Discussion :

[soria_t]

A partir des coordonnées des atomes je dois calculer la distance entre deux molécules .
Par exemples à partir des barycentres des molécules ou de tous les carbones....
Pour cela il faut traiter en simultanée deux fichier avec des tailles tout à fait différentes.

Non, j'ai l'impression que ce n'est pas trivial. Et comme c'est le premier programme que je fais , j'avoue trouver ça un peu au dessus de mes possibilitées parfois.

[Emmanuel Delahaye]

A partir des coordonnées des atomes je dois calculer la distance entre deux molécules .
Par exemples à partir des barycentres des molécules ou de tous les carbones....
Pour cela il faut traiter en simultanée deux fichier avec des tailles tout à fait différentes.

Pour y comprendre quelque chose (désolé, je ne suis qu'informaticien, et ma spécialité, c'est l'électronique et les réseaux, pas la chimie ni la physique moléculaire), il faudrait définir clairement le sens de chaque champ de la ligne. Pour le moment, pour moi, ce ne sont que des lettres et des chiffres...

(je crois deviner, vu le contexte, Nitrium (azote), CAlcium, Carbone, Oxygène... Mais le reste... ARGon ?)

[romain.barraud]

Si je comprend bien, tu as besoin de récupérer les données issues de la Protein data bank ... tu récupères ce fichier sous quel format ?
A priori, ces fichiers de sortie sont standardisés : je proposerais plutot d'écrire un script perl qui te récupérera uniquement ce dont tu as besoin dans un fichier annexe (Atome) dans lequel tu pourra mettre sur la première ligne le nombre d'atomes(compteur dans le script) et sur les lignes suivantes ta "séquence" d'atomes.
Je privilégie les scripts perl pour l'extraction des données dans un fichier et le traitement ensuite avec un programme C. C'est beaucoup plus simple à mon avis pour les recherches de motifs protéiques, domaines protéiques ...
En tout cas c'est mon avis !
Bon courage

[romain.barraud]

Tu ne peux pas réaliser ce type de travaux avec Rasmol ? (modelisation moléculaire)

[soria_t]

Ce sont les différents acides aminés : arginine, valine, leucine, isoleucine....
En fait les champs sont définis un peu plus loin.

void read_pdb(char *filename)
{
FILE *fp;
char s[256];

fp = fopen(filename, "r");
natoms = 0;

while((fgets(s, 256, fp)) != NULL) {
if (strncmp(s, "ATOM ", 6) != 0)
continue;
strncpy(atom[natoms].name, s+12, 4);
strncpy(atom[natoms].res_name, s+17, 3);
atom[natoms].res_seq = atoi(s+22);
atom[natoms].x = atof(s+30);
atom[natoms].y = atof(s+38);
atom[natoms].z = atof(s+46);
strncpy(atom[natoms].elt, s+76, 2);
printf("s", natoms, s);
natoms++;
}
fclose(fp);
}
C'est le code que j'utilise. Mon problème est de connaître la taille du tableau dans lequels je mets toutes les données qui sont nécessaires à mes calculs.

atom_t atom[MAX_ATOMS];
int natoms;
residue_t residue[MAX_RES];
int nres;

les deux tableaux sont définis avec 100 000 atomes au minimum et les résidus à 10 000.
Les résidus dans la réalité ne font qu'une dizaine d'atomes (grosse) et on en compte 200 ou 300 pour une protéine de petite taille.

C'est pour cela que je ne peut pas utiliser mon programme comme je l'ai fait.

Voilà.

[soria_t]

Non, apparamment je dois tout faire en C et Rasmol ne leur conviendraient pas.
Je le leur ai déjà proposé.

[stephl]

printf("s", natoms, s);

Il doit manquer quelque chose sur cette ligne.
Personnellement, quand je ne sais pas à l'avance combien d'éléments je vais avoir à traiter, j'utilise une liste chaînée: cela évite d'avoir à user du realloc.

[souviron34]

Il doit manquer quelque chose sur cette ligne.
Personnellement, quand je ne sais pas à l'avance combien d'éléments je vais avoir à traiter, j'utilise une liste chaînée: cela évite d'avoir à user du realloc.

c'est ce que j'avais proposé....

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
 
Atom *atom=NULL, *last=NULL ;
 
....
 
 
while((fgets(s, 256, fp)) != NULL) {
if (strncmp(s, "ATOM ", 6) != 0)
continue;
 
atom = calloc ( 1, sizeof(Atom) );
if ( atom != NULL )
{
strncpy(atom.name, s+12, 4);
strncpy(atom.res_name, s+17, 3);
atom.res_seq = atoi(s+22);
atom.x = atof(s+30);
atom.y = atof(s+38);
atom.z = atof(s+46);
strncpy(atom.elt, s+76, 2);
atom->suivant = NULL ;
atom->précedent = last ;
last = atom ;
natoms++ ;
}
}
fclose(fp);

Sinon une autre solution :

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
 
 
while((fgets(s, 256, fp)) != NULL) {
if (strncmp(s, "ATOM ", 6) != 0)
continue;
natoms++ ;
}
 
atoms = (Atom *) calloc ( natoms, sizeof(Atoms) );
if ( atoms == NULL )
  return ERROR ;
 
fseek ( fp, 0L, 0 );
 
i = 0 ;
while((fgets(s, 256, fp)) != NULL) {
if (strncmp(s, "ATOM ", 6) != 0)
continue;
 
strncpy(atom[i].name, s+12, 4);
strncpy(atom[i].res_name, s+17, 3);
atom[i].res_seq = atoi(s+22);
atom[i].x = atof(s+30);
atom[i].y = atof(s+38);
atom[i].z = atof(s+46);
strncpy(atom[i].elt, s+76, 2);
i++ ;
}

[soria_t]

Merci beaucoup à tous. Je n'ais pas compris la relation entre liste chainée et realloc, mais je vais travailler dessus.

Encore une fois merci.

[stephl]

Pour ce qui est des listes chaînées, voici un exemple basique d'implémentation d'une pile d'entiers (comme une pile d'assiettes):

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
 
