Análise Introdutória e Validação de Dados de Sequenciação CUT&RUN

Resumo

Este protocolo orienta os iniciantes em bioinformática através de um pipeline introdutório de análise CUT&RUN que permite aos usuários concluir uma análise inicial e validação dos dados de sequenciamento CUT&RUN. A conclusão das etapas de análise descritas aqui, combinadas com a anotação de pico a jusante, permitirá que os usuários obtenham insights mecanicistas sobre a regulação da cromatina.

Resumo

A técnica CUT&RUN facilita a detecção de interações proteína-DNA em todo o genoma. As aplicações típicas do CUT&RUN incluem alterações de perfil nas modificações da cauda das histonas ou mapeamento da ocupação da cromatina do fator de transcrição. A adoção generalizada do CUT&RUN é impulsionada, em parte, por vantagens técnicas em relação ao ChIP-seq convencional, que incluem requisitos de entrada de células mais baixos, requisitos de profundidade de sequenciamento mais baixos e maior sensibilidade com sinal de fundo reduzido devido à falta de agentes de reticulação que, de outra forma, mascaram os epítopos de anticorpos. A adoção generalizada do CUT&RUN também foi alcançada por meio do compartilhamento generoso de reagentes pelo laboratório Henikoff e do desenvolvimento de kits comerciais para acelerar a adoção para iniciantes. À medida que a adoção técnica do CUT&RUN aumenta, a análise e a validação do sequenciamento CUT&RUN tornam-se gargalos críticos que devem ser superados para permitir a adoção completa por equipes predominantemente de laboratório úmido. A análise CUT&RUN normalmente começa com verificações de controle de qualidade em leituras de sequenciamento bruto para avaliar a profundidade do sequenciamento, a qualidade da leitura e possíveis vieses. As leituras são então alinhadas a uma montagem de sequência do genoma de referência e várias ferramentas de bioinformática são posteriormente empregadas para anotar regiões genômicas de enriquecimento de proteínas, confirmar a interpretabilidade dos dados e tirar conclusões biológicas. Embora vários pipelines de análise in silico tenham sido desenvolvidos para suportar a análise de dados CUT&RUN, sua complexa estrutura de vários módulos e o uso de várias linguagens de programação tornam as plataformas difíceis para iniciantes em bioinformática que podem não ter familiaridade com várias linguagens de programação, mas desejam entender o procedimento de análise CUT&RUN e personalizar seus pipelines de análise. Aqui, fornecemos um protocolo de pipeline de análise CUT&RUN passo a passo de linguagem única, projetado para usuários com qualquer nível de experiência em bioinformática. Este protocolo inclui a conclusão de verificações críticas de qualidade para validar se os dados de sequenciamento são adequados para interpretação biológica. Esperamos que seguir o protocolo introdutório fornecido neste artigo, combinado com a anotação de pico a jusante, permita que os usuários extraiam insights biológicos de seus próprios conjuntos de dados CUT&RUN.

Introdução

A capacidade de medir as interações entre proteínas e DNA genômico é fundamental para entender a biologia da regulação da cromatina. Ensaios eficazes que medem a ocupação da cromatina para uma determinada proteína fornecem pelo menos duas informações importantes: i) localização genômica e ii) abundância de proteínas em uma determinada região genômica. Rastrear as mudanças de recrutamento e localização de uma proteína de interesse na cromatina pode revelar loci alvo direto da proteína e revelar papéis mecanicistas dessa proteína em processos biológicos baseados em cromatina, como regulação da transcrição, reparo do DNA ou replicação do DNA. As técnicas disponíveis hoje para traçar o perfil das interações proteína-DNA estão permitindo que os pesquisadores explorem a regulação com uma resolução sem precedentes. Tais avanços técnicos foram possibilitados pela introdução de novas técnicas de perfil de cromatina que incluem o desenvolvimento de Clivagem sob Alvos e Liberação Usando Nuclease (CUT & RUN) pelo laboratório Henikoff. O CUT&RUN oferece várias vantagens técnicas em relação à imunoprecipitação convencional da cromatina (ChIP) que incluem menores requisitos de entrada de células, menores requisitos de profundidade de sequenciamento e maior sensibilidade com sinal de fundo reduzido devido à falta de agentes de reticulação que, de outra forma, mascaram os epítopos de anticorpos. A adoção desta técnica para estudar a regulação da cromatina requer uma compreensão completa do princípio subjacente à técnica e uma compreensão de como analisar, validar e interpretar os dados do CUT&RUN.

O procedimento CUT&RUN começa com a ligação das células à Concanavalina A conjugada a esferas magnéticas para permitir a manipulação de números baixos de células durante todo o procedimento. As células isoladas são permeabilizadas usando um detergente neutro para facilitar a introdução de um anticorpo que tem como alvo a proteína de interesse. A nuclease microcócica (MNase) é então recrutada para o anticorpo ligado usando uma etiqueta de proteína A ou proteína A / G ligada à enzima. O cálcio é introduzido para iniciar a atividade enzimática. A digestão da MNase resulta em complexos mononucleossômicos de DNA-proteína. O cálcio é subsequentemente quelatado para encerrar a reação de digestão, e fragmentos curtos de DNA da digestão da MNase são liberados dos núcleos e, em seguida, submetidos à purificação do DNA, preparação da biblioteca e sequenciamento de alto rendimento¹ (Figura 1).

Abordagens in silico para mapear e quantificar a ocupação de proteínas em todo o genoma foram desenvolvidas em paralelo com as abordagens de laboratório úmido usadas para enriquecer essas interações DNA-proteína. A identificação de regiões de sinais enriquecidos (picos) é uma das etapas mais críticas na análise de bioinformática. Os métodos iniciais de análise ChIP-seq usaram algoritmos como MACS² e SICER³, que empregaram modelos estatísticos para distinguir locais de ligação proteína-DNA genuínos do ruído de fundo. No entanto, o ruído de fundo mais baixo e a resolução mais alta dos dados CUT & RUN tornam alguns programas de chamada de pico empregados na análise ChIP-seq inadequados para a análise CUT & RUN⁴. Este desafio destaca a necessidade de novas ferramentas mais adequadas para a análise de dados CUT&RUN. O SEACR⁴ representa uma dessas ferramentas recentemente desenvolvida para permitir chamadas de pico a partir de dados CUT&RUN, superando as limitações associadas às ferramentas normalmente empregadas para a análise ChIP-seq.

As interpretações biológicas dos dados de sequenciamento CUT&RUN são extraídas das saídas a jusante da chamada de pico no pipeline de análise. Vários programas de anotação funcional podem ser implementados para prever a relevância biológica potencial dos picos chamados a partir dos dados do CUT&RUN. Por exemplo, o projeto Gene Ontology (GO) fornece identificação funcional bem estabelecida de genes de interesse ^5,6,7. Várias ferramentas e recursos de software facilitam a análise de GO para revelar genes e conjuntos de genes enriquecidos entre os picos CUT&RUN 8,9,10,11,12,13,14. Além disso, softwares de visualização como o Deeptools¹⁵, o visualizador de genômica integrativa (IGV)¹⁶ e o UCSC Genome Browser¹⁷ permitem a visualização da distribuição de sinais e padrões em regiões de interesse em todo o genoma.

A capacidade de extrair interpretações biológicas dos dados do CUT&RUN depende criticamente da validação da qualidade dos dados. Os componentes críticos a serem validados incluem a avaliação de: i) qualidade do sequenciamento da biblioteca CUT&RUN, ii) similaridade replicada e iii) distribuição de sinal em centros de pico. A conclusão da validação de todos os três componentes é crucial para garantir a confiabilidade das amostras da biblioteca CUT&RUN e dos resultados da análise downstream. Portanto, é essencial estabelecer guias introdutórios de análise CUT&RUN para permitir que iniciantes em bioinformática e pesquisadores de laboratório úmido conduzam essas etapas de validação como parte de seus pipelines de análise CUT&RUN padrão.

Juntamente com o desenvolvimento do experimento CUT&RUN de laboratório úmido, vários pipelines de análise in silico CUT&RUN, como CUT&RUNTools 2.0^18,19, nf-core/cutandrun²⁰ e CnRAP²¹, foram desenvolvidos para apoiar a análise de dados CUT&RUN. Essas ferramentas fornecem abordagens poderosas para analisar conjuntos de dados CUT&RUN e CUT&Tag de célula única e em massa. No entanto, a estrutura modular relativamente complexa do programa e a familiaridade necessária com várias linguagens de programação para conduzir esses pipelines de análise podem dificultar a adoção por iniciantes em bioinformática que buscam entender completamente as etapas de análise do CUT&RUN e personalizar seus próprios pipelines. A evasão dessa barreira requer um novo pipeline de análise introdutório do CUT&RUN que é fornecido em scripts simples passo a passo codificados usando uma única linguagem de programação simples.

Neste artigo, descrevemos um protocolo simples de pipeline de análise CUT&RUN de linguagem única que fornece scripts passo a passo suportados com descrições detalhadas para permitir que usuários novos e novatos realizem análises de sequenciamento CUT&RUN. Os programas usados neste pipeline estão disponíveis publicamente pelos grupos de desenvolvedores originais. As principais etapas descritas neste protocolo incluem alinhamento de leitura, chamada de pico, análise funcional e, mais criticamente, etapas de validação para avaliar a qualidade da amostra para determinar a adequação e confiabilidade dos dados para interpretação biológica (Figura 2). Além disso, esse pipeline oferece aos usuários a oportunidade de cruzar os resultados da análise com os conjuntos de dados CUT&RUN disponíveis publicamente. Em última análise, este protocolo de pipeline de análise CUT&RUN serve como um guia introdutório e referência para iniciantes em análise de bioinformática e pesquisadores de laboratório úmido.

Protocolo

NOTA: As informações para os arquivos fastq CUT&RUN em GSE126612 estão disponíveis na Tabela 1. As informações relacionadas aos aplicativos de software utilizados neste estudo estão listadas na Tabela de Materiais.

1. Baixando o pipeline Easy-Shells_CUTnRUN de sua página do Github

