#==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 a resoudre # ChampGeoLin "ChampGeo" "" booleen Thermique f booleen Mecanique v # # La matrice de rigidité du problème mécanique dépent-elle du temps ? # # ATTENTION en cas d'hystérèse de E_ijkl on a une dépendance par rapport au temps # booleen forceAssemblageMatriceMec f booleen Reassemble f booleen VerboseInstationnaire v booleen VerbosePointFixe v booleen Hysterese v # # 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 (TempsInitial défini plus haut), # d'inscrire le pas de temps (LongueurPasDeTemps) 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): LongueurPasDeTemps # Pas de temps minimal: LongueurPasDeTemps # Pas de temps maximal (pas le limite = 0): LongueurMaximalePasDeTemps scalaire TempsInitial 0 scalaire TempsFinal 3888000 scalaire LongueurPasDeTemps 0.1 scalaire LongueurMaximalePasDeTemps 2. # Nombre maximal de pas de temps: NombreDePasDeTemps # 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 NombreDePasDeTemps 1 # scalaire NombreDePasDeTemps 9999 scalaire freqCalcul 1 scalaire freqImpression 1 scalaire NbPasDeTemps f(NombreDePasDeTemps)=NombreDePasDeTemps # # CHOIX DE L'INTERPOLATION POUR LES INCONNUES VARIATIONNELLES # scalaire MInitiale 8.6 scallin "M" reinterpole(MInitiale) scallin "MP" reinterpole(MInitiale) v3dquad "U" [0,0,0] v3dquad "UPrec" [0,0,0] // Materiau anisotrope. On suppose que // L == axe des x // T == axe des y // R == axe des z // // Temperature dans la piece scalaire TInfini 21 // Suivant labo scalaire specific_gravity .634 // Suivant Siau scalaire porosity f(specific_gravity,M)=1-specific_gravity*(0.653+M/100) scalaire D_BT f(M,TInfini)=0.000007*exp( (70*M-9200)/(2.*(TInfini+273.15)) ) scalaire D_T f(D_BT,porosity)=D_BT/((1-porosity)*(1-sqrt(porosity))) scalaire D_L f(D_T)=2.5*D_T // // On fabrique le module de Young, le cisaillement la difussion et les // coefficients de dilatation hydrique à partir du tableau Blanchet // // Valeurs du tableau: scalaire rho f(specific_gravity)=specific_gravity*1000 NombreDePasDeTemps scalaire "DL" f(D_L)=D_L scalaire "DR" f(D_T)=D_T scalaire "DT" f(D_T)=D_T scalaire "EL" 13.810e9 scalaire "ER" 1.311e9 scalaire "ET" 0.678e9 scalaire "GLR" 1.013e9 scalaire "GLT" 0.753e9 scalaire "GRT" 0.255e9 scalaire "VTR" 0.42 scalaire "VLR" 0.46 scalaire "VLT" 0.50 scalaire "BdeL" 1.8e-4 scalaire "BdeR" 1.9e-3 scalaire "BdeT" 3.39e-3 scalaire "BadL" 1.5e-4 scalaire "BadR" 2.1e-3 scalaire "BadT" 3.63e-3 // Pour la dilatation qui est BetaM scalaire "BL" f(M,MP,BdeL,BadL)=(M <= MP)*BdeL+(M > MP)*BadL scalaire "BT" f(M,MP,BdeT,BadT)=(M <= MP)*BdeT+(M > MP)*BadT scalaire "BR" f(M,MP,BdeR,BadR)=(M <= MP)*BdeR+(M > MP)*BadR empilementto2 BetaM [BL,BT,BR,Zero,Zero,Zero] scalaire C_M 0.01 // // Les données pour le programme: // scalaire C_MRho f(rho,C_M)=rho*C_M scalaire "KL" f(DL,C_MRho)=DL*C_MRho scalaire "KR" f(DR,C_MRho)=DR*C_MRho scalaire "KT" f(DT,C_MRho)=DT*C_MRho empilementto2 K_M [KL,KT,KR,Zero,Zero,Zero] // // Pour les C.L. // scalaire H_M -3.2e-4 // // Composante Visco-elastique // // composante purement elas booleen E_InfVieillissant v scalaire "IndicateurEtat_Inf" 0 scalaire "Integrale_bInf" f(Alpha,M,M12,MP)=0.05*(2.0+Alpha*(M-M12)+Alpha*(MP-M12)) to4elasticite "ERef_Infijkl" [EL,ET,ER,VLT,VTR,VLR,GLT,GRT,GLR] // // Branche v-e // scalaire "NombreBrancheViscoElastique" 1 { Branche_00 scalaire "Coeff" 6 scalaire "CoeffVisco" 9 scalaire "CoeffEL" f(Coeff,EL)=Coeff*EL scalaire "CoeffER" f(Coeff,ER)=Coeff*ER scalaire "CoeffET" f(Coeff,ET)=Coeff*ET scalaire "CoeffGLR" f(Coeff,GLR)=Coeff*GLR scalaire "CoeffGLT" f(Coeff,GLT)=Coeff*GLT scalaire "CoeffGRT" f(Coeff,GRT)=Coeff*GRT scalaire "CoeffViscoEL" f(CoeffVisco,EL)=CoeffVisco*EL scalaire "CoeffViscoER" f(CoeffVisco,ER)=CoeffVisco*ER scalaire "CoeffViscoET" f(CoeffVisco,ET)=CoeffVisco*ET scalaire "CoeffViscoGLR" f(CoeffVisco,GLR)=CoeffVisco*GLR scalaire "CoeffViscoGLT" f(CoeffVisco,GLT)=CoeffVisco*GLT scalaire "CoeffViscoGRT" f(CoeffVisco,GRT)=CoeffVisco*GRT to4elasticite "ERef_ijkl" [CoeffEL,CoeffET,CoeffER,VLT,VTR,VLR,CoeffGLT,CoeffGRT,CoeffGLR] to4elasticite "ViscoRef_ijkl" [CoeffViscoEL,CoeffViscoET,CoeffViscoER,VLT,VTR,VLR,CoeffViscoGLT,CoeffViscoGRT,CoeffViscoGLR] booleen MateriauVieillissant f #booleen MateriauVieillissant v scalaire "Alpha" -0.015 scalaire "PtZeroCinq" 0.05 scalaire "M12" 12 #scalaire "DeriveeMultiplicateur_b" 0 #scalaire "DeriveeMultiplicateur_bPrecedent" 0 scalaire "Multiplicateur_b" f(Un,Alpha,M,M12)=Un+Alpha*(M-M12) scalaire "Multiplicateur_bPrecedent" f(Un,Alpha,MP,M12)=Un+Alpha*(MP-M12) empilementto4 "FonctElasViscoRef_ijkl" [Un,Zero,Un, Un,Zero,Un, Zero,Zero,Zero,Un,Zero,Zero,Zero,Zero,Un,Un,Zero,Un,Zero,Zero,Un] scalaire "DeltaTempsReduit" .1 #scalaire "MultiplicateurLambda_l" 1 #scalaire "MultiplicateurLambda_lPrecedent" 1 scalaire "IndicateurEtat" f(M,MP)=(M-MP) } # # 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 26 scalaire TempsImpose_0 0.5 scalaire TempsImpose_1 21600.0 scalaire TempsImpose_2 172800 scalaire TempsImpose_3 267840.0 scalaire TempsImpose_4 276480.0 scalaire TempsImpose_5 691200 scalaire TempsImpose_6 820800.0 scalaire TempsImpose_7 1123200 scalaire TempsImpose_8 1296000 scalaire TempsImpose_9 1468800 scalaire TempsImpose_10 1900800 scalaire TempsImpose_11 2008800.0 scalaire TempsImpose_12 2116800.0 scalaire TempsImpose_13 2181600.0 scalaire TempsImpose_14 2224800.0 scalaire TempsImpose_15 2311200.0 scalaire TempsImpose_16 2570400.0 scalaire TempsImpose_17 2700000.0 scalaire TempsImpose_18 2851200 scalaire TempsImpose_19 3024000 scalaire TempsImpose_20 3153600.0 scalaire TempsImpose_21 3326400.0 scalaire TempsImpose_22 3412800.0 scalaire TempsImpose_23 3585600.0 scalaire TempsImpose_24 3672000.0 scalaire TempsImpose_25 3801600 scalaire TempsImpose_00 0 scalaire rhc0 17.3 scalaire rhc1 16.3 scalaire rhc2 16.3 scalaire rhc3 18.6 scalaire rhc4 16.9 scalaire rhc5 16.9 scalaire rhc6 16.1 scalaire rhc7 16.1 scalaire rhc8 17.3 scalaire rhc9 15.7 scalaire rhc10 15.7 scalaire rhc11 18. scalaire rhc12 19. scalaire rhc13 16.1 scalaire rhc14 18.1 scalaire rhc15 16.1 scalaire rhc16 16.1 scalaire rhc17 18.6 scalaire rhc18 16.3 scalaire rhc19 16.3 scalaire rhc20 18.6 scalaire rhc21 17.1 scalaire rhc22 18.3 scalaire rhc23 18.3 scalaire rhc24 16.1 scalaire rhc25 18.3 scalaire rhc100 f(TempsImpose_00,TempsImpose_1,TempsImpose_2,TempsImpose_3,TempsImpose_4,\ TempsImpose_5,TempsImpose_6,TempsImpose_7,TempsImpose_8,TempsImpose_9,\ TempsImpose_10, TempsImpose_11,TempsImpose_12,TempsImpose_13,TempsImpose_14,\ TempsImpose_15,TempsImpose_16,TempsImpose_17,TempsImpose_18,TempsImpose_19,\ TempsImpose_20,TempsImpose_21,TempsImpose_22,TempsImpose_23,TempsImpose_24,\ TempsImpose_25,rhc0,rhc1,rhc2,rhc3,rhc4,rhc5,rhc6,rhc7,rhc8,rhc9,rhc10,\ rhc11,rhc12,rhc13,rhc14,rhc15,rhc16,rhc17,rhc18,rhc19,rhc20,rhc21,rhc22,\ rhc23,rhc24,rhc25)=\ (rhc0+(rhc1-rhc0)*(t-TempsImpose_00)/(TempsImpose_1-TempsImpose_00))*(t<=TempsImpose_1)*(t>=TempsImpose_00)+\ (rhc1+(rhc2-rhc1)*(t-TempsImpose_1)/(TempsImpose_2-TempsImpose_1))*(t<=TempsImpose_2)*(t>TempsImpose_1)+\ (rhc2+(rhc3-rhc2)*(t-TempsImpose_2)/(TempsImpose_3-TempsImpose_2))*(t<=TempsImpose_3)*(t>TempsImpose_2)+\ (rhc3+(rhc4-rhc3)*(t-TempsImpose_3)/(TempsImpose_4-TempsImpose_3))*(t<=TempsImpose_4)*(t>TempsImpose_3)+\ (rhc4+(rhc5-rhc4)*(t-TempsImpose_4)/(TempsImpose_5-TempsImpose_4))*(t<=TempsImpose_5)*(t>TempsImpose_4)+\ (rhc5+(rhc6-rhc5)*(t-TempsImpose_5)/(TempsImpose_6-TempsImpose_5))*(t<=TempsImpose_6)*(t>TempsImpose_5)+\ (rhc6+(rhc7-rhc6)*(t-TempsImpose_6)/(TempsImpose_7-TempsImpose_6))*(t<=TempsImpose_7)*(t>TempsImpose_6)+\ (rhc7+(rhc8-rhc7)*(t-TempsImpose_7)/(TempsImpose_8-TempsImpose_7))*(t<=TempsImpose_8)*(t>TempsImpose_7)+\ (rhc8+(rhc9-rhc8)*(t-TempsImpose_8)/(TempsImpose_9-TempsImpose_8))*(t<=TempsImpose_9)*(t>TempsImpose_8)+\ (rhc9+(rhc10-rhc9)*(t-TempsImpose_9)/(TempsImpose_10-TempsImpose_9))*(t<=TempsImpose_10)*(t>TempsImpose_9)+\ (rhc10+(rhc11-rhc10)*(t-TempsImpose_10)/(TempsImpose_11-TempsImpose_10))*(t<=TempsImpose_11)*(t>TempsImpose_10)+\ (rhc11+(rhc12-rhc11)*(t-TempsImpose_11)/(TempsImpose_12-TempsImpose_11))*(t<=TempsImpose_12)*(t>TempsImpose_11)+\ (rhc12+(rhc13-rhc12)*(t-TempsImpose_12)/(TempsImpose_13-TempsImpose_12))*(t<=TempsImpose_13)*(t>TempsImpose_12)+\ (rhc13+(rhc14-rhc13)*(t-TempsImpose_13)/(TempsImpose_14-TempsImpose_13))*(t<=TempsImpose_14)*(t>TempsImpose_13)+\ (rhc14+(rhc15-rhc14)*(t-TempsImpose_14)/(TempsImpose_15-TempsImpose_14))*(t<=TempsImpose_15)*(t>TempsImpose_14)+\ (rhc15+(rhc16-rhc15)*(t-TempsImpose_15)/(TempsImpose_16-TempsImpose_15))*(t<=TempsImpose_16)*(t>TempsImpose_15)+\ (rhc16+(rhc17-rhc16)*(t-TempsImpose_16)/(TempsImpose_17-TempsImpose_16))*(t<=TempsImpose_17)*(t>TempsImpose_16)+\ (rhc17+(rhc18-rhc17)*(t-TempsImpose_17)/(TempsImpose_18-TempsImpose_17))*(t<=TempsImpose_18)*(t>TempsImpose_17)+\ (rhc18+(rhc19-rhc18)*(t-TempsImpose_18)/(TempsImpose_19-TempsImpose_18))*(t<=TempsImpose_19)*(t>TempsImpose_18)+\ (rhc19+(rhc20-rhc19)*(t-TempsImpose_19)/(TempsImpose_20-TempsImpose_19))*(t<=TempsImpose_20)*(t>TempsImpose_19)+\ (rhc20+(rhc21-rhc20)*(t-TempsImpose_20)/(TempsImpose_21-TempsImpose_20))*(t<=TempsImpose_21)*(t>TempsImpose_20)+\ (rhc21+(rhc22-rhc21)*(t-TempsImpose_21)/(TempsImpose_22-TempsImpose_21))*(t<=TempsImpose_22)*(t>TempsImpose_21)+\ (rhc22+(rhc23-rhc22)*(t-TempsImpose_22)/(TempsImpose_23-TempsImpose_22))*(t<=TempsImpose_23)*(t>TempsImpose_22)+\ (rhc23+(rhc24-rhc23)*(t-TempsImpose_23)/(TempsImpose_24-TempsImpose_23))*(t<=TempsImpose_24)*(t>TempsImpose_23)+\ (rhc24+(rhc25-rhc24)*(t-TempsImpose_24)/(TempsImpose_25-TempsImpose_24))*(t<=TempsImpose_25)*(t>TempsImpose_24)+\ rhc25*(t>TempsImpose_25) scalaire rhc f(rhc100)=(rhc100)/100. scalaire MInfini f(rhc100)=(6.3 + (rhc100-20.)/5.) # # valeur specifique au solveurInstNlinPETSc et solveurLinPETSc # # Tolerance accrue pour le solveur scalaire ToleranceLin 5e-8 scalaire ToleranceLinMec 5e-8 scalaire ToleranceLinMecR 1e-40 scalaire Divergence 1e+10 scalaire TolerancePointFixe 1e-8 scalaire NombreMaximalIterationsPointFixe 400 # # valeur specifique au solveurInstNlinPETSc et solveurLinPETSc # # tolerance pour le calcul des pas de temps scalaire TolerancePasVariable 5e-3 # Tolerance accrue pour le solveur non lineaire # Tolerance pour la convergence des solveurs scalaire ToleranceNlin 1e-9 # nombre maximum d'iterations pour les solveur scalaire MaxItNlin 200 scalaire MaxItLin 7000 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 ## 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" aucun #solveurlinpetsc type_matrice "SolveurLin" MUMPS solveurlinpetsc tolerance "SolveurLin" [ToleranceLin,ToleranceLin,Divergence,MaxItLin] solveurinstnlinpetsc typesolveur "SolveurInst" solveurinstnlinpetsc solveurlin "SolveurInst" SolveurLin solveurinstnlinpetsc parametresnlin "SolveurInst" [ToleranceNlin,MaxItNlin,v] solveurinstnlinpetsc parametresinst "SolveurInst" [LongueurPasDeTemps, NombreDePasDeTemps, TempsInitial, 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 NombreDePasDeTemps) # solveurinstnlinpetsc pasdetempsvariable "SolveurInst" [LongueurPasDeTemps,LongueurMaximalePasDeTemps,TempsFinal,TolerancePasVariable] #solveurlinpetsc typesolveur "SolveurLinmecanique" gradient_conjugue #solveurlinpetsc typeprecond "SolveurLinmecanique" sor #solveurlinpetsc configprecondsor "SolveurLinmecanique" [v,0.7] #solveurlinpetsc typesolveur "SolveurLinmecanique" direct #solveurlinpetsc type_matrice "SolveurLinmecanique" MUMPS #solveurlinpetsc suiviconvergence "SolveurLinmecanique" aucun #solveurlinpetsc tolerance "SolveurLinmecanique" [ToleranceLinMecR,ToleranceLinMec,Divergence,MaxItLinMec] #################################################################### # Configuration pour Solveur HP # On déclare le solveur lin. au niveau P1 solveurlinpetsc typesolveur solveur_P1 precondseulement solveurlinpetsc typeprecond solveur_P1 sor solveurlinpetsc configprecondsor solveur_P1 [true,1,1] # On déclare un solveur lin. pour la partie smoothing pour HP solveurlinpetsc typesolveur solveurP2 precondseulement solveurlinpetsc typeprecond solveurP2 sor solveurlinpetsc configprecondsor solveurP2 [true,1,1] solveurhp config_solveurs_P1_P2 SolveurMec [solveurP2,solveur_P1,true] solveurhp typesolveur SolveurMec gradientconjugue solveurhp typeprecond SolveurMec usager #solveurhp config_solveur_richardson SolveurMec [1.0] # #################################################################### #solveurlinpetsc typesolveur "SolveurMec" direct #solveurlinpetsc typesolveur "SolveurMec" gmres #solveurlinpetsc typeprecond "SolveurMec" sor //gmres #solveurlinpetsc configprecondsor "SolveurMec" [v] solveurlinpetsc suiviconvergence "SolveurMec" defaut //changer defaut par aucun pour ne pas afficher les echos solveurlinpetsc tolerance "SolveurMec" [ToleranceLin,ToleranceLin,Divergence,MaxItLin] #solveurlinpetsc typematrice "SolveurMec" MUMPS # # 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 9 vectoriel3d Coord_0 [0.3045,0.05395,0.0187] vectoriel3d Coord_1 [0.3045,0.,0.0187] vectoriel3d Coord_2 [0.609,0.,0.0187] vectoriel3d Coord_3 [0.609,0.05395,0.0187] vectoriel3d Coord_4 [0.609,0.1079,0.0187] vectoriel3d Coord_5 [0.,0.1079,0.0187] vectoriel3d Coord_6 [0.3045,0.1079,0.0187] vectoriel3d Coord_7 [0.,0.05395,0.0187] vectoriel3d Coord_8 [0.,0.0,0.0187]