Création d'un VCF

Cette page est dédiée à comment créer un VCF à partir d'un BAM. Ce VCF pourra être chargé sur Alamut ou bien sur IGV

Installer Miniconda

Télécharger le script d'installation:

• Ouvrez un terminal.

• Téléchargez le script d'installation de Miniconda pour Linux. Assurez-vous de choisir le script correspondant à votre version de Python préférée (Python 3.x est recommandé).

wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh

Exécuter le script d'installation:

• Rendez le script exécutable et lancez-le.

chmod +x Miniconda3-latest-Linux-x86_64.sh
./Miniconda3-latest-Linux-x86_64.sh

• Suivez les instructions à l'écran. Il vous sera demandé de passer en revue la licence, d'approuver la licence, puis de choisir le répertoire d'installation.

Initialiser l'installation:

• Une fois l'installation terminée, vous pouvez être invité à exécuter la commande conda init pour initialiser Conda pour votre shell (bash, zsh, etc.).

source ~/.bashrc  # Pour bash, rechargez votre fichier de configuration shell

• Vérifiez que Conda est correctement installé en vérifiant sa version. Cette commande devrait retourner la version de Conda installée :

conda --version

• Mettre à jour Conda pour s'assurer que vous avez la dernière version :

conda update conda

• Confirmez avec "yes" lorsque vous êtes invité à continuer.

Utiliser Conda

Préparation de l'Environnement

Il est souvent recommandé de créer un environnement Conda dédié pour chaque projet afin d'éviter les conflits de dépendances entre les outils. Voici comment vous pouvez créer et activer un nouvel environnement :

# Créer un nouvel environnement appelé 'genomics'
conda create -n genomics python=3.8

# Activer l'environnement
conda activate genomics

Installation des Outils Nécessaires

Avec Conda, vous pouvez facilement installer des outils comme bcftools pour manipuler des fichiers VCF, tabix pour indexer des fichiers compressés, et samtools pour travailler avec des fichiers BAM.

# Installer bcftools, samtools et tabix
conda install -c bioconda bcftools samtools htslib openblas

Création du BCF

Préparation des Fichiers de Référence

Avant de commencer, assurez-vous que vous avez un génome de référence correspondant à votre fichier BAM, souvent au format .fasta. Ce fichier doit être indexé :

samtools faidx reference.fasta

Indexer le Fichier BAM

Si votre fichier BAM n'est pas encore indexé :

samtools index example.bam

Appel de Variants avec Samtools et Bcftools

3.1 Appel des Piles (mpileup)

Utilisez bcftools mpileup pour générer un fichier BCF (Binary Call Format) qui contient les informations de pileup de toutes les positions :

bcftools mpileup -Ou -f hg38.fa SQK-NBD114-24_barcode09.bam | bcftools call -mv -Ob -o SQK-NBD114-24_barcode09.bcf

Explication des options utilisées :

• bcftools mpileup

  • -Ou: Output format to uncompressed BCF, which is suitable for piping into bcftools call.

  • -f hg38.fa: Spécifie le fichier de référence FASTA.

• bcftools call

  • -mv: Appelle les variants; -m est le mode multicall et -v ne produit que les variants (pas les positions de référence conservées).

  • -Ob: Output format to compressed BCF.

  • -o SQK-NBD114-24_barcode09.bcf: Spécifie le fichier de sortie.

Prise en compte des ploidies

• Le message concernant la ploïdie indique que bcftools call suppose que tous les sites sont diploïdes car aucun fichier de ploïdie n'a été spécifié. Si vous travaillez avec des organismes non-diploïdes ou des analyses qui nécessitent une configuration spécifique de ploïdie, vous devriez spécifier ces options :

  • --ploidy : Pour définir une ploïdie constante pour tous les échantillons.

  • --ploidy-file : Pour définir des ploïdies différentes selon les régions ou les échantillons.

Validation et Indexation du Fichier de Sortie

Après avoir créé le fichier BCF, il est souvent utile de l'indexer pour des analyses futures :

bcftools index SQK-NBD114-24_barcode09.bcf

Convertir BCF en VCF

Convertir le fichier BCF en VCF compressé : Utilisez bcftools view pour convertir le fichier BCF en un fichier VCF gzip compressé (.vcf.gz). C'est utile pour économiser de l'espace disque et pour les analyses futures où les fichiers compressés sont plus rapides à lire.

bcftools view -Oz -o SQK-NBD114-24_barcode09.vcf.gz SQK-NBD114-24_barcode09.bcf

Indexer le fichier VCF compressé : Utilisez tabix pour indexer le fichier VCF compressé. L'indexation est essentielle pour permettre des accès rapides à des régions spécifiques du fichier, ce qui est très utile pour les analyses et les visualisations qui nécessitent de lire des segments spécifiques du fichier VCF.

tabix -p vcf SQK-NBD114-24_barcode09.vcf.gz

L'option -p vcf spécifie que le format du fichier à indexer est VCF, ce qui aide tabix à appliquer les règles d'indexation appropriées.

Validation de l'Output

Pour vérifier que votre fichier VCF a été correctement généré et qu'il contient des données valides :

• Inspecter les premières lignes du fichier VCF :

zcat SQK-NBD114-24_barcode09.vcf.gz | head

Cette commande affichera les premières lignes du fichier VCF, vous permettant de voir les en-têtes et les premiers enregistrements de variant, ce qui confirme que le fichier est bien formaté et contient des données.