1. Abra o terminal do sistema operacional.
   NOTA: Se o usuário não tiver certeza de como abrir o terminal no macOS e no Windows, revise esta página da Web (https://discovery.cs.illinois.edu/guides/System-Setup/terminal/). Para Linux, revise esta página da Web (https://www.geeksforgeeks.org/how-to-open-terminal-in-linux/).
2. Baixe o pipeline de análise compactado do Github digitando wget https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/archive/refs/heads/main.zip -O ~/Desktop/Easy-Shells_CUTnRUN.zip no terminal.
3. Depois de baixar o arquivo zip, descompacte o arquivo zip baixado digitando unzip ~/Desktop/Easy-Shells_CUTnRUN.zip -d ~/Desktop/ no terminal.
4. Após a descompactação, exclua o arquivo zip digitando rm ~/Desktop/Easy-Shells_CUTnRUN.zip no terminal e altere o nome da pasta digitando mv ~/Desktop/Easy-Shells_CUTnRUN-master ~/Desktop/Easy-Shells_CUTnRUN.
5. Depois de remover o arquivo compactado, digite chmod +x ~/Desktop/Easy-Shells_CUTnRUN/script/*.sh no terminal para definir a permissão executável para todos os scripts de shell dentro do diretório de trabalho. A partir de agora, basta digitar o caminho e o nome desses scripts de shell no terminal ou arrastar os scripts para o terminal e entrar para executar esses scripts de shell no terminal.
   NOTA: O shell Bash normalmente é pré-instalado na maioria das distribuições Linux. No entanto, as versões recentes do macOS não fornecem mais o shell Bash pré-instalado. Se o sistema não tiver o Bash, instale o shell do Bash primeiro. Visite os links abaixo para obter instruções sobre como instalar o shell Bash no sistema operacional Linux (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:). Esses scripts de shell passo a passo são escritos para criar uma pasta ~/Desktop/GSE126612 para executar a maior parte dessa análise CUT&RUN dentro deste diretório sem qualquer necessidade de modificação. Se o usuário entender como usar esses scripts de shell, os usuários podem revisar e personalizar esses scripts de shell para analisar outros conjuntos de dados do CUT&RUN e modificar as opções de acordo com as necessidades específicas do projeto. Para ler e editar esses scripts de shell, considere usar o Visual Studio Code (https://code.visualstudio.com/) como uma opção para um programa fácil de usar disponível para os principais sistemas operacionais.

2. Instalando os programas necessários para o Easy Shells CUTnRUN

1. Entre os scripts de shell com o nome de Script_01_installation_***.sh, descubra o script de shell cujo nome inclui o tipo de sistema operacional do sistema do usuário. Atualmente, o Easy Shells CUTnRUN suporta o script de instalação para sistemas baseados em macOS, Debian/Ubuntu e CentOS/RPM.
2. Abra o terminal e digite echo $SHELL para verificar o shell padrão no terminal ativo. Se o shell Bash for o shell padrão no terminal atual, os usuários poderão ver o seguinte: /path/to/bash (ou uma mensagem semelhante, como /bin/bash) no terminal.
3. Se o shell padrão não for Bash, defina o shell Bash como shell padrão digitando chsh -s $(which bash) no terminal. Se o terminal usar o shell Bash como padrão, pule esta etapa.
4. No terminal, opere o script de shell de instalação digitando ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_01_installation_***.sh ou arraste o arquivo de script de shell para o terminal e digite.
5. Leia o arquivo Test_README.md na pasta /path/to/SEACR-1.3/Testfiles. Siga as instruções no arquivo README para esclarecer se o SEACR no sistema do usuário funciona corretamente.
   NOTA: É crucial validar a função SEACR com arquivos de teste fornecidos pela página do SEACR no Github para obter resultados de chamada de pico adequados a partir dos dados CUT&RUN. Portanto, siga as instruções do Test_README.md em /path/to/SEACR-1.3/Testfiles imediatamente após a instalação do SEACR. Embora o Easy Shells CUTnRUN forneça scripts de shell de instalação para alguns sistemas operacionais, esses scripts podem não funcionar no sistema de alguns usuários para instalar todos os programas necessários para o Easy Shells CUTnRUN. Se houver algum problema na instalação, revise o site original do programa desinstalado ou solicite assistência usando a página de problemas do GitHub do Easy Shells CUTnRUN (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).

3. Fazer o download do conjunto de dados CUT&RUN disponível publicamente do Sequence Read Archive (SRA)

1. Abra o terminal e digite echo $SHELL para verificar o shell padrão no terminal ativo. Se o shell Bash for o shell padrão no terminal atual, os usuários poderão ver o seguinte: /path/to/bash (ou uma mensagem semelhante, como /bin/bash) no terminal.
2. Se o shell padrão não for Bash, defina o shell Bash como shell padrão digitando chsh -s $(which bash) no terminal. Se o terminal usar o shell Bash como padrão, pule esta etapa.
3. Digite ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_02_download-fastq.sh no terminal ou arraste o arquivo de script de shell para o terminal e digite.
   NOTA: Este script irá: (i) Criar uma pasta (~/Desktop/GSE126612/fastq) e baixar uma lista de arquivos SRA escritos em um arquivo de texto (~/Desktop/Easy-Shells_CUTnRUN/sample_info/SRR_list.txt) dentro da pasta fastq. Como exemplo, o SRR_list.txt inclui os arquivos fastq do subconjunto de GSE126612 amostras CUT&RUN. (ii) Baixe os arquivos fastq brutos dentro da pasta fastq. (iii) Crie uma pasta (~/Desktop/GSE126612/log/fastq) e anote um arquivo de log (download-fastq_log.txt) e um arquivo de informações de amostra baixado (SRR_list_info.txt) dentro desta pasta de log.
4. Depois de executar o script, verifique o arquivo de log. Se houver alguma mensagem de erro no arquivo de log, corrija o erro e tente a etapa 3.3 novamente. Se houver algum problema para resolver o problema, peça ajuda na página de problemas do GitHub do Easy Shells CUTnRUN (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: Para facilitar a prática deste pipeline de análise CUT&RUN, as seguintes amostras disponíveis publicamente são recuperadas do SRA: uma amostra de controle simulado (IgG), três amostras de uma arquitetura de cromatina e proteína do fator de transcrição (CTCF), quatro amostras correspondentes a uma marca de histona 'ativa' (H3K27Ac) e três amostras correspondentes a regiões de iniciação transcricional marcadas por RNA polimerase II (RNAPII-S5P). O sequenciamento foi realizado como extremidade emparelhada, portanto, dois arquivos são pareados por amostra.

4. Verificação de qualidade inicial para os arquivos de sequenciamento brutos

1. Abra o terminal e digite echo $SHELL para verificar o shell padrão no terminal ativo. Se o shell Bash for o shell padrão no terminal atual, os usuários poderão ver o seguinte: /path/to/bash (ou uma mensagem semelhante, como /bin/bash) no terminal.
2. Se o shell padrão não for Bash, defina o shell Bash como shell padrão digitando chsh -s $(which bash) no terminal. Se o terminal usar o shell Bash como padrão, pule esta etapa.
3. Digite ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_03_fastQC.sh no terminal ou arraste o script de shell para o terminal e digite.
   NOTA: Este script de shell irá: (i) Executar o programa FastQC para todos os arquivos fastq brutos na pasta ~/Desktop/GSE126612/fastq e salvar os arquivos de relatório de verificação de qualidade na pasta ~/Desktop/GSE126612/fastqc.1st . (ii) Anote um arquivo de log (fastqc.1st.log.SRR-number.txt) por uma execução do FastQC em uma pasta de log (~/Desktop/GSE126612/log/fastqc.1st).
4. Após a conclusão da execução do script de shell, revise o arquivo de log para esclarecer o sucesso da execução. Se houver alguma mensagem de erro no arquivo de log, corrija o erro e repita a etapa 4.3. Se houver algum problema para resolver o problema, solicite assistência usando a página de problemas do GitHub do Easy Shells CUTnRUN (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: Entre os arquivos de saída, fastqc.html arquivos incluem resultados de verificação de qualidade fáceis de usar. Se houver problemas graves de qualidade, discuta com colegas de bioinformática para determinar a adequação dos dados para análise posterior. Relatórios de controle de qualidade semelhantes são usados para confirmar a qualidade de dados aprimorada após o corte do adaptador. Para usar esse script para outros conjuntos de dados, edite o caminho dos diretórios de trabalho e de saída para atender às necessidades do usuário. Uma diferença notável ao interpretar o QC do CUT&RUN em comparação com as leituras do ChIP-seq é que as leituras duplicadas no CUT&RUN não indicam necessariamente duplicatas de PCR. Isso ocorre porque a MNase recrutada será digerida no mesmo local ou em locais semelhantes dentro dos grupos experimentais.

5. Qualidade e ajuste do adaptador para arquivos de sequenciamento brutos

1. Abra o terminal e digite echo $SHELL para verificar o shell padrão no terminal ativo. Se o shell Bash for o shell padrão no terminal atual, os usuários poderão ver o seguinte: /path/to/bash (ou uma mensagem semelhante, como /bin/bash) no terminal.
2. Se o shell padrão não for Bash, defina o shell Bash como shell padrão digitando chsh -s $(which bash) no terminal. Se o terminal usar o shell Bash como padrão, pule esta etapa.
3. Digite ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_04_trimming.sh no terminal ou arraste o script Script_04_trimming.sh para o terminal e digite.
   NOTA: Este script de shell irá: (i) Executar o programa Trim-Galore para todos os arquivos fastq brutos em ~/Desktop/GSE126612/fastq para executar o ajuste do adaptador e da qualidade. (ii) Crie uma pasta (~/Desktop/GSE126612/trimmed) e salve os arquivos de saída do Trim-Galore dentro da pasta cortada. (iii) Crie uma pasta de log (~/Desktop/GSE126612/log/trim_galore) e anote um arquivo de log trim_galore_log_RSS-number.txt por uma execução do Trim-Galore.
4. Após a conclusão da execução, revise o arquivo de log com cuidado. Se houver alguma mensagem de erro no arquivo de log, corrija o erro e repita a etapa 5.3. Se houver algum problema para resolver o problema, solicite assistência usando a página de problemas do GitHub do Easy Shells CUTnRUN (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
5. Após a conclusão deste processo, compare os arquivos de saída .html com os arquivos fastqc.html criados em 4.3. Revise o caminho dos diretórios de entrada e saída para executar a etapa de corte para quaisquer arquivos fastq localizados em outro lugar.

6. Baixando o índice bowtie2 para os genomas de referência para amostras de controle reais e de pico

1. Abra o terminal e digite echo $SHELL para verificar o shell padrão no terminal ativo. Se o shell Bash for o shell padrão no terminal atual, os usuários poderão ver o seguinte: /path/to/bash (ou uma mensagem semelhante, como /bin/bash) no terminal.
2. Se o shell padrão não for Bash, defina o shell Bash como shell padrão digitando chsh -s $(which bash) no terminal. Se o terminal usar o shell Bash como padrão, pule esta etapa.
3. Digite ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_05_bowtie2-index.sh no terminal ou arraste o script de shell para o terminal e digite.
   NOTA: Este script irá: (i) Baixar índices Bowtie2 para genomas de referência de amostra reais (humano; hg19; usado na publicação original²²) e genomas de referência de controle Spike-in (levedura em brotamento; R64-1-1) na pasta bowtie2-index (~/Desktop/Easy-Shells_CUTnRUN/bowtie2-index). (iii) Anote um arquivo de log (bowtie2-index-log.txt) em um diretório de log (~/Desktop/GSE126612/log/bowtie2-index).
4. Após a conclusão da execução, verifique o arquivo de log. Se houver alguma mensagem de erro, corrija o erro e repita a etapa 6.3. Se houver algum problema para resolver o problema, solicite assistência usando a página de problemas do GitHub do Easy Shells CUTnRUN (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: Atualmente, os índices Bowtie2 para vários genomas de referência são fornecidos no site Bowtie2 (https://bowtie-bio.sourceforge.net/bowtie2/manual.shtml). Os usuários podem editar Script_05_bowtie2-index.sh para baixar qualquer índice Bowtie2 para atender aos requisitos do usuário. Se o usuário não conseguir localizar o índice Bowtie2 do genoma de referência de interesse, localize os arquivos fasta da sequência do genoma de referência em:
   1. Ensembl ftp (https://ftp.ensembl.org/pub/current_fasta/)
   2. Página da UCSC (https://hgdownload.soe.ucsc.edu/downloads.html)
   3. ou outros bancos de dados específicos da espécie.
      Depois de localizar os arquivos fasta da sequência do genoma de referência, crie um índice Bowtie2 para o genoma de referência baixado seguindo a seção "O indexador bowtie2-build" (https://bowtie-bio.sourceforge.net/bowtie2/manual.shtml#the-bowtie2-build-indexer) do site Bowtie2.

7. Mapeamento de leituras de sequenciamento CUT&RUN aparadas para os genomas de referência

1. Abra o terminal e digite echo $SHELL para verificar o shell padrão no terminal ativo. Se o shell Bash for o shell padrão no terminal atual, os usuários poderão ver o seguinte: /path/to/bash (ou uma mensagem semelhante, como /bin/bash) no terminal.
2. Se o shell padrão não for Bash, defina o shell Bash como shell padrão digitando chsh -s $(which bash) no terminal. Se o terminal usar o shell Bash como padrão, pule esta etapa.
3. Digite ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_06_bowtie2-mapping.sh no terminal ou arraste o arquivo de script de shell para o terminal e digite.
   NOTA: Este script de shell irá: (1) Executar o programa bowtie2 para mapear todos os arquivos fastq cortados do adaptador e da qualidade para controle experimental (humano; hg19) e pico (levedura de brotamento; R64-1-1) genomas de referência independentemente. (ii) Execute a função de visualização samtools para compactar os arquivos de pares de leitura mapeados no formato bam. (iii) Crie uma pasta (~/Desktop/GSE126612/bowtie2-mapped) e salve o arquivo de pares de leitura mapeados compactados dentro da pasta bowtie2-mapped. (iv) Crie uma pasta (~/Desktop/GSE126612/log/bowtie2-mapped) e anote o log do processo de mapeamento como bowtie2_log_hg19_SRR-number.txt de arquivo de texto para pares de leitura mapeados no genoma de referência hg19 e bowtie2_log_R64-1-1_SRR-number.txt para pares de leitura mapeados em R64-1-1) para indicar a eficiência do mapeamento dentro da pasta de log de mapeamento bowtie2.
4. Após a conclusão da execução, verifique o arquivo de log. Se houver alguma mensagem de erro no arquivo de log, corrija o erro e execute o script de shell novamente. Se houver algum problema para resolver o problema, solicite assistência usando a página de problemas do GitHub do Easy Shells CUTnRUN (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: Este script de shell executa bowtie2 com opções para mapear arquivos de sequenciamento de extremidade emparelhada para encontrar pares de leitura mapeados concordantemente com comprimentos de fragmento de 10 bp-700 bp. Descubra as descrições das opções digitando bowtie2 --help no terminal ou visitando o site da gravata borboleta2 (https://bowtie-bio.sourceforge.net/bowtie2/manual.shtml#the-bowtie2-aligner) para entender e alterar as opções conforme necessário. Use este script de shell para mapear quaisquer outros arquivos fastq alterando o formato de caminho e nome dos arquivos fastq e dos índices Bowtie2.

8. Classificando e filtrando os arquivos de pares de leitura mapeados

1. Abra o terminal e digite echo $SHELL para verificar o shell padrão no terminal ativo. Se o shell Bash for o shell padrão no terminal atual, os usuários poderão ver o seguinte: /path/to/bash (ou uma mensagem semelhante, como /bin/bash) no terminal.
2. Se o shell padrão não for Bash, defina o shell Bash como shell padrão digitando "chsh -s $(which bash)" no terminal. Se o terminal usar o shell Bash como padrão, pule esta etapa.
3. Digite ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_07_filter-sort-bam.sh no terminal ou arraste o arquivo de script de shell para o terminal e digite.
   NOTA: Este script irá: (i) Executar a função de visualização samtools para todos os arquivos de pares de leitura mapeados compactados na pasta ~/Desktop/GSE126612/bowtie2-mapped para filtrar pares de leitura mapeados em regiões cromossômicas não canônicas, lista negra anotada publicamente e regiões de repetição TA. (ii) Execute a função de classificação samtools para classificar os arquivos bam filtrados por nomes de fragmentos ou coordenadas dentro do mesmo diretório. (iii) Anote um arquivo de log por um arquivo bam de entrada no diretório ~/Desktop/GSE126612/log/filter-sort-bam .
4. Após a conclusão da execução, revise os arquivos de log com cuidado. Se houver alguma mensagem de erro nos arquivos de log, corrija o erro e tente executar o script de shell novamente. Se houver algum problema para resolver o problema, solicite assistência usando a página de problemas do GitHub do Easy Shells CUTnRUN (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: Os arquivos bam resultantes (saída) classificados por nomes de fragmentos servirão como arquivos de entrada para criar arquivos bedGraph de fragmentos e readcounts brutos. Os arquivos bam classificados por coordenadas servirão como arquivos de entrada para gerar arquivos BEDPE de fragmento. Todos os BED, bedGraph e BEDPE serão usados para chamadas de pico e visualização na análise downstream. Todos os arquivos de leito de anotação para regiões cromossômicas canônicas (chr1~22, chrX, chrY e chrM), regiões de lista negra^{anotadas publicamente 23} e regiões de repetição TA¹⁸ estão localizadas no diretório ~/Desktop/Easy-Shells_CUTnRUN/blacklist . Se necessário, use este diretório para adicionar arquivos de lista negra adicionais. Use este script de shell para executar as mesmas funções para outros arquivos bam de pares de leitura mapeados, alterando o caminho e o nome dos arquivos bam. Digite samtools view --help e samtools sort --help no terminal para obter mais descrições sobre essas funções.

9. Converta pares de leitura mapeados em arquivos bedGraph de fragmento BEDPE, BED e readcounts brutos

1. Abra o terminal e digite echo $SHELL para verificar o shell padrão no terminal ativo. Se o shell Bash for o shell padrão no terminal atual, os usuários poderão ver o seguinte: /path/to/bash (ou uma mensagem semelhante, como /bin/bash) no terminal.
2. Se o shell padrão não for Bash, defina o shell Bash como shell padrão digitando chsh -s $(which bash) no terminal. Se o terminal usar o shell Bash como padrão, pule esta etapa.
3. Digite ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_08_bam-to-BEDPE-BED-bedGraph.sh no terminal ou arraste o arquivo de script de shell para o terminal e digite.
   NOTA: Este script irá: (i) Executar macs3 filterdup e awk function para converter arquivos bam classificados por coordenadas em arquivos BEDPE de fragmento cujos comprimentos de fragmento são menores que 1kb e salvar os arquivos BEDPE em ~/Desktop/GSE126612/BEDPE. (ii) Crie um diretório de log (~/Desktop/GSE126612/log/bam-to-BEDPE) e anote um arquivo de log por arquivo de fragmentos de leituras mapeadas. (iii) Execute as funções bedtools bamtobed e awk, cut, sort para converter arquivos bam classificados por nomes de fragmentos em arquivos BED de fragmentos cujos comprimentos de fragmento são menores que 1 kb. (iv) Crie uma pasta (~/Desktop/GSE126612/bam-to-bed) e salve os arquivos BED de fragmento dentro da pasta bam-to-bed. (v) Anote um arquivo de log por arquivo BED de fragmentos de leituras mapeadas em um diretório de log (~/Desktop/GSE126612/log/bam-to-bed). (vi) Execute a função bedtools genomecov para gerar arquivos bedGraph readcounts brutos usando os arquivos BED de fragmento em uma pasta (~/Desktop/GSE126612/bedGraph).
4. Após a conclusão da execução, verifique os arquivos de log com cuidado. Se houver algum problema para resolver o problema, solicite assistência usando a página de problemas do GitHub do Easy Shells CUTnRUN (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: Os arquivos bedGraph de readcounts brutos de saída serão usados como arquivos de entrada para o programa de chamada de pico SEACR com opção de normalização na seção 12 e normalização de contagem de leitura fracionária em escala (SFRC)²² na seção 10. Os arquivos BED de fragmento servirão como arquivos de entrada para leituras mapeadas normalizadas por milhão de Spike-in na normalização de controle negativo (SRPMC)^24,25 na seção 10.To capturar fragmentos curtos (>100 bp) apenas para dados CUT&RUN de fatores associados à cromatina, alterar a etapa de filtragem de fragmentos neste script e prosseguir com a etapa de normalização. Para comparar os sinais CUT & RUN entre fragmentos de tamanho curto e regular dentro da mesma amostra, a normalização SFRC pode ser útil para reduzir o efeito potencial de redução da amostragem causado pela captura apenas de fragmentos curtos. Use este script de shell para executar os mesmos processos para outros arquivos bam classificados sequenciados de extremidade emparelhada, alterando o formato de caminho e nome dos arquivos bam e bed.

10. Convertendo arquivos bedGraph readcounts brutos em arquivos bedGraph e bigWig normalizados

1. Abra o terminal e digite echo $SHELL para verificar o shell padrão no terminal ativo. Se o shell Bash for o shell padrão no terminal atual, os usuários poderão ver o seguinte: /path/to/bash (ou uma mensagem semelhante, como /bin/bash) no terminal.
2. Se o shell padrão não for Bash, defina o shell Bash como shell padrão digitando chsh -s $(which bash) no terminal. Se o terminal usar o shell Bash como padrão, pule esta etapa.
3. Digite ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_09_normalization_SFRC.sh no terminal ou arraste o arquivo de script de shell para o terminal e digite.
   NOTA: Este script é gravado para: (i) Executar for-loop com a função awk para criar arquivos bedGraph normalizados SFRC usando arquivos bedGraph readcounts brutos em ~/Desktop/GSE126612/bedGraph. (ii) Execute a função bedGraphToBigWig para criar o formato compactado (.bw) dos arquivos bedGraph normalizados do SFRC em ~/Desktop/GSE126612/bigWig. (iii) Anote um arquivo de log para registrar o fator de normalização usado para o cálculo do SFRC por execução e salve o arquivo de log em ~/Desktop/GSE126612/log/SFRC.
4. Após a conclusão da execução, verifique os arquivos de log. Se houver alguma mensagem de erro, corrija o erro e execute o script de shell novamente. Se houver algum problema para resolver o problema, solicite assistência usando a página de problemas do GitHub do Easy Shells CUTnRUN (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: A normalização de contagem de leitura fracionária em escala foi usada na publicação original²² de GSE126612 conjunto de dados CUT&RUN. A fórmula da normalização no compartimento i é a mesma abaixo:
   
   Como esse método de normalização não inclui normalização com controle negativo (por exemplo, amostra de IgG) nem controle de pico, essa abordagem pode não ser ideal para observar a diferença de sinal em todo o genoma entre as amostras. No entanto, como esse método é teoricamente semelhante a outras normalizações baseadas em readcounts totais (por exemplo, Contagem por milhão), seria bom o suficiente observar a diferença de sinal local entre as amostras.
5. Digite ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_09_normalization_SRPMC.sh no terminal ou arraste o arquivo de script de shell para o terminal e digite.
   NOTA: Este script irá: (i) Executar for-loop com a função bedtools genomecov para criar arquivos de gráfico de leito normalizados SRPMC em ~/Desktop/GSE126612/bedGraph usando arquivos BED de fragmento em ~/Desktop/GSE126612/bam-to-bed. (ii) Anote um arquivo de log para registrar os fatores de normalização usados para a normalização SRPMC por uma execução em ~/Desktop/GSE126612/log/SRPMC. (iii) Execute a função bedGraphToBigWig para criar o formato compactado (.bw) dos arquivos bedGraph normalizados e salve os arquivos bigWig normalizados na pasta ~/Desktop/GSE126612/bigWig .
6. Após a conclusão da execução, revise os arquivos de log com cuidado. Se houver alguma mensagem de erro nos arquivos de log, corrija o erro e execute o script de shell novamente. Se houver algum problema para resolver o problema, solicite assistência usando a página de problemas do GitHub do Easy Shells CUTnRUN (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: A fórmula de normalização SRPMC foi desenvolvida para normalizar as contagens de leitura de amostras reais com controle negativo (amostra de IgG, por exemplo) e controle de pico, combinando o fator de normalização RPM (leituras por milhão de leituras mapeadas), RPS (proporção de leituras por leitura de pico) e razão de sinal relativo para controle^24,25. A definição de RPS é a mesma abaixo:
   
   Ao aplicar RPS para amostra real e amostra de controle negativo, a razão de sinal relativo (RS) para controle para amostra real pode ser calculada como abaixo:
   
   E a definição do fator de normalização RPM (RPM:NF) é a mesma abaixo:
   
   A partir daqui, o fator de normalização SRPMC (SRPMC:NF) saiu combinando o RS e o RPM:NF:
   
   E esta fórmula pode ser simplificada da seguinte forma:
   
   Portanto, o método SRPMC normaliza as leituras pela (1) proporção de leituras de pico entre o controle e a amostra e (2) leituras de controle normalizadas por RPM. Uma vez que esse fator de normalização considera leituras de pico e torna as leituras de controle comparáveis entre as amostras, esse método seria apropriado para observar a diferença em todo o genoma entre as amostras e reduzir o efeito do lote no total de leituras de amostras reais e controles em diferentes experimentos em lote. Esses arquivos bedGraph normalizados se tornarão arquivos de entrada para chamar picos usando o SEACR na seção 11. E esses arquivos bigWig normalizados serão usados na visualização de loci por meio de IGV e na criação de mapa de calor e gráfico médio via Deeptools. É altamente recomendável usar um navegador de genoma para visualizar o padrão de paisagem do conjunto de dados CUT&RUN usando os arquivos bigWig normalizados em regiões genômicas representativas para avaliar a qualidade dos dados. As amostras CUT&RUN que exibem padrões de sinal de fundo ruidosos que se assemelham ao controle de IgG provavelmente são apropriadas para omitir para análises posteriores. Use esses scripts de shell para normalizar outros arquivos de leito de leitura e arquivos bedGraph de readcounts brutos, alterando o caminho e os nomes de arquivo para arquivos de entrada e saída de bedgraph e bedgraph. Edite esses scripts para aplicar outros cálculos de normalização alterando os fatores e a fórmula dentro desse script.

11. Validando a distribuição do tamanho do fragmento

1. Abra o terminal e digite echo $SHELL para verificar o shell padrão no terminal ativo. Se o shell Bash for o shell padrão no terminal atual, os usuários poderão ver o seguinte: /path/to/bash (ou uma mensagem semelhante, como /bin/bash) no terminal.
2. Se o shell padrão não for Bash, defina o shell Bash como shell padrão digitando chsh -s $(which bash) no terminal. Se o terminal usar o shell Bash como padrão, pule esta etapa.
3. Digite ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_10_insert-size-analysis.sh no terminal ou arraste o arquivo de script de shell para o terminal e digite.
   NOTA: Este script é gravado em: (i) Execute picard.jar função CollectInsertSizeMetrics usando arquivos bam de pares de leitura mapeados na pasta ~/Desktop/GSE126612/filtered-bam para identificar a distribuição do tamanho da inserção. (ii) Crie uma pasta (~/Desktop/GSE126612/insert-size-distribution) e salve os resultados da análise de distribuição de tamanho de inserção na pasta criada. (iii) Anote um arquivo de log por um arquivo bam de entrada na pasta ~/Desktop/GSE126612/log/insert-size-distribution .
4. Após a conclusão da execução, verifique os arquivos de log com cuidado. Se houver alguma mensagem de erro nos arquivos de log, corrija o erro e tente executar o script de shell novamente. Se houver algum problema para resolver o problema, solicite assistência usando a página de problemas do GitHub do Easy Shells CUTnRUN (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: Em geral, a análise do tamanho da inserção (Saída) para amostras CUT&RUN mostra picos principais em faixas de tamanho nucleossômico mono (100-300 pb) e di (300-500 pb). Erros/limitações técnicas (como digestão excessiva/insuficiente da MNase durante a preparação da amostra CUT&RUN ou seleção inadequada do tamanho durante a preparação da biblioteca) podem causar o enriquecimento de fragmentos iguais ou maiores que os trinucleossômicos (500-700 pb) e iguais ou menores que os fragmentos subnucleossômicos (<100 pb). Às vezes, a ausência de picos de tamanho mononucleossômico com o enriquecimento dos fragmentos longos (>500 pb) e curtos (<100 pb) pode ser devido às faixas de seleção de tamanho de biblioteca escolhidas no estágio de laboratório úmido ou à baixa profundidade de sequenciamento. Compare a profundidade do sequenciamento ('bases sequenciadas totais' / 'tamanho total do genoma de referência'), a visão geral do cenário genômico usando arquivos bigWig de readcounts normalizados na seção 10 e o padrão de distribuição do tamanho da inserção para esclarecer a qualidade das amostras CUT&RUN processadas. As linhas tracejadas nos histogramas representam a 'fração cumulativa' de leituras com um tamanho de inserção maior ou igual ao valor no eixo x. Essa linha tracejada permite a identificação da distribuição dos tamanhos de inserção no arquivo de leituras mapeadas de entrada. A progressão ao longo do eixo x está associada ao aumento do tamanho da pastilha. A linha tracejada identifica a proporção de pares de leitura mapeados no arquivo bam de entrada que têm um tamanho de inserção pelo menos tão grande quanto o indicado na posição do eixo x de interseção. Portanto, a interpretação começa em 1 à esquerda, indicando que todas as leituras têm um tamanho de inserção maior ou igual ao menor tamanho, e diminui para 0 à medida que o tamanho da inserção aumenta.

12. Picos de chamada usando MACS2, MACS3 e SEACR

1. Abra o terminal e digite echo $SHELL para verificar o shell padrão no terminal ativo. Se o shell Bash for o shell padrão no terminal atual, os usuários poderão ver o seguinte: /path/to/bash (ou uma mensagem semelhante, como /bin/bash) no terminal.
2. Se o shell padrão não for Bash, defina o shell Bash como shell padrão digitando chsh -s $(which bash) no terminal. Se o terminal usar o shell Bash como padrão, pule esta etapa.
3. Digite ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_11_peak-calling_MACS.sh no terminal ou arraste o arquivo de script de shell para o terminal e digite.
   NOTA: Este script é gravado para: (i) Executar as funções macs2 callpeak e macs3 callpeak com e sem controle IgG usando arquivos BEDPE de fragmento para chamar picos e salvar os resultados de chamada de pico em diretórios de saída (~/Desktop/GSE126612/MACS2 e ~/Desktop/GSE126612/MACS3). (ii) Anote o log dessas chamadas de pico como arquivo de texto no diretório de log (~/Desktop/GSE126612/log/MACS2 e ~/Desktop/GSE126612/log/MACS3)
4. Digite ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_11_peak-calling_SEACR.sh no terminal ou arraste o arquivo de script de shell para o terminal e digite.
   NOTA: Este script é gravado para: (i) Executar SEACR_1.3.sh script com e sem controle IgG, com opções rigorosas e relaxadas usando readcounts brutos bedGraph e arquivos bedGraph normalizados para chamar picos. (ii) Crie o diretório de saída (~/Desktop/GSE126612/SEACR-peaks) e salve os resultados da chamada de pico por SEACR. (iii) Anote o registro dessas chamadas de pico como arquivo de texto no diretório de log (~/Desktop/GSE126612/log/SEACR).
5. Após a conclusão da execução de scripts de shell, verifique os arquivos de log com cuidado. Se houver alguma mensagem de erro nos arquivos de log, corrija o erro primeiro. Alguns programas podem não chamar picos para amostra de controle de IgG com opção de controle de IgG juntos, portanto, omitir a mensagem de erro sobre a amostra de controle de IgG com opção de controle de IgG. Se houver algum problema para resolver o problema, solicite assistência usando a página de problemas do GitHub do Easy Shells CUTnRUN (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: Esses dois scripts de shell executam chamadas de pico para amostras CUT&RUN usando três chamadores de pico (MACS2, MACS3 e SEACR) com várias opções: com/sem opção de controle IgG, usando arquivos bedGraph readcounts brutos com opção de normalização do chamador de pico ou arquivos bedGraph readcounts normalizados sem opção de normalização do chamador de pico e opções de chamada de pico SEACR rigorosas e relaxadas. Como os arquivos de saída de chamada de pico não são suficientes para serem usados diretamente em análises downstream, o Easy Shells CUTnRUN inclui um script para processar esses arquivos de saída de picos chamados para criar novos arquivos de pico que incluem cromossomo, início, fim e nome dos picos. Por meio de abordagens intensivas de chamadas de pico, o Easy Shells CUTnRUN oferece a oportunidade de escolher o programa de chamadas de pico mais adequado para o projeto CUT&RUN de um usuário, comparando os picos chamados em três chamadores de pico. Além disso, este pipeline de análise CUT&RUN também oferece a oportunidade de selecionar as opções de chamada de pico mais adequadas para o projeto CUT&RUN de um usuário. Essas comparações serão feitas por diagrama de Venn, e visualização como mapa de calor e gráfico médio.

13. Criando arquivos de cama de pico chamados

1. Abra o terminal e digite echo $SHELL para verificar o shell padrão no terminal ativo. Se o shell Bash for o shell padrão no terminal atual, os usuários poderão ver o seguinte: /path/to/bash (ou uma mensagem semelhante, como /bin/bash) no terminal.
2. Se o shell padrão não for Bash, defina o shell Bash como shell padrão digitando chsh -s $(which bash) no terminal. Se o terminal usar o shell Bash como padrão, pule esta etapa.
3. Digite ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_12_make-peak-bed.sh no terminal ou arraste o arquivo de script de shell para o terminal e digite.
   NOTA: Este script é gravado para: (i) Execute a função awk usando arquivos de cama na pasta ~/Desktop/GSE126612/SEACR para criar dois tipos de arquivos de cama de pico SEACR ~/Desktop/GSE126612/peak-bed_SEACR pasta. Todos os arquivos de leito de pico incluem o início e o fim de cada pico, e os arquivos de leito de pico focados incluem o início e o leito do compartimento de sinal mais alto dentro de cada pico. (ii) Execute a função awk usando arquivos _peaks.xls nas pastas ~/Desktop/GSE126612/MACS2 e ~/Desktop/GSE126612/MACS3 para criar arquivos de cama de pico inteiros que incluem o início e o fim de cada pico chamado por MACS2 e MACS3 nas pastas ~/Desktop/GSE126612/peak-bed_MACS2 e ~/Desktop/GSE126612/peak-bed_MACS3 . (iii) Execute a função awk usando arquivos _summits.bed nas pastas ~/Desktop/GSE126612/MACS2 e ~/Desktop/GSE126612/MACS3 para criar arquivos de cama de pico focados que incluem o início e o fim do compartimento mais significativo dentro de cada pico. (iv) Os arquivos de log são gravados em formato de arquivo de texto na pasta ~/Desktop/GSE126612/log/peak-bed .
4. Digite ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_13_filter-peaks.sh no terminal ou arraste o arquivo de script de shell para o terminal e digite.
   NOTA: Este script é gravado para: (i) Executar a função de interseção de ferramentas de cama usando arquivos de cama de pico que são chamados sem a opção de controle IgG para remover picos sobrepostos aos picos de controle IgG. (ii) Os arquivos de cama de pico filtrados são salvos nas pastas ~/Desktop/GSE126612/peak-bed-filtered_MACS2, ~/Desktop/GSE126612/peak-bed-filtered_MACS3 e ~/Desktop/GSE126612/peak-bed-filtered_SEACR . (iii) Um arquivo de log log_filter-peaks.txt é criado na pasta ~/Desktop/GSE126612/log/filter-peaks .
5. Digite ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_14_cat-merge-peak-bed_MACS.sh no terminal ou arraste o arquivo de script de shell para o terminal e digite.
   NOTA: Este script é gravado para: (i) Executar as funções cat e sort para concatenar os arquivos de cama de pico inteiros MACS2 e MACS3 das replicações como um arquivo de cama de pico e classificar o arquivo de cama de pico concatenado na pasta ~/Desktop/GSE126612/bed-for-comparison. (ii) Execute a função de mesclagem de bedtools usando os arquivos de leito de pico inteiros concatenados para mesclar picos que se sobrepõem. (iii) Um arquivo de log log_cat-merged-peak-bed_MACS.txt é escrito na pasta de log ~/Desktop/GSE126612/log/cat-merged-peak-bed.
6. Digite ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_14_cat-merge-peak-bed_SEACR.sh no terminal ou arraste o arquivo de script de shell para o terminal e digite.
   NOTA: Este script é gravado para: (i) Executar as funções cat e sort para concatenar os arquivos de leito de pico SEACR inteiros das réplicas como um arquivo de leito de pico e classificar o arquivo de leito de pico concatenado na pasta ~/Desktop/GSE126612/bed-for-comparison. (ii) Execute a função de mesclagem de bedtools usando os arquivos de leito de pico inteiros concatenados para mesclar picos que se sobrepõem. (iii) Um arquivo de log log_cat-merged-peak-bed_SEACR.txt é gravado na pasta de log ~/Desktop/GSE126612/log/cat-merged-peak-bed.
7. Após a conclusão da execução dos scripts de shell, revise os arquivos de log com cuidado. Se houver alguma mensagem de erro nos arquivos de log, corrija o erro e execute o(s) script(s) novamente. Se houver algum problema para resolver o problema, solicite assistência usando a página de problemas do GitHub do Easy Shells CUTnRUN (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: Todos os arquivos de leito de pico das regiões de pico serão usados como arquivos de entrada da análise do diagrama de Venn para comparar a semelhança entre opções de chamada de pico, métodos de chamada de pico, réplicas e observações de paisagem genômica próximas às regiões de pico. Os arquivos de leito de pico de regiões de pico inteiras mesclados serão usados para análise de componente principal (PC) e análise de correlação de coeficiente de Pearson usando deeptools. Os arquivos de leito de pico focados serão usados para análise de mapa de calor e gráfico médio usando Deeptools.

14. Validação da similaridade entre réplicas usando correlação de Pearson e análise de componentes principais (PC).

1. Abra o terminal e digite echo $SHELL para verificar o shell padrão no terminal ativo. Se o shell Bash for o shell padrão no terminal atual, os usuários poderão ver o seguinte: /path/to/bash (ou uma mensagem semelhante, como /bin/bash) no terminal.
2. Se o shell padrão não for Bash, defina o shell Bash como shell padrão digitando chsh -s $(which bash) no terminal. Se o terminal usar o shell Bash como padrão, pule esta etapa.
3. Digite ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_15_correlation_plotCorrelation.sh no terminal ou arraste o arquivo de script de shell para o terminal e digite.
   NOTA: Este script é gravado para: (i) Executar a função multiBamSummary BED-file usando os arquivos bam de replicações, que foram classificados por coordenadas, e mesclar arquivos de leito de pico inteiros para CTCF, H3K27Ac e RNAPII-S5P para gerar arquivos de matriz para análise de correlação Pearson na pasta Desktop/GSE126612/deeptools_multiBamSummary . (ii) Execute a função plotCorrelation usando os arquivos de matriz para realizar o cálculo do coeficiente de correlação de Pearson e o agrupamento do mapa de calor e salve o resultado na pasta ~/Desktop/GSE126612/deeptools_plotCorrelation . (iii) Anote um arquivo de log log_plotCorrelation.txt na pasta ~/Desktop/GSE126612/log/correlação .
4. Digite ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_15_correlation_plotPCA.sh no terminal ou arraste o arquivo de script de shell para o terminal e digite.
   NOTA: Este script é gravado para: (i) Executar a função multiBamSummary BED-file usando os arquivos bam, que foram classificados por coordenadas, e mesclar arquivos de leito de pico inteiros, que incluem todos os picos CTCF, H3K27ac e RNAPII-S5P, para gerar arquivos de matriz para análise de componentes principais (PCA) na pasta Desktop/GSE126612/deeptools_multiBamSummary . (ii) Execute a função plotPCA usando os arquivos de matriz para executar o PCA e salve o resultado na pasta ~/Desktop/GSE126612/deeptools_plotPCA . (iii) Anote um arquivo de log log_plotPCA.txt na pasta ~/Desktop/GSE126612/log/correlação .
5. Após a conclusão da execução de scripts de shell, verifique os arquivos de log. Se houver alguma mensagem de erro, corrija o erro e execute os scripts de shell novamente. Se houver algum problema para resolver o problema, solicite assistência usando a página de problemas do GitHub do Easy Shells CUTnRUN (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: Em princípio, as réplicas adequadamente preparadas e processadas mostram valores mais altos de coeficiente de correlação de Pearson dentro do mesmo grupo de agrupamento e posicionamento próximo na análise de componentes principais. Qualquer replicação, que mostre um coeficiente de correlação de Pearson mais baixo e longa distância de outras réplicas no gráfico de componentes principais, pode representar um potencial outlier entre as replicações. Este script de shell é aplicável a qualquer formato bam mapeado lê dados. Altere o caminho e o nome do arquivo dos arquivos bigwig para atender aos requisitos específicos do projeto.

15. Validação da similaridade entre replicados, métodos de chamada de pico e opções usando diagrama de Venn

1. Abra o terminal e digite echo $SHELL para verificar o shell padrão no terminal ativo. Se o shell Bash for o shell padrão no terminal atual, pode haver algo como /path/to/bash (por exemplo, /bin/bash) no terminal.
2. Se o shell padrão não for Bash, defina o shell Bash como shell padrão digitando chsh -s $(which bash) no terminal. Se o terminal usar o shell Bash como padrão, considere pular esta etapa
3. Digite ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_16_venn-diagram_methods.sh no terminal ou arraste o arquivo de script de shell para o terminal e digite.
   NOTA: Este script é escrito para: (i) Executar a função intervenn usando arquivos de leito de pico de toda a região de pico para encontrar sobreposições entre os picos chamados por várias opções (com/sem opção de controle IgG, com/sem normalização e opções de chamada de pico rigorosas/relaxadas para SEACR). (ii) Crie uma pasta (~/Desktop/GSE126612/intervene_methods) e salve os resultados da análise do diagrama de Venn nesta pasta. (iii) Anote um arquivo de log log_intervene_methods.txt na pasta ~/Desktop/GSE126612/log/interven .
4. Digite ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_16_venn-diagram_replicates.sh no terminal ou arraste o arquivo de script de shell para o terminal e digite.
   NOTA: Este script é escrito para: (i) Executar a função intervenn usando arquivos de leito de pico de toda a região de pico para encontrar sobreposições entre os picos das replicações. (ii) Crie uma pasta (~/Desktop/GSE126612/intervene_replicates) e salve os resultados da análise do diagrama de Venn nesta pasta. (iii) Anote um arquivo de log log_intervene_replicates.txt na pasta ~/Desktop/GSE126612/log/interven .
5. Após a conclusão da execução dos scripts de shell, revise os arquivos de log. Se houver alguma mensagem de erro, corrija o erro e execute os scripts de shell novamente. Se houver algum problema no uso do pipeline de análise Easy Shells CUTnRUN, peça ajuda na página de problemas do GitHub do Easy Shells CUTnRUN (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: Esses resultados da análise do diagrama de Venn fornecem informações para escolher as opções de chamada de pico, métodos e réplicas mais apropriados com alta reprodutibilidade para análise downstream. Pode ser preferível escolher as opções e métodos de chamada de pico que mostram os números de pico mais altos com boa sobreposição com outros métodos e opções de chamada de pico.

16. Analisar mapas de calor e gráficos médios para visualizar os picos chamados.

1. Abra o terminal e digite echo $SHELL para verificar o shell padrão no terminal ativo. Se o shell Bash for o shell padrão no terminal atual, pode haver algo como /path/to/bash (por exemplo, /bin/bash) no terminal.
2. Se o shell padrão não for Bash, defina o shell Bash como shell padrão digitando chsh -s $(which bash) no terminal. Se o terminal usar o shell Bash como padrão, considere pular esta etapa
3. Digite ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_27_plotHeatmap_focused.sh no terminal ou arraste o arquivo de script de shell para o terminal e digite.
   NOTA: Este script é gravado para: (i) Executar a função de ponto de referência computeMatrix usando arquivos bigWig normalizados e arquivos de cama de pico focados para criar matrizes de readcounts normalizadas no centro dos picos focados na pasta ~/Desktop/GSE126612/deeptools_computeMatrix . (ii) Execute a função plotHeatmap usando a matriz de contagem de leitura normalizada para gerar mapas de calor e gráficos médios que visualizam o padrão de distribuição de contagem de leitura normalizada nos locais de pico focados. (iii) Crie uma pasta (~/Desktop/GSE126612/deeptools_plotHeatmap) e salve os arquivos de saída plotHeatmap dentro desta pasta. (iv) Anote um arquivo de log log_plotHeatmap_focused.txt na pasta ~/Desktop/GSE126612/log/plotHeatmap .
4. Digite ~/Desktop/Easy-Shells_CUTnRUN/scripts/Script_27_plotHeatmap_whole.sh no terminal ou arraste o arquivo de script de shell para o terminal e digite.
   Este script é gravado para: (i) Executar a função de ponto de referência computeMatrix usando arquivos bigWig normalizados e arquivos de cama de pico inteiros para criar matrizes de readcounts normalizadas no centro de todos os picos na pasta ~/Desktop/GSE126612/deeptools_computeMatrix . (ii) Execute a função plotHeatmap usando a matriz de contagem de leitura normalizada para gerar mapas de calor e gráficos médios que visualizam o padrão de distribuição de contagem de leitura normalizado em todos os locais de pico. (iii) Crie uma pasta (~/Desktop/GSE126612/deeptools_plotHeatmap) e salve os arquivos de saída plotHeatmap dentro desta pasta. (iv) Anote um arquivo de log log_plotHeatmap_whole.txt na pasta ~/Desktop/GSE126612/log/plotHeatmap .
5. Após a conclusão da execução dos scripts de shell, revise os arquivos de log. Se houver alguma mensagem de erro, corrija o erro e execute os scripts de shell novamente. Se houver algum problema no uso do pipeline de análise Easy Shells CUTnRUN, peça ajuda na página de problemas do GitHub do Easy Shells CUTnRUN (https://github.com/JunwooLee89/Easy-Shells_CUTnRUN/issues).
   NOTA: Idealmente, os locais de pico do cume dos picos MACS2 / 3 e os locais de pico focados dos SEACR exibem uma distribuição de sinal nítida e focada no centro dos gráficos. No entanto, se o algoritmo de chamada de pico não funcionar corretamente para dados CUT & RUN, uma distribuição de sinal "ruidosa" menos focada pode aparecer nos gráficos. Portanto, o uso do número de picos chamados e os padrões de distribuição de sinal de pico dos gráficos de saída orientará a determinação da validade de pico para análises CUT & RUN adicionais que incluem anotação de pico a jusante.

Resultados

A qualidade e o corte do adaptador retêm leituras com alta qualidade de sequenciamento
As técnicas de sequenciamento de alto rendimento são propensas a gerar erros de sequenciamento, como 'mutações' de sequência nas leituras. Além disso, os dímeros do adaptador de sequenciamento podem ser enriquecidos em conjuntos de dados de sequenciamento devido à remoção inadequada do adaptador durante a preparação da biblioteca. Erros excessivos de sequenciamento, como mutações de leitura, geração de leituras mais curtas do que o necessário para o mapeamento adequado e enriquecimento de dímeros do adaptador, podem aumentar o tempo de mapeamento de leitura e podem produzir leituras mapeadas falso-positivas que distorcem os resultados da análise de bioinformática a jusante. Portanto, a filtragem de qualidade e o corte do adaptador são necessários para reter leituras de alta qualidade para análise e interpretação downstream.

Para reter leituras de alta qualidade para análise, este pipeline de análise CUT&RUN (Figura 2) emprega FastQC²⁶ e Trim Galore²⁷. O script de shell "Script_03_fastQC.sh" executa o FastQC para todos os arquivos fastq dentro do diretório de trabalho. Os resultados (Figura 3) desta etapa usando o conjunto de dados CTCF CUT & RUN disponível publicamente do GSE126612 (SRR8581589) identificam algumas leituras com bases de pontuação de baixa qualidade (Figura 3A, C) e alguns graus de incompatibilidade de distribuição de conteúdo de GC por sequência entre estimativa teórica e leituras reais (Figura 3E).

A execução do script "Script_04_trimming.sh" para executar o Trim Galore remove com sucesso as leituras com bases de pontuação de baixa qualidade (abaixo de 20 na Figura 3A) e baixas qualidades de sequência média evidentes de pré-corte (Figura 3B-D). Além disso, "Script_04_trimming.sh" também remove com sucesso 55 ~ 60% do enriquecimento médio do conteúdo de GC exibido na distribuição de GC de 'pré-corte' sobre o gráfico de sequência (Figura 3E, F). Esses resultados demonstram que este pipeline de análise CUT&RUN filtra leituras de alta qualidade para facilitar o mapeamento de leitura rápido e preciso para o genoma de referência.

A distribuição do tamanho da inserção pode fornecer uma estimativa para os resultados de chamadas de pico
Devido ao uso de MNase no CUT&RUN (Figura 1), espera-se que as leituras mapeadas do CUT&RUN exibam picos de tamanho de fragmento de DNA mono (~ 200 pb) e dinucleossômico (~ 350 pb) nos gráficos de distribuição do tamanho da inserção (Figura 4). Problemas com a detecção de alguns alvos podem resultar em inserções curtas (< 100 pb) (Figura 4C). O alto nível de leituras curtas reduz o número de leituras que podem ser usadas para chamadas de pico de alta confiança, reduzindo assim os números de pico e impactando a análise downstream. Neste pipeline de análise CUT&RUN, "Script_10_insert-size-analysis.sh" opera a função "picard.jar CollectInsertSizeMetrics" para realizar a análise de distribuição de tamanho de inserção e exportar histogramas como uma saída de visualização (Figura 2). Nos gráficos de saída (Figura 4A-C), o eixo x mostra a faixa de tamanho da pastilha, o lado esquerdo do eixo y e o histograma preenchido representam o número de pastilhas com o valor no eixo x, e o lado direito do eixo y mostra e a linha tracejada a fração cumulativa de pastilhas com um tamanho de pastilha igual ou maior que o valor no eixo x. Portanto, tanto a localização no eixo X com a mudança mais dramática na inclinação da linha tracejada que se cruza com o nível mais alto no histograma identifica o tamanho principal da inserção na amostra. Entre as leituras mapeadas no genoma de referência de interesse (humano, hg19), os fragmentos de amostra H3K27Ac (marca de histona ativa) exibem a distribuição de tamanho de inserção CUT & RUN esperada com maior tamanho mononucleossômico e picos de tamanho dinucleossômico detectáveis (Figura 4B). Os fragmentos de amostra de CTCF mostraram grupos adicionais em regiões de comprimento de fragmento de 100 ~ 200bp (Figura 4A). Ao todo, o pipeline de análise CUT&RUN fornece scripts de shell fáceis de usar para realizar a análise de distribuição de tamanho de inserção após o mapeamento de leituras em genomas de referência. Essas análises tornam-se importantes ao estimar a eficiência da chamada de pico antes da análise downstream.

O pipeline de análise Easy Shells CUTnRUN fornece opções de filtragem e normalização para criar readcounts confiáveis
Um dos pontos críticos da análise CUT&RUN é obter pares de leitura mapeados adequados, filtrando pares de leitura problemáticos das saídas iniciais de mapeamento e normalizando as contagens de leitura mapeadas filtradas com um método de cálculo de normalização específico que pode atender aos objetivos/necessidades da análise do usuário. O pipeline de análise CUT & RUN discutido neste estudo inclui script "Script_07_filter-sort-bam.sh" para remover pares de leitura que são mapeados em cromossomos não canônicos, regiões de lista negra anotadas publicamente²³ e TA repete regiões^18,22 de pares de leitura que foram mapeados por gravata borboleta2 usando "Script_06_bowtie2-mapping.sh". Essas filtrações são necessárias para remover pares de leitura que podem produzir sinais de pico atípicos falso-positivos e chamados picos na análise downstream (Figura 5; regiões de caixa amarela).

Além das filtrações, a aplicação do método de normalização correto é um fator importante para visualizar com precisão a diferença de sinal entre as amostras. Portanto, o pipeline de análise CUT & RUN inclui scripts "Script_09_normalization_SFRC.sh" e "Script_09_normalization_SRPMC.sh" para fornecer dois métodos de normalização verificados publicamente - o readcout fracionário em escala (SFRC) ²² e as leituras mapeadas normalizadas por milhão de leituras mapeadas no controle negativo (SRPMC) ^{24 , 25} ( Figura 5A - D). Como o SFRC não inclui controle (por exemplo, IgG) nem amostra de pico na fórmula, a normalização do SFRC pode ser usada para amostras que não incluem nenhuma amostra de controle ou devem mostrar diferenças de sinal apenas em regiões locais sem diferença de escala em todo o genoma. As amostras normalizadas do SFRC processadas pelo pipeline de análise CUT & RUN (Figura 5A-D; faixas vermelhas) produzem os mesmos padrões de distribuição de sinal que as leituras mapeadas disponíveis publicamente do GEO (Figura 5A-D; faixas pretas), sugerindo que esta tubulação pode reproduzir os resultados da publicação.

O método SRPMC é útil para normalizar amostras que incluem amostras de controle e Spike-in e espera-se que mostrem a diferença de sinal global entre as amostras (Figura 5A-D; trilhas verdes). Uma vez que uma amostra de H3K27Ac (SRR8581599) exibe uma proporção muito maior de "(leituras reais de CUT & RUN) / (leituras de pico)" (RPS de amostra; 997) do que outras réplicas (237, 175 e 161), os sinais relativos de H3K27Ac parecem diferentes entre as réplicas em amostras normalizadas SFRC e SRPMC (Figura 5A-D; H3K27Ac comparado em todas as faixas). As amostras RNAPII-S5P exibem RPS de amostra relativamente mais baixo (1,7, 0,8, 2,1) do que o controle IgG (259), portanto, as amostras RNAPII-S5P exibem sinal mais baixo do que o controle IgG após a normalização SRPMC (Figura 5A-D; RNAPII-S5P comparado em todas as faixas). Portanto, o pipeline de análise CUT & RUN discutido aqui recomenda o uso do método SRPMC apenas para as amostras que têm leituras suficientes em amostras experimentais em relação ao controle de IgG e às leituras de controle de pico.

A comparação do diagrama de Venn pode dar ideias para escolher o melhor método e opções de chamada de pico
Vários programas de chamada de pico permitem a identificação de ocupação de proteínas significativamente enriquecidas em todo o genoma. Tais programas empregados para análise CUT & RUN incluem os programas da família MACS² e SEACR⁴ como principais métodos até agora. No entanto, pode ser um desafio, especialmente para iniciantes em bioinformática, identificar o método e as opções de chamada de pico mais apropriados para um determinado projeto CUT&RUN. Portanto, o pipeline de análise CUT & RUN inclui etapas de análise do diagrama de Venn para dar aos usuários a chance de comparar a semelhança e a diferença dos resultados de chamadas de pico entre várias opções de chamadas de pico (opções de Script_17_intervene) e programas de chamadas de pico (Script_19_intervene_methods.sh) (Figura 6A-H).

De acordo com a comparação, os picos CTCF, H3K27ac e RNAPII-S5P mesclados que são chamados com e sem opção de controle de IgG durante a etapa de chamada de pico, MACS2 e MACS3 chamaram mais picos com opção de controle de IgG (Figura 6A), mas o SEACR chamou mais picos sem opção de controle de IgG em opções rigorosas e relaxadas (Figura 6B-D). Portanto, o pipeline de análise CUT&RUN sugere (1) aplicar a opção de controle de IgG para MACS2 e MACS3, (2) chamar picos para amostras experimentais de CUT&RUN e amostras de controle de IgG separadamente e, em seguida, filtrar os picos de IgG posteriormente para o chamador de pico SEACR. Entre MACS2 e MACS3, MACS3 chamou um pouco mais de picos (Figura 6A).

Além disso, a comparação dos picos chamados por MACS2 e MACS3 com a opção de controle IgG e SEACR sem opção de controle IgG mostra que os picos SEACR chamados com a opção rigorosa se sobrepõem aos picos MACS 2 e MACS3 mais do que os picos SEACR chamados com a opção relaxada (Figura 6E, F). Assim, as saídas do pipeline de análise CUT&RUN sugerem que a opção rigorosa maximiza a consistência do SEACR com a chamada de pico do MACS. Finalmente, o diagrama de Venn para comparar a sobreposição de picos chamados pelo SEACR com a normalização para arquivos bedGraph CUT&RUN de readcounts brutos e sem normalização para arquivos bedGraph CUT&RUN de readcounts normalizados não revela nenhuma diferença entre os métodos SFRC e SRPMC para SEACR com a opção strict. Os picos de SFRC exibem números de pico muito mais altos e melhor sobreposição com picos de opções normalizadas ('norma' na Figura 6) do que os picos de SRPMC para SEACR com opções relaxadas (Figura 6G, H).

Comparações estatísticas entre réplicas e amostras
Tirar conclusões precisas em várias réplicas requer uma avaliação da similaridade da replicação. O pipeline de análise CUT&RUN usado aqui emprega o cálculo do coeficiente de correlação estatística baseado no Deeptools2¹⁵, agrupamento de mapa de calor e análise de componentes principais (PCA) para facilitar a identificação de amostras e réplicas apropriadas para análise downstream válida. O agrupamento de mapas de calor baseado no coeficiente de correlação de Pearson mostrou correlação estatisticamente significativa entre as réplicas para CTCF, H3K27Ac e RNAPII-S5P em suas regiões de pico chamadas (Figura 7A-C). No entanto, o PCA mostrou que uma amostra de CTCF (SRR8581590) e H3K27Ac (SRR8581608) está localizada relativamente distante de outras repetições (Figura 7D) em todas as regiões de pico CTCF, H3K27Ac e RNAPII-S5P.

De acordo com o diagrama de Venn para comparar entre os picos entre as réplicas, os picos CTCF (SRR8581590) mostraram menos sobreposição com outras réplicas em todos os três resultados de chamada de pico (Figura 7E-G), e os picos de H3K27Ac (SRR8581608) mostraram menor sobreposição com outras réplicas nos resultados de chamada de pico SEACR (Figura 7F). os picos de H3K27Ac (SRR8581608) não exibiram sobreposição mínima com outras réplicas nos resultados de chamada de pico MACS2 e MACS3 (Figura 7F), o que pode sugerir que a distância entre as réplicas em PCA não é suficiente para definir a amostra discrepante. Portanto, o pipeline de análise CUT & RUN propõe definir a replicação discrepante como "a amostra que mostra baixo coeficiente de correlação de Pearson no grupo de agrupamento de mapa de calor, longa distância no gráfico PCA com outras réplicas e menor sobreposição de pico entre as réplicas".

A chamada de pico facilita a visualização e interpretação dos dados do CUT&RUN
O pipeline de análise CUT&RUN detalhado neste estudo emprega dois tipos de chamadores de pico disponíveis publicamente: família MACS e SEACR. Para otimizar a visualização dos picos chamados, este pipeline seleciona o compartimento de sinal mais alto como o centro de pico para análises de mapa de calor e metaplot. Todos os picos CTCF, H3K27Ac e RNAPII-S5P chamados pelos chamadores de pico MACS3 e SEACR mostraram um padrão de distribuição de pico mais nítido no centro dos compartimentos de sinal mais altos (Figura 8A-F, gráficos 'focados') do que no centro de regiões de pico inteiras (Figura 8A-F, gráficos 'inteiros'). As amostras CUT&RUN processadas pelo pipeline de análise Easy Shells CUTnRUN com normalização SFRC (Figura 8 AF, gráficos 'SFRC') exibem padrões de distribuição de sinal semelhantes aos das amostras normalizadas SFRC das quais os pares de leitura mapeados brutos estão disponíveis publicamente no GEO (Figura 8A-F, gráficos 'públicos') nos picos chamados pelo pipeline de análise. Assim, o pipeline de análise CUT&RUN pode reproduzir os resultados da publicação com sucesso.

Figura 1: Esquema do procedimento experimental CUT&RUN. CUT&RUN é uma abordagem baseada em enzimas para detectar interações proteína-DNA em todo o genoma. O procedimento CUT&RUN começa com a ligação de células (ou núcleos isolados) à Concanavalina A conjugada a esferas magnéticas para permitir o isolamento e a manipulação de números baixos de células durante todo o procedimento. As células isoladas são permeabilizadas usando um detergente neutro para facilitar a introdução de um anticorpo que tem como alvo a proteína de interesse. A nuclease microcócica (MNase) ligada à proteína A ou à etiqueta da proteína A / G é então introduzida na célula permeabilizada. A pA-MNase (ou pAG-MNase) é recrutada para o anticorpo ligado usando uma etiqueta de Proteína A ou Proteína A/G. Uma vez que a MNase está localizada nos locais-alvo, a nuclease é brevemente ativada através da introdução de cálcio para digerir o DNA ao redor da proteína-alvo. A digestão da MNase resulta em complexos mononucleossômicos de DNA-proteína. O cálcio é subsequentemente quelatado para encerrar a reação de digestão, e fragmentos curtos de DNA da digestão da MNase são liberados dos núcleos por uma incubação curta a 37 ° C e, em seguida, submetidos à purificação do DNA, preparação da biblioteca e sequenciamento de alto rendimento¹. Clique aqui para ver uma versão maior desta figura.

Figura 2: Resumo esquemático do pipeline de análise Easy-Shell CUT&RUN. O pipeline de análise Easy-Shell CUT&RUN é projetado em três seções principais - (1) controle de qualidade e mapeamento de arquivos de leitura bruta (esquerda; roxo), (2) normalização de leituras mapeadas e readcounts e chamadas de pico (centro; verde) e (3) validação de leituras mapeadas e picos chamados (direita; rosa). Em cada etapa, o número do script de shell correspondente, uma breve descrição e a ferramenta de programa usada nessa etapa (entre parênteses) são fornecidos. As setas simples mostram fluxos diretos entre as etapas. Este pipeline de análise CUT&RUN fornece dois métodos de normalização de leitura que podem atender às necessidades dos usuários com e sem leituras de controle, processos de validação multicamadas para identificar réplicas adequadas para análise downstream e identificação de pico focada para criação de saída de mapa de calor e metaplot bem focada. Este pipeline de análise é escrito em scripts de shell fáceis de usar de maneira passo a passo para fornecer aos iniciantes em bioinformática a oportunidade de aprender e praticar a análise básica de dados CUT & RUN lendo e editando os próprios scripts. Clique aqui para ver uma versão maior desta figura.

Figura 3: Comparação dos resultados da verificação de qualidade pré versus pós-corte de qualidade. As saídas do relatório de verificação de qualidade selecionadas do FastQC exibem o efeito do corte de qualidade usando leituras do SRR8581589 (GSM3609748, CTCF). Os resultados mostrados incluem: (A) Índice de qualidade nas bases de pré-corte. (B) Mesma leitura que A) pós-corte. (C) Distribuição do índice de qualidade em todas as sequências pré-corte. (D) Mesma leitura que C) pós-corte. (E) Distribuição de GC em todas as sequências pré-corte. (F) Mesma leitura que E) pós-corte. A pontuação de qualidade mínima em cada posição dentro das leituras de sequenciamento (A, B) e a qualidade média mínima da sequência (C, D) são aumentadas após o corte de qualidade. Além disso, esta etapa pode reduzir a diferença entre a distribuição teórica de contagens de GC e a contagem real de GC por base nas leituras (E, F), removendo pares de leituras que têm alta taxa de incompatibilidade de base. Clique aqui para ver uma versão maior desta figura.

Figura 4: Análise da distribuição do tamanho da pastilha. Insira o histograma de tamanho para (A) CTCF, (B) H3K27AC e (C) serina 5 RNA polimerase fosforilada II (RNAPII-S5P). Os histogramas exibem diferenças relativas na distribuição do tamanho da pastilha entre as amostras. A linha tracejada no histograma representa a fração cumulativa de leituras com um tamanho de inserção maior ou igual ao valor no eixo x. n: número de leituras únicas mapeadas de acordo por amostra após a filtração. FR: fragmentos. Clique aqui para ver uma versão maior desta figura.

Figura 5: Visão geral da paisagem das amostras CUT&RUN. Leituras mapeadas CUT&RUN disponíveis publicamente normalizadas pela contagem fracionária escalonada (SFRC) sem filtragem adicional (trilhas pretas), as amostras CUT&RUN processadas pelo pipeline de análise Easy Shells CUTnRUN com normalização SFRC (trilhas vermelhas) e 'Leituras normalizadas por milhão de leituras mapeadas no controle negativo (SRPMC; trilhas verdes)' são mostradas em (A) região de cluster de genes de histonas, e (B-D) outras três regiões com picos CTCF, H3K27Ac e RNAPII-S5P chamados por todos os chamadores de pico MACS2, MACS3 e SEACR. As caixas amarelas destacam a localização dos sinais de pico filtrados durante a etapa de filtragem no pipeline de análise Easy Shells CUTnRUN. Clique aqui para ver uma versão maior desta figura.

Figura 6: Diagrama de Venn para comparar entre picos chamados por diferentes chamadores de pico e opções de chamada de pico. (A) Comparação entre picos chamados por MACS2 e MACS3 com e sem opção de entrada IgG durante a chamada de pico. (BD) Comparação entre picos chamados pelo SEACR com e sem opção de entrada IgG, opções 'stringent' e 'relaxed', e com opção de normalização usando arquivos de pares de leitura brutos (B), sem opção de normalização usando arquivos de readcounts normalizados SFRC (C) ou arquivos de readcounts normalizados SRPMC (D). (E, F) Comparação entre picos chamados por MACS2, MACS3 com opção de entrada IgG e SEACR com opção rigorosa (E) ou relaxada (F). (G, H) Comparação entre picos chamados pelo SEACR sem opção de entrada de IgG e com opções rigorosas (G) ou relaxadas (H). c/ IgG: picos chamados com opção de entrada IgG. sem IgG: picos chamados sem opção de entrada IgG. norma: picos chamados com a opção de normalização. non: picos chamados sem opção de normalização. SFRC: picos chamados por arquivos readcounts normalizados pelo método 'contagem fracionária em escala (SFRC)'. SRPMC: picos chamados por arquivos readcounts normalizados pelo 'Spike-in normalized Reads Per Million mapeado Clique aqui para ver uma versão maior desta figura.

Figura 7: Correlação de Pearson, análise de componentes principais e diagrama de Venn para validar a similaridade entre as replicações. (A-C) O agrupamento de mapas de calor com valores de coeficiente de correlação de Pearson exibe o grau de similaridade entre as repetições nos picos denominados por MACS2 (A), MACS3 (B) e SEACR (C). O coeficiente de correlação de Pearson está em um valor entre -1 e 1. Um valor absoluto maior do coeficiente de correlação de Pearson indica uma correlação mais forte entre duas variáveis, e um valor positivo do coeficiente de correlação de Pearson indica uma correlação positiva, onde as duas variáveis se movem na mesma direção. Portanto, amostras com maior similaridade exibem pedigree mais próximo no agrupamento de mapas de calor e maior valor de coeficiente de Pearson. (D) A análise de componentes principais (PCA) exibe o grau de similaridade entre réplicas e amostras em todas as regiões de pico CTCF, H3K27Ac e RNAPII-S5P que são chamadas por MACS2 (esquerda), MACS3 (centro) e SEACR (direita). Amostras com maior similaridade são posicionadas mais próximas umas das outras no gráfico PCA. (E-G) Análise do diagrama de Venn para comparar os picos encontrados em cada repetição por MACS2 (E), MACS3 (F) e SEACR (G). O pipeline de análise Easy-Shell CUT&RUN propôs aplicar todos os três métodos para identificar réplicas com alta similaridade que podem ser adequadas para mesclar os picos chamados para análise a jusante. Clique aqui para ver uma versão maior desta figura.

Figura 8: Mapa de calor e visualização de metaplot da distribuição do sinal nos picos. O mapa de calor e os metagráficos exibem a distribuição do enriquecimento em torno dos centros de pico chamados usando diferentes chamadores de pico. (A, B) Picos CTCF CUT&RUN chamados a partir de uma réplica (SRR8581589) por MACS3 (A) e SEACR (B). (C, D) H3K27Ac CUT&RUN picos chamados de uma réplica (SRR8581607) usando MACS3 (C) e SEACR (D). (E, F) Picos RNAPII CUT&RUN chamados de uma réplica (SRR8581589) por MACS3 (E) e SEACR (F). Os pares de leitura mapeados disponíveis publicamente ('Público' na Figura 8) e os fragmentos mapeados pelo pipeline de análise Easy Shells CUTnRUN ('SFRC' na Figura 8) são comparados após a normalização da 'contagem fracionária em escala (SFRC)'. Os picos são chamados por MACS3 com opção de entrada IgG ('MACS3 com IgG' na Figura 8) e SEACR sem entrada IgG e sem opção de normalização usando arquivos de contagem de leitura normalizados SFRC em modo rigoroso ('SEACR sem IgG não SFRC rigoroso' na Figura 8). Duas versões de arquivos de coordenadas dos picos chamados são preparadas: do início ao fim dos picos chamados ('todo' na Figura 8) e a localização do compartimento com sinal mais alto dentro dos picos chamados (cumes em MACS3 chamados picos; 'focado' na Figura 8). Clique aqui para ver uma versão maior desta figura.

Tabela 1: Informações para arquivos CUT&RUN fastq em GSE126612. Todos os arquivos fastq CUT&RUN de leituras brutas que estão incluídos no GSE126612 e são selecionados como conjunto de dados de exemplo para o pipeline de análise CUTnRUN do Easy Shells são listados como uma tabela. A coluna 'Nome do arquivo' mostra os nomes dos arquivos CUT&RUN brutos que serão mostrados em '~/Desktop/GSE126612/fastq' após a execução do 'Script_02_download-fastq.sh'. 'md5sum' compartilha MD5 (Message-Digest Algorithm 5) para o conjunto de dados de exemplo que pode ser usado para verificar a integridade dos arquivos após o download do conjunto de dados por meio da execução de 'Script_02_download-fastq.sh'. A última coluna descreve o destino de CUT&RUN para cada amostra. Clique aqui para baixar esta tabela.

Discussão

A capacidade de mapear a ocupação de proteínas na cromatina é fundamental para a realização de estudos mecanísticos no campo da biologia da cromatina. À medida que os laboratórios adotam novas técnicas de laboratório úmido para traçar o perfil da cromatina, a capacidade de analisar dados de sequenciamento desses experimentos de laboratório úmido torna-se um gargalo comum para cientistas de laboratório úmido. Portanto, descrevemos um protocolo introdutório passo a passo para permitir que os iniciantes em bioinformática superem o gargalo da análise e iniciem a análise e as verificações de controle de qualidade de seus próprios dados de sequenciamento CUT & RUN.

Este protocolo de análise CUT&RUN descreve a aplicação de várias etapas para garantir que os sinais de boa-fé sejam quantificados. A remoção de leituras de baixa qualidade e sequências de adaptadores de dados brutos de leitura é uma das primeiras etapas de controle de qualidade e uma das etapas mais críticas para obter resultados de análise precisos. Portanto, esse pipeline de análise inclui etapas de corte de qualidade e adaptador fáceis de aplicar usando o programa Trim-galore²⁷. Devido à importância desse processo, esse pipeline de análise inclui etapas para comparar a qualidade dos resultados antes (etapa 4.3) e depois (etapa 5.3) do processo de corte (etapa 5.5). Além da qualidade e do corte do adaptador, esse pipeline de análise também remove leituras cromossômicas não canônicas, regiões de repetição de TA e regiões de lista negra, que podem introduzir viés de conteúdo de GC e picos/picos chamados de falsos positivos. Essas etapas de filtragem fornecem um pipeline introdutório apropriado para iniciantes em bioinformática entenderem as etapas críticas de controle de qualidade para análise de dados CUT&RUN.

Após a etapa de filtragem, este pipeline de análise CUT&RUN fornece duas opções de normalização: 'contagem de leitura fracionária dimensionada (SFRC)²²' e 'Leituras normalizadas por milhão de leituras mapeadas no controle negativo (SRPMC)^24,25 para criar arquivos de entrada para chamada e visualização de pico downstream. Se se espera que o conjunto de dados CUT&RUN revele diferenças locais apenas sem diferenças de sinal em todo o genoma entre as amostras, a contagem de leitura fracionária em escala (a fração de contagens vezes o tamanho do gnomo de referência) pode ser suficiente para a análise a jusante. No entanto, se houver a possibilidade de que diferenças de sinal em escala global estejam presentes entre as amostras CUT&RUN, os usuários podem escolher o método SRPMC que considera a proporção de leituras entre o pico e a amostra (amostras experimentais CUT&RUN e de controle negativo) juntamente com a normalização de leituras por milhão (RPM) para leituras de controle negativo para tornar as leituras de controle negativo comparáveis entre diferentes amostras. Como o SRPMC fornece leituras normalizadas em relação às leituras de controle negativo normalizadas, essa abordagem minimiza o sinal de controle negativo e permite a comparação entre conjuntos de dados criados em diferentes lotes e grupos.

Um fator importante na chamada de pico de amostra CUT&RUN é eliminar picos falsos positivos de CUT&RUN durante a análise in silico , em parte, por meio da inclusão de amostras de IgG. Especificamente, esse pipeline de análise fornece abordagens de chamada de pico para diferentes chamadores de pico para descartar picos chamados de CUT&RUN falsos positivos. Para chamadores de pico MACS2/3, nosso pipeline de análise aplica leituras simuladas de IgG como amostra de entrada durante o pico de chamadas. Para o SEACR, este pipeline de análise recomenda chamar os picos para amostras experimentais e amostras de controle negativo de forma independente primeiro e, em seguida, remover os picos que se sobrepõem entre amostras experimentais e amostras de controle negativo, uma vez que o SEACR pode "perder" a maioria dos picos se fornecido com o controle negativo durante a chamada de pico das amostras experimentais. Os picos selecionados exibem semelhança comparável entre diferentes chamadores de pico e replicados (Figura 5). Ao todo, a remoção de cromossomos não canônicos de baixa qualidade, região de lista negra e leituras de repetições de TA, corte de sequências de adaptadores, normalização de DNA de pico e tratamento adequado de controle negativo durante as etapas de chamada de pico fornecem aos usuários arquivos readcounts adequados para análises downstream. Com arquivos de leitura normalizados de alta qualidade e picos chamados com curadoria, os usuários podem comparar a semelhança entre as réplicas e criar mapas de calor e metaplots com sinal de fundo ultralimpo para validar a chamada de pico efetiva.

A chamada de pico com leituras de alta qualidade marca o início da elaboração de interpretações biológicas a partir dos dados do CUT&RUN. Este protocolo descreve a obtenção de sinais de pico focados em mapas de calor e metaplots, apontando o sinal mais alto ou os locais de sinal mais estatisticamente significativos como centros de pico. Algumas abordagens de pico de chamada não selecionam os sinais mais altos ou os sinais estatisticamente mais significativos em sua localização central. Portanto, redefinir o centro de cada pico como o sinal mais alto ou a localização do sinal mais estatisticamente significativo serve como uma etapa importante para criar saídas de dados visuais com sinais bem focados no centro dos gráficos. Os arquivos de leito dos picos chamados originais são retidos para realizar a anotação de pico e a análise de relevância funcional como próximas etapas após a conclusão das etapas descritas neste protocolo.

Embora este pipeline de análise CUT&RUN inclua etapas para descrever a instalação dos programas necessários, os iniciantes em bioinformática podem encontrar dificuldades na instalação das ferramentas de análise. Portanto, uma página de problemas associada do Github foi estabelecida para fornecer descrições passo a passo mais detalhadas para a instalação do programa e para facilitar as comunicações para dar suporte aos usuários durante a instalação do programa em seu próprio sistema. As próximas etapas no pipeline de análise CUT&RUN além do protocolo descrito neste artigo incluem anotação de pico, identificação de sobreposições entre diferentes tipos de picos chamados e anotação funcional para picos chamados. A conclusão das etapas de controle de qualidade e a chamada de pico descritas neste protocolo, combinadas com a anotação de pico downstream, permitirão que os usuários extraiam significado biológico de seus dados CUT & RUN.

Este pipeline de análise CUT&RUN foi criado para fornecer diretrizes passo a passo introdutórias gerais para a análise CUT&RUN em massa. Este pipeline possui algumas limitações. Primeiro, embora este pipeline de análise esteja tentando lidar com o efeito impulsionado pela variação do conteúdo de GC, filtrando leituras em regiões de lista negra (que incluem "regiões de artefato de alto sinal" e "regiões de repetição de artefato" e regiões de repetição de TA), essa abordagem pode não ser suficiente para alguns organismos que podem ter conteúdo de GC distinto em seu genoma. Portanto, se os usuários estiverem preocupados com qualquer viés orientado por conteúdo do GC, considere adicionar outra etapa para corrigir leituras mapeadas. Para iniciantes em bioinformática, 'computeGCBias' e 'correctGCBias' no Deeptools podem ser opções para esse objetivo. Em segundo lugar, este pipeline de análise está lidando com leituras de tamanho de inserção regular (100 bp-1 kb) e leituras de tamanho de inserção pequeno (< 100 bp), que podem ser as leituras reais de algumas proteínas associadas à cromatina, dentro do mesmo arquivo. Como esse pipeline de análise é escrito em scripts de shell, os usuários podem modificar "Script_08_bam-to-BEDPE-BED-bedGraph.sh" para obter as leituras de tamanho de inserção curtas separadamente das leituras regulares de tamanho de fragmento durante a etapa de geração do arquivo de cama de leituras mapeadas. Posteriormente, o arquivo de leito de leituras de tamanho de inserção curto pode ser normalizado independentemente das leituras mapeadas de tamanho de inserção regular para minimizar o efeito de downsizing. Em terceiro lugar, para reduzir a complexidade do pipeline de análise, o Easy Shells CUTnRUN não inclui uma etapa de redução da amostragem para corresponder à profundidade de sequenciamento das amostras CUT&RUN. No entanto, os usuários podem aplicar uma etapa de redução da amostra após filtrar arquivos bam usando samtools view²⁸ ou PositionBasedDownsampleSam (Picard)²⁹.

Todas as etapas de análise neste protocolo são escritas em scripts de shell para permitir que os iniciantes em bioinformática aprendam os fundamentos da análise CUT&RUN revisando os scripts. Esperamos que os usuários possam praticar a análise de bioinformática passo a passo, executando cada script de shell sequencialmente no terminal. Além disso, a simplicidade dos scripts de shell fornecidos neste pipeline de análise CUT&RUN permite que os usuários revisem e personalizem esses scripts para aplicar esse pipeline de análise aos seus próprios dados CUT&RUN. Em última análise, esperamos que este pipeline de análise CUT&RUN possa reduzir gargalos comuns no processo de análise de dados CUT&RUN para capacitar pesquisadores de laboratório úmido e iniciantes em bioinformática a tirar conclusões biológicas de seus próprios dados de sequenciamento CUT&RUN.

Materiais

Lista de materiais utilizados neste artigo

Nome	Empresa	Número de catálogo	Comentários
bedGraphToBigWig	ENCODE	https://hgdownload.soe.ucsc.edu/admin/exe/	Software para compactar e converter readcounts bedGraph para bigWig
	The Quinlan Lab @ U. of Utah	https://bedtools.readthedocs.io/en/latest/index.html	Software para processar arquivos bam/bed/bedGraph
bowtie2 2.5.4	Universidade	Johns Hopkinshttps://bowtie-bio.sourceforge.net/bowtie2/index.shtml	Software para construir índice de gravata borboleta e realizar alinhamento
CollectInsertSizeMetrics (Picard)	Broad institute	https://github.com/broadinstitute/picard	Software para realizar análise de distribuição de tamanho de inserção
Cutadapt	NBIS	https://cutadapt.readthedocs.io/en/stable/index.html	Software para realizar o corte do adaptador
Deeptoolsv3.5.1	Max Planck Institute	https://deeptools.readthedocs.io/en/develop/index.html	Software para realizar análise de correlação de coeficiente de Pearson, análise de componentes principais e análise de mapa de calor/gráfico médio
FastQC Versão 0.12.0	Babraham Bioinformatics	https://github.com/s-andrews/FastQC	Software para verificar a qualidade do arquivo fastq
Interventionv0.6.1	Biologia Computacional & Regulação gênica - Grupo Mathelier	https://intervene.readthedocs.io/en/latest/index.html	Software para realizar análise de diagrama de Venn usando arquivos de pico
MACSv2.2.9.1	Iniciativa de Chan Zuckerberg	https://github.com/macs3-project/MACS/tree/macs_v2	Software para chamar picos
MACSv3.0.2	Iniciativa de Chan Zuckerberg	https://github.com/macs3-project/MACS/tree/master	Software para chamar picos
Samtools-1.21	Wellcome Sanger Institute	https://github.com/samtools/samtools	Software para processar arquivos sam/bam
SEACRv1.3	Howard Hughes Medial institute	https://github.com/FredHutch/SEACR	Software para chamar picos
SRA Toolkit Release 3.1.1			NCBI https://github.com/ncbi/sra-tools Software para baixar SRR do GEO
Trim_Galore v0.6.10	de https://github.com/FelixKrueger/TrimGalore	Bioinformática Babraham	para realizar corte de qualidade e atapter