typedef struct stackitem_s
 {
 int value;
 struct stackitem_s *next;
 }
 STACKITEM;
 
 
int stack_push(STACKITEM **stack,int val)
 {
 STACKITEM *newitem;
 
 if ((newitem=(STACKITEM *) malloc(sizeof (STACKITEM)))==NULL) return 0;
 newitem->value=val;
 newitem->next=*stack;
 *stack=newitem;
 return 1;
 }
 
 
int stack_pop(STACKITEM **stack)
 {
 int val;
 STACKITEM *itemtodel;
 
 itemtodel=*stack;
 val=itemtodel->value;
 *stack=itemtodel->next;
 free(itemtodel);
 return val;
 }

[souviron34]

Pour ce qui est des listes chaînées, voici un exemple basique d'implémentation d'une pile d'entiers (comme une pile d'assiettes):

C'est pas le meilleur exemple de liste chaînée.. C'est même un cas particulier très particulier.........

Voici un exemple plus général :

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
 
 
typedef struct item_s
 {
 int value;
 struct item_s *next;
 struct item_s *previous ;
 }
 ITEM;
 
 
int Add_Item(ITEM **stack,int val)
 {
 ITEM *newitem;
 
 if ((newitem=(ITEM *) malloc(sizeof (ITEM)))==NULL) return 0;
 
 newitem->value=val;
 newitem->previous=*stack;
 newitem->next = NULL ;
 
 *stack->next = newitem ;
 
 *stack=newitem;
 
 return 1;
 }
 
 
int Delete_Item(ITEM **stack)
 {
 int val;
 ITEM *itemtodel;
 
 itemtodel=*stack;
 val=itemtodel->value;
 
 if ( itemtodel->previous != NULL )
      itemtodel->previous->next = itemtodel->next ;
 if ( itemtodel->previous != NULL )
      itemtodel->next->previous = itemtodel->previous ;
 
 *stack=itemtodel->next;
 
 free(itemtodel);
 return val;
 }

[stephl]

En effet, mon exemple n'est pas le plus général; je voulais juste donner une idée simple de ce qui était réalisable. Les piles s'avèrent très utiles et souvent suffisantes. Tout dépend de se que l'on compte faire des données. Votre exemple propose une liste doublement chaînée, et ce n'est pas toujours nécessaire.