Probleme de codage

Version imprimable

Probleme de codage

Bonjour,

J'aurai besoin d'aide pour mon exo voici le sujet:

En guise d’introduction à la méthode de simulation de Monte-Carlo
(http://fr.wikipedia.org/wiki/M%C3%A9...de_Monte-Carlo), on se propose de
programmer un petit système simple de particules non chevauchantes qui se déplacent
aléatoirement.
On considère un système de 50 particules dont on vous fournit les coordonnées de départ au
format PDB (repère orthonormé avec les coordonnées en Å). Après avoir lu les coordonnées
de chaque atome, on souhaite réaliser 1000 itérations au cours desquelles on effectue les
opérations suivantes :
• on choisit une particule au hasard
• on fait subir un mouvement au hasard à cette particule en changeant ses coordonnées
d'un pas tiré au hasard dans l'intervalle [-2 Å; 2 Å ]
• calcul des distances entre toutes les paires d'atomes possibles
• si une distance est inférieure à un seuil s=1 Å, on refuse le mouvement
• tous les 10 pas on écrit les coordonnées actuelles du système dans un fichier au format
PDB

Et voici se que j'ai fait:

Code:

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
# -*- coding: cp1252 -*-
 
# import des modules nécessaires
 
import random
import math
 
 
#-----------------------------------
# Fonction de lecture du ficier pdb
#  Nom       : lire_fic_pdb()
#  Arguments : fichier_pdb
#  Retour    : rien
#----------------------------------
 
def lire_fic_pdb (fichier_pdb):
    fichier = open (fichier_pdb, 'r')
    lignes_pdb = fichier.readlines()
    fichier.close()
    #affichage de toutes les lignes lues
    #------------------------------------
    global liste_atomes
    liste_atomes=[]
    for i in lignes_pdb:
        liste_atomes.append(i[0:-1])
        # print liste_atomes
    #------------------------------------
    return lignes_pdb
 
#-------------------------------------------------------------
# Fonction de lecture des coordonnees de chaque atome (ligne)
# Nom       : lire_coord_atome
# Arguments : ligne
# Retour    : coordonnees (x,y,z) des atomes du fichier
#-------------------------------------------------------------
def lire_coord_atome(ligne):
    x = float(ligne[30:38])
    y = float(ligne[38:46])
    z = float(ligne[46:54])
    A = [x,y,z]
    return A
 
 
 
#-------------------------------------------------------------
# Fonction d'extraction aléatoire d'un atome et de ses coordonnees
# Nom       : extract_atome_coor
# Arguments : ligne
# Retour    : coordonnees (x,y,z) de l'atome choisi aléatoirement
#-------------------------------------------------------------
 
def extract_atome_coor (liste_atomes):
    global u
    u = random.randint(1,len(liste_atomes))
    j=0
    for i in liste_atomes:
        # affiche toutes les lignes dans une liste:
        # print liste_atomes[j]
        j=j+1
        if j==u:
            B = lire_coord_atome(i)
            #print "L'atome tiré au hasard est l'atome n°",u, ";et ses coordonnees sont ",B
    return B
 
 
 
#-------------------------------------------------------------
# Fonction de modification de la position de la particule
# Nom       : extract_atome_coor
# Arguments : ligne
# Retour    : coordonnees (x,y,z) de l'atome
#-------------------------------------------------------------
 
def modif_particule (liste):
    valeur_hasard = random.randint(0,2)
    hasardfloat = random.uniform(-2.0,2.0)
    #print hasardfloat
    if valeur_hasard == 0:
        liste[0]=liste[0]+hasardfloat
    if valeur_hasard == 1:
        liste[1]=liste[1]+hasardfloat
    if valeur_hasard == 2:
        liste[2]=liste[2]+hasardfloat
    print liste
    return liste
 
#-------------------------------------------------------------
# Fonction de calcul des carrés des coordonnées
# Nom       : carre
# Arguments : élément d'une liste
# Retour    : carrés des coordonnées
#-------------------------------------------------------------
 
def carre(x):
    return x*x
 
#-------------------------------------------------------------
# Fonction de calcul des distances entre particules
# Nom       : distance
# Arguments : deux éléments de listes
# Retour    : distance
#-------------------------------------------------------------
 
def distance(A,B):
    xcarre = carre(B[0] - A[0])
    ycarre = carre(B[1] - A[1])
    zcarre = carre(B[2] - A[2])
    dist = math.sqrt(xcarre + ycarre + zcarre)
    return dist
 
 
def calcul_distance_atomes (lignes_pdb,A,u):
    n=0
    for lig in lignes_pdb:
        n=n+1
        if n != u:
        #print lire_coord_atome(k)
            distcalc=distance(A,lire_coord_atome(lig))
            if distcalc < 1:
                print lignes_pdb[n]
                print "La distance entre l'atome n°",u,"et l'atome n°",n,"est inférieure à 1, on garde donc les anciennes coordonnées"
            else:
                #n =2
                #print "split ", lignes_pdb[n].split()
                print "La distance entre l'atome n°",u,"et l'atome n°",n,"est supérieure à 1",distcalc
 
 
#====================================================
# programme principal
#====================================================
 
# Lecture du fichier et extraction des lignes
 
lig_pdb = lire_fic_pdb ('starting_structure.pdb')
 
 
fichier_out = open("resultats.pdb", "w")
 
for k in range (1,10):
    #print "####################  ITERATION n° ",k,"  ############################"
    # Extration aleatoire d'un atome et retour de ses coordonnees
    C = extract_atome_coor (lig_pdb)
    # Affichage des nouvelles coordonnees de l'atome
    modif_particule (C)
    #print "le numéro de l'atome choisi est", u
    calcul_distance_atomes (lig_pdb, C, u)
 
    n = 0
    for i in lig_pdb:
        n = n+1
        if n == u:
            Q = []
            Q.append(C[0])
            print Q
    # Y = []
    # Y.append(C[1]
    # Z = []
    # Z.append(C[2])
    # i[0:31]+i[31:38]+i[38:46]+i[46:54]+i[54:-1] 
            print float(i[31:38]) + float(Q[0:7])
            # print i[31:38] + Q[0:7]
    # float(i[38:46]) + float (Q[0:7])
    # float(i[31:38]) + float (Q[0:7])
 
 
 
 
 
    #print "lig_pdb ", lig_pdb
    if k % 2 == 0:
        print "C =", C
        for i in lig_pdb:
            fichier_out.write(i)
        #fichier_out.write('ATOM      1  AR  ARG     1      -7.542   5.187   9.163  1.00  0.00')
        #fichier_out.write( "%d \n" %(nb_atomes) )
 
 
fichier_out.close()

j'ai une erreur a la ligne en rouge et je ne comprend pas comment il faut la corriger.

Merci d'avance. C'est assez urgent si vous pouviez m'aider.

Bonsoir,

Citation:

Envoyé par nhella22

j'ai une erreur a la ligne en rouge et je ne comprend pas comment il faut la corriger.

Difficile sans l'erreur.

starting_structure.pdb est il dans le même répertoire que ton script ?
Sinon essai de faire lig_pdb = lire_fic_pdb ("/chemindetonfichier/starting_structure.pdb")
Ou pour tester
Code:

1 2 3 4 import os.path if os.path.isfile("/chemindetonfichier/starting_structure.pdb"): lig_pdb = lire_fic_pdb ("/chemindetonfichier/starting_structure.pdb") else: print 'erreur' # ou print ('erreur') suivant la version de python.
Sinon donne l'erreur.

@+

Bonjour,

Dans la fonction extract_atome_coor (liste_atomes) , tu sélectionnes au hasard un atome dans la liste_atomes en tirant au hasard un entier u entre 1 et len(liste_atomes)

La façon dont tu itères ensuite dans liste_atomes en incrémentant un entier j pour t’arrêter quand j==u fait que u est en fait l’index de l’atome i que tu choisis, c'est à dire le numéro d’ordre de i dans liste_atomes.

L’atome i s’obtient donc plus simplement par i = liste_atomes[u]

Ça aura aussi l’avantage d’éliminer une erreur invisible la plupart du temps: en commençant l’itération à 1 tu sautes systématiquement le premier atome. Car l’indiçage d’une liste commence par 0: li[0] et le premier élément d’une liste li.

D’autre part, u est nécessaire en dehors de la fonction, tu en as fait une valeur globale. Mais ce n’est pas une bonne pratique. Il vaut mieux faire sortir u de la fonction par le return.

L’instruction return peut sortir n’importe quel type de donnée:
return u,B marchera parfaitement, en faisant sortir un couple (tuple à deux éléments) de la fonction.

Mais le mieux encore, vue la simplicité de la fonction, c’est d’intégrer le instructions au sein du code général , ce qui évitera au programme de perdre du temps à appeler une fonction pour calculer quelque chose de fort simple.
Code:

1 2 u = random.randrange(len(liste_atomes)) C =lire_coord_atome(lig_pdb[u])
De même, il est totalement superflu d’utiliser une fonction carre() pour 3 calculs.
Il vaut mieux faire:
Code:

1 2 3 xcarre = (B[0] - A[0])**2 ycarre = (B[1] - A[1]])**2 zcarre = (B[2] - A[2]])**2
j'ecrirais meme:

