IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

  1. #1
    Nouveau Candidat au Club
    Femme Profil pro
    Étudiant
    Inscrit en
    décembre 2020
    Messages
    2
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Âge : 21
    Localisation : France, Pyrénées Atlantiques (Aquitaine)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : décembre 2020
    Messages : 2
    Points : 1
    Points
    1
    Par défaut Erreur : Program received signal SIGSEGV: Segmentation fault - invalid memory reference.
    Bonjour à tous,

    J'essaie de coder Runge Kutta Merson sur fortran, malheureusement, ce message d'erreur apparait : "Program received signal SIGSEGV: Segmentation fault - invalid memory reference.

    Backtrace for this error: #0 ffffffff" et je ne sais pas comment le résoudre.

    Je dispose d'un module, du programme principal et d'un fichier source (il est en pièce jointe).

    Après de nombreux affichages de 'print', le problème se situerait à l'entrée de la subroutine RKMerson.

    Le code pour le module et le programme principal sont affichés en dessous, merci d'avance pour vos réponses, ce code étant déterminant pour la validation de mon année ...



    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    MODULE mod_parametrage
     
        IMPLICIT NONE
     
        DOUBLE PRECISION:: z                                       ! abscisse
        DOUBLE PRECISION:: dz                                      ! pas de calcul
        INTEGER:: zmax                                             ! Longueur du réacteur
        INTEGER:: n                                                ! nombre de pas
        DOUBLE PRECISION,dimension(:,:),ALLOCATABLE:: Resultats            ! A l'appel ce tableau contient les valeurs y initiales
        INTEGER, PARAMETER::NbEquation=5                           ! nombre d'equations dans le systeme différentiel
        DOUBLE PRECISION,dimension(NbEquation):: F,Y
        DOUBLE PRECISION:: Debit
        INTEGER:: i,j,h                                            ! pour l'itération
        CHARACTER*20:: A                                           ! nom des données jamais de plus de 20 charactères
        DOUBLE PRECISION:: z1,z2,z3,z4,z5
        DOUBLE PRECISION,dimension(NbEquation):: y1,y2,y3,y4,y5,K1,K2,K3,K4,K5
        CONTAINS
     
    SUBROUTINE init()
     
       ! 3) IL faut ouvrir un fichier texte, lire les valeurs initiales et les mettre en première colonne du tableau
     
        OPEN(unit = 10, file = 'fichier_source.txt', STATUS='OLD',ACTION='READ')
     
     
        ! 2) Déclaration des variables locales
     
        z = 0                                           ! Longueur initiale
        dz = 0.5                                        !Pas de calcul fixé
        zmax = 0                                        ! On teste une seule itération
        n = int(zmax/dz)+1                              ! Calcul du nombre de pas total
        ALLOCATE(Resultats(NbEquation,n+1))
     
     
     
        DO h = 1, NbEquation
     
            READ(10,*) A,Resultats(h,1)
     
            !PRINT*, A,Resultats(h,1)
     
        END DO
     
        CLOSE (10)
     
    END SUBROUTINE init
     
     
    SUBROUTINE RKMERSON(NbEquation,y,z,derivee)
     
        DOUBLE PRECISION::y(NbEquation),z,dz
        INTEGER::NbEquation
        DOUBLE PRECISION,dimension(NbEquation):: K1,K2,K3,K4,K5
        DOUBLE PRECISION,dimension(:,:),ALLOCATABLE:: Resultats
     
        ! Application de la méthode de Runge Kutta
     
        Do i = 1,NbEquation
     
            y(i)=Resultats(i,1)
     
        END DO
     
        PRINT*,'y'
     
     
        DO j = 1,n
     
            z=z+(dz*(j-1))
     
     
    !calcul de K1
     
                PRINT*,'avant call derivee K1'
     
            CALL derivee(NbEquation,y1,z1,K1)
     
                z1=z
     
                DO i=1,NbEquation
                    y1(i)=y(i)
                END DO
     
                PRINT*,'apres call derivee K1'
     
     
    !calcul de K2
     
                CALL derivee(NbEquation,y2,z2,K2)
     
                z2=z+(dz/3)
                DO i=1,NbEquation
                y2(i)=y(i)+(dz/3)*K1(i)
                END DO
     
    !calcul de K3
     
                CALL derivee(NbEquation,y3,z3,K3)
     
                z3=z+(dz/3)
                DO i=1,NbEquation
                    y3(i)=y(i)+(dz/6)*(K1(i)+K2(i))
                END DO
     
     
    !calcul de K4
     
                CALL derivee(NbEquation,y4,z4,K4)
     
                z4=z+(dz/2)
                DO i=1,NbEquation
                    y4(i)=y(i)+(dz/8)*(K1(i)+3*K3(i))
                END DO
     
     
    !calcul de K5
     
                CALL derivee(NbEquation,y5,z5,K5)
     
                z5=z+dz
     
                DO i=1,NbEquation
                    y5(i)=y(i)+(dz/2)*(K1(i)-3*K3(i)+K4(i))
                END DO
     
    !Calcul des nouvelles compositions
     
                Do i =1, NbEquation
                    y(i)=y(i)+(dz/6)*(K1(i)+4*K4(i)+K5(i))
                    Resultats(i,j+1)=y(i)
                End Do
     
        END DO
     
    END SUBROUTINE RKMERSON
     
    SUBROUTINE derivee(NbEquation,y,z,F)
     
        DOUBLE PRECISION:: c1,c2,c3,r1,r2,r3,rH2,rCH4,rB,rT,rD,S,diametre,pi,z
        DOUBLE PRECISION::y(NbEquation),F(NbEquation)
        INTEGER::NbEquation
     
     
        pi=3.14
        diametre=1
     
        S=pi*((diametre**2)/4)
     
     
        !attention P varie avec T PV=nRT
     
        c1= (3.6858*(10**6))*exp((-2.5616*10**4)/895)
        c2= 0.62717*exp((-1.5362*10**4)/895)
        c3= 0.08124*exp((-1.2237*10**4)/895)
     
        PRINT*,c1,c2,c3
     
     
        r1=(c1*y(4)*sqrt(y(1))*((550*6894.76)**(1.5)))      !1PSI=6894.76Pa
        r2=c2*(y(3)**2)*((550*6894.76)**2)
        r3=c3*y(5)*y(1)*((550*6894.76)**2)
     
        !PRINT*, r1,r2,r3
     
        rH2=-r1+r2-r3
        rCH4=r1
        rB=r1-2*r2+2*r3
        rT=-r1
        rD=r2-r3
     
        F(1)=(S*rH2)/Debit
        F(2)=(S*rCH4)/Debit
        F(3)=(S*rB)/Debit
        F(4)=(S*rT)/Debit
        F(5)=(S*rD)/Debit
     
        !PRINT*,F
     
    END SUBROUTINE derivee
     
     
     
    END MODULE mod_parametrage
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
     
     PROGRAM ProgP
     
        USE mod_parametrage
     
        IMPLICIT NONE
     
        CALL init
     
        PRINT*,'avant RKMERSON'
     
        CALL RKMERSON(NbEquation,y,z,derivee)
     
        PRINT*,'apres RKMERSON'
     
     
        PRINT*,'Resultats', Resultats
     
     
     
     END PROGRAM ProgP
    Fichiers attachés Fichiers attachés

  2. #2
    Membre confirmé
    Profil pro
    Inscrit en
    mars 2007
    Messages
    483
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : mars 2007
    Messages : 483
    Points : 586
    Points
    586
    Par défaut
    Bonjour,

    Ajouter des print pour voir ce qui ce passe est une bonne idée.
    Ajouter des option de débogage à la compilation pour mieux identifier les problèmes à l'exécution aide aussi souvent beaucoup.
    Si on compile par exemple ces codes avec:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    gfortran mod_parametrage.F90 ProgP.F90 -ffpe-trap=invalid,zero,overflow -fbounds-check -g3 -O0 -fstack-protector-all -finit-real=snan -fbacktrace -o ProgP
    Alors l'exécution plante avec:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
     
    ./ProgP
     avant RKMERSON
    At line 60 of file mod_parametrage.F90
    Fortran runtime error: Index '1' of dimension 2 of array 'resultats' above upper bound of 0
     
    Error termination. Backtrace:
    #0  0x401ac2 in __mod_parametrage_MOD_rkmerson
    	at /home/Playground/tests_fortran/mod_parametrage.F90:60
    #1  0x402fee in progp
    	at /home/Playground/tests_fortran/ProgP.F90:12
    #2  0x403130 in main
    	at /home/Playground/tests_fortran/ProgP.F90:4
    Le problème est donc lié à la ligne 60 de mod_parametrage; effectivement y est utilisé le tableau allouable "Resultats" alors que ce tableau n'a jamais été alloué...

  3. #3
    Nouveau Candidat au Club
    Femme Profil pro
    Étudiant
    Inscrit en
    décembre 2020
    Messages
    2
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Âge : 21
    Localisation : France, Pyrénées Atlantiques (Aquitaine)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : décembre 2020
    Messages : 2
    Points : 1
    Points
    1
    Par défaut Remerciement
    Merci beaucoup !

    Je ne connaissais pas les options de débogage à la compilation, cela va mettre d'une grande aide !

    Effectivement, je n'avais pas alloué le tableau au bon endroit.

    Bonne soirée, et encore merci.

  4. #4
    Membre habitué

    Profil pro
    Inscrit en
    décembre 2010
    Messages
    55
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : décembre 2010
    Messages : 55
    Points : 149
    Points
    149
    Billets dans le blog
    1
    Par défaut -g3
    Citation Envoyé par Ehouarn Voir le message
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    gfortran mod_parametrage.F90 ProgP.F90 -ffpe-trap=invalid,zero,overflow -fbounds-check -g3 -O0 -fstack-protector-all -finit-real=snan -fbacktrace -o ProgP
    Merci, je ne connaissais pas l'option -g3
    D'après ce que je lis ci-dessous, -g est équivalent à -g2 :
    https://stackoverflow.com/questions/...the-difference
    et -g3 ajoute des informations supplémentaires, en particulier concernant les macros (donc utile en C mais peut-être pas en Fortran ?).

  5. #5
    Membre confirmé
    Profil pro
    Inscrit en
    mars 2007
    Messages
    483
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : mars 2007
    Messages : 483
    Points : 586
    Points
    586
    Par défaut
    Bonjour,

    Je n'ai pas d'arguments forts pour préconiser "-g3" (plutôt que "-g") vu que c'est à ma connaissance surtout pertinent pour l'utilisation d'un débogueur comme gdb.
    En ce qui concerne l'aspect macro, il me semble que comme ces définitions sont au niveau du préprocesseur, elles pourraient s'appliquer aussi bien à du code Fortran que du C (mais personnellement je ne les utilises pas plus que ça; donc je dis peut-être là des bêtises).

    A propos d'options pour aider au débogage, je réalise que j'ai oublié dans le lot "-Wall" qui donne souvent à la compilation des indications judicieuses sur de potentielles incohérences (utilisation d'une variable avant de l'avoir initialisé, etc.).

Discussions similaires

  1. Réponses: 2
    Dernier message: 26/12/2013, 09h19
  2. Réponses: 2
    Dernier message: 23/04/2012, 23h07
  3. Réponses: 2
    Dernier message: 07/03/2010, 00h20
  4. Réponses: 0
    Dernier message: 10/01/2008, 23h28
  5. Réponses: 15
    Dernier message: 15/04/2007, 13h31

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo