LBMC » NucleoMiner

NucleoMiner2. You can do this by typing the following command in a

These packages can be installed by typing the following command in an

R console:

   install.packages(c("fork", "rjson", "seqinr", "plotrix"))

   source("http://bioconductor.org/biocLite.R")

   biocLite("DESeq")

Finally,by typing the git command above, you downloaded specific R

packages provided with NucleoMiner2 that you now need to install:

To do so, type the following command in your terminal:

This tutorial describes steps allowing to perform quantitative

reads. The second part covers the R scripts that extracts nucleosome-

level information (nucleosome position and indicators) from the

dataset.

After having installed NucleoMiner2 environment (Previous section), go

In this tutorial, we want to compare nucleosomes of 2 yeast strains:

BY and RM. For each strain Mnase-Seq was performed as well as ChIP-Seq

using an antibody recognizing the H3K14ac epigenetic mark. Illumina

sequencing was done in single-read of 50 bp long.

First, we need to define useful configuration variables that will be

passed to python and R scripts. These variables are contained in file

*configurator.py*. The execution of this python script dumps variables

into the *nucleominer_config.json* file that will then be used by both

R and python scripts.

The initialization of this variables is done in the configurator.py

file. If you need to adapt variable values (path, default

parameters...) you need to edit this file. Then, go to the root

directory of your project and run the following command to dump the

configuration file:

Once variables and design have been specified, the script wf.py will

automatically run all the analysis. You don't need to do anything. To

run the full analysis, run the following command:

   python src/current/wf.py

The details of the steps performed by this script are explained below.

This preprocessing consists of 4 steps embedded in the *wf.py* script.

They are described bellow.  As a preamble, this script computes

*samples*, *samples_mnase* and *strains* that will be used along the 4

steps.

For each strain, the script *wf.py* then creates bowtie index. Bowtie

index of a strain is a tree view of the genome of this strain. It will

be used by bowtie to align reads. The part of the script performing

this is the following:

As an indication, the following table summarizes the file sizes and

process durations that we experienced when running this step on a

Linux server***.

Next, the *wf.py* script launches bowtie to align reads to the

reference genome. It produces a *.sam* file that is converted into a

*.bed* file. Binaries for *bowtie*, *samtools* and *bedtools* are

wrapped using python *subprocess* class. This step is performed by the

following part of the script:

necessary to convert the *.bed* files. TemplateFilter expect reads in

the following format: *chr*, *coord*, *strand* and *#read* where:

the first one on the right hand side.  This is taken into account in

NucleoMiner2 by adding the read length (in our case 50) to the reverse

The following table summarizes the number of reads, the involved file

sizes and process durations that we experienced when running the two

last steps. In our case, alignment process were multithreaded over 3

cores.

nucleosome is defined by its center and its width. An odd width leads

**WARNING** TemplateFilter was not designed to handle replicates. So

