miga-base 0.4.3.0 → 0.5.0.0

data/utils/enveomics/enveomics.R/R/recplot2.R

@@ -1,497 +1,647 @@
 #==============> Define S4 classes
-setClass("enve.RecPlot2",
-   ### Enve-omics representation of Recruitment plots. This object can
-   ### be produced by `enve.recplot2` and supports S4 method plot.
-   representation(
-   counts='matrix',		##<< Counts as a two-dimensional histogram.
-   pos.counts.in='numeric',	##<< Counts of in-group hits per position bin.
-   pos.counts.out='numeric',	##<< Counts of out-group hits per position bin.
-   id.counts='numeric',		##<< Counts per ID bin.
-   id.breaks='numeric',		##<< Breaks of identity bins.
-   pos.breaks='numeric',	##<< Breaks of position bins.
-   pos.names='character',       ##<< Names of the position bins.
-   seq.breaks='numeric',	##<< Breaks of input sequences.
-   peaks='list',                ##<< Peaks identified in the recplot.
-   ### Limits of the subject sequences after concatenation.
-   seq.names='character',	##<< Names of the subject sequences.
-   id.metric='character',	##<< Metric used as 'identity'.
-   id.ingroup='logical',	##<< Identity bins considered in-group.
-   call='call')			##<< Call producing this object.
-   ,package='enveomics.R'
-   );
-setClass("enve.RecPlot2.Peak",
-### Enve-omics representation of a peak in the sequencing depth histogram
-### of a Recruitment plot (see `enve.recplot2.findPeaks`).
-   representation(
-   dist='character',
-   ### Distribution of the peak. Currently supported: 'norm' (normal) and 'sn'
-   ### (skew-normal).
-   values='numeric',
-   ### Sequencing depth values predicted to conform the peak.
-   values.res='numeric',
-   ### Sequencing depth values not explained by this or previously identified
-   ### peaks.
-   mode='numeric',
-   ### Seed-value of mode anchoring the peak.
-   param.hat='list',
-   ### Parameters of the distribution. A list of two values if dist='norm' (sd
-   ### and mean), or three values if dist='sn' (omega=scale, alpha=shape, and
-   ### xi=location). Note that the "dispersion" parameter is always first and
-   ### the "location" parameter is always last.
-   n.hat='numeric',
-   ### Number of bins estimated to be explained by this peak. This should
-   ### ideally be equal to the length of `values`, but it's not and integer.
-   n.total='numeric',
-   ### Total number of bins from which the peak was extracted. I.e., total
-   ### number of position bins with non-zero sequencing depth in the recruitment
-   ### plot (regardless of peak count).
-   err.res='numeric',
-   ### Error left after adding the peak (mower) or log-likelihood (em or emauto).
-   merge.logdist='numeric',
-   ### Attempted `merge.logdist` parameter.
-   seq.depth='numeric',
-   ### Best estimate available for the sequencing depth of the peak (centrality).
-   log='logical'
-   ### Indicates if the estimation was performed in natural logarithm space
-   ));
+
+#' Enveomics: Recruitment Plot (2) - S4 Class
+#'
+#' Enve-omics representation of Recruitment plots. This object can
+#' be produced by \code{\link{enve.recplot2}} and supports S4 method plot.
+#'
+#' @slot counts \code{(matrix)} Counts as a two-dimensional histogram.
+#' @slot pos.counts.in \code{(numeric)} Counts of in-group hits per position bin.
+#' @slot pos.counts.out \code{(numeric)} Counts of out-group hits per position bin.
+#' @slot id.counts \code{(numeric)} Counts per ID bin.
+#' @slot id.breaks \code{(numeric)} Breaks of identity bins.
+#' @slot pos.breaks \code{(numeric)} Breaks of position bins.
+#' @slot pos.names \code{(character)} Names of the position bins.
+#' @slot seq.breaks \code{(numeric)} Breaks of input sequences.
+#' @slot peaks \code{(list)} Peaks identified in the recplot.
+#' Limits of the subject sequences after concatenation.
+#' @slot seq.names \code{(character}) Names of the subject sequences.
+#' @slot id.metric \code{(character}) Metric used as 'identity'.
+#' @slot id.ingroup \code{(logical}) Identity bins considered in-group.
+#' @slot call \code{(call)} Call producing this object.
+#'
+#' @author Luis M. Rodriguez-R [aut, cre]
+#'
+#' @exportClass
+
+enve.RecPlot2 <- setClass("enve.RecPlot2",
+                          representation(
+                            # slots = list(
+                            counts='matrix',
+                            pos.counts.in='numeric',
+                            pos.counts.out='numeric',
+                            id.counts='numeric',
+                            id.breaks='numeric',
+                            pos.breaks='numeric',
+                            pos.names='character',
+                            seq.breaks='numeric',
+                            peaks='list',
+                            seq.names='character',
+                            id.metric='character',
+                            id.ingroup='logical',
+                            call='call')
+                          ,package='enveomics.R'
+);
+
+#' Enveomics: Recruitment Plot (2) Peak - S4 Class
+#'
+#' Enve-omics representation of a peak in the sequencing depth histogram
+#' of a Recruitment plot (see \code{\link{enve.recplot2.findPeaks}}).
+#'
+#' @slot dist \code{(character)}
+#' Distribution of the peak. Currently supported: \code{norm} (normal) and \code{sn}
+#' (skew-normal).
+#' @slot values \code{(numeric)}
+#' Sequencing depth values predicted to conform the peak.
+#' @slot values.res \code{(numeric)}
+#' Sequencing depth values not explained by this or previously identified
+#' peaks.
+#' @slot mode \code{(numeric)}
+#' Seed-value of mode anchoring the peak.
+#' @slot param.hat \code{(list)}
+#' Parameters of the distribution. A list of two values if dist=\code{norm} (sd
+#' and mean), or three values if dist=\code{sn}(omega=scale, alpha=shape, and
+#' xi=location). Note that the "dispersion" parameter is always first and
+#' the "location" parameter is always last.
+#' @slot n.hat \code{(numeric)}
+#' Number of bins estimated to be explained by this peak. This should
+#' ideally be equal to the length of  \code{values}, but it's not an integer.
+#' @slot n.total \code{(numeric)}
+#' Total number of bins from which the peak was extracted. I.e., total
+#' number of position bins with non-zero sequencing depth in the recruitment
+#' plot (regardless of peak count).
+#' @slot err.res \code{(numeric)}
+#' Error left after adding the peak (mower) or log-likelihood (em or emauto).
+#' @slot merge.logdist \code{(numeric)}
+#' Attempted \code{merge.logdist} parameter.
+#' @slot seq.depth \code{(numeric)}
+#' Best estimate available for the sequencing depth of the peak (centrality).
+#' @slot log \code{(logical)}
+#' Indicates if the estimation was performed in natural logarithm space.
+#'
+#' @author Luis M. Rodriguez-R [aut, cre]
+#'
+#' @exportClass
+
+enve.RecPlot2.Peak <- setClass("enve.RecPlot2.Peak",
+                               representation(
+                                 # slots = list(
+                                 dist='character',
+                                 values='numeric',
+                                 values.res='numeric',
+                                 mode='numeric',
+                                 param.hat='list',
+                                 n.hat='numeric',
+                                 n.total='numeric',
+                                 err.res='numeric',
+                                 merge.logdist='numeric',
+                                 seq.depth='numeric',
+                                 log='logical'
+                               ));
+
+#' Attribute accessor
+#'
+#'
+#' @param x Object
+#' @param name Attribute name
 setMethod("$", "enve.RecPlot2", function(x, name) attr(x, name))
+
+#' Attribute accessor
+#'
+#'
+#' @param x Object
+#' @param name Attribute name
 setMethod("$", "enve.RecPlot2.Peak", function(x, name) attr(x, name))
 
 #==============> Define S4 methods
+
+#' Enveomics: Recruitment Plot (2)
+#'
+#' Plots an \code{\link{enve.RecPlot2}} object.
+#'
+#' @param x
+#' \code{\link{enve.RecPlot2}} object to plot.
+#' @param layout
+#' Matrix indicating the position of the different panels in the layout,
+#' where:
+#' \itemize{
+#'   \item 0: Empty space
+#'   \item 1: Counts matrix
+#'   \item 2: position histogram (sequencing depth)
+#'   \item 3: identity histogram
+#'   \item 4: Populations histogram (histogram of sequencing depths)
+#'   \item 5: Color scale for the counts matrix (vertical)
+#'   \item 6: Color scale of the counts matrix (horizontal)
+#' }
+#' Only panels indicated here will be plotted. To plot only one panel
+#' simply set this to the number of the panel you want to plot.
+#' @param panel.fun
+#' List of functions to be executed after drawing each panel. Use the
+#' indices in \code{layout} (as characters) as keys. Functions for indices
+#' missing in \code{layout} are ignored. For example, to add a vertical line
+#' at the 3Mbp mark in both the position histogram and the counts matrix:
+#' \code{list('1'=function() abline(v=3), '2'=function() abline(v=3))}.
+#' Note that the X-axis in both panels is in Mbp by default. To change
+#' this behavior, set \code{pos.units} accordingly.
+#' @param widths
+#' Relative widths of the columns of \code{layout}.
+#' @param heights
+#' Relative heights of the rows of \code{layout}.
+#' @param palette
+#' Colors to be used to represent the counts matrix, sorted from no hits
+#' to the maximum sequencing depth.
+#' @param underlay.group
+#' If TRUE, it indicates the in-group and out-group areas couloured based
+#' on \code{in.col} and \code{out.col}. Requires support for semi-transparency.
+#' @param peaks.col
+#' If not \code{NA}, it attempts to represent peaks in the population histogram
+#' in the specified color. Set to \code{NA} to avoid peak-finding.
+#' @param use.peaks
+#' A list of \code{\link{enve.RecPlot2.Peak}} objects, as returned by
+#' \code{\link{enve.recplot2.findPeaks}}. If passed, \code{peaks.opts} is ignored.
+#' @param id.lim
+#' Limits of identities to represent.
+#' @param pos.lim
+#' Limits of positions to represent (in bp, regardless of \code{pos.units}).
+#' @param pos.units
+#' Units in which the positions should be represented (powers of 1,000
+#' base pairs).
+#' @param mar
+#' Margins of the panels as a list, with the character representation of
+#' the number of the panel as index (see \code{layout}).
+#' @param pos.splines
+#' Smoothing parameter for the splines in the position histogram. Zero
+#' (0) for no splines. Use \code{NULL} to automatically detect by leave-one-out
+#' cross-validation.
+#' @param id.splines
+#' Smoothing parameter for the splines in the identity histogram. Zero
+#' (0) for no splines. Use \code{NULL} to automatically detect by leave-one-out
+#' cross-validation.
+#' @param in.lwd
+#' Line width for the sequencing depth of in-group matches.
+#' @param out.lwd
+#' Line width for the sequencing depth of out-group matches.
+#' @param id.lwd
+#' Line width for the identity histogram.
+#' @param in.col
+#' Color associated to in-group matches.
+#' @param out.col
+#' Color associated to out-group matches.
+#' @param id.col
+#' Color for the identity histogram.
+#' @param breaks.col
+#' Color of the vertical lines indicating sequence breaks.
+#' @param peaks.opts
+#' Options passed to \code{\link{enve.recplot2.findPeaks}},
+#' if \code{peaks.col} is not \code{NA}.
+#' @param ...
+#' Any other graphic parameters (currently ignored).
+#'
+#' @return
+#' Returns a list of \code{\link{enve.RecPlot2.Peak}} objects (see
+#' \code{\link{enve.recplot2.findPeaks}}). If \code{peaks.col=NA} or
+#' \code{layout} doesn't include 4, returns \code{NA}.
+#'
+#' @author Luis M. Rodriguez-R [aut, cre]
+#'
+#' @method plot enve.RecPlot2
+#' @export
+
 plot.enve.RecPlot2 <- function
