- If error occurs into the python instructions, the program stops.
SALOME VERSION 7.4 :
- - Scroll bar for the large windows
- - The meshes are published only if requested
- - The torus is a new possibility for the analytical boundary
+ - Scroll bar for the large windows.
+ - The meshes are published only if requested.
+ - The torus is a new possibility for the analytical boundary.
+ - The function ``SetAdapRefinUnRef(TypeAdap, TypeRaff, TypeDera)`` is suppressed. For an adaptation by a field or by zones, the mode refinement/unrefinement is automatically set from the other parameters of the hypothesis. For a uniform refinement, the function ``SetUnifRefinUnRef(TypeRaffDera)`` is now used (see :ref:`tui_create_hypothese`).
+
| **GetName()** |
| Returns the name of the hypothesis |
+---------------------------------------------------------------+
-| .. module:: SetAdapRefinUnRef |
-| |
-| **SetAdapRefinUnRef(Adap, Refin, UnRef)** |
-| Gives the type of adaptation to the hypothesis |
+| .. module:: GetAdapType |
| |
-| - ``Adap``: integer that defines the type of adaptation |
+| **GetAdapType()** |
+| Returns the type of the adaptation |
| |
| * -1: uniform |
| * 0: by zones |
| * 1: by a field |
-| |
-| - ``Refin``: integer that informs if the refinement is |
-| active or not |
-| |
-| * 0: unactive |
-| * 1: active |
-| |
-| - ``UnRef``: integer that informs if the refinement is |
-| active or not |
-| |
-| * 0: unactive |
-| * 1: active |
-| |
-+---------------------------------------------------------------+
-| .. module:: GetAdapType |
-| |
-| **GetAdapType()** |
-| Returns the type of the adaptation |
+---------------------------------------------------------------+
| .. module:: GetRefinType |
| |
| **GetRefinType()** |
| Returns the type of the refinement |
+| |
+| * 0: unactive |
+| * 1: active |
+---------------------------------------------------------------+
| .. module:: GetUnRefType |
| |
| **GetUnRefType()** |
| Returns the type of the unrefinement |
+| |
+| * 0: unactive |
+| * 1: active |
+---------------------------------------------------------------+
| .. module:: Delete |
| |
| * other value: problem |
+---------------------------------------------------------------+
+Uniform adaptation
+==================
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: SetUnifRefinUnRef |
+| |
+| **SetUnifRefinUnRef(RefinUnRef)** |
+| Defines a type of adaptation for the whole mesh |
+| |
+| - ``RefinUnRef``: integer that defines the |
+| type of adaptation |
+| |
+| * 1: refinement |
+| * -1: unrefinement |
++---------------------------------------------------------------+
+
+Adaptation by a field
+=====================
+
The driving field and the thresholds
-====================================
+------------------------------------
+---------------------------------------------------------------+
+---------------------------------------------------------------+
The components of the driving field
-===================================
+-----------------------------------
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
-The zones
-=========
+Adaptation by zones
+===================
+---------------------------------------------------------------+
+---------------------------------------------------------------+
::
hypo_1 = homard.CreateHypothesis("HypoField")
- hypo_1.SetAdapRefinUnRef(1, 1, 0)
hypo_1.SetField("INDICATEUR")
hypo_1.AddComp("INDX")
hypo_1.AddComp("INDZ")
*******************
.. index:: single: zone
-One proceeds here to refinement according to zones. To pass from the initial mesh to the mesh 'M_1', one uses a box framing the z=1 plane and a sphere centered on the origin with radius 1.05. Then to pass from the mesh 'M_1' to the mesh 'M_2', one replaces the sphere by a box framing the cube on side 0.5, pointing on the origin. It will be noted that the type of refinement was not specified; by default, it will be thus in conformity.
+One proceeds here to refinement according to zones. To pass from the initial mesh to the mesh 'M_1', one uses a box framing the z=1 plane and a sphere centered on the origin with radius 1.05. Then to pass from the mesh 'M_1' to the mesh 'M_2', one replaces the sphere by a box framing the cube on side 0.5, pointing on the origin and the meshes in the very first zone are unrefined.
.. literalinclude:: ../files/tutorial_2.py
- :lines: 57-101
+ :lines: 57-99
.. note::
Download the files
To adapt the H_1 mesh resulting from the Iter_1 iteration, two alternatives are applied. In the first, Iter_2, the field is a scalar field of indicators of error and one cuts out the 1.5% of elements where the error is largest. In the second alternative, Iter_2_bis, one is based on a vector field and one examines the jump of this vector between an element and its neighbors: one will cut out where the infinite standard of this jump is higher than the absolute threshold of 0.0001.
.. literalinclude:: ../files/tutorial_3.py
- :lines: 57-131
+ :lines: 57-128
.. note::
Download the files
In the case presented here, one for the first time refines all the elements contained in a bored disk, then in one second iteration, all the elements contained in a rectangle. One will note the use of the follow-up of the circular borders of the field.
.. literalinclude:: ../files/tutorial_5.py
- :lines: 57-101
+ :lines: 57-99
.. note::
Download the files
# Hypotheses
# ==========
Hypo_1 = homard.CreateHypothesis('Hypo_1')
-Hypo_1.SetAdapRefinUnRef(-1, 1, 0)
+Hypo_1.SetUnifRefinUnRef(1)
#
# Cas
# ===
# Hypothese "Hypo_2"
# ==================
Hypo_2 = homard.CreateHypothesis('Hypo_2')
-Hypo_2.SetAdapRefinUnRef(0, 1, 0)
Hypo_2.AddZone('Zone_1', 1)
Hypo_2.AddZone('Zone_0', 1)
#
# Hypothese "Hypo_2_bis"
# ======================
Hypo_2_bis = homard.CreateHypothesis('Hypo_2_bis')
-Hypo_2_bis.SetAdapRefinUnRef(0, 1, 0)
-Hypo_2_bis.AddZone('Zone_0', 1)
+Hypo_2_bis.AddZone('Zone_0', -1)
Hypo_2_bis.AddZone('Zone_2', 1)
#
# Cas
# Hypothese "Hypo_0vers1"
# =======================
Hypo_0vers1 = homard.CreateHypothesis('Hypo_0vers1')
-Hypo_0vers1.SetAdapRefinUnRef(1, 1, 0)
# Characterization of the field
Hypo_0vers1.SetField('SOLU_0__QIRE_ELEM_SIGM__________')
Hypo_0vers1.SetUseComp(0)
# Hypothese "Hypo_1vers2"
# =======================
Hypo_1vers2 = homard.CreateHypothesis('Hypo_1vers2')
-Hypo_1vers2.SetAdapRefinUnRef(1, 1, 1)
# Characterization of the field
Hypo_1vers2.SetField('SOLU_1__QIRE_ELEM_SIGM__________')
Hypo_1vers2.SetUseComp(0)
# Hypothese "Hypo_1vers2_bis"
# ===========================
Hypo_1vers2_bis = homard.CreateHypothesis('Hypo_1vers2_bis')
-Hypo_1vers2_bis.SetAdapRefinUnRef(1, 1, 1)
# Characterization of the field
Hypo_1vers2_bis.SetField('SOLU_1__DEPL____________________')
Hypo_1vers2_bis.SetUseComp(1)
# ==========
# Creation of the hypothesis Hypo_4
Hypo_4 = homard.CreateHypothesis('Hypo_4')
-Hypo_4.SetAdapRefinUnRef(-1, 1, 0)
+Hypo_4.SetUnifRefinUnRef(1)
Hypo_4.AddGroup('T1_INT_I')
Hypo_4.AddGroup('T1_INT_O')
Hypo_4.AddGroup('T2_INT')
# Creation of the hypothesis Hypo_4_bis
Hypo_4_bis = homard.CreateHypothesis('Hypo_4_bis')
-Hypo_4_bis.SetAdapRefinUnRef(-1, 1, 0)
+Hypo_4_bis.SetUnifRefinUnRef(1)
Hypo_4_bis.AddGroup('T1_EXT_I')
Hypo_4_bis.AddGroup('T1_EXT_O')
Hypo_4_bis.AddGroup('T2_EXT')
# ==========
# Creation of the hypothesis Hypo_5
Hypo_5 = homard.CreateHypothesis('Hypo_5')
-Hypo_5.SetAdapRefinUnRef(0, 1, 0)
Hypo_5.AddZone('enveloppe', 1)
# Creation of the hypothesis Hypo_5_bis
Hypo_5_bis = homard.CreateHypothesis('Hypo_5_bis')
-Hypo_5_bis.SetAdapRefinUnRef(0, 1, 0)
Hypo_5_bis.AddZone('quart_sup', 1)
#
# Cas
- Arrêt en cas d'erreur dans les données des instructions python
SALOME VERSION 7.4 :
- - Grandes fenêtres avec ascenseur
- - Publication des maillages à la demande
- - Suivi de frontière analytique torique
+ - Grandes fenêtres avec ascenseur.
+ - Publication des maillages à la demande.
+ - Suivi de frontière analytique torique.
+ - La fonction ``SetAdapRefinUnRef(TypeAdap, TypeRaff, TypeDera)`` est supprimée. Pour une adaptation selon un champ ou des zones, le mode raffinement/déraffinement est automatiquement déduit des autres paramètres de l'hypothèse. Pour un raffinement uniforme, on utilisera ``SetUnifRefinUnRef(TypeRaffDera)`` (voir :ref:`tui_create_hypothese`).
| **GetName()** |
| Retourne le nom de l'hypothèse |
+---------------------------------------------------------------+
-| .. module:: SetAdapRefinUnRef |
-| |
-| **SetAdapRefinUnRef(Adap, Refin, UnRef)** |
-| Affecte le mode d'adaptation associé à l'hypothèse |
+| .. module:: GetAdapType |
| |
-| - ``Adap`` : entier précisant le type d'adaptation |
+| **GetAdapType()** |
+| Retourne le type d'adaptation |
| |
| * -1 : uniforme |
| * 0 : selon des zones |
| * 1 : selon un champ |
-| |
-| - ``Refin`` : entier précisant si le raffinement est actif|
-| |
-| * 0 : inactif |
-| * 1 : actif |
-| |
-| - ``UnRef`` : entier précisant si déraffinement est actif |
-| |
-| * 0 : inactif |
-| * 1 : actif |
-| |
-+---------------------------------------------------------------+
-| .. module:: GetAdapType |
-| |
-| **GetAdapType()** |
-| Retourne le type d'adaptation |
+---------------------------------------------------------------+
| .. module:: GetRefinType |
| |
| **GetRefinType()** |
| Retourne le type de raffinement |
+| |
+| * 0 : inactif |
+| * 1 : actif |
+---------------------------------------------------------------+
| .. module:: GetUnRefType |
| |
| **GetUnRefType()** |
| Retourne le type de déraffinement |
+| |
+| * 0 : inactif |
+| * 1 : actif |
+---------------------------------------------------------------+
| .. module:: Delete |
| |
| * autre valeur : problème |
+---------------------------------------------------------------+
+Adaptation uniforme
+===================
+
++---------------------------------------------------------------+
++---------------------------------------------------------------+
+| .. module:: SetUnifRefinUnRef |
+| |
+| **SetUnifRefinUnRef(RefinUnRef)** |
+| Définit un mode d'adaptation uniforme à tout le maillage |
+| |
+| - ``RefinUnRef`` : entier précisant le type d'adaptation |
+| |
+| * 1 : raffinement |
+| * -1 : déraffinement |
++---------------------------------------------------------------+
+
+Adaptation selon un champ
+=========================
+
Le champ de pilotage de l'adaptation et les seuils
-==================================================
+--------------------------------------------------
+---------------------------------------------------------------+
+---------------------------------------------------------------+
Les composantes du champ de pilotage
-====================================
+------------------------------------
+---------------------------------------------------------------+
+---------------------------------------------------------------+
+---------------------------------------------------------------+
-Les zones
-=========
+Adaptation selon des zones
+==========================
+---------------------------------------------------------------+
+---------------------------------------------------------------+
La création de l'objet hypo_1 se fait ainsi : ::
hypo_1 = homard.CreateHypothesis("HypoField")
- hypo_1.SetAdapRefinUnRef(1, 1, 0)
hypo_1.SetField("INDICATEUR")
hypo_1.AddComp("INDX")
hypo_1.AddComp("INDZ")
*************************
.. index:: single: zone
-On procède ici au raffinement selon des zones. Pour passer du maillage initial au maillage 'M_1', on utilise une boîte encadrant le plan z=1 et une sphère centrée sur l'origine de rayon 1.05. Puis pour passer du maillage 'M_1' au maillage 'M_2', on remplace la sphère par une boîte encadrant le cube de côté 0.5, pointant sur l'origine. On notera que le type de raffinement n'a pas été précisé ; par défaut, il sera donc conforme.
+On procède ici au raffinement selon des zones. Pour passer du maillage initial au maillage 'M_1', on utilise une boîte encadrant le plan z=1 et une sphère centrée sur l'origine de rayon 1.05. Puis pour passer du maillage 'M_1' au maillage 'M_2', on remplace la sphère par une boîte encadrant le cube de côté 0.5, pointant sur l'origine et on déraffine les mailles contenues dans la toute première zone.
.. literalinclude:: ../files/tutorial_2.py
- :lines: 57-101
+ :lines: 57-99
.. note::
Téléchargement des fichiers
Pour adapter le maillage H_1 issu de l'itération Iter_1, deux variantes sont appliquées. Dans la première, Iter_2, le champ est un champ scalaire d'indicateurs d'erreur et on découpe les 1.5% de mailles où l'erreur est la plus grande. Dans la seconde variante, Iter_2_bis, on se base sur un champ vectoriel et on examine le saut de ce vecteur entre une maille et ses voisines : on découpera là où la norme infinie de ce saut est supérieure au seuil absolu de 0.0001.
.. literalinclude:: ../files/tutorial_3.py
- :lines: 57-131
+ :lines: 57-128
.. note::
Téléchargement des fichiers
Dans le cas présenté ici, on raffine une première fois toutes les mailles contenues dans un disque percé, puis dans une seconde itération, toutes les mailles contenues dans un rectangle. On notera l'utilisation du suivi des frontières circulaires du domaine.
.. literalinclude:: ../files/tutorial_5.py
- :lines: 57-101
+ :lines: 57-99
.. note::
Téléchargement des fichiers
string GetDumpPython() raises (SALOME::SALOME_Exception);
// Caracteristiques
- void SetAdapRefinUnRef(in long Adap, in long Raff, in long Dera)
- raises (SALOME::SALOME_Exception);
+ void SetUnifRefinUnRef(in long RaffDera) raises (SALOME::SALOME_Exception);
listeTypes GetAdapRefinUnRef() raises (SALOME::SALOME_Exception);
long GetAdapType() raises (SALOME::SALOME_Exception);
long GetRefinType() raises (SALOME::SALOME_Exception);
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<std::string>::const_iterator it = _ListZone.begin();
}
// Mise en place des attributs
- aHypothesis->SetAdapRefinUnRef(_aTypeAdap,_aTypeRaff,_aTypeDera);
+ if ( _aTypeAdap == -1 )
+ {
+ int TypeRaffDera ;
+ if ( _aTypeRaff == 1 ) { TypeRaffDera = 1 ; }
+ else { TypeRaffDera = -1 ; }
+ aHypothesis->SetUnifRefinUnRef(TypeRaffDera);
+ }
aHypothesis->SetTypeFieldInterp(_TypeFieldInterp);
aHypothesis->SetCaseCreation(_aCaseName.toStdString().c_str());
// Caracteristiques
//=============================================================================
//=============================================================================
-void HOMARD_Hypothesis_i::SetAdapRefinUnRef( CORBA::Long TypeAdap,CORBA::Long TypeRaff, CORBA::Long TypeDera )
+void HOMARD_Hypothesis_i::SetUnifRefinUnRef( CORBA::Long TypeRaffDera )
{
ASSERT( myHomardHypothesis );
- myHomardHypothesis->SetAdapType( TypeAdap );
+ int TypeRaff, TypeDera ;
+ if ( TypeRaffDera == 1 )
+ {
+ TypeRaff = 1 ;
+ TypeDera = 0 ;
+ }
+ else
+ {
+ TypeRaff = 0 ;
+ TypeDera = 1 ;
+ }
+ myHomardHypothesis->SetAdapType( -1 );
myHomardHypothesis->SetRefinTypeDera( TypeRaff, TypeDera );
}
//=============================================================================
//=============================================================================
void HOMARD_Hypothesis_i::SetRefinThr( CORBA::Long TypeThR, CORBA::Double ThreshR )
{
+ myHomardHypothesis->SetAdapType( 1 );
+ int TypeDera = myHomardHypothesis->GetUnRefType() ;
+ myHomardHypothesis->SetRefinTypeDera( 1, TypeDera );
myHomardHypothesis->SetRefinThr( TypeThR, ThreshR );
}
//=============================================================================
//=============================================================================
void HOMARD_Hypothesis_i::SetUnRefThr( CORBA::Long TypeThC, CORBA::Double ThreshC )
{
+ myHomardHypothesis->SetAdapType( 1 );
+ int TypeRaff = myHomardHypothesis->GetRefinType() ;
+ myHomardHypothesis->SetRefinTypeDera( TypeRaff, 1 );
myHomardHypothesis->SetUnRefThr( TypeThC, ThreshC );
}
//=============================================================================
//=============================================================================
void HOMARD_Hypothesis_i::AddZone( const char* NomZone, CORBA::Long TypeUse )
{
- MESSAGE ("Dans AddZone pour " << NomZone) ;
+ MESSAGE ("Dans AddZone pour " << NomZone << " et TypeUse = " << TypeUse ) ;
ASSERT( myHomardHypothesis );
+ myHomardHypothesis->SetAdapType( 0 );
+ int TypeRaff, TypeDera ;
+ if ( TypeUse == 1 )
+ {
+ TypeRaff = 1 ;
+ TypeDera = myHomardHypothesis->GetUnRefType() ;
+ }
+ else if ( TypeUse == -1 )
+ {
+ TypeRaff = myHomardHypothesis->GetRefinType() ;
+ TypeDera = 1 ;
+ }
+ else
+ {
+ ASSERT( "TypeUse should be 1 or -1" == 0 );
+ }
+ myHomardHypothesis->SetRefinTypeDera( TypeRaff, TypeDera );
char* NomHypo = GetName() ;
return _gen_i->AssociateHypoZone(NomHypo, NomZone, TypeUse) ;
}
bool Restore( const std::string& stream );
// Caracteristiques
- void SetAdapRefinUnRef( CORBA::Long TypeAdap, CORBA::Long TypeRaff, CORBA::Long TypeDera );
+ void SetUnifRefinUnRef( CORBA::Long TypeRaffDera );
HOMARD::listeTypes* GetAdapRefinUnRef();
CORBA::Long GetAdapType();
CORBA::Long GetRefinType();
HypoName_1 = "a10_1pc_de_mailles_a_raffiner_sur_ERRE_ELEM_SIGM"
print "-------- Creation of the hypothesis", HypoName_1
Hypo_1_1 = homard.CreateHypothesis(HypoName_1)
- Hypo_1_1.SetAdapRefinUnRef(1, 1, 0)
Hypo_1_1.SetField('RESU____ERRE_ELEM_SIGM__________')
Hypo_1_1.SetUseComp(0)
Hypo_1_1.AddComp('ERREST')
HypoName_2 = "Zones_1_et_2"
print "-------- Creation of the hypothesis", HypoName_2
Zones_1_et_2 = homard.CreateHypothesis(HypoName_2)
- Zones_1_et_2.SetAdapRefinUnRef(0, 1, 0)
Zones_1_et_2.AddZone('Zone_1_1', 1)
Zones_1_et_2.AddZone('Zone_1_2', 1)
print HypoName_2, " : zones utilisées :", Zones_1_et_2.GetZones()
HypoName_1 = "Hypo_" + Test_Name + "_1"
print "-------- Creation of the hypothesis", HypoName_1
Hypo_test_2_1 = homard.CreateHypothesis(HypoName_1)
- Hypo_test_2_1.SetAdapRefinUnRef(-1, 1, 0)
+ Hypo_test_2_1.SetUnifRefinUnRef(1)
Hypo_test_2_1.AddGroup('EG')
Hypo_test_2_1.AddGroup('BANDE')
print HypoName_1, " : zones utilisées :", Hypo_test_2_1.GetZones()
HypoName_2 = "Hypo_" + Test_Name + "_2"
print "-------- Creation of the hypothesis", HypoName_2
Hypo_test_2_2 = homard.CreateHypothesis(HypoName_2)
- Hypo_test_2_2.SetAdapRefinUnRef(-1, 1, 0)
+ Hypo_test_2_2.SetUnifRefinUnRef(1)
Hypo_test_2_2.AddGroup('M_D')
print HypoName_2, " : zones utilisées :", Hypo_test_2_2.GetZones()
print HypoName_2, " : champ utilisé :", Hypo_test_2_2.GetFieldName()
HypoName = "Hypo_" + Test_Name
print "-------- Creation of the hypothesis", HypoName
Hypo_test_3 = homard.CreateHypothesis(HypoName)
- Hypo_test_3.SetAdapRefinUnRef(-1, 1, 0)
+ Hypo_test_3.SetUnifRefinUnRef(1)
print HypoName, " : zones utilisées :", Hypo_test_3.GetZones()
print HypoName, " : champ utilisé :", Hypo_test_3.GetFieldName()
print HypoName, " : composantes utilisées :", Hypo_test_3.GetComps()
HypoName = "Hypo_test_3"
print "-------- Creation of the hypothesis", HypoName
Hypo_test_3 = homard.CreateHypothesis(HypoName)
- Hypo_test_3.SetAdapRefinUnRef(-1, 1, 0)
+ Hypo_test_3.SetUnifRefinUnRef(1)
#
break
#
