Analisi introduttiva e convalida dei dati di sequenziamento CUT&RUN

Sommario

Questo protocollo guida i principianti della bioinformatica attraverso una pipeline introduttiva di analisi CUT&RUN che consente agli utenti di completare un'analisi iniziale e la convalida dei dati di sequenziamento CUT&RUN. Il completamento delle fasi di analisi qui descritte, in combinazione con l'annotazione dei picchi a valle, consentirà agli utenti di trarre informazioni meccanicistiche sulla regolazione della cromatina.

Abstract

La tecnica CUT&RUN facilita il rilevamento delle interazioni proteina-DNA in tutto il genoma. Le applicazioni tipiche di CUT&RUN includono la profilazione delle modifiche della coda degli istoni o la mappatura dell'occupazione della cromatina del fattore di trascrizione. L'adozione diffusa di CUT&RUN è guidata, in parte, dai vantaggi tecnici rispetto al ChIP-seq convenzionale, che includono minori requisiti di input cellulare, minori requisiti di profondità di sequenziamento e una maggiore sensibilità con un segnale di fondo ridotto a causa della mancanza di agenti reticolanti che altrimenti mascherano gli epitopi anticorpali. L'adozione diffusa di CUT&RUN è stata raggiunta anche attraverso la generosa condivisione di reagenti da parte del laboratorio Henikoff e lo sviluppo di kit commerciali per accelerare l'adozione da parte dei principianti. Con l'aumento dell'adozione tecnica di CUT&RUN, l'analisi e la convalida del sequenziamento CUT&RUN diventano colli di bottiglia critici che devono essere superati per consentire la completa adozione da parte di team di laboratorio prevalentemente umidi. L'analisi CUT&RUN inizia in genere con controlli di qualità sulle letture di sequenziamento grezze per valutare la profondità di sequenziamento, la qualità di lettura e le potenziali distorsioni. Le letture vengono quindi allineate a un assemblaggio di sequenze genomiche di riferimento e successivamente vengono impiegati diversi strumenti bioinformatici per annotare le regioni genomiche dell'arricchimento proteico, confermare l'interpretabilità dei dati e trarre conclusioni biologiche. Sebbene siano state sviluppate più pipeline di analisi in silico per supportare l'analisi dei dati CUT&RUN, la loro complessa struttura multi-modulo e l'utilizzo di più linguaggi di programmazione rendono le piattaforme difficili per i principianti della bioinformatica che potrebbero non avere familiarità con più linguaggi di programmazione ma desiderano comprendere la procedura di analisi CUT&RUN e personalizzare le loro pipeline di analisi. Qui, forniamo un protocollo di pipeline di analisi CUT&RUN passo-passo in un'unica lingua, progettato per utenti con qualsiasi livello di esperienza bioinformatica. Questo protocollo include il completamento di controlli di qualità critici per convalidare che i dati di sequenziamento siano adatti all'interpretazione biologica. Ci aspettiamo che seguire il protocollo introduttivo fornito in questo articolo, combinato con l'annotazione dei picchi a valle, consentirà agli utenti di trarre informazioni biologiche dai propri set di dati CUT&RUN.

Introduzione

La capacità di misurare le interazioni tra proteine e DNA genomico è fondamentale per comprendere la biologia della regolazione della cromatina. I saggi efficaci che misurano l'occupazione della cromatina per una data proteina forniscono almeno due informazioni chiave: i) localizzazione genomica e ii) abbondanza proteica in una data regione genomica. Il monitoraggio dei cambiamenti di reclutamento e localizzazione di una proteina di interesse nella cromatina può rivelare loci bersaglio diretti della proteina e rivelare ruoli meccanicistici di quella proteina nei processi biologici basati sulla cromatina come la regolazione della trascrizione, la riparazione del DNA o la replicazione del DNA. Le tecniche oggi disponibili per profilare le interazioni proteina-DNA stanno consentendo ai ricercatori di esplorare la regolazione con una risoluzione senza precedenti. Tali progressi tecnici sono stati resi possibili grazie all'introduzione di nuove tecniche di profilazione della cromatina che includono lo sviluppo di Cleavage Under Targets e Release Using Nuclease (CUT&RUN) da parte del laboratorio Henikoff. CUT&RUN offre diversi vantaggi tecnici rispetto all'immunoprecipitazione convenzionale della cromatina (ChIP), tra cui minori requisiti di input cellulare, minori requisiti di profondità di sequenziamento e maggiore sensibilità con un segnale di fondo ridotto a causa della mancanza di agenti reticolanti che altrimenti mascherano gli epitopi anticorpali. L'adozione di questa tecnica per studiare la regolazione della cromatina richiede una comprensione approfondita del principio alla base della tecnica e una comprensione di come analizzare, convalidare e interpretare i dati CUT&RUN.

La procedura CUT&RUN inizia con il legame delle cellule alla concanavalina A coniugata a perline magnetiche per consentire la manipolazione di un basso numero di cellule durante tutta la procedura. Le cellule isolate vengono permeabilizzate utilizzando un detergente delicato per facilitare l'introduzione di un anticorpo che prende di mira la proteina di interesse. La nucleasi micrococcica (MNasi) viene quindi reclutata nell'anticorpo legato utilizzando un tag di proteina A o proteina A/G legato all'enzima. Il calcio viene introdotto per avviare l'attività enzimatica. La digestione della MNasi produce complessi DNA-proteina mononucleosomiali. Il calcio viene successivamente chelato per terminare la reazione di digestione e brevi frammenti di DNA dalla digestione della MNasi vengono rilasciati dai nuclei, quindi sottoposti a purificazione del DNA, preparazione della libreria e sequenziamento ad alto rendimento¹ (Figura 1).

Gli approcci in silico per mappare e quantificare l'occupazione delle proteine in tutto il genoma si sono sviluppati in parallelo con gli approcci di laboratorio utilizzati per arricchire tali interazioni DNA-proteina. L'identificazione delle regioni dei segnali arricchiti (picchi) è uno dei passaggi più critici nell'analisi bioinformatica. I metodi iniziali di analisi ChIP-seq utilizzavano algoritmi come MACS² e SICER³, che impiegavano modelli statistici per distinguere i siti di legame proteina-DNA dal rumore di fondo. Tuttavia, il rumore di fondo inferiore e la maggiore risoluzione dei dati CUT&RUN rendono alcuni programmi di chiamata di picco impiegati nell'analisi ChIP-seq inadatti per l'analisi CUT&RUN⁴. Questa sfida evidenzia la necessità di nuovi strumenti più adatti all'analisi dei dati CUT&RUN. SEACR⁴ rappresenta uno di questi strumenti recentemente sviluppato per consentire la chiamata di picco dai dati CUT&RUN, superando al contempo le limitazioni associate agli strumenti tipicamente impiegati per l'analisi ChIP-seq.

Le interpretazioni biologiche dei dati di sequenziamento CUT&RUN sono tratte dagli output a valle della chiamata dei picchi nella pipeline di analisi. Diversi programmi di annotazione funzionale possono essere implementati per prevedere la potenziale rilevanza biologica dei picchi chiamati dai dati CUT&RUN. Ad esempio, il progetto Gene Ontology (GO) fornisce un'identificazione funzionale ben consolidata dei geni di interesse ^5,6,7. Vari strumenti software e risorse facilitano l'analisi OB per rivelare geni e set di geni arricchiti tra i picchi CUT&RUN 8,9,10,11,12,13,14. Inoltre, software di visualizzazione come Deeptools¹⁵, Integrative genomics viewer (IGV)¹⁶ e UCSC Genome Browser¹⁷ consentono la visualizzazione della distribuzione del segnale e dei modelli nelle regioni di interesse del genoma.

La capacità di trarre interpretazioni biologiche dai dati CUT&RUN dipende in modo critico dalla convalida della qualità dei dati. I componenti critici da convalidare includono la valutazione di: i) qualità del sequenziamento della libreria CUT&RUN, ii) somiglianza della replica e iii) distribuzione del segnale nei centri di picco. Il completamento della convalida di tutti e tre i componenti è fondamentale per garantire l'affidabilità dei campioni della libreria CUT&RUN e dei risultati delle analisi a valle. Pertanto, è essenziale stabilire guide introduttive all'analisi CUT&RUN per consentire ai principianti della bioinformatica e ai ricercatori di laboratorio di condurre tali fasi di convalida come parte delle loro pipeline di analisi CUT&RUN standard.

Oltre allo sviluppo dell'esperimento CUT&RUN in wet lab, sono state sviluppate varie pipeline di analisi CUT&RUN in silico, come CUT&RUNTools 2.0^18,19, nf-core/cutandrun²⁰ e CnRAP²¹, per supportare l'analisi dei dati CUT&RUN. Questi strumenti forniscono approcci efficaci all'analisi di set di dati CUT&RUN e CUT&Tag a cella singola e in blocco. Tuttavia, la struttura del programma modulare relativamente complessa e la familiarità richiesta con più linguaggi di programmazione per condurre queste pipeline di analisi possono ostacolare l'adozione da parte dei principianti della bioinformatica che cercano di comprendere a fondo le fasi di analisi CUT&RUN e personalizzare le proprie pipeline. L'elusione di questa barriera richiede una nuova pipeline introduttiva di analisi CUT&RUN fornita in semplici script passo-passo codificati utilizzando un semplice linguaggio di programmazione singolo.

In questo articolo, descriviamo un semplice protocollo di pipeline di analisi CUT&RUN in un unico linguaggio che fornisce script passo-passo supportati da descrizioni dettagliate per consentire agli utenti nuovi e inesperti di condurre analisi di sequenziamento CUT&RUN. I programmi utilizzati in questa pipeline sono disponibili pubblicamente dai gruppi di sviluppatori originali. Le fasi principali descritte in questo protocollo includono l'allineamento di lettura, la chiamata dei picchi, l'analisi funzionale e, soprattutto, le fasi di convalida per valutare la qualità del campione per determinare l'idoneità e l'affidabilità dei dati per l'interpretazione biologica (Figura 2). Inoltre, questa pipeline offre agli utenti l'opportunità di incrociare i risultati dell'analisi con i set di dati CUT&RUN disponibili pubblicamente. In definitiva, questo protocollo di pipeline di analisi CUT&RUN funge da guida introduttiva e riferimento per i principianti dell'analisi bioinformatica e per i ricercatori di laboratorio umido.

Protocollo

NOTA: Le informazioni per i file fastq CUT&RUN in GSE126612 sono disponibili nella Tabella 1. Le informazioni relative alle applicazioni software utilizzate in questo studio sono elencate nella Tabella dei materiali.

1. Download della pipeline Easy-Shells_CUTnRUN dalla sua pagina Github

1. Aprire il terminale dal sistema operativo.
   NOTA: Se l'utente non è sicuro di come aprire il terminale in macOS e Windows, riview questa pagina web (https://discovery.cs.illinois.edu/guides/System-Setup/terminal/). Per Linux, consulta questa pagina Web (https://www.geeksforgeeks.org/how-to-open-terminal-in-linux/).