-   ### Plots an `enve.RecPlot2` object.
-      (x,
-      ### `enve.RecPlot2` object to plot.
-      layout=matrix(c(5,5,2,1,4,3), nrow=2),
-      ### Matrix indicating the position of the different panels in the layout,
-      ### where:
-      ###   0: Empty space,
-      ###   1: Counts matrix,
-      ###   2: position histogram (sequencing depth),
-      ###   3: identity histogram,
-      ###   4: Populations histogram (histogram of sequencing depths),
-      ###   5: Color scale for the counts matrix (vertical),
-      ###   6: Color scale of the counts matrix (horizontal)
-      ### Only panels indicated here will be plotted. To plot only one panel
-      ### simply set this to the number of the panel you want to plot.
-      panel.fun=list(),
-      ### List of functions to be executed after drawing each panel. Use the
-      ### indices in `layout` (as characters) as keys. Functions for indices
-      ### missing in `layout` are ignored. For example, to add a vertical line
-      ### at the 3Mbp mark in both the position histogram and the counts matrix:
-      ### `list('1'=function() abline(v=3), '2'=function() abline(v=3))`.
-      ### Note that the X-axis in both panels is in Mbp by default. To change
-      ### this behavior, set `pos.units` accordingly.
-      widths=c(1,7,2),
-      ### Relative widths of the columns of `layout`.
-      heights=c(1,2),
-      ### Relative heights of the rows of `layout`.
-      palette=grey((100:0)/100),
-      ### Colors to be used to represent the counts matrix, sorted from no hits
-      ### to the maximum sequencing depth.
-      underlay.group=TRUE,
-      ### If TRUE, it indicates the in-group and out-group areas couloured based
-      ### on `in.col` and `out.col`. Requires support for semi-transparency.
-      peaks.col='darkred',
-      ### If not NA, it attempts to represent peaks in the population histogram
-      ### in the specified color. Set to NA to avoid peak-finding.
-      use.peaks,
-      ### A list of `enve.RecPlot2.Peak` objects, as returned by
-      ### `enve.recplot2.findPeaks`. If passed, `peaks.opts` is ignored.
-      id.lim=range(x$id.breaks),
-      ### Limits of identities to represent.
-      pos.lim=range(x$pos.breaks),
-      ### Limits of positions to represent (in bp, regardless of `pos.units`).
-      pos.units=c('Mbp','Kbp','bp'),
-      ### Units in which the positions should be represented (powers of 1,000
-      ### base pairs).
-      mar=list('1'=c(5,4,1,1)+.1, '2'=c(ifelse(any(layout==1),1,5),4,4,1)+.1,
-	 '3'=c(5,ifelse(any(layout==1),1,4),1,2)+0.1,
-	 '4'=c(ifelse(any(layout==1),1,5),ifelse(any(layout==2),1,4),4,2)+0.1,
-	 '5'=c(5,3,4,1)+0.1, '6'=c(5,4,4,2)+0.1),
-      ### Margins of the panels as a list, with the character representation of
-      ### the number of the panel as index (see `layout`).
-      pos.splines=0,
-      ### Smoothing parameter for the splines in the position histogram. Zero
-      ### (0) for no splines. Use NULL to automatically detect by leave-one-out
-      ### cross-validation.
-      id.splines=1/2,
-      ### Smoothing parameter for the splines in the identity histogram. Zero
-      ### (0) for no splines. Use NULL to automatically detect by leave-one-out
-      ### cross-validation.
-      in.lwd=ifelse(is.null(pos.splines) || pos.splines>0, 1/2, 2),
-      ### Line width for the sequencing depth of in-group matches.
-      out.lwd=ifelse(is.null(pos.splines) || pos.splines>0, 1/2, 2),
-      ### Line width for the sequencing depth of out-group matches.
-      id.lwd=ifelse(is.null(id.splines) || id.splines>0, 1/2, 2),
-      ### Line width for the identity histogram.
-      in.col='darkblue',
-      ### Color associated to in-group matches.
-      out.col='lightblue',
-      ### Color associated to out-group matches.
-      id.col='black',
-      ### Color for the identity histogram.
-      breaks.col='#AAAAAA40',
-      ### Color of the vertical lines indicating sequence breaks.
-      peaks.opts=list(),
-      ### Options passed to `enve.recplot2.findPeaks`, if `peaks.col` is not NA.
-      ...
-      ### Any other graphic parameters (currently ignored).
-   ){
-   pos.units	<- match.arg(pos.units);
-   pos.factor	<- ifelse(pos.units=='bp',1,ifelse(pos.units=='Kbp',1e3,1e6));
-   pos.lim	<- pos.lim/pos.factor;
-   lmat <- layout;
-   for(i in 1:6) if(!any(layout==i)) lmat[layout>i] <- lmat[layout>i]-1;
-
-   layout(lmat, widths=widths, heights=heights);
-   ori.mar <- par('mar');
-
-   # Essential vars
-   counts	<- x$counts
-
-   id.ingroup	<- x$id.ingroup
-   id.counts	<- x$id.counts
-   id.breaks	<- x$id.breaks
-   id.mids	<- (id.breaks[-length(id.breaks)]+id.breaks[-1])/2
-   id.binsize	<- id.breaks[-1] - id.breaks[-length(id.breaks)]
-
-   pos.counts.in  <- x$pos.counts.in
-   pos.counts.out <- x$pos.counts.out
-   pos.breaks   <- x$pos.breaks/pos.factor
-   pos.mids     <- (pos.breaks[-length(pos.breaks)]+pos.breaks[-1])/2
-   pos.binsize  <- (pos.breaks[-1] - pos.breaks[-length(pos.breaks)])*pos.factor
-
-   seqdepth.in  <- pos.counts.in/pos.binsize
-   seqdepth.out <- pos.counts.out/pos.binsize
-   seqdepth.lim <- range(c(seqdepth.in[seqdepth.in>0],
-		     seqdepth.out[seqdepth.out>0]))*c(1/2,2)
-
-   if(underlay.group){
-      in.bg  <- do.call(rgb, c(as.list(col2rgb(in.col)),
-		  list(maxColorValue=256, alpha=62)));
-      out.bg <- do.call(rgb, c(as.list(col2rgb(out.col)[,1]),
-		  list(maxColorValue=256, alpha=52)));
-   }
-
-   # [1] Counts matrix
-   if(any(layout==1)){
-      par(mar=mar[['1']]);
-      plot(1, t='n', bty='l',
-	 xlim=pos.lim, xlab=paste('Position in genome (',pos.units,')',sep=''),
-	    xaxs='i', ylim=id.lim,  ylab=x$id.metric, yaxs='i');
+(x,
+ layout=matrix(c(5,5,2,1,4,3), nrow=2),
+ panel.fun=list(),
+ widths=c(1,7,2),
+ heights=c(1,2),
+ palette=grey((100:0)/100),
+ underlay.group=TRUE,
+ peaks.col='darkred',
+ use.peaks,
+ id.lim=range(x$id.breaks),
+ pos.lim=range(x$pos.breaks),
+ pos.units=c('Mbp','Kbp','bp'),
+ mar=list('1'=c(5,4,1,1)+.1, '2'=c(ifelse(any(layout==1),1,5),4,4,1)+.1,
+          '3'=c(5,ifelse(any(layout==1),1,4),1,2)+0.1,
+          '4'=c(ifelse(any(layout==1),1,5),ifelse(any(layout==2),1,4),4,2)+0.1,
+          '5'=c(5,3,4,1)+0.1, '6'=c(5,4,4,2)+0.1),
+ pos.splines=0,
+ id.splines=1/2,
+ in.lwd=ifelse(is.null(pos.splines) || pos.splines>0, 1/2, 2),
+ out.lwd=ifelse(is.null(pos.splines) || pos.splines>0, 1/2, 2),
+ id.lwd=ifelse(is.null(id.splines) || id.splines>0, 1/2, 2),
+ in.col='darkblue',
+ out.col='lightblue',
+ id.col='black',
+ breaks.col='#AAAAAA40',
+ peaks.opts=list(),
+ ...
+){
+  pos.units	<- match.arg(pos.units);
+  pos.factor	<- ifelse(pos.units=='bp',1,ifelse(pos.units=='Kbp',1e3,1e6));
+  pos.lim	<- pos.lim/pos.factor;
+  lmat <- layout;
+  for(i in 1:6) if(!any(layout==i)) lmat[layout>i] <- lmat[layout>i]-1;
+
+  layout(lmat, widths=widths, heights=heights);
+  ori.mar <- par('mar');
+
+  # Essential vars
+  counts	<- x$counts
+
+  id.ingroup	<- x$id.ingroup
+  id.counts	<- x$id.counts
+  id.breaks	<- x$id.breaks
+  id.mids	<- (id.breaks[-length(id.breaks)]+id.breaks[-1])/2
+  id.binsize	<- id.breaks[-1] - id.breaks[-length(id.breaks)]
+
+  pos.counts.in  <- x$pos.counts.in
+  pos.counts.out <- x$pos.counts.out
+  pos.breaks   <- x$pos.breaks/pos.factor
+  pos.mids     <- (pos.breaks[-length(pos.breaks)]+pos.breaks[-1])/2
+  pos.binsize  <- (pos.breaks[-1] - pos.breaks[-length(pos.breaks)])*pos.factor
+
+  seqdepth.in  <- pos.counts.in/pos.binsize
+  seqdepth.out <- pos.counts.out/pos.binsize
+  seqdepth.lim <- range(c(seqdepth.in[seqdepth.in>0],
+                          seqdepth.out[seqdepth.out>0]))*c(1/2,2)
+
+  if(underlay.group){
+    in.bg  <- do.call(rgb, c(as.list(col2rgb(in.col)),
+                             list(maxColorValue=256, alpha=62)));
+    out.bg <- do.call(rgb, c(as.list(col2rgb(out.col)[,1]),
+                             list(maxColorValue=256, alpha=52)));
+  }
+
+  # [1] Counts matrix
+  if(any(layout==1)){
+    par(mar=mar[['1']]);
+    plot(1, t='n', bty='l',
+         xlim=pos.lim, xlab=paste('Position in genome (',pos.units,')',sep=''),
+         xaxs='i', ylim=id.lim,  ylab=x$id.metric, yaxs='i');
+    if(underlay.group){
+      rect(pos.lim[1], id.lim[1], pos.lim[2],
+           min(id.breaks[c(id.ingroup,TRUE)]), col=out.bg, border=NA);
+      rect(pos.lim[1], min(id.breaks[c(id.ingroup,TRUE)]), pos.lim[2],
+           id.lim[2], col=in.bg,  border=NA);
+    }
+    abline(v=x$seq.breaks/pos.factor, col=breaks.col);
+    image(x=pos.breaks, y=id.breaks, z=log10(counts),col=palette,
+          bg=grey(1,0), breaks=seq(-.1,log10(max(counts)),
+                                   length.out=1+length(palette)), add=TRUE);
+    if(exists('1',panel.fun)) panel.fun[['1']]();
+  }
+
+  # [2] Position histogram
+  if(any(layout==2)){
+    par(mar=mar[['2']]);
+    if(any(layout==1)){
+      xlab=''
+      xaxt='n'
+    }else{
+      xlab=paste('Position in genome (',pos.units,')',sep='')
+      xaxt='s'
+    }
+    plot(1,t='n', bty='l', log='y',
+         xlim=pos.lim, xlab=xlab, xaxt=xaxt, xaxs='i',
+         ylim=seqdepth.lim, yaxs='i', ylab='Sequencing depth (X)');
+    abline(v=x$seq.breaks/pos.factor, col=breaks.col)
+    pos.x <- rep(pos.breaks,each=2)[-c(1,2*length(pos.breaks))]
+    pos.f <- rep(seqdepth.in,each=2)
+    lines(pos.x, rep(seqdepth.out,each=2), lwd=out.lwd, col=out.col);
+    lines(pos.x, pos.f, lwd=in.lwd, col=in.col);
+    if(is.null(pos.splines) || pos.splines > 0){
+      pos.spline <- smooth.spline(pos.x[pos.f>0], log(pos.f[pos.f>0]),
+                                  spar=pos.splines)
+      lines(pos.spline$x, exp(pos.spline$y), lwd=2, col=in.col)
+    }
+    if(any(pos.counts.out==0)) rect(pos.breaks[c(pos.counts.out==0,FALSE)],
+                                    seqdepth.lim[1], pos.breaks[c(FALSE,pos.counts.out==0)],
+                                    seqdepth.lim[1]*3/2, col=out.col, border=NA);
+    if(any(pos.counts.in==0))  rect(pos.breaks[c(pos.counts.in==0,FALSE)],
+                                    seqdepth.lim[1], pos.breaks[c(FALSE,pos.counts.in==0)],
+                                    seqdepth.lim[1]*3/2, col=in.col,  border=NA);
+    if(exists('2',panel.fun)) panel.fun[['2']]();
+  }
+
+  # [3] Identity histogram
+  if(any(layout==3)){
+    par(mar=mar[['3']]);
+    if(any(layout==1)){
+      ylab=''
+      yaxt='n'
+    }else{
+      ylab=x$id.metric
+      yaxt='s'
+    }
+    if(sum(id.counts>0) >= 4){
+      id.counts.range <- range(id.counts[id.counts>0])*c(1/2,2);
+      plot(1,t='n', bty='l', log='x',
+           xlim=id.counts.range, xlab='bps per bin', xaxs='i',
+           ylim=id.lim, yaxs='i', ylab=ylab, yaxt=yaxt);
       if(underlay.group){
-	 rect(pos.lim[1], id.lim[1], pos.lim[2],
-	    min(id.breaks[c(id.ingroup,TRUE)]), col=out.bg, border=NA);
-	 rect(pos.lim[1], min(id.breaks[c(id.ingroup,TRUE)]), pos.lim[2],
-	    id.lim[2], col=in.bg,  border=NA);
-      }
-      abline(v=x$seq.breaks/pos.factor, col=breaks.col);
-      image(x=pos.breaks, y=id.breaks, z=log10(counts),col=palette,
-	 bg=grey(1,0), breaks=seq(-.1,log10(max(counts)),
-	 length.out=1+length(palette)), add=TRUE);
-      if(exists('1',panel.fun)) panel.fun[['1']]();
-   }
-
-   # [2] Position histogram
-   if(any(layout==2)){
-      par(mar=mar[['2']]);
-      if(any(layout==1)){
-	 xlab=''
-	 xaxt='n'
-      }else{
-	 xlab=paste('Position in genome (',pos.units,')',sep='')
-	 xaxt='s'
-      }
-      plot(1,t='n', bty='l', log='y',
-	 xlim=pos.lim, xlab=xlab, xaxt=xaxt, xaxs='i',
-	 ylim=seqdepth.lim, yaxs='i', ylab='Sequencing depth (X)');
-      abline(v=x$seq.breaks/pos.factor, col=breaks.col)
-      pos.x <- rep(pos.breaks,each=2)[-c(1,2*length(pos.breaks))]
-      pos.f <- rep(seqdepth.in,each=2)
-      lines(pos.x, rep(seqdepth.out,each=2), lwd=out.lwd, col=out.col);
-      lines(pos.x, pos.f, lwd=in.lwd, col=in.col);
-      if(is.null(pos.splines) || pos.splines > 0){
-	 pos.spline <- smooth.spline(pos.x[pos.f>0], log(pos.f[pos.f>0]),
-	    spar=pos.splines)
-	 lines(pos.spline$x, exp(pos.spline$y), lwd=2, col=in.col)
+        rect(id.counts.range[1], id.lim[1], id.counts.range[2],
+             min(id.breaks[c(id.ingroup,TRUE)]), col=out.bg, border=NA);
+        rect(id.counts.range[1], min(id.breaks[c(id.ingroup,TRUE)]),
+             id.counts.range[2], id.lim[2], col=in.bg,  border=NA);
       }
-      if(any(pos.counts.out==0)) rect(pos.breaks[c(pos.counts.out==0,FALSE)],
-	       seqdepth.lim[1], pos.breaks[c(FALSE,pos.counts.out==0)],
-	       seqdepth.lim[1]*3/2, col=out.col, border=NA);
-      if(any(pos.counts.in==0))  rect(pos.breaks[c(pos.counts.in==0,FALSE)],
-	       seqdepth.lim[1], pos.breaks[c(FALSE,pos.counts.in==0)],
-	       seqdepth.lim[1]*3/2, col=in.col,  border=NA);
-      if(exists('2',panel.fun)) panel.fun[['2']]();
-   }
-
-   # [3] Identity histogram
-   if(any(layout==3)){
-      par(mar=mar[['3']]);
-      if(any(layout==1)){
-	 ylab=''
-	 yaxt='n'
-      }else{
-	 ylab=x$id.metric
-	 yaxt='s'
-      }
-      if(sum(id.counts>0) >= 4){
-	 id.counts.range <- range(id.counts[id.counts>0])*c(1/2,2);
-	 plot(1,t='n', bty='l', log='x',
-	       xlim=id.counts.range, xlab='bps per bin', xaxs='i',
-	       ylim=id.lim, yaxs='i', ylab=ylab, yaxt=yaxt);
-	 if(underlay.group){
-	    rect(id.counts.range[1], id.lim[1], id.counts.range[2],
-	       min(id.breaks[c(id.ingroup,TRUE)]), col=out.bg, border=NA);
-	    rect(id.counts.range[1], min(id.breaks[c(id.ingroup,TRUE)]),
-	       id.counts.range[2], id.lim[2], col=in.bg,  border=NA);
-	 }
-	 id.f <- rep(id.counts,each=2)
-	 id.x <- rep(id.breaks,each=2)[-c(1,2*length(id.breaks))]
-	 lines(id.f, id.x, lwd=id.lwd, col=id.col);
-	 if(is.null(id.splines) || id.splines > 0){
-	    id.spline <- smooth.spline(id.x[id.f>0], log(id.f[id.f>0]),
-	       spar=id.splines)
-	    lines(exp(id.spline$y), id.spline$x, lwd=2, col=id.col)
-	 }
-      }else{
-	 plot(1,t='n',bty='l',xlab='', xaxt='n', ylab='', yaxt='n')
-	 text(1,1,labels='Insufficient data', srt=90)
+      id.f <- rep(id.counts,each=2)
+      id.x <- rep(id.breaks,each=2)[-c(1,2*length(id.breaks))]
+      lines(id.f, id.x, lwd=id.lwd, col=id.col);
+      if(is.null(id.splines) || id.splines > 0){
+        id.spline <- smooth.spline(id.x[id.f>0], log(id.f[id.f>0]),
+                                   spar=id.splines)
+        lines(exp(id.spline$y), id.spline$x, lwd=2, col=id.col)
       }
-      if(exists('3',panel.fun)) panel.fun[['3']]();
-   }
-
-   # [4] Populations histogram
-   peaks <- NA;
-   if(any(layout==4)){
-      par(mar=mar[['4']]);
-      if(any(layout==2)){
-	 ylab=''
-	 yaxt='n'
+    }else{
+      plot(1,t='n',bty='l',xlab='', xaxt='n', ylab='', yaxt='n')
+      text(1,1,labels='Insufficient data', srt=90)
+    }
+    if(exists('3',panel.fun)) panel.fun[['3']]();
+  }
+
+  # [4] Populations histogram
+  peaks <- NA;
+  if(any(layout==4)){
+    par(mar=mar[['4']]);
+    if(any(layout==2)){
+      ylab=''
+      yaxt='n'
+    }else{
+      ylab='Sequencing depth (X)'
+      yaxt='s'
+    }
+    h.breaks <- seq(log10(seqdepth.lim[1]*2), log10(seqdepth.lim[2]/2),
+                    length.out=200);
+    h.in <- hist(log10(seqdepth.in), breaks=h.breaks, plot=FALSE);
+    h.out <- hist(log10(seqdepth.out), breaks=h.breaks, plot=FALSE);
+    plot(1, t='n', log='y',
+         xlim=range(c(h.in$counts,h.out$counts,sum(pos.counts.in==0))),
+         xaxs='r', xlab='', xaxt='n', ylim=seqdepth.lim, yaxs='i', ylab=ylab,
+         yaxt=yaxt)
+    y.tmp.in <- c(rep(10^h.in$breaks,each=2),seqdepth.lim[1]*c(1,1,3/2,3/2))
+    y.tmp.out <- c(rep(10^h.out$breaks,each=2),seqdepth.lim[1]*c(1,1,3/2,3/2))
+    lines(c(0,rep(h.out$counts,each=2),0,0,rep(sum(pos.counts.out==0),2),0),
+          y.tmp.out, col=out.col)
+    polygon(c(0,rep(h.in$counts,each=2),0,0,rep(sum(pos.counts.in==0),2),0),
+            y.tmp.in, border=NA, col=in.col)
+    if(!is.na(peaks.col)){
+      o <- peaks.opts; o$x = x;
+      if(missing(use.peaks)){
+        peaks <- do.call(enve.recplot2.findPeaks, o)
       }else{
-	 ylab='Sequencing depth (X)'
-	 yaxt='s'
+        peaks <- use.peaks
       }
-      h.breaks <- seq(log10(seqdepth.lim[1]*2), log10(seqdepth.lim[2]/2),
-	 length.out=200);
-      h.in <- hist(log10(seqdepth.in), breaks=h.breaks, plot=FALSE);
-      h.out <- hist(log10(seqdepth.out), breaks=h.breaks, plot=FALSE);
-      plot(1, t='n', log='y',
-	 xlim=range(c(h.in$counts,h.out$counts,sum(pos.counts.in==0))),
-	 xaxs='r', xlab='', xaxt='n', ylim=seqdepth.lim, yaxs='i', ylab=ylab,
-	 yaxt=yaxt)
-      y.tmp.in <- c(rep(10^h.in$breaks,each=2),seqdepth.lim[1]*c(1,1,3/2,3/2))
-      y.tmp.out <- c(rep(10^h.out$breaks,each=2),seqdepth.lim[1]*c(1,1,3/2,3/2))
-      lines(c(0,rep(h.out$counts,each=2),0,0,rep(sum(pos.counts.out==0),2),0),
-	 y.tmp.out, col=out.col)
-      polygon(c(0,rep(h.in$counts,each=2),0,0,rep(sum(pos.counts.in==0),2),0),
-	 y.tmp.in, border=NA, col=in.col)
-      if(!is.na(peaks.col)){
-	 o <- peaks.opts; o$x = x;
-         if(missing(use.peaks)){
-           peaks <- do.call(enve.recplot2.findPeaks, o)
-         }else{
-           peaks <- use.peaks
-         }
-	 h.mids <- (10^h.breaks[-1] + 10^h.breaks[-length(h.breaks)])/2
-	 if(!is.null(peaks) & length(peaks)>0){
-	    pf <- h.mids*0;
-	    for(i in 1:length(peaks)){
-	       cnt <- enve.recplot2.__peakHist(peaks[[i]], h.mids)
-	       lines(cnt, h.mids, col='red');
-	       pf <- pf+cnt;
-	       axis(4, at=peaks[[i]]$seq.depth, letters[i], las=1, hadj=1/2)
-	    }
-	    lines(pf, h.mids, col='red',lwd=1.5);
-            dpt <- signif(as.numeric(lapply(peaks, function(x) x$seq.depth)),2)
-            frx <- signif(100*as.numeric(
-                  lapply(peaks,
-                    function(x) ifelse(length(x$values)==0, x$n.hat,
-                      length(x$values))/x$n.total)), 2)
-            if(peaks[[1]]$err.res < 0){
-              err <- paste(', LL:', signif(peaks[[1]]$err.res, 3))
-            }else{
-              err <- paste(', err:',
-                    signif(as.numeric(lapply(peaks, function(x) x$err.res)), 2))
-            }
-	    legend('topright', bty='n', cex=1/2,
-                  legend=paste(letters[1:length(peaks)],'. ',
-                    dpt,'X (', frx, '%', err, ')', sep=''))
-	 }
+      h.mids <- (10^h.breaks[-1] + 10^h.breaks[-length(h.breaks)])/2
+      if(!is.null(peaks) & length(peaks)>0){
+        pf <- h.mids*0;
+        for(i in 1:length(peaks)){
+          cnt <- enve.recplot2.__peakHist(peaks[[i]], h.mids)
+          lines(cnt, h.mids, col='red');
+          pf <- pf+cnt;
+          axis(4, at=peaks[[i]]$seq.depth, letters[i], las=1, hadj=1/2)
+        }
+        lines(pf, h.mids, col='red',lwd=1.5);
+        dpt <- signif(as.numeric(lapply(peaks, function(x) x$seq.depth)),2)
+        frx <- signif(100*as.numeric(
+          lapply(peaks,
+                 function(x) ifelse(length(x$values)==0, x$n.hat,
+                                    length(x$values))/x$n.total)), 2)
+        if(peaks[[1]]$err.res < 0){
+          err <- paste(', LL:', signif(peaks[[1]]$err.res, 3))
+        }else{
+          err <- paste(', err:',
+                       signif(as.numeric(lapply(peaks, function(x) x$err.res)), 2))
+        }
+        legend('topright', bty='n', cex=1/2,
+               legend=paste(letters[1:length(peaks)],'. ',
+                            dpt,'X (', frx, '%', err, ')', sep=''))
       }
-      if(exists('4',panel.fun)) panel.fun[['4']]();
-   }
-
-   # [5] Color scale of the counts matrix (vertical)
-   count.bins <- 10^seq(log10(min(counts[counts>0])), log10(max(counts)),
-      length.out=1+length(palette))
-   if(any(layout==5)){
-      par(mar=mar[['5']]);
-      plot(1,t='n',log='y',xlim=0:1,xaxt='n',xlab='',xaxs='i',
-	 ylim=range(count.bins), yaxs='i', ylab='')
-      rect(0,count.bins[-length(count.bins)],1,count.bins[-1],col=palette,
-	 border=NA)
-      if(exists('5',panel.fun)) panel.fun[['5']]();
-   }
-
-   # [6] Color scale of the coutnts matrix (horizontal)
-   if(any(layout==6)){
-      par(mar=mar[['6']]);
-      plot(1,t='n',log='x',ylim=0:1,yaxt='n',ylab='',yaxs='i',
-	 xlim=range(count.bins), xaxs='i',xlab='');
-      rect(count.bins[-length(count.bins)],0,count.bins[-1],1,col=palette,
-	 border=NA);
-      if(exists('6',panel.fun)) panel.fun[['6']]();
-   }
-   
-   par(mar=ori.mar);
-   return(peaks);
-   ### Returns a list of `enve.RecPlot2.Peak` objects (see
-   ### `enve.recplot2.findPeaks`). If `peaks.col`=NA or `layout` doesn't include
-   ### 4, returns NA.
+    }
+    if(exists('4',panel.fun)) panel.fun[['4']]();
+  }
+
+  # [5] Color scale of the counts matrix (vertical)
+  count.bins <- 10^seq(log10(min(counts[counts>0])), log10(max(counts)),
+                       length.out=1+length(palette))
+  if(any(layout==5)){
+    par(mar=mar[['5']]);
+    plot(1,t='n',log='y',xlim=0:1,xaxt='n',xlab='',xaxs='i',
+         ylim=range(count.bins), yaxs='i', ylab='')
+    rect(0,count.bins[-length(count.bins)],1,count.bins[-1],col=palette,
+         border=NA)
+    if(exists('5',panel.fun)) panel.fun[['5']]();
+  }
+
+  # [6] Color scale of the coutnts matrix (horizontal)
+  if(any(layout==6)){
+    par(mar=mar[['6']]);
+    plot(1,t='n',log='x',ylim=0:1,yaxt='n',ylab='',yaxs='i',
+         xlim=range(count.bins), xaxs='i',xlab='');
+    rect(count.bins[-length(count.bins)],0,count.bins[-1],1,col=palette,
+         border=NA);
+    if(exists('6',panel.fun)) panel.fun[['6']]();
+  }
+
+  par(mar=ori.mar);
+  return(peaks);
 }
 
 #==============> Define core functions
+
+#' Enveomics: Recruitment Plot (2)
+#'
+#' Produces recruitment plots provided that \code{BlastTab.catsbj.pl} has
+#' been previously executed.
+#'
+#' @param prefix
+#' Path to the prefix of the \code{BlastTab.catsbj.pl} output files. At
+#' least the files .rec and .lim must exist with this prefix.
+#' @param plot
+#' Should the object be plotted?
+#' @param pos.breaks
+#' Breaks in the positions histogram. It can also be a vector of break
+#' points, and values outside the range are ignored. If zero (0), it
+#' uses the sequence breaks as defined in the .lim file, which means
+#' one bin per contig (or gene, if the mapping is agains genes). Ignored
+#' if `pos.breaks.tsv` is passed.
+#' @param pos.breaks.tsv
+#' Path to a list of (absolute) coordinates to use as position breaks.
+#' This tab-delimited file can be produced by \code{GFF.catsbj.pl}, and it
+#' must contain at least one column: coordinates of the break positions of
+#' each position bin. If it has a second column, this is used as the name
+#' of the position bin that ends at the given coordinate (the first row is
+#' ignored). Any additional columns are currently ignored. If \code{NA},
+#' position bins are determined by \code{pos.breaks}.
+#' @param id.breaks
+#' Breaks in the identity histogram. It can also be a vector of break
+#' points, and values outside the range are ignored.
+#' @param id.free.range
+#' Indicates that the range should be freely set from the observed
+#' values. Otherwise, 70-100\% is included in the identity histogram
+#' (default).
+#' @param id.metric
+#' Metric of identity to be used (Y-axis). Corrected identity is only
+#' supported if the original BLAST file included sequence lengths.
+#' @param id.summary
+#' Function summarizing the identity bins. Other recommended options
+#' include: \code{median} to estimate the median instead of total bins, and
+#' \code{function(x) mlv(x,method='parzen')$M} to estimate the mode.
+#' @param id.cutoff
+#' Cutoff of identity metric above which the hits are considered
+#' \code{in-group}. The 95\% identity corresponds to the expectation of
+#' ANI<95\% within species.
+#' @param threads
+#' Number of threads to use.
+#' @param verbose
+#' Indicates if the function should report the advance.
+#' @param ...
+#' Any additional parameters supported by \code{\link{plot.enve.RecPlot2}}.
+#'
+#' @return Returns an object of class \code{\link{enve.RecPlot2}}.
+#'
+#' @author Luis M. Rodriguez-R [aut, cre]
+#' @author Kenji Gerhardt [aut]
+#'
+#' @export
+
 enve.recplot2 <- function(
-  ### Produces recruitment plots provided that BlastTab.catsbj.pl has
-  ### been previously executed.
-    prefix,
-    ### Path to the prefix of the BlastTab.catsbj.pl output files. At
-    ### least the files .rec and .lim must exist with this prefix.
-    plot=TRUE,
-    ### Should the object be plotted?
-    pos.breaks=1e3,
-    ### Breaks in the positions histogram. It can also be a vector of break
-    ### points, and values outside the range are ignored. If zero (0), it
-    ### uses the sequence breaks as defined in the .lim file, which means
-    ### one bin per contig (or gene, if the mapping is agains genes). Ignored
-    ### if `pos.breaks.tsv` is passed.
-    pos.breaks.tsv=NA,
-    ### Path to a list of (absolute) coordinates to use as position breaks.
-    ### This tab-delimited file can be produced by `GFF.catsbj.pl`, and it
-    ### must contain at least one column: coordinates of the break positions of
-    ### each position bin. If it has a second column, this is used as the name
-    ### of the position bin that ends at the given coordinate (the first row is
-    ### ignored). Any additional columns are currently ignored. If NA,
-    ### position bins are determined by `pos.breaks`.
-    id.breaks=300,
-    ### Breaks in the identity histogram. It can also be a vector of break
-    ### points, and values outside the range are ignored.
-    id.free.range=FALSE,
-    ### Indicates that the range should be freely set from the observed
-    ### values. Otherwise, 70-100% is included in the identity histogram
-    ### (default).
-    id.metric=c('identity', 'corrected identity', 'bit score'),
-    ### Metric of identity to be used (Y-axis). Corrected identity is only
-    ### supported if the original BLAST file included sequence lengths.
-    id.summary=sum,
-    ### Function summarizing the identity bins. Other recommended options
-    ### include: `median` to estimate the median instead of total bins, and
-    ### `function(x) mlv(x,method='parzen')$M` to estimate the mode.
-    id.cutoff=95,
-    ### Cutoff of identity metric above which the hits are considered
-    ### 'in-group'. The 95% identity corresponds to the expectation of
-    ### ANI<95% within species.
-    threads=2,
-    ### Number of threads to use.
-    verbose=TRUE,
-    ### Indicates if the function should report the advance.
-    ...
-    ### Any additional parameters supported by `plot.enve.RecPlot2`.
-  ){
+  prefix,
+  plot = TRUE,
+  pos.breaks = 1e3,
+  pos.breaks.tsv = NA,
+  id.breaks = 60,
+  id.free.range = FALSE,
+  id.metric = c('identity', 'corrected identity', 'bit score'),
+  id.summary = sum,
+  id.cutoff = 95,
+  threads = 2,
+  verbose = TRUE,
+  ...
+){
   # Settings
   id.metric <- match.arg(id.metric);
 
   #Read files
-  if(verbose) cat("Reading files.\n")
-  rec <- read.table(paste(prefix, ".rec", sep=""), sep="\t", comment.char="",
-        quote="");
-  lim <- read.table(paste(prefix, ".lim", sep=""), sep="\t", comment.char="",
-        quote="", as.is=TRUE);
+  if (verbose) cat("Reading files.\n")
+  rec <- read.table(paste(prefix, ".rec", sep = ""),
+    sep = "\t", comment.char = "", quote = "");
+  lim <- read.table(paste(prefix, ".lim", sep = ""),
+    sep = "\t", comment.char = "", quote = "", as.is = TRUE);
 
   # Build matrix
-  if(verbose) cat("Building counts matrix.\n")
-  if(id.metric=="corrected identity" & ncol(rec)<6){
+  if (verbose) cat("Building counts matrix.\n")
+  if (id.metric == "corrected identity" & ncol(rec) < 6) {
     stop("Requesting corr. identity, but .rec file doesn't have 6th column")
   }
-  rec.idcol <- ifelse(id.metric=="identity", 3,
-        ifelse(id.metric=="corrected identity", 6, 4))
+  rec.idcol <- ifelse(id.metric == "identity", 3,
+                      ifelse(id.metric == "corrected identity", 6, 4))
   pos.names <- as.character(NULL)
-  if(!is.na(pos.breaks.tsv)){
-    tmp <- read.table(pos.breaks.tsv, sep='\t', header=FALSE, as.is=TRUE)
-    pos.breaks <- as.numeric(tmp[,1])
-    if(ncol(tmp)>1) pos.names <- as.character(tmp[-1,2])
-  }else if(length(pos.breaks)==1){
-    if(pos.breaks>0){
-      pos.breaks <- seq(min(lim[,2]), max(lim[,3]), length.out=pos.breaks+1);
-    }else{
-      pos.breaks <- c(lim[1,2], lim[,3])
-      pos.names  <- lim[,1]
+  if (!is.na(pos.breaks.tsv)){
+    tmp <- read.table(pos.breaks.tsv, sep = "\t", header = FALSE, as.is = TRUE)
+    pos.breaks <- as.numeric(tmp[, 1])
+    if (ncol(tmp) > 1) pos.names <- as.character(tmp[-1, 2])
+  } else if (length(pos.breaks) == 1) {
+    if (pos.breaks > 0){
+      pos.breaks <- seq(min(lim[, 2]), max(lim[, 3]), length.out = pos.breaks + 1)
+    } else {
+      pos.breaks <- c(lim[1, 2], lim[, 3])
+      pos.names  <- lim[, 1]
     }
   }
-  if(length(id.breaks)==1){
-    id.range.v <- rec[,rec.idcol]
-    if(!id.free.range) id.range.v <- c(id.range.v,70,100)
+  if (length(id.breaks) == 1) {
+    id.range.v <- rec[, rec.idcol]
+    if (!id.free.range) id.range.v <- c(id.range.v, 70, 100)
     id.range.v <- range(id.range.v)
-    id.breaks <- seq(id.range.v[1], id.range.v[2], length.out=id.breaks+1);
+    id.breaks <- seq(id.range.v[1], id.range.v[2], length.out = id.breaks + 1)
   }
 
   # Run in parallel
-  if(nrow(rec) < 200) threads <- 1 # It doesn't worth the overhead
-  cl    <- makeCluster(threads)
-  rec.l <- list()
-  thl   <- ceiling(nrow(rec)/threads)
-  for(i in 0:(threads-1)){
-    rec.l[[i+1]] <- list(
-          rec=rec[ (i*thl+1):min(((i+1)*thl),nrow(rec)), ],
-          verbose=ifelse(i==0, verbose, FALSE))
+  # If they already set threads to 1 manually, there's no point in launching
+  # clusters, it's just slower. Ditto for small files.
+  if (nrow(rec) < 75000 | threads == 1) {
+    # Coerces rec into a form that __counts is happy about
+    rec.l <- list()
+    rec.l[[1]] <- list(rec = rec, verbose = FALSE)
+
+    # No need to make a temporary variable, there's only one return for sure
+    # and it's not a list because it isn't coming back from an apply
+    counts <- enve.recplot2.__counts(
+      rec.l[[1]], pos.breaks = pos.breaks, id.breaks = id.breaks,
+      rec.idcol = rec.idcol)
+  } else {
+    cl <- makeCluster(threads)
+    rec.l <- list()
+    thl <- ceiling(nrow(rec)/threads)
+    for (i in 0:(threads - 1)) {
+      rec.l[[i + 1]] <- list(
+        rec = rec[(i * thl + 1):min(((i + 1) * thl), nrow(rec)), ],
+        verbose = ifelse(i == 0, verbose, FALSE))
+    }
+    counts.l <- clusterApply(
+      cl, rec.l, enve.recplot2.__counts, pos.breaks = pos.breaks,
+      id.breaks = id.breaks, rec.idcol = rec.idcol)
+    stopCluster(cl) # No spooky ghost clusters
+
+    counts <- counts.l[[1]]
+    for (i in 2:threads) counts <- counts + counts.l[[i]]
   }
-  counts.l <- clusterApply(cl, rec.l, enve.recplot2.__counts,
-                pos.breaks=pos.breaks, id.breaks=id.breaks,
-                rec.idcol=rec.idcol)
-  counts   <- counts.l[[1]]
-  if(threads>1) for(i in 2:threads) counts <- counts + counts.l[[i]]
-  stopCluster(cl)
 
   # Estimate 1D histograms
-  if(verbose) cat("Building histograms.\n")
-  id.mids	<- (id.breaks[-length(id.breaks)]+id.breaks[-1])/2;
+  if (verbose) cat("Building histograms.\n")
+  id.mids	<- (id.breaks[-length(id.breaks)] + id.breaks[-1])/2;
   id.ingroup	<- (id.mids > id.cutoff);
   id.counts	<- apply(counts, 2, id.summary);
-  pos.counts.in   <- apply(counts[,id.ingroup], 1, sum);
-  pos.counts.out  <- apply(counts[,!id.ingroup], 1, sum);
+  pos.counts.in   <- apply(counts[, id.ingroup], 1, sum);
+  pos.counts.out  <- apply(counts[, !id.ingroup], 1, sum);
 
   # Plot and return
   recplot <- new('enve.RecPlot2',
-    counts=counts, id.counts=id.counts, pos.counts.in=pos.counts.in,
-    pos.counts.out=pos.counts.out,
-    id.breaks=id.breaks, pos.breaks=pos.breaks, pos.names=pos.names,
-    seq.breaks=c(lim[1,2], lim[,3]), seq.names=lim[,1],
-    id.ingroup=id.ingroup,id.metric=id.metric,
-    call=match.call());
-  if(plot){
-    if(verbose) cat("Plotting.\n")
+                 counts = counts, id.counts = id.counts,
+                 pos.counts.in = pos.counts.in, pos.counts.out = pos.counts.out,
+                 id.breaks = id.breaks, pos.breaks = pos.breaks,
+                 pos.names = pos.names, seq.breaks = c(lim[1, 2], lim[, 3]),
+                 seq.names = lim[, 1], id.ingroup = id.ingroup,
+                 id.metric = id.metric, call = match.call());
+  if (plot) {
+    if (verbose) cat("Plotting.\n")
     peaks <- plot(recplot, ...);
     attr(recplot, "peaks") <- peaks
   }
   return(recplot);
-  ### Returns an object of class `enve.RecPlot2`.
 }
 
+#' Enveomics: Recruitment Plot (2) Peak Finder
+#'
+#' Identifies peaks in the population histogram potentially indicating
+#' sub-population mixtures.
+#'
+#' @param x
+#' An \code{\link{enve.RecPlot2}} object.
+#' @param method
+#' Peak-finder method. This should be one of:
+#' \itemize{
+#'    \item \strong{emauto}
+#'    (Expectation-Maximization with auto-selection of components)
+#'    \item \strong{em}
+#'    (Expectation-Maximization)
+#'    \item \strong{mower}
+#'    (Custom distribution-mowing method)
+#' }
+#' @param ...
+#' Any additional parameters supported by
+#' \code{\link{enve.recplot2.findPeaks}}.
+#'
+#' @return Returns a list of \code{\link{enve.RecPlot2.Peak}} objects.
+#'
+#' @author Luis M. Rodriguez-R [aut, cre]
+#'
+#' export
+
 enve.recplot2.findPeaks <- function(
-  ### Identifies peaks in the population histogram potentially indicating
-  ### sub-population mixtures
-    x,
-    ### An `enve.RecPlot2` object.
-    method="emauto",
-    ### Peak-finder method. This should be one of:
-    ### "emauto" (Expectation-Maximization with auto-selection of components),
-    ### "em" (Expectation-Maximization),
-    ### "mower" (Custom distribution-mowing method).
-    ...
-    ### Any additional parameters supported by
-    ### `enve.recplot2.findPeaks.<method>`.
-    ){
+  x,
+  method="emauto",
+  ...
+){
   if(method == "emauto"){
     peaks <- enve.recplot2.findPeaks.emauto(x, ...)
   }else if(method == "em"){
@@ -502,29 +652,44 @@ enve.recplot2.findPeaks <- function(
     stop("Invalid peak-finder method ", method)
   }
   return(peaks)
-  ### Returns a list of `enve.RecPlot2.Peak` objects.
 }
 
+#' Enveomics: Recruitment Plot (2) Emauto Peak Finder
+#'
+#' Identifies peaks in the population histogram using a Gaussian Mixture
+#' Model Expectation Maximization (GMM-EM) method with number of components
+#' automatically detected.
+#'
+#' @param x
+#' An \code{\link{enve.RecPlot2}} object.
+#' @param components
+#' A vector of number of components to evaluate.
+#' @param criterion
+#' Criterion to use for components selection. Must be one of:
+#' \code{aic} (Akaike Information Criterion),
+#' \code{bic} or \code{sbc} (Bayesian Information Criterion or Schwarz Criterion).
+#' @param merge.tol
+#' When attempting to merge peaks with very similar sequencing depth, use
+#' this number of significant digits (in log-scale).
+#' @param verbose
+#' Display (mostly debugging) information.
+#' @param ...
+#' Any additional parameters supported by \code{\link{enve.recplot2.findPeaks.em}}.
+#'
+#' @return Returns a list of \code{\link{enve.RecPlot2.Peak}} objects.
+#'
+#' @author Luis M. Rodriguez-R [aut, cre]
+#'
+#' @export
+
 enve.recplot2.findPeaks.emauto <- function(
-  ### Identifies peaks in the population histogram using a Gaussian Mixture
-  ### Model Expectation Maximization (GMM-EM) method with number of components
-  ### automatically detected.
-    x,
-    ### An `enve.RecPlot2` object.
-    components=seq(1,10),
-    ### A vector of number of components to evaluate.
-    criterion='aic',
-    ### Criterion to use for components selection. Must be one of:
-    ### 'aic' (Akaike Information Criterion),
-    ### 'bic' or 'sbc' (Bayesian Information Criterion or Schwarz Criterion).
-    merge.tol=2L,
-    ### When attempting to merge peaks with very similar sequencing depth, use
-    ### this number of significant digits (in log-scale).
-    verbose=FALSE,
-    ### Display (mostly debugging) information.
-    ...
-    ### Any additional parameters supported by `enve.recplot2.findPeaks.em`.
-    ){
+  x,
+  components=seq(1,10),
+  criterion='aic',
+  merge.tol=2L,
+  verbose=FALSE,
+  ...
+){
   best <- list(crit=0, pstore=list())
   if(criterion == 'aic'){
     do_crit <- function(ll, k, n) 2*k - 2*ll
@@ -536,55 +701,72 @@ enve.recplot2.findPeaks.emauto <- function(
   for(comp in components){
     if(verbose) cat('Testing:',comp,'\n')
     best <- enve.recplot2.findPeaks.__emauto_one(x, comp, do_crit, best,
-          verbose, ...)
+                                                 verbose, ...)
   }
   if(length(best[['peaks']])==0) return(list())
 
   seqdepths.r <- signif(log(sapply(best[['peaks']],
-        function(x) x$seq.depth)), merge.tol)
+                                   function(x) x$seq.depth)), merge.tol)
   distinct <- length(unique(seqdepths.r))
   if(distinct < length(best[['peaks']])){
     if(verbose) cat('Attempting merge to', distinct, 'components\n')
     init <- apply(sapply(best[['peaks']],
-          function(x) c(x$param.hat, alpha=x$n.hat/x$n.total)), 1, as.numeric)
+                         function(x) c(x$param.hat, alpha=x$n.hat/x$n.total)), 1, as.numeric)
     init <- init[!duplicated(seqdepths.r),]
     init <- list(mu=init[,'mean'], sd=init[,'sd'],
-          alpha=init[,'alpha']/sum(init[,'alpha']))
+                 alpha=init[,'alpha']/sum(init[,'alpha']))
     best <- enve.recplot2.findPeaks.__emauto_one(x, distinct, do_crit, best,
-          verbose, ...)
+                                                 verbose, ...)
   }
   return(best[['peaks']])
-  ### Returns a list of `enve.RecPlot2.Peak` objects.
 }
 
+#' Enveomics: Recruitment Plot (2) Em Peak Finder
+#'
+#' Identifies peaks in the population histogram using a Gaussian Mixture
+#' Model Expectation Maximization (GMM-EM) method.
+#'
+#' @param x
+#' An \code{\link{enve.RecPlot2}} object.
+#' @param max.iter
+#' Maximum number of EM iterations.
+#' @param ll.diff.res
+#' Maximum Log-Likelihood difference to be considered as convergent.
+#' @param components
+#' Number of distributions assumed in the mixture.
+#' @param rm.top
+#' Top-values to remove before finding peaks, as a quantile probability.
+#' This step is useful to remove highly conserved regions, but can be
+#' turned off by setting \code{rm.top=0}. The quantile is determined
+#' \strong{after} removing zero-coverage windows.
+#' @param verbose
+#' Display (mostly debugging) information.
+#' @param init
+#' Initialization parameters. By default, these are derived from k-means
+#' clustering. A named list with vectors for \code{mu}, \code{sd}, and
+#' \code{alpha}, each of length \code{components}.
+#' @param log
+#' Logical value indicating if the estimations should be performed in
+#' natural logarithm units. Do not change unless you know what you're
+#' doing.
+#'
+#' @return Returns a list of \code{\link{enve.RecPlot2.Peak}} objects.
+#'
+#' @author Luis M. Rodriguez-R [aut, cre]
+#'
+#' @export
+
 enve.recplot2.findPeaks.em <- function(
-  ### Identifies peaks in the population histogram using a Gaussian Mixture
-  ### Model Expectation Maximization (GMM-EM) method.
-    x,
-    ### An `enve.RecPlot2` object.
-    max.iter=1000,
-    ### Maximum number of EM iterations.
-    ll.diff.res=1e-8,
-    ### Maximum Log-Likelihood difference to be considered as convergent.
-    components=2,
-    ### Number of distributions assumed in the mixture.
-    rm.top=0.05,
-    ### Top-values to remove before finding peaks, as a quantile probability.
-    ### This step is useful to remove highly conserved regions, but can be
-    ### turned off by setting rm.top=0. The quantile is determined *after*
-    ### removing zero-coverage windows.
-    verbose=FALSE,
-    ### Display (mostly debugging) information.
-    init,
-    ### Initialization parameters. By default, these are derived from k-means
-    ### clustering. A named list with vectors for 'mu', 'sd', and 'alpha', each
-    ### of length `components`.
-    log=TRUE
-    ### Logical value indicating if the estimations should be performed in
-    ### natural logarithm units. Do not change unless you know what you're
-    ### doing.
-  ){
-  
+  x,
+  max.iter=1000,
+  ll.diff.res=1e-8,
+  components=2,
+  rm.top=0.05,
+  verbose=FALSE,
+  init,
+  log=TRUE
+){
+
   # Essential vars
   pos.binsize  <- x$pos.breaks[-1] - x$pos.breaks[-length(x$pos.breaks)]
   lsd1  <- (x$pos.counts.in/pos.binsize)[ x$pos.counts.in > 0 ]
@@ -603,7 +785,7 @@ enve.recplot2.findPeaks.em <- function(
   m.step <- init
   ll <- c()
   cur.ll <- -Inf
-  
+
   for(i in 1:max.iter){
     # 2/3. EM
     e.step <- enve.recplot2.findPeaks.__em_e(lsd1, m.step)
@@ -621,224 +803,297 @@ enve.recplot2.findPeaks.em <- function(
   for(i in 1:components){
     n.hat <- m.step[['alpha']][i]*length(lsd1)
     peaks[[i]] <- new('enve.RecPlot2.Peak', dist='norm', values=as.numeric(),
-      values.res=0, mode=m.step[['mu']][i],
-      param.hat=list(sd=m.step[['sd']][i], mean=m.step[['mu']][i]),
-      n.hat=n.hat, n.total=length(lsd1), err.res=cur.ll,
-      merge.logdist=as.numeric(), log=log,
-      seq.depth=ifelse(log, exp(m.step[['mu']][i]), m.step[['mu']][i]))
+                      values.res=0, mode=m.step[['mu']][i],
+                      param.hat=list(sd=m.step[['sd']][i], mean=m.step[['mu']][i]),
+                      n.hat=n.hat, n.total=length(lsd1), err.res=cur.ll,
+                      merge.logdist=as.numeric(), log=log,
+                      seq.depth=ifelse(log, exp(m.step[['mu']][i]), m.step[['mu']][i]))
   }
   return(peaks)
-  ### Returns a list of `enve.RecPlot2.Peak` objects.
 }
 
+#' Enveomics: Recruitment Plot (2) Mowing Peak Finder
+#'
+#' Identifies peaks in the population histogram potentially indicating
+#' sub-population mixtures, using a custom distribution-mowing method.
+#'
+#' @param x
+#' An \code{\link{enve.RecPlot2}} object.
+#' @param min.points
+#' Minimum number of points in the quantile-estimation-range
+#' \code{(quant.est)} to estimate a peak.
+#' @param quant.est
+#' Range of quantiles to be used in the estimation of a peak's
+#' parameters.
+#' @param mlv.opts
+#' Ignored. For backwards compatibility.
+#' @param fitdist.opts.sn
+#' Options passed to \code{fitdist} to estimate the standard deviation if
+#' \code{with.skewness=TRUE}. Note that the \code{start} parameter will be
+#' ammended with \code{xi=estimated} mode for each peak.
+#' @param fitdist.opts.norm
+#' Options passed to \code{fitdist} to estimate the standard deviation if
+#' \code{with.skewness=FALSE}. Note that the \code{start} parameter will be
+#' ammended with \code{mean=estimated} mode for each peak.
+#' @param rm.top
+#' Top-values to remove before finding peaks, as a quantile probability.
+#' This step is useful to remove highly conserved regions, but can be
+#' turned off by setting \code{rm.top=0}. The quantile is determined
+#' \strong{after} removing zero-coverage windows.
+#' @param with.skewness
+#' Allow skewness correction of the peaks. Typically, the
+#' sequencing-depth distribution for a single peak is left-skewed, due
+#' partly (but not exclusively) to fragmentation and mapping sensitivity.
+#' See \emph{Lindner et al 2013, Bioinformatics 29(10):1260-7} for an
+#' alternative solution for the first problem (fragmentation) called
+#' "tail distribution".
+#' @param optim.rounds
+#' Maximum rounds of peak optimization.
+#' @param optim.epsilon
+#' Trace change at which optimization stops (unless \code{optim.rounds} is
+#' reached first). The trace change is estimated as the sum of square
+#' differences between parameters in one round and those from two rounds
+#' earlier (to avoid infinite loops from approximation).
+#' @param merge.logdist
+#' Maximum value of \code{|log-ratio|} between centrality parameters in peaks
+#' to attempt merging. The default of ~0.22 corresponds to a maximum
+#' difference of 25\%.
+#' @param verbose
+#' Display (mostly debugging) information.
+#' @param log
+#' Logical value indicating if the estimations should be performed in
+#' natural logarithm units. Do not change unless you know what you're
+#' doing.
+#'
+#' @return Returns a list of \code{\link{enve.RecPlot2.Peak}} objects.
+#'
+#' @author Luis M. Rodriguez-R [aut, cre]
+#'
+#' @export
+
 enve.recplot2.findPeaks.mower <- function(
-   ### Identifies peaks in the population histogram potentially indicating
-   ### sub-population mixtures, using a custom distribution-mowing method.
-      x,
-      ### An `enve.RecPlot2` object.
-      min.points=10,
-      ### Minimum number of points in the quantile-estimation-range
-      ### (`quant.est`) to estimate a peak.
-      quant.est=c(0.002, 0.998),
-      ### Range of quantiles to be used in the estimation of a peak's
-      ### parameters.
-      mlv.opts=list(method='parzen'),
-      ### Ignored. For backwards compatibility.
-      fitdist.opts.sn=list(distr='sn', method='qme', probs=c(0.1,0.5,0.8),
-	 start=list(omega=1, alpha=-1), lower=c(0, -Inf, -Inf)),
-      ### Options passed to `fitdist` to estimate the standard deviation if
-      ### with.skewness=TRUE. Note that the `start` parameter will be ammended
-      ### with xi=estimated mode for each peak.
-      fitdist.opts.norm=list(distr='norm', method='qme', probs=c(0.4,0.6),
-	 start=list(sd=1), lower=c(0, -Inf)),
-      ### Options passed to `fitdist` to estimate the standard deviation if
-      ### with.skewness=FALSE. Note that the `start` parameter will be ammended
-      ### with mean=estimated mode for each peak.
-      rm.top=0.05,
-      ### Top-values to remove before finding peaks, as a quantile probability.
-      ### This step is useful to remove highly conserved regions, but can be
-      ### turned off by setting rm.top=0. The quantile is determined *after*
-      ### removing zero-coverage windows.
-      with.skewness=TRUE,
-      ### Allow skewness correction of the peaks. Typically, the
-      ### sequencing-depth distribution for a single peak is left-skewed, due
-      ### partly (but not exclusively) to fragmentation and mapping sensitivity.
-      ### See Lindner et al 2013, Bioinformatics 29(10):1260-7 for an
-      ### alternative solution for the first problem (fragmentation) called
-      ### "tail distribution".
-      optim.rounds=200,
-      ### Maximum rounds of peak optimization.
-      optim.epsilon=1e-4,
-      ### Trace change at which optimization stops (unless `optim.rounds` is
-      ### reached first). The trace change is estimated as the sum of square
-      ### differences between parameters in one round and those from two rounds
-      ### earlier (to avoid infinite loops from approximation).
-      merge.logdist=log(1.75),
-      ### Maximum value of |log-ratio| between centrality parameters in peaks to
-      ### attempt merging. The default of ~0.22 corresponds to a maximum
-      ### difference of 25%.
-      verbose=FALSE,
-      ### Display (mostly debugging) information.
-      log=TRUE
-      ### Logical value indicating if the estimations should be performed in
-      ### natural logarithm units. Do not change unless you know what you're
-      ### doing.
-   ){
-   
-   # Essential vars
-   pos.binsize	<- x$pos.breaks[-1] - x$pos.breaks[-length(x$pos.breaks)];
-   seqdepth.in	<- x$pos.counts.in/pos.binsize;
-   lsd1 <- seqdepth.in[seqdepth.in>0];
-   lsd1 <- lsd1[ lsd1 < quantile(lsd1, 1-rm.top, names=FALSE) ]
-   if(log) lsd1 <- log(lsd1)
-   if(with.skewness){
-      fitdist.opts <- fitdist.opts.sn
-   }else{
-      fitdist.opts <- fitdist.opts.norm
-   }
-   peaks.opts <- list(lsd1=lsd1, min.points=min.points, quant.est=quant.est,
-      mlv.opts=mlv.opts, fitdist.opts=fitdist.opts, with.skewness=with.skewness,
-      optim.rounds=optim.rounds, optim.epsilon=optim.epsilon, verbose=verbose,
-      n.total=length(lsd1), merge.logdist=merge.logdist, log=log)
-   
-   # Find seed peaks
-   if(verbose) cat('Mowing peaks for n =',length(lsd1),'\n')
-   peaks <- enve.recplot2.findPeaks.__mower(peaks.opts);
-
-   # Merge overlapping peaks
-   if(verbose) cat('Trying to merge',length(peaks),'peaks\n')
-   merged <- (length(peaks)>1)
-   while(merged){
-      merged <- FALSE
-      ignore <- c()
-      peaks2 <- list();
-      for(i in 1:length(peaks)){
-	 if(i %in% ignore) next
-	 p <- peaks[[ i ]]
-	 j <- enve.recplot2.__whichClosestPeak(p, peaks)
-	 p2 <- peaks[[ j ]]
-	 dst.a <- p$param.hat[[ length(p$param.hat) ]]
-	 dst.b <- p2$param.hat[[ length(p2$param.hat) ]]
-	 if( abs(log(dst.a/dst.b)) < merge.logdist ){
-	    if(verbose) cat('==> Attempting a merge at',
-		  p$param.hat[[ length(p$param.hat) ]],'&',
-		  p2$param.hat[[ length(p2$param.hat) ]],'X\n');
-	    peaks.opts$lsd1 <- c(p$values, p2$values)
-	    p.new <- enve.recplot2.findPeaks.__mower(peaks.opts)
-	    if(length(p.new)==1){
-	       peaks2[[ length(peaks2)+1 ]] <- p.new[[ 1 ]]
-	       ignore <- c(ignore, j)
-	       merged <- TRUE
-	    }
-	 }
-	 if(!merged) peaks2[[ length(peaks2)+1 ]] <- p
+  x,
+  min.points=10,
+  quant.est=c(0.002, 0.998),
+  mlv.opts=list(method='parzen'),
+  fitdist.opts.sn=list(distr='sn', method='qme', probs=c(0.1,0.5,0.8),
+                       start=list(omega=1, alpha=-1), lower=c(0, -Inf, -Inf)),
+  fitdist.opts.norm=list(distr='norm', method='qme', probs=c(0.4,0.6),
+                         start=list(sd=1), lower=c(0, -Inf)),
+  rm.top=0.05,
+  with.skewness=TRUE,
+  optim.rounds=200,
+  optim.epsilon=1e-4,
+  merge.logdist=log(1.75),
+  verbose=FALSE,
+  log=TRUE
+){
+
+  # Essential vars
+  pos.binsize	<- x$pos.breaks[-1] - x$pos.breaks[-length(x$pos.breaks)];
+  seqdepth.in	<- x$pos.counts.in/pos.binsize;
+  lsd1 <- seqdepth.in[seqdepth.in>0];
+  lsd1 <- lsd1[ lsd1 < quantile(lsd1, 1-rm.top, names=FALSE) ]
+  if(log) lsd1 <- log(lsd1)
+  if(with.skewness){
+    fitdist.opts <- fitdist.opts.sn
+  }else{
+    fitdist.opts <- fitdist.opts.norm
+  }
+  peaks.opts <- list(lsd1=lsd1, min.points=min.points, quant.est=quant.est,
+                     mlv.opts=mlv.opts, fitdist.opts=fitdist.opts, with.skewness=with.skewness,
+                     optim.rounds=optim.rounds, optim.epsilon=optim.epsilon, verbose=verbose,
+                     n.total=length(lsd1), merge.logdist=merge.logdist, log=log)
+
+  # Find seed peaks
+  if(verbose) cat('Mowing peaks for n =',length(lsd1),'\n')
+  peaks <- enve.recplot2.findPeaks.__mower(peaks.opts);
+
+  # Merge overlapping peaks
+  if(verbose) cat('Trying to merge',length(peaks),'peaks\n')
+  merged <- (length(peaks)>1)
+  while(merged){
+    merged <- FALSE
+    ignore <- c()
+    peaks2 <- list();
+    for(i in 1:length(peaks)){
+      if(i %in% ignore) next
+      p <- peaks[[ i ]]
+      j <- enve.recplot2.__whichClosestPeak(p, peaks)
+      p2 <- peaks[[ j ]]
+      dst.a <- p$param.hat[[ length(p$param.hat) ]]
+      dst.b <- p2$param.hat[[ length(p2$param.hat) ]]
+      if( abs(log(dst.a/dst.b)) < merge.logdist ){
+        if(verbose) cat('==> Attempting a merge at',
+                        p$param.hat[[ length(p$param.hat) ]],'&',
+                        p2$param.hat[[ length(p2$param.hat) ]],'X\n');
+        peaks.opts$lsd1 <- c(p$values, p2$values)
+        p.new <- enve.recplot2.findPeaks.__mower(peaks.opts)
+        if(length(p.new)==1){
+          peaks2[[ length(peaks2)+1 ]] <- p.new[[ 1 ]]
+          ignore <- c(ignore, j)
+          merged <- TRUE
+        }
       }
-      peaks <- peaks2
-      if(length(peaks)==1) break
-   }
-   
-   if(verbose) cat('Found',length(peaks),'peak(s)\n')
-   return(peaks);
-   ### Returns a list of `enve.RecPlot2.Peak` objects.
+      if(!merged) peaks2[[ length(peaks2)+1 ]] <- p
+    }
+    peaks <- peaks2
+    if(length(peaks)==1) break
+  }
+
+  if(verbose) cat('Found',length(peaks),'peak(s)\n')
+  return(peaks);
 }
 
 #==============> Define utils
+
+#' Enveomics: Recruitment Plot (2) Core Peak Finder
+#'
+#' Finds the peak in a list of peaks that is most likely to represent the
+#' "core genome" of a population.
+#'
+#' @param x \code{list} of \code{\link{enve.RecPlot2.Peak}} objects.
+#'
+#' @author Luis M. Rodriguez-R [aut, cre]
+#'
+#' @export
+
 enve.recplot2.corePeak <- function
-   ### Finds the peak in a list of peaks that is most likely to represent the
-   ### "core genome" of a population.
-      (x
-      ### `list` of `enve.RecPlot2.Peak` objects.
-   ){
-   # Find the peak with maximum depth (centrality)
-   maxPeak <- x[[
-	 which.max(as.numeric(lapply(x,
-	    function(y) y$param.hat[[ length(y$param.hat) ]])))
-      ]]
-   # If a "larger" peak (a peak explaining more bins of the genome) is within
-   # the default "merge.logdist" distance, take that one instead.
-   corePeak <- maxPeak
-   for(p in x){
-     p.len <- ifelse(length(p$values)==0, p$n.hat, length(p$values))
-     corePeak.len <- ifelse(
-           length(corePeak$values)==0, corePeak$n.hat, length(corePeak$values))
-     sz.d <- log(p.len/corePeak.len)
-     if(is.nan(sz.d) || sz.d < 0) next
-     sq.d.a <- as.numeric(tail(p$param.hat, n=1))
-     sq.d.b <- as.numeric(tail(maxPeak$param.hat, n=1))
-     if(p$log) sq.d.a <- exp(sq.d.a)
-     if(corePeak$log) sq.d.b <- exp(sq.d.b)
-     if(abs(log(sq.d.a/sq.d.b)) < log(1.75)+sz.d/5) corePeak <- p
-   }
-   return(corePeak)
+(x
+){
+  # Find the peak with maximum depth (centrality)
+  maxPeak <- x[[
+    which.max(as.numeric(lapply(x,
+                                function(y) y$param.hat[[ length(y$param.hat) ]])))
+    ]]
+  # If a "larger" peak (a peak explaining more bins of the genome) is within
+  # the default "merge.logdist" distance, take that one instead.
+  corePeak <- maxPeak
+  for(p in x){
+    p.len <- ifelse(length(p$values)==0, p$n.hat, length(p$values))
+    corePeak.len <- ifelse(
+      length(corePeak$values)==0, corePeak$n.hat, length(corePeak$values))
+    sz.d <- log(p.len/corePeak.len)
+    if(is.nan(sz.d) || sz.d < 0) next
+    sq.d.a <- as.numeric(tail(p$param.hat, n=1))
+    sq.d.b <- as.numeric(tail(maxPeak$param.hat, n=1))
+    if(p$log) sq.d.a <- exp(sq.d.a)
+    if(corePeak$log) sq.d.b <- exp(sq.d.b)
+    if(abs(log(sq.d.a/sq.d.b)) < log(1.75)+sz.d/5) corePeak <- p
+  }
+  return(corePeak)
 }
 
+#' Enveomics: Recruitment Plot (2) Change Cutoff
+#'
+#' Change the intra-species cutoff of an existing recruitment plot.
+#'
+#' @param rp
+#' \code{\link{enve.RecPlot2}} object.
+#' @param new.cutoff
+#' New cutoff to use.
+#'
+#' @author Luis M. Rodriguez-R [aut, cre]
+#'
+#' @export
+
 enve.recplot2.changeCutoff <- function
-   ### Change the intra-species cutoff of an existing recruitment plot.
-      (rp,
-      ### enve.RecPlot2 object.
-      new.cutoff=98
-      ### New cutoff to use.
-      ){
-   # Re-calculate vectors
-   id.mids	<- (rp$id.breaks[-length(rp$id.breaks)]+rp$id.breaks[-1])/2
-   id.ingroup	<- (id.mids > new.cutoff)
-   pos.counts.in  <- apply(rp$counts[,id.ingroup], 1, sum)
-   pos.counts.out <- apply(rp$counts[,!id.ingroup], 1, sum)
-   # Update object
-   attr(rp, "id.ingroup")     <- id.ingroup
-   attr(rp, "pos.counts.in")  <- pos.counts.in
-   attr(rp, "pos.counts.out") <- pos.counts.out
-   attr(rp, "call")           <- match.call()
-   return(rp)
+(rp,
+ new.cutoff=98
+){
+  # Re-calculate vectors
+  id.mids	<- (rp$id.breaks[-length(rp$id.breaks)]+rp$id.breaks[-1])/2
+  id.ingroup	<- (id.mids > new.cutoff)
+  pos.counts.in  <- apply(rp$counts[,id.ingroup], 1, sum)
+  pos.counts.out <- apply(rp$counts[,!id.ingroup], 1, sum)
+  # Update object
+  attr(rp, "id.ingroup")     <- id.ingroup
+  attr(rp, "pos.counts.in")  <- pos.counts.in
+  attr(rp, "pos.counts.out") <- pos.counts.out
+  attr(rp, "call")           <- match.call()
+  return(rp)
 }
 
+#' Enveomics: Recruitment Plot (2) Window Depth Threshold
+#'
+#' Identifies the threshold below which windows should be identified as
+#' variable or absent.
+#'
+#' @param rp
+#' Recruitment plot, an \code{\link{enve.RecPlot2}} object.
+#' @param peak
+#' Peak, an \code{\link{enve.RecPlot2.Peak}} object. If list, it is assumed to be a
+#' list of \code{\link{enve.RecPlot2.Peak}} objects, in which case the core peak is
+#' used (see \code{\link{enve.recplot2.corePeak}}).
+#' @param lower.tail
+#' If \code{FALSE}, it returns windows significantly above the peak in
+#' sequencing depth.
+#' @param significance
+#' Significance threshold (alpha) to select windows.
+#'
+#' @return
+#' Returns a float. The units are depth if the peaks were estimated in
+#' linear scale, or log-depth otherwise (\code{peak$log}).
+#'
+#' @author Luis M. Rodriguez-R [aut, cre]
+#'
+#' @export
+
 enve.recplot2.windowDepthThreshold <- function
-  ### Identifies the threshold below which windows should be identified as
-  ### variable or absent.
-    (rp,
-    ### Recruitment plot, an `enve.RecPlot2` object.
-    peak,
-    ### Peak, an `enve.RecPlot2.Peak` object. If list, it is assumed to be a
-    ### list of `enve.RecPlot2.Peak` objects, in which case the core peak is
-    ### used (see `enve.recplot2.corePeak`).
-    lower.tail=TRUE,
-    ### If FALSE, it returns windows significantly above the peak in
-    ### sequencing depth.
-    significance=0.05
-    ### Significance threshold (alpha) to select windows.
-    ){
-   if(is.list(peak)) peak <- enve.recplot2.corePeak(peak)
-   par <- peak$param.hat
-   par[["p"]] <- ifelse(lower.tail, significance, 1-significance)
-   thr <- do.call(ifelse(length(par)==4, qsn, qnorm), par)
-   if(peak$log) thr <- exp(thr)
-
-   return(thr)
-   ### Returns a float. The units are depth if the peaks were estimated in
-   ### linear scale, or log-depth otherwise (`peak$log`).
+(rp,
+ peak,
+ lower.tail=TRUE,
+ significance=0.05
+){
+  if(is.list(peak)) peak <- enve.recplot2.corePeak(peak)
+  par <- peak$param.hat
+  par[["p"]] <- ifelse(lower.tail, significance, 1-significance)
+  thr <- do.call(ifelse(length(par)==4, qsn, qnorm), par)
+  if(peak$log) thr <- exp(thr)
+
+  return(thr)
 }
 
+#' Enveomics: Recruitment Plot (2) Extract Windows
+#'
+#' Extract windows significantly below (or above) the peak in sequencing
+#' depth.
+#'
+#' @param rp
+#' Recruitment plot, a \code{\link{enve.RecPlot2}} object.
+#' @param peak
+#' Peak, an \code{\link{enve.RecPlot2.Peak}} object. If list, it is assumed to be a
+#' list of \code{\link{enve.RecPlot2.Peak}} objects, in which case the core peak is
+#' used (see \code{\link{enve.recplot2.corePeak}}).
+#' @param lower.tail
+#' If \code{FALSE}, it returns windows significantly above the peak in
+#' sequencing depth.
+#' @param significance
+#' Significance threshold (alpha) to select windows.
+#' @param seq.names
+#' Returns subject sequence names instead of a vector of Booleans. If
+#' the recruitment plot was generated with named position bins (e.g, using
+#' \code{pos.breaks=0} or a two-column \code{pos.breaks.tsv}), it returns a
+#' vector of characters (the sequence identifiers), otherwise it returns a
+#' data.frame with a name column and two columns of coordinates.
+#'
+#' @return
+#' Returns a vector of logicals if \code{seq.names = FALSE}.
+#' If \code{seq.names = TRUE}, it returns a data.frame with five columns:
+#' \code{name.from}, \code{name.to}, \code{pos.from}, \code{pos.to}, and
+#' \code{seq.name} (see \code{\link{enve.recplot2.coordinates}}).
+#'
+#' @author Luis M. Rodriguez-R [aut, cre]
+#'
+#' @export
+
 enve.recplot2.extractWindows <- function
-  ### Extract windows significantly below (or above) the peak in sequencing
-  ### depth.
-    (rp,
-    ### Recruitment plot, a `enve.RecPlot2` object.
-    peak,
-    ### Peak, an `enve.RecPlot2.Peak` object. If list, it is assumed to be a
-    ### list of `enve.RecPlot2.Peak` objects, in which case the core peak is
-    ### used (see `enve.recplot2.corePeak`).
-    lower.tail=TRUE,
-    ### If FALSE, it returns windows significantly above the peak in
-    ### sequencing depth.
-    significance=0.05,
-    ### Significance threshold (alpha) to select windows.
-    seq.names=FALSE
-    ### Returns subject sequence names instead of a vector of Booleans. If
-    ### the recruitment plot was generated with named position bins (e.g, using
-    ### `pos.breaks`=0 or a two-column `pos.breaks.tsv`), it returns a vector of
-    ### characters (the sequence identifiers), otherwise it returns a data.frame
-    ### with a name column and two columns of coordinates.
-  ){
+(rp,
+ peak,
+ lower.tail = TRUE,
+ significance = 0.05,
+ seq.names = FALSE
+){
   # Determine the threshold
   thr <- enve.recplot2.windowDepthThreshold(rp, peak, lower.tail, significance)
 
@@ -850,43 +1105,54 @@ enve.recplot2.extractWindows <- function
     sel <- seqdepth.in > thr
   }
 
-  # seq.names=FALSE
+  # seq.names = FALSE
   if(!seq.names) return(sel)
-  # seq.names=TRUE and pos.names defined
-  if(length(rp$pos.names) != 0) return(rp$pos.names[sel])
-  # seq.names=TRUE and pos.names undefined
-  return(enve.recplot2.coordinates(rp,sel))
-  ### Returns a vector of logicals if `seq.names=FALSE`. If `seq.names=TRUE`,
-  ### it returns a vector of characters if the object has `pos.names` defined,
-  ### or a data.frame with four columns otherwise:
-  ### name.from, name.to, pos.from, and pos.to
-  ### (see `enve.recplot2.coordinates`).
+  # seq.names = TRUE
+  return(enve.recplot2.coordinates(rp, sel))
 }
 
+#' Enveomics: Recruitment Plot (2) Compare Identities
+#'
+#' Compare the distribution of identities between two
+#' \code{\link{enve.RecPlot2}} objects.
+#'
+#' @param x
+#' First \code{\link{enve.RecPlot2}} object.
+#' @param y
+#' Second \code{\link{enve.RecPlot2}} object.
+#' @param method
+#' Distance method to use. This should be (an unambiguous abbreviation of)
+#' one of:
+#' \itemize{
+#'    \item{"hellinger" (\emph{Hellinger, 1090, doi:10.1515/crll.1909.136.210}),}
+#'    \item{"bhattacharyya" (\emph{Bhattacharyya, 1943, Bull. Calcutta Math. Soc. 35}),}
+#'    \item{"kl" or "kullback-leibler" (\emph{Kullback & Leibler, 1951,
+#'    doi:10.1214/aoms/1177729694}), or}
+#'    \item{"euclidean"}
+#' }
+#' @param smooth.par
+#' Smoothing parameter for cubic spline smoothing. Use 0 for no smoothing.
+#' Use \code{NULL} to automatically determine this value using leave-one-out
+#' cross-validation (see \code{smooth.spline} parameter \code{spar}).
+#' @param pseudocounts
+#' Smoothing parameter for Laplace smoothing. Use 0 for no smoothing, or
+#' 1 for add-one smoothing.
+#' @param max.deviation
+#' Maximum mean deviation between identity breaks tolerated (as percent
+#' identity). Difference in number of \code{id.breaks} is never tolerated.
+#'
+#' @author Luis M. Rodriguez-R [aut, cre]
+#'
+#' @export
+
 enve.recplot2.compareIdentities <- function
-  ### Compare the distribution of identities between two enve.RecPlot2 objects.
-    (x,
-    ### First enve.RecPlot2 object.
-    y,
-    ### Second enve.RecPlot2 object.
-    method="hellinger",
-    ### Distance method to use. This should be (an unambiguous abbreviation of)
-    ### one of:
-    ### "hellinger" (Hellinger, 1090, doi:10.1515/crll.1909.136.210),
-    ### "bhattacharyya" (Bhattacharyya, 1943, Bull. Calcutta Math. Soc. 35),
-    ### "kl" or "kullback-leibler" (Kullback & Leibler, 1951,
-    ### doi:10.1214/aoms/1177729694), or "euclidean".
-    smooth.par=NULL,
-    ### Smoothing parameter for cubic spline smoothing. Use 0 for no smoothing.
-    ### Use NULL to automatically determine this value using leave-one-out
-    ### cross-validation (see `smooth.spline` parameter `spar`).
-    pseudocounts=0,
-    ### Smoothing parameter for Laplace smoothing. Use 0 for no smoothing, or
-    ### 1 for add-one smoothing.
-    max.deviation=0.75
-    ### Maximum mean deviation between identity breaks tolerated (as percent
-    ### identity). Difference in number of id.breaks is never tolerated.
-    ){
+(x,
+ y,
+ method="hellinger",
+ smooth.par=NULL,
+ pseudocounts=0,
+ max.deviation=0.75
+){
   METHODS <- c("hellinger","bhattacharyya","kullback-leibler","kl","euclidean")
   i.meth <- pmatch(method, METHODS)
   if (is.na(i.meth)) stop("Invalid distance ", method)
@@ -899,7 +1165,7 @@ enve.recplot2.compareIdentities <- function
   dev <- mean(abs(x$id.breaks - y$id.breaks))
   if(dev > max.deviation)
     stop("'x' and 'y' must have similar `id.breaks`; exceeding max.deviation: ",
-          dev)
+         dev)
   x.cnt <- x$id.counts
   y.cnt <- y$id.counts
   if(is.null(smooth.par) || smooth.par > 0){
@@ -928,63 +1194,92 @@ enve.recplot2.compareIdentities <- function
   return(d)
 }
 
+#' Enveomics: Recruitment Plot (2) Coordinates
+#'
+#' Returns the sequence name and coordinates of the requested position bins.
+#'
+#' @param x
+#' \code{\link{enve.RecPlot2}} object.
+#' @param bins
+#' Vector of selected bins to return. It can be a vector of logical values
+#' with the same length as \code{x$pos.breaks-1} or a vector of integers. If
+#' missing, returns the coordinates of all windows.
+#'
+#' @return
+#' Returns a data.frame with five columns: \code{name.from} (character),
+#' \code{pos.from} (numeric), \code{name.to} (character), \code{pos.to}
+#' (numeric), and \code{seq.name} (character).
+#' The first two correspond to sequence and position of the start point of the
+#' bin. The next two correspond to the sequence and position of the end point of
+#' the bin. The last one indicates the name of the sequence (if defined).
+#'
+#' @author Luis M. Rodriguez-R [aut, cre]
+#'
+#' @export
+
 enve.recplot2.coordinates <- function
-  ### Returns the sequence name and coordinates of the requested position bins.
-    (x,
-    ### `enve.RecPlot2` object.
-    bins
-    ### Vector of selected bins to return. It can be a vector of logical values
-    ### with the same length as `x$pos.breaks`-1 or a vector of integers. If
-    ### missing, returns the coordinates of all windows.
-    ){
+(x,
+ bins
+){
   if(!inherits(x, "enve.RecPlot2"))
     stop("'x' must inherit from class `enve.RecPlot2`")
   if(missing(bins)) bins <- rep(TRUE, length(x$pos.breaks)-1)
   if(!is.vector(bins)) stop("'bins' must be a vector")
   if(inherits(bins, "logical")) bins <- which(bins)
 
-  y <- data.frame(stringsAsFactors=FALSE, row.names=bins)
-  
+  y <- data.frame(stringsAsFactors = FALSE, row.names = bins)
+
   for(i in 1:length(bins)){
     j <- bins[i]
     # Concatenated coordinates
     cc <- x$pos.breaks[c(j, j+1)]
     # Find the corresponding `seq.breaks`
     sb.from <- which(
-          cc[1] >=x$seq.breaks[-length(x$seq.breaks)] &
-          cc[1] < x$seq.breaks[-1])
+      cc[1] >= x$seq.breaks[-length(x$seq.breaks)] &
+        cc[1] <  x$seq.breaks[-1])
     sb.to   <- which(
-          cc[2] > x$seq.breaks[-length(x$seq.breaks)] &
-          cc[2] <=x$seq.breaks[-1])
+      cc[2] >  x$seq.breaks[-length(x$seq.breaks)] &
+        cc[2] <= x$seq.breaks[-1])
     # Translate coordinates
     if(length(sb.from)==1 & length(sb.to)==1){
       y[i, 'name.from'] <- x$seq.names[sb.from]
-      y[i, 'pos.from'] <- floor(x$seq.breaks[sb.from] + cc[1] - 1)
+      y[i, 'pos.from']  <- floor(x$seq.breaks[sb.from] + cc[1] - 1)
       y[i, 'name.to']   <- x$seq.names[sb.to]
-      y[i, 'pos.to']   <- ceiling(x$seq.breaks[sb.to] + cc[2] - 1)
+      y[i, 'pos.to']    <- ceiling(x$seq.breaks[sb.to] + cc[2] - 1)
+      y[i, 'seq.name']  <- x$pos.names[i]
     }
   }
 
   return(y)
-  ### Returns a data.frame with four columns: name.from (character), pos.from
-  ### (numeric) name.to (character), and pos.to (numeric). The first two
-  ### correspond to sequence and position of the start point of the bin, the
-  ### last two correspond to the sequence and position of the end point of the
-  ### bin.
 }
 
+#' Enveomics: Recruitment Plot (2) Sequencing Depth
+#'
+#' Calculate the sequencing depth of the given window(s).
+#'
+#' @param x
+#' \code{\link{enve.RecPlot2}} object.
+#' @param sel
+#' Window(s) for which the sequencing depth is to be calculated. If not
+#' passed, it returns the sequencing depth of all windows.
+#' @param low.identity
+#' A logical indicating if the sequencing depth is to be estimated only
+#' with low-identity matches. By default, only high-identity matches are
+#' used.
+#'
+#' @return
+#' Returns a numeric vector of sequencing depths (in bp/bp).
+#'
+#' @author Luis M. Rodriguez-R [aut, cre]
+#'
+#' @export
+
 enve.recplot2.seqdepth <- function
-  ### Calculate the sequencing depth of the given window(s)
-    (x,
-    ### `enve.RecPlot2` object.
-    sel,
-    ### Window(s) for which the sequencing depth is to be calculated. If not
-    ### passed, it returns the sequencing depth of all windows
-    low.identity=FALSE
-    ### A logical indicating if the sequencing depth is to be estimated only
-    ### with low-identity matches. By default, only high-identity matches are
-    ### used.
-    ){
+
+(x,
+ sel,
+ low.identity=FALSE
+){
   if(!inherits(x, "enve.RecPlot2"))
     stop("'x' must inherit from class `enve.RecPlot2`")
   if(low.identity){
@@ -997,21 +1292,30 @@ enve.recplot2.seqdepth <- function
   seqdepth.in <- pos.cnts.in/pos.binsize
   if(missing(sel)) return(seqdepth.in)
   return(seqdepth.in[sel])
-  ### Returns a numeric vector of sequencing depths (in bp/bp). 
 }
 
+#' Enveomics: Recruitment Plot (2) ANI Estimate
+#'
+#' Estimate the Average Nucleotide Identity from reads (ANIr) from a
+#' recruitment plot.
+#'
+#' @param x
+#' \code{\link{enve.RecPlot2}} object.
+#' @param range
+#' Range of identities to be considered. By default, the full range
+#' is used (note that the upper boundary is \code{Inf} and not 100 because
+#' recruitment plots can also be built with bit-scores). To use only
+#' intra-population matches (with identities), use c(95,100). To use only
+#' inter-population values, use c(0,95).
+#'
+#' @author Luis M. Rodriguez-R [aut, cre]
+#'
+#' @export
+
 enve.recplot2.ANIr <- function
-  ### Estimate the Average Nucleotide Identity from reads (ANIr) from a
-  ### recruitment plot
-    (x,
-    ### `enve.RecPlot2` object.
-    range=c(0,Inf)
-    ### Range of identities to be considered. By default, the full range
-    ### is used (note that the upper boundary is `Inf` and not 100 because
-    ### recruitment plots can also be built with bit-scores). To use only
-    ### intra-population matches (with identities), use c(95,100). To use only
-    ### inter-population values, use c(0,95).
-    ){
+(x,
+ range=c(0,Inf)
+){
   if(!inherits(x, "enve.RecPlot2"))
     stop("'x' must inherit from class `enve.RecPlot2`")
   id.b <- x$id.breaks
@@ -1023,35 +1327,82 @@ enve.recplot2.ANIr <- function
 }
 
 #==============> Define internal functions
+
+#' Enveomics: Recruitment Plot (2) Internal Ancillary Function
+#'
+#' Internal ancillary function (see \code{\link{enve.recplot2}}).
+#'
+#' @param x \code{\link{enve.RecPlot2}} object
+#' @param pos.breaks Position breaks
+#' @param id.breaks Identity breaks
+#' @param rec.idcol Identity column to use
+#'
+#' @author Luis M. Rodriguez-R [aut, cre]
+#' @author Kenji Gerhardt [aut]
+#'
+#' @export
+
 enve.recplot2.__counts <- function
-   ### Internal ancilliary function (see `enve.recplot2`).
-      (x, pos.breaks, id.breaks, rec.idcol){
-   rec <- x$rec
-   verbose <- x$verbose
-   counts <- matrix(0, nrow=length(pos.breaks)-1, ncol=length(id.breaks)-1);
-   for(i in 1:nrow(rec)){
-      if(verbose & i%%100==0) cat("   [",signif(i*100/nrow(rec),3),"% ]   \r");
-      y.bin <- which(
-	 rec[i,rec.idcol]>=id.breaks[-length(id.breaks)] &
-	 rec[i,rec.idcol]<=id.breaks[-1])[1] ;
-      for(pos in rec[i,1]:rec[i,2]){
-	 x.bin <- which(
-	    pos>=pos.breaks[-length(pos.breaks)] & pos<=pos.breaks[-1])[1] ;
-	 counts[x.bin, y.bin] <- counts[x.bin, y.bin]+1 ;
-      }
-   }
-   return(counts);
+(x, pos.breaks, id.breaks, rec.idcol) {
+  rec2 <- x$rec
+  verbose <- x$verbose
+
+  # get counts of how many occurrences of each genome pos.bin there are per read
+  x.bins <- mapply(
+    function(start, end) {
+      list(rle(findInterval(start:end, pos.breaks, left.open = T)))
+    }, rec2[, 1], rec2[, 2])
+
+  # find the single y bin for each row, replicates it at the correct places to
+  # the number of distinct bins found in its row
+  y.bins <- rep(findInterval(rec2[, rec.idcol], id.breaks, left.open = T),
+                times = unlist(lapply(x.bins, function(a) length(a$lengths))))
+
+  # x.bins_counts is the number of occurrences of each bin a row contains,
+  # per row, then unlisted
+  x.bins_counts <- unlist(lapply(x.bins, function(a) a$lengths))
+
+  # these are the pos. in. genome bins that each count in x.bins_counts falls into
+  x.bins <- unlist(lapply(x.bins, function(a) a$values))
+
+  # much more efficient counts implementation in R using lists instead of a matrix:
+  counts <- lapply(
+    1:(length(pos.breaks) - 1),
+    function(col_len) rep(0, length(id.breaks) - 1))
+
+  # accesses the correct list in counts by x.bin, then
+  # accesses the position in that row by y.bins and adds the new count
+  for(i in 1:length(x.bins)){
+    counts[[x.bins[i]]][y.bins[i]] <- counts[[x.bins[i]]][y.bins[i]] + x.bins_counts[i]
+  }
+
+  counts <- do.call(rbind, counts)
+  return(counts)
 }
 
+#' Enveomics: Recruitment Plot (2) EMauto Peak Finder - Internal Ancillary Function
+#'
+#' Internal ancillary function (see \code{\link{enve.recplot2.findPeaks.emauto}}).
+#'
+#' @param x \code{\link{enve.RecPlot2}} object
+#' @param comp Components
+#' @param do_crit Function estimating the criterion
+#' @param best Best solution thus far
+#' @param verbose If verbose
+#' @param ... Additional parameters for \code{\link{enve.recplot2.findPeaks.em}}
+#'
+#' @author Luis M. Rodriguez-R [aut, cre]
+#'
+#' @export
+
 enve.recplot2.findPeaks.__emauto_one <- function
-  ### Internal ancilliary function (see `enve.recplot2.findPeaks.emauto).
-    (x, comp, do_crit, best, verbose, ...){
+(x, comp, do_crit, best, verbose, ...){
   peaks <- enve.recplot2.findPeaks.em(x=x, components=comp, ...)
   if(length(peaks)==0) return(best)
   k <- comp*3 - 1 # mean & sd for each component, and n-1 free alpha parameters
   crit <- do_crit(peaks[[1]]$err.res, k, peaks[[1]]$n.total)
   if(verbose) cat(comp,'\t| LL =', peaks[[1]]$err.res, '\t| Estimate =', crit,
-        ifelse(crit > best[['crit']], '*', ''), '\n')
+                  ifelse(crit > best[['crit']], '*', ''), '\n')
   if(crit > best[['crit']]){
     best[['crit']] <- crit
     best[['peaks']] <- peaks
@@ -1059,148 +1410,217 @@ enve.recplot2.findPeaks.__emauto_one <- function
   best[['pstore']][[comp]] <- peaks
   return(best)
 }
+
+#' Enveomics: Recruitment Plot (2) EM Peak Finder - Internal Ancillary Function Expectation
+#'
+#' Internal ancillary function (see \code{\link{enve.recplot2.findPeaks.em}}).
+#'
+#' @param x Vector of log-transformed sequencing depths
+#' @param theta Parameters list
+#'
+#' @author Luis M. Rodriguez-R [aut, cre]
+#'
+#' @export
+
 enve.recplot2.findPeaks.__em_e <- function
-  ### Internal ancilliary function (see `enve.recplot2.findPeaks.em`).
-    (x, theta){
+(x, theta){
   components <- length(theta[['mu']])
   product <- do.call(cbind,
-        lapply(1:components,
-          function(i) dnorm(x, theta[['mu']][i],
-             theta[['sd']][i])*theta[['alpha']][i]))
+                     lapply(1:components,
+                            function(i) dnorm(x, theta[['mu']][i],
+                                              theta[['sd']][i])*theta[['alpha']][i]))
   sum.of.components <- rowSums(product)
   posterior <- product / sum.of.components
-  
+
   return(list(ll=sum(log(sum.of.components)), posterior=posterior))
 }
 
+#' Enveomics: Recruitment Plot (2) Em Peak Finder - Internal Ancillary Function Maximization
+#'
+#' Internal ancillary function (see \code{\link{enve.recplot2.findPeaks.em}}).
+#'
+#' @param x Vector of log-transformed sequencing depths
+#' @param posterior Posterior probability
+#'
+#' @author Luis M. Rodriguez-R [aut, cre]
+#'
+#' @export
+
 enve.recplot2.findPeaks.__em_m <- function
-  ### Internal ancilliary function (see `enve.recplot2.findPeaks.em`
-    (x, posterior){
+(x, posterior){
   components <- ncol(posterior)
   n <- colSums(posterior)
   mu <- colSums(posterior * x) / n
   sd <- sqrt( colSums(
-        posterior * (matrix(rep(x,components), ncol=components) - mu)^2) / n )
+    posterior * (matrix(rep(x,components), ncol=components) - mu)^2) / n )
   alpha <- n/length(x)
   return(list(mu=mu, sd=sd, alpha=alpha))
 }
 
+#' Enveomics: Recruitment Plot (2) Peak S4 Class - Internal Ancillary Function
+#'
+#' Internal ancillary function (see \code{\link{enve.RecPlot2.Peak}}).
+#'
+#' @param x \code{\link{enve.RecPlot2.Peak}} object
+#' @param mids Midpoints
+#' @param counts Counts
+#'
+#' @author Luis M. Rodriguez-R [aut, cre]
+#'
+#' @export
+
 enve.recplot2.__peakHist <- function
-   ### Internal ancilliary function (see `enve.RecPlot2.Peak`).
-      (x, mids, counts=TRUE){
-   d.o <- x$param.hat
-   if(length(x$log)==0) x$log <- FALSE
-   if(x$log){
-     d.o$x <- log(mids)
-   }else{
-     d.o$x <- mids
-   }
-   prob  <- do.call(paste('d', x$dist, sep=''), d.o)
-   if(!counts) return(prob)
-   if(length(x$values)>0) return(prob*length(x$values)/sum(prob))
-   return(prob*x$n.hat/sum(prob))
+(x, mids, counts=TRUE){
+  d.o <- x$param.hat
+  if(length(x$log)==0) x$log <- FALSE
+  if(x$log){
+    d.o$x <- log(mids)
+  }else{
+    d.o$x <- mids
+  }
+  prob  <- do.call(paste('d', x$dist, sep=''), d.o)
+  if(!counts) return(prob)
+  if(length(x$values)>0) return(prob*length(x$values)/sum(prob))
+  return(prob*x$n.hat/sum(prob))
 }
 
+#' Enveomics: Recruitment Plot (2) Mowing Peak Finder - Internal Ancillary Function 1
+#'
+#' Internall ancillary function (see \code{\link{enve.recplot2.findPeaks.mower}}).
+#'
+#' @param lsd1 Vector of log-transformed sequencing depths
+#' @param min.points Minimum number of points
+#' @param quant.est Quantile estimate
+#' @param mlv.opts List of options for \code{mlv}
+#' @param fitdist.opts List of options for \code{fitdist}
+#' @param with.skewness If skewed-normal should be used
+#' @param optim.rounds Maximum number of optimization rounds
+#' @param optim.epsilon Minimum difference considered negligible
+#' @param n.total Global number of windows
+#' @param merge.logdist Attempted \code{merge.logdist} parameter
+#' @param verbose If verbose
+#' @param log If log-transformed depths
+#'
+#' @author Luis M. Rodriguez-R [aut, cre]
+#'
+#' @export
+
 enve.recplot2.findPeaks.__mow_one <- function
-   ### Internall ancilliary function (see `enve.recplot2.findPeaks.mower`).
-      (lsd1, min.points, quant.est, mlv.opts, fitdist.opts, with.skewness,
-      optim.rounds, optim.epsilon, n.total, merge.logdist, verbose, log
-   ){
-   dist	<- ifelse(with.skewness, 'sn', 'norm');
-   
-   # Find peak
-   o <- mlv.opts; o$x = lsd1;
-   mode1 <- median(lsd1); # mode1 <- do.call(mlv, o)$M;
-   if(verbose) cat('Anchoring at mode =',mode1,'\n')
-   param.hat <- fitdist.opts$start; last.hat <- param.hat;
-   lim <- NA;
-   if(with.skewness){ param.hat$xi <- mode1 }else{ param.hat$mean <- mode1 }
-   
-   # Refine peak parameters
-   for(round in 1:optim.rounds){
-      param.hat[[ 1 ]] <- param.hat[[ 1 ]]/diff(quant.est)# <- expand dispersion
-      lim.o <- param.hat
-      lim.o$p <- quant.est; lim <- do.call(paste('q',dist,sep=''), lim.o)
-      lsd1.pop <- lsd1[(lsd1>lim[1]) & (lsd1<lim[2])];
-      if(verbose) cat(' Round', round, 'with n =',length(lsd1.pop),
-	    'and params =',as.numeric(param.hat),' \r')
-      if(length(lsd1.pop) < min.points) break;
-      o <- fitdist.opts; o$data = lsd1.pop; o$start = param.hat;
-      last.last.hat <- last.hat
-      last.hat <- param.hat
-      param.hat <- as.list(do.call(fitdist, o)$estimate);
-      if(any(is.na(param.hat))){
-	 if(round>1) param.hat <- last.hat;
-	 break;
-      }
-      if(round > 1){
-        epsilon1 <- sum((as.numeric(last.hat)-as.numeric(param.hat))^2)
-        if(epsilon1 < optim.epsilon) break;
-        if(round > 2){
-          epsilon2 <- sum((as.numeric(last.last.hat)-as.numeric(param.hat))^2)
-          if(epsilon2 < optim.epsilon) break;
-        }
+(lsd1, min.points, quant.est, mlv.opts, fitdist.opts, with.skewness,
+ optim.rounds, optim.epsilon, n.total, merge.logdist, verbose, log
+){
+  dist	<- ifelse(with.skewness, 'sn', 'norm');
+
+  # Find peak
+  o <- mlv.opts; o$x = lsd1;
+  mode1 <- median(lsd1); # mode1 <- do.call(mlv, o)$M;
+  if(verbose) cat('Anchoring at mode =',mode1,'\n')
+  param.hat <- fitdist.opts$start; last.hat <- param.hat;
+  lim <- NA;
+  if(with.skewness){ param.hat$xi <- mode1 }else{ param.hat$mean <- mode1 }
+
+  # Refine peak parameters
+  for(round in 1:optim.rounds){
+    param.hat[[ 1 ]] <- param.hat[[ 1 ]]/diff(quant.est)# <- expand dispersion
+    lim.o <- param.hat
+    lim.o$p <- quant.est; lim <- do.call(paste('q',dist,sep=''), lim.o)
+    lsd1.pop <- lsd1[(lsd1>lim[1]) & (lsd1<lim[2])];
+    if(verbose) cat(' Round', round, 'with n =',length(lsd1.pop),
+                    'and params =',as.numeric(param.hat),' \r')
+    if(length(lsd1.pop) < min.points) break;
+    o <- fitdist.opts; o$data = lsd1.pop; o$start = param.hat;
+    last.last.hat <- last.hat
+    last.hat <- param.hat
+    param.hat <- as.list(do.call(fitdist, o)$estimate);
+    if(any(is.na(param.hat))){
+      if(round>1) param.hat <- last.hat;
+      break;
+    }
+    if(round > 1){
+      epsilon1 <- sum((as.numeric(last.hat)-as.numeric(param.hat))^2)
+      if(epsilon1 < optim.epsilon) break;
+      if(round > 2){
+        epsilon2 <- sum((as.numeric(last.last.hat)-as.numeric(param.hat))^2)
+        if(epsilon2 < optim.epsilon) break;
       }
-   }
-   if(verbose) cat('\n')
-   if(is.na(param.hat[1]) | is.na(lim[1])) return(NULL);
-
-   # Mow distribution
-   lsd2 <- c();
-   lsd.pop <- c();
-   n.hat <- length(lsd1.pop)/diff(quant.est)
-   peak <- new('enve.RecPlot2.Peak', dist=dist, values=as.numeric(), mode=mode1,
-      param.hat=param.hat, n.hat=n.hat, n.total=n.total,
-      merge.logdist=merge.logdist, log=log)
-   peak.breaks <- seq(min(lsd1), max(lsd1), length=20)
-   peak.cnt <- enve.recplot2.__peakHist(peak,
-      (peak.breaks[-length(peak.breaks)]+peak.breaks[-1])/2)
-   for(i in 2:length(peak.breaks)){
-      values <- lsd1[ (lsd1 >= peak.breaks[i-1]) & (lsd1 < peak.breaks[i]) ]
-      n.exp <- peak.cnt[i-1]
-      if(is.na(n.exp) | n.exp==0) n.exp <- 0.1
-      if(length(values)==0) next
-      in.peak <- runif(length(values)) <= n.exp/length(values)
-      lsd2 <- c(lsd2, values[!in.peak])
-      lsd.pop <- c(lsd.pop, values[in.peak])
-   }
-   if(length(lsd.pop) < min.points) return(NULL)
-
-   # Return peak
-   attr(peak, 'values') <- lsd.pop
-   attr(peak, 'values.res') <- lsd2
-   attr(peak, 'err.res') <- 1-(cor(hist(lsd.pop, breaks=peak.breaks,
-      plot=FALSE)$counts, hist(lsd1, breaks=peak.breaks,
-      plot=FALSE)$counts)+1)/2
-   mu <- tail(param.hat, n=1)
-   attr(peak, 'seq.depth') <- ifelse(log, exp(mu), mu)
-   if(verbose) cat(' Extracted peak with n =',length(lsd.pop),
-	 'with expected n =',n.hat,'\n')
-   return(peak)
+    }
+  }
+  if(verbose) cat('\n')
+  if(is.na(param.hat[1]) | is.na(lim[1])) return(NULL);
+
+  # Mow distribution
+  lsd2 <- c();
+  lsd.pop <- c();
+  n.hat <- length(lsd1.pop)/diff(quant.est)
+  peak <- new('enve.RecPlot2.Peak', dist=dist, values=as.numeric(), mode=mode1,
+              param.hat=param.hat, n.hat=n.hat, n.total=n.total,
+              merge.logdist=merge.logdist, log=log)
+  peak.breaks <- seq(min(lsd1), max(lsd1), length=20)
+  peak.cnt <- enve.recplot2.__peakHist(peak,
+                                       (peak.breaks[-length(peak.breaks)]+peak.breaks[-1])/2)
+  for(i in 2:length(peak.breaks)){
+    values <- lsd1[ (lsd1 >= peak.breaks[i-1]) & (lsd1 < peak.breaks[i]) ]
+    n.exp <- peak.cnt[i-1]
+    if(is.na(n.exp) | n.exp==0) n.exp <- 0.1
+    if(length(values)==0) next
+    in.peak <- runif(length(values)) <= n.exp/length(values)
+    lsd2 <- c(lsd2, values[!in.peak])
+    lsd.pop <- c(lsd.pop, values[in.peak])
+  }
+  if(length(lsd.pop) < min.points) return(NULL)
+
+  # Return peak
+  attr(peak, 'values') <- lsd.pop
+  attr(peak, 'values.res') <- lsd2
+  attr(peak, 'err.res') <- 1-(cor(hist(lsd.pop, breaks=peak.breaks,
+                                       plot=FALSE)$counts, hist(lsd1, breaks=peak.breaks,
+                                                                plot=FALSE)$counts)+1)/2
+  mu <- tail(param.hat, n=1)
+  attr(peak, 'seq.depth') <- ifelse(log, exp(mu), mu)
+  if(verbose) cat(' Extracted peak with n =',length(lsd.pop),
+                  'with expected n =',n.hat,'\n')
+  return(peak)
 }
 
+#' Enveomics: Recruitment Plot (2) Mowing Peak Finder - Internal Ancillary Function 2
+#'
+#' Internal ancillary function (see \code{\link{enve.recplot2.findPeaks.mower}}).
+#'
+#' @param peaks.opts List of options for \code{\link{enve.recplot2.findPeaks.__mow_one}}
+#'
+#' @author Luis M. Rodriguez-R [aut, cre]
+#'
+#' @export
+
 enve.recplot2.findPeaks.__mower <- function
-   ### Internal ancilliary function (see `enve.recplot2.findPeaks.mower`).
-      (peaks.opts){
-   peaks <- list()
-   while(length(peaks.opts$lsd1) > peaks.opts$min.points){
-      peak <- do.call(enve.recplot2.findPeaks.__mow_one, peaks.opts)
-      if(is.null(peak)) break
-      peaks[[ length(peaks)+1 ]] <- peak
-      peaks.opts$lsd1 <- peak$values.res
-   }
-   return(peaks)
+(peaks.opts){
+  peaks <- list()
+  while(length(peaks.opts$lsd1) > peaks.opts$min.points){
+    peak <- do.call(enve.recplot2.findPeaks.__mow_one, peaks.opts)
+    if(is.null(peak)) break
+    peaks[[ length(peaks)+1 ]] <- peak
+    peaks.opts$lsd1 <- peak$values.res
+  }
+  return(peaks)
 }
 
+#' Enveomics: Recruitment Plot (2) Peak Finder - Internal Ancillary Function
+#'
+#' Internal ancillary function (see \code{\link{enve.recplot2.findPeaks}}).
+#'
+#' @param peak Query \code{\link{enve.RecPlot2.Peak}} object
+#' @param peaks list of \code{\link{enve.RecPlot2.Peak}} objects
+#'
+#' @author Luis M. Rodriguez-R [aut, cre]
+#'
+#' @export
 
 enve.recplot2.__whichClosestPeak <- function
-   ### Internal ancilliary function (see `enve.recplot2.findPeaks`).
-      (peak, peaks){
-   dist <- as.numeric(lapply(peaks,
-         function(x)
-           abs(log(x$param.hat[[ length(x$param.hat) ]] /
-             peak$param.hat[[ length(peak$param.hat) ]] ))))
-   dist[ dist==0 ] <- Inf
-   return(which.min(dist))
+(peak, peaks){
+  dist <- as.numeric(lapply(peaks,
+                            function(x)
+                              abs(log(x$param.hat[[ length(x$param.hat) ]] /
+                                        peak$param.hat[[ length(peak$param.hat) ]] ))))
+  dist[ dist==0 ] <- Inf
+  return(which.min(dist))
 }
-