Code:

dist = math.sqrt((B[0] - A[0])**2 + (B[1] - A[1])**2 + (B[2] - A[2])**2)

for i in lig_pdb:

i est un élément de lig_pdb qui a été défini par

Code:

lig_pdb = lire_fic_pdb ('starting_structure.pdb')

Et lire_fic_pdb () renvoie lignes_pdb qui est fichier.readlines() donc une liste de lignes AVEC LEURS FINS DE LIGNES.

Sans doute est-ce parce que i[31:38] ne s’arrête pas avant la fin de ligne que float(i[31:38]) provoque une erreur.
Je suppose.
Manifestement, penser à poster le message d’erreur demande à la plupart des questionneurs une sagacité hors d’atteinte...

Pour ce qui est de def lire_fic_pdb (fichier_pdb):
cette fonction crée liste_atomes en tant que variable globale
et il s’agit d’une liste de lignes du fichier_pdb dont ont été retirées les fins de lignes,
tandis que ce qui est renvoyé est lignes_pdb, une liste de lignes avec les fins de lignes.
Ce n’est pas très cohérent. Il faut faire créer par cette fonction une seule liste_atomes et basta. Pour éviter les fins de ligne, read().split() au lieu de readlines() règle le souci:
Code:

1 2 3 def lire_fic_pdb (fichier_pdb): with open (fichier_pdb, 'r') as fichier return fichier.read().splitlines()
Là encore, c’est tellement simple qu’il est oiseux de mettre ça dans une fonction.

Donc moi j'ai ça comme code executoire:
Code:

1 2 3 4 5 6 7 8 9 10 11 with open ('starting_structure.pdb', 'r') as fichier liste_atomes = fichier.read().splitlines() fichier_out = open("resultats.pdb", "w") for k in range (1,10): #print "#################### ITERATION n° ",k," ############################" # Extration aleatoire d'un atome et retour de ses coordonnees u = random.randrange(len(liste_atomes)) C = lire_coord_atome(liste_atomes[u])
Bon, il y a d’autres choses à corriger, mais n’ayant pas les bases de départ, je me perds dans l’algorithme un peu trouble.

08/05/2010, 16h59
nhella22

Merci pour votre aide a tous c'est trés gentil cela m'a beaucoup aidé