Chargement des VCF dans Alamut ou dans IGV

RB9 QScore0 NBD114

RB9 QScore0 NBD114

Script qui automatise la création de VCF quand les dépendances nécessaires sont installées

#!/bin/bash

# Active l'environnement Conda spécifique pour l'analyse génomique
conda activate genomics

# Indexe le fichier de référence génomique, nécessaire pour les analyses avec samtools et bcftools
samtools faidx hg38.fa

# Indexe le fichier BAM pour permettre un accès rapide aux données pour le traitement
samtools index SQK-NBD114-24_barcode09.bam

# Effectue l'analyse de pileup et l'appel de variants à partir du fichier BAM en utilisant la référence génomique hg38
# Les résultats sont stockés directement dans un fichier BCF
bcftools mpileup -Ou -f hg38.fa SQK-NBD114-24_barcode09.bam | bcftools call -mv -Ob -o SQK-NBD114-24_barcode09.bcf

# Indexe le fichier BCF généré pour permettre des accès rapides aux variants
bcftools index SQK-NBD114-24_barcode09.bcf

# Convertit le fichier BCF en un fichier VCF compressé, ce qui est utile pour les analyses et le stockage à long terme
bcftools view -Oz -o SQK-NBD114-24_barcode09.vcf.gz SQK-NBD114-24_barcode09.bcf

# Indexe le fichier VCF compressé pour permettre des recherches rapides et des accès régionaux efficaces
tabix -p vcf SQK-NBD114-24_barcode09.vcf.gz

echo "Variant calling and file processing completed."

Et en python via interface graphique

import tkinter as tk
from tkinter import filedialog, messagebox

def launch_vcf_creator_ui():
    root = tk.Tk()
    root.title("VCF Creator Configuration")

    configurations = []

    def add_configuration():
        ref_genome = ref_genome_entry.get()
        bam_file = bam_file_entry.get()
        output_vcf = output_vcf_entry.get()
        
        if not all([ref_genome, bam_file, output_vcf]):
            messagebox.showerror("Error", "Please fill all fields before adding a configuration.")
            return
        
        configurations.append({
            "ref_genome": ref_genome,
            "bam_file": bam_file,
            "output_vcf": output_vcf
        })
        
        listbox.insert(tk.END, f"BAM: {bam_file}, VCF: {output_vcf}")
        ref_genome_entry.delete(0, tk.END)
        bam_file_entry.delete(0, tk.END)
        output_vcf_entry.delete(0, tk.END)
        messagebox.showinfo("Success", "Configuration added successfully.")

    def generate_script():
        script_path = "create_vcf_all.sh"
        with open(script_path, "w") as script_file:
            script_file.write("#!/bin/bash\n\n")
            script_file.write("source ~/miniconda3/etc/profile.d/conda.sh\n")
            script_file.write("conda activate genomics\n\n")
            for config in configurations:
                script_file.write(f"samtools faidx {config['ref_genome']}\n")
                script_file.write(f"samtools index {config['bam_file']}\n")
                script_file.write(f"bcftools mpileup -Ou -f {config['ref_genome']} {config['bam_file']} | bcftools call -mv -Ob -o {config['output_vcf']}.bcf\n")
                script_file.write(f"bcftools index {config['output_vcf']}.bcf\n")
                script_file.write(f"bcftools view -Oz -o {config['output_vcf']}.vcf.gz {config['output_vcf']}.bcf\n")
                script_file.write(f"tabix -p vcf {config['output_vcf']}.vcf.gz\n")
                script_file.write(f"gunzip -c {config['output_vcf']}.vcf.gz > {config['output_vcf']}.vcf\n")
                script_file.write(f"rm -f {config['output_vcf']}.bcf {config['output_vcf']}.vcf.gz {config['output_vcf']}.bcf.csi {config['output_vcf']}.vcf.gz.tbi\n")
            script_file.write("echo \"Variant calling and file processing completed.\"\n")
        messagebox.showinfo("Done", f"All configurations have been written to {script_path}. Please run the script manually.")

    tk.Label(root, text="Select the genome reference file (.fa):").pack()
    ref_genome_entry = tk.Entry(root, width=50)
    ref_genome_entry.pack(padx=20, pady=5)
    tk.Button(root, text="Browse", command=lambda: ref_genome_entry.insert(0, filedialog.askopenfilename(filetypes=[("FASTA files", "*.fa")]))).pack()

    tk.Label(root, text="Select the BAM file:").pack()
    bam_file_entry = tk.Entry(root, width=50)
    bam_file_entry.pack(padx=20, pady=5)
    tk.Button(root, text="Browse", command=lambda: bam_file_entry.insert(0, filedialog.askopenfilename(filetypes=[("BAM files", "*.bam")]))).pack()

    tk.Label(root, text="Specify the output VCF file name (without extension):").pack()
    output_vcf_entry = tk.Entry(root, width=50)
    output_vcf_entry.pack(padx=20, pady=5)

    tk.Button(root, text="Add Configuration", command=add_configuration).pack(pady=10)

    listbox = tk.Listbox(root, height=6, width=50)
    listbox.pack(pady=10)

    tk.Button(root, text="Generate Script", command=generate_script).pack(pady=20)

    root.mainloop()

if __name__ == "__main__":
    launch_vcf_creator_ui()