Search is not available for this dataset
text stringlengths 75 104k |
|---|
def filter_all_clusters(data, samples, ipyclient):
"""
Open the clust_database HDF5 array with seqs, catg, and filter data.
Fill the remaining filters.
"""
## create loadbalanced ipyclient
lbview = ipyclient.load_balanced_view()
## get chunk size from the HD5 array and close
with h5py.... |
def padnames(names):
""" pads names for loci output """
## get longest name
longname_len = max(len(i) for i in names)
## Padding distance between name and seq.
padding = 5
## add pad to names
pnames = [name + " " * (longname_len - len(name)+ padding) \
for name in names]
s... |
def make_loci_and_stats(data, samples, ipyclient):
"""
Makes the .loci file from h5 data base. Iterates by optim loci at a
time and write to file. Also makes alleles file if requested.
"""
## start vcf progress bar
start = time.time()
printstr = " building loci/stats | {} | s7 |"
elaps... |
def locichunk(args):
"""
Function from make_loci to apply to chunks. smask is sample mask.
"""
## parse args
data, optim, pnames, snppad, smask, start, samplecov, locuscov, upper = args
## this slice
hslice = [start, start+optim]
## get filter db info
co5 = h5py.File(data.database,... |
def enter_pairs(iloc, pnames, snppad, edg, aseqs, asnps, smask, samplecov, locuscov, start):
""" enters funcs for pairs """
## snps was created using only the selected samples.
LOGGER.info("edges in enter_pairs %s", edg)
seq1 = aseqs[iloc, :, edg[0]:edg[1]+1]
snp1 = asnps[iloc, edg[0]:edg[1]+1, ]
... |
def enter_singles(iloc, pnames, snppad, edg, aseqs, asnps, smask, samplecov, locuscov, start):
""" enter funcs for SE or merged data """
## grab all seqs between edges
seq = aseqs[iloc, :, edg[0]:edg[1]+1]
## snps was created using only the selected samples, and is edge masked.
## The mask is for c... |
def init_arrays(data):
"""
Create database file for storing final filtered snps data as hdf5 array.
Copies splits and duplicates info from clust_database to database.
"""
## get stats from step6 h5 and create new h5
co5 = h5py.File(data.clust_database, 'r')
io5 = h5py.File(data.database, 'w... |
def filter_stacks(data, sidx, hslice):
"""
Grab a chunk of loci from the HDF5 database. Apply filters and fill the
the filters boolean array.
The design of the filtering steps intentionally sacrifices some performance
for an increase in readability, and extensibility. Calling multiple filter
fu... |
def get_edges(data, superints, splits):
"""
Gets edge trimming based on the overlap of sequences at the edges of
alignments and the tuple arg passed in for edge_trimming. Trims as
(R1 left, R1 right, R2 left, R2 right). We also trim off the restriction
site if it present. This modifies superints, an... |
def filter_minsamp(data, superints):
"""
Filter minimum # of samples per locus from superseqs[chunk]. The shape
of superseqs is [chunk, sum(sidx), maxlen]
"""
## global minsamp
minsamp = data.paramsdict["min_samples_locus"]
## use population minsamps
if data.populations:
## data... |
def ucount(sitecol):
"""
Used to count the number of unique bases in a site for snpstring.
returns as a spstring with * and -
"""
## a list for only catgs
catg = [i for i in sitecol if i in "CATG"]
## find sites that are ambigs
where = [sitecol[sitecol == i] for i in "RSKYWM"]
## ... |
def filter_maxsnp(data, superints, edgearr):
"""
Filter max # of SNPs per locus. Do R1 and R2 separately if PE.
Also generate the snpsite line for the .loci format and save in the snp arr
This uses the edge filters that have been built based on trimming, and
saves the snps array with edges filtered.... |
def snpcount_numba(superints, snpsarr):
"""
Used to count the number of unique bases in a site for snpstring.
"""
## iterate over all loci
for iloc in xrange(superints.shape[0]):
for site in xrange(superints.shape[2]):
## make new array
catg = np.zeros(4, dtype=np.in... |
def filter_maxhet(data, superints, edgearr):
"""
Filter max shared heterozygosity per locus. The dimensions of superseqs
are (chunk, sum(sidx), maxlen). Don't need split info since it applies to
entire loci based on site patterns (i.e., location along the seq doesn't
matter.) Current implementation ... |
def filter_indels(data, superints, edgearr):
"""
Filter max indels. Needs to split to apply to each read separately.
The dimensions of superseqs are (chunk, sum(sidx), maxlen).
"""
maxinds = np.array(data.paramsdict["max_Indels_locus"]).astype(np.int64)
## an empty array to fill with failed lo... |
def maxind_numba(block):
""" filter for indels """
## remove terminal edges
inds = 0
for row in xrange(block.shape[0]):
where = np.where(block[row] != 45)[0]
if len(where) == 0:
obs = 100
else:
left = np.min(where)
right = np.max(where)
... |
def make_outfiles(data, samples, output_formats, ipyclient):
"""
Get desired formats from paramsdict and write files to outfiles
directory.
"""
## will iterate optim loci at a time
with h5py.File(data.clust_database, 'r') as io5:
optim = io5["seqs"].attrs["chunksize"][0]
nloci =... |
def worker_make_arrays(data, sidx, hslice, optim, maxlen):
"""
Parallelized worker to build array chunks for output files. One main
goal here is to keep seqarr to less than ~1GB RAM.
"""
## big data arrays
io5 = h5py.File(data.clust_database, 'r')
co5 = h5py.File(data.database, 'r')
... |
def write_phy(data, sidx, pnames):
"""
write the phylip output file from the tmparr[seqarray]
"""
## grab seq data from tmparr
start = time.time()
tmparrs = os.path.join(data.dirs.outfiles, "tmp-{}.h5".format(data.name))
with h5py.File(tmparrs, 'r') as io5:
seqarr = io5["seqarr"]... |
def write_nex(data, sidx, pnames):
"""
write the nexus output file from the tmparr[seqarray] and tmparr[maparr]
"""
## grab seq data from tmparr
start = time.time()
tmparrs = os.path.join(data.dirs.outfiles, "tmp-{}.h5".format(data.name))
with h5py.File(tmparrs, 'r') as io5:
s... |
def write_snps_map(data):
""" write a map file with linkage information for SNPs file"""
## grab map data from tmparr
start = time.time()
tmparrs = os.path.join(data.dirs.outfiles, "tmp-{}.h5".format(data.name))
with h5py.File(tmparrs, 'r') as io5:
maparr = io5["maparr"][:]
## get... |
def write_usnps(data, sidx, pnames):
""" write the bisnp string """
## grab bis data from tmparr
tmparrs = os.path.join(data.dirs.outfiles, "tmp-{}.h5".format(data.name))
with h5py.File(tmparrs, 'r') as io5:
bisarr = io5["bisarr"]
## trim to size b/c it was made longer than actual
... |
def write_str(data, sidx, pnames):
""" Write STRUCTURE format for all SNPs and unlinked SNPs """
## grab snp and bis data from tmparr
start = time.time()
tmparrs = os.path.join(data.dirs.outfiles, "tmp-{}.h5".format(data.name))
with h5py.File(tmparrs, 'r') as io5:
snparr = io5["snparr"]
... |
def write_geno(data, sidx):
"""
write the geno output formerly used by admixture, still supported by
adegenet, perhaps. Also, sNMF still likes .geno.
"""
## grab snp and bis data from tmparr
start = time.time()
tmparrs = os.path.join(data.dirs.outfiles, "tmp-{}.h5".format(data.name))
... |
def write_gphocs(data, sidx):
"""
write the g-phocs output. This code is hella ugly bcz it's copy/pasted
directly from the old loci2gphocs script from pyrad. I figure having it
get done the stupid way is better than not having it done at all, at
least for the time being. This could probably be sped ... |
def make_vcf(data, samples, ipyclient, full=0):
"""
Write the full VCF for loci passing filtering. Other vcf formats are
possible, like SNPs-only, or with filtered loci included but the filter
explicitly labeled. These are not yet supported, however.
"""
## start vcf progress bar
start = tim... |
def concat_vcf(data, names, full):
"""
Sorts, concatenates, and gzips VCF chunks. Also cleans up chunks.
"""
## open handle and write headers
if not full:
writer = open(data.outfiles.vcf, 'w')
else:
writer = gzip.open(data.outfiles.VCF, 'w')
vcfheader(data, names, writer)
... |
def vcfchunk(data, optim, sidx, chunk, full):
"""
Function called within make_vcf to run chunks on separate engines.
"""
## empty array to be filled before writing
## will not actually be optim*maxlen, extra needs to be trimmed
maxlen = data._hackersonly["max_fragment_length"] + 20
## get d... |
def reftrick(iseq, consdict):
""" Returns the most common base at each site in order. """
altrefs = np.zeros((iseq.shape[1], 4), dtype=np.uint8)
altrefs[:, 1] = 46
for col in xrange(iseq.shape[1]):
## expand colums with ambigs and remove N-
fcounts = np.zeros(111, dtype=np.int64)
... |
def vcfheader(data, names, ofile):
"""
Prints header for vcf files
"""
## choose reference string
if data.paramsdict["reference_sequence"]:
reference = data.paramsdict["reference_sequence"]
else:
reference = "pseudo-reference (most common base at site)"
##FILTER=<ID=minCov,... |
def loci2bpp(name, locifile, imap, guidetree,
minmap=None,
maxloci=None,
infer_sptree=0,
infer_delimit=0,
delimit_alg=(0, 5),
seed=12345,
burnin=1000,
nsample=10000,
sampfreq=2,
thetaprior=(5, 5),
tauprior=(4, 2, 1),
traits_df=None,
nu=0,
kappa=0,
useseqdata=1... |
def write_ctl(name, imap, guidetree, nloci,
infer_sptree, infer_delimit, delimit_alg,
seed, burnin, nsample, sampfreq,
thetaprior, tauprior, traits_df, nu0, kappa0,
cleandata, useseqdata, usetraitdata, wdir,
finetune, verbose):
""" write outfile... |
def _collapse_outgroup(tree, taxdicts):
""" collapse outgroup in ete Tree for easier viewing """
## check that all tests have the same outgroup
outg = taxdicts[0]["p4"]
if not all([i["p4"] == outg for i in taxdicts]):
raise Exception("no good")
## prune tree, keep only one sample from ou... |
def _decompose_tree(ttree, orient='right', use_edge_lengths=True):
""" decomposes tree into component parts for plotting """
## set attributes
ttree._orient = orient
ttree._use_edge_lengths = use_edge_lengths
ult = use_edge_lengths == False
## map numeric values to internal nodes from root to... |
def draw(
self,
show_tip_labels=True,
show_node_support=False,
use_edge_lengths=False,
orient="right",
print_args=False,
*args,
**kwargs):
"""
plot the tree using toyplot.graph.
Parameters:
-----------
show_... |
def tree_panel_plot(ttree,
print_args=False,
*args,
**kwargs):
"""
signature...
"""
## create Panel plot object and set height & width
panel = Panel(ttree) #tree, edges, verts, names)
if not kwargs.get("width"):
panel.kwargs["width"] = min(1000, 25*len(panel.tree))... |
def get_quick_depths(data, sample):
""" iterate over clustS files to get data """
## use existing sample cluster path if it exists, since this
## func can be used in step 4 and that can occur after merging
## assemblies after step3, and if we then referenced by data.dirs.clusts
## the path would be... |
def sample_cleanup(data, sample):
""" stats, cleanup, and link to samples """
## get maxlen and depths array from clusters
maxlens, depths = get_quick_depths(data, sample)
try:
depths.max()
except ValueError:
## If depths is an empty array max() will raise
print(" no clu... |
def persistent_popen_align3(clusts, maxseqs=200, is_gbs=False):
""" keeps a persistent bash shell open and feeds it muscle alignments """
## create a separate shell for running muscle in, this is much faster
## than spawning a separate subprocess for each muscle call
proc = sps.Popen(["bash"],
... |
def gbs_trim(align1):
"""
No reads can go past the left of the seed, or right of the least extended
reverse complement match. Example below. m is a match. u is an area where
lots of mismatches typically occur. The cut sites are shown.
Original locus*
Seed TGCAG*******************... |
def align_and_parse(handle, max_internal_indels=5, is_gbs=False):
""" much faster implementation for aligning chunks """
## data are already chunked, read in the whole thing. bail if no data.
try:
with open(handle, 'rb') as infile:
clusts = infile.read().split("//\n//\n")
##... |
def aligned_indel_filter(clust, max_internal_indels):
""" checks for too many internal indels in muscle aligned clusters """
## make into list
lclust = clust.split()
## paired or not
try:
seq1 = [i.split("nnnn")[0] for i in lclust[1::2]]
seq2 = [i.split("nnnn")[1] for i in lclu... |
def build_clusters(data, sample, maxindels):
"""
Combines information from .utemp and .htemp files to create .clust files,
which contain un-aligned clusters. Hits to seeds are only kept in the
cluster if the number of internal indels is less than 'maxindels'.
By default, we set maxindels=6 for this ... |
def setup_dirs(data):
""" sets up directories for step3 data """
## make output folder for clusters
pdir = os.path.realpath(data.paramsdict["project_dir"])
data.dirs.clusts = os.path.join(pdir, "{}_clust_{}"\
.format(data.name, data.paramsdict["clust_threshold"]))
if not os.pa... |
def new_apply_jobs(data, samples, ipyclient, nthreads, maxindels, force):
"""
Create a DAG of prealign jobs to be run in order for each sample. Track
Progress, report errors. Each assembly method has a slightly different
DAG setup, calling different functions.
"""
## is datatype gbs? used in al... |
def build_dag(data, samples):
"""
build a directed acyclic graph describing jobs to be run in order.
"""
## Create DAGs for the assembly method being used, store jobs in nodes
snames = [i.name for i in samples]
dag = nx.DiGraph()
## get list of pre-align jobs from globals based on assembly... |
def _plot_dag(dag, results, snames):
"""
makes plot to help visualize the DAG setup. For developers only.
"""
try:
import matplotlib.pyplot as plt
from matplotlib.dates import date2num
from matplotlib.cm import gist_rainbow
## first figure is dag layout
plt.figur... |
def trackjobs(func, results, spacer):
"""
Blocks and prints progress for just the func being requested from a list
of submitted engine jobs. Returns whether any of the jobs failed.
func = str
results = dict of asyncs
"""
## TODO: try to insert a better way to break on KBD here.
LOGGER.... |
def declone_3rad(data, sample):
"""
3rad uses random adapters to identify pcr duplicates. We will
remove pcr dupes here. Basically append the radom adapter to
each sequence, do a regular old vsearch derep, then trim
off the adapter, and push it down the pipeline. This will
remove all identical s... |
def derep_and_sort(data, infile, outfile, nthreads):
"""
Dereplicates reads and sorts so reads that were highly replicated are at
the top, and singletons at bottom, writes output to derep file. Paired
reads are dereplicated as one concatenated read and later split again.
Updated this function to tak... |
def data_cleanup(data):
""" cleanup / statswriting function for Assembly obj """
data.stats_dfs.s3 = data._build_stat("s3")
data.stats_files.s3 = os.path.join(data.dirs.clusts, "s3_cluster_stats.txt")
with io.open(data.stats_files.s3, 'w') as outfile:
data.stats_dfs.s3.to_string(
buf... |
def concat_multiple_edits(data, sample):
"""
if multiple fastq files were appended into the list of fastqs for samples
then we merge them here before proceeding.
"""
## if more than one tuple in fastq list
if len(sample.files.edits) > 1:
## create a cat command to append them all (doesn... |
def cluster(data, sample, nthreads, force):
"""
Calls vsearch for clustering. cov varies by data type, values were chosen
based on experience, but could be edited by users
"""
## get the dereplicated reads
if "reference" in data.paramsdict["assembly_method"]:
derephandle = os.path.join(... |
def muscle_chunker(data, sample):
"""
Splits the muscle alignment into chunks. Each chunk is run on a separate
computing core. Because the largest clusters are at the beginning of the
clusters file, assigning equal clusters to each file would put all of the
large cluster, that take longer to align... |
def reconcat(data, sample):
""" takes aligned chunks (usually 10) and concatenates them """
try:
## get chunks
chunks = glob.glob(os.path.join(data.tmpdir,
sample.name+"_chunk_[0-9].aligned"))
## sort by chunk number, cuts off last 8 =(aligned)
chunks.sort(key=... |
def derep_concat_split(data, sample, nthreads, force):
"""
Running on remote Engine. Refmaps, then merges, then dereplicates,
then denovo clusters reads.
"""
## report location for debugging
LOGGER.info("INSIDE derep %s", sample.name)
## MERGED ASSEMBIES ONLY:
## concatenate edits file... |
def run(data, samples, noreverse, maxindels, force, ipyclient):
""" run the major functions for clustering within samples """
## list of samples to submit to queue
subsamples = []
## if sample is already done skip
for sample in samples:
## If sample not in state 2 don't try to cluster it.
... |
def parse_params(args):
""" Parse the params file args, create and return Assembly object."""
## check that params.txt file is correctly formatted.
try:
with open(args.params) as paramsin:
plines = paramsin.readlines()
except IOError as _:
sys.exit(" No params file found")
... |
def showstats(parsedict):
""" loads assembly or dies, and print stats to screen """
#project_dir = parsedict['1']
project_dir = parsedict["project_dir"]
if not project_dir:
project_dir = "./"
## Be nice if somebody also puts in the file extension
#assembly_name = parsedict['0']
asse... |
def branch_assembly(args, parsedict):
"""
Load the passed in assembly and create a branch. Copy it
to a new assembly, and also write out the appropriate params.txt
"""
## Get the current assembly
data = getassembly(args, parsedict)
## get arguments to branch command
bargs = args.bran... |
def merge_assemblies(args):
"""
merge all given assemblies into a new assembly. Copies the params
from the first passed in extant assembly. this function is called
with the ipyrad -m flag. You must pass it at least 3 values, the first
is a new assembly name (a new `param-newname.txt` will be creat... |
def getassembly(args, parsedict):
"""
loads assembly or creates a new one and set its params from
parsedict. Does not launch ipcluster.
"""
## Creating an assembly with a full path in the name will "work"
## but it is potentially dangerous, so here we have assembly_name
## and assembly_f... |
def _check_version():
""" Test if there's a newer version and nag the user to upgrade."""
import urllib2
from distutils.version import LooseVersion
header = \
"\n -------------------------------------------------------------"+\
"\n ipyrad [v.{}]".format(ip.__version__)+\
"\n Interactive a... |
def main():
""" main function """
## turn off traceback for the CLI
ip.__interactive__ = 0
## Check for a new version on anaconda
_check_version()
## parse params file input (returns to stdout if --help or --version)
args = parse_command_line()
## Turn the debug output written to ipyr... |
def get_binom(base1, base2, estE, estH):
"""
return probability of base call
"""
prior_homo = (1. - estH) / 2.
prior_hete = estH
## calculate probs
bsum = base1 + base2
hetprob = scipy.misc.comb(bsum, base1)/(2. **(bsum))
homoa = scipy.stats.binom.pmf(base2, bsum, estE)... |
def removerepeats(consens, arrayed):
"""
Checks for interior Ns in consensus seqs and removes those that are at
low depth, here defined as less than 1/3 of the average depth. The prop 1/3
is chosen so that mindepth=6 requires 2 base calls that are not in [N,-].
"""
## default trim no edges
... |
def newconsensus(data, sample, tmpchunk, optim):
"""
new faster replacement to consensus
"""
## do reference map funcs?
isref = "reference" in data.paramsdict["assembly_method"]
## temporarily store the mean estimates to Assembly
data._este = data.stats.error_est.mean()
data._esth = d... |
def basecaller(arrayed, mindepth_majrule, mindepth_statistical, estH, estE):
"""
call all sites in a locus array.
"""
## an array to fill with consensus site calls
cons = np.zeros(arrayed.shape[1], dtype=np.uint8)
cons.fill(78)
arr = arrayed.view(np.uint8)
## iterate over columns
... |
def nfilter1(data, reps):
""" applies read depths filter """
if sum(reps) >= data.paramsdict["mindepth_majrule"] and \
sum(reps) <= data.paramsdict["maxdepth"]:
return 1
else:
return 0 |
def nfilter4(consens, hidx, arrayed):
""" applies max haplotypes filter returns pass and consens"""
## if less than two Hs then there is only one allele
if len(hidx) < 2:
return consens, 1
## store base calls for hetero sites
harray = arrayed[:, hidx]
## remove any reads that have N o... |
def storealleles(consens, hidx, alleles):
""" store phased allele data for diploids """
## find the first hetero site and choose the priority base
## example, if W: then priority base in A and not T. PRIORITY=(order: CATG)
bigbase = PRIORITY[consens[hidx[0]]]
## find which allele has priority based... |
def cleanup(data, sample, statsdicts):
"""
cleaning up. optim is the size (nloci) of tmp arrays
"""
LOGGER.info("in cleanup for: %s", sample.name)
isref = 'reference' in data.paramsdict["assembly_method"]
## collect consens chunk files
combs1 = glob.glob(os.path.join(
... |
def chunk_clusters(data, sample):
""" split job into bits and pass to the client """
## counter for split job submission
num = 0
## set optim size for chunks in N clusters. The first few chunks take longer
## because they contain larger clusters, so we create 4X as many chunks as
## processors... |
def get_subsamples(data, samples, force):
"""
Apply state, ncluster, and force filters to select samples to be run.
"""
subsamples = []
for sample in samples:
if not force:
if sample.stats.state >= 5:
print("""\
Skipping Sample {}; Already has consens reads. ... |
def run(data, samples, force, ipyclient):
""" checks if the sample should be run and passes the args """
## prepare dirs
data.dirs.consens = os.path.join(data.dirs.project, data.name+"_consens")
if not os.path.exists(data.dirs.consens):
os.mkdir(data.dirs.consens)
## zap any tmp files that ... |
def calculate_depths(data, samples, lbview):
"""
check whether mindepth has changed, and thus whether clusters_hidepth
needs to be recalculated, and get new maxlen for new highdepth clusts.
if mindepth not changed then nothing changes.
"""
## send jobs to be processed on engines
start = tim... |
def make_chunks(data, samples, lbview):
"""
calls chunk_clusters and tracks progress.
"""
## first progress bar
start = time.time()
printstr = " chunking clusters | {} | s5 |"
elapsed = datetime.timedelta(seconds=int(time.time()-start))
progressbar(10, 0, printstr.format(elapsed), sp... |
def process_chunks(data, samples, lasyncs, lbview):
"""
submit chunks to consens func and ...
"""
## send chunks to be processed
start = time.time()
asyncs = {sample.name:[] for sample in samples}
printstr = " consens calling | {} | s5 |"
## get chunklist from results
for sam... |
def make(data, samples):
""" reads in .loci and builds alleles from case characters """
#read in loci file
outfile = open(os.path.join(data.dirs.outfiles, data.name+".alleles"), 'w')
lines = open(os.path.join(data.dirs.outfiles, data.name+".loci"), 'r')
## Get the longest sample name for prett... |
def make(data, samples):
""" builds snps output """
## get attr
ploidy = data.paramsdict["max_alleles_consens"]
names = [i.name for i in samples]
longname = max([len(i) for i in names])
## TODO: use iter cuz of super huge files
inloci = open(os.path.join(\
data.dirs.outf... |
def cluster_info(ipyclient, spacer=""):
""" reports host and engine info for an ipyclient """
## get engine data, skips busy engines.
hosts = []
for eid in ipyclient.ids:
engine = ipyclient[eid]
if not engine.outstanding:
hosts.append(engine.apply(_socket.gethostname)... |
def _debug_on():
"""
Turns on debugging by creating hidden tmp file
This is only run by the __main__ engine.
"""
## make tmp file and set loglevel for top-level init
with open(__debugflag__, 'w') as dfile:
dfile.write("wat")
__loglevel__ = "DEBUG"
_LOGGER.info("debugging turned o... |
def _set_debug_dict(__loglevel__):
""" set the debug dict """
_lconfig.dictConfig({
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': "%(asctime)s \t"\
+"pid=%(process)d \t"\
+"[%(filename)s]\t"\
... |
def _debug_off():
""" turns off debugging by removing hidden tmp file """
if _os.path.exists(__debugflag__):
_os.remove(__debugflag__)
__loglevel__ = "ERROR"
_LOGGER.info("debugging turned off")
_set_debug_dict(__loglevel__) |
def _cmd_exists(cmd):
""" check if dependency program is there """
return _subprocess.call("type " + cmd,
shell=True,
stdout=_subprocess.PIPE,
stderr=_subprocess.PIPE) == 0 |
def _getbins():
""" gets the right version of vsearch, muscle, and smalt
depending on linux vs osx """
# Return error if system is 32-bit arch.
# This is straight from the python docs:
# https://docs.python.org/2/library/platform.html#cross-platform
if not _sys.maxsize > 2**32:
_sys.exi... |
def nworker(data, chunk):
"""
Worker to distribute work to jit funcs. Wraps everything on an
engine to run single-threaded to maximize efficiency for
multi-processing.
"""
## set the thread limit on the remote engine
oldlimit = set_mkl_thread_limit(1)
## open seqarray view, the modif... |
def store_all(self):
"""
Populate array with all possible quartets. This allows us to
sample from the total, and also to continue from a checkpoint
"""
with h5py.File(self.database.input, 'a') as io5:
fillsets = io5["quartets"]
## generator for all quartet sets
qiter = ite... |
def store_random(self):
"""
Populate array with random quartets sampled from a generator.
Holding all sets in memory might take a lot, but holding a very
large list of random numbers for which ones to sample will fit
into memory for most reasonable sized sets. So we'll load a
list of random nu... |
def store_equal(self):
"""
Takes a tetrad class object and populates array with random
quartets sampled equally among splits of the tree so that
deep splits are not overrepresented relative to rare splits,
like those near the tips.
"""
with h5py.File(self.database.input, 'a') as io5:
... |
def random_combination(nsets, n, k):
"""
Returns nsets unique random quartet sets sampled from
n-choose-k without replacement combinations.
"""
sets = set()
while len(sets) < nsets:
newset = tuple(sorted(np.random.choice(n, k, replace=False)))
sets.add(newset)
return tuple(se... |
def random_product(iter1, iter2):
"""
Random sampler for equal_splits functions
"""
iter4 = np.concatenate([
np.random.choice(iter1, 2, replace=False),
np.random.choice(iter2, 2, replace=False)
])
return iter4 |
def resolve_ambigs(tmpseq):
"""
Randomly resolve ambiguous bases. This is applied to each boot
replicate so that over reps the random resolutions don't matter.
Sites are randomly resolved, so best for unlinked SNPs since
otherwise linked SNPs are losing their linkage information...
though it'... |
def set_mkl_thread_limit(cores):
"""
set mkl thread limit and return old value so we can reset
when finished.
"""
if "linux" in sys.platform:
mkl_rt = ctypes.CDLL('libmkl_rt.so')
else:
mkl_rt = ctypes.CDLL('libmkl_rt.dylib')
oldlimit = mkl_rt.mkl_get_max_threads()
mkl_rt... |
def get_total(tots, node):
""" get total number of quartets possible for a split"""
if (node.is_leaf() or node.is_root()):
return 0
else:
## Get counts on down edges.
## How to treat polytomies here?
if len(node.children) > 2:
down_r = node.children[0]
... |
def get_sampled(data, totn, node):
""" get total number of quartets sampled for a split"""
## convert tip names to ints
names = sorted(totn)
cdict = {name: idx for idx, name in enumerate(names)}
## skip some nodes
if (node.is_leaf() or node.is_root()):
return 0
else:
## ... |
def consensus_tree(trees, names=None, cutoff=0.0):
"""
An extended majority rule consensus function for ete3.
Modelled on the similar function from scikit-bio tree module. If
cutoff=0.5 then it is a normal majority rule consensus, while if
cutoff=0.0 then subsequent non-conflicting clades are ad... |
def find_clades(trees, names):
"""
A subfunc of consensus_tree(). Traverses trees to count clade occurrences.
Names are ordered by names, else they are in the order of the first
tree.
"""
## index names from the first tree
if not names:
names = trees[0].get_leaf_names()
ndict =... |
def build_trees(fclade_counts, namedict):
"""
A subfunc of consensus_tree(). Build an unrooted consensus tree
from filtered clade counts.
"""
## storage
nodes = {}
idxarr = np.arange(len(fclade_counts[0][0]))
queue = []
## create dict of clade counts and set keys
countdict =... |
def _refresh(self):
"""
Remove all existing results files and reinit the h5 arrays
so that the tetrad object is just like fresh from a CLI start.
"""
## clear any existing results files
oldfiles = [self.files.qdump] + \
self.database.__dict__.values... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.