(http://http://www.r-project.org). NucleoMiner2 contains a set of R

scripts that will be sourced in R from a console launched at the root

of your project. These scripts are:

The script headers.R is included in all other R scripts. It is in

   * computing and caching Common Uinterrupted Regions (CURs).

     Caching means storing the information in the computer's memory.

various tasks.

   * You may want to analyze data of a single strain (e.g.

     treatment/control, or only few mutations). In this case, the

     genome is identical across all samples and you do not need to

     define particular CURs (CURs are chromosomes). Simply use the

   * If you are analyzing data from two or more strains (as

     NucleoMiner2 was designed for), then you need to translate

     coordinates of one genome into the coordinates of another one.

     You must do this by aligning the two genomes, which will produce

     a .c2c file (see Appendice "Generate .c2c Files").  thenuse it to

     produce the list of regions and customise “translate”.

In our tutorial, we are in the second case and to perform all these

steps run the following command line in your R console:

sensitive nucleosomes. First of all, this script computes intra and

inter-strain matches of nucleosome maps for each CUR. This step can be

executed in parallel on many cores using the BoT library. Next, it

collects results and produces maps of  well-positioned nucleosomes,

sensitive nucleosomes and Unaligned Nucleosomal Regions .

The map of well-positioned nucleosomes for BY is collected in the

result directory and is called *BY_wp.tab*. It is composed of

following columns:

     chi square test obtained from LLR2 (*1-pchisq(2.LLR2, df=4)*)

The sensitive map for BY is collected in the result directory and is

     (in bp)

positions from a strain to another strain and stores it into a table.

well-positioned nucleosomes translated into the BY genome coordinates.

To optimize memory space usage, we split and compress TemplateFilter

If you don't know which column to use for normalization, we recommend

using wpunr.

Here are the details of the factors produced:

   * pvalsGLM, the pvalue resulting from the comparison of the GLM

     model considering the interaction term *marker:strain* to the GLM

     model that does not consider it. This is the statsitcial

     significance of the interaction term and therefore the

     statistical significance of the SNEP.

The *.c2c* files is a simple table that describes how two genome

sequences are aligned. This file can be generated by using scripts

that were developed in NucleoMiner 1.0 (Nagarajan et al. PLoS Genetics

2010) and which we provide in this release of NucleoMiner2.

To use these scripts on your UNIX/LINUX computer you need first to

install MUMmer which is designed to rapidly align entire genomes,

whether in complete or draft form.

Installing MUMmer

-----------------

(MUMmer3.23.tar.gz is provided in the directory deps of your working

tar -xvzf MUMmer3.23.tar.gz

Get the nucleominer-1.0.tar.gz archive on your computer (this archive

is provided in the directory deps of your working directory). Install

it locally into the src folder of you working directory by typing

(working directory):

This creates a directory that contains  NucleoMiner 1.0 scripts

print("nb wp nm2 nuc aligned with dp nuc?")

tmp_nuc_by = by_only_wp[!is.na(by_only_wp$start) ,]

print(length(tmp_nuc_by$diff))

print("...with diff = 0?")

print(sum(tmp_nuc_by$diff==0))

print("...with diff < 1?")

print(sum(tmp_nuc_by$diff<1))

print("...with diff <= 1bp?")

print(sum(tmp_nuc_by$diff<=1))

print("...with diff <= 5bp?")

print(sum(tmp_nuc_by$diff<=5))

print("...with diff <= 30?")

print(sum(tmp_nuc_by$diff<=30))

@

nuc_by = nuc_by[nuc_by$wp_pval !=0,]

nuc_rm = nuc_rm[nuc_rm$wp_pval !=0,]

library(MASS)

Lab.palette <- colorRampPalette(c("white", "orange", "red"), space = "Lab")

x = nuc_by$fuzziness_score

y = -log10(nuc_by$wp_pval)

smoothScatter(x, y, col=adjustcolor(1, alpha.f=1), pch=".", ylab="BY NM2.0 -log10(wp_pval)", xlab="Danpos2 fuzziness score", nrpoints=0, colramp = Lab.palette)

k = kde2d(x,y, n=50)

contour(k, drawlabels=FALSE, nlevels=10, add=TRUE, zlim=c(0,max(k$z)/4), col=adjustcolor(1, alpha.f=0.3))

x = nuc_by$fuzziness_score

y = nuc_by$diff

smoothScatter(x, y, col=adjustcolor(1, alpha.f=1), pch=".", ylim=range(nuc_by$diff), ylab="diff NM2.0 Danpos2", xlab="Danpos2 fuzziness score", nrpoints=0, colramp = Lab.palette)

k = kde2d(x,y, n=50)

contour(k, drawlabels=FALSE, nlevels=10, add=TRUE, zlim=c(0,max(k$z)/4), col=adjustcolor(1, alpha.f=0.3))

x = nuc_rm$fuzziness_score

y = -log10(nuc_rm$wp_pval)

smoothScatter(x, y, col=adjustcolor(1, alpha.f=1), pch=".", ylab="RM NM2.0 -log10(wp_pval)", xlab="Danpos2 fuzziness score", nrpoints=0, colramp = Lab.palette)

k = kde2d(x,y, n=50)

contour(k, drawlabels=FALSE, nlevels=10, add=TRUE, zlim=c(0,max(k$z)/4), col=adjustcolor(1, alpha.f=0.3))

x = nuc_rm$fuzziness_score

y = nuc_rm$diff

smoothScatter(x, y, col=adjustcolor(1, alpha.f=1), pch=".", ylim=range(nuc_rm$diff), ylab="diff NM2.0 Danpos2", xlab="Danpos2 fuzziness score", nrpoints=0, colramp = Lab.palette)

k = kde2d(x,y, n=50)

contour(k, drawlabels=FALSE, nlevels=10, add=TRUE, zlim=c(0,max(k$z)/4), col=adjustcolor(1, alpha.f=0.3))

<<echo=FALSE, results=hide, fig=TRUE, height=3, width=5, eval=TRUE >>=

hist(nuc_by$diff, breaks=-1:50)

@

<< nm_vs_dp_nucs, results=hide, fig=TRUE, height=3, width=16, echo=FALSE, eval=TRUE >>= 

	draw.ellipse(0.5*(l$upper_bound + l$lower_bound), 0.5, 0.5*(l$upper_bound - l$lower_bound), 0.4, lwd=3)

	draw.ellipse(0.5*(l$start + l$end), 1.5, 0.5*(l$start - l$end), 0.4, lwd=3)

  # abline(h=c(0.5, 1.5))

version = '2.3.52'

release = '2.3.52'

The first installation step is to retrieve the source code of NucleoMiner2. You can do this by typing the following command in a terminal.

These packages can be installed by typing the following command in an R console:

Finally,by typing the git command above, you downloaded specific R packages provided with NucleoMiner2 that you now need to install:

 - cachecache https://forge.cbp.ens-lyon.fr/redmine/projects/cachecache

 - bot https://forge.cbp.ens-lyon.fr/redmine/projects/bot

 - nucleominer https://forge.cbp.ens-lyon.fr/redmine/projects/nucleominer

To do so, type the following command in your terminal:     

| Version:      | 2.3.52                                            |

This tutorial describes steps allowing to perform quantitative analysis of epigenetic marks on individual nucleosomes. We assume that files are organised according to a given hierarchy and that all command lines are launched from the project’s root directory.

This tutorial is divided into two main parts. The first part covers the python script `wf.py` that aligns and converts short sequence reads. The second part covers the R scripts that extracts nucleosome-level information (nucleosome position and indicators) from the dataset.

After having installed NucleoMiner2 environment (Previous section), go to the root working directory of the tutorial by typing the following command in a terminal:

In this tutorial, we want to compare nucleosomes of 2 yeast strains: BY and RM. For each strain Mnase-Seq was performed as well as ChIP-Seq using an antibody recognizing the H3K14ac epigenetic mark. Illumina sequencing was done in single-read of 50 bp long.

First, we need to define useful configuration variables that will be passed to python and R scripts. These variables are contained in file `configurator.py`. The execution of this python script dumps variables into the `nucleominer_config.json` file that will then be used by both R and python scripts.

The initialization of this variables is done in the configurator.py file. If you need to adapt variable values (path, default parameters...) you need to edit this file. Then, go to the root directory of your project and run the following command to dump the configuration file:

Once variables and design have been specified, the script wf.py will automatically run all the analysis. You don't need to do anything. 

To run the full analysis, run the following command:

.. code:: bash

  python src/current/wf.py

The details of the steps performed by this script are explained below.

This preprocessing consists of 4 steps embedded in the `wf.py` script. They are described bellow.  As a preamble, this script computes `samples`, `samples_mnase` and `strains` that will be used along the 4 steps.

For each strain, the script *wf.py* then creates bowtie index. Bowtie index of a strain is a tree view of the genome of this strain. It will be used by bowtie to align reads. The part of the script performing this is the following:

As an indication, the following table summarizes the file sizes and process durations that we experienced when running this step on a Linux server***.

Next, the *wf.py* script launches bowtie to align reads to the reference genome. It produces a `.sam` file that is converted into a `.bed` file. Binaries for `bowtie`, `samtools` and `bedtools` are wrapped using python `subprocess` class. This step is performed by the following part of the script:

TemplateFilter uses particular input formats for reads, so it is necessary to convert the `.bed` files. TemplateFilter expect reads in the following format: `chr`, `coord`, `strand` and `#read` where:

**WARNING** for reverse strands, bowtie returns the position of the first nucleotide on the left hand side, whereas TemplateFilter expects the first one on the right hand side.  This is taken into account in NucleoMiner2 by adding the read length (in our case 50) to the reverse reads coordinates.

This step is performed by the following part of the *wf.py* script:

The following table summarizes the number of reads, the involved file sizes and process durations that we experienced when running the two last steps. In our case, alignment process were multithreaded over 3 cores.

defined by its center and its width. An odd width leads us to consider non-

**WARNING** TemplateFilter was not designed to handle replicates. So we recommend to keep a maximum of nucleosomes and filter the aberrant ones afterwards using the benefits of having replicates. To do this, we set a low correlation threshold parameter (0.5) and a particularly high value of overlap (300%).

The second part of the tutorial uses R (http://http://www.r-project.org). NucleoMiner2 contains a set of R scripts that will be sourced in R from a console launched at the root of your project. These scripts are:

The script headers.R is included in all other R scripts. It is in charge of: 

  - computing and caching Common Uinterrupted Regions (CURs). Caching means storing the information in the computer's memory.

Note that you can customize the function “translate”. This function allows you to use the alignments between genomes when performing various tasks. 

  -  You may want to analyze data of a single strain (e.g. treatment/control, or only few mutations). In this case, the genome is identical across all samples and you do not need to define particular CURs (CURs are chromosomes). Simply use the default translate function which is neutral.

  - If you are analyzing data from two or more strains (as NucleoMiner2 was designed for), then you need to translate coordinates of one genome into the coordinates of another one. You must do this by aligning the two genomes, which will produce a .c2c file (see Appendice "Generate .c2c Files").  thenuse it to produce the list of regions and customise “translate”.

In our tutorial, we are in the second case and to perform all these steps run the following command line in your R console:

This script is in charge of extracting Maps for well-positioned and sensitive nucleosomes. First of all, this script computes intra and inter-strain matches of nucleosome maps for each CUR. This step can be executed in parallel on many cores using the BoT library. Next, it collects results and produces maps of  well-positioned nucleosomes, sensitive nucleosomes and Unaligned Nucleosomal Regions .

The map of well-positioned nucleosomes for BY is collected in the result directory and is called `BY_wp.tab`. It is composed of following columns:

 - wp_pval, for a well-positioned nucleosome, it is the p-value chi square test obtained from LLR2 (`1-pchisq(2.LLR2, df=4)`)

The sensitive map for BY is collected in the result directory and is called `BY_fuzzy.tab`. It is composed of following columns:

 - diff, the dyads shift between the positions in the two strains (in bp)

This script is used to translate common well-positioned nucleosome positions from a strain to another strain and stores it into a table. 

For example, the file `results/2014-04/RM_wp_tr_2_BY.tab` contains RM well-positioned nucleosomes translated into the BY genome coordinates. It is composed of following columns:

To optimize memory space usage, we split and compress TemplateFilter input files according to their corresponding  chromosome. for example, `sample_1_TF.tab` will be split into :

If you don't know which column to use for normalization, we recommend using wpunr.

Here are the details of the factors produced:

  - pvalsGLM, the pvalue resulting from the comparison of the GLM model considering the interaction term *marker:strain* to the GLM model that does not consider it. This is the statsitcial significance of the interaction term and therefore the statistical significance of the SNEP.

The `.c2c` files is a simple table that describes how two genome

sequences are aligned. This file can be generated by using scripts that were developed in NucleoMiner 1.0 (Nagarajan et al. PLoS Genetics 2010) and which we provide in this release of NucleoMiner2.

To use these scripts on your UNIX/LINUX computer you need first to install MUMmer which is designed to rapidly align entire genomes, whether in complete or draft form.

Installing MUMmer

^^^^^^^^^^^^^^^^^

Get the last version of MUMmer archive on your computer (MUMmer3.23.tar.gz is provided in the directory deps of your working directory). Copy it in a dedicated directory. Install it locally into the src folder of you working directory by typing (working directory):

tar -xvzf MUMmer3.23.tar.gz

Get the nucleominer-1.0.tar.gz archive on your computer (this archive is provided in the directory deps of your working directory). Install it locally into the src folder of you working directory by typing (working directory):

This creates a directory that contains  NucleoMiner 1.0 scripts (src/nucleominer-1.0/scripts). 

Version: 2.3.52