2. Scarica la pipeline di analisi compressa da Github digitando wget https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/archive/refs/heads/main.zip -O ~/Desktop/Easy-Shells_CUTnRUN.zip nel terminale.
3. Dopo aver scaricato il file zip, decomprimi il file zip scaricato digitando unzip ~/Desktop/Easy-Shells_CUTnRUN.zip -d ~/Desktop/ nel terminale.
4. Dopo la decompressione, eliminare il file zip digitando rm ~/Desktop/Easy-Shells_CUTnRUN.zip nel terminale e modificare il nome della cartella digitando mv ~/Desktop/Easy-Shells_CUTnRUN-master ~/Desktop/Easy-Shells_CUTnRUN.
5. Dopo aver rimosso il file zippato, digita chmod +x ~/Desktop/Easy-Shells_CUTnRUN/script/*.sh nel terminale per impostare l'autorizzazione eseguibile per tutti gli script di shell all'interno della directory di lavoro. D'ora in poi, basta digitare il percorso e il nome di questi script di shell nel terminale o trascinare gli script nel terminale e inviare per eseguire questi script di shell nel terminale.
   NOTA: la shell Bash è in genere preinstallata sulla maggior parte delle distribuzioni Linux. Tuttavia, le versioni recenti di macOS non forniscono più la shell Bash preinstallata. Se il sistema non dispone di Bash, installare prima la shell Bash. Visita i link sottostanti per istruzioni che descrivono come installare la shell Bash in Linux OS (https://ioflood.com/blog/install-bash-shell-linux/) e macOS (https://www.cs.cornell.edu/courses/cs2043/2024sp/styled-3/#:~:text=The first thing you will,you will see the following:). Questi script di shell passo-passo sono scritti per creare una cartella ~/Desktop/GSE126612 per eseguire la maggior parte di questa analisi CUT&RUN all'interno di questa directory senza alcuna necessità di modifiche. Se l'utente comprende come utilizzare questi script di shell, gli utenti possono rivedere e personalizzare questi script di shell per analizzare altri set di dati CUT&RUN e modificare le opzioni in base alle esigenze specifiche del progetto. Per leggere e modificare questi script della shell, è consigliabile utilizzare Visual Studio Code (https://code.visualstudio.com/) come opzione per un programma di facile utilizzo disponibile per i principali sistemi operativi.

2. Installazione dei programmi necessari per Easy Shells CUTnRUN

1. Tra gli script di shell con il nome di Script_01_installation_***.sh, scopri lo script di shell il cui nome include il tipo di sistema operativo del sistema dell'utente. Attualmente, Easy Shells CUTnRUN supporta lo script di installazione per i sistemi basati su macOS, Debian/Ubuntu e CentOS/RPM.
2. Apri il terminale e digita echo $SHELL per controllare la shell predefinita nel terminale attivo. Se la shell Bash è la shell predefinita nel terminale corrente, gli utenti potrebbero vedere quanto segue: /path/to/bash (o un messaggio simile come /bin/bash) nel terminale.
3. Se la shell predefinita non è Bash, imposta la shell Bash come shell predefinita digitando chsh -s $(which bash) nel terminale. Se il terminale utilizza la shell Bash come impostazione predefinita, ignorare questo passaggio.
4. Nel terminale, azionare lo script della shell di installazione digitando ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_01_installation_***.sh o trascinare il file dello script della shell nel terminale e inserire.
5. Leggi il file Test_README.md nella cartella /path/to/SEACR-1.3/Testfiles. Seguire le istruzioni all'interno del file README per chiarire se il SEACR nel sistema dell'utente funziona correttamente.
   NOTA: È fondamentale convalidare la funzione SEACR con i file di test forniti dalla pagina Github di SEACR per ottenere risultati di chiamata di picco corretti dai dati CUT&RUN. Pertanto, seguire le istruzioni di Test_README.md in /path/to/SEACR-1.3/Testfiles subito dopo l'installazione di SEACR. Sebbene Easy Shells CUTnRUN fornisca script di shell di installazione per alcuni sistemi operativi, questi script potrebbero non funzionare nel sistema di alcuni utenti per installare tutti i programmi necessari per Easy Shells CUTnRUN. In caso di problemi durante l'installazione, consultare il sito Web originale del programma disinstallato o richiedere assistenza utilizzando la pagina Web dei problemi di github CUTnRUN di Easy Shells (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).

3. Scaricare il set di dati CUT&RUN disponibile pubblicamente da Sequence Read Archive (SRA)

1. Apri il terminale e digita echo $SHELL per controllare la shell predefinita nel terminale attivo. Se la shell Bash è la shell predefinita nel terminale corrente, gli utenti potrebbero vedere quanto segue: /path/to/bash (o un messaggio simile come /bin/bash) nel terminale.
2. Se la shell predefinita non è Bash, imposta la shell Bash come shell predefinita digitando chsh -s $(which bash) nel terminale. Se il terminale utilizza la shell Bash come impostazione predefinita, ignorare questo passaggio.
3. Digita ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_02_download-fastq.sh nel terminale o trascina il file di script della shell nel terminale e inserisci.
   NOTA:Questo script: (i) creerà una cartella (~/Desktop/GSE126612/fastq) e scaricherà un elenco di file SRA scritti in un file di testo (~/Desktop/Easy-Shells_CUTnRUN/sample_info/SRR_list.txt) all'interno della cartella fastq. Ad esempio, il SRR_list.txt include i file fastq di un sottoinsieme di campioni CUT&RUN GSE126612. (ii) Scaricare i file fastq grezzi all'interno della cartella fastq. (iii) Creare una cartella (~/Desktop/GSE126612/log/fastq) e annotare un file di registro (download-fastq_log.txt) e un file di informazioni di esempio scaricato (SRR_list_info.txt) all'interno di questa cartella di registro.
4. Dopo aver eseguito lo script, controllare il file di registro. Se viene visualizzato un messaggio di errore all'interno del file di registro, correggere l'errore e riprovare il passaggio 3.3. Se c'è qualche problema per risolvere il problema, chiedi aiuto nella pagina web dei problemi di github CUTnRUN di Easy Shells (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: Per facilitare la pratica di questa pipeline di analisi CUT&RUN, vengono recuperati dall'SRA i seguenti campioni pubblicamente disponibili: un campione dal controllo simulato (IgG), tre campioni di una proteina dell'architettura della cromatina e del fattore di trascrizione (CTCF), quattro campioni corrispondenti a un segno istonico "attivo" (H3K27Ac) e tre campioni corrispondenti a regioni di inizio trascrizionale contrassegnate dalla RNA polimerasi II (RNAPII-S5P). Il sequenziamento è stato eseguito come paired-end, pertanto vengono accoppiati due file per campione.

4. Controllo di qualità iniziale per i file di sequenziamento grezzi

1. Apri il terminale e digita echo $SHELL per controllare la shell predefinita nel terminale attivo. Se la shell Bash è la shell predefinita nel terminale corrente, gli utenti potrebbero vedere quanto segue: /path/to/bash (o un messaggio simile come /bin/bash) nel terminale.
2. Se la shell predefinita non è Bash, imposta la shell Bash come shell predefinita digitando chsh -s $(which bash) nel terminale. Se il terminale utilizza la shell Bash come impostazione predefinita, ignorare questo passaggio.
3. Digita ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_03_fastQC.sh nel terminale o trascina lo script della shell nel terminale e invio.
   NOTA: Questo script di shell: (i) Eseguirà il programma FastQC per tutti i file fastq grezzi nella cartella ~/Desktop/GSE126612/fastq e salverà i file del rapporto di controllo qualità nella cartella ~/Desktop/GSE126612/fastqc.1st . (ii) Annotare un file di registro (fastqc.1st.log.SRR-number.txt) per un'esecuzione di FastQC in una cartella di registro (~/Desktop/GSE126612/log/fastqc.1st).
4. Al termine dell'esecuzione dello script della shell, esaminare il file di log per chiarire il successo dell'esecuzione. Se è presente un messaggio di errore all'interno del file di registro, correggere l'errore e ripetere il passaggio 4.3. In caso di problemi per risolvere il problema, richiedere assistenza utilizzando la pagina Web dei problemi di github CUTnRUN di Easy Shells (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: Tra i file di output, fastqc.html file includono risultati di controllo qualità di facile utilizzo. In caso di gravi problemi di qualità, discutere con i colleghi di bioinformatica per determinare l'idoneità dei dati per l'analisi a valle. Rapporti di controllo qualità simili vengono utilizzati per confermare il miglioramento della qualità dei dati dopo il taglio dell'adattatore. Per utilizzare questo script per altri set di dati, modificare il percorso delle directory di lavoro e di output per soddisfare le esigenze dell'utente. Una differenza notevole nell'interpretazione del controllo qualità di CUT&RUN rispetto alle letture ChIP-seq è che le letture duplicate in CUT&RUN non indicano necessariamente duplicati PCR. Questo perché la MNasi reclutata digerisce nelle stesse posizioni o in posizioni simili all'interno di gruppi sperimentali.

5. Qualità e ritaglio dell'adattatore per i file di sequenziamento non elaborati

1. Apri il terminale e digita echo $SHELL per controllare la shell predefinita nel terminale attivo. Se la shell Bash è la shell predefinita nel terminale corrente, gli utenti potrebbero vedere quanto segue: /path/to/bash (o un messaggio simile come /bin/bash) nel terminale.
2. Se la shell predefinita non è Bash, imposta la shell Bash come shell predefinita digitando chsh -s $(which bash) nel terminale. Se il terminale utilizza la shell Bash come impostazione predefinita, ignorare questo passaggio.
3. Digita ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_04_trimming.sh nel terminale o trascina lo script Script_04_trimming.sh nel terminale e inserisci.
   NOTA: Questo script di shell: (i) Eseguirà il programma Trim-Galore per tutti i file fastq grezzi in ~/Desktop/GSE126612/fastq per eseguire il ritaglio dell'adattatore e della qualità. (ii) Creare una cartella (~/Desktop/GSE126612/trimmed) e salvare i file di output di Trim-Galore all'interno della cartella tagliata. (iii) Creare una cartella di log (~/Desktop/GSE126612/log/trim_galore) e annotare un file di log trim_galore_log_RSS-number.txt per ogni esecuzione di Trim-Galore.
4. Al termine dell'esecuzione, esaminare attentamente il file di registro. Se è presente un messaggio di errore all'interno del file di registro, correggere l'errore e ripetere il passaggio 5.3. In caso di problemi per risolvere il problema, richiedere assistenza utilizzando la pagina Web dei problemi di github CUTnRUN di Easy Shells (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
5. Al termine di questo processo, confrontare i file di output .html con i file fastqc.html creati nella versione 4.3. Rivedere il percorso delle directory di input e output per eseguire il passaggio di taglio per tutti i file fastq che si trovano altrove.

6. Download dell'indice bowtie2 per i genomi di riferimento per i campioni di controllo effettivi e spike-in

1. Apri il terminale e digita echo $SHELL per controllare la shell predefinita nel terminale attivo. Se la shell Bash è la shell predefinita nel terminale corrente, gli utenti potrebbero vedere quanto segue: /path/to/bash (o un messaggio simile come /bin/bash) nel terminale.
2. Se la shell predefinita non è Bash, imposta la shell Bash come shell predefinita digitando chsh -s $(which bash) nel terminale. Se il terminale utilizza la shell Bash come impostazione predefinita, ignorare questo passaggio.
3. Digita ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_05_bowtie2-index.sh nel terminale o trascina lo script della shell nel terminale e invio.
   NOTA: Questo script: (i) Scaricherà gli indici Bowtie2 per i genomi di riferimento del campione effettivo (umano; hg19; utilizzato nella pubblicazione originale²²) e i genomi di riferimento di controllo Spike-in (lievito in gemmazione; R64-1-1) nella cartella bowtie2-index (~/Desktop/Easy-Shells_CUTnRUN/bowtie2-index). (iii) Annota un file di log (bowtie2-index-log.txt) in una directory di log (~/Desktop/GSE126612/log/bowtie2-index).
4. Al termine dell'esecuzione, controllare il file di registro. Se viene visualizzato un messaggio di errore, correggere l'errore e ripetere il passaggio 6.3. In caso di problemi per risolvere il problema, richiedere assistenza utilizzando la pagina Web dei problemi di github CUTnRUN di Easy Shells (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: Attualmente, gli indici Bowtie2 per vari genomi di riferimento sono forniti nel sito web di Bowtie2 (https://bowtie-bio.sourceforge.net/bowtie2/manual.shtml). Gli utenti possono modificare Script_05_bowtie2-index.sh per scaricare qualsiasi indice Bowtie2 per soddisfare le esigenze dell'utente. Se l'utente non riesce a individuare l'indice Bowtie2 del genoma di riferimento di interesse, individuare i file fasta della sequenza del genoma di riferimento da:
   1. Ensembl ftp (https://ftp.ensembl.org/pub/current_fasta/)
   2. Pagina web dell'UCSC (https://hgdownload.soe.ucsc.edu/downloads.html)
   3. o altre banche dati specie-specifiche.
      Dopo aver individuato i file fasta della sequenza del genoma di riferimento, creare un indice Bowtie2 per il genoma di riferimento scaricato seguendo la sezione "The bowtie2-build indexer" (https://bowtie-bio.sourceforge.net/bowtie2/manual.shtml#the-bowtie2-build-indexer) del sito Web Bowtie2.

7. Mappatura delle letture di sequenziamento CUT&RUN tagliate sui genomi di riferimento

1. Apri il terminale e digita echo $SHELL per controllare la shell predefinita nel terminale attivo. Se la shell Bash è la shell predefinita nel terminale corrente, gli utenti potrebbero vedere quanto segue: /path/to/bash (o un messaggio simile come /bin/bash) nel terminale.
2. Se la shell predefinita non è Bash, imposta la shell Bash come shell predefinita digitando chsh -s $(which bash) nel terminale. Se il terminale utilizza la shell Bash come impostazione predefinita, ignorare questo passaggio.
3. Digita ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_06_bowtie2-mapping.sh nel terminale o trascina il file di script della shell nel terminale e inserisci.
   NOTA: Questo script di shell: (1) Eseguirà il programma bowtie2 per mappare tutti i file fastq tagliati di qualità e adattatore sia al controllo sperimentale (umano; hg19) che al controllo spike-in (lievito in gemmazione; R64-1-1) fanno riferimento ai genomi in modo indipendente. (ii) Eseguire la funzione di visualizzazione samtools per comprimere i file di coppie di lettura mappati in formato bam. (iii) Creare una cartella (~/Desktop/GSE126612/bowtie2-mapped) e salvare il file di coppie di lettura mappato compresso all'interno della cartella bowtie2-mapped. (iv) Creare una cartella (~/Desktop/GSE126612/log/bowtie2-mapped) e annotare il registro del processo di mappatura come file di testo bowtie2_log_hg19_SRR-number.txt per le coppie di lettura mappate sul genoma di riferimento hg19 e bowtie2_log_R64-1-1_SRR-number.txt per le coppie di lettura mappate su R64-1-1) per indicare l'efficienza della mappatura all'interno della cartella del registro di mappatura bowtie2.
4. Al termine dell'esecuzione, controllare il file di registro. Se è presente un messaggio di errore all'interno del file di registro, correggere l'errore ed eseguire nuovamente lo script della shell. In caso di problemi per risolvere il problema, richiedere assistenza utilizzando la pagina Web dei problemi di github CUTnRUN di Easy Shells (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: Questo script di shell esegue bowtie2 con opzioni per mappare i file di sequenziamento paired-end per trovare coppie di lettura mappate in modo concorde con lunghezze di frammento da 10 bp-700 bp. Scopri le descrizioni delle opzioni digitando bowtie2 --help nel terminale o visitando il sito web di bowtie2 (https://bowtie-bio.sourceforge.net/bowtie2/manual.shtml#the-bowtie2-aligner) per capire e modificare le opzioni secondo necessità. Utilizzare questo script di shell per mappare qualsiasi altro file fastq modificando il percorso e il formato del nome dei file fastq e degli indici Bowtie2.

8. Ordinamento e filtraggio dei file delle coppie di lettura mappati

1. Apri il terminale e digita echo $SHELL per controllare la shell predefinita nel terminale attivo. Se la shell Bash è la shell predefinita nel terminale corrente, gli utenti potrebbero vedere quanto segue: /path/to/bash (o un messaggio simile come /bin/bash) nel terminale.
2. Se la shell predefinita non è Bash, imposta la shell Bash come shell predefinita digitando "chsh -s $(which bash)" nel terminale. Se il terminale utilizza la shell Bash come impostazione predefinita, ignorare questo passaggio.
3. Digita ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_07_filter-sort-bam.sh nel terminale o trascina il file di script della shell nel terminale e inserisci.
   NOTA: Questo script: (i) Eseguirà la funzione di visualizzazione samtools per tutti i file di coppie di lettura mappati compressi nella cartella ~/Desktop/GSE126612/bowtie2-mapped per filtrare le coppie di lettura mappate in regioni cromosomiche non canoniche, blacklist annotate pubblicamente e regioni di ripetizione TA. (ii) Eseguire la funzione di ordinamento samtools per ordinare i file bam filtrati in base ai nomi dei frammenti o alle coordinate all'interno della stessa directory. (iii) Annotare un file di log per un file bam di input nella directory ~/Desktop/GSE126612/log/filter-sort-bam .
4. Al termine dell'esecuzione, esaminare attentamente i file di registro. Se viene visualizzato un messaggio di errore nei file di registro, correggere l'errore e provare a eseguire nuovamente lo script della shell. In caso di problemi per risolvere il problema, richiedere assistenza utilizzando la pagina Web dei problemi di github CUTnRUN di Easy Shells (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: I file bam (output) risultanti ordinati in base ai nomi dei frammenti serviranno come file di input per creare file bedGraph BED e readcount grezzi dei frammenti. I file bam ordinati per coordinate serviranno come file di input per generare file BEDPE di frammenti. Tutti i BED, bedGraph e BEDPE verranno utilizzati per la chiamata e la visualizzazione dei picchi nell'analisi a valle. Tutti i file del letto di annotazione per le regioni cromosomiche canoniche (chr1~22, chrX, chrY e chrM), le regioni blacklist^{annotate pubblicamente 23} e le regioni di ripetizione TA¹⁸ si trovano nella directory ~/Desktop/Easy-Shells_CUTnRUN/blacklist . Se necessario, utilizzare questa directory per aggiungere ulteriori file di blacklist. Utilizzare questo script di shell per eseguire le stesse funzioni per altri file bam di coppie di lettura mappate modificando il percorso e il nome dei file bam. Digita samtools view --help e samtools sort --help nel terminale per ulteriori descrizioni su queste funzioni.

9. Converti le coppie di lettura mappate in file bedGraph di frammenti BEDPE, BED e conteggi di lettura grezzi bedGraph

1. Apri il terminale e digita echo $SHELL per controllare la shell predefinita nel terminale attivo. Se la shell Bash è la shell predefinita nel terminale corrente, gli utenti potrebbero vedere quanto segue: /path/to/bash (o un messaggio simile come /bin/bash) nel terminale.
2. Se la shell predefinita non è Bash, imposta la shell Bash come shell predefinita digitando chsh -s $(which bash) nel terminale. Se il terminale utilizza la shell Bash come impostazione predefinita, ignorare questo passaggio.
3. Digita ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_08_bam-to-BEDPE-BED-bedGraph.sh nel terminale o trascina il file di script della shell nel terminale e inserisci.
   NOTA: Questo script: (i) Eseguirà la funzione filterdup e awk di macs3 per convertire i file bam ordinati per coordinate in file BEDPE frammentati la cui lunghezza dei frammenti è inferiore a 1kb, e salverà i file BEDPE in ~/Desktop/GSE126612/BEDPE. (ii) Creare una directory di log (~/Desktop/GSE126612/log/bam-to-BEDPE) e annotare un file di log per ogni file di frammenti di letture mappate. (iii) Eseguire le funzioni bamtobed e awk, cut, sort di bedtools per convertire i file bam ordinati per nome dei frammenti in file BED di frammenti la cui lunghezza dei frammenti è inferiore a 1 kb. (iv) Creare una cartella (~/Desktop/GSE126612/bam-to-bed) e salvare i file BED del frammento all'interno della cartella bam-to-bed. (v) Annotare un file di log per ogni file BED di frammenti di letture mappate in una directory di log (~/Desktop/GSE126612/log/bam-to-bed). (vi) Eseguire la funzione genomecov di bedtools per generare i file bedGraph di readcount grezzi utilizzando i file BED di frammento in una cartella (~/Desktop/GSE126612/bedGraph).
4. Al termine dell'esecuzione, controllare attentamente i file di registro. In caso di problemi per risolvere il problema, richiedere assistenza utilizzando la pagina Web dei problemi di github CUTnRUN di Easy Shells (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: I file bedGraph dei conteggi di lettura grezzi di output verranno utilizzati come file di input per il programma di chiamata di picco SEACR con l'opzione di normalizzazione nella sezione 12 e la normalizzazione SFRC (Scaled Fractional Readcount)²² nella sezione 10. I file BED dei frammenti serviranno come file di input per le letture normalizzate Spike-in per milione di letture mappate nella normalizzazione del controllo negativo (SRPMC)^24,25 nella sezione 10.To acquisire frammenti brevi (>100 bp) solo per i dati CUT&RUN dei fattori associati alla cromatina, modificare il passaggio di filtrazione dei frammenti in questo script e procedere con la fase di normalizzazione. Per confrontare i segnali CUT&RUN tra frammenti di dimensioni corte e regolari all'interno dello stesso campione, la normalizzazione SFRC può essere utile per ridurre il potenziale effetto di downsampling causato dall'acquisizione solo di frammenti corti. Utilizzare questo script di shell per eseguire gli stessi processi per altri file bam ordinati in sequenza paired-end modificando il percorso e il formato del nome dei file bam e bed.

10. Conversione dei file bedGraph rawcount in file bedGraph e bigWig normalizzati

1. Apri il terminale e digita echo $SHELL per controllare la shell predefinita nel terminale attivo. Se la shell Bash è la shell predefinita nel terminale corrente, gli utenti potrebbero vedere quanto segue: /path/to/bash (o un messaggio simile come /bin/bash) nel terminale.
2. Se la shell predefinita non è Bash, imposta la shell Bash come shell predefinita digitando chsh -s $(which bash) nel terminale. Se il terminale utilizza la shell Bash come impostazione predefinita, ignorare questo passaggio.
3. Digita ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_09_normalization_SFRC.sh nel terminale o trascina il file di script della shell nel terminale e invio.
   NOTA: Questo script è scritto per: (i) Eseguire for-loop con la funzione awk per creare file bedGraph normalizzati SFRC utilizzando i file bedGraph rawcounts readcounts all'interno di ~/Desktop/GSE126612/bedGraph. (ii) Eseguire la funzione bedGraphToBigWig per creare il formato compresso (.bw) dei file bedGraph normalizzati SFRC in ~/Desktop/GSE126612/bigWig. (iii) Annotare un file di log per registrare il fattore di normalizzazione utilizzato per il calcolo SFRC per un'esecuzione e salvare il file di log all'interno di ~/Desktop/GSE126612/log/SFRC.
4. Al termine dell'esecuzione, controllare i file di registro. Se viene visualizzato un messaggio di errore, correggere l'errore ed eseguire nuovamente lo script della shell. In caso di problemi per risolvere il problema, richiedere assistenza utilizzando la pagina Web dei problemi di github CUTnRUN di Easy Shells (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: La normalizzazione del conteggio dei readcount frazionari in scala è stata utilizzata nella pubblicazione originale²² del set di dati CUT&RUN GSE126612. La formula della normalizzazione in bin i è la stessa di seguito:
   
   Poiché questo metodo di normalizzazione non include la normalizzazione con controllo negativo (ad esempio, campione IgG) né il controllo spike-in, questo approccio potrebbe non essere l'ideale per osservare la differenza di segnale a livello di genoma tra i campioni. Tuttavia, poiché questo metodo è teoricamente simile ad altre normalizzazioni basate su readcount totali (ad esempio, conteggio per milione), sarebbe sufficiente osservare la differenza di segnale locale tra i campioni.
5. Digita ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_09_normalization_SRPMC.sh nel terminale o trascina il file di script della shell nel terminale e invio.
   NOTA: Questo script: (i) Eseguirà for-loop con la funzione genomecov di bedtools per creare file bedgraph normalizzati SRPMC in ~/Desktop/GSE126612/bedGraph utilizzando i file BED di frammento in ~/Desktop/GSE126612/bam-to-bed. (ii) Annotare un file di registro per registrare i fattori di normalizzazione utilizzati per la normalizzazione SRPMC per un'esecuzione in ~/Desktop/GSE126612/log/SRPMC. (iii) Eseguire la funzione bedGraphToBigWig per creare il formato compresso (.bw) dei file bedGraph normalizzati e salvare i file bigWig normalizzati nella cartella ~/Desktop/GSE126612/bigWig .
6. Al termine dell'esecuzione, esaminare attentamente i file di registro. Se è presente un messaggio di errore all'interno dei file di registro, correggere l'errore ed eseguire nuovamente lo script della shell. In caso di problemi per risolvere il problema, richiedere assistenza utilizzando la pagina Web dei problemi di github CUTnRUN di Easy Shells (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: La formula della normalizzazione SRPMC è stata sviluppata per normalizzare i conteggi effettivi dei campioni di lettura sia con controllo negativo (campione IgG, ad esempio) che con controllo spike-in combinando il fattore di normalizzazione RPM (letture per milione di letture mappate), RPS (rapporto letture per lettura spike-in) e rapporto del segnale relativo per controllare^24,25. La definizione di RPS è la stessa di seguito:
   
   Applicando RPS sia per il campione effettivo che per il campione di controllo negativo, il rapporto del segnale relativo (RS) al controllo del campione effettivo può essere calcolato come segue:
   
   E la definizione del fattore di normalizzazione RPM (RPM:NF) è la stessa di seguito:
   
   Da qui, il fattore di normalizzazione SRPMC (SRPMC:NF) è emerso combinando insieme RS e RPM:NF:
   
   E questa formula può essere semplificata come di seguito:
   
   Pertanto, il metodo SRPMC normalizza le letture in base al rapporto (1) tra le letture di picco tra il controllo e il campione e (2) le letture di controllo normalizzate RPM. Poiché questo fattore di normalizzazione considera le letture spike-in e rende le letture di controllo comparabili tra i campioni, questo metodo sarebbe appropriato per osservare la differenza a livello di genoma tra i campioni e ridurre l'effetto batch nelle letture totali dei campioni effettivi e dei controlli in diversi esperimenti batch. Questi file bedGraph normalizzati diventeranno file di input per chiamare i picchi utilizzando SEACR nella sezione 11. E questi file bigWig normalizzati verranno utilizzati nella visualizzazione dei loci tramite IGV e nella creazione di mappe di calore e grafici medi tramite Deeptools. Si consiglia vivamente di utilizzare un browser genomico per visualizzare il modello del panorama del set di dati CUT&RUN utilizzando i file bigWig normalizzati in regioni genomiche rappresentative per valutare la qualità dei dati. I campioni CUT&RUN che mostrano modelli di segnale di fondo rumorosi che assomigliano al controllo IgG sono probabilmente appropriati da omettere per le analisi a valle. Utilizzare questi script di shell per normalizzare altri file bed di lettura e i file bedGraph di readcount non elaborati modificando il percorso e i nomi dei file per i file bed e bedgraph di input e output. Modificare questi script per applicare altri calcoli di normalizzazione modificando i fattori e la formula all'interno di questo script.

11. Convalida della distribuzione delle dimensioni dei frammenti

1. Apri il terminale e digita echo $SHELL per controllare la shell predefinita nel terminale attivo. Se la shell Bash è la shell predefinita nel terminale corrente, gli utenti potrebbero vedere quanto segue: /path/to/bash (o un messaggio simile come /bin/bash) nel terminale.
2. Se la shell predefinita non è Bash, imposta la shell Bash come shell predefinita digitando chsh -s $(which bash) nel terminale. Se il terminale utilizza la shell Bash come impostazione predefinita, ignorare questo passaggio.
3. Digita ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_10_insert-size-analysis.sh nel terminale o trascina il file di script della shell nel terminale e inserisci.
   NOTA: Questo script viene scritto per: (i) Eseguire picard.jar funzione CollectInsertSizeMetrics utilizzando i file bam delle coppie di lettura mappate nella cartella ~/Desktop/GSE126612/filtered-bam per identificare la distribuzione delle dimensioni dell'inserto. (ii) Creare una cartella (~/Desktop/GSE126612/insert-size-distribution) e salvare i risultati dell'analisi della distribuzione delle dimensioni dell'inserto nella cartella creata. (iii) Annotare un file di log per un file bam di input nella cartella ~/Desktop/GSE126612/log/insert-size-distribution .
4. Al termine dell'esecuzione, controllare attentamente i file di registro. Se viene visualizzato un messaggio di errore all'interno dei file di registro, correggere l'errore e provare a eseguire nuovamente lo script della shell. In caso di problemi per risolvere il problema, richiedere assistenza utilizzando la pagina Web dei problemi di github CUTnRUN di Easy Shells (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: In generale, l'analisi delle dimensioni dell'inserto (Output) per i campioni CUT&RUN mostra picchi importanti a intervalli di dimensioni nucleosomiali mono- (100-300 bp) e di- (300-500 bp). Errori/limitazioni tecniche (come la sovra/sottodigestione della MNasi durante la preparazione del campione CUT&RUN o la selezione impropria delle dimensioni durante la preparazione della libreria) possono causare l'arricchimento di frammenti trinucleosomici uguali o più grandi (500-700 bp) e uguali o più corti di frammenti subnucleosomici (<100 bp). A volte l'assenza di picchi di dimensioni mononucleosomiche con l'arricchimento dei frammenti lunghi (>500 bp) e corti (<100 bp) può essere dovuta a intervalli di selezione delle dimensioni della libreria scelti nella fase di laboratorio umido o a una bassa profondità di sequenziamento. Confronta la profondità di sequenziamento ("basi sequenziate totali" / "dimensione totale del genoma di riferimento"), la panoramica del panorama genomico utilizzando i file bigWig readcount normalizzati nella sezione 10 e il modello di distribuzione delle dimensioni degli inserti per chiarire la qualità dei campioni CUT&RUN elaborati. Le linee tratteggiate negli istogrammi rappresentano la "frazione cumulativa" di letture con una dimensione dell'inserto maggiore o uguale al valore sull'asse x. Questa linea tratteggiata consente l'identificazione della distribuzione delle dimensioni degli inserti nel file di lettura mappato in input. La progressione lungo l'asse x è associata all'aumento delle dimensioni dell'inserto. La linea tratteggiata identifica la proporzione di coppie di lettura mappate nel file bam di input che hanno una dimensione di inserimento almeno pari a quella indicata nella posizione dell'asse x intersecante. Pertanto, l'interpretazione inizia da 1 a sinistra, indicando che tutte le letture hanno una dimensione dell'inserto maggiore o uguale alla dimensione più piccola, e diminuisce verso 0 all'aumentare della dimensione dell'inserto.

12. Chiamare i picchi utilizzando MACS2, MACS3 e SEACR

1. Apri il terminale e digita echo $SHELL per controllare la shell predefinita nel terminale attivo. Se la shell Bash è la shell predefinita nel terminale corrente, gli utenti potrebbero vedere quanto segue: /path/to/bash (o un messaggio simile come /bin/bash) nel terminale.
2. Se la shell predefinita non è Bash, imposta la shell Bash come shell predefinita digitando chsh -s $(which bash) nel terminale. Se il terminale utilizza la shell Bash come impostazione predefinita, ignorare questo passaggio.
3. Digita ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_11_peak-calling_MACS.sh nel terminale o trascina il file di script della shell nel terminale e invio.
   NOTA: Questo script è scritto per: (i) Eseguire le funzioni macs2 callpeak e macs3 callpeak con e senza controllo IgG utilizzando i file BEDPE di frammento per chiamare i picchi e salvare i risultati delle chiamate di picco nelle directory di output (~/Desktop/GSE126612/MACS2 e ~/Desktop/GSE126612/MACS3). (ii) Annotare il log di queste chiamate di picco come file di testo nella directory dei log (~/Desktop/GSE126612/log/MACS2 e ~/Desktop/GSE126612/log/MACS3)
4. Digita ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_11_peak-calling_SEACR.sh nel terminale o trascina il file di script della shell nel terminale e invio.
   NOTA: Questo script è scritto per: (i) Eseguire SEACR_1.3.sh script con e senza controllo IgG, con opzioni rigorose e rilassate utilizzando i file bedGraph e bedGraph normalizzati per chiamare i picchi. (ii) Creare una directory di output (~/Desktop/GSE126612/SEACR-peaks) e salvare i risultati della chiamata dei picchi da parte di SEACR. (iii) Annotare il registro di queste chiamate di picco come file di testo nella directory del registro (~/Desktop/GSE126612/log/SEACR).
5. Dopo aver completato l'esecuzione degli script della shell, controllare attentamente i file di registro. Se nei file di registro è presente un messaggio di errore, correggere prima l'errore. Alcuni programmi potrebbero non chiamare insieme i picchi per il campione di controllo IgG con l'opzione di controllo IgG, quindi omettono il messaggio di errore relativo al campione di controllo IgG con l'opzione di controllo IgG. In caso di problemi per risolvere il problema, richiedere assistenza utilizzando la pagina Web dei problemi di github CUTnRUN di Easy Shells (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: Questi due script di shell eseguono la chiamata di picco per campioni CUT&RUN utilizzando tre chiamanti di picco (MACS2, MACS3 e SEACR) con varie opzioni: con/senza opzione di controllo IgG, utilizzando i file bedGraph di readcount grezzi con l'opzione di normalizzazione del chiamante di picco o i file bedGraph readcount normalizzati senza l'opzione di normalizzazione del chiamante di picco e opzioni di chiamata di picco SEACR rigorose e rilassate. Poiché i file di output di chiamata dei picchi non sono sufficienti per essere utilizzati direttamente nelle analisi a valle, CUTnRUN di Easy Shells include uno script per elaborare questi file di output chiamati picchi per creare nuovi file di picco che includono cromosoma, inizio, fine e nome dei picchi. Attraverso approcci intensivi di chiamata di picco, Easy Shells CUTnRUN offre l'opportunità di scegliere il programma di chiamata di picco più adatto per il progetto CUT&RUN di un utente, confrontando i picchi chiamati tra tre chiamanti di picco. Inoltre, questa pipeline di analisi CUT&RUN offre anche l'opportunità di selezionare le opzioni di peak calling più adatte per il progetto CUT&RUN di un utente. Questi confronti saranno effettuati tramite diagramma di Venn e visualizzazione come mappa di calore e grafico medio.

13. Creazione di file di picco chiamati

1. Apri il terminale e digita echo $SHELL per controllare la shell predefinita nel terminale attivo. Se la shell Bash è la shell predefinita nel terminale corrente, gli utenti potrebbero vedere quanto segue: /path/to/bash (o un messaggio simile come /bin/bash) nel terminale.
2. Se la shell predefinita non è Bash, imposta la shell Bash come shell predefinita digitando chsh -s $(which bash) nel terminale. Se il terminale utilizza la shell Bash come impostazione predefinita, ignorare questo passaggio.
3. Digita ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_12_make-peak-bed.sh nel terminale o trascina il file di script della shell nel terminale e inserisci.
   NOTA: Questo script è scritto per: (i) Eseguire la funzione awk utilizzando i file bed nella cartella ~/Desktop/GSE126612/SEACR per creare due tipi di file peak bed SEACR ~/Desktop/GSE126612/peak-bed_SEACR cartella. I file del letto di picco includono l'inizio e la fine di ciascun picco, mentre i file del letto di picco focalizzati includono l'inizio e il letto del contenitore del segnale più alto all'interno di ciascun picco. (ii) Eseguire la funzione awk utilizzando i file _peaks.xls nelle cartelle ~/Desktop/GSE126612/MACS2 e ~/Desktop/GSE126612/MACS3 per creare interi file peak bed che includono l'inizio e la fine di ogni picco chiamato da MACS2 e MACS3 nelle cartelle ~/Desktop/GSE126612/peak-bed_MACS2 e ~/Desktop/GSE126612/peak-bed_MACS3 . (iii) Eseguire la funzione awk utilizzando i file _summits.bed nelle cartelle ~/Desktop/GSE126612/MACS2 e ~/Desktop/GSE126612/MACS3 per creare file di peak bed focalizzati che includono l'inizio e la fine del bin più significativo all'interno di ciascun picco. (iv) I file di registro sono scritti in formato di file di testo nella cartella ~/Desktop/GSE126612/log/peak-bed .
4. Digita ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_13_filter-peaks.sh nel terminale o trascina il file di script della shell nel terminale e inserisci.
   NOTA: Questo script è scritto per: (i) Eseguire la funzione di intersezione dei bedtools utilizzando i file del letto di picco che vengono chiamati senza l'opzione di controllo IgG per rimuovere i picchi sovrapposti ai picchi di controllo IgG. (ii) I file filtrati del peak bed vengono salvati nelle cartelle ~/Desktop/GSE126612/peak-bed-filtered_MACS2, ~/Desktop/GSE126612/peak-bed-filtered_MACS3 e ~/Desktop/GSE126612/peak-bed-filtered_SEACR . (iii) Viene creato un file di registro log_filter-peaks.txt nella cartella ~/Desktop/GSE126612/log/filter-peaks .
5. Digita ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_14_cat-merge-peak-bed_MACS.sh nel terminale o trascina il file di script della shell nel terminale e inserisci.
   NOTA: Questo script è scritto per: (i) Eseguire le funzioni cat e sort per concatenare i file MACS2 e MACS3 interi peak bed delle repliche come un unico file peak bed e ordinare il file peak bed concatenato nella cartella ~/Desktop/GSE126612/bed-for-comparison . (ii) Eseguire la funzione di unione bedtools utilizzando i file interi del letto di picco concatenati per unire i picchi che si sovrappongono l'uno all'altro. (iii) Un file di registro log_cat-merged-peak-bed_MACS.txt viene scritto nella cartella di registro ~/Desktop/GSE126612/log/cat-merged-peak-bed.
6. Digita ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_14_cat-merge-peak-bed_SEACR.sh nel terminale o trascina il file di script della shell nel terminale e invio.
   NOTA: Questo script è scritto per: (i) Eseguire le funzioni cat e sort per concatenare i file SEACR interi peak bed delle repliche come un unico file peak bed e ordinare il file peak bed concatenato nella cartella ~/Desktop/GSE126612/bed-for-comparison . (ii) Eseguire la funzione di unione bedtools utilizzando i file interi del letto di picco concatenati per unire i picchi che si sovrappongono l'uno all'altro. (iii) Un file di registro log_cat-merged-peak-bed_SEACR.txt è scritto nella cartella di registro ~/Desktop/GSE126612/log/cat-merged-peak-bed.
7. Dopo aver completato l'esecuzione degli script della shell, esaminare attentamente i file di registro. Se viene visualizzato un messaggio di errore nei file di registro, correggere l'errore ed eseguire nuovamente gli script. In caso di problemi per risolvere il problema, richiedere assistenza utilizzando la pagina Web dei problemi di github CUTnRUN di Easy Shells (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: I file del letto di picco di intere regioni di picco verranno utilizzati come file di input dell'analisi del diagramma di Venn per confrontare la somiglianza tra le opzioni di richiamo dei picchi, i metodi di chiamata dei picchi, le repliche e le osservazioni del paesaggio genomico vicino alle regioni di picco. I file del letto di picco delle regioni di picco unite verranno utilizzati per l'analisi dei componenti principali (PC) e l'analisi della correlazione dei coefficienti di Pearson utilizzando deeptools. I file del letto di picco focalizzati verranno utilizzati per l'analisi della mappa di calore e del grafico medio utilizzando Deeptools.

14. Convalida della somiglianza tra le repliche utilizzando la correlazione di Pearson e l'analisi delle componenti principali (PC).

1. Apri il terminale e digita echo $SHELL per controllare la shell predefinita nel terminale attivo. Se la shell Bash è la shell predefinita nel terminale corrente, gli utenti potrebbero vedere quanto segue: /path/to/bash (o un messaggio simile come /bin/bash) nel terminale.
2. Se la shell predefinita non è Bash, imposta la shell Bash come shell predefinita digitando chsh -s $(which bash) nel terminale. Se il terminale utilizza la shell Bash come impostazione predefinita, ignorare questo passaggio.
3. Digita ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_15_correlation_plotCorrelation.sh nel terminale o trascina il file di script della shell nel terminale e inserisci.
   NOTA: Questo script è scritto per: (i) Eseguire la funzione multiBamSummary BED-file utilizzando i file bam delle repliche, che sono stati ordinati per coordinata, e unire interi file di picco per CTCF, H3K27Ac e RNAPII-S5P per generare file matrice per l'analisi della correlazione Pearson nella cartella Desktop/GSE126612/deeptools_multiBamSummary . (ii) Eseguire la funzione plotCorrelation utilizzando i file matrice per eseguire il calcolo del coefficiente di correlazione Pearson e il clustering della mappa di calore e salvare il risultato nella cartella ~/Desktop/GSE126612/deeptools_plotCorrelation . (iii) Annotare un file di registro log_plotCorrelation.txt nella cartella ~/Desktop/GSE126612/log/correlation .
4. Digita ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_15_correlation_plotPCA.sh nel terminale o trascina il file di script della shell nel terminale e invio.
   NOTA: Questo script è scritto per: (i) Eseguire la funzione multiBamSummary BED-file utilizzando i file bam, che sono stati ordinati per coordinate, e unire interi file del letto di picco, che includono tutti i picchi CTCF, H3K27ac e RNAPII-S5P, per generare file matrice per l'analisi dei componenti principali (PCA) nella cartella Desktop/GSE126612/deeptools_multiBamSummary . (ii) Eseguire la funzione plotPCA utilizzando i file matrice per eseguire la PCA e salvare il risultato nella cartella ~/Desktop/GSE126612/deeptools_plotPCA . (iii) Annotare un file di registro log_plotPCA.txt nella cartella ~/Desktop/GSE126612/log/correlation .
5. Dopo aver completato l'esecuzione degli script della shell, controllare i file di registro. Se viene visualizzato un messaggio di errore, correggere l'errore ed eseguire nuovamente gli script della shell. In caso di problemi per risolvere il problema, richiedere assistenza utilizzando la pagina Web dei problemi di github CUTnRUN di Easy Shells (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: In linea di principio, le repliche adeguatamente preparate ed elaborate mostrano valori del coefficiente di correlazione di Pearson più elevati all'interno dello stesso gruppo di clustering e un posizionamento ravvicinato nell'analisi delle componenti principali. Qualsiasi replica, che mostra un coefficiente di correlazione di Pearson più basso e una lunga distanza da altre repliche nel grafico della componente principale, può rappresentare un potenziale valore anomalo tra le repliche. Questo script di shell è applicabile a qualsiasi formato bam mappato di dati di lettura. Modifica il percorso e il nome del file dei file bigwig per soddisfare i requisiti specifici del progetto.

15. Convalida della somiglianza tra repliche, metodi di chiamata di picco e opzioni utilizzando il diagramma di Venn

1. Apri il terminale e digita echo $SHELL per controllare la shell predefinita nel terminale attivo. Se la shell Bash è la shell predefinita nel terminale corrente, potrebbe esserci qualcosa come /path/to/bash (ad esempio, /bin/bash) nel terminale.
2. Se la shell predefinita non è Bash, imposta la shell Bash come shell predefinita digitando chsh -s $(which bash) nel terminale. Se il terminale utilizza la shell Bash come predefinita, considera di saltare questo passaggio
3. Digita ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_16_venn-diagram_methods.sh nel terminale o trascina il file di script della shell nel terminale e invio.
   NOTA: Questo script è scritto per: (i) Eseguire la funzione interviene venn utilizzando i file del letto di picco dell'intera regione di picco per trovare sovrapposizioni tra i picchi chiamati da varie opzioni (con/senza opzione di controllo IgG, con/senza normalizzazione e opzioni di chiamata dei picchi rigorose/rilassate per SEACR). (ii) Creare una cartella (~/Desktop/GSE126612/intervene_methods) e salvare i risultati dell'analisi del diagramma di Venn in questa cartella. (iii) Annotare un file di registro log_intervene_methods.txt nella cartella ~/Desktop/GSE126612/log/intervene .
4. Digita ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_16_venn-diagram_replicates.sh nel terminale o trascina il file di script della shell nel terminale e invio.
   NOTA: Questo script è scritto per: (i) Eseguire la funzione interviene venn utilizzando i file del letto di picco dell'intera regione di picco per trovare sovrapposizioni tra i picchi delle repliche. (ii) Creare una cartella (~/Desktop/GSE126612/intervene_replicates) e salvare i risultati dell'analisi del diagramma di Venn in questa cartella. (iii) Annotare un file di registro log_intervene_replicates.txt nella cartella ~/Desktop/GSE126612/log/intervene .
5. Al termine dell'esecuzione degli script della shell, esaminare i file di registro. Se viene visualizzato un messaggio di errore, correggere l'errore ed eseguire nuovamente gli script della shell. In caso di problemi nell'utilizzo della pipeline di analisi CUTnRUN di Easy Shells, chiedi aiuto nella pagina web dei problemi di github di Easy Shells CUTnRUN (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: Questi risultati dell'analisi del diagramma di Venn forniscono informazioni per scegliere le opzioni, i metodi e le repliche di chiamata dei picchi più appropriati con un'elevata riproducibilità per l'analisi a valle. Si può preferire scegliere le opzioni di richiamo di picco e i metodi che mostrano i numeri di picco più alti con una buona sovrapposizione con altri metodi e opzioni di richiamo di picco.

16. Analisi delle mappe di calore e dei grafici medi per visualizzare i picchi chiamati.

1. Apri il terminale e digita echo $SHELL per controllare la shell predefinita nel terminale attivo. Se la shell Bash è la shell predefinita nel terminale corrente, potrebbe esserci qualcosa come /path/to/bash (ad esempio, /bin/bash) nel terminale.
2. Se la shell predefinita non è Bash, imposta la shell Bash come shell predefinita digitando chsh -s $(which bash) nel terminale. Se il terminale utilizza la shell Bash come predefinita, considera di saltare questo passaggio
3. Digita ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_27_plotHeatmap_focused.sh nel terminale o trascina il file di script della shell nel terminale e invio.
   NOTA: Questo script è scritto per: (i) Eseguire la funzione del punto di riferimento computeMatrix utilizzando i file bigWig normalizzati e i file del letto di picco focalizzato per creare matrici di conteggio dei readcount normalizzate al centro dei picchi focalizzati nella cartella ~/Desktop/GSE126612/deeptools_computeMatrix . (ii) Eseguire la funzione plotHeatmap utilizzando la matrice di readcount normalizzata per generare heatmap e grafici medi che visualizzano il modello di distribuzione dei readcount normalizzati nelle posizioni di picco focalizzate. (iii) Creare una cartella (~/Desktop/GSE126612/deeptools_plotHeatmap) e salvare i file di output di plotHeatmap all'interno di questa cartella. (iv) Annotare un file di registro log_plotHeatmap_focused.txt nella cartella ~/Desktop/GSE126612/log/plotHeatmap .
4. Digita ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_27_plotHeatmap_whole.sh nel terminale o trascina il file di script della shell nel terminale e invio.
   Questo script è scritto per: (i) Eseguire la funzione del punto di riferimento computeMatrix utilizzando file bigWig normalizzati e interi file peak bed per creare matrici di readcount normalizzate al centro di tutti i picchi nella cartella ~/Desktop/GSE126612/deeptools_computeMatrix . (ii) Eseguire la funzione plotHeatmap utilizzando la matrice di readcount normalizzata per generare heatmap e grafici medi che visualizzano il modello di distribuzione dei readcount normalizzati in tutte le posizioni di picco. (iii) Creare una cartella (~/Desktop/GSE126612/deeptools_plotHeatmap) e salvare i file di output plotHeatmap all'interno di questa cartella. (iv) Annotare un file di registro log_plotHeatmap_whole.txt nella cartella ~/Desktop/GSE126612/log/plotHeatmap .
5. Al termine dell'esecuzione degli script della shell, esaminare i file di registro. Se viene visualizzato un messaggio di errore, correggere l'errore ed eseguire nuovamente gli script della shell. In caso di problemi nell'utilizzo della pipeline di analisi CUTnRUN di Easy Shells, chiedi aiuto nella pagina web dei problemi di github di Easy Shells CUTnRUN (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: Idealmente, le posizioni dei picchi sommitali dei picchi MACS2/3 e le posizioni dei picchi focalizzati di quelli SEACR mostrano una distribuzione del segnale nitida e focalizzata al centro dei grafici. Tuttavia, se l'algoritmo di chiamata dei picchi non funziona correttamente per i dati CUT&RUN, nei grafici potrebbe apparire una distribuzione del segnale "rumorosa" meno focalizzata. Pertanto, l'utilizzo del numero di picchi chiamati e dei modelli di distribuzione del segnale di picco dei grafici di output guiderà la determinazione della validità del picco per ulteriori analisi CUT&RUN che includono l'annotazione del picco a valle.

Risultati

La qualità e la rifinitura dell'adattatore mantengono le letture con un'elevata qualità di sequenziamento
Le tecniche di sequenziamento ad alto rendimento sono soggette a generare errori di sequenziamento come "mutazioni" di sequenza nelle letture. Inoltre, i dimeri dell'adattatore di sequenziamento possono essere arricchiti nei set di dati di sequenziamento a causa della scarsa rimozione dell'adattatore durante la preparazione della libreria. Errori di sequenziamento eccessivi, come le mutazioni di lettura, la generazione di letture più brevi di quelle necessarie per una corretta mappatura e l'arricchimento dei dimeri adattatori, possono aumentare il tempo di mappatura delle letture e possono produrre letture mappate false positive che distorcono i risultati delle analisi bioinformatiche a valle. Pertanto, il filtraggio di qualità e il taglio dell'adattatore sono necessari per mantenere letture di alta qualità per l'analisi e l'interpretazione a valle.

Per mantenere letture di alta qualità per l'analisi, questa pipeline di analisi CUT&RUN (Figura 2) utilizza FastQC²⁶ e Trim Galore²⁷. Lo script di shell "Script_03_fastQC.sh" esegue FastQC per tutti i file fastq all'interno della directory di lavoro. I risultati (Figura 3) di questa fase, utilizzando il set di dati CTCF CUT&RUN disponibile al pubblico di GSE126612 (SRR8581589) identificano alcune letture con basi di punteggio di bassa qualità (Figura 3A, C) e alcuni gradi di discrepanza nella distribuzione dei contenuti GC per sequenza tra la stima teorica e le letture effettive (Figura 3E).

L'esecuzione dello script "Script_04_trimming.sh" per eseguire Trim Galore rimuove con successo quelle letture con basi di punteggio di bassa qualità (inferiori a 20 nella Figura 3A) e basse qualità di sequenza media evidenti prima del taglio (Figura 3B-D). Inoltre, "Script_04_trimming.sh" rimuove con successo anche il 55~60% dell'arricchimento medio del contenuto GC visualizzato nella distribuzione GC "pre-trimming" sul grafico di sequenza (Figura 3E, F). Questi risultati dimostrano che questa pipeline di analisi CUT&RUN filtra per letture di alta qualità per facilitare una mappatura rapida e accurata della lettura del genoma di riferimento.

La distribuzione delle dimensioni dell'inserto può fornire una stima dei risultati delle chiamate di picco
A causa dell'uso di MNase in CUT&RUN (Figura 1), si prevede che le letture mappate di CUT&RUN mostrino picchi di dimensioni dei frammenti di DNA mono- (~200 bp) e dinucleosomiali (~350 bp) all'interno dei grafici di distribuzione delle dimensioni degli inserti (Figura 4). I problemi con il rilevamento per alcuni target possono causare inserimenti brevi (< 100 bp) (Figura 4C). Un livello elevato di letture brevi riduce il numero di letture che possono essere utilizzate per le chiamate di picco ad alta confidenza, riducendo così i numeri di picco e influenzando l'analisi a valle. In questa pipeline di analisi CUT&RUN, "Script_10_insert-size-analysis.sh" gestisce la funzione "picard.jar CollectInsertSizeMetrics" per eseguire l'analisi della distribuzione delle dimensioni degli inserti ed esportare gli istogrammi come output di visualizzazione (Figura 2). Nei grafici di output (Figura 4A-C), l'asse x mostra l'intervallo di dimensioni dell'inserto, il lato sinistro dell'asse y e l'istogramma riempito rappresentano il numero di inserti con il valore sull'asse x e il lato destro dell'asse y mostra e la linea tratteggiata la frazione cumulativa di inserti con una dimensione dell'inserto uguale o superiore al valore sull'asse x. Pertanto, sia la posizione sull'asse X con la variazione più drastica della pendenza della linea tratteggiata che si interseca con il livello massimo nell'istogramma identifica la dimensione principale dell'inserto nel campione. Tra le reads mappate sul genoma di riferimento di interesse (umano, hg19), i frammenti di campione H3K27Ac (active hystone mark) mostrano la distribuzione dimensionale prevista dell'inserto CUT&RUN con la più alta dimensione mononucleosomica e picchi dinucleosomici rilevabili (Figura 4B). I frammenti del campione CTCF hanno mostrato gruppi aggiuntivi a regioni di lunghezza del frammento di 100~200 bp (Figura 4A). Nel complesso, la pipeline di analisi CUT&RUN fornisce script di shell di facile utilizzo per eseguire l'analisi della distribuzione delle dimensioni degli inserti dopo le letture di mappatura sui genomi di riferimento. Queste analisi diventano importanti quando si stima l'efficienza del richiamo dei picchi prima dell'analisi a valle.

La pipeline di analisi CUTnRUN di Easy Shells fornisce filtrazioni e opzioni di normalizzazione per creare readcount affidabili
Uno dei punti critici dell'analisi CUT&RUN è quello di ottenere coppie di lettura mappate corrette filtrando le coppie di lettura problematiche dagli output di mappatura iniziali e normalizzando i readcount mappati filtrati con un metodo di calcolo di normalizzazione specifico in grado di soddisfare gli obiettivi/esigenze dell'analisi dell'utente. La pipeline di analisi CUT&RUN discussa in questo studio include lo script "Script_07_filter-sort-bam.sh" per rimuovere le coppie di lettura mappate su cromosomi non canonici, le regioni²³ della blacklist annotate pubblicamente e le regioni^18,22 delle ripetizioni TA dalle coppie di lettura mappate da papillon2 utilizzando "Script_06_bowtie2-mapping.sh". Queste filtrazioni sono necessarie per rimuovere le coppie di lettura che possono produrre falsi positivi, segnali di picco anomali e chiamati picchi nell'analisi a valle (Figura 5; regioni a scatola gialla).

Oltre alle filtrazioni, l'applicazione del metodo di normalizzazione corretto è un fattore importante per visualizzare accuratamente la differenza di segnale tra i campioni. Pertanto, la pipeline di analisi CUT&RUN include script "Script_09_normalization_SFRC.sh" e "Script_09_normalization_SRPMC.sh" per fornire due metodi di normalizzazione verificati pubblicamente: il readcout frazionario scalato (SFRC)²² e le letture mappate normalizzate Spike-in per milione di letture mappate nel controllo negativo (SRPMC)^24,25 (Figura 5A-D). Poiché la SFRC non include il campione di controllo (ad esempio, IgG) né il campione spike-in nella formula, la normalizzazione SFRC può essere utilizzata per campioni che non includono alcun campione di controllo o che si prevede mostrino differenze di segnale solo nelle regioni locali senza differenze di scala a livello di genoma. I campioni normalizzati SFRC elaborati dalla pipeline di analisi CUT&RUN (Figura 5A-D; tracce rosse) producono gli stessi modelli di distribuzione del segnale delle letture mappate disponibili pubblicamente da GEO (Figura 5A-D; tracce nere), suggerendo che questa pipeline può riprodurre i risultati della pubblicazione.

Il metodo SRPMC è utile per normalizzare i campioni che includono sia i campioni di controllo che quelli Spike-in e ci si aspetta che mostrino la differenza di segnale globale tra i campioni (Figura 5A-D; tracce verdi). Poiché un campione di H3K27Ac (SRR8581599) mostra un rapporto molto più elevato "(letture effettive CUT&RUN)/(letture spike-in)" (RPS campione; 997) rispetto ad altre repliche (237, 175 e 161), i segnali H3K27Ac relativi appaiono diversi tra le repliche nei campioni normalizzati SFRC e SRPMC (Figura 5A-D; H3K27Ac confrontato su tutte le tracce). I campioni di RNAPII-S5P mostrano RPS del campione relativamente più bassi (1,7, 0,8, 2,1) rispetto al controllo IgG (259), quindi i campioni di RNAPII-S5P mostrano un segnale inferiore rispetto al controllo IgG dopo la normalizzazione di SRPMC (Figura 5A-D; RNAPII-S5P a confronto tra tutte le tracce). Pertanto, la pipeline di analisi CUT&RUN qui discussa raccomanda di utilizzare il metodo SRPMC solo per i campioni che hanno letture sufficienti nei campioni sperimentali rispetto sia al controllo IgG che alle letture di controllo spike-in.

Il confronto del diagramma di Venn può fornire idee per scegliere un metodo e opzioni di chiamata di picco migliori
Più programmi di chiamata dei picchi consentono l'identificazione dell'occupazione proteica significativamente arricchita in tutto il genoma. Tali programmi impiegati per l'analisi CUT&RUN includono i programmi della famiglia MACS² e SEACR⁴ come metodi principali finora. Tuttavia, può essere difficile, soprattutto per i principianti della bioinformatica, identificare il metodo e le opzioni di chiamata dei picchi più appropriati per un determinato progetto CUT&RUN. Pertanto, la pipeline di analisi CUT&RUN include i passaggi di analisi del diagramma di Venn per dare agli utenti la possibilità di confrontare la somiglianza e la differenza dei risultati delle chiamate di picco tra le varie opzioni di chiamata di picco (opzioni Script_17_intervene) e i programmi di chiamata di picco (Script_19_intervene_methods.sh) (Figura 6A-H).

Secondo il confronto, i picchi CTCF, H3K27ac e RNAPII-S5P uniti che vengono chiamati con e senza l'opzione di controllo IgG durante la fase di richiamo dei picchi, MACS2 e MACS3 hanno chiamato più picchi con l'opzione di controllo IgG (Figura 6A), ma SEACR ha chiamato più picchi senza opzione di controllo IgG sia nelle opzioni stringenti che rilassate (Figura 6B-D). Pertanto, la pipeline di analisi CUT&RUN suggerisce (1) di applicare l'opzione di controllo IgG per MACS2 e MACS3, (2) di chiamare separatamente i picchi per i campioni sperimentali CUT&RUN e i campioni di controllo IgG, quindi di filtrare i picchi di IgG in un secondo momento per il chiamante del picco SEACR. Tra MACS2 e MACS3, MACS3 ha chiamato un numero leggermente maggiore di picchi (Figura 6A).

Inoltre, il confronto dei picchi chiamati da MACS2 e MACS3 con l'opzione di controllo IgG e SEACR senza l'opzione di controllo IgG mostra che i picchi SEACR chiamati con l'opzione rigorosa si sovrappongono ai picchi MACS 2 e MACS3 più dei picchi SEACR chiamati con l'opzione rilassata (Figura 6E, F). Pertanto, i risultati della pipeline di analisi CUT&RUN suggeriscono che l'opzione rigorosa massimizza la coerenza SEACR con la chiamata dei picchi MACS. Infine, il diagramma di Venn per confrontare la sovrapposizione dei picchi chiamati da SEACR con la normalizzazione per i readcount grezzi CUT&RUN bedGraph files e senza normalizzazione per i readcount normalizzati CUT&RUN bedGraph non rivela alcuna differenza tra i metodi SFRC e SRPMC per SEACR con l'opzione rigorosa. I picchi SFRC mostrano numeri di picco molto più elevati e una migliore sovrapposizione con i picchi delle opzioni normalizzate ("norma" nella Figura 6) rispetto ai picchi SRPMC per SEACR con opzioni rilassate (Figura 6G,H).

Confronti statistici tra repliche e campioni
Trarre conclusioni accurate su più repliche richiede una valutazione della somiglianza delle repliche. La pipeline di analisi CUT&RUN utilizzata utilizza il calcolo del coefficiente di correlazione statistico basato su Deeptools2¹⁵, il clustering della heatmap e l'analisi delle componenti principali (PCA) per facilitare l'identificazione di campioni e repliche appropriate per un'analisi a valle valida. Il clustering della heatmap basato sul coefficiente di correlazione di Pearson ha mostrato una correlazione statisticamente significativa tra le repliche per CTCF, H3K27Ac e RNAPII-S5P nelle regioni di picco chiamate (Figura 7A-C). Tuttavia, la PCA ha mostrato che un campione di CTCF (SRR8581590) e H3K27Ac (SRR8581608) si trova relativamente lontano da altre repliche (Figura 7D) in tutte le regioni di picco chiamate CTCF, H3K27Ac e RNAPII-S5P.

Secondo il diagramma di Venn per confrontare i picchi tra le repliche, i picchi CTCF (SRR8581590) hanno mostrato la minima sovrapposizione con altre repliche in tutti e tre i risultati del chiamante di picco (Figura 7E-G) e i picchi di H3K27Ac (SRR8581608) hanno mostrato la minima sovrapposizione con altre repliche nei risultati del richiamo di picco SEACR (Figura 7F). i picchi di H3K27Ac (SRR8581608) non hanno mostrato una sovrapposizione minima con altre repliche nei risultati di chiamata dei picchi MACS2 e MACS3 (Figura 7F), il che potrebbe suggerire che la distanza tra le repliche nella PCA non è sufficiente per definire il campione anomalo. Pertanto, la pipeline di analisi CUT&RUN propone di definire la replica outlier come "il campione che mostra un basso coefficiente di correlazione di Pearson nel gruppo di clustering della mappa di calore, una lunga distanza nel grafico PCA con altre repliche e la più bassa sovrapposizione di picchi tra le repliche".

Il peak calling facilita la visualizzazione e l'interpretazione dei dati CUT&RUN
La pipeline di analisi CUT&RUN descritta in questo studio impiega due tipi di chiamanti di picco disponibili pubblicamente: la famiglia MACS e SEACR. Per ottimizzare la visualizzazione dei picchi chiamati, questa pipeline seleziona il bin del segnale più alto come centro del picco per le analisi della mappa di calore e del metaplot. Tutti i picchi CTCF, H3K27Ac e RNAPII-S5P chiamati dai chiamanti di picco MACS3 e SEACR hanno mostrato un pattern di distribuzione dei picchi più nitido al centro dei contenitori di segnale più alti (Figura 8A-F, grafici 'focalizzati') rispetto al centro di intere regioni di picco (Figura 8A-F, grafici 'interi'). I campioni CUT&RUN elaborati dalla pipeline di analisi CUTnRUN di Easy Shells con normalizzazione SFRC (Figura 8 A-F, grafici 'SFRC') mostrano modelli di distribuzione del segnale simili a quelli dei campioni normalizzati SFRC di cui le coppie di lettura mappate grezze sono disponibili pubblicamente in GEO (Figura 8A-F, grafici 'pubblici') ai picchi chiamati dalla pipeline di analisi. Pertanto, la pipeline di analisi CUT&RUN può riprodurre correttamente i risultati della pubblicazione.

Figura 1: Schema della procedura sperimentale CUT&RUN. CUT&RUN è un approccio basato su enzimi per rilevare le interazioni proteina-DNA in tutto il genoma. La procedura CUT&RUN inizia con il legame delle cellule (o dei nuclei isolati) alla concanavalina A coniugata a biglie magnetiche per consentire l'isolamento e la manipolazione di un basso numero di cellule durante la procedura. Le cellule isolate vengono permeabilizzate utilizzando un detergente delicato per facilitare l'introduzione di un anticorpo che prende di mira la proteina di interesse. La nucleasi micrococcica (MNasi) legata alla proteina A o alla proteina A/G viene quindi introdotta nella cellula permeabilizzata. La pA-MNasi (o pAG-MNasi) viene reclutata nell'anticorpo legato utilizzando un tag Protein A o Protein A/G. Una volta che la MNasi è localizzata nei siti bersaglio, la nucleasi viene brevemente attivata attraverso l'introduzione di calcio per digerire il DNA attorno alla proteina bersaglio. La digestione della MNasi produce complessi DNA-proteina mononucleosomiali. Il calcio viene successivamente chelato per terminare la reazione di digestione e brevi frammenti di DNA dalla digestione MNasi vengono rilasciati dai nuclei mediante una breve incubazione a 37°C, quindi sottoposti a purificazione del DNA, preparazione della libreria e sequenziamento ad alto rendimento¹. Clicca qui per visualizzare una versione più grande di questa figura.

Figura 2: Riepilogo schematico della pipeline di analisi CUT&RUN di Easy-Shell. La pipeline di analisi CUT&RUN di Easy-Shell è progettata in tre sezioni principali: (1) controllo qualità e mappatura dei file di lettura grezzi (a sinistra; viola), (2) normalizzazione delle letture e dei readcount mappati e delle chiamate ai picchi (al centro; verde) e (3) convalida delle letture mappate e dei picchi chiamati (a destra; rosa). In ogni passaggio, vengono forniti il numero di script della shell corrispondente, una breve descrizione e lo strumento del programma utilizzato in quel passaggio (tra parentesi). Le frecce semplici mostrano i flussi diretti tra i passaggi. Questa pipeline di analisi CUT&RUN fornisce due metodi di normalizzazione delle letture in grado di soddisfare le esigenze degli utenti con e senza letture di controllo, processi di convalida multilivello per identificare le repliche corrette per l'analisi a valle e identificazione mirata dei picchi per la creazione di mappe di calore e metaplot ben focalizzate. Questa pipeline di analisi è scritta in script shell di facile utilizzo in modo graduale per fornire ai principianti della bioinformatica l'opportunità di apprendere e praticare l'analisi dei dati CUT&RUN di base leggendo e modificando gli script stessi. Clicca qui per visualizzare una versione più grande di questa figura.

Figura 3: Confronto tra i risultati del controllo di qualità pre e post rifilatura di qualità. Gli output del rapporto di controllo qualità selezionati da FastQC visualizzano l'effetto del taglio di qualità utilizzando le letture da SRR8581589 (GSM3609748, CTCF). I risultati mostrati includono: (A) Punteggio di qualità su tutte le basi prima del ritaglio. (B) Stessa lettura di A) post-rifilatura. (C) Distribuzione del punteggio di qualità su tutte le sequenze pre-trimming. (D) Stessa lettura di C) post-rifilatura. (E) Distribuzione GC su tutte le sequenze prima del trimming. (F) Stessa lettura di E) post-rifilatura. Il punteggio di qualità minimo in ogni posizione all'interno delle letture di sequenziamento (A, B) e la qualità media minima della sequenza (C, D) vengono aumentati dopo il taglio di qualità. Inoltre, questo passaggio può ridurre la differenza tra la distribuzione teorica dei conteggi GC e il conteggio effettivo dei GC per base nelle letture (E, F) rimuovendo le coppie di letture che hanno un elevato rapporto di mancata corrispondenza delle basi. Clicca qui per visualizzare una versione più grande di questa figura.

Figura 4: Analisi della distribuzione delle dimensioni degli inserti. Istogramma della dimensione dell'inserto per (A) CTCF, (B) H3K27Ac e (C) serina 5 RNA polimerasi II fosforilata (RNAPII-S5P). Gli istogrammi mostrano le differenze relative nella distribuzione delle dimensioni dell'inserto tra i campioni. La linea tratteggiata nell'istogramma rappresenta la frazione cumulativa di letture con una dimensione dell'inserto maggiore o uguale al valore sull'asse x. n: numero di letture univoche mappate in modo concordante per campione dopo la filtrazione. FR: frammenti. Clicca qui per visualizzare una versione più grande di questa figura.

Figura 5: Panoramica panoramica dei campioni CUT&RUN. Le letture mappate CUT&RUN disponibili al pubblico normalizzate dal conteggio frazionario scalato (SFRC) senza filtrazione aggiuntiva (tracce nere), i campioni CUT&RUN elaborati dalla pipeline di analisi CUTnRUN di Easy Shells con normalizzazione SFRC (tracce rosse) e le "letture normalizzate Spike-in per milione di letture mappate nel controllo negativo (SRPMC; tracce verdi)" sono mostrate nella regione del cluster dei geni istonici (A), e (B-D) altre tre regioni con picchi CTCF, H3K27Ac e RNAPII-S5P chiamati da tutti i chiamanti di picco MACS2, MACS3 e SEACR. Le caselle gialle evidenziano la posizione dei segnali spike filtrati durante la fase di filtrazione nella pipeline di analisi CUTnRUN di Easy Shells. Clicca qui per visualizzare una versione più grande di questa figura.

Figura 6: Diagramma di Venn per confrontare i picchi chiamati da diversi chiamanti di picco e le opzioni di richiamo dei picchi. (A) Confronto tra i picchi chiamati da MACS2 e MACS3 con e senza l'opzione di ingresso IgG durante il richiamo dei picchi. (B-D) Confronto tra i picchi chiamati da SEACR con e senza l'opzione di input IgG, le opzioni 'stringent' e 'relaxed' e con l'opzione di normalizzazione utilizzando file di coppie di lettura grezze (B), senza opzione di normalizzazione utilizzando file di readcount normalizzati SFRC (C) o file di readcount normalizzati SRPMC (D). (E,F) Confronto tra picchi chiamati da MACS2, MACS3 con opzione di ingresso IgG e SEACR con opzione stringente (E) o rilassata (F). (G,H) Confronto tra picchi chiamati da SEACR senza opzione di input IgG e con opzioni stringenti (G) o rilassate (H). con IgG: picchi chiamati con opzione di ingresso IgG. senza IgG: picchi chiamati senza opzione di ingresso IgG. Norma: Picchi chiamati con opzione di normalizzazione. non: picchi chiamati senza opzione di normalizzazione. SFRC: picchi chiamati dai file readcount normalizzati con il metodo 'scaled fractional count (SFRC)'. SRPMC: picchi chiamati dai file readcounts normalizzati dal metodo "Spike-in normalized reads Per Million mappapped reads in the negative Control (SRPMC)". Clicca qui per visualizzare una versione più grande di questa figura.

Figura 7: Correlazione di Pearson, analisi delle componenti principali e diagramma di Venn per convalidare la somiglianza tra le repliche. (A-C) Il clustering della heatmap con i valori del coefficiente di correlazione di Pearson mostra il grado di somiglianza tra le repliche ai picchi chiamati da MACS2 (A), MACS3 (B) e SEACR (C). Il coefficiente di correlazione di Pearson è compreso tra -1 e 1. Un valore del coefficiente di correlazione di Pearson assoluto più grande indica una correlazione più forte tra due variabili, mentre un valore del coefficiente di correlazione di Pearson positivo indica una correlazione positiva, in cui le due variabili si muovono nella stessa direzione. Pertanto, i campioni con una maggiore somiglianza mostrano un pedigree più stretto nel clustering della mappa di calore e un valore del coefficiente di Pearson più elevato. (D) L'analisi delle componenti principali (PCA) mostra un grado di somiglianza tra repliche e campioni in tutte le regioni di picco CTCF, H3K27Ac e RNAPII-S5P che sono chiamate da MACS2 (a sinistra), MACS3 (al centro) e SEACR (a destra). I campioni con maggiore somiglianza sono posizionati più vicini tra loro nel grafico PCA. (E-G) Analisi del diagramma di Venn per confrontare i picchi trovati in ciascuna replica da MACS2 (E), MACS3 (F) e SEACR (G). La pipeline di analisi CUT&RUN Easy-Shell ha proposto di applicare tutti e tre i metodi per identificare le repliche con un'elevata somiglianza che potrebbero essere adatte a unire i picchi chiamati per l'analisi a valle. Clicca qui per visualizzare una versione più grande di questa figura.

Figura 8: Visualizzazione della heatmap e del metaplot della distribuzione del segnale ai picchi. La mappa termica e i metagrafici visualizzano la distribuzione dell'arricchimento attorno ai centri di picco chiamati utilizzando diversi chiamanti di picco. (A,B) Picchi di cut&run CTCF richiamati da una replica (SRR8581589) da MACS3 (A) e SEACR (B). (C, D) Picchi H3K27Ac CUT&RUN chiamati da una replica (SRR8581607) utilizzando MACS3 (C) e SEACR (D). (E,F) Picchi RNAPII CUT&RUN chiamati da una replica (SRR8581589) da MACS3 (E) e SEACR (F). Le coppie di lettura mappate disponibili pubblicamente ('Public' nella Figura 8) e i frammenti mappati dalla pipeline di analisi CUTnRUN di Easy Shells ('SFRC' nella Figura 8) vengono confrontati dopo la normalizzazione del 'conteggio frazionario scalato (SFRC)'. I picchi sono chiamati da MACS3 con l'opzione di input IgG ('MACS3 w/ IgG' nella Figura 8) e SEACR senza input IgG e senza l'opzione di normalizzazione utilizzando i file di readcount normalizzati SFRC in modalità rigorosa ('SEACR w/o IgG non SFRC stringent' nella Figura 8). Vengono preparate due versioni dei file di coordinate dei picchi chiamati: dall'inizio alla fine dei picchi chiamati ("intero" in Figura 8) e la posizione del bin con il segnale più alto all'interno dei picchi chiamati (i picchi in MACS3 chiamati picchi; "focalizzato" nella Figura 8). Clicca qui per visualizzare una versione più grande di questa figura.

Tabella 1: Informazioni per i file fastq CUT&RUN in GSE126612. Tutti i file CUT&RUN fastq di lettura grezza inclusi in GSE126612 e selezionati come set di dati di esempio per la pipeline di analisi CUTnRUN di Easy Shells sono elencati come tabella. La colonna 'Nome file' mostra i nomi dei file di lettura fastq raw di CUT&RUN che verranno mostrati in '~/Desktop/GSE126612/fastq' dopo aver eseguito 'Script_02_download-fastq.sh'. 'md5sum' condivide MD5 (Message-Digest Algorithm 5) per il set di dati di esempio, che può essere utilizzato per verificare l'integrità dei file dopo aver scaricato il set di dati tramite l'esecuzione di 'Script_02_download-fastq.sh'. L'ultima colonna descrive l'obiettivo di CUT&RUN per ogni campione. Clicca qui per scaricare questa tabella.

Discussione

La capacità di mappare l'occupazione delle proteine sulla cromatina è fondamentale per condurre studi meccanicistici nel campo della biologia della cromatina. Man mano che i laboratori adottano nuove tecniche di laboratorio umido per profilare la cromatina, la capacità di analizzare i dati di sequenziamento di questi esperimenti di laboratorio umido diventa un collo di bottiglia comune per gli scienziati di laboratorio umido. Pertanto, descriviamo un protocollo introduttivo passo-passo per consentire ai principianti della bioinformatica di superare il collo di bottiglia dell'analisi e avviare l'analisi e i controlli di qualità dei propri dati di sequenziamento CUT&RUN.

Questo protocollo di analisi CUT&RUN descrive l'applicazione di diversi passaggi per garantire la quantificazione dei segnali in buona fede. La rimozione delle letture di scarsa qualità e delle sequenze di adattatori dai dati di lettura non elaborati è uno dei primi passaggi del controllo di qualità e uno dei passaggi più critici per ottenere risultati di analisi accurati. Pertanto, questa pipeline di analisi include passaggi di ritaglio di qualità e adattatori facili da applicare utilizzando il programma Trim-galore²⁷. Data l'importanza di questo processo, questa pipeline di analisi include passaggi per confrontare la qualità dei risultati prima (passaggio 4.3) e dopo (passaggio 5.3) il processo di rifilatura (passaggio 5.5). Oltre al trimming della qualità e dell'adattatore, questa pipeline di analisi rimuove anche le letture cromosomiche non canoniche, le regioni di ripetizione TA e le regioni della blacklist, che possono introdurre distorsioni del contenuto GC e picchi falsi positivi/picchi chiamati. Queste fasi di filtrazione forniscono una pipeline introduttiva appropriata per i principianti della bioinformatica per comprendere le fasi critiche del controllo di qualità per l'analisi dei dati CUT&RUN.

Dopo la fase di filtraggio, questa pipeline di analisi CUT&RUN fornisce due opzioni di normalizzazione: 'scaled fractional readcount (SFRC)²²' e 'Spike-in normalized Reads Per Million mapped reads in the negative Control (SRPMC)^24,25 per creare file di input per la chiamata e la visualizzazione dei picchi a valle. Se ci si aspetta che il set di dati CUT&RUN riveli differenze locali solo senza differenze di segnale a livello di genoma tra i campioni, il readcount frazionario scalato (la frazione di conteggi moltiplicata per la dimensione dello gnomo di riferimento) può essere sufficiente per l'analisi a valle. Tuttavia, se esiste la possibilità che siano presenti differenze di segnale su scala globale tra i campioni CUT&RUN, gli utenti possono scegliere il metodo SRPMC che considera il rapporto tra le letture tra spike-in e campione (sia i campioni sperimentali CUT&RUN che i campioni di controllo negativi) insieme alla normalizzazione delle letture per milione (RPM) per le letture dei controlli negativi per rendere le letture dei controlli negativi comparabili tra campioni diversi. Poiché SRPMC fornisce letture normalizzate rispetto alle letture di controllo negative normalizzate, questo approccio riduce al minimo il segnale di controllo negativo e consente il confronto tra set di dati creati in batch e gruppi diversi.

Un fattore importante nella chiamata dei picchi dei campioni CUT&RUN è l'eliminazione dei picchi CUT&RUN falsi positivi durante l'analisi in silico , in parte attraverso l'inclusione di campioni di IgG. In particolare, questa pipeline di analisi fornisce approcci di chiamata dei picchi per diversi chiamanti di picco per eliminare i falsi positivi CUT&RUN chiamati picchi. Per i chiamanti di picco MACS2/3, la pipeline di analisi applica le letture fittizie IgG come campione di input durante la chiamata di picco. Per SEACR, questa pipeline di analisi raccomanda di chiamare prima i picchi per i campioni sperimentali e i campioni di controllo negativi in modo indipendente, quindi di rimuovere i picchi che si sovrappongono tra i campioni sperimentali e i campioni di controllo negativi poiché SEACR può "perdere" la maggior parte dei picchi se fornito con il controllo negativo durante la chiamata dei picchi dei campioni sperimentali. I picchi curati mostrano una somiglianza comparabile tra i diversi chiamanti di picco e le repliche (Figura 5). Nel complesso, la rimozione di cromosomi non canonici di scarsa qualità, la regione della blacklist e le letture delle ripetizioni TA, il taglio delle sequenze adattatrici, la normalizzazione del DNA spike-in e la corretta gestione del controllo negativo durante le fasi di peak calling forniscono agli utenti file di conteggio dei letti appropriati adatti per le analisi a valle. Con file di lettura normalizzati di alta qualità e picchi denominati curati, gli utenti possono procedere al confronto della somiglianza tra le repliche e creare mappe di calore e metaplot con segnale di sfondo ultra-pulito per convalidare l'efficace chiamata del picco.

La chiamata di picco con letture di alta qualità segna l'inizio dell'estrazione di interpretazioni biologiche dai dati CUT&RUN. Questo protocollo descrive l'ottenimento di segnali di picco focalizzati in mappe di calore e metaplot nominando il segnale più alto o le posizioni del segnale statisticamente più significative come centri di picco. Alcuni approcci di peak calling non selezionano i segnali più alti o i segnali statisticamente più significativi nella loro posizione centrale. Pertanto, ridefinire il centro di ciascun picco come il segnale più alto o la posizione del segnale statisticamente più significativa è un passo importante per creare output di dati visivi con segnali ben focalizzati al centro dei grafici. I file di letto dei picchi originali chiamati vengono conservati per eseguire l'annotazione dei picchi e l'analisi della rilevanza funzionale come passaggi successivi al completamento dei passaggi descritti in questo protocollo.

Sebbene questa pipeline di analisi CUT&RUN includa passaggi per descrivere l'installazione dei programmi richiesti, i principianti in bioinformatica potrebbero incontrare difficoltà nell'installazione degli strumenti di analisi. Pertanto, è stata creata una pagina del problema di Github associata per fornire descrizioni dettagliate passo dopo passo per l'installazione del programma e per facilitare le comunicazioni per supportare gli utenti durante l'installazione del programma nel proprio sistema. I passaggi successivi nella pipeline di analisi CUT&RUN oltre al protocollo descritto in questo articolo includono l'annotazione dei picchi, l'identificazione delle sovrapposizioni tra diversi tipi di picchi chiamati e l'annotazione funzionale per i picchi chiamati. Il completamento delle fasi di controllo della qualità e di richiamo dei picchi descritte in questo protocollo, combinato con l'annotazione dei picchi a valle, consentirà agli utenti di trarre un significato biologico dai loro dati CUT&RUN.

Questa pipeline di analisi CUT&RUN è stata creata per fornire linee guida generali introduttive passo dopo passo per l'analisi CUT&RUN di massa. Questa pipeline presenta alcune limitazioni. In primo luogo, sebbene questa pipeline di analisi stia cercando di gestire l'effetto guidato dalla variazione del contenuto GC filtrando le letture sulle regioni della lista nera (che includono "regioni artefatto ad alto segnale" e "regioni ripetute artefatto" e regioni ripetute TA), questo approccio potrebbe non essere sufficiente per alcuni organismi che potrebbero avere un contenuto GC distintivo sul loro genoma. Pertanto, se gli utenti sono preoccupati per eventuali distorsioni basate sul contenuto GC, prendere in considerazione l'aggiunta di un altro passaggio per correggere le letture mappate. Per i principianti della bioinformatica, 'computeGCBias' e 'correctGCBias' in Deeptools possono essere opzioni per questo obiettivo. In secondo luogo, questa pipeline di analisi gestisce sia le normali dimensioni dell'inserto (100 bp-1 kb) che le letture di piccole dimensioni dell'inserto (< 100 bp), che possono essere le letture effettive di alcune proteine associate alla cromatina, all'interno dello stesso file. Poiché questa pipeline di analisi è scritta in script di shell, gli utenti possono modificare "Script_08_bam-to-BEDPE-BED-bedGraph.sh" per acquisire le letture delle dimensioni di inserimento brevi separatamente dalle normali letture delle dimensioni dei frammenti durante la fase di generazione del file bed delle letture mappate. Successivamente, il file del letto di lettura della dimensione dell'inserto corta può essere normalizzato indipendentemente dalle normali letture mappate della dimensione dell'inserto per ridurre al minimo l'effetto di ridimensionamento. In terzo luogo, per ridurre la complessità della pipeline di analisi, Easy Shells CUTnRUN non include una fase di downsampling per abbinare la profondità di sequenziamento dei campioni CUT&RUN. Tuttavia, gli utenti possono applicare un passaggio di downsampling dopo aver filtrato i file bam utilizzando samtools view²⁸ o PositionBasedDownsampleSam (Picard)²⁹.

Tutte le fasi di analisi di questo protocollo sono scritte in script shell per consentire ai principianti della bioinformatica di apprendere le basi dell'analisi CUT&RUN rivedendo gli script. Ci aspettiamo che gli utenti possano esercitarsi nell'analisi bioinformatica in modo graduale, eseguendo ogni script di shell in sequenza nel terminale. Inoltre, la semplicità degli script di shell forniti in questa pipeline di analisi CUT&RUN consente agli utenti di rivedere e personalizzare questi script per applicare questa pipeline di analisi ai propri dati CUT&RUN. In definitiva, ci aspettiamo che questa pipeline di analisi CUT&RUN possa ridurre i colli di bottiglia comuni nel processo di analisi dei dati CUT&RUN per consentire ai ricercatori di laboratorio e ai principianti della bioinformatica di trarre conclusioni biologiche dai propri dati di sequenziamento CUT&RUN.

Materiali

Elenco dei materiali utilizzati in questo articolo

Nome	Azienda	Numero di catalogo	Commenti
bedGraphToBigWig	ENCODE	https://hgdownload.soe.ucsc.edu/admin/exe/	Software per comprimere e convertire i conteggi delle letture bedGraph in bigWig
bedtools-2.31.1	The Quinlan Lab @ the U. of Utah	https://bedtools.readthedocs.io/en/latest/index.html	Software per elaborare i file bam/bed/bedGraph
bowtie2 2.5.4	Università	Johns Hopkinshttps://bowtie-bio.sourceforge.net/bowtie2/index.shtml	Software per costruire l'indice del papillon ed eseguire l'allineamento
CollectInsertSizeMetrics (Picard)	Broad institute	https://github.com/broadinstitute/picard	Software per eseguire l'analisi della distribuzione delle dimensioni degli inserti
Cutadapt	NBIS	https://cutadapt.readthedocs.io/en/stable/index.html	Software per eseguire la rifilatura
dell'adattatoreDeeptoolsv3.5.1	Max Planck Institute	https://deeptools.readthedocs.io/en/develop/index.html	Software per eseguire l'analisi di correlazione del coefficiente di Pearson, l'analisi dei componenti principali e l'analisi della mappa di calore/grafico medio
FastQC Versione 0.12.0	Babraham Bioinformatics	https://github.com/s-andrews/FastQC	Software per controllare la qualità del file fastq
Intervenev0.6.1	Biologia Computazionale & Regolazione genica - Mathelier group	Software per eseguire l'analisi del diagramma di Venn utilizzando i file di picco
MACSv2.2.9.1	Chan Zuckerberg initiative	https://github.com/macs3-project/MACS/tree/macs_v2	Software per chiamare i picchi
MACSv3.0.2	Chan Zuckerberg initiative	https://github.com/macs3-project/MACS/tree/master	Software per chiamare i picchi
Samtools-1.21	Wellcome Sanger Institute	https://github.com/samtools/samtools	Software per elaborare i file sam / bam
SEACRv1.3	Howard Hughes Medial Institute	https://github.com/FredHutch/SEACR	Software per chiamare i picchi
SRA Toolkit Release 3.1.1	NCBI	https://github.com/ncbi/sra-tools	Software per scaricare SRR da GEO
Trim_Galore v0.6.10	Babraham Bioinformatics	https://github.com/FelixKrueger/TrimGalore	Software per eseguire rifiniture di qualità e atapter