X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHOMARD%2FHOMARD_Hypothesis.cxx;h=2c647d8a1e05bfa18b8f560d80001d1ab581a44d;hb=b417e21f963634e1162dc535e85ef6de6454997d;hp=4c59eef9af611d98bdce9d3d7c087188c2b88587;hpb=a3b974f0f68b4ea42bbfadb42106996e9a1842c8;p=modules%2Fhomard.git diff --git a/src/HOMARD/HOMARD_Hypothesis.cxx b/src/HOMARD/HOMARD_Hypothesis.cxx index 4c59eef9..2c647d8a 100644 --- a/src/HOMARD/HOMARD_Hypothesis.cxx +++ b/src/HOMARD/HOMARD_Hypothesis.cxx @@ -1,11 +1,11 @@ -// HOMARD HOMARD : implementaion of HOMARD idl descriptions +// HOMARD HOMARD : implementation of HOMARD idl descriptions // -// Copyright (C) 2011-2013 CEA/DEN, EDF R&D +// Copyright (C) 2011-2016 CEA/DEN, EDF R&D // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either -// version 2.1 of the License. +// version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -19,7 +19,7 @@ // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // // File : HOMARD_Hypothesis.cxx -// Author : Paul RASCLE, EDF +// Author : Gerald NICOLAS, EDF // Module : HOMARD // // Remarques : @@ -32,6 +32,7 @@ // Quand les 2 fonctions Setxxx et Getxxx sont presentes, Setxxx est decrit en premier #include "HOMARD_Hypothesis.hxx" +#include "HOMARD.hxx" #include "utilities.h" //============================================================================= @@ -78,7 +79,13 @@ std::string HOMARD_Hypothesis::GetDumpPython() const std::ostringstream aScript; aScript << "\n# Creation of the hypothesis " << _Name << "\n" ; aScript << "\t" << _Name << " = homard.CreateHypothesis(\"" << _Name << "\")\n"; - aScript << "\t" << _Name << ".SetAdapRefinUnRef(" << _TypeAdap << ", " << _TypeRaff << ", " << _TypeDera << ")\n"; + if ( _TypeAdap == -1 ) + { + int TypeRaffDera ; + if ( _TypeRaff == 1 ) { TypeRaffDera = 1 ; } + else { TypeRaffDera = -1 ; } + aScript << "\t" << _Name << ".SetUnifRefinUnRef(" << TypeRaffDera << ")\n"; + } // Raffinement selon des zones geometriques std::list::const_iterator it = _ListZone.begin(); @@ -99,8 +106,8 @@ std::string HOMARD_Hypothesis::GetDumpPython() const aScript << "\t" << _Name << ".SetField(\"" << _Field << "\")\n"; aScript << "\t" << _Name << ".SetUseField(" << _UsField << ")\n"; aScript << "\t" << _Name << ".SetUseComp(" << _UsCmpI << ")\n"; - std::list::const_iterator it_comp = _ListComposant.begin(); - while(it_comp != _ListComposant.end()) + std::list::const_iterator it_comp = _ListComp.begin(); + while(it_comp != _ListComp.end()) { aScript << "\t" << _Name << ".AddComp(\"" << *it_comp << "\")\n"; it_comp++; @@ -119,17 +126,22 @@ std::string HOMARD_Hypothesis::GetDumpPython() const for ( it=_ListGroupSelected.begin(); it!=_ListGroupSelected.end();it++) aScript << "\t" << _Name << ".AddGroup(\"" << (*it) << "\")\n" ; -// Interpolation champ - aScript << "\t" << _Name << ".SetTypeFieldInterp(" << _TypeFieldInterp << ")\n"; +// Interpolation des champs if ( _TypeFieldInterp == 2 ) { std::list::const_iterator it_champ = _ListFieldInterp.begin(); while(it_champ != _ListFieldInterp.end()) { - aScript << "\t" << _Name << ".AddFieldInterp(\"" << *it_champ << "\")\n"; + aScript << "\t" << _Name << ".AddFieldInterpType( \"" << *it_champ << "\" " ; + it_champ++; + aScript << ", " << *it_champ << ")\n"; it_champ++; } } + else if ( _TypeFieldInterp != 0 ) + { + aScript << "\t" << _Name << ".SetTypeFieldInterp(" << _TypeFieldInterp << ")\n"; + } if ( _NivMax > 0 ) { aScript << "\t" <<_Name << ".SetNivMax(" << _NivMax << ")\n"; @@ -142,9 +154,9 @@ std::string HOMARD_Hypothesis::GetDumpPython() const { aScript << "\t" <<_Name << ".SetAdapInit(" << _AdapInit << ")\n"; } - if ( _LevelOutput != 0 ) + if ( _ExtraOutput != 1 ) { - aScript << "\t" <<_Name << ".SetLevelOutput(" << _LevelOutput << ")\n"; + aScript << "\t" <<_Name << ".SetExtraOutput(" << _ExtraOutput << ")\n"; } return aScript.str(); @@ -156,7 +168,7 @@ std::string HOMARD_Hypothesis::GetDumpPython() const //============================================================================= void HOMARD_Hypothesis::SetAdapType( int TypeAdap ) { - ASSERT (!((TypeAdap < -1) or (TypeAdap > 1))); + VERIFICATION( (TypeAdap>=-1) && (TypeAdap<=1) ); _TypeAdap = TypeAdap; } //============================================================================= @@ -167,9 +179,9 @@ int HOMARD_Hypothesis::GetAdapType() const //============================================================================= void HOMARD_Hypothesis::SetRefinTypeDera( int TypeRaff, int TypeDera ) { - ASSERT(!(( TypeRaff < 0) or (TypeRaff > 1))); + VERIFICATION( (TypeRaff>=-1) && (TypeRaff<=1) ); _TypeRaff = TypeRaff; - ASSERT(! ((TypeDera < 0) or (TypeDera > 1))); + VERIFICATION( (TypeDera>=-1) && (TypeDera<=1) ); _TypeDera = TypeDera; } //============================================================================= @@ -196,7 +208,7 @@ std::string HOMARD_Hypothesis::GetFieldName() const //============================================================================= void HOMARD_Hypothesis::SetUseField( int UsField ) { - ASSERT(!((UsField < 0) or (UsField > 1 ))); + VERIFICATION( (UsField>=0) && (UsField<=1) ); _UsField = UsField; } //============================================================================= @@ -207,7 +219,8 @@ int HOMARD_Hypothesis::GetUseField() const //============================================================================= void HOMARD_Hypothesis::SetUseComp( int UsCmpI ) { - ASSERT(!((UsCmpI < 0) or (UsCmpI > 2))); + MESSAGE ("SetUseComp pour UsCmpI = "<=0) && (UsCmpI<=2) ); _UsCmpI = UsCmpI; } //============================================================================= @@ -216,26 +229,37 @@ int HOMARD_Hypothesis::GetUseComp() const return _UsCmpI; } //============================================================================= -void HOMARD_Hypothesis::AddComp( const char* NomComposant ) +void HOMARD_Hypothesis::AddComp( const char* NomComp ) { - _ListComposant.push_back( std::string( NomComposant ) ); +// 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() +void HOMARD_Hypothesis::SupprComp( const char* NomComp ) { - MESSAGE ("SupprComp") ; - _ListComposant.clear(); + MESSAGE ("SupprComp pour "<::iterator it = find( _ListComp.begin(), _ListComp.end(), NomComp ); + if ( it != _ListComp.end() ) { it = _ListComp.erase( it ); } } //============================================================================= -const std::list& HOMARD_Hypothesis::GetListComp() const +void HOMARD_Hypothesis::SupprComps() { - return _ListComposant; + _ListComp.clear(); +} +//============================================================================= +const std::list& HOMARD_Hypothesis::GetComps() const +{ + return _ListComp; } //============================================================================= void HOMARD_Hypothesis::SetRefinThr( int TypeThR, double ThreshR ) { MESSAGE( "SetRefinThr : TypeThR = " << TypeThR << ", ThreshR = " << ThreshR ); - ASSERT(!(( TypeThR < 0) or (TypeThR > 4 ))); + VERIFICATION( (TypeThR>=0) && (TypeThR<=4) ); _TypeThR = TypeThR; _ThreshR = ThreshR; } @@ -252,7 +276,7 @@ double HOMARD_Hypothesis::GetThreshR() const //============================================================================= void HOMARD_Hypothesis::SetUnRefThr( int TypeThC, double ThreshC ) { - ASSERT(!((TypeThC < 0) or (TypeThC > 4))); + VERIFICATION( (TypeThC>=0) && (TypeThC<=4) ); _TypeThC = TypeThC; _ThreshC = ThreshC; } @@ -303,23 +327,40 @@ const int HOMARD_Hypothesis::GetAdapInit() const return _AdapInit; } //============================================================================= -void HOMARD_Hypothesis::SetLevelOutput( int LevelOutput ) +void HOMARD_Hypothesis::SetExtraOutput( int ExtraOutput ) //============================================================================= { - _LevelOutput = LevelOutput; + _ExtraOutput = ExtraOutput; } //============================================================================= -const int HOMARD_Hypothesis::GetLevelOutput() const +const int HOMARD_Hypothesis::GetExtraOutput() const //============================================================================= { - return _LevelOutput; + 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 "<::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& ListGroup ) { _ListGroupSelected.clear(); @@ -333,9 +374,13 @@ const std::list& 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 ) { - ASSERT (!((TypeFieldInterp < -1) or (TypeFieldInterp > 2))); + VERIFICATION( (TypeFieldInterp>=0) && (TypeFieldInterp<=2) ); _TypeFieldInterp = TypeFieldInterp; } //============================================================================= @@ -344,18 +389,59 @@ int HOMARD_Hypothesis::GetTypeFieldInterp() const return _TypeFieldInterp; } //============================================================================= -void HOMARD_Hypothesis::AddFieldInterp( const char* FieldInterp ) +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::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 = "<& HOMARD_Hypothesis::GetListFieldInterp() const +const std::list& HOMARD_Hypothesis::GetFieldInterps() const { return _ListFieldInterp; } @@ -385,7 +471,7 @@ void HOMARD_Hypothesis::UnLinkIteration( const char* NomIteration ) if ( it != _ListIter.end() ) { MESSAGE ("Dans UnLinkIteration pour " << NomIteration) ; - _ListIter.erase( it ) ; + it = _ListIter.erase( it ) ; } } //============================================================================= @@ -401,21 +487,29 @@ const std::list& HOMARD_Hypothesis::GetIterations() const //============================================================================= void HOMARD_Hypothesis::AddZone( const char* NomZone, int TypeUse ) { - MESSAGE ("Dans AddZone pour " << NomZone) ; + 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 ; - std::string saux2 = saux1.str() ; - _ListZone.push_back( saux2 ); + _ListZone.push_back( saux1.str() ); } //============================================================================= void HOMARD_Hypothesis::SupprZone( const char* NomZone ) { MESSAGE ("Dans SupprZone pour " << NomZone) ; std::list::iterator it = find( _ListZone.begin(), _ListZone.end(), NomZone ); +// Attention a supprimer le nom de zone et le type d'usage if ( it != _ListZone.end() ) { - _ListZone.erase( it ); + it = _ListZone.erase( it ); + it = _ListZone.erase( it ); } } //=============================================================================