---
description: Cette page est dédié pour savoir comment merge des BAM
---

# Merge BAM

### Installer samtools

```sh
sudo apt-get update
sudo apt-get install samtools
```

### Fusionner les fichiers BAM

Supposons que vous avez trois fichiers BAM que vous voulez fusionner : `file1.bam`, `file2.bam`, et `file3.bam`.

```shell
samtools merge merged.bam file1.bam file2.bam file3.bam
```

Cette commande fusionnera les trois fichiers BAM en un seul fichier nommé `merged.bam`.

### Indexer le fichier BAM fusionné (optionnel mais recommandé)

Après avoir fusionné les fichiers BAM, il est généralement utile d'indexer le fichier fusionné pour une accessibilité plus rapide :

```sh
samtools index merged.bam
```

### Fusionner les fichiers BAM d'un dossier entier

```sh
samtools merge merged.bam /chemin/vers/votre/dossier/*.bam
```

Si il y a noté "too many open files" cela signifie que le nombre de fichiers ouverts simultanément dépasse la limite fixée par le système. Pour contourner ce problème, vous pouvez augmenter cette limite temporairement ou fusionner les fichiers en plusieurs étapes.

#### Vérifier la limite actuelle :

```sh
ulimit -n
```

#### Augmenter la limite (pour la session actuelle) :

```sh
ulimit -n 4096
```

### Fusionner en plusieurs étapes

Si vous ne pouvez pas augmenter la limite, vous pouvez fusionner les fichiers par lots. Voici un script pour fusionner les fichiers par lots de 100 fichiers à la fois :

```bash
#!/bin/bash

SOURCE_DIR="/chemin/vers/votre/dossier"  # Remplacez par le chemin de votre dossier contenant les fichiers .bam
TEMP_DIR="${SOURCE_DIR}/temp"
MERGED_FILE="${SOURCE_DIR}/merged.bam"

# Créer un dossier temporaire
mkdir -p "$TEMP_DIR"

# Copier les fichiers .bam dans le dossier temporaire pour un traitement par lots
cp "$SOURCE_DIR"/*.bam "$TEMP_DIR"

# Fusionner les fichiers par lots de 100
counter=0
batch_files=()
for file in "$TEMP_DIR"/*.bam; do
    batch_files+=("$file")
    counter=$((counter + 1))
    if [ "$counter" -eq 100 ]; then
        samtools merge "temp_merged_$counter.bam" "${batch_files[@]}"
        batch_files=()
        counter=0
    fi
done

# Fusionner le reste des fichiers s'il y en a
if [ "${#batch_files[@]}" -gt 0 ]; then
    samtools merge "temp_merged_last.bam" "${batch_files[@]}"
fi

# Fusionner tous les fichiers temporaires
samtools merge "$MERGED_FILE" "$TEMP_DIR"/temp_merged_*.bam

# Nettoyer les fichiers temporaires
rm -r "$TEMP_DIR"

echo "Fusion terminée. Fichier fusionné: $MERGED_FILE"

```

### Fusionner des dossiers de BAM automatiquement

Ce genre de fichier bash permettent de fusionner un dossier BAM et quand cette première fusion aura fini, une seconde commencera. Cela permet d'éviter de retaper une commande quand la première a fini.

```bash
#!/bin/bash

mkdir -p "C:/path/to/bam_merged"
samtools merge "C:/path/to/bam_merged/merged.bam" "C:/path/to/bam/*.bam
echo "Merging complete for BAM files in C:/path/to/bam_merged/"

mkdir -p "C:/path/to/bam_merged2"
samtools merge "C:/path/to/bam_merged2/merged.bam" "C:/path/to/bam2/*.bam
echo "Merging complete for BAM files in C:/path/to/bam_merged2/"
```

### Script python permettant de creer le bash via interface graphique

```python
import tkinter as tk
from tkinter import filedialog, messagebox

def launch_bam_merger_ui():
    root = tk.Tk()
    root.title("BAM Merger Configuration")

    configurations = []

    def add_configuration():
        input_dir = input_dir_entry.get()
        output_dir = output_dir_entry.get()
        
        if not all([input_dir, output_dir]):
            messagebox.showerror("Error", "Please specify both input and output directories.")
            return
        
        configurations.append({
            "input_dir": input_dir,
            "output_dir": output_dir
        })
        
        listbox.insert(tk.END, f"Input: {input_dir}, Output: {output_dir}")
        input_dir_entry.delete(0, tk.END)
        output_dir_entry.delete(0, tk.END)
        messagebox.showinfo("Success", "Configuration added successfully.")

    def generate_script():
        script_path = "merge_all_bam.sh"
        with open(script_path, "w") as script_file:
            script_file.write("#!/bin/bash\n\n")
            for config in configurations:
                script_file.write(f"mkdir -p \"{config['output_dir']}\"\n")
                script_file.write(f"samtools merge \"{config['output_dir']}/merged.bam\" \"{config['input_dir']}\"/*.bam\n")
                script_file.write(f"echo \"Merging complete for BAM files in {config['input_dir']}\"\n\n")
        messagebox.showinfo("Done", f"All configurations have been written to {script_path}.")

    tk.Label(root, text="Select the input folder containing BAM files:").pack()
    input_dir_entry = tk.Entry(root, width=50)
    input_dir_entry.pack(padx=20, pady=5)
    tk.Button(root, text="Browse", command=lambda: input_dir_entry.insert(0, filedialog.askdirectory())).pack()

    tk.Label(root, text="Select the output folder for merged BAM file:").pack()
    output_dir_entry = tk.Entry(root, width=50)
    output_dir_entry.pack(padx=20, pady=5)
    tk.Button(root, text="Browse", command=lambda: output_dir_entry.insert(0, filedialog.askdirectory())).pack()

    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_bam_merger_ui()
```
