#==ATTENTION==ATTENTION==ATTENTION==ATTENTION==ATTENTION==ATTENTION # # temps --> seconde # dimension --> mètre # pression --> Gpa # #==ATTENTION==ATTENTION==ATTENTION==ATTENTION==ATTENTION==ATTENTION # # on choisit le type de probleme on veut resoudre # booleen Thermique f booleen Mecanique v # # constantes # # Temps de depart: T_0 # Temps final: T_F scalaire T_0 0 scalaire T_F 3542400 # # Si les donnees ont des discontinuites en temps on va forcer une resolution a ces temps particuliers # et on aura pas a se soucier des pas de temps car le solveur fera le travail qu'on donne des pas de temps # fixes ou varaibles. # # # Sert à imposer des temps lors d'un calcul à pas de temps variable. # booleen TempsImpose : sert à activer l'imposition de temps. # scalaire NbTempsImpose : définit les temps que l'on veut imposer. Prends les premiers de la liste. # booleen TempsImpose v scalaire NbTempsImpose 4 scalaire TempsImpose_0 86400. scalaire TempsImpose_1 259200. scalaire TempsImpose_2 1209600. scalaire TempsImpose_3 2332800. scalaire TempsImpose_4 4320000. scalaire TempsImpose_5 4752000. scalaire TempsImpose_6 5184000. scalaire TempsImpose_7 5616000. scalaire TempsImpose_8 6048000. scalaire TempsImpose_9 6480000. scalaire TempsImpose_10 334.5 scalaire TempsImpose_11 670.5 scalaire TempsImpose_12 1318.5 scalaire TempsImpose_13 1414.5 # # Donnees pour le calcul avec pas de temps variable. # N.B: Si on veut faire un calcul avec un pas de temps fixe, On a seulement besoin d'indiquer le temps initial (T_0 définit plus haut), d'inscrire le pas de temps (PasDeTemps) # et le nombre de pas de temps (NbPasDetemps un peu plus bas) que l'on veut faire. Il ne faut pas oublier de mettre en commentaire la ligne définissant le pas de temps variable. # # Pas de temps (valeur initiale si variable): PasDeTempsInit # Pas de temps minimal: PasDeTempsMin # Pas de temps maximal (pas le limite = 0): PasDeTempsMax scalaire PasDeTemps 0.00001 scalaire PasDeTempsMin 0.1 scalaire PasDeTempsMax 500000 # Nombre maximal de pas de temps: NbPasDeTemps # frequence du calcul en elasticite (relativement au probleme en M: 0 == pas de calcul): freqCalcul # frequence d'impression des champs (pas d'impression = 0): freqImpression scalaire NbPasDeTemps 9999 scalaire freqCalcul 1 scalaire freqImpression 1 # # valeur specifique au solveurInstNlinPETSc et solveurLinPETSc # # tolerance pour le calcul des pas de temps scalaire TolerancePasVariable 5e-3 # Tolerance pour la convergence des solveurs scalaire ToleranceNlin 1e-9 scalaire ToleranceLin 5e-9 scalaire ToleranceLinMec 5e-12 scalaire ToleranceLinMecR 5e-40 scalaire Divergence 1e+10 # nombre maximum d'iterations pour les solveur scalaire MaxItNlin 200 scalaire MaxItLin 5000 scalaire MaxItLinMec 5000 # # est-ce que l'on aura a resoudre un probleme avec des mouvements de corps rigide? # a modifier si on sait que l'on aura des mouvements de corps rigide. # # ATTENTION : il faudra alors modifier dans le code suivant la direction CONNUE des # mouvements de corps rigide booleen CorpsRigideGCP f # # on veut la trace de la solution en certains points # NbEval nombre de points d'evaluations # Coord_i le point i pour i=0 a NbEval-1 # # en mettant NbEval à zéro on ne fait plus les evaluations scalaire NbEval 1 vectoriel3d Coord_0 [0.0325,0.011,0.014] ## Solveur PETSc ## # Pour plus d'information sur les solveurs, voir le lien "format du fichier champs" dans la documentation MEF++ solveurlinpetsc typesolveur "SolveurLin" gradient_conjugue solveurlinpetsc typeprecond "SolveurLin" sor solveurlinpetsc configprecondsor "SolveurLin" [v] solveurlinpetsc suiviconvergence "SolveurLin" defaut solveurlinpetsc tolerance "SolveurLin" [ToleranceLin,ToleranceLin,Divergence,MaxItLin] solveurinstnlinpetsc typesolveur "SolveurInst" solveurinstnlinpetsc solveurlin "SolveurInst" SolveurLin solveurinstnlinpetsc parametresnlin "SolveurInst" [ToleranceNlin,MaxItNlin,v] solveurinstnlinpetsc parametresinst "SolveurInst" [PasDeTemps, NbPasDeTemps, T_0, eulerimplicit,v] solveurinstnlinpetsc reassemblagesafaire "SolveurInst" [1,1] # # Proprietes des matrices permettant d'optimiser la resolution instationnaire # Ce sont des optimisations. Le code marchera sans ces options (plus long cependant) # # PM0 la matrice masse depend du temps via C_MRho # PM1 la matrice masse depend de la solution recherchee via C_MRho # PK0 la matrice rigidite depend du temps # PK1 la matrice rigidite depend de la solution recherchee # PK2 la matrice rigidite depend des CL (la matrice sera modifiee par les CL: robin <=> neumannonlineaire) # # solveurinstnlinpetsc parametres_matrice_masse "SolveurInst" [PM0,PM1] # solveurinstnlinpetsc parametres_matrice_rigidite "SolveurInst" [PK0,PK1,PK2] # solveurinstnlinpetsc parametres_matrice_masse "SolveurInst" [f,f] solveurinstnlinpetsc parametres_matrice_rigidite "SolveurInst" [f,v,v] # # on choisit un pas de temps variable calculé par le solveur # (commenter si on en veut pas, mais attention a NbPasDeTemps) # solveurinstnlinpetsc pasdetempsvariable "SolveurInst" [PasDeTempsMin,PasDeTempsMax,T_F,TolerancePasVariable] solveurlinpetsc typesolveur "SolveurMec" gradient_conjugue solveurlinpetsc typeprecond "SolveurMec" sor solveurlinpetsc configprecondsor "SolveurMec" [v,0.7] solveurlinpetsc suiviconvergence "SolveurMec" defaut solveurlinpetsc tolerance "SolveurMec" [ToleranceLinMecR,ToleranceLinMec,Divergence,MaxItLinMec] # # FIN DES CONSTANTES, DEBUT DES CHAMPS OU DES CONSTANTES DEPENDANT D'AUTRES CONSTANTES # ChampGeoLin "ChampGeo" "" scalaire "mult" 1 # mult est un facteur multiplicatif pour éviter les pivots nuls lors que la résolution avec la méthode directe. # Ne pas en tenir compte avec les méthodes itératives (le mettre à 1). #------------------------------------------------- # DECLARATION DES VARIABLES #------------------------------------------------- # Les paramètres "db" ont comme valeur db/100. # Les paramètres de diffusion "D" ont comme valeur D*db/100. {Sugar_Maple scalaire "db" f(mult)=597*1e-2*mult scalaire "DL" f(mult)=1.3e-08*mult } {White_Birch scalaire "db" f(mult)=506*1e-2*mult scalaire "DL" f(mult)=1.3e-08*mult scalaire "DR" f(mult)=2.39e-10*mult scalaire "DT" f(mult)=2.39e-10*mult } {UF_Resin scalaire "db" f(mult)=1500*1e-2*mult scalaire "D" f(mult)=1.0e-15*mult } #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ # PARTIE DIFFUSION NON-STATIONNAIRE #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ # Humidité initiale. MP est utilisé en cas d'hystéresse, représente l'humidité au pas précédent. # ici scallin est utilisé pour la résolution linéaire. On utilise scalquad pour la résolution quadratique scallin "M" 6.3 scallin "MP" 6.3 #--------------------------------------------------------------- # Champs necessaires a la definition de la matrice de diffusion #--------------------------------------------------------------- # Coefficient de diffusion pour l'érable pour les axes tangentielle et radiale. Varie selon l'humidité. scalaire "CErableXZ" f(M,mult)=(-6.34*M+40.1)*1.0e-10*mult scalaire "dCErableXZdM" f(mult)=-6.34*1.0e-10*mult scalaire "zero" 0 { Diffusion empilementto2 "Smaple_to2" [CErableXZ,Sugar_Maple::DL,CErableXZ,zero,zero,zero] empilementto2 "Wbirch_to2" [White_Birch::DT,White_Birch::DL,White_Birch::DR, zero, zero, zero] empilementto2 "Wbirch_to2R" [White_Birch::DL,White_Birch::DR,White_Birch::DT, zero, zero, zero] empilementto2 "UF_to2" [UF_Resin::D, UF_Resin::D, UF_Resin::D, zero, zero, zero] } # La diffusionNewton est pour avoir une convergence quadratique. { DiffusionNewton empilementto2 "Smaple_to2" [dCErableXZdM,zero,dCErableXZdM,zero,zero,zero] empilementto2 "Wbirch_to2" [zero, zero, zero, zero, zero, zero] empilementto2 "Wbirch_to2R" [zero, zero, zero, zero, zero, zero] empilementto2 "UF_to2" [zero, zero, zero, zero, zero, zero] } #------------------------------------- #Definition de la matrice de diffusion #------------------------------------- to2surgeom "K_M" DESSUS=Diffusion::Smaple_to2 DESSOUS=Diffusion::Wbirch_to2 CENTRE=Diffusion::Wbirch_to2R defaut=Diffusion::UF_to2 to2surgeom "dK_MdM" DESSUS=DiffusionNewton::Smaple_to2 DESSOUS=DiffusionNewton::Wbirch_to2 CENTRE=DiffusionNewton::Wbirch_to2R defaut=DiffusionNewton::UF_to2 #------------------------------------------- # RhoCp, coefficient de la derivee en temps #------------------------------------------- scalsurgeom "C_MRho" DESSUS=Sugar_Maple::db DESSOUS=White_Birch::db CENTRE=White_Birch::db defaut=UF_Resin::db #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ # PARTIE DEFORMATION #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ # déformation initiale # ici v3dlin est utilisé pour la résolution linéaire. On utilise v3dquad pour la résolution quadratique v3dlin "U" [0,0,0] ##-------------------------------------## { Coeff to4elasticite "erable" [0.678, 13.81, 1.311, 0.025, 0.43, 0.46, 0.753, 0.255, 1.013] to4elasticite "bouleau" [0.516, 12.045, 1.069, 0.018, 0.38, 0.49, 0.607, 0.20, 0.829] to4elasticite "bouleauR" [12.045, 0.516, 1.069, 0.43, 0.49, 0.38, 0.607, 0.829, 0.20] to4elasticite "UF" [10, 10, 10, 0.35, 0.35, 0.35, 3.703703704, 3.703703704, 3.703703704] } to4surgeom "Eijkl" DESSUS=Coeff::erable DESSOUS=Coeff::bouleau CENTRE=Coeff::bouleauR defaut=Coeff::UF # Coefficients de dilatation de l'érable. Varient selon l'humidité. Les premiers termes sont utilisés en gain d'humidité, les secondes en retrait. scalaire DilErX f(M,MP)=(M > MP)*0.0027579+(M < MP)*0.0033495 scalaire DilErY f(M,MP)=(M > MP)*0.0001842+(M < MP)*0.00014715 scalaire DilErZ f(M,MP)=(M > MP)*0.0019053+(M < MP)*0.0021382 { Dilat empilementto2 "erable" [DilErX,DilErY,DilErZ,zero,zero,zero] to2symaconstant "bouleau" [0.0024, 0.00015, 0.00173, 0 ,0 ,0] to2symaconstant "bouleauR" [0.00015, 0.0024, 0.00173, 0 ,0 ,0] to2symaconstant "UF" [0.019, 0.019, 0.019, 0 ,0 ,0] } # # Si on utilise DilEr* alors on indique au programme que BetaM tiendra compte de l'hysterese: # booleen Hysterese v to2surgeom "BetaM" DESSUS=Dilat::erable DESSOUS=Dilat::bouleau CENTRE=Dilat::bouleauR defaut=Dilat::UF ##-------------------------------------## #------------------------------------- #Champs necessaires pour la CL #------------------------------------- # MInfini varie dans le temps scalaire "MInfini" f()=4.46*(t<14400.) + 5.00*(t>=14400.)*(t<=25200.) + 5.32*(t>25200.)*(t<=54000.) + 5.10*(t>54000.)*(t<=90000.) + 5.6*(t>90000.)*(t<=97200.) \ + 5.15*(t>97200.)*(t<=111600.) + 4.86*(t>111600.)*(t<=133200.) + 4.77*(t>133200.)*(t<=183600.) + 4.9*(t>183600.)*(t<=253800) \ + 4.8*(t>253800)*(t<=858600) + 4.77*(t>858600)*(t<=1204200) + 4.6*(t>1204200)*(t<=2413800) + 4.5*(t>2413800)*(t<=4746600) \ + 4.37*(t>4746600)*(t<=5092200) + 4.31*(t>5092200)