#include <direct.h>
#endif
+// La gestion des repertoires
+#ifndef CHDIR
+ #ifdef WIN32
+ #define CHDIR _chdir
+ #else
+ #define CHDIR chdir
+ #endif
+#endif
+
namespace SMESHHOMARDImpl
{
- std::string SEPARATOR = "|" ;
-
- /*!
- \brief Read next chunk of data from the string
- \internal
-
- The function tries to read next chunk of the data from the input string \a str.
- The parameter \a start specifies the start position of next chunk. If the operation
- read the chunk successfully, after its completion this parameter will refer to the
- start position of the next chunk. The function returns resulting chunk as a string.
- The status of the operation is returned via \a ok parameter.
-
- \param str source data stream string
- \param start start position to get next chunk
- \param ok in this variable the status of the chunk reading operation is returned
- \return next chunk read from the string
- */
- static std::string getNextChunk( const std::string& str, std::string::size_type& start, bool& ok )
- {
- std::string chunk = "";
- ok = false;
- if ( start <= str.size() ) {
- std::string::size_type end = str.find( separator(), start );
- chunk = str.substr( start, end == std::string::npos ? std::string::npos : end-start );
- start = end == std::string::npos ? str.size()+1 : end + separator().size();
- ok = true;
- }
- return chunk;
- }
-
- /*!
- \brief Get persistence signature
- \param type persistence entity type
- \return persistence signature
- */
- std::string GetSignature( SignatureType type )
- {
- std::string signature = "";
- switch ( type ) {
- case Case: signature = "CASE"; break;
- case Zone: signature = "ZONE"; break;
- case Hypothesis: signature = "HYPO"; break;
- case Iteration: signature = "ITER"; break;
- case Boundary: signature = "BOUNDARY"; break;
- default: break;
- }
- signature += separator();
- return signature;
- }
-
- /*!
- \brief Get data separator
- \return string that is used to separate data entities in the stream
- */
- std::string separator()
- {
- return SEPARATOR ;
- }
-
-// =======================
-// 1.1. Case
-// =======================
- /*!
- \brief Dump case to the string
- \param cas case being dumped
- \return string representation of the case
- */
- std::string Dump( const HOMARD_Cas& cas )
- {
- std::stringstream os;
- std::string saux ;
- // ...
- MESSAGE( ". Sauvegarde du cas "<<cas.GetName());
- os << cas.GetName();
- os << separator() << cas.GetDirName();
- os << separator() << cas.GetConfType();
-
- std::vector<double> coor = cas.GetBoundingBox();
- os << separator() << coor.size();
- for ( unsigned int i = 0; i < coor.size(); i++ )
- os << separator() << coor[i];
-
- std::list<std::string> ListString = cas.GetIterations();
- os << separator() << ListString.size();
- std::list<std::string>::const_iterator it;
- for ( it = ListString.begin(); it != ListString.end(); ++it )
- os << separator() << *it;
-
- ListString = cas.GetGroups();
- os << separator() << ListString.size();
- for ( it = ListString.begin(); it != ListString.end(); ++it )
- os << separator() << *it;
- ListString = cas.GetBoundaryGroup();
- os << separator() << ListString.size();
- for ( it = ListString.begin(); it != ListString.end(); ++it )
- os << separator() << *it;
-
- os << separator() << 0; //cas.GetPyram()
-
- saux = os.str();
-// MESSAGE( ". Fin avec "<<saux);
- return saux ;
- }
-//
-// ==============
-// 1.2. Iteration
-// ==============
-//
- /*!
- \brief Dump iteration to the string
- \param iteration iteration being dumped
- \return string representation of the iteration
- */
- std::string Dump( const HOMARD_Iteration& iteration )
- {
- std::stringstream os;
- std::string saux ;
- // ...
- MESSAGE( ". Sauvegarde de l'iteration "<<iteration.GetName());
- os << iteration.GetName();
- os << separator() << iteration.GetState();
- os << separator() << iteration.GetNumber();
- os << separator() << iteration.GetMeshFile();
- os << separator() << iteration.GetLogFile();
- os << separator() << iteration.GetMeshName();
- os << separator() << iteration.GetFieldFile();
- os << separator() << iteration.GetTimeStep();
- os << separator() << iteration.GetRank();
- os << separator() << iteration.GetIterParentName();
- //
- std::list<std::string> ListString = iteration.GetIterations();
- os << separator() << ListString.size();
- std::list<std::string>::const_iterator it;
- for ( it = ListString.begin(); it != ListString.end(); ++it )
- os << separator() << *it;
-
- os << separator() << iteration.GetHypoName();
- os << separator() << iteration.GetCaseName();
- os << separator() << iteration.GetDirNameLoc();
-
- saux = os.str();
-// MESSAGE( ". Fin avec "<<saux);
- return saux ;
- }
-//
-// ==============
-// 1.3. hypothese
-// ==============
- /*!
- \brief Dump hypothesis to the string
- \param hypothesis hypothesis being dumped
- \return string representation of the hypothesis
- */
- std::string Dump( const HOMARD_Hypothesis& hypothesis )
- {
- std::stringstream os;
- std::string saux ;
- // ...
- MESSAGE( ". Sauvegarde de l'hypothese "<<hypothesis.GetName());
- os << hypothesis.GetName();
- os << separator() << hypothesis.GetCaseCreation();
- os << separator() << hypothesis.GetAdapType();
- os << separator() << hypothesis.GetRefinType();
- os << separator() << hypothesis.GetUnRefType();
- os << separator() << hypothesis.GetFieldName();
- os << separator() << hypothesis.GetRefinThrType();
- os << separator() << hypothesis.GetThreshR();
- os << separator() << hypothesis.GetUnRefThrType();
- os << separator() << hypothesis.GetThreshC();
- os << separator() << hypothesis.GetUseField();
- os << separator() << hypothesis.GetUseComp();
- os << separator() << hypothesis.GetTypeFieldInterp();
-
- std::list<std::string> ListString = hypothesis.GetIterations();
- std::list<std::string>::const_iterator it;
- os << separator() << ListString.size();
- for ( it = ListString.begin(); it != ListString.end(); ++it )
- os << separator() << *it;
-
- ListString = hypothesis.GetZones();
- os << separator() << ListString.size();
- for ( it = ListString.begin(); it != ListString.end(); ++it )
- os << separator() << *it;
-
- ListString = hypothesis.GetComps();
- os << separator() << ListString.size();
- for ( it = ListString.begin(); it != ListString.end(); ++it )
- os << separator() << *it;
-
- ListString = hypothesis.GetGroups();
- os << separator() << ListString.size();
- for ( it = ListString.begin(); it != ListString.end(); ++it )
- os << separator() << *it;
-
- ListString = hypothesis.GetFieldInterps();
- os << separator() << ListString.size();
- for ( it = ListString.begin(); it != ListString.end(); ++it )
- os << separator() << *it;
-
- os << separator() << hypothesis.GetNivMax();
- os << separator() << hypothesis.GetDiamMin();
- os << separator() << hypothesis.GetAdapInit();
- os << separator() << hypothesis.GetExtraOutput();
-
- saux = os.str();
-// MESSAGE( ". Fin avec "<<saux);
- return saux ;
- }
-//
-// ==============================
-// 1.5. Archivage d'une frontiere
-// ==============================
-
- /*!
- \brief Dump boundary to the string
- \param boundary boundary being dumped
- \return string representation of the boundary
- */
- std::string Dump( const HOMARD_Boundary& boundary )
- {
- std::stringstream os;
- std::string saux ;
- MESSAGE( ". Sauvegarde de la frontiere "<<boundary.GetName());
-
- int BoundaryType = boundary.GetType() ;
-
- os << boundary.GetName() ;
- os << separator() << BoundaryType ;
- os << separator() << boundary.GetCaseCreation() ;
-
- if ( BoundaryType == -1 )
- {
- os << separator() << boundary.GetDataFile();
- }
- else if ( BoundaryType == 0 )
- {
- os << separator() << boundary.GetMeshName();
- os << separator() << boundary.GetDataFile();
- }
- else {
- std::vector<double> coor = boundary.GetCoords() ;
- for ( unsigned int i = 0; i < coor.size(); i++ )
- os << separator() << coor[i];
- std::vector<double> limit = boundary.GetLimit();
- for ( unsigned int i = 0; i < limit.size(); i++ )
- os << separator() << limit[i];
- }
-
- std::list<std::string> ListString = boundary.GetGroups();
- std::list<std::string>::const_iterator it;
- os << separator() << ListString.size();
- for ( it = ListString.begin(); it != ListString.end(); ++it )
- os << separator() << *it;
-
- saux = os.str();
-// MESSAGE( ". Fin avec "<<saux);
- return saux ;
- }
-
-//
-// 2. Restauration des objets
-// ==========================
-// 2.1. Case
-// ==========================
-//
- /*!
- \brief Restore case from the string
- \param cas case being restored
- \param stream string representation of the case
- \return \c true if case is correctly restored or \c false otherwise
- */
- bool Restore( HOMARD_Cas& cas, const std::string& stream )
- {
- MESSAGE( ". Restoration du cas ");
- std::string::size_type start = 0;
- std::string chunk, chunkNext;
- bool ok;
- // ...
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- cas.SetName( chunk.c_str() );
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- cas.SetDirName( chunk.c_str() );
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- cas.SetConfType( atoi( chunk.c_str() ) );
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
-
- int size = atoi( chunk.c_str() );
- std::vector<double> boite;
- boite.resize( size );
- for ( int i = 0; i < size; i++ ) {
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- boite[i] = strtod( chunk.c_str(), 0 );
- }
- cas.SetBoundingBox( boite );
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
-
- size = atoi( chunk.c_str() );
- for ( int i = 0; i < size; i++ ) {
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- cas.AddIteration( chunk.c_str() );
- }
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- size = atoi( chunk.c_str() );
- for ( int i = 0; i < size; i++ )
- {
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- cas.AddGroup( chunk.c_str() );
- }
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- size = atoi( chunk.c_str() );
- for ( int i = 0; i < size; i++ ) {
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- i++;
- chunkNext = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- cas.AddBoundaryGroup( chunk.c_str(), chunkNext.c_str() );
- }
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- //cas.SetPyram( atoi( chunk.c_str() ) );
-
- return true;
- }
-//
-// ==============
-// 2.2. Iteration
-// ==============
- /*!
- \brief Restore iteration from the string
- \param iteration iteration being restored
- \param stream string representation of the iteration
- \return \c true if iteration is correctly restored or \c false otherwise
- */
- bool Restore( HOMARD_Iteration& iteration, const std::string& stream )
- {
- std::string::size_type start = 0;
- std::string chunk;
- bool ok;
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
-
- iteration.SetName( chunk.c_str() );
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- iteration.SetState( atoi( chunk.c_str() ) );
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- iteration.SetNumber( atoi( chunk.c_str() ) );
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- iteration.SetMeshFile( chunk.c_str() );
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- iteration.SetLogFile( chunk.c_str() );
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- iteration.SetMeshName( chunk.c_str() );
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- iteration.SetFieldFile( chunk.c_str() );
- // .
- int timestep, rank;
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- timestep = atoi( chunk.c_str() );
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- rank = atoi( chunk.c_str() );
- iteration.SetTimeStepRank( timestep, rank );
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- iteration.SetIterParentName( chunk.c_str() );
- //
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- int size = atoi( chunk.c_str() );
- for ( int i = 0; i < size; i++ ) {
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- iteration.LinkNextIteration( chunk.c_str() );
- }
- //
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- iteration.SetHypoName( chunk.c_str() );
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- iteration.SetCaseName( chunk.c_str() );
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- iteration.SetDirNameLoc( chunk.c_str() );
- return true;
- }
-
-//
-// ==============
-// 2.3. hypothese
-// ==============
- /*!
- \brief Restore hypothesis from the string
- \param hypothesis hypothesis being restored
- \param stream string representation of the hypothesis
- \return \c true if hypothesis is correctly restored or \c false otherwise
- */
- bool Restore( HOMARD_Hypothesis& hypothesis, const std::string& stream )
- {
- std::string::size_type start = 0;
- std::string chunk, chunkNext;
- bool ok;
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- hypothesis.SetName( chunk.c_str() );
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- hypothesis.SetCaseCreation( chunk.c_str() );
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- hypothesis.SetAdapType( atoi( chunk.c_str() ) );
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- int typeraff = atoi( chunk.c_str() );
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- int typedera = atoi( chunk.c_str() );
- hypothesis.SetRefinTypeDera( typeraff, typedera );
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- hypothesis.SetField( chunk.c_str() );
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- int typethr = atoi( chunk.c_str() );
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- double threshr = strtod( chunk.c_str(), 0 );
- hypothesis.SetRefinThr( typethr, threshr );
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- int typethc = atoi( chunk.c_str() );
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- double threshc = strtod( chunk.c_str(), 0 );
- hypothesis.SetUnRefThr( typethc, threshc );
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- hypothesis.SetUseField(atoi(chunk.c_str()));
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- hypothesis.SetUseComp(atoi(chunk.c_str()));
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- hypothesis.SetTypeFieldInterp(atoi(chunk.c_str()));
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- int size = atoi( chunk.c_str() );
- for ( int i = 0; i < size; i++ ) {
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- hypothesis.LinkIteration( chunk.c_str() );
- }
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- size = atoi( chunk.c_str() );
- for ( int i = 0; i < size; i++ ) {
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- i++;
- chunkNext = getNextChunk( stream, start, ok );
- int typeuse = atoi( chunkNext.c_str() );
- if ( !ok ) return false;
- hypothesis.AddZone( chunk.c_str(), typeuse );
- }
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- size = atoi( chunk.c_str() );
- for ( int i = 0; i < size; i++ ) {
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- hypothesis.AddComp( chunk.c_str() );
- }
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- size = atoi( chunk.c_str() );
- for ( int i = 0; i < size; i++ ) {
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- hypothesis.AddGroup( chunk.c_str() );
- }
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- size = atoi( chunk.c_str() );
- for ( int i = 0; i < size; i++ ) {
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- i++;
- chunkNext = getNextChunk( stream, start, ok );
- int TypeInterp = atoi( chunkNext.c_str() );
- if ( !ok ) return false;
- hypothesis.AddFieldInterpType( chunk.c_str(), TypeInterp );
- }
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- hypothesis.SetNivMax( atoi( chunk.c_str() ) );
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- hypothesis.SetDiamMin( strtod( chunk.c_str(), 0 ) );
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- hypothesis.SetAdapInit( strtod( chunk.c_str(), 0 ) );
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- hypothesis.SetExtraOutput( strtod( chunk.c_str(), 0 ) );
-
- return true;
- }
-
-//
-// =================================
-// 2.5. Restauration d'une frontiere
-// =================================
-
- /*!
- \brief Restore boundary from the string
- \param boundary boundary being restored
- \param stream string representation of the boundary
- \return \c true if the boundary is correctly restored or \c false otherwise
- */
- bool Restore( HOMARD_Boundary& boundary, const std::string& stream )
- {
- std::string::size_type start = 0;
- std::string chunk;
- bool ok;
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- boundary.SetName( chunk.c_str() );
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- int BoundaryType = atoi( chunk.c_str() ) ;
- boundary.SetType( BoundaryType );
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- boundary.SetCaseCreation( chunk.c_str() );
-
- // Si analytique, les coordonnees des frontieres : le nombre depend du type
- // Si discret, le maillage
- // Si CAO, la géométrie
- int lgcoords ;
- if ( BoundaryType == -1 ) { lgcoords = -1 ; }
- else if ( BoundaryType == 1 ) { lgcoords = 7 ; }
- else if ( BoundaryType == 2 ) { lgcoords = 4 ; }
- else { lgcoords = 0 ; }
-//
- if ( lgcoords == -1 )
- {
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- boundary.SetDataFile( chunk.c_str() );
- }
- else if ( lgcoords == 0 )
- {
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- boundary.SetMeshName( chunk.c_str() );
-
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- boundary.SetDataFile( chunk.c_str() );
- }
- else
- { std::vector<double> coords;
- coords.resize( lgcoords );
- for ( int i = 0; i < lgcoords; i++ ) {
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- coords[i] = strtod( chunk.c_str(), 0 );
- }
- if ( BoundaryType == 1 )
- { boundary.SetCylinder(coords[0],coords[1],coords[2],coords[3],coords[4],coords[5],coords[6]); }
- else if ( BoundaryType == 2 )
- { boundary.SetSphere( coords[0], coords[1], coords[2], coords[3]); }
- else if ( BoundaryType == 3 )
- { boundary.SetConeA( coords[0], coords[1], coords[2], coords[3], coords[4], coords[5], coords[6]); }
- else if ( BoundaryType == 4 )
- { boundary.SetConeR( coords[0], coords[1], coords[2], coords[3], coords[4], coords[5], coords[6], coords[7]); }
- // Remarque : la taille de coords est suffisante pour les limites
- for ( int i = 0; i < 3; i++ ) {
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- coords[i] = strtod( chunk.c_str(), 0 );
- }
- boundary.SetLimit( coords[0], coords[1], coords[2]);
- }
- // Les groupes
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- int size = atoi( chunk.c_str() );
- for ( int i = 0; i < size; i++ ) {
- chunk = getNextChunk( stream, start, ok );
- if ( !ok ) return false;
- boundary.AddGroup( chunk.c_str() );
- }
-
- return true;
- }
-
//=============================================================================
/*!
* default constructor:
std::vector<double> HOMARD_Boundary::GetCoords() const
{
std::vector<double> mesCoor;
-//
switch (_Type)
{
-// Cylindre
+ // Cylindre
case 1:
{
mesCoor.push_back( _Xcentre );
mesCoor.push_back( _rayon );
break ;
}
-// Sphere
+ // Sphere
case 2:
{
mesCoor.push_back( _Xcentre );
mesCoor.push_back( _rayon );
break ;
}
-// Cone defini par un axe et un angle
+ // Cone defini par un axe et un angle
case 3:
{
mesCoor.push_back( _Xaxe );
mesCoor.push_back( _Zcentre );
break ;
}
-// Cone defini par les 2 rayons
+ // Cone defini par les 2 rayons
case 4:
{
mesCoor.push_back( _Xcentre1 );
mesCoor.push_back( _Rayon2 );
break ;
}
-// Tore
+ // Tore
case 5:
{
mesCoor.push_back( _Xcentre );
mesCoor.push_back( _Rayon2 );
break ;
}
- VERIFICATION( (_Type>=1) && (_Type<=5) ) ;
+ default:
+ break ;
}
return mesCoor;
}
//=============================================================================
int HOMARD_Cas::SetDirName( const char* NomDir )
{
-// MESSAGE("SetDirName, NomDir : "<<NomDir);
-// MESSAGE("SetDirName, _NomDir : "<<_NomDir);
int erreur = 0 ;
// On vérifie qu'aucun calcul n'a eu lieu pour ce cas
-// MESSAGE("SetDirName, _ListIter.size() : "<<_ListIter.size());
if ( _ListIter.size() > 1 ) { erreur = 1 ; }
// Creation
- if ( CHDIR(NomDir) == 0 )
- { _NomDir = std::string( NomDir ); }
- else
- {
-
+ if ( CHDIR(NomDir) == 0 ) {
+ _NomDir = std::string( NomDir );
+ }
+ else {
#ifndef WIN32
if ( mkdir(NomDir, S_IRWXU|S_IRGRP|S_IXGRP) == 0 )
#else
else { erreur = 2 ; }
}
else { erreur = 2 ; }
- };
- return erreur ;
+ }
+ return erreur;
}
//=============================================================================
std::string HOMARD_Cas::GetDirName() const
{
return _NomDir;
}
-//=============================================================================
-int HOMARD_Cas::GetNumberofIter()
-{
- return _ListIter.size();
-}
//
// Le type de conformite ou non conformite
//
//=============================================================================
void HOMARD_Cas::SetConfType( int Conftype )
{
-// VERIFICATION( (Conftype>=-2) && (Conftype<=3) );
_ConfType = Conftype;
}
//=============================================================================
// Liens avec les autres structures
//=============================================================================
//=============================================================================
-std::string HOMARD_Cas::GetIter0Name() const
-{
-// Par construction de la liste, l'iteration a ete mise en tete.
- return (*(_ListIter.begin()));
-}
-//=============================================================================
void HOMARD_Cas::AddIteration( const char* NomIteration )
{
_ListIter.push_back( std::string( NomIteration ) );
}
-//=============================================================================
-const std::list<std::string>& HOMARD_Cas::GetIterations() const
-{
- return _ListIter;
-}
-//=============================================================================
-void HOMARD_Cas::SupprIterations()
-{
- _ListIter.clear();
-}
//=============================================================================
//=============================================================================
//===============================================================================
// C. Le pilotage de l'adaptation
//===============================================================================
-void HomardDriver::TexteConfRaffDera( int ConfType, int TypeAdap, int TypeRaff, int TypeDera )
+void HomardDriver::TexteConfRaffDera( int ConfType )
{
- MESSAGE("TexteConfRaffDera, ConfType ="<<ConfType);
- MESSAGE("TexteConfRaffDera, TypeAdap ="<<TypeAdap<<", TypeRaff ="<<TypeRaff<<", TypeDera ="<<TypeDera);
-//
-// Type de conformite
-//
- std::string saux ;
+ MESSAGE("TexteConfRaffDera, ConfType = " << ConfType);
+ //
+ // Type de conformite
+ //
+ std::string saux;
switch (ConfType)
{
case -2: //
}
}
_Texte += "# Type de conformite\nTypeConf " + saux + "\n" ;
+ //
+ // Type de raffinement/deraffinement
+ //
+ saux = "TypeRaff uniforme\n" ;
+ saux += "TypeDera non" ;
+ _Texte += "# Type de raffinement/deraffinement\n" + saux + "\n" ;
+}
+//===============================================================================
+// D. Les frontieres
+//===============================================================================
+void HomardDriver::TexteBoundaryOption( int BoundaryOption )
+{
+ MESSAGE("TexteBoundaryOption, BoundaryOption = "<<BoundaryOption);
//
-// Type de raffinement/deraffinement
+// Type de suivi de frontiere
//
- if ( TypeAdap == -1 )
- {
- if ( TypeRaff == 1 )
- {
- saux = "TypeRaff uniforme\n" ;
- }
- else
- {
- saux = "TypeRaff non\n" ;
- }
- if ( TypeDera == 1 )
- {
- saux += "TypeDera uniforme" ;
- }
- else
- {
- saux += "TypeDera non" ;
- }
- }
- else
- {
- if ( TypeRaff == 1 )
- {
- saux = "TypeRaff libre\n" ;
- }
- else
- {
- saux = "TypeRaff non\n" ;
- }
- if ( TypeDera == 1 )
- {
- saux += "TypeDera libre" ;
- }
- else
- {
- saux += "TypeDera non" ;
- }
- }
- _Texte += "# Type de raffinement/deraffinement\n" + saux + "\n" ;
+ std::stringstream saux1 ;
+ saux1 << BoundaryOption ;
+ std::string saux = saux1.str() ;
+ _Texte += "SuivFron " + saux + "\n" ;
+//
+}//===============================================================================
+void HomardDriver::TexteBoundaryCAOGr( const std::string GroupName )
+{
+ MESSAGE("TexteBoundaryCAOGr, GroupName = "<<GroupName);
+//
+ _Texte += "GrFroCAO \"" + GroupName + "\"\n" ;
//
-// MESSAGE("A la fin de HomardDriver::TexteConfRaffDera, _Texte ="<<_Texte);
}
+
//===============================================================================
-void HomardDriver::TexteCompo( int NumeComp, const std::string NomCompo)
+void HomardDriver::TexteBoundaryDi( const std::string MeshName, const std::string MeshFile )
{
- MESSAGE("TexteCompo, NumeComp = "<<NumeComp<<", NomCompo = "<<NomCompo);
- _Texte +="CCCoChaI \"" + NomCompo + "\"\n" ;
+ MESSAGE("TexteBoundaryDi, MeshName = "<<MeshName);
+ MESSAGE("TexteBoundaryDi, MeshFile = "<<MeshFile);
+//
+ _Texte += "#\n# Frontiere discrete\n" ;
+ _Texte += "CCNoMFro \"" + MeshName + "\"\n" ;
+ _Texte += "CCFronti \"" + MeshFile + "\"\n" ;
+//
}
//===============================================================================
-void HomardDriver::TexteZone( int NumeZone, int ZoneType, int TypeUse, double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7, double x8 )
+void HomardDriver::TexteBoundaryDiGr( const std::string GroupName )
{
- MESSAGE("TexteZone, NumeZone = "<<NumeZone<<", ZoneType = "<<ZoneType<<", TypeUse = "<<TypeUse);
- MESSAGE("TexteZone, coor = "<< x0<<","<<x1<< ","<< x2<< ","<< x3<<","<<x4<<","<<x5<<","<<x6<<","<<x7<<","<<x8);
+ MESSAGE("TexteBoundaryDiGr, GroupName = "<<GroupName);
//
- std::string saux, saux2 ;
+ _Texte += "CCGroFro \"" + GroupName + "\"\n" ;
//
-// Type de zones
-// On convertit le type de zone au sens du module HOMARD dans Salome, ZoneType, dans le
-// type au sens de l'executable HOMARD, ZoneTypeHOMARD
-// Attention a mettre le bon signe a ZoneTypeHOMARD :
-// >0 signifie que l'on raffinera les mailles contenues dans la zone,
-// <0 signifie que l'on deraffinera
+}
+//===============================================================================
+void HomardDriver::TexteBoundaryAn( const std::string NameBoundary, int NumeBoundary, int BoundaryType, double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7 )
+{
+ MESSAGE("TexteBoundaryAn, NameBoundary = "<<NameBoundary);
+// MESSAGE("TexteBoundaryAn, NumeBoundary = "<<NumeBoundary);
+ MESSAGE("TexteBoundaryAn, BoundaryType = "<<BoundaryType);
+// MESSAGE("TexteBoundaryAn, coor = "<< x0<<","<<x1<< ","<< x2<< ","<< x3<<","<<x4<<","<<x5<<","<<x6","<<x7);
//
- int ZoneTypeHOMARD ;
- if ( ZoneType >= 11 && ZoneType <= 13 ) { ZoneTypeHOMARD = 1 ; }
- else if ( ZoneType >= 31 && ZoneType <= 33 ) { ZoneTypeHOMARD = 3 ; }
- else if ( ZoneType >= 61 && ZoneType <= 63 ) { ZoneTypeHOMARD = 6 ; }
- else { ZoneTypeHOMARD = ZoneType ; }
+ std::string saux, saux2 ;
//
- if ( TypeUse < 0 ) { ZoneTypeHOMARD = -ZoneTypeHOMARD ; }
+// Commentaires
//
std::stringstream saux1 ;
- saux1 << NumeZone ;
- saux = "#\n# Zone numero " + saux1.str() + "\n" ;
+ saux1 << NumeBoundary ;
+ saux2 = saux1.str() ;
+ saux = "#\n# Frontiere numero " + saux2 + "\n" ;
+ if ( BoundaryType == 1 )
+ { saux += "# Cylindre\n" ; }
+ if ( BoundaryType == 2 )
+ { saux += "# Sphere\n" ; }
+ if ( BoundaryType == 3 || BoundaryType == 4 )
+ { saux += "# Cone\n" ; }
+ if ( BoundaryType == 5 )
+ { saux += "# Tore\n" ; }
+//
+// Le nom de la frontiere
+//
+ { std::stringstream saux1 ;
+ saux1 << NumeBoundary ;
+ saux += "FANom " + saux1.str() + " \"" + NameBoundary + "\"\n" ;
+ }
+//
+// Type de frontiere
//
{ std::stringstream saux1 ;
- saux1 << NumeZone << " " << ZoneTypeHOMARD ;
- saux += "ZoRaType " + saux1.str() + "\n" ;
+ saux1 << NumeBoundary << " " << BoundaryType ;
+ saux += "FAType " + saux1.str() + "\n" ;
}
//
-// Cas du rectangle
+// Cas du cylindre
//
- if ( ZoneType == 11 ) // Z est constant X Homard <=> X Salome
-// Y Homard <=> Y Salome
+ if ( BoundaryType == 1 )
{
- saux += "#Rectangle\n" ;
{ std::stringstream saux1 ;
- saux1 << NumeZone << " " << x0 ;
- saux += "ZoRaXmin " + saux1.str() + "\n" ;
+ saux1 << NumeBoundary << " " << x0 ;
+ saux2 = saux1.str() ;
+ saux += "FAXCen " + saux1.str() + "\n" ;
}
{ std::stringstream saux1 ;
- saux1 << NumeZone << " " << x1 ;
- saux += "ZoRaXmax " + saux1.str() + "\n" ;
+ saux1 << NumeBoundary << " " << x1 ;
+ saux += "FAYCen " + saux1.str() + "\n" ;
}
{ std::stringstream saux1 ;
- saux1 << NumeZone << " " << x2 ;
- saux += "ZoRaYmin " + saux1.str() + "\n" ;
+ saux1 << NumeBoundary << " " << x2 ;
+ saux += "FAZCen " + saux1.str() + "\n" ;
}
{ std::stringstream saux1 ;
- saux1 << NumeZone << " " << x3 ;
- saux += "ZoRaYmax " + saux1.str() + "\n" ;
- }
- }
-//
- else if ( ZoneType == 12 ) // X est constant X Homard <=> Y Salome
-// Y Homard <=> Z Salome
- {
- saux += "#Rectangle\n" ;
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x2 ;
- saux += "ZoRaXmin " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x3 ;
- saux += "ZoRaXmax " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x4 ;
- saux += "ZoRaYmin " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x5 ;
- saux += "ZoRaYmax " + saux1.str() + "\n" ;
- }
- }
-//
- else if ( ZoneType == 13 ) // Y est constant X Homard <=> X Salome
-// Y Homard <=> Z Salome
- {
- saux += "#Rectangle\n" ;
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x0 ;
- saux += "ZoRaXmin " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x1 ;
- saux += "ZoRaXmax " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x4 ;
- saux += "ZoRaYmin " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x5 ;
- saux += "ZoRaYmax " + saux1.str() + "\n" ;
- }
- }
-//
-// Cas du parallelepipede
-//
- else if ( ZoneType == 2 )
- {
- saux += "# Boite\n" ;
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x0 ;
- saux += "ZoRaXmin " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x1 ;
- saux += "ZoRaXmax " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x2 ;
- saux += "ZoRaYmin " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x3 ;
- saux += "ZoRaYmax " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x4 ;
- saux += "ZoRaZmin " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x5 ;
- saux += "ZoRaZmax " + saux1.str() + "\n" ;
- }
- }
-//
-// Cas du disque
-//
- else if ( ZoneType == 31 || ZoneType == 61 )
- {
- saux += "# Sphere\n" ;
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x0 ;
- saux += "ZoRaXCen " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x1 ;
- saux += "ZoRaYCen " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x6 ;
- saux2 = saux1.str() ;
- if ( ZoneType == 61 ) { saux += "ZoRaRayE " + saux2 + "\n" ; }
- else { saux += "ZoRaRayo " + saux2 + "\n" ; }
- }
- if ( ZoneType == 61 )
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x8 ;
- saux += "ZoRaRayI " + saux1.str() + "\n" ;
- }
- }
- else if ( ZoneType == 32 || ZoneType == 62 )
- {
- saux += "# Sphere\n" ;
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x1 ;
- saux += "ZoRaXCen " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x2 ;
- saux += "ZoRaYCen " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x6 ;
- saux2 = saux1.str() ;
- if ( ZoneType == 62 ) { saux += "ZoRaRayE " + saux2 + "\n" ; }
- else { saux += "ZoRaRayo " + saux2 + "\n" ; }
- }
- if ( ZoneType == 62 )
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x8 ;
- saux += "ZoRaRayI " + saux1.str() + "\n" ;
- }
- }
- else if ( ZoneType == 33 || ZoneType == 63 )
- {
- saux += "# Sphere\n" ;
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x0 ;
- saux += "ZoRaXCen " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x2 ;
- saux += "ZoRaYCen " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x6 ;
- saux2 = saux1.str() ;
- if ( ZoneType == 63 ) { saux += "ZoRaRayE " + saux2 + "\n" ; }
- else { saux += "ZoRaRayo " + saux2 + "\n" ; }
- }
- if ( ZoneType == 63 )
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x8 ;
- saux += "ZoRaRayI " + saux1.str() + "\n" ;
- }
- }
-//
-// Cas de la sphere
-//
- else if ( ZoneType == 4 )
- {
- saux += "# Sphere\n" ;
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x0 ;
- saux += "ZoRaXCen " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x1 ;
- saux += "ZoRaYCen " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x2 ;
- saux += "ZoRaZCen " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x3 ;
- saux += "ZoRaRayo " + saux1.str() + "\n" ;
- }
- }
-//
-// Cas du cylindre ou du tuyau
-//
- else if ( ZoneType == 5 || ZoneType == 7 )
- {
- if ( ZoneType == 5 ) { saux += "# Cylindre\n" ; }
- else { saux += "# Tuyau\n" ; }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x0 ;
- saux += "ZoRaXBas " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x1 ;
- saux += "ZoRaYBas " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x2 ;
- saux += "ZoRaZBas " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x3 ;
- saux += "ZoRaXAxe " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x4 ;
- saux += "ZoRaYAxe " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x5 ;
- saux += "ZoRaZAxe " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x6 ;
- saux2 = saux1.str() ;
- if ( ZoneType == 5 ) { saux += "ZoRaRayo " + saux2 + "\n" ; }
- else { saux += "ZoRaRayE " + saux2 + "\n" ; }
- }
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x7 ;
- saux += "ZoRaHaut " + saux1.str() + "\n" ;
- }
- if ( ZoneType == 7 )
- { std::stringstream saux1 ;
- saux1 << NumeZone << " " << x8 ;
- saux += "ZoRaRayI " + saux1.str() + "\n" ;
- }
- }
-//
- _Texte += saux + "#\n" ;
-//
-// MESSAGE("A la fin de HomardDriver::TexteZone, _Texte ="<<_Texte);
-}
-//===============================================================================
-void HomardDriver::TexteField( const std::string FieldName, const std::string FieldFile, int TimeStep, int Rank,
- int TypeThR, double ThreshR, int TypeThC, double ThreshC,
- int UsField, int UsCmpI )
-{
- MESSAGE("TexteField, FieldName = "<<FieldName<<", FieldFile = "<<FieldFile);
- MESSAGE("TexteField, TimeStep = "<<TimeStep<<", Rank = "<<Rank);
-
- std::string saux, saux2 ;
-//
-//
- _Texte += "# Champ d'indicateurs\n" ;
- _Texte += "CCIndica \"" + FieldFile + "\"\n" ;
- _Texte += "CCNoChaI \"" + FieldName + "\"\n" ;
-
-// Cas ou on prend le dernier pas de temps
- if ( TimeStep == -2 )
- { _Texte += "CCNumPTI Last\n" ; }
-// Cas avec pas de temps
- else if ( TimeStep >= 0 )
- {
- {
- std::stringstream saux1 ;
- saux1 << TimeStep ;
- saux2 = saux1.str() ;
- _Texte += "CCNumPTI " + saux2 + "\n" ;
- }
- if ( Rank >= 0 )
- {
- std::stringstream saux1 ;
- saux1 << Rank ;
- saux2 = saux1.str() ;
- _Texte += "CCNumOrI " + saux2 + "\n" ;
- }
- }
-//
- saux = " " ;
- if ( TypeThR == 1 )
- { saux = "Hau" ; }
- if ( TypeThR == 2 )
- { saux = "HRe" ; }
- if ( TypeThR == 3 )
- { saux = "HPE" ; }
- if ( TypeThR == 4 )
- { saux = "HMS" ; }
- if ( saux != " " )
- {
- std::stringstream saux1 ;
- saux1 << ThreshR ;
- _Texte += "Seuil" + saux + " " + saux1.str() + "\n" ;
- }
-//
- saux = " " ;
- if ( TypeThC == 1 )
- { saux = "Bas" ; }
- if ( TypeThC == 2 )
- { saux = "BRe" ; }
- if ( TypeThC == 3 )
- { saux = "BPE" ; }
- if ( TypeThC == 4 )
- { saux = "BMS" ; }
- if ( saux != " " )
- {
- std::stringstream saux1 ;
- saux1 << ThreshC ;
- _Texte += "Seuil" + saux + " " + saux1.str() + "\n" ;
- }
-//
- saux = " " ;
- if ( UsField == 0 )
- { saux = "MAILLE" ; }
- if ( UsField == 1 )
- { saux = "SAUT" ; }
- if ( saux != " " )
- {
- _Texte += "CCModeFI " + saux + "\n" ;
- }
-//
- saux = " " ;
- if ( UsCmpI == 0 )
- { saux = "L2" ; }
- if ( UsCmpI == 1 )
- { saux = "INFINI" ; }
- if ( UsCmpI == 2 )
- { saux = "RELATIF" ; }
- if ( saux != " " )
- {
- _Texte += "CCUsCmpI " + saux + "\n" ;
- }
-}
-//===============================================================================
-void HomardDriver::TexteGroup( const std::string GroupName )
-{
- MESSAGE("TexteGroup, GroupName = "<<GroupName);
-//
- _Texte += "CCGroAda \"" + GroupName + "\"\n" ;
-//
-}
-//===============================================================================
-// D. Les frontieres
-//===============================================================================
-void HomardDriver::TexteBoundaryOption( int BoundaryOption )
-{
- MESSAGE("TexteBoundaryOption, BoundaryOption = "<<BoundaryOption);
-//
-// Type de suivi de frontiere
-//
- std::stringstream saux1 ;
- saux1 << BoundaryOption ;
- std::string saux = saux1.str() ;
- _Texte += "SuivFron " + saux + "\n" ;
-//
-}//===============================================================================
-void HomardDriver::TexteBoundaryCAOGr( const std::string GroupName )
-{
- MESSAGE("TexteBoundaryCAOGr, GroupName = "<<GroupName);
-//
- _Texte += "GrFroCAO \"" + GroupName + "\"\n" ;
-//
-}
-
-//===============================================================================
-void HomardDriver::TexteBoundaryDi( const std::string MeshName, const std::string MeshFile )
-{
- MESSAGE("TexteBoundaryDi, MeshName = "<<MeshName);
- MESSAGE("TexteBoundaryDi, MeshFile = "<<MeshFile);
-//
- _Texte += "#\n# Frontiere discrete\n" ;
- _Texte += "CCNoMFro \"" + MeshName + "\"\n" ;
- _Texte += "CCFronti \"" + MeshFile + "\"\n" ;
-//
-}
-//===============================================================================
-void HomardDriver::TexteBoundaryDiGr( const std::string GroupName )
-{
- MESSAGE("TexteBoundaryDiGr, GroupName = "<<GroupName);
-//
- _Texte += "CCGroFro \"" + GroupName + "\"\n" ;
-//
-}
-//===============================================================================
-void HomardDriver::TexteBoundaryAn( const std::string NameBoundary, int NumeBoundary, int BoundaryType, double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7 )
-{
- MESSAGE("TexteBoundaryAn, NameBoundary = "<<NameBoundary);
-// MESSAGE("TexteBoundaryAn, NumeBoundary = "<<NumeBoundary);
- MESSAGE("TexteBoundaryAn, BoundaryType = "<<BoundaryType);
-// MESSAGE("TexteBoundaryAn, coor = "<< x0<<","<<x1<< ","<< x2<< ","<< x3<<","<<x4<<","<<x5<<","<<x6","<<x7);
-//
- std::string saux, saux2 ;
-//
-// Commentaires
-//
- std::stringstream saux1 ;
- saux1 << NumeBoundary ;
- saux2 = saux1.str() ;
- saux = "#\n# Frontiere numero " + saux2 + "\n" ;
- if ( BoundaryType == 1 )
- { saux += "# Cylindre\n" ; }
- if ( BoundaryType == 2 )
- { saux += "# Sphere\n" ; }
- if ( BoundaryType == 3 || BoundaryType == 4 )
- { saux += "# Cone\n" ; }
- if ( BoundaryType == 5 )
- { saux += "# Tore\n" ; }
-//
-// Le nom de la frontiere
-//
- { std::stringstream saux1 ;
- saux1 << NumeBoundary ;
- saux += "FANom " + saux1.str() + " \"" + NameBoundary + "\"\n" ;
- }
-//
-// Type de frontiere
-//
- { std::stringstream saux1 ;
- saux1 << NumeBoundary << " " << BoundaryType ;
- saux += "FAType " + saux1.str() + "\n" ;
- }
-//
-// Cas du cylindre
-//
- if ( BoundaryType == 1 )
- {
- { std::stringstream saux1 ;
- saux1 << NumeBoundary << " " << x0 ;
- saux2 = saux1.str() ;
- saux += "FAXCen " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeBoundary << " " << x1 ;
- saux += "FAYCen " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeBoundary << " " << x2 ;
- saux += "FAZCen " + saux1.str() + "\n" ;
- }
- { std::stringstream saux1 ;
- saux1 << NumeBoundary << " " << x3 ;
- saux += "FAXAxe " + saux1.str() + "\n" ;
+ saux1 << NumeBoundary << " " << x3 ;
+ saux += "FAXAxe " + saux1.str() + "\n" ;
}
{ std::stringstream saux1 ;
saux1 << NumeBoundary << " " << x4 ;
//
}
//===============================================================================
-// E. Les interpolations
+// F. Les options avancees
//===============================================================================
-// Les fichiers d'entree et de sortie des champs a interpoler
-void HomardDriver::TexteFieldInterp( const std::string FieldFile, const std::string MeshFile )
+void HomardDriver::TexteAdvanced( int NivMax, double DiamMin, int AdapInit, int ExtraOutput )
{
- MESSAGE("TexteFieldInterp, FieldFile = "<<FieldFile<<", MeshFile = "<<MeshFile);
-//
- _Texte += "#\n# Interpolations des champs\n" ;
-//
-// Fichier en entree
- _Texte += "CCSolN__ \"" + FieldFile + "\"\n" ;
-// Fichier en sortie
- _Texte += "CCSolNP1 \"" + MeshFile + "\"\n" ;
-//
-// std::cerr << "A la fin de TexteFieldInterp _Texte ="<<_Texte << std::endl;
-}
-//===============================================================================
-// Tous les champs sont a interpoler
-void HomardDriver::TexteFieldInterpAll( )
-{
- MESSAGE("TexteFieldInterpAll");
-//
- _Texte += "CCChaTou oui\n" ;
-}
-//===============================================================================
-// Ecrit les caracteristiques de chaque interpolation sous la forme :
-// CCChaNom 1 "DEPL" ! Nom du 1er champ a interpoler
-// CCChaTIn 1 0 ! Mode d'interpolation : automatique
-// CCChaNom 2 "VOLUME" ! Nom du 2nd champ a interpoler
-// CCChaTIn 2 1 ! Mode d'interpolation : une variable extensive
-// CCChaPdT 2 14 ! Pas de temps 14
-// CCChaNuO 2 14 ! Numero d'ordre 14
-// etc.
-//
-// NumeChamp : numero d'ordre du champ a interpoler
-// FieldName : nom du champ
-// TypeInterp : type d'interpolation
-// TimeStep : pas de temps retenu (>0 si pas de precision)
-// Rank : numero d'ordre retenu
-//
-void HomardDriver::TexteFieldInterpNameType( int NumeChamp, const std::string FieldName, const std::string TypeInterp, int TimeStep, int Rank)
-{
- MESSAGE("TexteFieldInterpNameType, NumeChamp = "<<NumeChamp<<", FieldName = "<<FieldName<<", TypeInterp = "<<TypeInterp);
- MESSAGE("TexteFieldInterpNameType, TimeStep = "<<TimeStep<<", Rank = "<<Rank);
-// Numero d'ordre du champ a interpoler
- std::stringstream saux1 ;
- saux1 << NumeChamp ;
- std::string saux = saux1.str() ;
-// Nom du champ
- _Texte +="CCChaNom " + saux + " \"" + FieldName + "\"\n" ;
-// Type d'interpolation pour le champ
- _Texte +="CCChaTIn " + saux + " " + TypeInterp + "\n" ;
-//
- if ( TimeStep >= 0 )
- {
- {
- std::stringstream saux1 ;
- saux1 << TimeStep ;
- _Texte += "CCChaPdT " + saux + " " + saux1.str() + "\n" ;
- }
- {
- std::stringstream saux1 ;
- saux1 << Rank ;
- _Texte += "CCChaNuO " + saux + " " + saux1.str() + "\n" ;
- }
- }
-}
-//===============================================================================
-// F. Les options avancees
-//===============================================================================
-void HomardDriver::TexteAdvanced( int NivMax, double DiamMin, int AdapInit, int ExtraOutput )
-{
- MESSAGE("TexteAdvanced, NivMax ="<<NivMax<<", DiamMin ="<<DiamMin<<", AdapInit ="<<AdapInit<<", ExtraOutput ="<<ExtraOutput);
+ MESSAGE("TexteAdvanced, NivMax ="<<NivMax<<", DiamMin ="<<DiamMin<<
+ ", AdapInit ="<<AdapInit<<", ExtraOutput ="<<ExtraOutput);
if ( NivMax > 0 )
{
}
//=============================================================================
-//=============================================================================
-/*!
- * default constructor:
- */
-//=============================================================================
-HOMARD_Hypothesis::HOMARD_Hypothesis():
- _Name(""), _NomCasCreation(""),
- _TypeAdap(-1), _TypeRaff(0), _TypeDera(0),
- _Field(""),
- _TypeThR(0), _TypeThC(0),
- _ThreshR(0), _ThreshC(0),
- _UsField(0), _UsCmpI(0), _TypeFieldInterp(0),
-
- _NivMax(-1), _DiamMin(-1.0), _AdapInit(0), _ExtraOutput(1)
-{
- MESSAGE("HOMARD_Hypothesis");
-}
-
-//=============================================================================
-/*!
- */
-//=============================================================================
-HOMARD_Hypothesis::~HOMARD_Hypothesis()
-{
- MESSAGE("~HOMARD_Hypothesis");
-}
-//=============================================================================
-//=============================================================================
-// Generalites
-//=============================================================================
-//=============================================================================
-void HOMARD_Hypothesis::SetName( const char* Name )
-{
- _Name = std::string( Name );
-}
-//=============================================================================
-std::string HOMARD_Hypothesis::GetName() const
-{
- return _Name;
-}
-//=============================================================================
-//=============================================================================
-// Caracteristiques
-//=============================================================================
-//=============================================================================
-void HOMARD_Hypothesis::SetAdapType( int TypeAdap )
-{
- VERIFICATION( (TypeAdap>=-1) && (TypeAdap<=1) );
- _TypeAdap = TypeAdap;
-}
-//=============================================================================
-int HOMARD_Hypothesis::GetAdapType() const
-{
- return _TypeAdap;
-}
-//=============================================================================
-void HOMARD_Hypothesis::SetRefinTypeDera( int TypeRaff, int TypeDera )
-{
- VERIFICATION( (TypeRaff>=-1) && (TypeRaff<=1) );
- _TypeRaff = TypeRaff;
- VERIFICATION( (TypeDera>=-1) && (TypeDera<=1) );
- _TypeDera = TypeDera;
-}
-//=============================================================================
-int HOMARD_Hypothesis::GetRefinType() const
-{
- return _TypeRaff;
-}
-//=============================================================================
-int HOMARD_Hypothesis::GetUnRefType() const
-{
- return _TypeDera;
-}
-//=============================================================================
-void HOMARD_Hypothesis::SetField( const char* FieldName )
-{
- _Field = std::string( FieldName );
- MESSAGE( "SetField : FieldName = " << FieldName );
-}
-//=============================================================================
-std::string HOMARD_Hypothesis::GetFieldName() const
-{
- return _Field;
-}
-//=============================================================================
-void HOMARD_Hypothesis::SetUseField( int UsField )
-{
- VERIFICATION( (UsField>=0) && (UsField<=1) );
- _UsField = UsField;
-}
-//=============================================================================
-int HOMARD_Hypothesis::GetUseField() const
-{
- return _UsField;
-}
-//=============================================================================
-void HOMARD_Hypothesis::SetUseComp( int UsCmpI )
-{
- MESSAGE ("SetUseComp pour UsCmpI = "<<UsCmpI) ;
- VERIFICATION( (UsCmpI>=0) && (UsCmpI<=2) );
- _UsCmpI = UsCmpI;
-}
-//=============================================================================
-int HOMARD_Hypothesis::GetUseComp() const
-{
- return _UsCmpI;
-}
-//=============================================================================
-void HOMARD_Hypothesis::AddComp( const char* NomComp )
-{
-// On commence par supprimer la composante au cas ou elle aurait deja ete inseree
-// Cela peut se produire dans un schema YACS quand on repasse plusieurs fois par la
-// definition de l'hypothese
- SupprComp( NomComp ) ;
-// Insertion veritable
- _ListComp.push_back( std::string( NomComp ) );
-}
-//=============================================================================
-void HOMARD_Hypothesis::SupprComp( const char* NomComp )
-{
- MESSAGE ("SupprComp pour "<<NomComp) ;
- std::list<std::string>::iterator it = find( _ListComp.begin(), _ListComp.end(), NomComp );
- if ( it != _ListComp.end() ) { it = _ListComp.erase( it ); }
-}
-//=============================================================================
-void HOMARD_Hypothesis::SupprComps()
-{
- _ListComp.clear();
-}
-//=============================================================================
-const std::list<std::string>& HOMARD_Hypothesis::GetComps() const
-{
- return _ListComp;
-}
-//=============================================================================
-void HOMARD_Hypothesis::SetRefinThr( int TypeThR, double ThreshR )
-{
- MESSAGE( "SetRefinThr : TypeThR = " << TypeThR << ", ThreshR = " << ThreshR );
- VERIFICATION( (TypeThR>=0) && (TypeThR<=4) );
- _TypeThR = TypeThR;
- _ThreshR = ThreshR;
-}
-//=============================================================================
-int HOMARD_Hypothesis::GetRefinThrType() const
-{
- return _TypeThR;
-}
-//=============================================================================
-double HOMARD_Hypothesis::GetThreshR() const
-{
- return _ThreshR;
-}
-//=============================================================================
-void HOMARD_Hypothesis::SetUnRefThr( int TypeThC, double ThreshC )
-{
- VERIFICATION( (TypeThC>=0) && (TypeThC<=4) );
- _TypeThC = TypeThC;
- _ThreshC = ThreshC;
-}
-//=============================================================================
-int HOMARD_Hypothesis::GetUnRefThrType() const
-{
- return _TypeThC;
-}
-//=============================================================================
-double HOMARD_Hypothesis::GetThreshC() const
-{
- return _ThreshC;
-}
-//=============================================================================
-void HOMARD_Hypothesis::SetNivMax( int NivMax )
-//=============================================================================
-{
- _NivMax = NivMax;
-}
-//=============================================================================
-const int HOMARD_Hypothesis::GetNivMax() const
-//=============================================================================
-{
- return _NivMax;
-}
-//=============================================================================
-void HOMARD_Hypothesis::SetDiamMin( double DiamMin )
-//=============================================================================
-{
- _DiamMin = DiamMin;
-}
-//=============================================================================
-const double HOMARD_Hypothesis::GetDiamMin() const
-//=============================================================================
-{
- return _DiamMin;
-}
-//=============================================================================
-void HOMARD_Hypothesis::SetAdapInit( int AdapInit )
-//=============================================================================
-{
- _AdapInit = AdapInit;
-}
-//=============================================================================
-const int HOMARD_Hypothesis::GetAdapInit() const
-//=============================================================================
-{
- return _AdapInit;
-}
-//=============================================================================
-void HOMARD_Hypothesis::SetExtraOutput( int ExtraOutput )
-//=============================================================================
-{
- _ExtraOutput = ExtraOutput;
-}
-//=============================================================================
-const int HOMARD_Hypothesis::GetExtraOutput() const
-//=============================================================================
-{
- return _ExtraOutput;
-}
-//=============================================================================
-void HOMARD_Hypothesis::AddGroup( const char* Group)
-{
-// On commence par supprimer le groupe au cas ou il aurait deja ete insere
-// Cela peut se produire dans un schema YACS quand on repasse plusieurs fois par la
-// definition de l'hypothese
- SupprGroup( Group ) ;
-// Insertion veritable
- _ListGroupSelected.push_back(Group);
-}
-//=============================================================================
-void HOMARD_Hypothesis::SupprGroup( const char* Group )
-{
- MESSAGE ("SupprGroup pour "<<Group) ;
- std::list<std::string>::iterator it = find( _ListGroupSelected.begin(), _ListGroupSelected.end(), Group );
- if ( it != _ListGroupSelected.end() ) { it = _ListGroupSelected.erase( it ); }
-}
-//=============================================================================
-void HOMARD_Hypothesis::SupprGroups()
-{
- _ListGroupSelected.clear();
-}
-//=============================================================================
-void HOMARD_Hypothesis::SetGroups( const std::list<std::string>& ListGroup )
-{
- _ListGroupSelected.clear();
- std::list<std::string>::const_iterator it = ListGroup.begin();
- while(it != ListGroup.end())
- _ListGroupSelected.push_back((*it++));
-}
-//=============================================================================
-const std::list<std::string>& HOMARD_Hypothesis::GetGroups() const
-{
- return _ListGroupSelected;
-}
-//=============================================================================
-// Type d'interpolation des champs :
-// 0 : aucun champ n'est interpole
-// 1 : tous les champs sont interpoles
-// 2 : certains champs sont interpoles
-void HOMARD_Hypothesis::SetTypeFieldInterp( int TypeFieldInterp )
-{
- VERIFICATION( (TypeFieldInterp>=0) && (TypeFieldInterp<=2) );
- _TypeFieldInterp = TypeFieldInterp;
-}
-//=============================================================================
-int HOMARD_Hypothesis::GetTypeFieldInterp() const
-{
- return _TypeFieldInterp;
-}
-//=============================================================================
-void HOMARD_Hypothesis::AddFieldInterpType( const char* FieldInterp, int TypeInterp )
-{
- MESSAGE ("Dans AddFieldInterpType pour " << FieldInterp << " et TypeInterp = " << TypeInterp) ;
-// On commence par supprimer le champ au cas ou il aurait deja ete insere
-// Cela peut se produire dans un schema YACS quand on repasse plusieurs fois par la
-// definition de l'hypothese
- SupprFieldInterp( FieldInterp ) ;
-// Insertion veritable
-// . Nom du champ
- _ListFieldInterp.push_back( std::string( FieldInterp ) );
-// . Usage du champ
- std::stringstream saux1 ;
- saux1 << TypeInterp ;
- _ListFieldInterp.push_back( saux1.str() );
-// . Indication generale : certains champs sont a interpoler
- SetTypeFieldInterp ( 2 ) ;
-}
-//=============================================================================
-void HOMARD_Hypothesis::SupprFieldInterp( const char* FieldInterp )
-{
- MESSAGE ("Dans SupprFieldInterp pour " << FieldInterp) ;
- std::list<std::string>::iterator it = find( _ListFieldInterp.begin(), _ListFieldInterp.end(), FieldInterp ) ;
-// Attention a supprimer le nom du champ et le type d'usage
- if ( it != _ListFieldInterp.end() )
- {
- it = _ListFieldInterp.erase( it ) ;
- it = _ListFieldInterp.erase( it ) ;
- }
-// Decompte du nombre de champs restant a interpoler
- it = _ListFieldInterp.begin() ;
- int cpt = 0 ;
- while(it != _ListFieldInterp.end())
- {
- cpt += 1 ;
- (*it++);
- }
- MESSAGE("Nombre de champ restants = "<<cpt/2);
-// . Indication generale : aucun champ ne reste a interpoler
- if ( cpt == 0 )
- {
- SetTypeFieldInterp ( 0 ) ;
- }
-}
-//=============================================================================
-void HOMARD_Hypothesis::SupprFieldInterps()
-{
- MESSAGE ("SupprFieldInterps") ;
- _ListFieldInterp.clear();
-// . Indication generale : aucun champ ne reste a interpoler
- SetTypeFieldInterp ( 0 ) ;
-}
-//=============================================================================
-const std::list<std::string>& HOMARD_Hypothesis::GetFieldInterps() const
-{
- return _ListFieldInterp;
-}
-//=============================================================================
-//=============================================================================
-// Liens avec les autres structures
-//=============================================================================
-//=============================================================================
-void HOMARD_Hypothesis::SetCaseCreation( const char* NomCasCreation )
-{
- _NomCasCreation = std::string( NomCasCreation );
-}
-//=============================================================================
-std::string HOMARD_Hypothesis::GetCaseCreation() const
-{
- return _NomCasCreation;
-}
-//=============================================================================
-void HOMARD_Hypothesis::LinkIteration( const char* NomIteration )
-{
- _ListIter.push_back( std::string( NomIteration ) );
-}
-//=============================================================================
-void HOMARD_Hypothesis::UnLinkIteration( const char* NomIteration )
-{
- std::list<std::string>::iterator it = find( _ListIter.begin(), _ListIter.end(), NomIteration ) ;
- if ( it != _ListIter.end() )
- {
- MESSAGE ("Dans UnLinkIteration pour " << NomIteration) ;
- it = _ListIter.erase( it ) ;
- }
-}
-//=============================================================================
-void HOMARD_Hypothesis::UnLinkIterations()
-{
- _ListIter.clear();
-}
-//=============================================================================
-const std::list<std::string>& HOMARD_Hypothesis::GetIterations() const
-{
- return _ListIter;
-}
-//=============================================================================
-void HOMARD_Hypothesis::AddZone( const char* NomZone, int TypeUse )
-{
- MESSAGE ("Dans AddZone pour " << NomZone << " et TypeUse = " << TypeUse) ;
-// On commence par supprimer la zone au cas ou elle aurait deja ete inseree
-// Cela peut se produire dans un schema YACS quand on repasse plusieurs fois par la
-// definition de l'hypothese
- SupprZone( NomZone ) ;
-// Insertion veritable
-// . Nom de la zone
- _ListZone.push_back( std::string( NomZone ) );
-// . Usage de la zone
- std::stringstream saux1 ;
- saux1 << TypeUse ;
- _ListZone.push_back( saux1.str() );
-}
-//=============================================================================
-void HOMARD_Hypothesis::SupprZone( const char* NomZone )
-{
- MESSAGE ("Dans SupprZone pour " << NomZone) ;
- std::list<std::string>::iterator it = find( _ListZone.begin(), _ListZone.end(), NomZone );
-// Attention a supprimer le nom de zone et le type d'usage
- if ( it != _ListZone.end() )
- {
- it = _ListZone.erase( it );
- it = _ListZone.erase( it );
- }
-}
-//=============================================================================
-void HOMARD_Hypothesis::SupprZones()
-{
- _ListZone.clear();
-}
-//=============================================================================
-const std::list<std::string>& HOMARD_Hypothesis::GetZones() const
-{
- return _ListZone;
-}
-
//=============================================================================
/*!
* default constructor:
*/
//=============================================================================
HOMARD_Iteration::HOMARD_Iteration():
- _Name( "" ), _Etat( 0 ),
- _NumIter( -1 ),
- _NomMesh( "" ), _MeshFile( "" ),
- _FieldFile( "" ), _TimeStep( -1 ), _Rank( -1 ),
+ _Name( "" ),
+ _Etat( 0 ),
+ _NumIter( -1 ),
+ _NomMesh( "" ),
+ _MeshFile( "" ),
_LogFile( "" ),
- _IterParent( "" ),
- _NomHypo( "" ), _NomCas( "" ), _NomDir( "" ),
+ _NomDir( "" ),
_FileInfo( "" ),
- _MessInfo( 1 )
+ _MessInfo( 1 )
{
MESSAGE("HOMARD_Iteration");
}
return _MeshFile;
}
//=============================================================================
-void HOMARD_Iteration::SetFieldFile( const char* FieldFile )
-{
- _FieldFile = std::string( FieldFile );
-}
-//=============================================================================
-std::string HOMARD_Iteration::GetFieldFile() const
-{
- return _FieldFile;
-}
-//=============================================================================
-// Instants pour le champ de pilotage
-//=============================================================================
-void HOMARD_Iteration::SetTimeStep( int TimeStep )
-{
- _TimeStep = TimeStep;
-}
-//=============================================================================
-void HOMARD_Iteration::SetTimeStepRank( int TimeStep, int Rank )
-{
- _TimeStep = TimeStep;
- _Rank = Rank;
-}
-//=============================================================================
-void HOMARD_Iteration::SetTimeStepRankLast()
-{
- _TimeStep = -2;
-}
-//=============================================================================
-int HOMARD_Iteration::GetTimeStep() const
-{
- return _TimeStep;
-}
-//=============================================================================
-int HOMARD_Iteration::GetRank() const
-{
- return _Rank;
-}
-//=============================================================================
-// Instants pour un champ a interpoler
-//=============================================================================
-void HOMARD_Iteration::SetFieldInterpTimeStep( const char* FieldInterp, int TimeStep )
-{
- SetFieldInterpTimeStepRank( FieldInterp, TimeStep, TimeStep ) ;
-}
-//=============================================================================
-void HOMARD_Iteration::SetFieldInterpTimeStepRank( const char* FieldInterp, int TimeStep, int Rank )
-{
- MESSAGE("Champ " << FieldInterp << ", hypothese " << _NomHypo )
-// Verification de la presence du champ dans l'hypothese
- std::list<std::string>::iterator it = find( _ListFieldInterp.begin(), _ListFieldInterp.end(), FieldInterp );
- if ( it == _ListFieldInterp.end() )
- {
- INFOS("Champ " << FieldInterp << " ; hypothese " << _NomHypo )
- VERIFICATION("Le champ est inconnu dans l'hypothese associee a cette iteration." == 0);
- }
-
-// . Nom du champ
- _ListFieldInterpTSR.push_back( std::string( FieldInterp ) );
-// . Pas de temps
- std::stringstream saux1 ;
- saux1 << TimeStep ;
- _ListFieldInterpTSR.push_back( saux1.str() );
-// . Numero d'ordre
- std::stringstream saux2 ;
- saux2 << Rank ;
- _ListFieldInterpTSR.push_back( saux2.str() );
-}
-//=============================================================================
-const std::list<std::string>& HOMARD_Iteration::GetFieldInterpsTimeStepRank() const
-{
- return _ListFieldInterpTSR;
-}
-//=============================================================================
-void HOMARD_Iteration::SetFieldInterp( const char* FieldInterp )
-{
- _ListFieldInterp.push_back( std::string( FieldInterp ) );
-}
-//=============================================================================
-const std::list<std::string>& HOMARD_Iteration::GetFieldInterps() const
-{
- return _ListFieldInterp;
-}
-//=============================================================================
-void HOMARD_Iteration::SupprFieldInterps()
-{
- _ListFieldInterp.clear();
-}
-//=============================================================================
void HOMARD_Iteration::SetLogFile( const char* LogFile )
{
_LogFile = std::string( LogFile );
return _FileInfo;
}
//=============================================================================
-//=============================================================================
-// Liens avec les autres iterations
-//=============================================================================
-//=============================================================================
-void HOMARD_Iteration::LinkNextIteration( const char* NomIteration )
-{
- _mesIterFilles.push_back( std::string( NomIteration ) );
-}
-//=============================================================================
-void HOMARD_Iteration::UnLinkNextIteration( const char* NomIteration )
-{
- std::list<std::string>::iterator it = find( _mesIterFilles.begin(), _mesIterFilles.end(), NomIteration ) ;
- if ( it != _mesIterFilles.end() )
- {
- MESSAGE ("Dans UnLinkNextIteration pour " << NomIteration) ;
- it = _mesIterFilles.erase( it ) ;
- }
-}
-//=============================================================================
-void HOMARD_Iteration::UnLinkNextIterations()
-{
- _mesIterFilles.clear();
-}
-//=============================================================================
-const std::list<std::string>& HOMARD_Iteration::GetIterations() const
-{
- return _mesIterFilles;
-}
-//=============================================================================
-void HOMARD_Iteration::SetIterParentName( const char* IterParent )
-{
- _IterParent = IterParent;
-}
-//=============================================================================
-std::string HOMARD_Iteration::GetIterParentName() const
-{
- return _IterParent;
-}
-//=============================================================================
-//=============================================================================
-// Liens avec les autres structures
-//=============================================================================
-//=============================================================================
-void HOMARD_Iteration::SetCaseName( const char* NomCas )
-{
- _NomCas = std::string( NomCas );
-}
-//=============================================================================
-std::string HOMARD_Iteration::GetCaseName() const
-{
- return _NomCas;
-}
-//=============================================================================
-void HOMARD_Iteration::SetHypoName( const char* NomHypo )
-{
- _NomHypo = std::string( NomHypo );
-}
-//=============================================================================
-std::string HOMARD_Iteration::GetHypoName() const
-{
- return _NomHypo;
-}
-//=============================================================================
-//=============================================================================
-// Divers
-//=============================================================================
-//=============================================================================
void HOMARD_Iteration::SetInfoCompute( int MessInfo )
{
_MessInfo = MessInfo;
#include <vector>
#include <stdio.h>
+// C'est le ASSERT de SALOMELocalTrace/utilities.h dans KERNEL
+#ifndef VERIFICATION
+#define VERIFICATION(condition) \
+ if (!(condition)){INTERRUPTION("CONDITION "<<#condition<<" NOT VERIFIED")}
+#endif /* VERIFICATION */
+
+// La gestion des repertoires
+#ifndef CHDIR
+ #ifdef WIN32
+ #define CHDIR _chdir
+ #else
+ #define CHDIR chdir
+ #endif
+#endif
+
using namespace std;
SMESHHOMARD::HOMARD_Gen_ptr SMESH_Gen_i::CreateHOMARD_ADAPT()
myHomardCas->AddIteration(NomIteration);
}
-//=============================================================================
-/*!
- * standard constructor
- */
-//=============================================================================
-HOMARD_Hypothesis_i::HOMARD_Hypothesis_i()
- : SALOME::GenericObj_i(SMESH_Gen_i::GetPOA())
-{
- MESSAGE("Default constructor, not for use");
- ASSERT(0);
-}
-
-//=============================================================================
-/*!
- * standard constructor
- */
-//=============================================================================
-HOMARD_Hypothesis_i::HOMARD_Hypothesis_i(SMESHHOMARD::HOMARD_Gen_var engine)
- : SALOME::GenericObj_i(SMESH_Gen_i::GetPOA())
-{
- MESSAGE("standard constructor");
- _gen_i = engine;
- myHomardHypothesis = new SMESHHOMARDImpl::HOMARD_Hypothesis();
- ASSERT(myHomardHypothesis);
-
- // SetUnifRefinUnRef(1)
- int RefinType = 1;
- int UnRefType = 0;
- myHomardHypothesis->SetAdapType(-1);
- myHomardHypothesis->SetRefinTypeDera(RefinType, UnRefType);
-
- // Set name
- myHomardHypothesis->SetName("Hypo_1");
-}
-
-//=============================================================================
-/*!
- * standard destructor
- */
-//=============================================================================
-HOMARD_Hypothesis_i::~HOMARD_Hypothesis_i()
-{
-}
-
-//=============================================================================
-void HOMARD_Hypothesis_i::SetExtraOutput(CORBA::Long ExtraOutput)
-{
- ASSERT(myHomardHypothesis);
- myHomardHypothesis->SetExtraOutput(ExtraOutput);
-}
-//=============================================================================
-CORBA::Long HOMARD_Hypothesis_i::GetExtraOutput()
-{
- ASSERT(myHomardHypothesis);
- return myHomardHypothesis->GetExtraOutput();
-}
-
-//=============================================================================
-//=============================================================================
-// Liens avec les autres structures
-//=============================================================================
-//=============================================================================
-void HOMARD_Hypothesis_i::LinkIteration(const char* NomIteration)
-{
- ASSERT(myHomardHypothesis);
- myHomardHypothesis->LinkIteration(NomIteration);
-}
-//=============================================================================
-void HOMARD_Hypothesis_i::UnLinkIteration(const char* NomIteration)
-{
- ASSERT(myHomardHypothesis);
- myHomardHypothesis->UnLinkIteration(NomIteration);
-}
-
//=============================================================================
/*!
* standard constructor
return CORBA::string_dup(myHomardIteration->GetFileInfo().c_str());
}
//=============================================================================
-//=============================================================================
-// Liens avec les autres iterations
-//=============================================================================
-//=============================================================================
-void HOMARD_Iteration_i::LinkNextIteration(const char* NomIteration)
-{
- ASSERT(myHomardIteration);
- myHomardIteration->LinkNextIteration(NomIteration);
-}
-//=============================================================================
-void HOMARD_Iteration_i::UnLinkNextIteration(const char* NomIteration)
-{
- ASSERT(myHomardIteration);
- myHomardIteration->UnLinkNextIteration(NomIteration);
-}
-//=============================================================================
-void HOMARD_Iteration_i::SetIterParentName(const char* NomIterParent)
-{
- ASSERT(myHomardIteration);
- myHomardIteration->SetIterParentName(NomIterParent);
-}
-//=============================================================================
-char* HOMARD_Iteration_i::GetIterParentName()
-{
- ASSERT(myHomardIteration);
- return CORBA::string_dup(myHomardIteration->GetIterParentName().c_str());
-}
-
-//=============================================================================
-//=============================================================================
-// Liens avec les autres structures
-//=============================================================================
-//=============================================================================
-void HOMARD_Iteration_i::SetCaseName(const char* NomCas)
-{
- ASSERT(myHomardIteration);
- myHomardIteration->SetCaseName(NomCas);
-}
-//=============================================================================
-char* HOMARD_Iteration_i::GetCaseName()
-{
- ASSERT(myHomardIteration);
- return CORBA::string_dup(myHomardIteration->GetCaseName().c_str());
-}
-//=============================================================================
-void HOMARD_Iteration_i::SetHypoName(const char* NomHypo)
-{
- ASSERT(myHomardIteration);
- myHomardIteration->SetHypoName(NomHypo);
-}
-//=============================================================================
-//=============================================================================
-// Divers
-//=============================================================================
-//=============================================================================
void HOMARD_Iteration_i::SetInfoCompute(CORBA::Long MessInfo)
{
ASSERT(myHomardIteration);
HOMARD_Gen_i::~HOMARD_Gen_i()
{
MESSAGE ("HOMARD_Gen_i::~HOMARD_Gen_i()");
- if (!myCase->_is_nil()) {
- CleanCase();
- }
+ //if (!myCase->_is_nil()) {
+ // CleanCase();
+ //}
}
//=============================================================================
MESSAGE ("DeleteIteration : numIter = " << numIter);
if (numIter == 0) {
- if (CORBA::is_nil(myIteration1))
- myIteration0 = SMESHHOMARD::HOMARD_Iteration::_nil();
+ myIteration0 = SMESHHOMARD::HOMARD_Iteration::_nil();
}
else {
if (!CORBA::is_nil(myIteration1)) {
+ /*
if (CORBA::is_nil(myIteration0)) {
SALOME::ExceptionStruct es;
es.type = SALOME::BAD_PARAM;
es.text = "Invalid iteration 0";
throw SALOME::SALOME_Exception(es);
}
+ */
// Invalide Iteration
if (myIteration1->GetState() > 0) {
}
}
- // Unlink from the parent iteration and from the hypothesis
- myIteration0->UnLinkNextIteration("Iter_1");
- ASSERT(!CORBA::is_nil(myHypothesis));
- myHypothesis->UnLinkIteration("Iter_1");
myIteration1 = SMESHHOMARD::HOMARD_Iteration::_nil();
}
}
}
myCase->AddIteration(myIteration0->GetName());
- myIteration0->SetCaseName("Case_1");
}
else {
if (CORBA::is_nil(myIteration1)) {
}
myCase->AddIteration(myIteration1->GetName());
- myIteration1->SetCaseName("Case_1");
}
}
myIteration1->SetState(1);
myIteration1->SetNumber(1);
- int nbitercase = 1; //myCase->GetNumberofIter()
+ int nbitercase = 1;
char* nomDirIter = CreateDirNameIter(nomDirCase, nbitercase);
myIteration1->SetDirNameLoc(nomDirIter);
std::string label = "IterationHomard_" + nomIterParent;
AssociateCaseIter(1, label.c_str());
- // Lien avec l'iteration precedente
- myIteration0->LinkNextIteration("Iter_1");
- myIteration1->SetIterParentName(nomIterParent.c_str());
-
- // Associate hypothesis
- if (CORBA::is_nil(myHypothesis)) {
- SMESHHOMARD::HOMARD_Gen_var engine = POA_SMESHHOMARD::HOMARD_Gen::_this();
- HOMARD_Hypothesis_i* aServant = new HOMARD_Hypothesis_i(engine);
- myHypothesis = SMESHHOMARD::HOMARD_Hypothesis::_narrow(aServant->_this());
- if (CORBA::is_nil(myHypothesis)) {
- SALOME::ExceptionStruct es;
- es.type = SALOME::BAD_PARAM;
- es.text = "Unable to create the hypothesis";
- throw SALOME::SALOME_Exception(es);
- }
- //myHypothesis->SetNivMax(-1);
- //myHypothesis->SetDiamMin(-1.0);
- //myHypothesis->SetAdapInit(0);
- //myHypothesis->SetExtraOutput(1);
- }
- myIteration1->SetHypoName("Hypo_1");
- myHypothesis->LinkIteration("Iter_1");
-
return SMESHHOMARD::HOMARD_Iteration::_duplicate(myIteration1);
}
//=============================================================================
// B.1. Le répertoire courant
std::string nomDirWork = getenv("PWD");
// B.2. Le sous-répertoire de l'iteration a traiter
- char* DirCompute = ComputeDirManagement(myCase, myIteration1);
+ char* DirCompute = ComputeDirManagement();
MESSAGE(". DirCompute = " << DirCompute);
// C. Le fichier des messages
iaux = 1;
myDriver->TexteMaillageHOMARD(DirCompute, siterp1, iaux);
myDriver->TexteMaillage(NomMesh, MeshFile, 1);
- codret = ComputeAdap(myCase, myIteration1, myDriver);
+ codret = ComputeAdap(myDriver);
// E.4. Ajout des informations liees a l'eventuel suivi de frontiere
- int BoundaryOption = DriverTexteBoundary(myCase, myDriver);
+ int BoundaryOption = DriverTexteBoundary(myDriver);
// E.5. Ecriture du texte dans le fichier
MESSAGE (". Ecriture du texte dans le fichier de configuration; codret = "<<codret);
if (codret == 0) {
if ((BoundaryOption % 5 == 0) && (codretexec == 0)) {
MESSAGE ("Suivi de frontière CAO");
- codret = ComputeCAO(myCase, myIteration1);
+ codret = ComputeCAO();
}
}
// Python Dump
PythonDump();
+ // Delete log file, if required
+ if (!myIteration1->_is_nil()) {
+ MESSAGE("myIteration1->GetLogFile() = " << myIteration1->GetLogFile());
+ if (_LogInFile && _RemoveLogOnSuccess) {
+ // Remove log file on success
+ SMESH_File(myIteration1->GetLogFile(), false).remove();
+ }
+ }
+
// Clean all data
CleanCase();
}
void HOMARD_Gen_i::CleanCase()
{
- // Delete log file, if required
- if (!myIteration1->_is_nil()) {
- MESSAGE("myIteration1->GetLogFile() = " << myIteration1->GetLogFile());
- if (_LogInFile && _RemoveLogOnSuccess) {
- // Remove log file on success
- SMESH_File(myIteration1->GetLogFile(), false).remove();
- }
- }
+ MESSAGE ("CleanCase");
+ if (myCase->_is_nil()) return;
// Delete all boundaries
- //std::map<std::string, SMESHHOMARD::HOMARD_Boundary_var>::const_iterator it_boundary;
- //for (it_boundary = _mesBoundarys.begin();
- // it_boundary != _mesBoundarys.end(); ++it_boundary) {
- // DeleteBoundary((*it_boundary).first.c_str());
- //}
_mesBoundarys.clear();
// Delete iteration
DeleteIteration(1);
- // Delete hypothesis
- // Hypothesis should be deleted only after iteration deletion
- myHypothesis = SMESHHOMARD::HOMARD_Hypothesis::_nil();
-
// Delete case
DeleteCase();
//=============================================================================
// Calcul d'une iteration : partie spécifique à l'adaptation
//=============================================================================
-CORBA::Long HOMARD_Gen_i::ComputeAdap(SMESHHOMARD::HOMARD_Cas_var myCase,
- SMESHHOMARD::HOMARD_Iteration_var myIteration,
- SMESHHOMARDImpl::HomardDriver* myDriver)
+CORBA::Long HOMARD_Gen_i::ComputeAdap(SMESHHOMARDImpl::HomardDriver* myDriver)
{
MESSAGE ("ComputeAdap");
// A.1. Bases
int codret = 0;
// Numero de l'iteration
- int NumeIter = myIteration->GetNumber();
+ int NumeIter = 1;
std::stringstream saux0;
saux0 << NumeIter-1;
std::string siter = saux0.str();
if (NumeIter < 11) { siter = "0" + siter; }
- // A.2. On verifie qu il y a une hypothese (erreur improbable);
- ASSERT(!CORBA::is_nil(myHypothesis));
-
// B. L'iteration parent
ASSERT(!CORBA::is_nil(myIteration0));
// C. Le sous-répertoire de l'iteration precedente
- char* DirComputePa = ComputeDirPaManagement(myCase, myIteration);
+ char* DirComputePa = ComputeDirPaManagement();
MESSAGE(". DirComputePa = " << DirComputePa);
// D. Les données de l'adaptation HOMARD
MESSAGE (". MeshFileParent = " << MeshFileParent);
// D.4. Le maillage associe a l'iteration
- const char* MeshFile = myIteration->GetMeshFile();
+ const char* MeshFile = myIteration1->GetMeshFile();
MESSAGE (". MeshFile = " << MeshFile);
FILE *file = fopen(MeshFile,"r");
if (file != NULL) {
}
}
- // D.5. Les types de raffinement et de deraffinement
- // Les appels corba sont lourds, il vaut mieux les grouper
- //SMESHHOMARD::listeTypes* ListTypes = myHypothesis->GetAdapRefinUnRef();
- //ASSERT(ListTypes->length() == 3);
- int TypeAdap = -1; // HomardHypothesis->GetAdapType()
- int TypeRaff = 1; // HomardHypothesis->GetRefinType()
- int TypeDera = 0; // HomardHypothesis->GetUnRefType()
-
// E. Texte du fichier de configuration
// E.1. Incontournables du texte
myDriver->TexteAdap();
int iaux = 0;
myDriver->TexteMaillageHOMARD(DirComputePa, siter, iaux);
myDriver->TexteMaillage(NomMeshParent, MeshFileParent, 0);
- myDriver->TexteConfRaffDera(ConfType, TypeAdap, TypeRaff, TypeDera);
+ myDriver->TexteConfRaffDera(ConfType);
// E.6. Ajout des options avancees
- //int NivMax = myHypo->GetNivMax();
- //MESSAGE (". NivMax = " << NivMax);
- //double DiamMin = myHypo->GetDiamMin();
- //MESSAGE (". DiamMin = " << DiamMin);
- //int AdapInit = myHypo->GetAdapInit();
- //MESSAGE (". AdapInit = " << AdapInit);
- //int ExtraOutput = myHypo->GetExtraOutput();
- //MESSAGE (". ExtraOutput = " << ExtraOutput);
//myDriver->TexteAdvanced(NivMax, DiamMin, AdapInit, ExtraOutput);
myDriver->TexteAdvanced(-1, -1.0, 0, 1);
// E.7. Ajout des informations sur le deroulement de l'execution
- int MessInfo = myIteration->GetInfoCompute();
+ int MessInfo = myIteration1->GetInfoCompute();
MESSAGE (". MessInfo = " << MessInfo);
myDriver->TexteInfoCompute(MessInfo);
//=============================================================================
// Calcul d'une iteration : partie spécifique au suivi de frontière CAO
//=============================================================================
-CORBA::Long HOMARD_Gen_i::ComputeCAO(SMESHHOMARD::HOMARD_Cas_var myCase,
- SMESHHOMARD::HOMARD_Iteration_var myIteration)
+CORBA::Long HOMARD_Gen_i::ComputeCAO()
{
MESSAGE ("ComputeCAO");
// A.1. Bases
int codret = 0;
// A.2. Le sous-répertoire de l'iteration en cours de traitement
- char* DirCompute = myIteration->GetDirName();
+ char* DirCompute = myIteration1->GetDirName();
// A.3. Le maillage résultat de l'iteration en cours de traitement
- char* MeshFile = myIteration->GetMeshFile();
+ char* MeshFile = myIteration1->GetMeshFile();
// B. Les données pour FrontTrack
// B.1. Le maillage à modifier
const std::string theXaoFileName = myBoundary->GetDataFile();
MESSAGE (". theXaoFileName = " << theXaoFileName);
- // B.5. Parallélisme
- bool theIsParallel = false;
-
// C. Lancement des projections
MESSAGE (". Lancement des projections");
PyRun_SimpleString(pyCommand.c_str());
PyGILState_Release(gstate);
- //SMESHHOMARDImpl::FrontTrack* myFrontTrack = new SMESHHOMARDImpl::FrontTrack();
- //myFrontTrack->track(theInputMedFile, theOutputMedFile,
- // theInputNodeFiles, theXaoFileName, theIsParallel);
-
// D. Transfert des coordonnées modifiées dans le fichier historique de HOMARD
// On lance une exécution spéciale de HOMARD en attendant
// de savoir le faire avec MEDCoupling
MESSAGE (". Transfert des coordonnées");
- codret = ComputeCAObis(myIteration);
+ codret = ComputeCAObis();
return codret;
}
//=============================================================================
// Transfert des coordonnées en suivi de frontière CAO
//=============================================================================
-CORBA::Long HOMARD_Gen_i::ComputeCAObis(SMESHHOMARD::HOMARD_Iteration_var myIteration)
+CORBA::Long HOMARD_Gen_i::ComputeCAObis()
{
MESSAGE ("ComputeCAObis");
// A.1. Controle de la possibilite d'agir
// A.1.1. Etat de l'iteration
- int etat = myIteration->GetState();
+ int etat = myIteration1->GetState();
MESSAGE ("etat = " << etat);
// A.1.2. L'iteration doit être calculee
if (etat == 1) {
}
// A.2. Numero de l'iteration
// siterp1 : numero de l'iteration a traiter
- int NumeIter = myIteration->GetNumber();
+ int NumeIter = myIteration1->GetNumber();
std::string siterp1;
std::stringstream saux1;
saux1 << NumeIter;
ASSERT(!CORBA::is_nil(myCase));
// A.4. Le sous-répertoire de l'iteration a traiter
- char* DirCompute = myIteration->GetDirName();
+ char* DirCompute = myIteration1->GetDirName();
MESSAGE(". DirCompute = " << DirCompute);
// C. Le fichier des messages
std::string LogFile = DirCompute;
LogFile += "/Liste." + siterp1 + ".maj_coords.log";
MESSAGE (". LogFile = " << LogFile);
- myIteration->SetFileInfo(LogFile.c_str());
+ myIteration1->SetFileInfo(LogFile.c_str());
// D. On passe dans le répertoire de l'iteration a calculer
MESSAGE (". On passe dans DirCompute = " << DirCompute);
myDriver->TexteInit(DirCompute, LogFile, "English");
// E.2. Le maillage associe a l'iteration
- const char* NomMesh = myIteration->GetMeshName();
+ const char* NomMesh = myIteration1->GetMeshName();
MESSAGE (". NomMesh = " << NomMesh);
- const char* MeshFile = myIteration->GetMeshFile();
+ const char* MeshFile = myIteration1->GetMeshFile();
MESSAGE (". MeshFile = " << MeshFile);
// E.3. Les données du traitement HOMARD
//=============================================================================
// Calcul d'une iteration : gestion du répertoire de calcul
//=============================================================================
-char* HOMARD_Gen_i::ComputeDirManagement(SMESHHOMARD::HOMARD_Cas_var myCase,
- SMESHHOMARD::HOMARD_Iteration_var myIteration)
+char* HOMARD_Gen_i::ComputeDirManagement()
{
MESSAGE ("ComputeDirManagement : répertoires pour le calcul");
// B.3. Le sous-répertoire de l'iteration a calculer, puis le répertoire complet a creer
// B.3.1. Le nom du sous-répertoire
- const char* nomDirIt = myIteration->GetDirNameLoc();
+ const char* nomDirIt = myIteration1->GetDirNameLoc();
// B.3.2. Le nom complet du sous-répertoire
std::stringstream DirCompute;
//=============================================================================
// Calcul d'une iteration : gestion du répertoire de calcul de l'iteration parent
//=============================================================================
-char* HOMARD_Gen_i::ComputeDirPaManagement(SMESHHOMARD::HOMARD_Cas_var myCase,
- SMESHHOMARD::HOMARD_Iteration_var myIteration)
+char* HOMARD_Gen_i::ComputeDirPaManagement()
{
MESSAGE ("ComputeDirPaManagement : répertoires pour le calcul");
// Le répertoire du cas
// 2. les liens avec les groupes
// 3. un entier resumant le type de comportement pour les frontieres
//=============================================================================
-int HOMARD_Gen_i::DriverTexteBoundary(SMESHHOMARD::HOMARD_Cas_var myCase, SMESHHOMARDImpl::HomardDriver* myDriver)
+int HOMARD_Gen_i::DriverTexteBoundary(SMESHHOMARDImpl::HomardDriver* myDriver)
{
MESSAGE ("... DriverTexteBoundary");
// 1. Recuperation des frontieres
