1600 lines
70 KiB
C++
Executable file
1600 lines
70 KiB
C++
Executable file
|
|
// This file is part of the Herezh++ application.
|
|
//
|
|
// The finite element software Herezh++ is dedicated to the field
|
|
// of mechanics for large transformations of solid structures.
|
|
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
|
|
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
|
|
//
|
|
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
|
//
|
|
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
|
// AUTHOR : Gérard Rio
|
|
// E-MAIL : gerardrio56@free.fr
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License,
|
|
// or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
|
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
// See the GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
//
|
|
// For more information, please consult: <https://herezh.irdl.fr/>.
|
|
|
|
|
|
|
|
#include "DdlLim.h"
|
|
#include <fstream>
|
|
#include <sstream>
|
|
#include <cstring>
|
|
|
|
|
|
# include <iostream>
|
|
using namespace std; //introduces namespace std
|
|
#include <stdlib.h>
|
|
#include "Sortie.h"
|
|
#include "ConstMath.h"
|
|
#include "CharUtil.h"
|
|
|
|
|
|
|
|
DdlLim::DdlLim () : // par defaut
|
|
tab(),ref(),t_min(0.),t_max(ConstMath::tresgrand),precedent(false)
|
|
,nom_maillage(NULL),champ(false),blocage_relatif(false),mvtsolide(NULL)
|
|
,nom_fnD_t_min(""),nom_fnD_t_max("")
|
|
,typeCL(RIEN_TYPE_CL)
|
|
{
|
|
};
|
|
|
|
// de copie
|
|
DdlLim::DdlLim (const DdlLim& d) :
|
|
t_min(d.t_min),t_max(d.t_max),ref(d.ref),tab(d.tab),precedent(d.precedent)
|
|
,nom_maillage(NULL),champ(d.champ),blocage_relatif(d.blocage_relatif)
|
|
,mvtsolide(NULL),typeCL(d.typeCL)
|
|
,nom_fnD_t_min(d.nom_fnD_t_min)
|
|
,nom_fnD_t_max(d.nom_fnD_t_max)
|
|
// Constructeur de copie
|
|
{ if (d.nom_maillage != NULL) nom_maillage = new string(*(d.nom_maillage));
|
|
if (d.mvtsolide != NULL)
|
|
mvtsolide = new MvtSolide(*(d.mvtsolide));
|
|
};
|
|
|
|
DdlLim::~DdlLim ()
|
|
// Destructeur
|
|
{ if (nom_maillage != NULL) delete nom_maillage;
|
|
if (mvtsolide != NULL) delete mvtsolide;
|
|
};
|
|
|
|
// Remplace la reference par nouveau
|
|
// ATTENTION : Les modifications liees au changement de la reference
|
|
// sont a la charge de l'utilisateur.
|
|
void DdlLim::Change_ref (string nouveau)
|
|
{ if (nouveau.length() == 0)
|
|
{ cout << "\nErreur : reference non valide car de longueur nulle !\n";
|
|
cout << "DdlLim::CHANGE_REF(string ) \n";
|
|
Sortie(1);
|
|
}
|
|
ref = nouveau;
|
|
};
|
|
|
|
// idem pour le changement de nom de maillage
|
|
void DdlLim::Change_nom_maillage(const string& nouveau)
|
|
{ if (nouveau.length() == 0)
|
|
{ cout << "\nErreur : reference de nom de maillage non valide car de longueur nulle ! "
|
|
<< " nom_mail= " << nouveau << "\n";
|
|
cout << "DdlLim::Change_nom_maillage(....) \n";
|
|
Sortie(1);
|
|
}
|
|
if (nom_maillage == NULL)
|
|
{ nom_maillage = new string(nouveau);}
|
|
else
|
|
{ *nom_maillage = nouveau;};
|
|
};
|
|
|
|
// lecture des degres de liberte
|
|
// sur le fichier d'entree
|
|
// util pour la lecture de ddl bloque
|
|
void DdlLim::Lecture(UtilLecture & entreePrinc)
|
|
{ // on regarde tout d'abord si il y a un nom de maillage, qui doit être le premier nom
|
|
string nom;
|
|
*(entreePrinc.entree) >> nom;
|
|
if (nom == "nom_mail=")
|
|
{ // cas où il y a un nom de maillage
|
|
*(entreePrinc.entree) >> nom; // lecture du nom
|
|
if (nom_maillage == NULL) { nom_maillage = new string(nom);}
|
|
else { *nom_maillage = nom;};
|
|
// puis on prépare la suite en lisant la référence
|
|
*(entreePrinc.entree) >> nom;
|
|
}
|
|
// lecture de la reference
|
|
char tat[250]; char * ta = tat; char tt[100]; char * t = tt;
|
|
char ch = '\''; char * pt = & ch; char bl = ' '; char* pbl = &bl;
|
|
ref = nom; // *(entreePrinc.entree) >> ref;
|
|
if (ref.length() == 0)
|
|
{ // pas de reference
|
|
cout << "\n erreur de lecture d'une reference de ddl bloquee "
|
|
<< " la chaine a une longueur nulle \n";
|
|
entreePrinc.MessageBuffer("*** lecture d'une reference de ddl bloquee ****" );
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
}
|
|
// def de la liste de ddl
|
|
list <Ddlbloque> lili;
|
|
// on regarde si un type de condition limite est indiqué
|
|
if (strstr(entreePrinc.tablcar,"typeCL_=")!=NULL)
|
|
{ string mot;
|
|
*(entreePrinc.entree) >> mot ;
|
|
if (mot != "typeCL_=")
|
|
{ cout << "\n erreur de lecture d'une reference "
|
|
<< " on s'attandait a lire le mot cle : typeCL_= et on a lue: " << mot << " \n";
|
|
entreePrinc.MessageBuffer("*** lecture d'une reference de ddl bloquee: mot cle typeCL_= ****" );
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
// sinon c'est ok pour le mot cle, on passe au contenu,
|
|
*(entreePrinc.entree) >> mot;
|
|
if (Existe_typeCL(mot))
|
|
{ typeCL = Id_nomTypeCL(mot);} // cas ou le type de cl existe
|
|
else
|
|
{ cout << "\n erreur de lecture d'un type de condition limite "
|
|
<< " on a lue: " << mot << " \n";
|
|
entreePrinc.MessageBuffer("*** lecture d'une reference de ddl bloquee: type de CL ****" );
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
}
|
|
else // sinon on précise qu'il n'y a pas de type de CL particulier
|
|
{ typeCL = RIEN_TYPE_CL; };
|
|
|
|
// maintenant les cas particulier
|
|
if (strstr(entreePrinc.tablcar,"champ_de:")!=NULL)
|
|
// on regarde si c'est un champ de valeur c'est-à-dire une valeur par noeud de la ref
|
|
// dans ce cas appel de la procédure a doc
|
|
{ lili = Lecture_champ(entreePrinc); champ = true;}
|
|
else if (strstr(entreePrinc.tablcar,MvtSolide::MotCleMvtSolide().c_str())!=NULL)
|
|
// on regarde si c'est un mouvement solide, si oui appel de la procédure a doc
|
|
{ // petite vérif: incompatible avec la condition de tangente imposée
|
|
if (typeCL == TANGENTE_CL)
|
|
{cout << "\n erreur en lecture, la condition de mouvement solide est incompatible "
|
|
<< " avec une condition de tangente imposée !!! revoir l'entree de la "
|
|
<< " condition " ;
|
|
cout << "\n DdlLim::Lecture(.. " << endl ;
|
|
entreePrinc.MessageBuffer("**erreur**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
lili = Lecture_mvtSolide(entreePrinc); champ = false ;
|
|
}
|
|
else
|
|
{champ = false;
|
|
// --- dans la suite comme il ne s'agit pas d'un champ toutes les données sont sur une seule ligne -----
|
|
//recup de la fin de la ligne
|
|
char tout[150] ; char * ptout = tout;
|
|
(entreePrinc.entree)->get(ptout,150);
|
|
// avant la lecture on remplace toutes les virgules par des espaces
|
|
char * ii = strchr(ptout,',');
|
|
while (ii != NULL)
|
|
{ *ii = ' ';
|
|
ii = strchr(ptout,',');
|
|
}
|
|
// def d'un flot intermédiaire
|
|
#ifndef ENLINUX_STREAM
|
|
istringstream flot(ptout);
|
|
#else
|
|
istrstream flot(ptout);
|
|
#endif
|
|
|
|
// lecture tant que le flot est valide
|
|
while (flot.rdstate() == 0)
|
|
// tout d'abord on passe les espaces qui sont des séparateurs
|
|
// lecture du prochain caractère sans modifier le flot
|
|
{ char car;
|
|
flot >> car;
|
|
// éventuellement il n'avait pas bien déterminé la fin de l'enregistrement
|
|
// au niveau du while, dans ce cas si durant la lecture de car il y a eu un pb
|
|
// cela signifie qu'en fait la ligne était terminée donc on s'arrête
|
|
if (flot.rdstate() != 0) break;
|
|
while ( (car==' ') && (flot.rdstate() == 0 ))
|
|
// cas où le prochain caractère est un espace
|
|
{ flot >> car;};
|
|
flot.putback(car);
|
|
bool un_ddl_a_lire=true;
|
|
// on démarre une boucle qui se termine lorsqu'il n'y a plus de ddl à lire
|
|
while(un_ddl_a_lire)
|
|
{// on définit un ddl pour la lecture
|
|
Ddlbloque elem;
|
|
// deux cas, soit un ddl nulle par defaut, soit une valeur non nulle imposee
|
|
// soit le caractère est ' , signifie que c'est un ddl avec une valeur
|
|
// imposée
|
|
if ( (car=='\'') && (flot.rdstate() == 0 ))
|
|
{ // on passe le premier '
|
|
flot >> car;
|
|
// on lit jusqu'au prochain ' en non formaté
|
|
flot.get(ta,150,'\'');
|
|
// on passe ce dernier '
|
|
flot >> car;
|
|
// on recherche le = pour mettre un blanc a la place
|
|
char * ii = strchr(ta,'\'');char * pii=ii; // sauvegarde de l'adresse
|
|
ii = strchr(ta,'='); // on recherche le =
|
|
if (ii == NULL)
|
|
{ cout << "\n erreur de syntaxe dans la definition des conditions limites "
|
|
<< " imposees a une valeur non nulle ";
|
|
cout << " le ddl doit etre separe de la valeur par le signe = , caractere non"
|
|
<< " trouve ";
|
|
entreePrinc.MessageBuffer("*** lecture d'une reference de ddl bloquee ****" );
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
*ii = ' '; // supprime le =
|
|
// def d'un flux intermediaire
|
|
#ifndef ENLINUX_STREAM
|
|
istringstream flux (ta);
|
|
#else
|
|
istrstream flux (ta);
|
|
#endif
|
|
|
|
flux >> t ;
|
|
elem.ddl.Change_nom(t);
|
|
// on vérifie que le ddl est compatible avec la dimension
|
|
if (!CompatDim(t))
|
|
{ cout << "\n erreur de choix de ddl dans la definition des conditions limites "
|
|
<< " le ddl " << t << " n'est pas compatible avec la dimension du probleme ";
|
|
entreePrinc.MessageBuffer("*** lecture d'une reference de ddl bloquee ****" );
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
|
|
// on regarde s'il ne s'agit pas d'une courbe ou fonction de charge imposée
|
|
bool sans_courbe_ou_fct_nD=true; // variable locale
|
|
// l'ordre d'apparition de la courbe de charge ou de la fonction nD peut être
|
|
// quelconque
|
|
if ((strstr(ta,"COURBE_CHARGE:")!=0)|| (strstr(ta,"Fonction_nD_CHARGE:")!=0))
|
|
{string nom_fonct;string nom_cle;
|
|
flux >> nom_cle >> nom_fonct;
|
|
// a) cas d'une courbe
|
|
if(nom_cle == "COURBE_CHARGE:")
|
|
{ // cas d'une courbe de charge
|
|
// flux >> toto >> elem.co_charge;
|
|
elem.co_charge = nom_fonct;
|
|
sans_courbe_ou_fct_nD=false;
|
|
// on regarde s'il y a une fct nD qui suit
|
|
if(strstr(ta,"Fonction_nD_CHARGE:")!=0)
|
|
{ // cas d'une fonction nD
|
|
string toto;
|
|
flux >> toto >> elem.f_charge;
|
|
// on vérifie la présence au bon endroit du mot clé Fonction_nD_CHARGE:
|
|
if (toto != "Fonction_nD_CHARGE:")
|
|
{cout << "\n erreur de syntaxe en lecture du nom de la fonction nD ";
|
|
cout << " on attendait Fonction_nD_CHARGE: "
|
|
<< " et on a lu "<< toto;
|
|
cout << "\n DdlLim::Lecture(.. " << endl ;
|
|
entreePrinc.MessageBuffer("**erreur**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
};
|
|
}
|
|
else if (nom_cle == "Fonction_nD_CHARGE:")
|
|
{ elem.f_charge = nom_fonct;
|
|
sans_courbe_ou_fct_nD=false;
|
|
// on regarde s'il y a une courbe 1D qui suit
|
|
if(strstr(ta,"COURBE_CHARGE:")!=0)
|
|
{ // cas d'une courbe de charge
|
|
string toto;
|
|
flux >> toto >> elem.co_charge;
|
|
elem.co_charge = nom_fonct;
|
|
// on vérifie la présence au bon endroit du mot clé Fonction_nD_CHARGE:
|
|
if (toto != "COURBE_CHARGE:")
|
|
{cout << "\n erreur de syntaxe en lecture du nom de la courbe ";
|
|
cout << " on attendait COURBE_CHARGE: "
|
|
<< " et on a lu "<< toto;
|
|
cout << "\n DdlLim::Lecture(.. " << endl ;
|
|
entreePrinc.MessageBuffer("**erreur**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
};
|
|
}
|
|
else
|
|
{cout << "\n erreur de syntaxe en lecture du nom de la courbe ou du nom d'une fonction nD";
|
|
cout << " on attendait COURBE_CHARGE: ou Fonction_nD_CHARGE: "
|
|
<< " et on a lu "<< nom_cle;
|
|
cout << "\n DdlLim::Lecture(.. " << endl ;
|
|
entreePrinc.MessageBuffer("**erreur**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
// on récupère l'échelle éventuellement
|
|
if(strstr(ta,"ECHELLE:")!=0)
|
|
{ // cas où il y a un facteur d'échelle
|
|
string toto;
|
|
flux >> toto;
|
|
if (toto != "ECHELLE:")
|
|
{cout << "\n erreur de syntaxe en lecture du facteur d'échelle ";
|
|
cout << "\n DdlLim::Lecture(.. " << endl ;
|
|
entreePrinc.MessageBuffer("**erreur**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
// lecture du facteur
|
|
flux >> elem.echelle;
|
|
};
|
|
};
|
|
// // b) cas d'une fonction nD
|
|
// if(strstr(ta,"Fonction_nD_CHARGE:")!=0)
|
|
// { // cas d'une fonction nD
|
|
// string toto;
|
|
// flux >> toto >> elem.f_charge;
|
|
// sans_courbe_ou_fct_nD=false;
|
|
// // on vérifie la présence au bon endroit du mot clé Fonction_nD_CHARGE:
|
|
// if (toto != "Fonction_nD_CHARGE:")
|
|
// {cout << "\n erreur de syntaxe en lecture du nom de la fonction nD ";
|
|
// cout << "\n DdlLim::Lecture(.. " << endl ;
|
|
// entreePrinc.MessageBuffer("**erreur**");
|
|
// throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
// Sortie(1);
|
|
// };
|
|
// };
|
|
|
|
// si aucune courbe ou fct nD
|
|
if (sans_courbe_ou_fct_nD)
|
|
// cas où c'est une valeur fixe
|
|
{
|
|
flux >> elem.ddl.Valeur();
|
|
}
|
|
elem.ddl.Change_fixe (true);
|
|
}
|
|
else if (flot.rdstate() == 0 ) // il s'agit d'un ddl à 0
|
|
{ //un ddl nulle par defaut
|
|
flot >> t;
|
|
// on vérifie que c'est bien un ddl
|
|
if (!ExisteEnum_ddl(t))
|
|
{ cout << "\n erreur , on s'attendait a lire un ddl et on a lue: " << t
|
|
<< " !!, partie de condition actuellement lue: ";
|
|
this->Affiche();
|
|
cout << " DdlLim::Lecture(UtilLecture & entreePrinc)" << endl;
|
|
entreePrinc.MessageBuffer("** erreur en lecture des conditions limites**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie (1);
|
|
};
|
|
elem.ddl.Change_nom(t);
|
|
elem.ddl.Valeur() = 0;
|
|
elem.ddl.Change_fixe (true);
|
|
};
|
|
// on verifie que l'on n'utilise pas deux fois le meme identificateur de ddl
|
|
// avec deux valeurs differentes
|
|
list <Ddlbloque>::iterator imi;
|
|
for (imi=lili.begin() ; imi != lili.end(); imi++)
|
|
if (((*imi).ddl.Id_nom() == elem.ddl.Id_nom()) && ((*imi).ddl.Valeur() != elem.ddl.Valeur()))
|
|
{ cout << "\n erreur , un meme identificateur de ddl est utilisee avec"
|
|
<< " deux valeurs differentes \n";
|
|
cout << " premiere Ddl : "; (*imi).ddl.Affiche();
|
|
cout << " seconde Ddl : "; elem.ddl.Affiche();
|
|
cout << " DdlLim::Lecture(UtilLecture & entreePrinc)" << endl;
|
|
entreePrinc.MessageBuffer("** erreur en lecture des conditions limites**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie (1);
|
|
}
|
|
// stockage du ddl bloque
|
|
lili.push_back(elem);
|
|
// --- maintenant on regarde si on a encore d'autre ddl à lire
|
|
// 1- on passe les blancs
|
|
flot >> car;
|
|
while ( (car==' ') && (flot.rdstate() == 0 ))
|
|
// cas où le prochain caractère est un espace
|
|
{ flot >> car;}
|
|
flot.putback(car);
|
|
// on enregistre la position actuelle dans le flot au premier caractère non nul
|
|
streampos posi=flot.tellg();
|
|
// maintenant on regarde s'il reste un ddl à lire
|
|
// en ayant passé éventuellement le caractère ', on regarde s'il s'agit
|
|
// d'un énum de ddl
|
|
// manip pour passer le caractère '
|
|
flot >> car; // lecture du prochain caractère
|
|
if (flot.rdstate() == 0 )
|
|
{ // s'il ne s'agit pas de ' on le remet dans le flot
|
|
if (!(car=='\'')) flot.putback(car);
|
|
// maintenant on lit la chaine
|
|
string ddnom;
|
|
flot >> ddnom; // lecture de la chaine
|
|
// on cherche s'il y a éventuellement un signe =, si oui
|
|
// on supprime le signe = et tout ce qui suit
|
|
string::iterator ala,alafin=ddnom.end();
|
|
for (ala=ddnom.begin();ala!=alafin;ala++)
|
|
if (*ala == '=')
|
|
{ ddnom.erase(ala,alafin);
|
|
break;
|
|
};
|
|
// est-ce que c'est un enum de ddl
|
|
if (ExisteEnum_ddl(ddnom))
|
|
{un_ddl_a_lire=true;
|
|
flot.clear(); // on remet ok le flot au cas où on avait été jusqu'au bout à la
|
|
} // dernière lecture par exemple, car de toute manière on va relire
|
|
else {un_ddl_a_lire=false;};
|
|
}
|
|
else {un_ddl_a_lire=false;}; // sinon fin
|
|
// retour avant la lecture du futur ddl éventuel
|
|
flot.seekg(posi, ios::beg);
|
|
// on prépare le prochain caractère
|
|
flot >> car;
|
|
flot.putback(car);
|
|
|
|
}; //-- fin de while(un_ddl_a_lire)
|
|
|
|
// --- lecture éventuelle des temp mini et maxi ---
|
|
if (((!flot.rdstate())&& (!(flot.eof())))) // lecture s'il n'y a pas d'erreur
|
|
{if(strstr(ptout,"TEMPS_MINI=") != 0)
|
|
{ // cas d'un temps mini
|
|
string toto;
|
|
flot >> toto;
|
|
// on vérifie la présence au bon endroit du mot clé TEMPS_MINI=
|
|
if (toto != "TEMPS_MINI=")
|
|
{cout << "\n erreur de syntaxe en lecture du temps mini, info lue: " << toto;
|
|
cout << "\n DdlLim::Lecture(.. " << endl ;
|
|
entreePrinc.MessageBuffer("**erreur**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
}
|
|
//lecture du temps mini
|
|
string nomOuNombre;
|
|
flot >> nomOuNombre;
|
|
if (nomOuNombre != "fct_nD:")
|
|
{t_min = ChangeReel(nomOuNombre);
|
|
nom_fnD_t_min = "";
|
|
}
|
|
else
|
|
{flot >> nom_fnD_t_min;};
|
|
}
|
|
};
|
|
if (((!flot.rdstate())&& (!(flot.eof())))) // lecture s'il n'y a pas d'erreur
|
|
{if(strstr(ptout,"TEMPS_MAXI=") != 0)
|
|
{ // cas d'un temps maxi
|
|
string toto;
|
|
flot >> toto;
|
|
// on vérifie la présence au bon endroit du mot clé TEMPS_MAXI=
|
|
if (toto != "TEMPS_MAXI=")
|
|
{cout << "\n erreur de syntaxe en lecture du temps maxi ";
|
|
cout << "\n DdlLim::Lecture(.. " << endl ;
|
|
entreePrinc.MessageBuffer("**erreur**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
}
|
|
//lecture du temps maxi
|
|
string nomOuNombre;
|
|
flot >> nomOuNombre;
|
|
if (nomOuNombre != "fct_nD:")
|
|
{t_max = ChangeReel(nomOuNombre);
|
|
nom_fnD_t_max = "";
|
|
}
|
|
else
|
|
{flot >> nom_fnD_t_max;};
|
|
}
|
|
};
|
|
// lecture éventuel de l'indicateur de blocage "relatif"
|
|
if (((!flot.rdstate())&& (!(flot.eof())))) // lecture s'il n'y a pas d'erreur
|
|
if(strstr(ptout,"BLOCAGE_RELATIF_") != 0)
|
|
{ string toto; flot >> toto; // on passe le mot clé
|
|
blocage_relatif = true;
|
|
// message d'avertissement éventuel
|
|
int taille_tab = tab.Taille();
|
|
bool queDesCourbesDeCharge = true;
|
|
for (int i=1; i<= taille_tab; i++) // on regarde s'il y n'y a que des courbes de charge
|
|
if (tab(i).co_charge == "")
|
|
{ queDesCourbesDeCharge = false;} ;
|
|
if (!queDesCourbesDeCharge)
|
|
{ // cas où il n'y a au moins un ddl sans courbe de charge
|
|
cout << "\n **** Warning !!! le blocage relatif ne fonctionne pas avec des blocages simples "
|
|
<< " le blocage relatif ne fonctionne qu'avec les ddls soumis a une courbe de charge ";
|
|
};
|
|
};
|
|
|
|
} // -- fin de lecture tant que le flot est valide
|
|
}//-- fin du test sur existence de champ ou pas
|
|
// enregistrement des infos
|
|
tab.Change_taille((int) lili.size());
|
|
list <Ddlbloque>::iterator i;
|
|
int j;
|
|
for (i=lili.begin(),j=1 ; i != lili.end(); i++,j++)
|
|
tab(j) = *i;
|
|
// dans le cas où il s'agit d'une condition de tangente imposée, il faut que
|
|
// le nombre de ddl = la dimension de l'espace, car la condition représente un vecteur
|
|
if (typeCL == TANGENTE_CL)
|
|
if (tab.Taille() != ParaGlob::Dimension())
|
|
{cout << "\n erreur en lecture d'une condition de tangente imposée, "
|
|
<< " le nombre de dd (ici = " << tab.Taille() << ") doit etre egale a la dimension"
|
|
<< " de l'espace (ici = " << ParaGlob::Dimension()<<") ";
|
|
cout << "\n DdlLim::Lecture(.. " << endl ;
|
|
entreePrinc.MessageBuffer("**erreur**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
// verification en fonction de la dimension du pb
|
|
// VerifDimDdl();
|
|
|
|
};
|
|
|
|
// examine si le ddlmin passé en argument possède les mêmes cibles que this
|
|
// c'est-à-dire s'il y a une intersection incohérente entre les deux tableaux de ddl de base
|
|
// ramène true s'il y a une intersection incohérente non nulle, false sinon
|
|
bool DdlLim::MemeCibleMaisDataDifferents(const DdlLim& d) const
|
|
{ // l'opération est malheureusement combinatoire (en N^2) à moins de classer les ddlm
|
|
// mais pour l'instant ce n'est pas fait, je ne suis pas sûr que ici le temps soit un pb
|
|
bool incoherence = false;
|
|
|
|
int tailtab = tab.Taille();
|
|
int tailtabex = d.Taille();
|
|
for (int i=1; i<= tailtab; i++)
|
|
for (int j=1; j<= tailtabex; j++)
|
|
if (tab(i).ddl.Id_nom() == d.ElemLim_const(j).Id_nom())
|
|
if (tab(i).ddl != d.ElemLim_const(j))
|
|
// si on a deux même noms de ddl et le reste qui n'est pas identique --> incohérence
|
|
incoherence = true;
|
|
// retour
|
|
return incoherence;
|
|
};
|
|
|
|
// ramène true si le DdlLim contient l'enum_ddl passé en argument, false sinon
|
|
bool DdlLim::Existe_ici_leDdl(Enum_ddl enu) const
|
|
{ // on passe en revue le tableau de ddl
|
|
int taille = tab.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
if (tab(i).ddl.Id_nom() == enu)
|
|
return true;
|
|
// si on arrive ici, c'est que l'on n'a rien trouvé !
|
|
return false;
|
|
};
|
|
|
|
// ramène true si le DdlLim contient au moins un déplacement, false sinon
|
|
bool DdlLim::Existe_ici_un_deplacement() const
|
|
{ // on passe en revue le tableau de ddl
|
|
int taille = tab.Taille();
|
|
for (int i=1;i<=taille;i++)
|
|
{switch (ParaGlob::Dimension())
|
|
{case 3: if (tab(i).ddl.Id_nom() == UZ)
|
|
return true;
|
|
case 2: if (tab(i).ddl.Id_nom() == UY)
|
|
return true;
|
|
case 1: if (tab(i).ddl.Id_nom() == UX)
|
|
return true;
|
|
};
|
|
};
|
|
// si on arrive ici, c'est que l'on n'a rien trouvé !
|
|
return false;
|
|
};
|
|
|
|
// Affiche les donnees liees au degre de liberte
|
|
void DdlLim::Affiche () const
|
|
{ // affichage éventuelle du nom de maillage
|
|
if (nom_maillage != NULL)
|
|
{ cout << "\n nom_mail= " << *nom_maillage;} else cout << "\n";
|
|
// affichage éventuelle du type de CL
|
|
if (typeCL != RIEN_TYPE_CL)
|
|
{ cout << "type_de_CL= " << NomTypeCL(typeCL);};
|
|
// puis le reste
|
|
if (champ)
|
|
{cout << " ref_de_champ= " << ref << ':';}
|
|
else if (mvtsolide != NULL)
|
|
{mvtsolide->Affiche();}
|
|
else
|
|
{cout << " ref= " << ref << ':';};
|
|
for (int i=1; i<= tab.Taille();i++)
|
|
{ (tab(i).ddl).Affiche();
|
|
if (tab(i).co_charge != "")
|
|
cout << " courbe_de_charge= " << (tab(i)).co_charge << " echelle= " << (tab(i)).echelle;
|
|
if (tab(i).f_charge != "")
|
|
cout << " fonction_nD_de_charge= " << (tab(i)).f_charge << " ";
|
|
cout << " temps_mini= ";
|
|
if (nom_fnD_t_min == "")
|
|
{cout << t_min;}
|
|
else {cout << " fct_nD: " << nom_fnD_t_min ;};
|
|
cout << " temps_maxi= ";
|
|
if (nom_fnD_t_max == "")
|
|
{cout << t_max;}
|
|
else {cout << " fct_nD: " << nom_fnD_t_max ;};
|
|
cout << " activité_actuelle: " << precedent;
|
|
cout << " blocage_relatif_ " << blocage_relatif << " ";
|
|
};
|
|
cout << endl;
|
|
};
|
|
|
|
|
|
// Realise l'egalite entre deux degres de liberte
|
|
DdlLim& DdlLim::operator= (const DdlLim& d)
|
|
{ if (d.nom_maillage == NULL)
|
|
{ if (nom_maillage != NULL) {delete nom_maillage;nom_maillage = NULL;}}
|
|
else
|
|
{ if (nom_maillage == NULL) nom_maillage = new string(*(d.nom_maillage));
|
|
else *nom_maillage = *(d.nom_maillage);
|
|
};
|
|
typeCL = d.typeCL;
|
|
ref=d.ref;
|
|
tab = d.tab;
|
|
nom_fnD_t_min = d.nom_fnD_t_min ;
|
|
nom_fnD_t_max = d.nom_fnD_t_max ;
|
|
t_min = d.t_min;
|
|
t_max = d.t_max;
|
|
precedent = d.precedent;
|
|
champ = d.champ;
|
|
blocage_relatif = d.blocage_relatif;
|
|
if (d.mvtsolide != NULL)
|
|
{ if (mvtsolide == NULL)
|
|
{ mvtsolide = new MvtSolide(*(d.mvtsolide));}
|
|
else
|
|
{ (*mvtsolide) = *(d.mvtsolide);};
|
|
}
|
|
else // cas où d.mvtsolide est null
|
|
{ if (mvtsolide != NULL)
|
|
{delete mvtsolide;mvtsolide = NULL;};
|
|
};
|
|
return (*this);
|
|
};
|
|
|
|
//Surcharge d'operateur logique
|
|
bool DdlLim::operator == (const DdlLim& a) const
|
|
{ if (nom_maillage == NULL)
|
|
{ if (a.nom_maillage != NULL) return false;
|
|
}
|
|
else
|
|
{ if (a.nom_maillage == NULL) return false;
|
|
// sinon les deux sont non null: on test leur égalité
|
|
if (*nom_maillage != *(a.nom_maillage)) return false;
|
|
};
|
|
// maintenant on regarde les autres données
|
|
if (typeCL != a.typeCL) return false;
|
|
// 1) traitement du cas des mouvements solides
|
|
bool apriorivrai = true;
|
|
if (a.mvtsolide != NULL)
|
|
{ if (mvtsolide == NULL)
|
|
{ //apriorivrai = false;
|
|
return false; } // on arrete tout de suite
|
|
else
|
|
{ apriorivrai = ((*mvtsolide) == *(a.mvtsolide));};
|
|
};
|
|
// 2) traitement du rest
|
|
if (( ref==a.ref) && (tab==a.tab)
|
|
&& (t_min == a.t_min) && (t_max == a.t_max)
|
|
&& (nom_fnD_t_min == a.nom_fnD_t_min)
|
|
&& (nom_fnD_t_max == a.nom_fnD_t_max)
|
|
&& (precedent == a.precedent)
|
|
&& (champ == a.champ) && (blocage_relatif == a.blocage_relatif)
|
|
&& apriorivrai)
|
|
return true;
|
|
else return false;
|
|
};
|
|
|
|
// surcharge de l'operateur de lecture typée
|
|
istream & operator >> (istream & entree, DdlLim & dlim)
|
|
{ // vérification du type
|
|
string type;
|
|
entree >> type;
|
|
if (type == "DdlLim") {dlim.champ = false;}
|
|
else if (type == "DdlLim_de_champ") {dlim.champ = true;}
|
|
else
|
|
{cout << "\n erreur en lecture d'un DdlLim ";
|
|
Sortie (1);
|
|
return entree;
|
|
}
|
|
// lecture d'un nom de maillage éventuel
|
|
bool existe_nom_maillage; entree >> existe_nom_maillage;
|
|
string nom;
|
|
if (existe_nom_maillage)
|
|
{ entree >> nom;
|
|
if (dlim.nom_maillage == NULL)
|
|
dlim.nom_maillage = new string(nom);
|
|
else
|
|
*(dlim.nom_maillage) = nom;
|
|
};
|
|
// passage du nom de la référence puis le type de cl puis du tableau
|
|
entree >> dlim.ref >> nom;
|
|
dlim.typeCL = Id_nomTypeCL(nom);
|
|
entree >> dlim.tab >> nom >> dlim.t_min >> nom >> dlim.t_max >> nom >> dlim.precedent;
|
|
entree >> nom >> dlim.blocage_relatif;
|
|
// mouvement solide éventuel
|
|
int iii=0;
|
|
entree >> iii;
|
|
if (iii == 0) // indique qu'il n'y a pas de mouvement solide
|
|
{if (dlim.mvtsolide != NULL) // on supprime le mouvement solide s'il en existait un
|
|
{delete dlim.mvtsolide;dlim.mvtsolide=NULL;};
|
|
}
|
|
else // cas d'un mouvement solide
|
|
{ if (dlim.mvtsolide != NULL) // création s'il n'y en avait pas
|
|
dlim.mvtsolide = new MvtSolide();
|
|
entree >> *(dlim.mvtsolide); // lecture du mouvement solide
|
|
};
|
|
|
|
return entree;
|
|
};
|
|
|
|
// surcharge de l'operateur d'ecriture typée
|
|
ostream & operator << ( ostream & sort,const DdlLim & dlim)
|
|
{ // tout d'abord un indicateur donnant le type
|
|
if (dlim.champ)
|
|
{sort << "DdlLim_de_champ ";}
|
|
else
|
|
{sort << "DdlLim ";};
|
|
// puis le maillage éventuelle
|
|
if (dlim.nom_maillage == NULL)
|
|
sort << false << " ";
|
|
else
|
|
sort << true << " " << *(dlim.nom_maillage) << " ";
|
|
// maintenant la référence
|
|
sort << dlim.ref << " ";
|
|
// le type de condition limite
|
|
sort << NomTypeCL(dlim.typeCL) << " ";
|
|
// puis les data
|
|
sort << dlim.tab;
|
|
sort << " tmin= " << dlim.t_min << " tmax= " << dlim.t_max << " prec " << dlim.precedent;
|
|
sort << " blocage_relatif= " << dlim.blocage_relatif;
|
|
// mouvement solide éventuel
|
|
if (dlim.mvtsolide == NULL)
|
|
{ sort << " 0 ";}
|
|
else
|
|
{ sort << " 1 " << (*(dlim.mvtsolide)) << " ";};
|
|
sort << "\n";
|
|
return sort;
|
|
};
|
|
|
|
// affichage et definition interactive des commandes
|
|
void DdlLim::Info_commande_DdlLim(ofstream & sort,bool plusieurs_maillages)
|
|
{ //On va proposer un menu
|
|
string rep=" ";
|
|
string nom_courbe="_";
|
|
string nom_fonction_nD="_";
|
|
double echelle = ConstMath::trespetit;
|
|
double temps_mini = - ConstMath::trespetit;
|
|
double temps_maxi = ConstMath::tresgrand;
|
|
// tableau des choix possibles
|
|
Tableau <string> tab_choix(16);
|
|
tab_choix(1) = "\n (0 ou f) (defaut) (fin) ";
|
|
tab_choix(2) = "\n (1) choix d'un deplacement impose ";
|
|
tab_choix(3) = "\n (2) ou autre ddl impose ";
|
|
tab_choix(4) = "\n (3) valeur du ddl ? ";
|
|
tab_choix(5) = "\n (4) ou utilisation d'une courbe de charge ";
|
|
tab_choix(6) = "\n (5) echelle ";
|
|
tab_choix(7) = "\n (6) temps mini ";
|
|
tab_choix(8) = "\n (7) temps maxi ";
|
|
tab_choix(9) = "\n (8) blocage relatif ";
|
|
tab_choix(10) = "\n (9) condition de tangence ";
|
|
tab_choix(11) = "\n (10) mouvement solide impose ";
|
|
tab_choix(12) = "\n (11) champ de valeurs ";
|
|
tab_choix(13) = "\n (12) liste de ddl existant ";
|
|
tab_choix(14) = "\n (13 ou ? ) information ";
|
|
tab_choix(15) = "\n (14) plusieurs ddl de deplacement, nuls ";
|
|
tab_choix(16) = "\n (15) utilisation d'une fonction nD de charge ";
|
|
// tableau d'indexage pour limiter les choix
|
|
int choix=1; // type de choix: ici le cas choix d'un ddl de depart
|
|
Tableau <int> index(9);
|
|
index(1) = 1; index(2) = 2; index(3) = 3;index(4) = 10;index(5) = 11;
|
|
index(6) = 12; index(7) = 13; index(8) =14;index(9) =15;
|
|
string nom_des_ddl="";
|
|
bool blocage_relatif =false; // par défaut
|
|
double valeur_du_ddl = 0.;
|
|
bool plusieurs_ddl_deplacement_nul = false;
|
|
string nom_ref="";
|
|
string condition_tangence="";
|
|
bool condition_mvt_solide=false;
|
|
ostringstream flux;
|
|
bool champ_valeurs=false;
|
|
string str_champ_valeurs="";
|
|
|
|
|
|
while ((Minuscules(rep) != "f")&&(Minuscules(rep) != "0"))
|
|
{
|
|
try
|
|
{ for (int i=1;i<=index.Taille();i++)
|
|
cout << tab_choix(index(i));
|
|
cout << "\n reponse ? ";
|
|
rep = lect_return_defaut(false,"0"); cout << " grandeur lue " << rep;
|
|
if ((Minuscules(rep) == "f") || (Minuscules(rep) == "0"))// sortie
|
|
// c'est à la sortie que ce fait l'écriture donc ici
|
|
{sort << "\n";
|
|
if ((nom_des_ddl=="")&&(condition_tangence =="")&&(!condition_mvt_solide)
|
|
&&(!champ_valeurs))
|
|
break; // arrêt s'il n'y a pas eu de choix
|
|
if (plusieurs_maillages)
|
|
{ cout << "\n nom du maillage ? ";
|
|
string nom_mail;
|
|
nom_mail= lect_chaine(); cout << " nom lu = "<< nom_mail;
|
|
sort << "nom_mail= "<< nom_mail << " ";
|
|
};
|
|
sort << nom_ref <<" ";
|
|
// ici plusieurs cas
|
|
if ((condition_tangence =="")&&(!condition_mvt_solide)&&(!champ_valeurs))
|
|
{ // cas normal
|
|
bool sortie_cote=false;
|
|
if (((valeur_du_ddl != 0.)||(nom_courbe != "_")
|
|
|| (nom_fonction_nD != "_"))
|
|
&& (!plusieurs_ddl_deplacement_nul))
|
|
{sort << " ' ";sortie_cote=true;};
|
|
sort << nom_des_ddl ;
|
|
if (sortie_cote) sort <<"= ";
|
|
if (!plusieurs_ddl_deplacement_nul)
|
|
{if (nom_courbe != "_")
|
|
{sort << " COURBE_CHARGE: "<<nom_courbe<<" ";}
|
|
else if (sortie_cote == true)
|
|
{sort << valeur_du_ddl<<" ";};
|
|
if (nom_fonction_nD != "_")
|
|
{sort << " Fonction_nD_CHARGE: "<<nom_fonction_nD<<" ";};
|
|
if (echelle != ConstMath::trespetit)
|
|
sort << " ECHELLE: "<< echelle<<" ";
|
|
if (sortie_cote)
|
|
sort << " ' ";
|
|
};
|
|
}
|
|
else if (condition_mvt_solide)
|
|
{ // cas d'un mouvement solide
|
|
sort << nom_des_ddl ;
|
|
sort <<flux.str();
|
|
if (nom_courbe != "_")
|
|
{sort << " COURBE_CHARGE: "<<nom_courbe<<" ";};
|
|
if (nom_fonction_nD != "_")
|
|
{sort << " Fonction_nD_CHARGE: "<<nom_fonction_nD<<" ";};
|
|
if (echelle != ConstMath::trespetit)
|
|
sort << " ECHELLE: "<< echelle<<" ";
|
|
}
|
|
else if (champ_valeurs)
|
|
{ // cas d'un champ de valeur
|
|
sort << str_champ_valeurs ;
|
|
}
|
|
else // cas d'une condition de tangence
|
|
{ sort << condition_tangence;};
|
|
if (temps_mini != (- ConstMath::trespetit))
|
|
sort << " TEMPS_MINI= "<< temps_mini<<" ";
|
|
if (temps_maxi != ConstMath::tresgrand)
|
|
sort << " TEMPS_MAXI= "<< temps_maxi<<" ";
|
|
if (blocage_relatif)
|
|
sort << " BLOCAGE_RELATIF_ "<<endl;
|
|
break;
|
|
};
|
|
int num = ChangeEntier(rep);
|
|
if (Minuscules(rep) == "?")
|
|
num = 13;
|
|
bool choix_valide=false;
|
|
if ((num >= 0)&&(num<=16))
|
|
{ choix_valide=true; }
|
|
else { cout << "\n Erreur on attendait un entier entre 0 et 16 !!, "
|
|
<< "\n redonnez une bonne valeur"
|
|
<< "\n ou taper f ou 0 pour arreter le programme";
|
|
choix_valide=false;
|
|
}
|
|
switch (num)
|
|
{ case 0: // sortie
|
|
{ break;} // normalement cela a déjà été filtré avant
|
|
case 1: // déplacement imposé
|
|
{ string repi=" ";
|
|
cout << "\n -- choix du ddl -- ";
|
|
switch (ParaGlob::Dimension())
|
|
{case 1: cout << "\n (1) UX "; break;
|
|
case 2: cout << "\n (1) UX "
|
|
<< "\n (2) UY "; break;
|
|
case 3: cout << "\n (1) UX "
|
|
<< "\n (2) UY "
|
|
<< "\n (3) UZ "; break;
|
|
default: cout << " ";
|
|
}; cout << "\n";
|
|
repi=lect_chaine();
|
|
cout << " valeur lue "<<repi;
|
|
if ((repi == "1")) {nom_des_ddl = " UX ";}
|
|
else if ((repi == "2")) {nom_des_ddl = " UY ";}
|
|
else if ((repi == "3")) {nom_des_ddl = " UZ ";}
|
|
else { cout << "\n *** choix non valide !";break;};
|
|
cout << "\n nom de la reference de noeuds associee? ";
|
|
nom_ref= lect_chaine();cout << " nom lu = "<< nom_ref;
|
|
if (nom_ref.at(0) != 'N')
|
|
{cout << "\n *** erreur, la premiere lettre de la ref de noeud "
|
|
<< " doit etre N et non "<< nom_ref.at(0)<< " !!";
|
|
break;
|
|
};
|
|
index.Change_taille(9);
|
|
index(1) = 1; index(2) = 4; index(3) = 5; index(4) = 6;
|
|
index(5) = 7;index(6) = 8;index(7) = 9;index(8) = 14;
|
|
index(9) = 16;
|
|
break;
|
|
}
|
|
case 2: // un ddl autre qu'un déplacement
|
|
{ string repi="";
|
|
cout << "\n nom du ddl ? \n";
|
|
repi=lect_chaine(); cout << " valeur lue "<<repi;
|
|
if (!ExisteEnum_ddl(repi))
|
|
{cout << "\n *** erreur, ce ddl n'existe pas ****";
|
|
break;
|
|
};
|
|
nom_des_ddl = repi;
|
|
cout << "\n nom de la reference de noeuds associee? ";
|
|
nom_ref= lect_chaine();cout << " nom lu = "<< nom_ref;
|
|
if (nom_ref.at(0) != 'N')
|
|
{cout << "\n *** erreur, la premiere lettre de la ref de noeud "
|
|
<< " doit etre N et non "<< nom_ref.at(0)<< " !!";
|
|
break;
|
|
};
|
|
index.Change_taille(9);
|
|
index(1) = 1; index(2) = 4; index(3) = 5; index(4) = 6;
|
|
index(5) = 7;index(6) = 8;index(7) = 9;index(8) = 14;
|
|
index(9) = 16;
|
|
break;
|
|
}
|
|
case 3: // une valeur de ddl
|
|
{ cout << "\n valeur du ddl (un reel) ? ";
|
|
valeur_du_ddl=lect_double();cout << " valeur lue ="<< valeur_du_ddl;
|
|
index.Change_taille(5);
|
|
index(1) = 1; index(2) = 7; index(3) = 8;
|
|
index(4) = 9;index(5) = 14;
|
|
break;
|
|
}
|
|
case 4: // courbe de charge
|
|
{ cout << "\n nom de la courbe de charge ? ";
|
|
nom_courbe= lect_chaine();cout << " nom lu = "<< nom_courbe;
|
|
index.Change_taille(7);
|
|
index(1) = 1;index(2) = 6; index(3) = 7; index(4) = 8;index(5) = 9;
|
|
index(6) = 14;index(7) = 16;
|
|
break;
|
|
}
|
|
case 5: // l'echelle
|
|
{ cout << "\n valeur de l'echelle (un reel) ? ";
|
|
echelle=lect_double();cout << " valeur lue ="<< echelle;
|
|
index.Change_taille(6);
|
|
index(1) = 1;index(2) = 7; index(3) = 8; index(4) = 9;index(5) = 14;
|
|
index(6) = 16;
|
|
break;
|
|
}
|
|
case 6: // temps mini
|
|
{ cout << "\n valeur du temps mini (un reel) ? ";
|
|
temps_mini=lect_double();cout << " valeur lue ="<< temps_mini;
|
|
index.Change_taille(5);
|
|
index(1) = 1;index(2) = 7; index(3) = 8; index(4) = 9;index(5) = 14;
|
|
break;
|
|
}
|
|
case 7: // temps maxi
|
|
{ cout << "\n valeur du temps maxi (un reel) ? ";
|
|
temps_maxi=lect_double();cout << " valeur lue ="<< temps_maxi;
|
|
index.Change_taille(5);
|
|
index(1) = 1;index(2) = 7; index(3) = 8; index(4) = 9;index(5) = 14;
|
|
break;
|
|
}
|
|
case 8: // blocage relatif
|
|
{cout << "\n --> le blocage est mis en relatif ";
|
|
blocage_relatif = true;
|
|
index.Change_taille(5);
|
|
index(1) = 1;index(2) = 7; index(3) = 8; index(4) = 9;index(5) = 14;
|
|
break;
|
|
}
|
|
case 9: // condition de tangence
|
|
{cout << "\n --> condition de tangence ";
|
|
if (ParaGlob::Dimension() != 3)
|
|
{ cout << "\n **** erreur il faut etre en dimension 3 pour cette condition !!";
|
|
break;
|
|
};
|
|
cout << "\n nom de la ref d'arete pour l'application de la condition ? ";
|
|
nom_ref= lect_chaine();cout << " nom lu = "<< nom_ref;
|
|
if (nom_ref.at(0) != 'A')
|
|
{cout << "\n *** erreur, la premiere lettre de la ref d'aretes "
|
|
<< " doit etre A et non "<< nom_ref.at(0)<< " !!";
|
|
break;
|
|
};
|
|
cout << "\n def du vecteur tangent ";
|
|
condition_tangence += " typeCL_= TANGENTE_CL ";
|
|
|
|
for (int i=1;i<=3;i++) // i représente la dimention
|
|
{ string compo; // on defini la composante
|
|
switch (i){ case 1: compo="UX";break; case 2:compo="UY";break;
|
|
case 3: compo="UZ";break;};
|
|
string repi=" ";
|
|
bool choix_valide=false;
|
|
while (!choix_valide)
|
|
{ cout << "\n cas de "<<compo
|
|
<< "\n (1) valeur nulle "
|
|
<< "\n (2) valeur non nulle "
|
|
<< "\n (3) courbe de charge "
|
|
<< "\n (4) fonction nD de charge \n";
|
|
repi=lect_chaine(); cout << " valeur lue "<<repi;
|
|
if ((repi == "1"))
|
|
{condition_tangence += " "+compo+" ";
|
|
choix_valide=true;
|
|
}
|
|
else if ((repi == "2"))
|
|
{condition_tangence += "' "+compo+"= ";
|
|
cout << "\n valeur de "<<compo<<" ? ";
|
|
double val;
|
|
val=lect_double();cout << " valeur lue ="<< val;
|
|
condition_tangence += (ChangeReelSTring(val))+" ' ";
|
|
choix_valide=true;
|
|
}
|
|
else if ((repi == "3"))
|
|
{condition_tangence += "' "+compo+"= COURBE_CHARGE: ";
|
|
cout << "\n nom de la courbe de charge ? ";
|
|
string nom_c;
|
|
nom_c= lect_chaine();cout << " nom lu = "<< nom_c;
|
|
condition_tangence += nom_c;
|
|
cout << "\n echelle (un reel) ? ";
|
|
double val;
|
|
val=lect_double();cout << " valeur lue ="<< val;
|
|
condition_tangence += " ECHELLE: "+(ChangeReelSTring(val))+" ' ";
|
|
choix_valide=true;
|
|
}
|
|
else if ((repi == "4"))
|
|
{condition_tangence += "' "+compo+"= Fonction_nD_CHARGE: ";
|
|
cout << "\n nom de la fonction nD de charge ? ";
|
|
string nom_c;
|
|
nom_c= lect_chaine();cout << " nom lu = "<< nom_c;
|
|
condition_tangence += nom_c;
|
|
choix_valide=true;
|
|
}
|
|
else { cout << "\n *** choix non valide !";choix_valide=false;};
|
|
};
|
|
};
|
|
index.Change_taille(5);
|
|
index(1) = 1;index(2) = 7; index(3) = 8; index(4) = 9;index(5) = 14;
|
|
break;
|
|
}
|
|
case 10: // mouvement solide imposé
|
|
{cout << "\n --> mouvement solide impose ";
|
|
cout << "\n nom de la reference de noeuds associee? ";
|
|
nom_ref= lect_chaine();cout << " nom lu = "<< nom_ref;
|
|
if (nom_ref.at(0) != 'N')
|
|
{cout << "\n *** erreur, la premiere lettre de la ref de noeud "
|
|
<< " doit etre N et non "<< nom_ref.at(0)<< " !!";
|
|
break;
|
|
};
|
|
// ici on utilise un string intermédiaire pour capter le flux
|
|
MvtSolide mvt; // un mouvement par défaut
|
|
mvt.Info_commande_MvtSolide(flux);
|
|
condition_mvt_solide=true;
|
|
|
|
index.Change_taille(8);
|
|
index(1) = 1;index(2) = 5; index(3) = 6; index(4) = 7;index(5) = 8;
|
|
index(6) = 9;index(7) = 14;index(8) = 16;
|
|
break;
|
|
}
|
|
case 11: // champ de valeurs
|
|
{cout << "\n --> champ de valeurs impose ";
|
|
cout << "\n nom de la reference de noeuds associee? ";
|
|
nom_ref= lect_chaine();cout << " nom lu = "<< nom_ref;
|
|
if (nom_ref.at(0) != 'N')
|
|
{cout << "\n *** erreur, la premiere lettre de la ref de noeud "
|
|
<< " doit etre N et non "<< nom_ref.at(0)<< " !!";
|
|
break;
|
|
};
|
|
int nb_valeur=0;
|
|
cout <<"\n nombre d'elements dans la reference ? ";
|
|
nb_valeur=(int) lect_double(); cout << " nombre lu ="<< nb_valeur;
|
|
string repa;
|
|
str_champ_valeurs += " champ_de:\n";
|
|
bool erreur=false;
|
|
for (int i=1;i<=nb_valeur;i++)
|
|
{ string nom_ddl="";
|
|
cout << "\n nom du ddl "<<i<<" ? \n";
|
|
nom_ddl= lect_chaine(); cout << " nom lue "<<nom_ddl;
|
|
if (!ExisteEnum_ddl(nom_ddl))
|
|
{cout << "\n *** erreur, ce ddl n'existe pas ****, on sort de la condition !!";
|
|
erreur = true;
|
|
break;
|
|
};
|
|
str_champ_valeurs += " ' "+nom_ddl+"= ";
|
|
// maintenant la valeur
|
|
cout << "\n (1) valeur numerique ? "
|
|
<< "\n (2) courbe de charge ? "
|
|
<< "\n (4) fonction nD de charge ? ";
|
|
repa=lect_chaine(); cout << " rep lue: "<< repa;
|
|
if (repa=="1")
|
|
{ double val= 0.;cout << "\n valeur ? ";
|
|
val=lect_double();cout << " valeur lue: "<< val;
|
|
str_champ_valeurs += (ChangeReelSTring(val))+" ' \n";
|
|
}
|
|
else if (repa=="2")
|
|
{ cout << "\n nom de la courbe de charge ? ";
|
|
string nom;
|
|
nom= lect_chaine();cout << " nom lu = "<< nom;
|
|
str_champ_valeurs += " COURBE_CHARGE: "+nom+" ' \n";
|
|
}
|
|
else if (repa=="3")
|
|
{ cout << "\n nom de la fonction nD de charge ? ";
|
|
string nom;
|
|
nom= lect_chaine();cout << " nom lu = "<< nom;
|
|
str_champ_valeurs += " Fonction_nD_CHARGE: "+nom+" ' \n";
|
|
};
|
|
};
|
|
if (erreur)
|
|
break; // on sort s'il y a eu une erreur
|
|
str_champ_valeurs += "fin_champ_de_ ";
|
|
champ_valeurs=true;
|
|
index.Change_taille(5);
|
|
index(1) = 1;index(2) = 7; index(3) = 8; index(4) = 9;index(5) = 14;
|
|
break;
|
|
}
|
|
case 12: // liste des ddl existants
|
|
{cout << "\n --> liste des ddl existants ";
|
|
int nb_ddl = nombre_maxi_de_type_de_ddl;
|
|
cout << "\n";
|
|
for (int i=1;i<= nombre_maxi_de_type_de_ddl;i++)
|
|
cout << Nom_ddl(Enum_ddl(i)) << " ";
|
|
cout << "\n";
|
|
break;
|
|
}
|
|
case 13: // informations
|
|
{cout << "\n Il faut se reporter a la document pour avoir une explication detaille de chaque "
|
|
<< "\n conditions. Globalement les conditions possibles sont les suivantes: "
|
|
<< "\n (1) choix d'un deplacement impose --> UX ou UY ou UZ "
|
|
<< "\n (2) autre ddl impose --> a choisir dans la liste des ddl diponibles "
|
|
<< "\n (3) valeur du ddl --> on definit une valeur numerique "
|
|
<< "\n (4) utilisation d'une courbe de charge --> la valeur du ddl = la valeur d'une courbe de charge "
|
|
<< "\n (5) echelle --> facteur multiplicatif de la valeur du ddl (fixe ou dependant d'une fct f(t)"
|
|
<< "\n (6) temps mini --> en dessous du temps mini, la condition n'existe pas "
|
|
<< "\n (7) temps maxi --> au dessus du temps maxi la condition n'existe pas "
|
|
<< "\n (8) blocage relatif --> a partir de temps mini, la condition est ajoute a la valeur existante du ddl "
|
|
<< "\n (9) condition de tangence --> permet de definir des conditions limites pour les elements SFE "
|
|
<< "\n (10) mouvement solide impose --> permet de definir des mouvements d'ensemble pour un groupe de noeuds "
|
|
<< "\n (11) champ de valeurs --> permet de definir de maniere concise un ensemble de conditions non identiques "
|
|
<< "\n (12) liste de ddl existant --> donne la liste des ddl possibles "
|
|
<< "\n (13 ou ? ) information --> ce message "
|
|
<< "\n (14) plusieurs ddl de deplacement, nuls --> forme concise pour mettre des deplacements a 0 "
|
|
<< "\n (15) une fonction nD --> la valeur du ddl = la valeur de la fonction, eventuellement x Co charge ";
|
|
break;
|
|
}
|
|
case 14: // plusieurs ddl de deplacement, nuls
|
|
{ string repi=" ";
|
|
nom_des_ddl = "";
|
|
while (repi != "f")
|
|
{ cout << "\n -- choix du ddl -- ";
|
|
switch (ParaGlob::Dimension())
|
|
{case 1: cout << "\n (1) UX "
|
|
<< "\n (f) (defaut) fin"; break;
|
|
case 2: cout << "\n (1) UX "
|
|
<< "\n (2) UY "
|
|
<< "\n (f) (defaut) fin" ; break;
|
|
case 3: cout << "\n (1) UX "
|
|
<< "\n (2) UY "
|
|
<< "\n (3) UZ "
|
|
<< "\n (f) (defaut) fin" ; break;
|
|
default: cout << " ";
|
|
}; cout << "\n";
|
|
repi= lect_return_defaut(false,"f");; cout << " valeur lue "<<repi;
|
|
if ((repi == "1")) {nom_des_ddl += " UX ";}
|
|
else if ((repi == "2")) {nom_des_ddl += " UY ";}
|
|
else if ((repi == "3")) {nom_des_ddl += " UZ ";}
|
|
else if ((Minuscules(repi) == "f")||(Minuscules(repi) == "0")) {}
|
|
else { cout << "\n *** choix non valide !";};
|
|
};
|
|
valeur_du_ddl=0.;
|
|
cout << "\n nom de la reference de noeuds associee? ";
|
|
nom_ref= lect_chaine();cout << " nom lu = "<< nom_ref;
|
|
if (nom_ref.at(0) != 'N')
|
|
{cout << "\n *** erreur, la premiere lettre de la ref de noeud "
|
|
<< " doit etre N et non "<< nom_ref.at(0)<< " !!";
|
|
break;
|
|
};
|
|
index.Change_taille(7);
|
|
index(1) = 1; index(2) = 5; index(3) = 6; index(4) = 7;
|
|
index(5) = 8;index(6) = 9;index(7) = 14;
|
|
break;
|
|
}
|
|
case 15: // fonction nD de charge
|
|
{ cout << "\n nom de la fonction nD de charge ? ";
|
|
nom_fonction_nD= lect_chaine();cout << " nom lu = "<< nom_fonction_nD;
|
|
index.Change_taille(7);
|
|
index(1) = 1;index(2) = 6; index(3) = 7; index(4) = 8;index(5) = 9;
|
|
index(6) = 14;index(7) = 5;
|
|
break;
|
|
}
|
|
default:
|
|
cout << "\n le cas "<<rep<<" n'est pas traite !!, bizarre, il faut se plaindre !! ";
|
|
};
|
|
}
|
|
catch (ErrSortieFinale)
|
|
// cas d'une direction voulue vers la sortie
|
|
// on relance l'interuption pour le niveau supérieur
|
|
{ ErrSortieFinale toto;
|
|
throw (toto);
|
|
}
|
|
catch (...)//(UtilLecture::ErrNouvelleDonnee erreur)
|
|
{ cout << "\n Erreur on attendait un des mots cles proposes !!, "
|
|
<< "\n redonnez une bonne valeur"
|
|
<< "\n ou taper f ou 0 pour sortir ";
|
|
};
|
|
}; //-- fin du while
|
|
sort << flush;
|
|
|
|
};
|
|
|
|
|
|
//------------------------------ FONCTIONS PROTEGEES --------------------
|
|
|
|
// verification en fonction de la dimension du pb
|
|
// par exemple en dim 2 d'existance des UZ ou des X3 etc..
|
|
void DdlLim::VerifDimDdl()
|
|
{ //pour l'instant ne fait rien
|
|
};
|
|
|
|
// ====================================================================
|
|
// classe Ddlbloque
|
|
// ====================================================================
|
|
|
|
// surcharge de l'operateur d'ecriture
|
|
ostream & operator << (ostream & sort,const DdlLim::Ddlbloque & a)
|
|
{ // écriture du type
|
|
sort << "Ddlbloque ";
|
|
// les données
|
|
sort << a.ddl << " " << a.co_charge << " " << a.echelle << " "<< a.f_charge << " " ;
|
|
return sort;
|
|
};
|
|
// surcharge de l'operator de lecture
|
|
istream & operator >> (istream & entree, DdlLim::Ddlbloque& a)
|
|
{ // vérification du type
|
|
string type;
|
|
entree >> type;
|
|
if (type != "Ddlbloque")
|
|
{Sortie (1);
|
|
return entree;
|
|
}
|
|
// entrée des données
|
|
entree >> a.ddl;
|
|
entree >> a.co_charge >> a.echelle >> a.f_charge;
|
|
return entree;
|
|
};
|
|
|
|
// surcharge de l'opérateur d'affectation
|
|
DdlLim::Ddlbloque& DdlLim::Ddlbloque::operator= (const DdlLim::Ddlbloque& d)
|
|
{ ddl=d.ddl;
|
|
co_charge=d.co_charge;
|
|
echelle = d.echelle;
|
|
f_charge = d.f_charge;
|
|
return (*this);
|
|
};
|
|
|
|
//Surcharge d'operateur logique
|
|
bool DdlLim::Ddlbloque::operator == ( DdlLim::Ddlbloque& a)
|
|
{ if ( (ddl==a.ddl)
|
|
&& (co_charge == a.co_charge) && (echelle == a.echelle)
|
|
&& (f_charge == a.f_charge)
|
|
)
|
|
return true;
|
|
else return false;
|
|
};
|
|
|
|
bool DdlLim::Ddlbloque::operator != ( DdlLim::Ddlbloque& a)
|
|
{ return !(*this == a);};
|
|
|
|
// lecture dans le cas particulier d'un champ
|
|
list <DdlLim::Ddlbloque> DdlLim::Lecture_champ(UtilLecture & entreePrinc)
|
|
{ // def de variables inter
|
|
char tat[250]; char * ta = tat; char tt[100]; char * t = tt;
|
|
// def de la liste de ddl qui sera retournée
|
|
list <Ddlbloque> lili;
|
|
// le traitement qui suit s'effectue soit une fois si ce n'est pas un champ, soit n fois jusqu'a
|
|
// ce que la ligne contienne le mot clé fin_champ_de_ qui doit être le premier enregistrement de la ligne
|
|
bool derniere_ligne = true; // le cas courant c'est qu'il y a une seule ligne a exploiter
|
|
do ///__________ la grande boucle
|
|
{ // dans ce cas dans le fichier d'entrée les infos se trouvent sur les lignes qui suivent
|
|
// via normalement un fichier (mais ce n'est pas obligatoire) donc on passe
|
|
// une ligne à chaque passage jusqu'à trouver le mot clé fin_champ_de_
|
|
entreePrinc.NouvelleDonnee(); // lecture d'une nouvelle ligne
|
|
// on lira jusqu'à la ligne qui contiend le mot clé: fin_champ_de_ en début d'enregistrement
|
|
if (strstr(entreePrinc.tablcar,"fin_champ_de_")!=NULL)
|
|
{derniere_ligne= true; string toto; *(entreePrinc.entree) >> toto;
|
|
if (toto != "fin_champ_de_")
|
|
{ cout << "\n erreur de lecture d'un champ de valeurs "
|
|
<< " le premier mot de la derniere ligne devait etre fin_champ_de_ \n";
|
|
entreePrinc.MessageBuffer("*** lecture champ de valeurs ****" );
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
}
|
|
}
|
|
else
|
|
{derniere_ligne = false;};
|
|
|
|
//recup de la fin de la ligne
|
|
char tout[150] ; char * ptout = tout; (entreePrinc.entree)->get(ptout,150);
|
|
// avant la lecture on remplace toutes les virgules par des espaces
|
|
char * ii = strchr(ptout,',');
|
|
while (ii != NULL) { *ii = ' '; ii = strchr(ptout,',');}
|
|
// def du flot intermédiaire
|
|
#ifndef ENLINUX_STREAM
|
|
istringstream flot(ptout);
|
|
#else
|
|
istrstream flot(ptout);
|
|
#endif
|
|
// lecture tant que le flot est valide
|
|
while (flot.rdstate() == 0)
|
|
// tout d'abord on passe les espaces qui sont des séparateurs
|
|
// lecture du prochain caractère sans modifier le flot
|
|
{char car; // = flot.peek();
|
|
//---- debug
|
|
//cout << "\n debug DdlLim::Lecture_champ( flot.rdstate()= " << flot.rdstate()<< endl;
|
|
//--- fin debug
|
|
|
|
flot >> car;
|
|
// éventuellement il n'avait pas bien déterminé la fin de l'enregistrement
|
|
// au niveau du while, dans ce cas si durant la lecture de car il y a eu un pb
|
|
// cela signifie qu'en fait la ligne était terminée donc on s'arrête
|
|
if (flot.rdstate() != 0) break;
|
|
while ( (car==' ') && (flot.rdstate() == 0 ))
|
|
// cas où le prochain caractère est un espace
|
|
{ flot >> car; }
|
|
flot.putback(car);
|
|
|
|
if (!derniere_ligne)
|
|
{// on définit un ddl pour la lecture
|
|
Ddlbloque elem;
|
|
// deux cas, soit un ddl nulle par defaut, soit une valeur non nulle imposee
|
|
// soit le caractère est ' , signifie que c'est un ddl avec une valeur
|
|
// imposée
|
|
if ( (car=='\'') && (flot.rdstate() == 0 ))
|
|
{// on passe le premier '
|
|
flot >> car;
|
|
// on lit jusqu'au prochain ' en non formaté
|
|
flot.get(ta,150,'\'');
|
|
// on passe ce dernier '
|
|
flot >> car;
|
|
// on recherche le = pour mettre un blanc a la place
|
|
char * ii = strchr(ta,'\'');char * pii=ii; // sauvegarde de l'adresse
|
|
ii = strchr(ta,'='); // on recherche le =
|
|
if (ii == NULL)
|
|
{ cout << "\n erreur de syntaxe dans la definition des conditions limites "
|
|
<< " imposees a une valeur non nulle ";
|
|
cout << " le ddl doit etre separe de la valeur par le signe = , caractere non"
|
|
<< " trouve ";
|
|
entreePrinc.MessageBuffer("*** lecture d'une reference de ddl bloquee ****" );
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
}
|
|
*ii = ' '; // supprime le =
|
|
|
|
// def du flux intermediaire
|
|
#ifndef ENLINUX_STREAM
|
|
istringstream flux (ta);
|
|
#else
|
|
istrstream flux (ta);
|
|
#endif
|
|
|
|
flux >> t ;
|
|
elem.ddl.Change_nom(t);
|
|
// on regarde s'il ne s'agit pas d'une courbe de charge imposée
|
|
bool sans_courbe_ou_fct_nD=true; // variable locale
|
|
// a) cas d'une courbe
|
|
if(strstr(ta,"COURBE_CHARGE:")!=0)
|
|
{ // cas d'une courbe de charge
|
|
string toto;
|
|
flux >> toto >> elem.co_charge;
|
|
// on vérifie la présence au bon endroit du mot clé COURBE_CHARGE=
|
|
if (toto != "COURBE_CHARGE:")
|
|
{cout << "\n erreur de syntaxe en lecture du nom de la courbe ";
|
|
cout << "\n DdlLim::Lecture_champ(.. " << endl ;
|
|
entreePrinc.MessageBuffer("**erreur**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
// on récupère l'échelle éventuellement
|
|
if(strstr(ta,"ECHELLE:")!=0)
|
|
{ // cas où il y a un facteur d'échelle
|
|
flux >> toto;
|
|
if (toto != "ECHELLE:")
|
|
{cout << "\n erreur de syntaxe en lecture du facteur d'échelle ";
|
|
cout << "\n DdlLim::Lecture_champ(.. " << endl ;
|
|
entreePrinc.MessageBuffer("**erreur**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
// lecture du facteur
|
|
flux >> elem.echelle;
|
|
};
|
|
};
|
|
// b) cas d'une fonction nD
|
|
if(strstr(ta,"Fonction_nD_CHARGE:")!=0)
|
|
{ // cas d'une fonction nD
|
|
string toto;
|
|
flux >> toto >> elem.f_charge;
|
|
sans_courbe_ou_fct_nD=false;
|
|
// on vérifie la présence au bon endroit du mot clé Fonction_nD_CHARGE:
|
|
if (toto != "Fonction_nD_CHARGE:")
|
|
{cout << "\n erreur de syntaxe en lecture du nom de la fonction nD ";
|
|
cout << "\n DdlLim::Lecture_champ(.. " << endl ;
|
|
entreePrinc.MessageBuffer("**erreur**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
};
|
|
|
|
// si aucune courbe ou fct nD
|
|
if (sans_courbe_ou_fct_nD)
|
|
// cas où c'est une valeur fixe
|
|
{ flux >> elem.ddl.Valeur();}
|
|
elem.ddl.Change_fixe (true);
|
|
}
|
|
else if (flot.rdstate() == 0 ) // il s'agit d'un ddl à 0
|
|
{//un ddl nulle par defaut
|
|
flot >> t;
|
|
elem.ddl.Change_nom(t);
|
|
elem.ddl.Valeur() = 0;
|
|
elem.ddl.Change_fixe (true);
|
|
}
|
|
// on ne verifie pas que l'on n'utilise pas deux fois le meme identificateur de ddl
|
|
// avec deux valeurs differentes car dans le cas d'un champ il y a obligatoirement plusieurs fois le même ddl
|
|
// stockage
|
|
lili.push_back(elem);
|
|
}
|
|
else // cas de la dernière ligne
|
|
{// lecture éventuelle des temp mini et maxi
|
|
if (((!flot.rdstate())&& (!(flot.eof())))) // lecture s'il n'y a pas d'erreur
|
|
{if(strstr(ptout,"TEMPS_MINI=") != 0)
|
|
{// cas d'un temps mini
|
|
string toto;
|
|
flot >> toto;
|
|
// on vérifie la présence au bon endroit du mot clé TEMPS_MINI=
|
|
if (toto != "TEMPS_MINI=")
|
|
{cout << "\n erreur de syntaxe en lecture du temps mini, info lue: " << toto;
|
|
cout << "\n DdlLim::Lecture_champ(.. " << endl ;
|
|
entreePrinc.MessageBuffer("**erreur**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
}
|
|
//lecture du temps mini
|
|
flot >> t_min;
|
|
}
|
|
}
|
|
if (((!flot.rdstate())&& (!(flot.eof())))) // lecture s'il n'y a pas d'erreur
|
|
{if(strstr(ptout,"TEMPS_MAXI=") != 0)
|
|
{// cas d'un temps maxi
|
|
string toto;
|
|
flot >> toto;
|
|
// on vérifie la présence au bon endroit du mot clé TEMPS_MAXI=
|
|
if (toto != "TEMPS_MAXI=")
|
|
{cout << "\n erreur de syntaxe en lecture du temps maxi ";
|
|
cout << "\n DdlLim::Lecture_champ(.. " << endl ;
|
|
entreePrinc.MessageBuffer("**erreur**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
}
|
|
//lecture du temps maxi
|
|
flot >> t_max;
|
|
}
|
|
};
|
|
// à la fin on considère que c'est fini, il n'y a plus d'info spécifique à lire
|
|
// donc on sort de la boucle
|
|
break;
|
|
} //-- fin du cas de la dernière ligne
|
|
|
|
} //-- fin du while (flot.rdstate() == 0)
|
|
} ///__________ fin de la grande boucle
|
|
while(! derniere_ligne);
|
|
|
|
// dans le cas où il s'agit d'un champ de conditions de tangente imposée, il faut que
|
|
// la condition soit un multiple de la dimension de l'espace, car chaque condition représente un
|
|
// vecteur
|
|
if (typeCL == TANGENTE_CL)
|
|
{if ((tab.Taille() % ParaGlob::Dimension()) != 0)
|
|
{cout << "\n erreur en lecture d'un champ de condition de tangente imposée, "
|
|
<< " le nombre de dd (ici = " << tab.Taille() << ") doit etre multiple de la dimension"
|
|
<< " de l'espace (ici = " << ParaGlob::Dimension()<<") ";
|
|
cout << "\n DdlLim::Lecture_champ(.. " << endl ;
|
|
entreePrinc.MessageBuffer("**erreur**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
};
|
|
|
|
return lili;
|
|
};
|
|
|
|
// lecture dans le cas particulier d'un mouvement solide
|
|
list <DdlLim::Ddlbloque> DdlLim::Lecture_mvtSolide(UtilLecture & entreePrinc)
|
|
{ // on commence par lire les mouvements solides
|
|
if (mvtsolide == NULL)
|
|
mvtsolide = new MvtSolide(); // création s'il n'existe pas
|
|
mvtsolide->Lecture_mouvements_solides(&entreePrinc);
|
|
// def de la liste de ddl qui sera retournée
|
|
list <Ddlbloque> lili;
|
|
// on définit les ddl bloque associés
|
|
int dima = ParaGlob::Dimension();
|
|
Ddlbloque elem; // def d'un ddl courant
|
|
elem.ddl.Change_fixe (true);
|
|
switch (dima)
|
|
{ case 3: {elem.ddl.Change_nom(UZ); lili.push_front(elem);}
|
|
case 2: {elem.ddl.Change_nom(UY); lili.push_front(elem);}
|
|
case 1: {elem.ddl.Change_nom(UX); lili.push_front(elem);}
|
|
};
|
|
// def d'un string pour les lectures de chaine
|
|
string nom;
|
|
// maintenant on regarde s'il y a une courbe de charge
|
|
// on regarde s'il ne s'agit pas d'une courbe de charge imposée
|
|
if (strstr(entreePrinc.tablcar,"COURBE_CHARGE:")!=NULL)
|
|
{ // cas d'une courbe de charge
|
|
*(entreePrinc.entree) >> nom;
|
|
// on vérifie la présence au bon endroit du mot clé COURBE_CHARGE=
|
|
if (nom != "COURBE_CHARGE:")
|
|
{cout << "\n erreur de syntaxe en lecture du nom de la courbe "
|
|
<< " on a lue " << nom << " alors que l'on attendait : COURBE_CHARGE: ";
|
|
cout << "\n DdlLim::Lecture_mvtSolide(.. " << endl ;
|
|
entreePrinc.MessageBuffer("**erreur**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
// on se sert du premier ddlbloqué pour stocker la courbe de charge
|
|
Ddlbloque & elem = *(lili.begin());
|
|
// lecture de la courbe
|
|
*(entreePrinc.entree) >> elem.co_charge;
|
|
// on récupère l'échelle éventuellement
|
|
if (strstr(entreePrinc.tablcar,"ECHELLE:")!=NULL)
|
|
{ // cas où il y a un facteur d'échelle
|
|
*(entreePrinc.entree) >> nom;
|
|
if (nom != "ECHELLE:")
|
|
{cout << "\n erreur de syntaxe en lecture du facteur d'echelle "
|
|
<< " on a lue " << nom << " alors que l'on attendait ECHELLE: ";
|
|
cout << "\n DdlLim::Lecture(.. " << endl ;
|
|
entreePrinc.MessageBuffer("**erreur**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
}
|
|
// lecture du facteur
|
|
*(entreePrinc.entree) >> elem.echelle;
|
|
};
|
|
};
|
|
if (strstr(entreePrinc.tablcar,"Fonction_nD_CHARGE:")!=NULL)
|
|
{ // cas d'une fonction nD de charge
|
|
*(entreePrinc.entree) >> nom;
|
|
// on vérifie la présence au bon endroit du mot clé Fonction_nD_CHARGE:
|
|
if (nom != "Fonction_nD_CHARGE:")
|
|
{cout << "\n erreur de syntaxe en lecture du nom de la fonction nD "
|
|
<< " on a lue " << nom << " alors que l'on attendait : Fonction_nD_CHARGE: ";
|
|
cout << "\n DdlLim::Lecture_mvtSolide(.. " << endl ;
|
|
entreePrinc.MessageBuffer("**erreur**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
};
|
|
// on se sert du premier ddlbloqué pour stocker la courbe de charge
|
|
Ddlbloque & elem = *(lili.begin());
|
|
// lecture de la courbe
|
|
*(entreePrinc.entree) >> elem.f_charge;
|
|
};
|
|
// lecture éventuelle des temp mini et maxi
|
|
if (strstr(entreePrinc.tablcar,"TEMPS_MINI=")!=NULL)
|
|
{ // cas d'un temps mini
|
|
*(entreePrinc.entree) >> nom;
|
|
// on vérifie la présence au bon endroit du mot clé TEMPS_MINI=
|
|
if (nom != "TEMPS_MINI=")
|
|
{cout << "\n erreur de syntaxe en lecture du temps mini, info lue: " << nom
|
|
<< " alors que l'on attendait : TEMPS_MINI=";
|
|
cout << "\n DdlLim::Lecture(.. " << endl ;
|
|
entreePrinc.MessageBuffer("**erreur**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
}
|
|
//lecture du temps mini
|
|
*(entreePrinc.entree) >> t_min;
|
|
};
|
|
if (strstr(entreePrinc.tablcar,"TEMPS_MAXI=")!=NULL)
|
|
{ // cas d'un temps maxi
|
|
*(entreePrinc.entree) >> nom;
|
|
// on vérifie la présence au bon endroit du mot clé TEMPS_MAXI=
|
|
if (nom != "TEMPS_MAXI=")
|
|
{cout << "\n erreur de syntaxe en lecture du temps maxi, info lue: " << nom
|
|
<< " alors que l'on attendait : TEMPS_MAXI=";
|
|
cout << "\n DdlLim::Lecture(.. " << endl ;
|
|
entreePrinc.MessageBuffer("**erreur**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
}
|
|
//lecture du temps maxi
|
|
*(entreePrinc.entree) >> t_max;
|
|
};
|
|
// lecture éventuel de l'indicateur de blocage "relatif"
|
|
if (strstr(entreePrinc.tablcar,"BLOCAGE_RELATIF_")!=NULL)
|
|
{ *(entreePrinc.entree) >> nom;
|
|
// on vérifie la présence au bon endroit du mot clé BLOCAGE_RELATIF_
|
|
if (nom != "BLOCAGE_RELATIF_")
|
|
{cout << "\n erreur de syntaxe en lecture de l'indicateur de blocage relatif, info lue: " << nom
|
|
<< " alors que l'on attendait : BLOCAGE_RELATIF_";
|
|
cout << "\n DdlLim::Lecture(.. " << endl ;
|
|
entreePrinc.MessageBuffer("**erreur**");
|
|
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
|
Sortie(1);
|
|
}
|
|
blocage_relatif = true;
|
|
};
|
|
|
|
return lili;
|
|
};
|