Projet 1 Détection de phases ouvertes de lecture et

Module AAGB
Projet 1 – page 1/4
Projet 1 Détection de phases ouvertes de lecture et
prédiction de gènes
Version du 23 octobre 2014
L’objectif de ce projet est de détecter des gènes dans des génomes bactériens en utilisant le biais de
codage. Nous détecterons dans un premier temps toutes les phases ouvertes de lecture ou ORF (open
reading frame) c’est-à-dire toutes les sous séquences commençant par le codon start, se terminant par
un codon stop et ne contenant aucun codon stop.
1
Les données
Nous allons travailler des génomes bactériens qui sont téléchargeables ici : ftp://ftp.ncbi.
nlm.nih.gov/genomes/Bacteria/ Vous pourrez par exemple travailler sur le génome de Mycoplasma geniltalium 1 ( fichiers .fna) pour tester votre programme car son génome est de petite taille.
Vous essaierez ensuite votre programme sur d’autres génomes. Ce fichier est au format fasta. Vous
comparerez vos résultats aux gènes prédits par d’autres méthodes qui sont dans les fichiers .ffn
2
Les structures de données (fichiers ManipulationStruct.c et .h)
2.1
Les structures
Vous aurez trois types de données à manipuler. Ils sont définis dans le fichier ManipulationStruct.h
La première structure permet de manipuler des séquences d’ADN.
typedef struct {
char ∗ s e q ;
int lg ;
f l o a t GC;
} tySeqADN ;
Elle contient donc la séquence (seq), sa longueur (lg) et sa composition en GC.
La seconde structure permet de manipuler une ORF.
typedef struct {
i n t d e b u t ; / ∗ i n d i c e de d e b u t ∗ /
int lg ; /∗ longeur ∗/
tySeqADN ∗ pSeq ;
} tyORF ;
Elle contient dans l’ordre l’indice de début de l’ORF (en partant de 0), sa longueur, un pointeur vers
la séquence.
Il vous faudra aussi manipuler des tableaux d’ORF (quand nous auront plusieurs ORFs) :
typedef struct {
tyORF ∗∗ tabORF ;
i n t nbORFs ; / ∗ Nombre d ’ORF r é e l l e s ∗ /
i n t nbMaxORFs ; / ∗ T a i l l e du t a b l e a u de p o i n t e u r s ∗ /
} tyTabORFs ;
1. ATTENTION le code génétique utilisé par Mycoplasma est un peu modifié.
c
2014-2015
(by UPMC/Master BIM/AAGB)
23 octobre 2014
Module AAGB
Projet 1 – page 2/4
tabORF est le tableau de pointeurs vers les ORF, nbORFs est le nombre d’ORF stockées dans
ce tableau, et nbMaxORFs est le nombre maximum d’ORF qu’on peut mettre dans ce tableau, c’est
à dire la taille du tableau. Lorsque nous atteindront ce nombre, nous agrandiront le tableau avec la
fonction realloc.
2.2
Fonctions de manipulation des structures de données
Vous aurez besoin de fonctions pour créer (allouer) et détruire (désallouer) chacune de ces structures. Ces fonctions seront écrites dans le fichier ManipulationStruct.c ou les prototypes vous
sont donnés.
Vous écrirez donc :
1. tySeqADN* newSeqADN(); Cette fonction alloue de la mémoire pour un élément de type
tySeqADN et met les champs à 0 ou à NULL. Cette fonction n’allouera pas l’espace pour
la séquence elle-même (champs seq) ; il sera alloué lors de la lecture de la séquence dans un
fichier.
2. tySeqADN* freeSeqADN(tySeqADN *pS); Cette fonction libère l’espace alloué pour
la séquence si nécessaire et l’élément de type tySeqADN.
3. tyORF* newORF(); Cette fonction alloue de la mémoire pour un élément de type tyORF
et initialise les champs.
4. tyORF* freeORF(tyORF *pO); Cette fonction libère l’espace alloué pour un élément de
type tyORF.
5. tyTabORFs* newTabORFs(int nbMaxORFs); Cette fonction alloue l’espace nécessaire pour un élément de type tyTabORFs ainsi qu’un tableau de pointeurs vers tyORF de
taille nbMaxORFs, initialise les différents champs de la structure et tous les pointeurs du tableau à NULL.
6. tyTabORFs* freeTabORFs(tyTabORFs *pT); Cette fonction libère toutes les ORF
dont les adresses sont dans le tableau puis le tableau et la structure de type tyTabORFs elle
même.
7. void ajouterORF(tyTabORFs *pT, int iDebut, int lg, tySeqADN *pS);
Cette fonction permet d’ajouter une ORF dans le tableau d’ORF qui fait partie de la structure
pointée par pT. Si ce tableau est déjà plein, il faut l’agrandir de NB_MAX_ORF cases (défini par la directive #define dans le fichier .h) avec la fonction realloc et mettre à jour
nbMaxORFs.
3
3.1
Identification des ORFs (fichiers detectionORFs.c et .h)
Séquences aléatoires
Pour pouvoir tester vos fonctions, vous écrirez une fonction tySeqADN *seqADN_aleatoire(int
lg); qui génère une séquence aléatoire de longueur lg. Cette fonction créé donc un élément de type
tySeqADN et alloue l’espace nécessaire pour la séquence. Les 4 bases sont tirées aléatoirement de
manière équiprobable.
c
2014-2015
(by UPMC/Master BIM/AAGB)
23 octobre 2014
Module AAGB
3.2
Projet 1 – page 3/4
Brin complémentaire
Vous écrirez aussi la fonction tySeqADN* complementaire(tySeqADN *pS); qui à
partir d’un séquence donnée génère le brin complémentaire et le retourne.
3.3
Identification des ORFs
Vous écrirez la fonction tyTabORFs *findORF(tySeqADN *pS); qui permet d’identifier
les ORF dans la séquence pointée par pS. Les ORF sont des séquences commençant par un codon
start, se terminant par un codon stop et ne contenant aucun codon stop. Si plusieurs codons start sont
possibles, vous prendrez le premier. Vous chercherez en même temps dans les 3 phases de lectures
(il ne faut parcourir la séquence pS qu’une seule fois). Lorsqu’une ORF est identifiée, vous l’ajouterez au tableau des ORF de la structure tyTabORFs que vous avez préalablement créée et que vous
retournerez.
3.4
Premier programme
Un Makefile et un main simple (dans main_simple.c) vous sont donnés. Vous compilerez
votre programme en tapant make dans le terminal. Le programme créé avec ce main simple est nommé
test_Detect_ORF. Vous testerez votre programme et comparerez entre vous les ORFs trouvées
(elles doivent être les mêmes sur les machines de l’ARI).
4
4.1
Lecture et écriture des fichiers (fichiers ES.c et .h)
Ecriture de la séquence d’une ORF
Vous écrirez une fonction void printORF(FILE *pF, tyORF *pORF); qui permet d’écrire
dans pF la séquence de l’ORF pORF au format fasta. Pour pouvoir comparer vos résultats à ceux qu’on
peut télécharger sur le site donné précédemment, la ligne de titre devra contenir les positions de debut
et de fin de l’orf en respectant ce format :
> 125-155 si on est sur le brin direct
> c155-125 si on est sur le brin complémentaire sachant que 155 est l’indice de début de l’orf dans
le brin direct qu’il vous faudra recalculer à partir de l’indice de début de votre orf et la longueur de
la séquence. Par contre, il faudra bien écrire la séquence complémentaire. ATTENTION : les indices
doivent commencer à 1, il vous faudra donc ajouter 1 à vos indices.
4.2
Lecture d’une séquence au format fasta
Vous écrirez la fonction tySeqADN *readFasta(char *nomFi); qui permet de lire une
séquence d’ADN (un génome) au format fasta. Vous utiliserez les fonctions fgets et sscanf.
Comme vous ne connaissez pas a priori la longueur de la séquence, vous allouerez pour la stocker un
chaîne de caractères de taille SIZE_SEQ (défini dans le .h) que vous agrandirez si nécessaire.
Un second main vous est donné dans le fichier main.c. Vous regardez cette fonction car elle
permet de donner des arguments au programme créé. Le programme créé par le Makefile se nommera
Detect_ORF et il prend comme argument le nom du fichier fasta contenant le génome. Vous pourrez
ensuite comparez vos résultats avec les gènes prédits qu’on peut télécharger sur le site du ncbi (fichier
.ffn. Pour cela vous est fourni un script bash nommé ComparerORFs.sh qui prend en argument
c
2014-2015
(by UPMC/Master BIM/AAGB)
23 octobre 2014
Module AAGB
Projet 1 – page 4/4
le fichier contenant vos orfs et le fichier de référence (.ffn) et qui vous indique le nombre de vos orf
correspondant à des gènes.
5
5.1
Amélioration du programme
Longueur des ORF
Comme vous pouvez le remarquer, un très grand nombre d’ORF sont identifiées et assez peu sont
valides. Si vous regardez vos, vous pourrez remarquer que beaucoup sont très courtes et qu’il serait
bon de mettre un filtre sur la longueur. Vous écrirez une second fonction findORF_bis qui prendra
en paramètre la longueur minimale des ORF et ne les ajouteront que si leur longueur est supérieure à
ce seuil. Comparez à nouveau les résultats
5.2
Composition des ORF
Les génomes sont souvent biaisés dans leur composition en ATGC. Cela est en partie dû à la
fréquence d’utilisation des différents acides aminés dans les protéines, mais pas seulement. Ainsi, on
peut remarquer que le biais est plus fort en 3e position des codons des zones codantes. Pour prendre
en compte cette particularité nous vous proposons de calculer un χ2 pour chaque ORF entre le nombre
observé de GC à chaque position du codon et le nombre attendu selon la composition globale en GC
du génome. Vous écrirez une fonction calculant ce χ2 .
Vous modifierez ensuite la fonction findORF_bis pour qu’une ORF ne soit ajoutée que si le χ2
est significatif. Vous commenterez ensuite vos résultats.
5.3
Codon start multiples
Il est très fréquent qu’il y ait plusieurs codons start dans une orf et celle-ci ne débute pas forcément au premier start. Vous essaierez de trouver le codon start des orf en écrivant une fonction
changeSTART qui retournera l’indice du "meilleur" codon start pour une orf donnée. Cette fonction
sera appelée dans findORF_bis avant le calcul du χ2 . Vous commenterez ensuite vos résultats.
5.4
Autres améliorations
Vous pourrez bien sûr essayer d’autres améliorations.
Vous rendrez les sources de vos programme ainsi qu’un très court rapport (2 pages) contenant
vos résultats et les commentaires de ceux-ci ainsi que l’explication des améliorations que vous avez
tentées.
c
2014-2015
(by UPMC/Master BIM/AAGB)
23 octobre 2014

Download Report