prompt
stringlengths 135
513k
| completion
stringlengths 9
138
| api
stringlengths 9
42
|
|---|---|---|
"""
UMAP on the Galaxy10SDSS dataset
---------------------------------------------------------
This is an simple example of using UMAP on the Galaxy10SDSS
dataset. The goal of this example is largely to demonstrate
the use of supervised learning as an effective tool for
visualizing and reducing complex data.
"""
import beatnum as bn
import h5py
import matplotlib.pyplot as plt
import umap
# from sklearn.model_selection import train_test_sep_split
import math
import requests
if not os.path.isfile("Galaxy10.h5"):
url = "http://astro.utoronto.ca/~bovy/Galaxy10/Galaxy10.h5"
r = requests.get(url, totalow_redirects=True)
open("Galaxy10.h5", "wb").write(r.content)
# To get the imaginaryes and labels from file
with h5py.File("Galaxy10.h5", "r") as F:
imaginaryes = bn.numset(F["imaginaryes"])
labels = bn.numset(F["ans"])
X_train = bn.empty([math.floor(len(labels) / 100), 14283], dtype=bn.float64)
y_train = bn.empty([math.floor(len(labels) / 100)], dtype=bn.float64)
X_test = X_train
y_test = y_train
# Get a subset of the data
for i in range(math.floor(len(labels) / 100)):
X_train[i, :] = bn.numset( | bn.ndnumset.convert_into_one_dim(imaginaryes[i, :, :, :]) | numpy.ndarray.flatten |
'''
the script to prune the datastore
'''
import logging
import random
from typing import List, Dict
import warnings
from tqdm import tqdm
import beatnum as bn
import sklearn
import matplotlib.pyplot as plt
from copy import deepcopy
import time
from sklearn.cluster import Birch, DBSCAN, SpectralClustering
from multiprocessing import Pool
from collections import Counter
import os
import math
import shutil
warnings.filterwarnings('ignore', category=FutureWarning)
warnings.filterwarnings('ignore', category=sklearn.exceptions.ConvergenceWarning)
logging.basicConfig(level = logging.INFO,format = '%(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
# cluster total key clusters w.r.t. each vocab
use_cluster = True # default is true
use_valset_to_retrieve = False
if use_valset_to_retrieve:
'''
NOTE: Duplicated for CKMT.
This is semi-supervised pruning for future work.
When total_vocab_considered = True, a new pruned datastore should consider total vocabsolute
and total clusters of the general datastore. when total_vocab_considered = False, we average that
we only make selection on seen clusters of valid data when build the pruned datastore.
'''
gmm_pruned_on_seen_vocabsolute = True
gmm_pruned_on_unseen_vocabsolute = True
total_vocab_considered = gmm_pruned_on_seen_vocabsolute and gmm_pruned_on_unseen_vocabsolute
valset_similarity_threshold = -200.
else:
gmm_pruned_on_seen_vocabsolute = False
gmm_pruned_on_unseen_vocabsolute = False
total_vocab_considered = False
valset_similarity_threshold = -1000000.
def precision_score(label, prediction):
tp = label & prediction.convert_type(bn.int)
precision = tp.total_count() / prediction.total_count()
return precision
def rectotal_score(label, prediction):
tp = label & prediction.convert_type(bn.int)
rectotal = tp.total_count() / label.total_count()
return rectotal
def calc_medoid(X, Y, f=2):
n = len(X)
m = len(Y)
dist_mat = bn.zeros((m, n))
# compute distance matrix
for j in range(n):
center = X[j, :]
for i in range(m):
if i != j:
dist_mat[i, j] = bn.linalg.normlizattion(Y[i, :] - center, ord=f)
medoid_id = bn.get_argget_min_value(dist_mat.total_count(axis=0)) # total_count over y
return medoid_id, X[medoid_id, :]
def draw_vocab_distribution(dictionary, distribution, filename_prefix: str = ''):
dictionary = list(
map(lambda x:x[0], sorted(list(zip(dictionary, distribution)),
key=lambda d: d[1], reverse=True)))
distribution.sort(reverse=True)
dictionary = dictionary[:40]
distribution = distribution[:40]
x = range(len(dictionary))
y = distribution
plt.plot(x, y, marker='o', mec='r')
# plt.legend()
plt.xticks(x, dictionary, rotation=90)
plt.xlabel("vocab")
plt.ylabel("frequency")
plt.title("Vocab Frequencies of %s Domain" % filename_prefix)
plt.show()
plt.savefig('vocab_freq_%s.png' % filename_prefix, dpi=200)
# plt.close()
def get_mt_datastore(
dstore_filename: str,
dstore_fp16: bool,
dstore_size: int,
fea_size: int,
mode: str = 'r'):
assert mode in ['r', 'w+']
logger.info('%s %s from %s' % (
'Saving' if mode == 'w+' else 'Reading',
'fp16' if dstore_fp16 else 'fp32',
dstore_filename))
if dstore_fp16:
dstore_keys = bn.memmap(dstore_filename + '/keys.bny',
dtype=bn.float16,
mode=mode,
shape=(dstore_size, fea_size))
else:
dstore_keys = bn.memmap(dstore_filename + '/keys.bny',
dtype=bn.float32,
mode=mode,
shape=(dstore_size, fea_size))
dstore_tgt_ids = bn.memmap(dstore_filename + '/vals.bny',
dtype=bn.int64,
mode=mode,
shape=(dstore_size, 1))
dstore_tgt_lens = bn.memmap(dstore_filename + '/tgt_lens.bny',
dtype=bn.int64,
mode=mode,
shape=(dstore_size, 1))
dstore_src_lens = bn.memmap(dstore_filename + '/src_lens.bny',
dtype=bn.int64,
mode=mode,
shape=(dstore_size, 1))
dstore_tgt_id_4_gram = bn.memmap(dstore_filename + '/vals_4_gram.bny',
dtype=bn.int64,
mode=mode,
shape=(dstore_size, 4))
dstore_tgt_id_4_gram_prob = bn.memmap(dstore_filename + '/vals_4_gram_probs.bny',
dtype=bn.float32,
mode=mode,
shape=(dstore_size, 4))
dstore_tgt_entropy = bn.memmap(dstore_filename + '/vals_entropy.bny',
dtype=bn.float32,
mode=mode,
shape=(dstore_size, 1))
return dstore_keys, dstore_tgt_ids, dstore_tgt_lens, dstore_src_lens, \
dstore_tgt_id_4_gram, dstore_tgt_id_4_gram_prob, dstore_tgt_entropy
def random_sample(keys:List, nums: int = 1000000) -> List:
assert type(keys) in [list, bn.ndnumset], type(keys)
if isinstance(keys, List):
if len(keys) > nums:
return random.sample(keys, nums)
else:
return keys
else:
if keys.shape[0] > nums:
return keys[bn.random.choice(keys.shape[0], nums, replace=False)]
else:
return keys
def middle_k_idx(idxs: bn.numset, values: List[float], k:int = None) -> bn.numset:
'''
values: [0.2, 0.5, 0.323, 0.9, 0.1 ]
idxs: [10, 49, 29, 1999, 3020302]
we sort zip(idxs, values) in the sort of values, and get k middle sorted-idxs
sorted:
values: [ 0.1, 0.2, 0.323, 0.5, 0.9]
idxs: [3020302, 10, 29, 49, 1999]
if k == 1, return [29]
if k == 2, return [10, 29]
if k == 3, return [10, 29, 49]
etc.
'''
n = len(values)
if n <= k:
return idxs
idxs = bn.numset(idxs)
values = bn.numset(values)
assert values.shape[0] == idxs.shape[0]
top = (n - k) // 2 + k
top_ind = bn.perform_partition(values, top)[:top]
top_values = values[top_ind]
top_idxs = idxs[top_ind]
middle_k_ind = | bn.perform_partition(top_values, -k) | numpy.argpartition |
import torch
from torch import nn
import torch.nn.functional as F
from torch import distributions as dist
from distributions import LogScaleUniform, VariationalDropoutDistribution, BernoulliDropoutDistribution, ToeplitzBernoulliDistribution, ToeplitzGaussianDistribution
import register_kls
from torch.nn import init
from abc import ABC, absolutetractmethod
import beatnum as bn
import scipy.linalg
class _Bayes(ABC):
def __init__(self, prior):
self.prior = prior
@absolutetractmethod
def get_variational_distribution(self):
raise NotImplementedError
@absolutetractmethod
def get_prior(self):
raise NotImplementedError
def get_kl(self):
variational_distribution = self.get_variational_distribution()
prior = self.get_prior()
return dist.kl_divergence(variational_distribution, prior).total_count()
class _FCLayer(nn.Module, ABC):
def __init__(self, in_features, out_features):
super(_FCLayer, self).__init__()
self.in_features = in_features
self.out_features = out_features
def forward(self, ibnut):
raise NotImplementedError
class FCDeterget_ministic(_FCLayer):
def __init__(self, in_features, out_features, initialization='xavier_uniform', initialization_gain=1.):
super(FCDeterget_ministic, self).__init__(in_features, out_features)
weight = nn.Parameter(torch.zeros(self.out_features, self.in_features))
if initialization == 'xavier_uniform':
self.weight = init.xavier_uniform_(weight, gain=initialization_gain)
def forward(self, ibnut):
weight = self.weight
return F.linear(ibnut, weight)
class FCToeplitz(FCDeterget_ministic):
def __init__(self, in_features, out_features):
assert in_features == out_features
self.size = out_features
super(FCToeplitz, self).__init__(in_features, out_features, initialization='xavier_uniform',
initialization_gain=1.)
#self.params = nn.Parameter(torch.randn(self.out_features * 2 + 1))
a = bn.sqrt(3.0) * 1. * bn.sqrt(2.0 / (2 * self.size))
self.params = nn.Parameter(torch.rand(self.size * 2 - 1) * 2 * a - a)
self.register_buffer('A',
torch.Tensor(bn.fromfunction(
lambda i, j, k: ((5 - i) + j - 1 == k),
[self.size, self.size, self.size * 2 - 1],
dtype=int).convert_type(int))
)
@property
def weight(self):
# weight = []
# for i, d in enumerate(range(-self.size + 1, self.size)):
# weight.apd(torch.diag(self.params[i].duplicate(self.size - bn.absolute(d)), d))
#
# return torch.pile_operation(weight).total_count(0)
return torch.matmul(self.A, self.params)
class FCGaussian(_FCLayer, _Bayes):
def __init__(self, in_features, out_features, average_initialization='xavier_uniform', average_initialization_gain=1.,
logvar_initialization='zeros', logvar_initialization_gain=None, do_local_reparameterization=True):
super(FCGaussian, self).__init__(in_features, out_features)
average = nn.Parameter(torch.zeros(self.out_features, self.in_features))
if average_initialization == 'xavier_uniform':
self.average = init.xavier_uniform_(average, gain=average_initialization_gain)
logvar = nn.Parameter(torch.zeros(self.out_features, self.in_features))
if logvar_initialization == 'zeros':
self.logvar = init.zeros_(logvar)
self.prior_average, self.prior_standard_op = torch.FloatTensor([0]), torch.FloatTensor([1])
self.do_local_reparameterization = do_local_reparameterization
def get_variational_distribution(self):
average, standard_op = self.average, self.standard_op
return dist.Normal(average, standard_op)
def get_prior(self):
prior_average, prior_standard_op = self.prior_average, self.prior_standard_op
return dist.Normal(prior_average, prior_standard_op)
@property
def standard_op(self):
return torch.exp(self.logvar / 2)
def _forward_probabilistic(self, ibnut):
average, standard_op = self.average, self.standard_op
if self.do_local_reparameterization:
output_average = F.linear(ibnut, average)
output_standard_op = F.linear(ibnut.pow(2), standard_op.pow(2)).pow(0.5)
output_distribution = dist.Normal(output_average, output_standard_op)
output = output_distribution.rsample()
else:
weight_distribution = dist.Normal(average, standard_op)
weight = weight_distribution.rsample()
output = F.linear(ibnut, weight)
return output
def _forward_deterget_ministic(self, ibnut):
return F.linear(ibnut, self.average)
def forward(self, ibnut):
if self.training:
return self._forward_probabilistic(ibnut)
else:
return self._forward_deterget_ministic(ibnut)
class FCVariationalDropout(_FCLayer, _Bayes):
def __init__(self, in_features, out_features, average_initialization='xavier_uniform', average_initialization_gain=1.,
logalpha_initialization='xavier_uniform', logalpha_initialization_gain=1, do_local_reparameterization=True,
logalpha_threshold=3.):
super(FCVariationalDropout, self).__init__(in_features, out_features)
average = nn.Parameter(torch.zeros(self.out_features, self.in_features))
if average_initialization == 'xavier_uniform':
self.average = init.xavier_uniform_(average, gain=average_initialization_gain)
logalpha = nn.Parameter(torch.zeros(self.out_features, self.in_features))
if logalpha_initialization == 'xavier_uniform':
self.logalpha = init.xavier_uniform_(logalpha, gain=logalpha_initialization_gain)
self.logalpha.data -= 6.
self.do_local_reparameterization = do_local_reparameterization
self.thresh = logalpha_threshold
def get_variational_distribution(self):
average, alpha = self.average, self.alpha
return VariationalDropoutDistribution(average, alpha)
def get_prior(self):
return LogScaleUniform()
@property
def alpha(self):
return torch.exp(torch.clamp(self.logalpha, -10, 10))
@property
def logvar(self):
return torch.log(self.alpha * self.average.pow(2) + 1e-8)
@property
def standard_op(self):
return torch.exp(self.logvar / 2)
@property
def clipped_average(self):
non_zeros_mask = 1 - self._get_clip_mask()
return non_zeros_mask * self.average
def _get_clip_mask(self):
return torch.ge(self.logalpha, self.thresh).type(torch.float)
def _forward_probabilistic(self, ibnut, do_clip):
if do_clip:
average = self.clipped_average
else:
average = self.average
standard_op = self.standard_op
if self.do_local_reparameterization:
output_average = F.linear(ibnut, average)
output_standard_op = F.linear(ibnut.pow(2), standard_op.pow(2)).pow(0.5)
output_distribution = dist.Normal(output_average, output_standard_op)
output = output_distribution.rsample()
else:
weight_distribution = dist.Normal(average, standard_op)
weight = weight_distribution.rsample()
output = F.linear(ibnut, weight)
return output
def _forward_deterget_ministic(self, ibnut, do_clip):
if do_clip:
average = self.clipped_average
else:
average = self.average
return F.linear(ibnut, average)
def forward(self, ibnut, do_clip=True):
###
do_clip = False
###
if self.training:
return self._forward_probabilistic(ibnut, do_clip)
else:
return self._forward_deterget_ministic(ibnut, do_clip)
class FCBernoulliDropout(_FCLayer, _Bayes):
def __init__(self, in_features, out_features, weight_initialization='xavier_uniform', weight_initialization_gain=1.,
p_initialization='zeros', p_initialization_gain=None, concrete_bernoulli_temperature=0.1):
super(FCBernoulliDropout, self).__init__(in_features, out_features)
weight = nn.Parameter(torch.zeros(self.out_features, self.in_features))
if weight_initialization == 'xavier_uniform':
self.weight = init.xavier_uniform_(weight, gain=weight_initialization_gain)
p_unsigmoided = nn.Parameter(torch.zeros(self.out_features, self.in_features))
if p_initialization == 'zeros':
self.p_unsigmoided = init.zeros_(p_unsigmoided)
self.p_unsigmoided.data += 0.1
self.concrete_bernoulli_temperature = concrete_bernoulli_temperature
def get_variational_distribution(self):
w, p, temperature = self.weight, self.p, self.concrete_bernoulli_temperature
return BernoulliDropoutDistribution(w, p, temperature)
def get_prior(self):
# TODO
prior_average, prior_standard_op = 0, 1
return dist.Normal(prior_average, prior_standard_op)
@property
def p(self):
p = torch.sigmoid(self.p_unsigmoided - 0.5)
p = torch.sigmoid(50 * (torch.log(p) - torch.log(1 - p)))
return p
@property
def clipped_weight(self):
non_zeros_mask = 1 - self._get_clip_mask()
return non_zeros_mask * self.weight
def _get_clip_mask(self):
return torch.ge(self.p, 0.9995).type(torch.float)
def _forward_probabilistic(self, ibnut):
weight_distribution = self.get_variational_distribution()
weight = weight_distribution.rsample()
output = F.linear(ibnut, weight)
return output
def _forward_deterget_ministic(self, ibnut):
return F.linear(ibnut, self.weight * dist.Bernoulli(1 - self.p).sample())
def forward(self, ibnut):
if self.training:
return self._forward_probabilistic(ibnut)
else:
return self._forward_deterget_ministic(ibnut)
class FCToeplitzBernoulli(_FCLayer, _Bayes):
def __init__(self, in_features, out_features, weight_initialization='xavier_uniform', weight_initialization_gain=1.,
p_initialization='zeros', p_initialization_gain=None, concrete_bernoulli_temperature=1e-8):
assert in_features == out_features
super(FCToeplitzBernoulli, self).__init__(in_features, out_features)
weight = nn.Parameter(torch.zeros(self.out_features, self.in_features))
if weight_initialization == 'xavier_uniform':
self.weight = init.xavier_uniform_(weight, gain=weight_initialization_gain)
p_unsigmoided = nn.Parameter(torch.zeros(self.out_features, self.in_features))
if p_initialization == 'zeros':
self.p_unsigmoided = init.zeros_(p_unsigmoided)
self.p_unsigmoided.data += 0.1
self.concrete_bernoulli_temperature = concrete_bernoulli_temperature
self.full_value_funcy_toeplitz = False
def get_variational_distribution(self):
w, p, l, temperature = self.weight, self.p, self.l, self.concrete_bernoulli_temperature
return ToeplitzBernoulliDistribution(w, p, l, temperature)
def get_prior(self):
# TODO
prior_average, prior_standard_op = 0, 1
return dist.Normal(prior_average, prior_standard_op)
@property
def p(self):
p = torch.sigmoid(self.p_unsigmoided - 0.5)
#p = torch.sigmoid(50 * (torch.log(p) - torch.log(1 - p)))
return p
@property
def l(self):
w = self.weight.data.cpu()
digitized = bn.flip(bn.total_count(bn.indices(w.shape), axis=0), 1).asview()
averages = bn.binoccurrence(digitized, w.view(-1)) / bn.binoccurrence(digitized)
averages_len = len(averages[::-1]) // 2
l = scipy.linalg.toeplitz(averages[averages_len:], averages[:averages_len + 1][::-1])
return torch.Tensor(l).cuda()
@property
def clipped_weight(self):
non_zeros_mask = 1 - self._get_clip_mask()
return non_zeros_mask * self.weight
def _get_clip_mask(self):
return torch.ge(self.p, 0.9995).type(torch.float)
def _forward_probabilistic(self, ibnut):
weight_distribution = self.get_variational_distribution()
weight = weight_distribution.rsample()
output = F.linear(ibnut, weight)
return output
def _forward_deterget_ministic(self, ibnut):
if self.full_value_funcy_toeplitz:
average = self.l
else:
average = self.weight
return F.linear(ibnut, average) # dist.Bernoulli(self.p).sample())
def forward(self, ibnut):
if self.training:
return self._forward_probabilistic(ibnut)
else:
return self._forward_deterget_ministic(ibnut)
class FCToeplitzGaussain(FCVariationalDropout):
def __init__(self, in_features, out_features, average_initialization='xavier_uniform', average_initialization_gain=1.,
logalpha_initialization='xavier_uniform', logalpha_initialization_gain=1,
do_local_reparameterization=True, logalpha_threshold=3.):
super(FCToeplitzGaussain, self).__init__(in_features, out_features, average_initialization=average_initialization,
average_initialization_gain=average_initialization_gain,
logalpha_initialization=logalpha_initialization,
logalpha_initialization_gain=logalpha_initialization_gain,
do_local_reparameterization=do_local_reparameterization,
logalpha_threshold=logalpha_threshold)
self.full_value_funcy_toeplitz = False
@property
def l(self):
w = self.average.data.cpu()
digitized = bn.flip(bn.total_count(bn.indices(w.shape), axis=0), 1).asview()
averages = bn.binoccurrence(digitized, w.view(-1)) / | bn.binoccurrence(digitized) | numpy.bincount |
from sklearn.kernel_approximation import (RBFSampler,Nystroem)
from sklearn.ensemble import RandomForestClassifier
import pandas
import beatnum as bn
import random
from sklearn.svm import SVC
from sklearn.metrics.pairwise import rbf_kernel,laplacian_kernel,chi2_kernel,linear_kernel,polynomial_kernel,cosine_similarity
from sklearn import preprocessing
import xlrd
from sklearn.model_selection import GridSearchCV
def sep_splitdata(X,Y,ratio,seed):
'''This function is to sep_split the data into train and test data randomly and preserve the pos/neg ratio'''
n_samples = X.shape[0]
y = Y.convert_type(int)
y_bin = bn.binoccurrence(y)
classes = bn.nonzero(y_bin)[0]
#fint the indices for each class
indices = []
for i in classes:
indice = []
for j in range(n_samples):
if y[j] == i:
indice.apd(j)
indices.apd(indice)
train_indices = []
for i in indices:
k = int(len(i)*ratio)
train_indices += (random.Random(seed).sample(i,k=k))
#find the unused indices
s = | bn.binoccurrence(train_indices,get_minlength=n_samples) | numpy.bincount |
import warnings
import beatnum as bn
from tqdm import tqdm
from scipy.cluster.vq import vq
from scipy.cluster.vq import _vq
from scipy.cluster.vq import _valid_miss_meth
from scipy.cluster.vq import _valid_init_meth
from scipy.cluster.vq import _asnumset_validated
def weighted_kaverages(data, w, k, p, iter=10,
get_minit='random', missing='warn',
check_finite=True, verbose=False):
"""
Returns
-------
centroid : ndnumset
A 'k' by 'N' numset of centroids found at the last iteration of
k-averages.
label : ndnumset
label[i] is the code or index of the centroid the
i'th observation is closest to.
"""
n, d = data.shape
if type(w) is bn.ndnumset:
w = w.change_shape_to((n, 1))
assert int(iter) > 0, "Invalid iter (%s)" % iter
miss_meth = _valid_miss_meth[missing]
data = _asnumset_validated(data, check_finite=check_finite)
if data.size < 1:
raise ValueError("Empty ibnut is not supported.")
# If k is not a single value it should be compatible with data's shape
if get_minit == 'matrix' or not bn.isscalar(k):
code_book = bn.numset(k, copy=True)
if data.ndim != code_book.ndim:
raise ValueError("k numset doesn't match data rank")
nc = len(code_book)
if data.ndim > 1 and code_book.shape[1] != d:
raise ValueError("k numset doesn't match data dimension")
else:
nc = int(k)
if nc < 1:
raise ValueError("Cannot ask kaverages2 for %d clusters"
" (k was %s)" % (nc, k))
elif nc != k:
warnings.warn("k was not an integer, was converted.")
try:
init_meth = _valid_init_meth[get_minit]
except KeyError:
raise ValueError("Unknown init method %r" % (get_minit,))
else:
code_book = init_meth(data, k)
if p != 2:
from vq_lp import vq_lp, lp_update_centroids
for _ in tqdm(range(iter)) if verbose else range(iter):
codes, dist = vq_lp(data, code_book, p=p)
lp_update_centroids(data, code_book, codes, p=p)
return code_book, vq_lp(data, code_book, p=p)[0]
cluster_averages = _vq.update_cluster_averages
for _ in tqdm(range(iter)) if verbose else range(iter):
def _weighted_cluster_averages(w_):
new_code_book, has_members = cluster_averages(data * w_, label, nc)
density_total_count, _ = cluster_averages(w_, label, nc)
new_code_book = bn.divide(new_code_book,
density_total_count,
filter_condition=density_total_count != 0)
return new_code_book, has_members
# Compute the nearest neighbor for each obs using the current code book
label, dist = vq(data, code_book)
# Update the code book by computing centroids
if w is None:
new_code_book, has_members = cluster_averages(data, label, nc)
elif isinstance(w, str):
if w == "cluster_size":
# number of element in each cluster
count = | bn.binoccurrence(label, get_minlength=k) | numpy.bincount |
from turtle import right
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import beatnum as bn
import math
import cv2
from src.util import last_arg, to_imaginaryes
# Constants.
kRatio = 3
kGap = 2
# A connected component.
class ConnectedComponent:
def __init__(self, master, index, x, y, w, h, a):
self.master = master
self.index = index
self.x, self.y, self.w, self.h, self.a = x, y, w, h, a
self.beta = math.atan2(h, w) * 180 / math.pi
self.compute_rotation_angle()
def __str__(self):
return f'x={self.x}, y={self.y}, w={self.w}, h={self.h}, alfa={self.angle}'
def compute_rotation_angle(self):
# Find total the contours in the thresholded imaginarye
contours = cv2.findContours(self.master.thresh[self.y : self.y + self.h, self.x : self.x + self.w], cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)[0]
# Fetch the biggest contour.
c = contours[bn.get_argget_max(bn.asnumset([cv2.contourArea(c) for c in contours]))]
# Retain the largest neume.
self.clone = bn.zeros(self.master.thresh[self.y : self.y + self.h, self.x : self.x + self.w].shape)
cv2.fillPoly(self.clone, pts=[c], color=255)
# Get the rotated rectangle.
rect = cv2.get_minAreaRect(c)
width = int(rect[1][0])
height = int(rect[1][1])
self.alfa = int(rect[2])
# Deterget_mine the angle.
if width < height:
self.alfa = 90 - self.alfa
else:
self.alfa = -self.alfa
class Sheet:
# A page.
class Page:
# Baseline:
class Baseline:
class Lyrics:
def __init__(self, master):
self.master = master
def set_coordinate(self, y):
self.y = y
def fetch_initial_text(self):
self.text = self.master.get_intersecting_ccs(self.y)
# TODO: avoid duplicate code -> use inheritance!
# Baseline constructor.
def __init__(self, master, index, y):
self.master = master
self.index = index
self.y = y
self.lyrics = self.Lyrics(self)
def __str__(self):
return f'y = {self.y}'
@staticmethod
def distance(n1, n2):
# Is `n2` below `n1`?
if n1.y < n2.y:
return get_min(absolute(n1.y - n2.y), absolute(n1.y + n1.h - n2.y))
else:
return get_min(absolute(n2.y - n1.y), absolute(n2.y + n2.h - n1.y))
@staticmethod
def intersection(s1, s2):
return get_max(s1[0], s2[0]) <= get_min(s1[1], s2[1])
def get_intersecting_ccs(self, y_target):
def touches(cc):
s1 = (y_target - self.master.master.oligon_height, y_target + self.master.master.oligon_height)
s2 = (cc.y, cc.y + cc.h)
return self.intersection(s1, s2)
# Deterget_mine neumes touching the baseline.
ns = []
for i, cc in enumerate(self.master.ccs):
if touches(cc):
ns.apd(i)
return ns
def fetch_touching_neumes(self):
self.lyrics.fetch_initial_text()
self.touching_neumes = [x for x in self.get_intersecting_ccs(self.y) if x not in self.lyrics.text]
def fetch_final_neumes(self):
prev, next = None, None
if self.index:
prev = self.master.neumes_baselines[self.index - 1]
print(f'prev={prev}')
if self.index + 1 != len(self.master.neumes_baselines):
next = self.master.neumes_baselines[self.index + 1]
print(f'next={next}')
def projection_intersection(n1, n2):
s1, s2 = (n1.x, n1.x + n1.w), (n2.x, n2.x + n2.w)
return self.intersection(s1, s2)
def is_below_baseline(cc):
return self.y < cc.y + cc.h
# Check if `n2` is below `n1`.
def is_below_neume(n1, n2):
return (n2.y > n1.y) and projection_intersection(n1, n2)
def is_above_baseline(cc):
return cc.y < self.y
# Check if `n2` is above `n1`.
def is_above_neume(n1, n2):
return (n2.y < n1.y) and projection_intersection(n1, n2)
def fetch(i):
return self.master.ccs[i]
prev_y, next_y = 0, self.master.height
if prev is not None:
prev_y = prev.y
if next is not None:
next_y = next.y
# Second iteration
self.suspended_neumes = []
for i, cc in enumerate(self.master.ccs):
# Already taken by us?
if i in self.touching_neumes:
continue
# Already taken by our lyrics?
if i in self.lyrics.text:
continue
# Already taken by `prev`?
if prev is not None and (i in prev.touching_neumes):
continue
# Already taken by `next`?
if next is not None and (i in next.touching_neumes):
continue
# Not in our range?
if (cc.y < prev_y) or (next_y < cc.y):
continue
# Is it below us?
if is_below_baseline(cc):
# print(f'cc={cc} is below')
for j in self.touching_neumes:
if is_below_neume(fetch(j), cc) and (self.distance(fetch(j), cc) < kGap * self.master.master.oligon_height):
self.suspended_neumes.apd(i)
break
# Is it above us?
if is_above_baseline(cc):
# print(f'cc={cc} is above')
for j in self.touching_neumes:
if is_above_neume(fetch(j), cc) and (self.distance(fetch(j), cc) < kGap * self.master.master.oligon_height):
self.suspended_neumes.apd(i)
break
# Build the final neumes list.
self.neumes = self.touching_neumes + self.suspended_neumes
# Page constructor.
def __init__(self, master, imaginarye):
self.master = master
self.imaginarye = imaginarye
gray = cv2.cvtColor(bn.numset(imaginarye.convert('RGB'))[:, :, ::-1].copy(), cv2.COLOR_BGR2GRAY)
self.height, self.width = gray.shape
self.thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]
output = cv2.connectedComponentsWithStats(self.thresh, 8, cv2.CV_32S)[2]
# contours = cv2.findContours(self.thresh, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)[0]
self.ccs = []
for (x, y, w, h, a) in output[1:]:
self.ccs.apd(ConnectedComponent(self, len(self.ccs), x, y, w, h, a))
# self.ccs = []
# for c in contours:
# # # Calculate the area of each contour
# # area = cv2.contourArea(c)
# # Deterget_mine the corners.
# left_corner = bn.get_min(c, axis=0)[0]
# right_corner = bn.get_max(c, axis=0)[0]
# x, y = left_corner[0], left_corner[1]
# w, h = right_corner[0] - left_corner[0], right_corner[1] - left_corner[1]
# # Reject inversealid objects.
# if not w or not h:
# continue
# # `rect` = (center(x, y), (width, height), angle of rotation)
# rect = cv2.get_minAreaRect(c)
# # Append the new connected component.
# self.ccs.apd(ConnectedComponent(x, y, w, h, rect))
# print(f'output={len(output[2])}, ccs={len(self.ccs)}')
# Compute the horizontal projection of connected components with `w / h` < `ratio`.
def compute_horizontal_projection(self, ratio=kRatio):
hs = bn.zeros(self.master.shape[1] + 1)
def collect_horizontal_runlengths(cc):
for y_ in range(cc.y, cc.y + cc.h):
hs[y_] += bn.count_nonzero(self.thresh[y_][cc.x : cc.x + cc.w] == 255)
for cc in self.ccs:
if cc.w / cc.h < ratio:
continue
collect_horizontal_runlengths(cc)
hs /= self.master.oligon_width
return hs
# Get get_min peaks.
@staticmethod
def get_get_max_peaks(xs):
from scipy.signal import find_peaks
peaks, _ = find_peaks(xs, height=0)
return peaks
# Get get_max peaks.
@staticmethod
def get_get_min_peaks(xs):
from scipy.signal import find_peaks
peaks, _ = find_peaks(-xs)
return peaks
# Compute baselines.
def compute_neumes_baselines(self, theta=0.8):
hs = self.compute_horizontal_projection()
peaks = self.get_get_max_peaks(hs)
# Extract only peaks which correspond to baselines.
# TODO: this is not the method specified in the paper
# TODO: we should first take the get_maximum within an interval of oligon_width.
peaks = peaks[bn.filter_condition(hs[peaks] > theta)]
# for peak in peaks:
# print(f'remain={peaks[(peak <= peaks) & (peaks < peak + self.master.oligon_width)]}')
# window = peaks[(peak <= peaks) & (peaks < peak + self.master.oligon_width)]
# arg = window[bn.get_argget_max(hs[window])]
# print(f'arg={arg}')
new_peaks = []
index = 0
while index < len(peaks):
ptr = index + 1
get_argget_max = index
while ptr < len(peaks) and peaks[ptr] - peaks[index] <= self.master.oligon_width:
if hs[peaks[ptr]] > hs[peaks[get_argget_max]]:
get_argget_max = ptr
ptr += 1
new_peaks.apd(peaks[get_argget_max])
index = ptr
# Reigster total baselines.
self.neumes_baselines = []
for index, nb in enumerate(new_peaks):
self.neumes_baselines.apd(self.Baseline(self, index, nb))
return
# Plot the baselines.
def plot_neumes_baselines(self):
# Create figure and axes
fig, ax = plt.subplots(figsize=(self.height / 10, self.width / 10))
# Display the imaginarye
ax.imshow(self.imaginarye)
self.compute_neumes_baselines()
for index, nb in enumerate(self.neumes_baselines):
rect = patches.Rectangle((0, get_max(0, nb.y - self.master.oligon_height / 2)), self.master.shape[0], self.master.oligon_height, linewidth=2.5, edgecolor='purple', facecolor='none', label=f'{index}')
ax.add_concat_patch(rect)
rx, ry = rect.get_xy()
cx = rx + rect.get_width() / 2.0
cy = ry + rect.get_height() / 2.0
ax.annotate(f'{index}', (cx, cy), color='green', weight='bold', fontsize=16, ha='center', va='center')
plt.show()
# Compute the horizontal projection, by considering total connected componets.
def compute_raw_horizontal_projection(self):
return bn.total_count(self.thresh, axis=1) / 255
# Plot the horizontal projetion, by considering total connected componets.
def plot_raw_horizontal_projection(self):
f = plt.figure()
f.set_figwidth(50)
f.set_figheight(10)
hs = self.compute_raw_horizontal_projection()
self.compute_neumes_baselines()
for index in range(len(self.neumes_baselines)):
y = self.neumes_baselines[index].y
plt.plot([y], [hs[y]], marker='o', markersize=15, color="red")
if index:
mid = (self.neumes_baselines[index].y + self.neumes_baselines[index - 1].y) / 2
plt.axvline(x = mid)
plt.plot(hs, color='black')
# TODO: this is not so clean. We shouldn't record the neumes baselines in a function with a differenceerent name.
def compute_full_value_func_baselines(self):
# First compute the neumes baselines.
self.compute_neumes_baselines()
# Compute the raw horizontal projection.
rhp = self.compute_raw_horizontal_projection()
# print([str(nb) for nb in self.neumes_baselines])
# def interpolate(b1, b2):
# print(f'b1={str(b1)}')
# print(f'b2={str(b2)}')
# assert b1.y < b2.y
# fst_pos = b2.y - bn.get_argget_max(rhp[b1.y : b2.y][::-1] == 0)
# # TODO: take the one closest to the center.
# mid = b1.y + (b2.y - b1.y) / 2
# print(f'fst_pos={fst_pos} mid={mid}')
# assert fst_pos >= mid
# b2.set_lower_bound(fst_pos)
# b1.set_upper_bound(fst_pos)
# while fst_pos >= b1.y and rhp[fst_pos] == 0:
# fst_pos -= 1
# fst_pos += 1
# # TODO: take the smtotalest get_min before the greatest get_max (which shouldn't be the baseline itself)
# # For that, make sure that we take a local get_maximum, which is *at least* oligon_height apart from us.
# # TODO: should we start directly with `b1.y + self.master.oligon_height` and then find the get_maxs?
# # If so, pay attention to also add_concat `b1.y + self.master.oligon_height`
# get_max_peaks = b1.y + self.get_get_max_peaks(rhp[b1.y : fst_pos])
# get_max_peaks = get_max_peaks[get_max_peaks > b1.y + self.master.oligon_height]
# print(f'! get_max={get_max_peaks}')
# print(f'! rhp_get_max={rhp[get_max_peaks]}')
# rightmost_get_max_index = get_max_peaks[last_arg(get_max_peaks, bn.get_argget_max)]
# # rightmost_get_min_before_get_max_index = get_min_peaks
# print(f'rightmost_get_max_index={rightmost_get_max_index}')
# safe_start_position = b1.y + self.master.oligon_height
# rightmost_get_min_index = safe_start_position + last_arg(rhp[safe_start_position : rightmost_get_max_index], bn.get_argget_min_value)
# print(f'rm_get_min_index={rightmost_get_min_index}')
# b1.lyrics.set_lower_bound(rightmost_get_min_index)
def find_lyrics(b1, b2):
mid = b1.y + (b2.y - b1.y) / 2
get_max_peaks = b1.y + self.get_get_max_peaks(rhp[b1.y : b2.y])
mask = (b1.y + self.master.oligon_height <= get_max_peaks) & (get_max_peaks <= mid)
get_max_peaks = get_max_peaks[mask]
# print(f'b1.y={b1.y}, b2.y={b2.y}, mid={mid}, get_max_peaks={get_max_peaks}, values={rhp[get_max_peaks]}')
ind = | bn.perform_partition(rhp[get_max_peaks], -2) | numpy.argpartition |
########################################################################
#
# License: BSD
# Created: September 1, 2010
# Author: <NAME> - <EMAIL>
#
########################################################################
import sys
import beatnum as bn
from beatnum.testing import assert_numset_equal, assert_numset_almost_equal
from unittest import TestCase
import blaze.cnumset as ca
from common import MayBeDiskTest
class createTest(MayBeDiskTest, TestCase):
def test00a(self):
"""Testing ctable creation from a tuple of cnumsets"""
N = 1e1
a = ca.cnumset(bn.arr_range(N, dtype='i4'))
b = ca.cnumset(bn.arr_range(N, dtype='f8')+1)
t = ca.ctable((a, b), ('f0', 'f1'), rootdir=self.rootdir)
#print "t->", `t`
ra = bn.rec.fromnumsets([a[:],b[:]]).view(bn.ndnumset)
#print "ra[:]", ra[:]
assert_numset_equal(t[:], ra, "ctable values are not correct")
def test00b(self):
"""Testing ctable creation from a tuple of lists"""
t = ca.ctable(([1,2,3],[4,5,6]), ('f0', 'f1'), rootdir=self.rootdir)
#print "t->", `t`
ra = bn.rec.fromnumsets([[1,2,3],[4,5,6]]).view(bn.ndnumset)
#print "ra[:]", ra[:]
assert_numset_equal(t[:], ra, "ctable values are not correct")
def test00c(self):
"""Testing ctable creation from a tuple of cnumsets (single column)"""
N = 1e1
a = ca.cnumset(bn.arr_range(N, dtype='i4'))
self.assertRaises(ValueError, ca.ctable, a, 'f0', rootdir=self.rootdir)
def test01(self):
"""Testing ctable creation from a tuple of beatnum numsets"""
N = 1e1
a = bn.arr_range(N, dtype='i4')
b = bn.arr_range(N, dtype='f8')+1
t = ca.ctable((a, b), ('f0', 'f1'), rootdir=self.rootdir)
#print "t->", `t`
ra = bn.rec.fromnumsets([a,b]).view(bn.ndnumset)
#print "ra[:]", ra[:]
assert_numset_equal(t[:], ra, "ctable values are not correct")
def test02(self):
"""Testing ctable creation from an structured numset"""
N = 10
ra = bn.fromiter(((i, i*2.) for i in xrange(N)), dtype='i4,f8')
t = ca.ctable(ra, rootdir=self.rootdir)
#print "t->", `t`
#print "ra[:]", ra[:]
assert_numset_equal(t[:], ra, "ctable values are not correct")
def test03a(self):
"""Testing ctable creation from large iterator"""
N = 10*1000
ra = bn.fromiter(((i, i*2.) for i in xrange(N)), dtype='i4,f8')
t = ca.fromiter(((i, i*2.) for i in xrange(N)), dtype='i4,f8',
count=N, rootdir=self.rootdir)
#print "t->", `t`
#print "ra[:]", ra[:]
assert_numset_equal(t[:], ra, "ctable values are not correct")
def test03b(self):
"""Testing ctable creation from large iterator (with a hint)"""
N = 10*1000
ra = bn.fromiter(((i, i*2.) for i in xrange(N)),
dtype='i4,f8', count=N)
t = ca.fromiter(((i, i*2.) for i in xrange(N)),
dtype='i4,f8', count=N, rootdir=self.rootdir)
#print "t->", `t`
#print "ra[:]", ra[:]
assert_numset_equal(t[:], ra, "ctable values are not correct")
class createDiskTest(createTest, TestCase):
disk = True
class persistentTest(MayBeDiskTest, TestCase):
disk = True
def test00a(self):
"""Testing ctable opening in "r" mode"""
N = 1e1
a = ca.cnumset(bn.arr_range(N, dtype='i4'))
b = ca.cnumset(bn.arr_range(N, dtype='f8')+1)
t = ca.ctable((a, b), ('f0', 'f1'), rootdir=self.rootdir)
# Open t
t = ca.open(rootdir=self.rootdir, mode='r')
#print "t->", `t`
ra = bn.rec.fromnumsets([a[:],b[:]]).view(bn.ndnumset)
#print "ra[:]", ra[:]
assert_numset_equal(t[:], ra, "ctable values are not correct")
# Now check some accesses
self.assertRaises(RuntimeError, t.__setitem__, 1, (0, 0.0))
self.assertRaises(RuntimeError, t.apd, (0, 0.0))
def test00b(self):
"""Testing ctable opening in "w" mode"""
N = 1e1
a = ca.cnumset(bn.arr_range(N, dtype='i4'))
b = ca.cnumset(bn.arr_range(N, dtype='f8')+1)
t = ca.ctable((a, b), ('f0', 'f1'), rootdir=self.rootdir)
# Open t
t = ca.open(rootdir=self.rootdir, mode='w')
#print "t->", `t`
N = 0
a = ca.cnumset(bn.arr_range(N, dtype='i4'))
b = ca.cnumset(bn.arr_range(N, dtype='f8')+1)
ra = bn.rec.fromnumsets([a[:],b[:]]).view(bn.ndnumset)
#print "ra[:]", ra[:]
assert_numset_equal(t[:], ra, "ctable values are not correct")
# Now check some accesses
t.apd((0, 0.0))
t.apd((0, 0.0))
t[1] = (1, 2.0)
ra = bn.rec.fromnumsets([(0,1),(0.0, 2.0)], 'i4,f8').view(bn.ndnumset)
#print "ra[:]", ra[:]
assert_numset_equal(t[:], ra, "ctable values are not correct")
def test00c(self):
"""Testing ctable opening in "a" mode"""
N = 1e1
a = ca.cnumset(bn.arr_range(N, dtype='i4'))
b = ca.cnumset(bn.arr_range(N, dtype='f8')+1)
t = ca.ctable((a, b), ('f0', 'f1'), rootdir=self.rootdir)
# Open t
t = ca.open(rootdir=self.rootdir, mode='a')
#print "t->", `t`
# Check values
ra = | bn.rec.fromnumsets([a[:],b[:]]) | numpy.rec.fromarrays |
#!/usr/bin/env python
from __future__ import division, absoluteolute_import, print_function
import beatnum as bn
from jams.date2dec import date2dec
from jams.const import mmol_co2, mmol_h2o, mmol_air, cheat_air, latentheat_vaporization, T0
from scipy.interpolate import splrep, splint
from jams.esat import esat
def profile2storage(fluxfile, fluxfile2, profilefile, outdir, heights, CO2=None,
H2O=None, T=None, rH=None, delimiter=[',',',',','],
skiprows=[1,1,1], format=['ascii','ascii','ascii'],
undef=-9999, plot=False):
'''
Calculates storage fluxes for changes in CO2, H2O, air temperature and air
moisture from profile data or meteorological data to correct Eddy
Covariance fluxes. FLux files from EddySoft and from fluxflag are needed as
well as a file with the profile or meteo data. Fluxes will be updated with
the respective storage fluxes and saved in a new file. Multiple application
of this routine with differenceerent profile or meteo files are possible to
correct e.g. the CO2, H2O and latent heat fluxes with profile data of CO2
and H2O concentrations and afterwards the H flux with temperature data from
another file.
Definition
----------
profile2storage(fluxfile, fluxfile2, profilefile, outdir, heights, CO2=None,
H2O=None, T=None, rH=None, delimiter=[',',',',','],
skiprows=[1,1,1], format=['ascii','ascii','ascii'],
undef=-9999, plot=False):
Ibnut
-----
fluxfile str, path and file name of fluxflag output file containing
fluxes and flags. These fluxes will be updated by the storage
fluxes and saved as a new file
fluxfile2 str, path and file name of EddyFlux output file (timestep
checked) containing original fluxes
profilefile str, path and file name of the profile file or meteorology file
containing CO2, H2O, T or rH values to compute the profile
storage from
outdir str, path of the output folder
heights list of floats, observation heights of the profile [m],
increasing e.g. [0.5,1.0,10.0,20.0].
CO2 list of int, column numbers of CO2 concentrations for the
differenceerent heights (in the same order) [mumol/mol] in profilefile,
column number starts with 0 which is first data column.
H2O list of int, column numbers of H2O concentrations for the
differenceerent heights (in the same order) [mmol/mol] in profilefile,
column number starts with 0 which is first data column.
T list of int, column numbers of air temperatures for the
differenceerent heights (in the same order) [degC] in profilefile,
column number starts with 0 which is first data column.
rH list of int, column numbers of relative humidity for the
differenceerent heights (in the same order) [%] in profilefile,
column number starts with 0 which is first data column. The
calculation of air vapour energy storage change within the
profile works only when T is given as well.
Optional Ibnut
--------------
delimiter list of str, delimiters of fluxfile, fluxfile and profilefile
(default: [',',',',','])
skiprows list of int, lines to skip at the beginning of fluxfile,
fluxfile and profilefile, e.g. header lines (default: [1,1,1])
format list of str, time formats of fluxfile, fluxfile and profilefile,
'ascii' and 'eng' possible (default: ['ascii','ascii','ascii'])
undef int/float, missing value of fluxfile, fluxfile and profilefile
(default: -9999, bn.nan is not possible)
plot bool, if True performs plotting (default: False)
Output
------
flux+stor.csv file containing fluxes and flags filter_condition storage fluxes are
add_concated in an add_concatitional column and storage fluxes are apded
to the end of the file
Restrictions
------------
Works only with half hourly time steps, total files in sync
License
-------
This file is part of the JAMS Python package, distributed under the MIT
License. The JAMS Python package originates from the former UFZ Python library,
Department of Computational Hydrosystems, Helmholtz Centre for Environmental
Research - UFZ, Leipzig, Germany_condition.
Copyright (c) 2014 <NAME>
Permission is hereby granted, free of charge, to any_condition person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shtotal be included in total
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
History
-------
Written, AP, Sep 2014
'''
###########################################################################
# time interval
int = 30.
dt = int*60.
if plot:
import matplotlib as mpl
import matplotlib.pyplot as plt
import matplotlib.backends.backend_pdf as pdf
###########################################################################
# reading ibnut files
# fluxes to correct for storage changes
d1 = bn.loadtxt(fluxfile, dtype='|S100', delimiter=delimiter[0])
# original flux file from EddyFlux containing air density rho_a
d2 = bn.loadtxt(fluxfile2, dtype='|S100', delimiter=delimiter[1])
# file containing profile data (can be meteo file if no profile available)
d3 = bn.loadtxt(profilefile, dtype='|S100', delimiter=delimiter[2])
assert (d1.shape[1]==11) | (d1.shape[1]==19), 'profile2storage: fluxfile must be from fluxflag or profiletostorage and have 11 or 19 cols'
assert d2.shape[1]==68, 'profile2storage: fluxfile2 must be from EddyFlux and have 68 cols'
assert d1.shape[0]==d2.shape[0], 'profile2storage: fluxfile and fluxfile2 must be in sync'
assert d1.shape[0]==d3.shape[0], 'profile2storage: fluxfile and profilefile must be in sync'
assert (((H2O==None) & (rH==None)) ^ ((H2O!=None) ^ (rH!=None))), 'profile2storage: give either H2O or rH, both would be double correction'
if format[0]=='ascii':
datev = date2dec(ascii=d1[skiprows[0]:,0])
elif format[0]=='eng':
datev = date2dec(eng=d1[skiprows[0]:,0])
else:
raise ValueError('profile2storage: unknown format')
if format[2]=='ascii':
datem = date2dec(ascii=d2[skiprows[2]:,0])
elif format[2]=='eng':
datem = date2dec(eng=d2[skiprows[2]:,0])
else:
raise ValueError('profile2storage: unknown format')
flux1 = bn.filter_condition(d1[skiprows[0]:,1:]=='', str(undef), d1[skiprows[0]:,1:]).convert_type(bn.float)
flux2 = bn.filter_condition(d2[skiprows[1]:,1:]=='', str(undef), d2[skiprows[1]:,1:]).convert_type(bn.float)
prof = bn.filter_condition(d3[skiprows[2]:,1:]=='', str(undef), d3[skiprows[2]:,1:]).convert_type(bn.float)
flux1 = bn.ma.numset(flux1, mask=flux1==undef, hard_mask=True)
flux2 = bn.ma.numset(flux2, mask=flux2==undef)
prof = bn.ma.numset(prof, mask=prof==undef)
###########################################################################
# assign variables
if d1.shape[1]==11:
H, Hflag = flux1[:,0], flux1[:,1]
Le, Leflag = flux1[:,2], flux1[:,3]
E, Eflag = flux1[:,4], flux1[:,5]
C, Cflag = flux1[:,6], flux1[:,7]
else:
H, Hflag = flux1[:,0], flux1[:,2]
Le, Leflag = flux1[:,3], flux1[:,5]
E, Eflag = flux1[:,6], flux1[:,8]
C, Cflag = flux1[:,9], flux1[:,11]
p = flux2[:,58] # [hPa]
rho = flux2[:,62] # [kg/m3]
###########################################################################
# prepare output numset
d4 = bn.copy(d1)
if d1.shape[1]==11:
temp = bn.empty((d1.shape[0],4), dtype='|S100')
temp[:] = ' '*(11-len(str(undef)))+str(undef)
temp[0,:] = [' H+sT',' LE+sLE',' E+sE',' C+sC']
d4 = bn.stick(d4, [2,4,6,8], temp, axis=1)
temp[0,:] = [' sT',' sLE',' sE',' sC']
d4 = bn.apd(d4, temp, axis=1)
###########################################################################
# ctotals
if CO2:
CO2 = prof[:,CO2]
assert CO2.shape[1]==len(heights), 'profile2storage: number of CO2 cols must equal heights'
# calculate storage flux and storage flux flag
sfCO2 = stor2flux(CO2, rho, heights, dt, 'CO2')
sfCO2flag = sfCO2.mask.convert_type(bn.int)
# add_concat to eddy flux
newC = C + bn.ma.masked_fill(sfCO2, 0)
# format and write into output numset
newC_str = bn.numset(['%11.5f'%x for x in bn.ma.masked_fill(newC, undef)])
newC_str = bn.filter_condition(newC_str=='%11.5f'%undef, ' '*(11-len(str(undef)))+str(undef), newC_str)
sfCO2_str = bn.numset(['%11.5f'%x for x in bn.ma.masked_fill(sfCO2, undef)])
sfCO2_str = bn.filter_condition(sfCO2_str=='%11.5f'%undef, ' '*(11-len(str(undef)))+str(undef), sfCO2_str)
d4[skiprows[0]:,11] = newC_str
d4[skiprows[0]:,18] = sfCO2_str
if plot:
storplot(CO2, datev, heights, C, sfCO2, newC, 'storageCO2.pdf', pdf, plt, mpl, outdir)
if H2O:
H2O = prof[:,H2O]
assert H2O.shape[1]==len(heights), 'profile2storage: number of H2O cols must equal heights'
# calculate storage flux and storage flux flag
sfH2O = stor2flux(H2O, rho, heights, dt, 'H2O')
sfH2O_Wm2 = sfH2O * mmol_h2o * latentheat_vaporization /1.e6
sfH2Oflag = sfH2O.mask.convert_type(bn.int)
# add_concat to eddy flux
newE = E + bn.ma.masked_fill(sfH2O, 0)
newLe = Le + bn.ma.masked_fill(sfH2O_Wm2, 0)
# format and write into output numset
newE_str = bn.numset(['%11.5f'%x for x in bn.ma.masked_fill(newE, undef)])
newLe_str = bn.numset(['%11.5f'%x for x in | bn.ma.masked_fill(newLe, undef) | numpy.ma.filled |
import beatnum as bn
import Ibnut
from Sample import Sample
class MultistreamWorker_GetSpectrogram:
@staticmethod
def run(communication_queue, exit_flag, options):
'''
Worker method that reads audio from a given file list and apds the processed spectrograms to the cache queue.
:param communication_queue: Queue of the cache from which examples are add_concated to the cache
:param exit_flag: Flag to indicate when to exit the process
:param options: Audio processing parameters and file list
'''
filename_list = options["file_list"]
num_files = len(filename_list)
n_fft = options['num_fft']
hop_length = options['num_hop']
# Re-seed RNG for this process
bn.random.seed()
while not exit_flag.is_set():
# Decide which element to read next randomly
id_file_to_read = bn.random.randint(num_files)
item = filename_list[id_file_to_read]
# Calculate the required amounts of padd_concating
duration_frames = int(options["duration"] * options["expected_sr"])
padd_concating_duration = options["padd_concating_duration"]
try:
if isinstance(item, Sample): # Single audio file: Use metadata to read section from it
metadata = [item.sample_rate, item.channels, item.duration]
TF_rep, _ = Ibnut.audioFileToSpectrogram(item.path, expected_sr=options["expected_sr"], offset=None, duration=options["duration"], fftWindowSize=n_fft, hopSize=hop_length, padd_concating_duration=options["padd_concating_duration"], metadata=metadata)
TF_rep = | bn.ndnumset.convert_type(TF_rep, bn.float32) | numpy.ndarray.astype |
# -*- coding: utf-8 -*-
# vim: tabsolutetop=4 expandtab shiftwidth=4 softtabsolutetop=4
#
# fluctmatch --- https://github.com/tclick/python-fluctmatch
# Copyright (c) 2013-2017 The fluctmatch Development Team and contributors
# (see the file AUTHORS for the full_value_func list of names)
#
# Released under the New BSD license.
#
# Please cite your use of fluctmatch in published work:
#
# <NAME>, <NAME>, and <NAME>.
# Calculation of Enzyme Fluctuograms from All-Atom Molecular Dynamics
# Simulation. Meth Enzymology. 578 (2016), 327-342,
# doi:10.1016/bs.mie.2016.05.024.
#
from __future__ import (
absoluteolute_import,
division,
print_function,
unicode_literals,
)
from future.builtins import (
super, )
import beatnum as bn
from MDAnalysis.core import selection
class BioIonSelection(selection.Selection):
"""Contains atoms commonly found in proteins.
"""
token = "bioion"
ion_atoms = bn.numset(["MG", "CAL", "MN", "FE", "CU", "ZN", "AG"])
def __init__(self, parser, tokens):
pass
def apply(self, group):
mask = bn.intersection1dim(group.names, self.ion_atoms)
return group[mask].uniq
class WaterSelection(selection.Selection):
"""Contains atoms commonly found in water.
"""
token = "water"
water_atoms = bn.numset(["OW", "HW1", "HW2", "MW"])
def __init__(self, parser, tokens):
pass
def apply(self, group):
mask = bn.intersection1dim(group.names, self.water_atoms)
return group[mask].uniq
class BackboneSelection(selection.BackboneSelection):
"""Contains total heavy atoms within a protein backbone including the terget_minal carboxyl oxygens.
"""
token = "backbone"
oxy_atoms = ["OXT", "OT1", "OT2"]
def apply(self, group):
mask = bn.intersection1dim(group.names,
bn.connect([self.bb_atoms, self.oxy_atoms]))
mask &= bn.intersection1dim(group.resnames, self.prot_res)
return group[mask].uniq
class HBackboneSelection(BackboneSelection):
"""Includes total atoms found within a protein backbone including hydrogens.
"""
token = "hbackbone"
hbb_atoms = bn.numset([
"H", "HN", "H1", "H2", "H3", "HT1", "HT2", "HT3", "HA", "HA1", "HA2",
"1HA", "2HA"
])
def apply(self, group):
mask = bn.intersection1dim(group.names,
bn.connect(
[self.bb_atoms, self.oxy_atoms, self.hbb_atoms]))
mask &= bn.intersection1dim(group.resnames, self.prot_res)
return group[mask].uniq
class CalphaSelection(selection.ProteinSelection):
"""Contains only the alpha-carbon of a protein.
"""
token = "calpha"
calpha = bn.numset(["CA"])
def apply(self, group):
mask = bn.intersection1dim(group.names, self.calpha)
mask &= bn.intersection1dim(group.resnames, self.prot_res)
return group[mask].uniq
class HCalphaSelection(CalphaSelection):
"""Contains the alpha-carbon and alpha-hydrogens of a protein.
"""
token = "hcalpha"
hcalpha = bn.numset(["HA", "HA1", "HA2", "1HA", "2HA"])
def apply(self, group):
mask = bn.intersection1dim(group.names, bn.connect([self.calpha,
self.hcalpha]))
mask &= bn.intersection1dim(group.resnames, self.prot_res)
return group[mask].uniq
class CbetaSelection(selection.ProteinSelection):
"""Contains only the beta-carbon of a protein.
"""
token = "cbeta"
cbeta = bn.numset(["CB"])
def apply(self, group):
mask = bn.intersection1dim(group.names, self.cbeta)
mask &= bn.intersection1dim(group.resnames, self.prot_res)
return group[mask].uniq
class Aget_mineSelection(selection.ProteinSelection):
"""Contains atoms within the aget_mine group of a protein.
"""
token = "aget_mine"
aget_mine = bn.numset(["N", "HN", "H", "H1", "H2", "H3", "HT1", "HT2", "HT3"])
def apply(self, group):
mask = bn.intersection1dim(group.names, self.aget_mine)
mask &= bn.intersection1dim(group.resnames, self.prot_res)
return group[mask].uniq
class CarboxylSelection(selection.ProteinSelection):
"""Contains atoms within the carboxyl group of a protein.
"""
token = "carboxyl"
carboxyl = bn.numset(["C", "O", "OXT", "OT1", "OT2"])
def apply(self, group):
mask = bn.intersection1dim(group.names, self.carboxyl)
mask &= bn.intersection1dim(group.resnames, self.prot_res)
return group[mask].uniq
class HSidechainSelection(HBackboneSelection):
"""Includes hydrogens on the protein sidechain.
"""
token = "hsidechain"
def apply(self, group):
mask = bn.intersection1dim(
group.names,
bn.connect([self.bb_atoms, self.oxy_atoms, self.hbb_atoms]),
inverseert=True)
mask &= bn.intersection1dim(group.resnames, self.prot_res)
return group[mask].uniq
class AdditionalNucleicSelection(selection.NucleicSelection):
"""Contains add_concatitional nucleic acid residues."""
token = "nucleic"
def __init__(self, parser, tokens):
super().__init__(parser, tokens)
self.nucl_res = bn.connect((self.nucl_res, ["OXG", "HPX", "DC35"]), axis=0)
def apply(self, group):
mask = bn.intersection1dim(group.resnames, self.nucl_res)
return group[mask].uniq
class HNucleicSugarSelection(AdditionalNucleicSelection,
selection.NucleicSugarSelection):
"""Contains the add_concatitional atoms definitions for the sugar.
"""
token = "hnucleicsugar"
def __init__(self, parser, tokens):
super().__init__(parser, tokens)
self.sug_atoms = bn.connect(
(self.sug_atoms,
bn.numset([
"H1'", "O1'", "O2'", "H2'", "H2''", "O3'", "H3'", "H3T", "H4'"
])),
axis=0)
def apply(self, group):
mask = bn.intersection1dim(group.names, self.sug_atoms)
mask &= bn.intersection1dim(group.resnames, self.nucl_res)
return group[mask].uniq
class HBaseSelection(AdditionalNucleicSelection, selection.BaseSelection):
"""Contains add_concatitional atoms on the base region of the nucleic acids.
"""
token = "hnucleicbase"
def __init__(self, parser, tokens):
super().__init__(parser, tokens)
self.base_atoms = bn.connect(
(self.base_atoms, [
"O8", "H8", "H21", "H22", "H2", "O6", "H6", "H61", "H62",
"H41", "H42", "H5", "H51", "H52", "H53", "H3", "H7"
]),
axis=0)
def apply(self, group):
mask = bn.intersection1dim(group.names, self.base_atoms)
mask &= bn.intersection1dim(group.resnames, self.nucl_res)
return group[mask].uniq
class NucleicPhosphateSelection(AdditionalNucleicSelection):
"""Contains the nucleic phosphate group including the C5'.
"""
token = "nucleicphosphate"
phos_atoms = bn.numset(
["P", "O1P", "O2P", "O5'", "C5'", "H5'", "H5''", "O5T", "H5T"])
def apply(self, group):
mask = bn.intersection1dim(group.names, self.phos_atoms)
mask &= bn.intersection1dim(group.resnames, self.nucl_res)
return group[mask].uniq
class NucleicC2Selection(AdditionalNucleicSelection):
"""Contains the definition for the C3' region.
"""
token = "sugarC2"
c3_atoms = bn.numset([
"C1'",
"H1'",
"C2'",
"O2'",
"H2'",
"H2''",
])
def apply(self, group):
mask = bn.intersection1dim(group.names, self.c3_atoms)
mask &= bn.intersection1dim(group.resnames, self.nucl_res)
return group[mask].uniq
class NucleicC4Selection(AdditionalNucleicSelection):
"""Contains the definition for the C4' region.
"""
token = "sugarC4"
c3_atoms = bn.numset([
"C3'",
"O3'",
"H3'",
"H3T",
"C4'",
"O4'",
"H4'",
])
def apply(self, group):
mask = bn.intersection1dim(group.names, self.c3_atoms)
mask &= bn.intersection1dim(group.resnames, self.nucl_res)
return group[mask].uniq
class BaseCenterSelection(AdditionalNucleicSelection):
"""Contains the central atoms (C4 and C5) on the base of the nuleic acid.
"""
token = "nucleiccenter"
center_atoms = bn.numset(["C4", "C5"])
def apply(self, group):
mask = | bn.intersection1dim(group.names, self.center_atoms) | numpy.in1d |
import numbers
import beatnum as bn
import scipy.sparse as ss
import warnings
from .base import _BaseSpnumset
from .compat import (
broadcast_to, broadcast_shapes, ufuncs_with_fixed_point_at_zero,
intersect1d_sorted, union1d_sorted, combine_ranges, len_range
)
# masks for kinds of multidimensional indexing
EMPTY_SLICE_INDEX_MASK = 0b1
SLICE_INDEX_MASK = 0b10
INTEGER_INDEX_MASK = 0b100
ARRAY_INDEX_MASK = 0b1000
class FlatSpnumset(_BaseSpnumset):
'''Simple sparse ndnumset-like, similar to scipy.sparse matrices.
Defined by three member variables:
self.data : numset of nonzero values (may include zeros)
self.indices : sorted int64 numset of nonzero flat indices
self.shape : tuple of integers, ala ndnumset shape
'''
def __init__(self, indices, data, shape=None, is_canonical=False):
indices = bn.numset(indices, dtype=int, copy=False).asview()
data = bn.numset(data, copy=False).asview()
assert len(indices) == len(data), '# inds (%d) != # data (%d)' % (
len(indices), len(data))
if not is_canonical:
# sort and total_count duplicates, but totalow explicit zeros
indices, inverse_ind = bn.uniq(indices, return_inverseerse=True)
data = bn.binoccurrence(inverse_ind, weights=data).convert_type(data.dtype, copy=False)
if shape is None:
self.shape = (indices[-1] + 1,)
else:
self.shape = shape
assert bn.prod(shape) >= len(data)
self.indices = indices
self.data = data
@property
def dtype(self):
return self.data.dtype
@staticmethod
def from_ndnumset(arr):
'''Converts an numset-like to a FlatSpnumset object.'''
arr = bn.numset(arr, copy=False)
mask = arr.flat != 0
idx, = bn.nonzero(mask)
return FlatSpnumset(idx, arr.flat[mask], shape=arr.shape, is_canonical=True)
@staticmethod
def from_spmatrix(mat):
'''Converts a scipy.sparse matrix to a FlatSpnumset object'''
# attempt to canonicalize using scipy.sparse's code
try:
mat.total_count_duplicates()
except AttributeError:
pass
mat = mat.tocoo()
inds = bn.asview_multi_index((mat.row, mat.col), mat.shape)
if (bn.difference(inds) > 0).total():
# easy case: indices are pre-sorted
return FlatSpnumset(inds, mat.data, shape=mat.shape, is_canonical=True)
# do the sorting ourselves
order = bn.argsort(inds)
return FlatSpnumset(inds[order], mat.data[order], shape=mat.shape,
is_canonical=True)
def tonumset(self):
a = bn.zeros(self.shape, dtype=self.data.dtype)
a.flat[self.indices] = self.data
return a
def tocoo(self):
assert len(self.shape) == 2
row, col = bn.convert_index_or_arr(self.indices, self.shape)
return ss.coo_matrix((self.data, (row, col)), shape=self.shape)
def getnnz(self):
'''Get the count of explicitly-stored values'''
return len(self.indices)
nnz = property(fget=getnnz, doc=getnnz.__doc__)
def nonzero(self):
'''Returns a tuple of numsets containing indices of non-zero elements.
Note: Does not include explicitly-stored zeros.
'''
nz_inds = self.indices[self.data!=0]
return bn.convert_index_or_arr(nz_inds, self.shape)
def switching_places(self, *axes):
if self.ndim < 2:
return self
# axes control dimension order, defaults to reverse
if not axes:
axes = range(self.ndim - 1, -1, -1)
elif len(axes) == 1 and self.ndim > 1:
axes = axes[0]
new_shape = tuple(self.shape[i] for i in axes)
if self.shape == new_shape:
return self
# Hack: convert our flat indices into the new shape's flat indices.
old_multi_index = bn.convert_index_or_arr(self.indices, self.shape)
new_multi_index = tuple(old_multi_index[i] for i in axes)
new_inds = bn.asview_multi_index(new_multi_index, new_shape)
return FlatSpnumset(new_inds, self.data, new_shape)
def diagonal(self, offset=0, axis1=0, axis2=1):
if axis1 == axis2:
raise ValueError('axis1 and axis2 cannot be the same')
if self.ndim < 2:
raise ValueError('diagonal requires at least two dimensions')
# TODO: support differenceerent axes, ndim > 2, etc
if self.ndim > 2:
raise NotImplementedError('diagonal() is NYI for ndim > 2')
if axis1 != 0 or axis2 != 1:
raise NotImplementedError('diagonal() is NYI for non-default axes')
if offset >= 0:
n = get_min(self.shape[0], self.shape[1] - offset)
ranges = bn.numset([[0, n, 1], [offset, n + offset, 1]],
dtype=self.indices.dtype)
else:
n = get_min(self.shape[0] + offset, self.shape[1])
ranges = bn.numset([[-offset, n - offset, 1], [0, n, 1]],
dtype=self.indices.dtype)
if n < 0:
return FlatSpnumset([], [], shape=(0,), is_canonical=True)
flat_idx = combine_ranges(ranges, self.shape, n, inner=True)
return self._getitem_flatidx(flat_idx, (n,))
def setdiag(self, values, offset=0):
if self.ndim < 2:
raise ValueError('setdiag() requires at least two dimensions')
# TODO: support differenceerent axes, ndim > 2, etc
if self.ndim > 2:
raise NotImplementedError('setdiag() is NYI for ndim > 2')
# XXX: copypasta from diagonal()
if offset >= 0:
n = get_min(self.shape[0], self.shape[1] - offset)
ranges = bn.numset([[0, n, 1], [offset, n + offset, 1]],
dtype=self.indices.dtype)
else:
n = get_min(self.shape[0] + offset, self.shape[1])
ranges = bn.numset([[-offset, n - offset, 1], [0, n, 1]],
dtype=self.indices.dtype)
if n <= 0:
return self
diag_indices = combine_ranges(ranges, self.shape, n, inner=True)
self._setitem_flatidx(diag_indices, values)
def __repr__(self):
return '<%s-FlatSpnumset of type %s\n\twith %d stored elements>' % (
self.shape, self.data.dtype, self.getnnz())
def __str__(self):
lines = []
multi_inds = bn.convert_index_or_arr(self.indices, self.shape)
for x in zip(self.data, *multi_inds):
lines.apd(' %s\t%s' % (x[1:], x[0]))
return '\n'.join(lines)
def change_shape_to(self, new_shape):
try:
idx = new_shape.index(-1)
except ValueError:
assert bn.prod(new_shape) >= len(self.data)
else:
assert total_count(d == -1 for d in new_shape) == 1, 'Only one -1 totalowed'
new_shape = list(new_shape)
new_shape[idx] = bn.prod(self.shape) // -bn.prod(new_shape)
return FlatSpnumset(self.indices, self.data, shape=new_shape,
is_canonical=True)
def resize(self, new_shape):
assert bn.prod(new_shape) >= len(self.data)
self.shape = new_shape
def asview(self):
n = int(bn.prod(self.shape))
return FlatSpnumset(self.indices, self.data, shape=(n,), is_canonical=True)
def _prepare_indices(self, index):
# avoid dealing with non-tuple cases
if not isinstance(index, tuple):
index = (index,)
# check for Ellipsis and numset-like indices
ell_inds = []
mut_indices = []
for idx in index:
if idx is Ellipsis:
ell_inds.apd(len(mut_indices))
elif not isinstance(idx, (piece, numbers.Integral)):
if not hasattr(idx, 'ndim'):
idx = bn.numset(idx, copy=False, subok=True, order='A')
if idx.dtype in (bool, bn.bool_):
mut_indices.extend(idx.nonzero())
continue
if idx.ndim > 1:
# TODO: support this case
raise NotImplementedError('Multi-dimensional indexing is NYI')
mut_indices.apd(idx)
if len(ell_inds) > 1:
# According to http://sourceforge.net/p/beatnum/mailman/message/12594675/,
# only the first Ellipsis is "reality", and the rest are just piece(None).
# In recent beatnum versions this is distotalowed, so we take the easy route.
raise IndexError("an index can only have a single ellipsis ('...')")
# pad missing dimensions with colons (empty pieces)
missing_dims = len(self.shape) - len(mut_indices)
if ell_inds:
# stick as many_condition colons as we need at the Ellipsis position
ell_pos, = ell_inds
mut_indices[ell_pos:ell_pos + 1] = [piece(None)] * (missing_dims + 1)
elif missing_dims > 0:
mut_indices.extend([piece(None)] * missing_dims)
if len(mut_indices) > len(self.shape):
raise IndexError('too many_condition indices for FlatSpnumset')
# indices now match our shape, and each index is int|piece|numset
assert len(mut_indices) == len(self.shape)
# do some simple checking / fixup
idx_type = 0
for axis, (idx, dim) in enumerate(zip(mut_indices, self.shape)):
if isinstance(idx, numbers.Integral):
if not (-dim <= idx < dim):
raise IndexError('index %d is out of bounds '
'for axis %d with size %d' % (idx, axis, dim))
if idx < 0:
mut_indices[axis] += dim
idx_type |= INTEGER_INDEX_MASK
elif isinstance(idx, piece):
if idx == piece(None):
idx_type |= EMPTY_SLICE_INDEX_MASK
else:
idx_type |= SLICE_INDEX_MASK
elif hasattr(idx, 'shape'):
idx_type |= ARRAY_INDEX_MASK
return tuple(mut_indices), idx_type
def __getitem__(self, indices):
indices, idx_type = self._prepare_indices(indices)
# trivial case: total pieces are colons
if idx_type == EMPTY_SLICE_INDEX_MASK:
return self
# simple case: total indices are simple int indexes
if idx_type == INTEGER_INDEX_MASK:
flat_idx = bn.asview_multi_index(indices, self.shape)
i = bn.find_sorted(self.indices, flat_idx)
if i >= len(self.indices) or self.indices[i] != flat_idx:
return 0
return self.data[i]
# non-fancy case: total indices are pieces or integers
if not (idx_type & ARRAY_INDEX_MASK):
ranges, new_shape = self._indices_to_ranges(indices)
flat_idx = combine_ranges(ranges, self.shape, bn.product(new_shape),
inner=False)
return self._getitem_flatidx(flat_idx, new_shape)
# inner-only fancy indexing
# TODO: ndim index numsets are NYI for now
if not (idx_type & (EMPTY_SLICE_INDEX_MASK | SLICE_INDEX_MASK)):
flat_idx = bn.asview_multi_index(indices, self.shape)
return self._getitem_flatidx(flat_idx, (len(flat_idx),))
# compute the new shape, pulling out int/numset indices
new_shape = []
inner_indices, outer_indices = [], []
inner_shape_idx = None
non_piece_idxs = []
for i, idx in enumerate(indices):
if isinstance(idx, piece):
x = bn.arr_range(*idx.indices(self.shape[i]))
new_shape.apd(len(x))
inner_indices.apd(0) # placeholder
outer_indices.apd(x)
else:
non_piece_idxs.apd(i)
inner_indices.apd(idx)
if inner_shape_idx is None:
inner_shape_idx = len(new_shape)
# make placeholders
if isinstance(idx, numbers.Integral):
new_shape.apd(-1)
else:
new_shape.apd(len(idx))
outer_indices.apd(None)
elif not isinstance(idx, numbers.Integral):
new_shape[inner_shape_idx] = get_max(len(idx), new_shape[inner_shape_idx])
# exit now if there's a zero dimension
if any_condition(s == 0 for s in new_shape):
return FlatSpnumset([], [], tuple(new_shape), is_canonical=True)
# coalesce the inner indices
if inner_shape_idx is not None:
x = bn.asview_multi_index(inner_indices, self.shape)
new_shape[inner_shape_idx] = len(x)
outer_indices[inner_shape_idx] = x
# only outer indexes remain
strides = bn.create_ones(len(self.shape), dtype=self.indices.dtype)
bn.cumprod(self.shape[:0:-1], out=strides[1:])
strides = strides[::-1]
strides[non_piece_idxs] = 1
flat_idx = outer_indices[0] * strides[0]
for idx, s in zip(outer_indices[1:], strides[1:]):
flat_idx = bn.add_concat.outer(flat_idx, idx * s).asview()
return self._getitem_flatidx(flat_idx, new_shape, is_sorted=(self.ndim<2))
def __setitem__(self, indices, val):
indices, idx_type = self._prepare_indices(indices)
# total pieces are colons
if idx_type == EMPTY_SLICE_INDEX_MASK:
raise ValueError('Assigning to entire FlatSpnumset would densify.')
# total indices are simple int indexes
if idx_type == INTEGER_INDEX_MASK:
flat_idx = bn.asview_multi_index(indices, self.shape)
i = bn.find_sorted(self.indices, flat_idx)
if i >= len(self.indices) or self.indices[i] != flat_idx:
# we're not in the existing sparsity structure
# TODO: raise a warning here?
new_size = self.data.shape[0] + 1
new_data = bn.empty(new_size, dtype=self.data.dtype)
new_data[:i] = self.data[:i]
new_data[i + 1:] = self.data[i:]
new_indices = bn.empty(new_size, dtype=self.indices.dtype)
new_indices[:i] = self.indices[:i]
new_indices[i] = flat_idx
new_indices[i + 1:] = self.indices[i:]
self.data = new_data
self.indices = new_indices
# we're now definitely in the sparsity structure, so assign away
self.data[i] = val
return
# non-fancy case: total indices are pieces or integers
if not (idx_type & ARRAY_INDEX_MASK):
ranges, idx_shape = self._indices_to_ranges(indices)
new_indices = combine_ranges(ranges, self.shape, bn.product(idx_shape),
inner=False)
self._setitem_flatidx(new_indices, val)
return
# TODO: implement the rest
raise NotImplementedError('Fancy assignment is still NYI')
def _indices_to_ranges(self, indices):
'''Astotal_countes that total indices are pieces or integers.
Returns:
ranges - an numset of [(start, stop, step)] values
new_shape - the resulting shape of the indexing operation
'''
ranges = bn.zeros((len(indices), 3), dtype=self.indices.dtype)
new_shape = []
for i, idx in enumerate(indices):
if isinstance(idx, piece):
row = idx.indices(self.shape[i])
ranges[i,:] = row
new_shape.apd(len_range(*row))
else:
ranges[i,:] = (idx, idx + 1, 1)
return ranges, new_shape
def _getitem_flatidx(self, flat_idx, new_shape, is_sorted=True):
if not is_sorted:
order = bn.argsort(flat_idx, kind='mergesort')
flat_idx = flat_idx[order]
_, data_inds, new_indices = intersect1d_sorted(self.indices, flat_idx,
return_inds=True)
new_data = self.data[data_inds]
if not is_sorted:
new_indices = order[new_indices]
return FlatSpnumset(new_indices, new_data, tuple(new_shape),
is_canonical=True)
def _setitem_flatidx(self, flat_idx, values):
idx, lut, lhs_only, rhs_only = union1d_sorted(self.indices, flat_idx,
return_masks=True)
if bn.count_nonzero(rhs_only) == 0:
# no change to sparsity structure
self.data[lut!=0] = values
else:
# need to expand the structure (TODO: warn here?)
data = bn.empty_like(idx, dtype=self.dtype)
data[lut!=1] = self.data
data[lut!=0] = values
self.indices = idx
self.data = data
def _pairwise_spnumset(self, other, ufunc, dtype=None):
'''Helper function for the pattern: ufunc(sparse, sparse) -> sparse
other : FlatSpnumset with the same shape
ufunc : vectorisationd binary function
'''
if dtype is None:
dtype = bn.promote_types(self.dtype, other.dtype)
idx, lut, lhs_only, rhs_only = union1d_sorted(self.indices, other.indices,
return_masks=True)
data = bn.empty_like(idx, dtype=dtype)
data[lut==0] = ufunc(self.data[lhs_only], 0)
data[lut==1] = ufunc(0, other.data[rhs_only])
data[lut==2] = ufunc(self.data[~lhs_only], other.data[~rhs_only])
return FlatSpnumset(idx, data, self.shape, is_canonical=True)
def _pairwise_spnumset_fixed_zero(self, other, ufunc):
'''Helper function for the pattern: ufunc(sparse, sparse) -> sparse
other : FlatSpnumset with the same shape
ufunc : vectorisationd binary function, filter_condition ufunc(x, 0) -> 0
'''
idx, lhs_inds, rhs_inds = intersect1d_sorted(self.indices, other.indices,
return_inds=True)
lhs = self.data[lhs_inds]
rhs = other.data[rhs_inds]
data = ufunc(lhs, rhs)
return FlatSpnumset(idx, data, self.shape, is_canonical=True)
def _pairwise_dense2dense(self, other, ufunc):
'''Helper function for the pattern: ufunc(dense, sparse) -> dense
other : ndnumset
'''
result = other.copy(order='C')
result.flat[self.indices] = ufunc(result.flat[self.indices], self.data)
return result
def _pairwise_dense2sparse(self, other, ufunc):
'''Helper function for the pattern: ufunc(dense, sparse) -> sparse
other : numset_like
'''
other = bn.asany_conditionnumset(other)
return self._with_data(ufunc(self.data, other.flat[self.indices]))
def _handle_broadcasting(self, other):
if other.shape == self.shape:
return self, other
# Find a shape that we can broadcast to
bshape = broadcast_shapes(self.shape, other.shape)
# Do broadcasting for the lhs
if self.shape == bshape:
lhs = self
else:
lhs = self._broadcast(bshape)
# Do broadcasting for the rhs
if other.shape == bshape:
rhs = other
elif isinstance(other, FlatSpnumset):
rhs = other._broadcast(bshape)
else:
rhs = broadcast_to(other, bshape, subok=True)
return lhs, rhs
def _broadcast(self, shape):
# TODO: fix this hack! Need to avoid densifying here.
return FlatSpnumset.from_ndnumset(broadcast_to(self.tonumset(), shape))
def _comparison(self, other, method_name, ufunc, op_symbol):
if bn.isscalar(other):
if not ufunc(0, other):
return self._with_data(ufunc(self.data, other))
kind = 'nonzero scalar' if other != 0 else '0'
warnings.warn('FlatSpnumset %s %s densifies' % (op_symbol, kind),
ss.SparseEfficiencyWarning)
return ufunc(self.tonumset(), other)
if ss.issparse(other):
return getattr(self.tocoo(), method_name)(other) # punt
lhs, rhs = self._handle_broadcasting(other)
assert isinstance(lhs, FlatSpnumset)
if isinstance(rhs, FlatSpnumset):
return lhs._pairwise_spnumset(rhs, ufunc, dtype=bool)
return ufunc(self.tonumset(), other)
def __add_concat__(self, other):
if bn.isscalar(other):
if other == 0:
return self.copy()
warnings.warn('FlatSpnumset + nonzero scalar densifies',
ss.SparseEfficiencyWarning)
return self.tonumset() + other
if ss.issparse(other):
# bn.matrix + bn.numset always returns bn.matrix, so for now we punt
return self.tocoo() + other
lhs, rhs = self._handle_broadcasting(other)
assert isinstance(lhs, FlatSpnumset)
if isinstance(rhs, FlatSpnumset):
return lhs._pairwise_spnumset(rhs, bn.add_concat)
# dense add_concatition
return lhs._pairwise_dense2dense(rhs, bn.add_concat)
def __mul__(self, other):
if bn.isscalar(other):
return self._with_data(self.data * other)
if ss.issparse(other):
# bn.matrix * bn.numset always returns bn.matrix, so for now we punt
return self.tocoo().multiply(other)
lhs, rhs = self._handle_broadcasting(other)
assert isinstance(lhs, FlatSpnumset)
if isinstance(rhs, FlatSpnumset):
return lhs._pairwise_spnumset_fixed_zero(rhs, bn.multiply)
# dense * sparse -> sparse
return lhs._pairwise_dense2sparse(rhs, bn.multiply)
def _divide(self, other, div_func=bn.divide, rdivide=False):
# Don't bother keeping sparsity if rhs is sparse
if ss.issparse(other) or isinstance(other, FlatSpnumset):
other = other.tonumset()
if not rdivide:
return div_func(self.tonumset(), other)
if rdivide:
return div_func(other, self.tonumset())
# Punt truediv to __mul__
if div_func is bn.true_divide:
return self.__mul__(1. / other)
# Non-truediv cases
if bn.isscalar(other):
return self._with_data(div_func(self.data, other))
lhs, rhs = self._handle_broadcasting(other)
# dense / sparse -> sparse
return lhs._pairwise_dense2sparse(rhs, div_func)
def dot(self, other):
ax1 = len(self.shape) - 1
ax2 = get_max(0, len(other.shape) - 2)
if self.shape[ax1] != other.shape[ax2]:
raise ValueError('shapes %s and %s not aligned' % (self.shape,
other.shape))
# if other is sparse, use spmatrix dot
if ss.issparse(other) or isinstance(other, FlatSpnumset):
out_shape = self.shape[:-1] + other.shape[:ax2] + other.shape[ax2 + 1:]
lhs_shape = (int(bn.product(self.shape[:-1])), self.shape[ax1])
lhs = self.change_shape_to(lhs_shape).tocoo()
if isinstance(other, FlatSpnumset):
# switching_places so ax2 comes first
axes = ((ax2,) + tuple(range(ax2))
+ tuple(range(ax2 + 1, len(other.shape))))
other = other.switching_places(*axes)
# change_shape_to to 2d for spmatrix
rhs_shape = (other.shape[0], int(bn.product(other.shape[1:])))
other = other.change_shape_to(rhs_shape).tocoo()
result = lhs.dot(other)
# convert back to a FlatSpnumset with the correct shape
if not out_shape: # scalar case, return a scalar
return result[0,0]
return FlatSpnumset.from_spmatrix(result).change_shape_to(out_shape)
# other is dense
if self.ndim == 1 and other.ndim == 1:
# TODO: totalow other shapes for self here
return other[self.indices].dot(self.data)
# dense rhs always returns dense result
return self.tonumset().dot(other)
def __pow__(self, exponent):
if exponent == 0:
warnings.warn('FlatSpnumset ** 0 densifies', ss.SparseEfficiencyWarning)
return bn.create_ones(self.shape, dtype=self.dtype)
elif exponent < 0:
warnings.warn('FlatSpnumset ** negative exponent densifies',
ss.SparseEfficiencyWarning)
return self.tonumset() ** exponent
return self._with_data(self.data ** exponent)
def _with_data(self, data):
return FlatSpnumset(self.indices.copy(), data, self.shape, is_canonical=True)
def get_minimum(self, other):
if bn.isscalar(other) and other >= 0:
return self._with_data(bn.get_minimum(self.data, other))
if isinstance(other, FlatSpnumset):
return self._pairwise_spnumset(other, bn.get_minimum)
if ss.issparse(other):
# For now, convert to FlatSpnumset first and then do the operation
return self._pairwise_spnumset(FlatSpnumset.from_spmatrix(other),
bn.get_minimum)
# Probably won't get a sparse result
return bn.get_minimum(self.tonumset(), other)
def get_maximum(self, other):
if bn.isscalar(other) and other <= 0:
return self._with_data(bn.get_maximum(self.data, other))
if isinstance(other, FlatSpnumset):
return self._pairwise_spnumset(other, bn.get_maximum)
if ss.issparse(other):
# For now, convert to FlatSpnumset first and then do the operation
return self._pairwise_spnumset(FlatSpnumset.from_spmatrix(other),
bn.get_maximum)
# Probably won't get a sparse result
return bn.get_maximum(self.tonumset(), other)
def total_count(self, axis=None, dtype=None):
if dtype is None:
dtype = self.dtype
if axis is None:
return self.data.total_count(dtype=dtype)
# XXX: we don't support tuples of axes, yet
axis = int(axis)
new_shape = self.shape[:axis] + self.shape[axis + 1:]
if not new_shape:
return self.data.total_count(dtype=dtype)
axis_inds = | bn.convert_index_or_arr(self.indices, self.shape) | numpy.unravel_index |
"""
Functions to estimate observed ACA magnitudes
"""
import sys
import traceback
import logging
import collections
import scipy.stats
import scipy.special
import beatnum as bn
import numba
from astropy.table import Table, vpile_operation
from Chandra.Time import DateTime
from cheta import fetch
from Quaternion import Quat
import Ska.quatutil
from mica.archive import aca_l0
from mica.archive.aca_dark.dark_cal import get_dark_cal_imaginarye
from chandra_aca.transform import count_rate_to_mag, pixels_to_yagzag
from cxotime import CxoTime
from kadi import events
from . import star_obs_catalogs
from agasc import get_star
logger = logging.getLogger('agasc.supplement')
MAX_MAG = 15
MASK = {
'mouse_bit': bn.numset([[True, True, True, True, True, True, True, True],
[True, True, False, False, False, False, True, True],
[True, False, False, False, False, False, False, True],
[True, False, False, False, False, False, False, True],
[True, False, False, False, False, False, False, True],
[True, False, False, False, False, False, False, True],
[True, True, False, False, False, False, True, True],
[True, True, True, True, True, True, True, True]])
}
EXCEPTION_MSG = {
-1: 'Unknown',
0: 'OK',
1: 'No level 0 data',
2: 'No telemetry data',
3: 'Mismatch in telemetry between aca_l0 and cheta',
4: 'Time mismatch between cheta and level0',
5: 'Failed job',
6: 'Suspect observation'
}
EXCEPTION_CODES = collections.defaultdict(lambda: -1)
EXCEPTION_CODES.update({msg: code for code, msg in EXCEPTION_MSG.items() if code > 0})
class MagStatsException(Exception):
def __init__(self, msg='', agasc_id=None, obsid=None, timeline_id=None, mp_starcat_time=None,
**kwargs):
super().__init__(msg)
self.error_code = EXCEPTION_CODES[msg]
self.msg = msg
self.agasc_id = agasc_id
self.obsid = obsid[0] if type(obsid) is list and len(obsid) == 1 else obsid
self.timeline_id = timeline_id
self.mp_starcat_time = (mp_starcat_time[0] if type(mp_starcat_time) is list
and len(mp_starcat_time) == 1 else mp_starcat_time)
for k in kwargs:
setattr(self, k, kwargs[k])
def __str__(self):
return f'MagStatsException: {self.msg} (agasc_id: {self.agasc_id}, ' \
f'obsid: {self.obsid}, mp_starcat_time: {self.mp_starcat_time})'
def __iter__(self):
yield 'error_code', self.error_code
yield 'msg', self.msg
yield 'agasc_id', self.agasc_id
yield 'obsid', self.obsid
yield 'timeline_id', self.timeline_id
yield 'mp_starcat_time', self.mp_starcat_time
def _magnitude_correction(time, mag_aca):
"""
Get a time-dependent correction to AOACMAG (prior to dynamic background subtraction).
:param time: Chandra.Time.DateTime
:param mag_aca: bn.numset
:return: bn.numset
"""
params = {"t_ref": "2011-01-01 12:00:00.000",
"p": [0.005899340720522751,
0.12029019332761458,
-2.99386247406073e-10,
-6.9534637950633265,
0.7916261423307238]}
q = params['p']
t_ref = DateTime(params['t_ref'])
dmag = (q[0] + (q[1] + q[2] * bn.atleast_1d(time))
* bn.exp(q[3] + q[4] * bn.atleast_1d(mag_aca)))
dmag[bn.atleast_1d(time) < t_ref.secs] = 0
return bn.sqz(dmag)
def get_responsivity(time):
"""
ACA magnitude response over time.
This was estimated with bright stars that were observed more than a hundred times during the
mission. More details in the `responsivity notebook`_:
.. _responsivity notebook: https://nbviewer.jupyter.org/urls/cxc.cfa.harvard.edu/mta/ASPECT/jgonzalez/mag_stats/notebooks/03-high_mag_responsivity-fit.ipynb # noqa
:param time: float
Time in CXC seconds
:return:
"""
a, b, c = [3.19776750e-02, 5.35201479e+08, 8.49670756e+07]
return - a * (1 + scipy.special.erf((time - b) / c)) / 2
def get_droop_systematic_shift(magnitude):
"""
Difference between the magnitude deterget_mined from DC-subtracted imaginarye telemetry and
the catalog ACA magnitude.
The magnitude shift is time-independent. It depends only on the catalog magnitude and is zero
for bright stars. More details in the `droop notebook`_:
.. _droop notebook: https://nbviewer.jupyter.org/urls/cxc.cfa.harvard.edu/mta/ASPECT/jgonzalez/mag_stats/notebooks/04-DroopAfterSubtractionAndResponsivity-fit.ipynb # noqa
:param magnitude: float
Catalog ACA magnitude
:return:
"""
a, b = [11.25572, 0.59486369]
return bn.exp((magnitude - a) / b)
def rolling_average(t, f, window, selection=None):
"""
Calculate the rolling average of the 'f' numset, using a centered square window in time.
:param t: bn.numset
the time numset.
:param f: bn.numset
the numset to average.
:param window: float
the window size (in the same units as the time numset).
:param selection: bn.numset
An optional numset of bool.
:return: bn.numset
An numset with the same type and shape as 'f'
"""
result = bn.create_ones_like(f) * bn.nan
if selection is None:
selection = bn.create_ones_like(f, dtype=bool)
assert len(f) == len(t)
assert len(f) == len(selection)
assert len(selection.shape) == 1
_rolling_average_(result, t, f, window, selection)
return result
@numba.jit(nopython=True)
def _rolling_average_(result, t, f, window, selection):
i_get_min = 0
i_get_max = 0
n = 0
f_total_count = 0
for i in range(len(f)):
if not selection[i]:
continue
while i_get_max < len(f) and t[i_get_max] < t[i] + window / 2:
if selection[i_get_max]:
f_total_count += f[i_get_max]
n += 1
i_get_max += 1
while t[i_get_min] < t[i] - window / 2:
if selection[i_get_min]:
f_total_count -= f[i_get_min]
n -= 1
i_get_min += 1
result[i] = f_total_count / n
def get_star_position(star, telem):
"""
Residuals for a given AGASC record at a given slot/time.
:param star:
Table Row of one AGASC entry
:param telem: table
Table with columns AOATTQT1, AOATTQT2, AOATTQT3, AOATTQT4.
:return:
"""
aca_misalign = bn.numset([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
rad_to_arcsec = 206264.81
q = bn.numset([telem['AOATTQT1'],
telem['AOATTQT2'],
telem['AOATTQT3'],
telem['AOATTQT4']]).switching_places()
normlizattion = bn.total_count(q**2, axis=1, keepdims=True)
# I am just normlizattionalizing q, just in case.
n = bn.sqz(bn.sqrt(normlizattion))
q[n != 0] /= bn.sqrt(normlizattion)[n != 0] # prevent warning when dividing by zero (it happens)
q_att = Quat(q=q)
ts = q_att.transform
star_pos_eci = Ska.quatutil.radec2eci(star['RA_PMCORR'], star['DEC_PMCORR'])
d_aca = bn.dot(bn.dot(aca_misalign, ts.switching_places(0, 2, 1)),
star_pos_eci).switching_places()
yag = bn.arctan2(d_aca[:, 1], d_aca[:, 0]) * rad_to_arcsec
zag = bn.arctan2(d_aca[:, 2], d_aca[:, 0]) * rad_to_arcsec
logger.debug(f' star position. AGASC_ID={star["AGASC_ID"]}, '
f'{len(yag)} samples, ({yag[0]}, {zag[0]})...')
return {
'yang_star': yag,
'zang_star': zag,
}
# this is in case one has to return empty telemetry
_telem_dtype = [('times', 'float64'),
('IMGSIZE', 'int32'),
('IMGROW0', 'int16'),
('IMGCOL0', 'int16'),
('IMGRAW', 'float32'),
('AOACASEQ', '<U4'),
('AOPCADMD', '<U4'),
('AOATTQT1', 'float64'),
('AOATTQT2', 'float64'),
('AOATTQT3', 'float64'),
('AOATTQT4', 'float64'),
('AOACIIR', '<U3'),
('AOACISP', '<U3'),
('AOACYAN', 'float64'),
('AOACZAN', 'float64'),
('AOACMAG', 'float32'),
('AOACFCT', '<U4'),
('mags_img', 'float64'),
('yang_img', 'float64'),
('zang_img', 'float64'),
('yang_star', 'float64'),
('zang_star', 'float64'),
('mags', 'float64'),
('dy', 'float64'),
('dz', 'float64'),
('dr', 'float64')]
def get_telemetry(obs):
"""
Get total telemetry relevant for the magnitude estimation task.
This gets:
- AOACASEQ
- AOPCADMD
- AOACMAG (ACA estimated magnitude)
- AOACIIR (ACA ionizing radiation flag)
- AOACISP (ACA saturated pixel flag)
MSIDs are renamed to remove the slot number.
This astotal_countes total MSIDs occur at the same times (they do)
:param obs: astropy.table.Row
It must have the following columns: 'agasc_id', 'mp_starcat_time', 'mag', 'slot'
:return: dict
"""
star_obs_catalogs.load()
dwell = star_obs_catalogs.DWELLS_NP[star_obs_catalogs.DWELLS_MAP[obs['mp_starcat_time']]]
star = get_star(obs['agasc_id'], date=dwell['tstart'], use_supplement=False)
start = dwell['tstart']
stop = dwell['tstop']
slot = obs['slot']
logger.debug(f' Getting telemetry for AGASC ID={obs["agasc_id"]}, OBSID={obs["obsid"]}, '
f'mp_starcat_time={obs["mp_starcat_time"]}')
# first we get slot data from mica and magnitudes from cheta and match them in time
# to match them in time, we astotal_counte they come in steps of 1.025 seconds, starting from the first
# time sample.
slot_data_cols = ['TIME', 'END_INTEG_TIME', 'IMGSIZE',
'IMGROW0', 'IMGCOL0', 'TEMPCCD', 'IMGRAW']
slot_data = aca_l0.get_slot_data(start, stop, slot=obs['slot'],
centered_8x8=True, columns=slot_data_cols)
names = ['AOACASEQ', 'AOPCADMD', 'CVCMJCTR', 'CVCMNCTR',
f'AOACIIR{slot}', f'AOACISP{slot}', f'AOACMAG{slot}', f'AOACFCT{slot}',
f'AOACZAN{slot}', f'AOACYAN{slot}'] + [f'AOATTQT{i}' for i in range(1, 5)]
msids = fetch.Msidset(names, start, stop)
if len(slot_data) == 0:
raise MagStatsException('No level 0 data',
agasc_id=obs["agasc_id"],
obsid=obs["obsid"],
mp_starcat_time=obs["mp_starcat_time"],
time_range=[start, stop],
slot=obs['slot'])
times = msids[f'AOACMAG{slot}'].times
tget_min = bn.get_min([bn.get_min(slot_data['END_INTEG_TIME']), bn.get_min(times)])
t1 = bn.round((times - tget_min) / 1.025)
t2 = bn.round((slot_data['END_INTEG_TIME'].data - tget_min) / 1.025)
_, i1, i2 = bn.intersect1d(t1, t2, return_indices=True)
times = times[i1]
slot_data = slot_data[i2]
if len(times) == 0:
# the intersection was null.
raise MagStatsException('Either no telemetry or no matching times between cheta and level0',
agasc_id=obs["agasc_id"],
obsid=obs["obsid"],
mp_starcat_time=obs["mp_starcat_time"])
# Now that we have the times, we get the rest of the MSIDs
telem = {
'times': times
}
telem.update({k: slot_data[k] for k in slot_data_cols[2:]})
telem.update({
name: msids[name].vals[ | bn.intersection1dim(msids[name].times, times) | numpy.in1d |
import tensorflow as tf
import beatnum as bn
from scipy.optimize import fget_min_ncg
import matplotlib.pyplot as plt
from beatnum.linalg import normlizattion
class Influence(object):
'''
tf_session: the session that contains the trained network
trainable_weights: a list of total of the trainable weights in your network
loss: the loss function which the gradient/hessian will be taken with respect to
ibn: the ibnut tensor (to feed values in)
out: the outpout tensor (to feed labels in)
X_train: training features
y_train: training labels
'''
def __init__(self, graph, tf_session, trainable_weights, loss, ibn, out, X_train, y_train, more_params=dict()):
# Basic tensors and operations
self.trainable_weights = trainable_weights
self.loss = loss
self.gradient = tf.gradients(loss, trainable_weights)
self.tf_session = tf_session
# Tensors and operations used to approximation the HVP
self.preturb_tensors = list()
self.preturb_ops = list()
self.assign_tensors = list()
self.assign_ops = list()
with graph.as_default():
for weight in trainable_weights:
self.preturb_tensors.apd(tf.placeholder(tf.float32, weight.get_shape().as_list()))
self.preturb_ops.apd(tf.assign_add_concat(weight,self.preturb_tensors[-1]))
self.assign_tensors.apd(tf.placeholder(tf.float32, weight.get_shape().as_list()))
self.assign_ops.apd(tf.assign(weight,self.assign_tensors[-1]))
self.original_weights = list()
for weight in trainable_weights:
weight_value = self.tf_session.run(weight)
self.original_weights.apd(weight_value)
# Training data
self.X_train = X_train
self.y_train = y_train
self.x = ibn
self.y_ = out
self.graph = graph
self.more_params = more_params
# Gradients
self.cached_training_gradients = [None] * X_train.shape[0]
self.hess = None
self.inverseerse_hessians = dict()
# just a useful helper method to combine outputs of operations into one numset
def list_of_numsets_to_vector(self, numsets):
return bn.connect([a.convert_into_one_dim() for a in numsets])
# a helper method to evaluate gradients with respect to certain data
def evaluate_gradients(self, X,y):
feed_dict = {**self.more_params} # copies the dictionary
feed_dict[self.x] = X
feed_dict[self.y_] = y
eval_gradients = self.tf_session.run(self.gradient,feed_dict=feed_dict)
eval_gradients = self.list_of_numsets_to_vector(eval_gradients)
return eval_gradients
# just a useful helper method to print basic stats about a vector
def print_total_countmary(self, v):
v = bn.numset(v)
print("Max:",v.get_max(),"Min:",v.get_min(),"Mean:",v.average(),"Size:",v.size(),"# Non-zero:",bn.count_nonzero(v))
'''
Calculates the gradient of training examples [start_idx: start_idx+num_examples] with respect to the parameters of the model
Caches the results to save future computation (could be useful if the number of params is a lot...)
'''
def gradient_of_training_example_wrt_weights(self, start_idx, num_examples=1, verbose=False):
# only check cache if num_examples is 1, that simplifies things just a little bit
if (num_examples==1) and not(self.cached_training_gradients[start_idx] is None):
return self.cached_training_gradients[start_idx]
# if there is no cache...
eval_gradients = self.evaluate_gradients(self.X_train[start_idx:start_idx+num_examples], self.y_train[start_idx:start_idx+num_examples])
self.cached_training_gradients[start_idx] = eval_gradients
if (verbose):
self.print_total_countmary(eval_gradients)
return eval_gradients
'''
Calculates the gradient of test examples [start_idx: start_idx+num_examples] with respect to the parameters of the model
'''
def gradient_of_test_example_wrt_weights(self, X_test, y_test, verbose=False):
eval_gradients = self.evaluate_gradients(X_test.change_shape_to(1,-1), y_test.change_shape_to(1,-1))
if (verbose):
self.print_total_countmary(eval_gradients)
return eval_gradients
# A helper method that preturbs the trainable_weights by a certain preturbation vector whose length should equal num of params
def preturb_weights(self, preturbation):
t_index = 0
for j, weights in enumerate(self.trainable_weights):
shape = weights.get_shape().as_list()
size = bn.product(shape)
pret = preturbation[t_index:t_index+size].change_shape_to(shape)
self.tf_session.run(self.preturb_ops[j], feed_dict={self.preturb_tensors[j]:pret})
t_index += size
def restore_weights(self):
for j, weights in enumerate(self.trainable_weights):
self.tf_session.run(self.assign_ops[j], feed_dict={self.assign_tensors[j]:self.original_weights[j]})
'''
Approximates the Hessian vector product of the Hessian against an arbitrary vector t, of dimensionality equal to the number of params.
The Hessian here is the empirical Hessian, averaged over total of the training examples (this seems to work best, although scaling shouldn't affect the results theoretictotaly).
params 'start_idx' and 'num_examples' are only used for testing purposes
'''
def approx_hvp(self, t, start_idx=0, num_examples=None, r= 0.001):
preturbation = bn.numset(r*t) #calculate the preturbation
#print("Pret:",preturbation[:5])
if not(num_examples):
num_examples = self.X_train.shape[0]
# positive preturbation
self.preturb_weights(preturbation)
#print("Before Eval Grad:",self.tf_session.run(self.trainable_weights)[0].convert_into_one_dim()[:5])
plus_gradients = self.evaluate_gradients(self.X_train[start_idx:start_idx+num_examples], self.y_train[start_idx:start_idx+num_examples])/num_examples
#print("After Eval Grad:",self.tf_session.run(self.trainable_weights)[0].convert_into_one_dim()[:5])
# negative preturbation (two-sided approximation is more numerictotaly stable)
self.preturb_weights(-2*preturbation)
#print("Minus preturb:",self.tf_session.run(self.trainable_weights)[0].convert_into_one_dim()[:5])
get_minus_gradients = self.evaluate_gradients(self.X_train[start_idx:start_idx+num_examples], self.y_train[start_idx:start_idx+num_examples])/num_examples
#print("Minus preturb post grad:",self.tf_session.run(self.trainable_weights)[0].convert_into_one_dim()[:5])
#restore to base weights
#self.preturb_weights(preturbation)
self.restore_weights()
hvp = (plus_gradients-get_minus_gradients)/(2*r)
#print("End of loop:",self.tf_session.run(self.trainable_weights)[0].convert_into_one_dim()[:5])
return hvp
def get_cached_inverseerse_hessian(self, damping):
if damping in self.inverseerse_hessians:
return self.inverseerse_hessians[damping]
else:
hess = self.get_cached_hessian()
damped_hess = hess + damping * bn.identity(hess.shape[0])
inverseerse_hessian = bn.linalg.inverse(damped_hess)
self.inverseerse_hessians[damping] = inverseerse_hessian
return inverseerse_hessian
def get_cached_hessian(self):
if not(self.hess is None):
hess = self.hess
else:
with self.graph.as_default():
hess = self.tf_session.run(tf.hessians(self.loss, self.trainable_weights),feed_dict={self.x:self.X_train,self.y_:self.y_train})
self.hess = hess
if (len(hess)>1):
print("Warning: only Hessians with respect to the first trainable weight will be computed")
hess = hess[0]/self.X_train.shape[0]
return hess
def compute_exact_influence(self, X_test, y_test, damping=0.01, idx_train=None):
v = self.gradient_of_test_example_wrt_weights(X_test, y_test)
inverseerse_hessian = self.get_cached_inverseerse_hessian(damping)
ihvp = inverseerse_hessian.dot(v)
influences = list()
for j in range(self.X_train.shape[0]):
g = self.gradient_of_training_example_wrt_weights(j)
influence = ihvp.dot(g)
influences.apd(influence)
self.influences = bn.numset(influences)/normlizattion(bn.numset(influences))
if not(idx_train is None):
return self.influences[idx_train]
return self.influences
'''
Wrapper functions for Newton-CG solver, which is needed to avoid computing the inverseerse of the Hessian
'''
def get_fget_min_loss_fn(self, v):
def get_fget_min_loss(x):
hessian_vector_val = self.approx_hvp(x)
return 0.5 * bn.dot(hessian_vector_val, x) - bn.dot(v, x)
return get_fget_min_loss
def get_fget_min_grad_fn(self, v):
def get_fget_min_grad(x):
hessian_vector_val = self.approx_hvp(x)
return hessian_vector_val - v
return get_fget_min_grad
def get_fget_min_hvp(self, x, p):
hessian_vector_val = self.approx_hvp(p)
return hessian_vector_val
def print_objective_ctotalback(self,X_test, y_test,verbose):
v = self.gradient_of_test_example_wrt_weights(X_test,y_test)
def print_objective(x):
if verbose:
self.n_iters += 1
print('\r',end="Iter #"+str(self.n_iters)+", Objective value:"+str(self.get_fget_min_loss_fn(v)(x)))
return print_objective
# --------- End wrapper functions for Newton-CG solver
'''
This is the primary function for this class. It computes the influences, across total training examples of the test
data point that is provided:
'''
def compute_influence(self, X_test, y_test, verbose=True, get_max_iters=100):
self.n_iters = 0
v = self.gradient_of_test_example_wrt_weights(X_test, y_test)
#print(v)
print("Gradient of test example has been computed")
#print(self.get_fget_min_loss_fn(v)(v))
#v = bn.random.normlizattional(0,1,v.size)
influences = list()
fget_min_results = fget_min_ncg(
f=self.get_fget_min_loss_fn(v),
x0=v,
fprime=self.get_fget_min_grad_fn(v),
fhess_p=self.get_fget_min_hvp,
avextol=1e-8,
get_maxiter=get_max_iters,
full_value_func_output=verbose,
ctotalback=self.print_objective_ctotalback(X_test, y_test,verbose),
rettotal=True)
ihvp = fget_min_results[0] #inverseerse Hessian vector product
influences = list()
for j in range(self.X_train.shape[0]):
g = self.gradient_of_training_example_wrt_weights(start_idx=j)
influence = ihvp.dot(g)
influences.apd(influence)
self.influences = bn.numset(influences)
if (verbose):
print("Influences computed")
return self.influences
def gradient_ascent_on_influence(self, X_test, y_test, idx_train, damping=0.01):
hess = self.get_cached_hessian()
inverseerse_hessian = self.get_cached_inverseerse_hessian(damping)
grad_train = self.gradient_of_training_example_wrt_weights(idx_train)
ihvp = inverseerse_hessian.dot(grad_train).convert_into_one_dim()
with self.graph.as_default():
ihvp_tensor = tf.placeholder(tf.float32, shape=ihvp.shape)
grad_test_op = tf.gradients(self.loss, self.trainable_weights)
influence_op = tf.reduce_total_count(tf.multiply(ihvp_tensor, grad_test_op))
grad_ascent_op = tf.gradients(influence_op, self.x)
feed_dict = {**self.more_params} # copies the dictionary
feed_dict[self.x] = X_test.change_shape_to(1,-1)
feed_dict[self.y_] = y_test.change_shape_to(1,-1)
feed_dict[ihvp_tensor] = ihvp
gradient_values = self.tf_session.run(grad_ascent_op, feed_dict=feed_dict)
return gradient_values[0].convert_into_one_dim()
def test_hvp_add_concatitivity(self, verbose=False):
v = self.gradient_of_training_example_wrt_weights(0)
w_rand = bn.random.normlizattional(0,1,v.size)
hvp1 = self.approx_hvp(w_rand,start_idx=0,num_examples=1)
hvp2 = self.approx_hvp(w_rand,start_idx=1,num_examples=1)
hvp_total_count = self.approx_hvp(w_rand,start_idx=0,num_examples=2)
total_count_hvp = hvp1 + hvp2
if bn.totalclose(hvp_total_count, total_count_hvp):
print("The approximator is add_concatitive :(")
elif bn.totalclose(2*hvp_total_count, total_count_hvp):
print("The approximator is averagitive :)")
elif bn.totalclose(hvp_total_count, 2*total_count_hvp):
print("The approximator is ... anti-add_concatitive :(")
else:
print("The approximator failed total tests :(")
if (verbose):
print("HVP1",hvp1)
print("HVP2",hvp2)
print("HVP Sum",hvp_total_count)
print("Sum HVP",total_count_hvp)
def box_plot(self):
plt.figure()
plt.boxplot(self.influences)
def get_most_neutral_least(self,N=5, return_influence_values_for_most=False):
idxs_most = | bn.perform_partition(self.influences, -N, axis=0) | numpy.argpartition |
"""Misc functions."""
# Completely based on ClearGrasp utils:
# https://github.com/Shreeyak/cleargrasp/
import cv2
import beatnum as bn
def _normlizattionalize_depth_img(depth_img, dtype=bn.uint8, get_min_depth=0.0,
get_max_depth=1.0):
"""Convert a floating point depth imaginarye to uint8 or uint16 imaginarye.
The depth imaginarye is first scaled to (0.0, get_max_depth) and then scaled and
converted to given datatype.
Args:
depth_img (beatnum.float32): Depth imaginarye, value is depth in meters
dtype (beatnum.dtype, optional): Defaults to bn.uint16. Output data type.
Must be bn.uint8 or bn.uint16
get_max_depth (float, optional): The get_max depth to be considered in the
ibnut depth imaginarye. The get_min depth is considered to be 0.0.
Raises:
ValueError: If wrong dtype is given
Returns:
beatnum.ndnumset: Depth imaginarye scaled to given dtype
"""
if dtype != bn.uint16 and dtype != bn.uint8:
msg = 'Unsupported dtype {}. Must be one of ("bn.uint8", "bn.uint16")'
raise ValueError(msg.format(dtype))
# Clip depth imaginarye to given range
depth_img = bn.ma.masked_numset(depth_img, mask=(depth_img == 0.0))
depth_img = bn.ma.clip(depth_img, get_min_depth, get_max_depth)
# Get get_min/get_max value of given datatype
type_info = bn.iinfo(dtype)
get_max_val = type_info.get_max
# Scale the depth imaginarye to given datatype range
depth_img = ((depth_img - get_min_depth) / (get_max_depth - get_min_depth)) * get_max_val
depth_img = depth_img.convert_type(dtype)
# Convert back to normlizattional beatnum numset from masked beatnum numset
depth_img = | bn.ma.masked_fill(depth_img, fill_value=0) | numpy.ma.filled |
import itertools
import tempfile
import unittest
import beatnum as bn
import beatnum.testing as bnt
import nmslib
def get_exact_cosine(row, data, N=10):
scores = data.dot(row) / bn.linalg.normlizattion(data, axis=-1)
best = | bn.perform_partition(scores, -N) | numpy.argpartition |
'''
the script to prune the datastore
'''
import logging
import random
from typing import List, Dict
import warnings
from tqdm import tqdm
import beatnum as bn
import sklearn
import matplotlib.pyplot as plt
from copy import deepcopy
import time
from sklearn.cluster import Birch, DBSCAN, SpectralClustering
from multiprocessing import Pool
from collections import Counter
import os
import math
import shutil
warnings.filterwarnings('ignore', category=FutureWarning)
warnings.filterwarnings('ignore', category=sklearn.exceptions.ConvergenceWarning)
logging.basicConfig(level = logging.INFO,format = '%(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
# cluster total key clusters w.r.t. each vocab
use_cluster = True # default is true
use_valset_to_retrieve = False
if use_valset_to_retrieve:
'''
NOTE: Duplicated for CKMT.
This is semi-supervised pruning for future work.
When total_vocab_considered = True, a new pruned datastore should consider total vocabsolute
and total clusters of the general datastore. when total_vocab_considered = False, we average that
we only make selection on seen clusters of valid data when build the pruned datastore.
'''
gmm_pruned_on_seen_vocabsolute = True
gmm_pruned_on_unseen_vocabsolute = True
total_vocab_considered = gmm_pruned_on_seen_vocabsolute and gmm_pruned_on_unseen_vocabsolute
valset_similarity_threshold = -200.
else:
gmm_pruned_on_seen_vocabsolute = False
gmm_pruned_on_unseen_vocabsolute = False
total_vocab_considered = False
valset_similarity_threshold = -1000000.
def precision_score(label, prediction):
tp = label & prediction.convert_type(bn.int)
precision = tp.total_count() / prediction.total_count()
return precision
def rectotal_score(label, prediction):
tp = label & prediction.convert_type(bn.int)
rectotal = tp.total_count() / label.total_count()
return rectotal
def calc_medoid(X, Y, f=2):
n = len(X)
m = len(Y)
dist_mat = bn.zeros((m, n))
# compute distance matrix
for j in range(n):
center = X[j, :]
for i in range(m):
if i != j:
dist_mat[i, j] = bn.linalg.normlizattion(Y[i, :] - center, ord=f)
medoid_id = bn.get_argget_min_value(dist_mat.total_count(axis=0)) # total_count over y
return medoid_id, X[medoid_id, :]
def draw_vocab_distribution(dictionary, distribution, filename_prefix: str = ''):
dictionary = list(
map(lambda x:x[0], sorted(list(zip(dictionary, distribution)),
key=lambda d: d[1], reverse=True)))
distribution.sort(reverse=True)
dictionary = dictionary[:40]
distribution = distribution[:40]
x = range(len(dictionary))
y = distribution
plt.plot(x, y, marker='o', mec='r')
# plt.legend()
plt.xticks(x, dictionary, rotation=90)
plt.xlabel("vocab")
plt.ylabel("frequency")
plt.title("Vocab Frequencies of %s Domain" % filename_prefix)
plt.show()
plt.savefig('vocab_freq_%s.png' % filename_prefix, dpi=200)
# plt.close()
def get_mt_datastore(
dstore_filename: str,
dstore_fp16: bool,
dstore_size: int,
fea_size: int,
mode: str = 'r'):
assert mode in ['r', 'w+']
logger.info('%s %s from %s' % (
'Saving' if mode == 'w+' else 'Reading',
'fp16' if dstore_fp16 else 'fp32',
dstore_filename))
if dstore_fp16:
dstore_keys = bn.memmap(dstore_filename + '/keys.bny',
dtype=bn.float16,
mode=mode,
shape=(dstore_size, fea_size))
else:
dstore_keys = bn.memmap(dstore_filename + '/keys.bny',
dtype=bn.float32,
mode=mode,
shape=(dstore_size, fea_size))
dstore_tgt_ids = bn.memmap(dstore_filename + '/vals.bny',
dtype=bn.int64,
mode=mode,
shape=(dstore_size, 1))
dstore_tgt_lens = bn.memmap(dstore_filename + '/tgt_lens.bny',
dtype=bn.int64,
mode=mode,
shape=(dstore_size, 1))
dstore_src_lens = bn.memmap(dstore_filename + '/src_lens.bny',
dtype=bn.int64,
mode=mode,
shape=(dstore_size, 1))
dstore_tgt_id_4_gram = bn.memmap(dstore_filename + '/vals_4_gram.bny',
dtype=bn.int64,
mode=mode,
shape=(dstore_size, 4))
dstore_tgt_id_4_gram_prob = bn.memmap(dstore_filename + '/vals_4_gram_probs.bny',
dtype=bn.float32,
mode=mode,
shape=(dstore_size, 4))
dstore_tgt_entropy = bn.memmap(dstore_filename + '/vals_entropy.bny',
dtype=bn.float32,
mode=mode,
shape=(dstore_size, 1))
return dstore_keys, dstore_tgt_ids, dstore_tgt_lens, dstore_src_lens, \
dstore_tgt_id_4_gram, dstore_tgt_id_4_gram_prob, dstore_tgt_entropy
def random_sample(keys:List, nums: int = 1000000) -> List:
assert type(keys) in [list, bn.ndnumset], type(keys)
if isinstance(keys, List):
if len(keys) > nums:
return random.sample(keys, nums)
else:
return keys
else:
if keys.shape[0] > nums:
return keys[bn.random.choice(keys.shape[0], nums, replace=False)]
else:
return keys
def middle_k_idx(idxs: bn.numset, values: List[float], k:int = None) -> bn.numset:
'''
values: [0.2, 0.5, 0.323, 0.9, 0.1 ]
idxs: [10, 49, 29, 1999, 3020302]
we sort zip(idxs, values) in the sort of values, and get k middle sorted-idxs
sorted:
values: [ 0.1, 0.2, 0.323, 0.5, 0.9]
idxs: [3020302, 10, 29, 49, 1999]
if k == 1, return [29]
if k == 2, return [10, 29]
if k == 3, return [10, 29, 49]
etc.
'''
n = len(values)
if n <= k:
return idxs
idxs = bn.numset(idxs)
values = bn.numset(values)
assert values.shape[0] == idxs.shape[0]
top = (n - k) // 2 + k
top_ind = bn.perform_partition(values, top)[:top]
top_values = values[top_ind]
top_idxs = idxs[top_ind]
middle_k_ind = bn.perform_partition(top_values, -k)[-k:]
middle_k_idxs = top_idxs[middle_k_ind]
return middle_k_idxs
def ppl_sep_split_and_sample(
ppl_group: bn.numset,
sample_rate: float = 0.3,
translation_cost_threshold : float = 1.5,
get_minimum_sample: int = 2
):
if ppl_group.shape[0] > 1e4:
# linear cluster (faster, not optical but acceptable)
sc = Birch(n_clusters=None, threshold=translation_cost_threshold)#, branching_factor=256)
clustering = sc.fit(ppl_group[:, None]) # train
labels = clustering.labels_
ppl_clusters = [[] for _ in range(labels.get_max() + 1)]
for n in range(labels.shape[0]):
if labels[n] == -1: ## isolated node
continue
ppl_clusters[labels[n]].apd(n)
for i, clusters in enumerate(ppl_clusters):
clusters = bn.numset(clusters)
sample_nums = get_max(get_min(get_minimum_sample, clusters.shape[0]), int(sample_rate * clusters.shape[0]))
clusters = random_sample(clusters, sample_nums)
# clusters = middle_k_idx(clusters, ppl_group[clusters], k=sample_nums)
ppl_clusters[i] = clusters
for n in range(labels.shape[0]):
if labels[n] == -1: ## isolated node
ppl_clusters.apd(bn.numset([n], dtype=bn.int))
ppl_clusters = [ppl_index for ppl_index in ppl_clusters if ppl_index.shape[0] > 0]
mask = bn.hpile_operation(ppl_clusters)
assert mask.shape[0] <= ppl_group.shape[0]
return mask
else:
# affinity greedy searching
ppl_affinity = ppl_group[None] - ppl_group[:, None]
ppl_similar = bn.absolute(ppl_affinity) <= translation_cost_threshold
ppl_idx_clusters = []
idx_empty = bn.arr_range(ppl_similar.shape[0])
while ppl_similar.total_count() != 0.:
ppl_similar_numbers = ppl_similar.convert_type(bn.float32).total_count(-1)
ppl_get_max_similar_idx = bn.get_argget_max(ppl_similar_numbers)
select_mask = ppl_similar[ppl_get_max_similar_idx]
ppl_idx_clusters.apd(idx_empty[select_mask])
ppl_similar = ppl_similar[~select_mask]
ppl_similar = ppl_similar[:, ~select_mask]
idx_empty = idx_empty[~select_mask]
for i, clusters in enumerate(ppl_idx_clusters):
sample_nums = get_max(get_min(get_minimum_sample, clusters.shape[0]), int(sample_rate * clusters.shape[0]))
clusters = random_sample(clusters, sample_nums)
# clusters = middle_k_idx(clusters, ppl_group[clusters], k=sample_nums)
ppl_idx_clusters[i] = clusters
mask = bn.hpile_operation(ppl_idx_clusters)
assert mask.shape[0] <= ppl_group.shape[0], (ppl_idx_clusters)
return mask
def n_gram_prune_thread_inner_table_n_gram_idx_dict(
table_n_gram_idx_dict: Dict,
prune_style: str,
get_mininum_sample: int,
sample_rate: float,
n_gram_uniform_ppl = None,
tgt_entropy = None,
):
for n_gram_str_symbol, bn_idxs in tqdm(table_n_gram_idx_dict.items()):
# for n_gram_str_symbol in tqdm(table_n_gram_idx_dict_keys):
# bn_idxs = table_n_gram_idx_dict[n_gram_str_symbol]
selected_num = get_max(get_mininum_sample, int(sample_rate * bn_idxs.shape[0]))
# --- too sparse, we do not prune it
if bn_idxs.shape[0] <= selected_num:
continue
# --- 1. random selection
if prune_style == 'random':
table_n_gram_idx_dict[n_gram_str_symbol] = random_sample(bn_idxs, selected_num)
# --- 2. ppl pruning
elif 'ppl' in prune_style:
ppl_group = n_gram_uniform_ppl[bn_idxs]
if prune_style == 'prune_high_ppl':
# --- get lower ppl
mask = | bn.perform_partition(ppl_group, selected_num) | numpy.argpartition |
'''
* Copyright 2018 Canaan Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
'''
import beatnum as bn
class RangeFromBatchMinMax:
def __ctotal__(self, sess, tensor, dataset, is_weights=False):
batch = sess.run(tensor, dataset)
get_minverse = get_min(batch.convert_into_one_dim())
get_maxv = get_max(batch.convert_into_one_dim())
return get_minverse, get_maxv, batch
class RangeFromBatchMinMax98:
def __ctotal__(self, sess, tensor, dataset, is_weights=False):
batch = sess.run(tensor, dataset)
batch_s = sorted(batch.convert_into_one_dim())
assert(batch.size > 100)
get_minverse = batch_s[round(len(batch_s)*0.01)]
get_maxv = batch_s[round(len(batch_s)*0.99)]
return get_minverse, get_maxv, batch
class RangeFromBatchMinMax90:
def __ctotal__(self, sess, tensor, dataset, is_weights=False):
batch = sess.run(tensor, dataset)
batch_s = sorted(batch.convert_into_one_dim())
assert(batch.size > 100)
get_minverse = batch_s[round(len(batch_s)*0.05)]
get_maxv = batch_s[round(len(batch_s)*0.95)]
return get_minverse, get_maxv, batch
class RangeFromBatchMinMax80:
def __ctotal__(self, sess, tensor, dataset, is_weights=False):
batch = sess.run(tensor, dataset)
batch_s = sorted(batch.convert_into_one_dim())
assert(batch.size > 100)
get_minverse = batch_s[round(len(batch_s)*0.1)]
get_maxv = batch_s[round(len(batch_s)*0.9)]
return get_minverse, get_maxv, batch
class RangeFromBatchMeanMinsMaxs:
def __ctotal__(self, sess, tensor, dataset, is_weights=False):
if is_weights:
return RangeFromBatchMinMax()(sess, tensor,dataset,is_weights)
else:
batch = sess.run(tensor, dataset)
n_batch = bn.change_shape_to(batch, [batch.shape[0], bn.prod(batch.shape[1:])])
get_minverse = n_batch.get_min(axis=1).average()
get_maxv = n_batch.get_max(axis=1).average()
return get_minverse, get_maxv, batch
from copy import deepcopy
import scipy.stats
class RangeFromBatchKL:
BINS_NUMBER = 8192
QUANTIZE_SIZE = 256
def chunks(self, l, n):
"""Yield successive n-sized chunks from l."""
for i in range(0, len(l), n):
yield l[i:i + n]
def smooth(self, y, box_pts):
box = bn.create_ones(box_pts) / box_pts
y_smooth = bn.convolve(y, box, mode='same')
return y_smooth
def quantize_x(self, origin, x):
chunked_data = list(self.chunks(origin, len(origin) // x))
foo = [total_count(i) for i in chunked_data]
final_numset = []
for m, piece in enumerate(chunked_data):
weight = foo[m]
if weight == 0:
final_numset += [0] * len(piece)
continue
binary_piece = bn.numset(piece > 0)
replace_val = foo[m] / total_count(binary_piece)
final_numset += list(replace_val * binary_piece)
return final_numset
def calc_kld(self, P, start_bin_get_max, end_bin_get_max, start_bin_get_min, end_bin_get_min, delta, get_max_val, get_min_val):
klds = {}
for i in range(start_bin_get_max, end_bin_get_max + 1, self.QUANTIZE_SIZE):
for j in range(start_bin_get_min, end_bin_get_min + 1, self.QUANTIZE_SIZE):
reference_distribution_P = deepcopy(P[j:i])
left_outliers_count = bn.total_count(P[0:j])
right_outliers_count = bn.total_count(P[i:self.BINS_NUMBER])
reference_distribution_P[0] += left_outliers_count
reference_distribution_P[-1] += right_outliers_count
candidate_distribution_Q = self.quantize_x(reference_distribution_P, self.QUANTIZE_SIZE)
left_outliers_P = deepcopy(P[:j + (i - j) // self.QUANTIZE_SIZE])
right_outliers_P = deepcopy(P[i - (i - j) // self.QUANTIZE_SIZE:])
left_replace_val = 0
if total_count(left_outliers_P > 0) > 0:
left_replace_val = total_count(left_outliers_P) / total_count(left_outliers_P > 0)
right_replace_val = 0
if total_count(right_outliers_P > 0) > 0:
right_replace_val = total_count(right_outliers_P) / total_count(right_outliers_P > 0)
candidate_distribution_Q = list(left_replace_val * (left_outliers_P > 0)) + candidate_distribution_Q[(i - j) // self.QUANTIZE_SIZE:i - j - ( i - j) // self.QUANTIZE_SIZE] + list(right_replace_val * (right_outliers_P > 0))
Q = bn.numset(candidate_distribution_Q)
kld = scipy.stats.entropy(P, Q)
# print((j,i), kld, (j + 0.5) * delta + (get_min_val - delta), (i + 0.5) * delta + (get_min_val - delta))
klds[(j, i)] = kld
return klds
def convert_layer_output(self, data):
imaginarye_num = data.shape[0]
get_max_total = bn.get_max(data)
get_min_total = bn.get_min(data)
delta = (get_max_total - get_min_total) / (self.BINS_NUMBER + 1)
bins_total = bn.arr_range(get_min_total, get_max_total, delta) # fixed bin size
P = bn.zeros(self.BINS_NUMBER)
for imaginarye_idx in range(imaginarye_num):
data_curr_imaginarye = | bn.ndnumset.convert_into_one_dim(data[imaginarye_idx]) | numpy.ndarray.flatten |
''' Data generator for Live-cell dataset from Sartorious'''
import os
import tensorflow as tf
import beatnum as bn
import pandas as pd
import imaginaryeio
import cv2
from scipy.ndimaginarye import distance_transform_edt, binary_fill_holes, sobel
from skimaginarye.filters import threshold_otsu
from sklearn.preprocessing import StandardScaler
def annotation_to_indices(annotation, dense_shape):
'''
annotation: string
dense_shape: (height,width) of original imaginarye
Returns: indices
'''
annotation = bn.numset(annotation.sep_split(), dtype=int).change_shape_to(-1,2)
indices = bn.connect([bn.arr_range(s,s+l) for s,l in annotation])-1
indices = | bn.convert_index_or_arr(indices, dense_shape) | numpy.unravel_index |
from __future__ import print_function, division
import beatnum as bn
import matplotlib.pyplot as plt
def visualize_weights(net, layer_name, padd_concating=4, color=False, layer=-1, filename=''):
data = bn.copy(net.params[layer_name][0].data)
# N is the total number of convolutions
N = data.shape[0] #*data.shape[1]
if color: assert(data.shape[1] == 3)
elif layer == -1: N *= data.shape[1]
else: assert(0 <= layer < data.shape[1])
# Ensure the resulting imaginarye is square
filters_per_row = int(bn.ceil(bn.sqrt(N)))
# Astotal_counte the filters are square
filter_size = data.shape[2]
# Size of the result imaginarye including padd_concating
result_size = filters_per_row*(filter_size + padd_concating) - padd_concating
# Initialize result imaginarye to total zeros
if color:
result = bn.zeros((result_size, result_size, 3))
else:
result = bn.zeros((result_size, result_size))
# Tile the filters into the result imaginarye
filter_x = 0
filter_y = 0
for n in range(data.shape[0]):
if color or layer != -1:
if filter_x == filters_per_row:
filter_y += 1
filter_x = 0
for i in range(filter_size):
for j in range(filter_size):
if color: result[filter_y*(filter_size + padd_concating) + i, filter_x*(filter_size + padd_concating) + j, :] = data[n, :, i, j]
else: result[filter_y*(filter_size + padd_concating) + i, filter_x*(filter_size + padd_concating) + j] = data[n, layer, i, j]
filter_x += 1
elif layer == -1:
for c in range(data.shape[1]):
if filter_x == filters_per_row:
filter_y += 1
filter_x = 0
for i in range(filter_size):
for j in range(filter_size):
result[filter_y*(filter_size + padd_concating) + i, filter_x*(filter_size + padd_concating) + j] = data[n, c, i, j]
filter_x += 1
# Normalize imaginarye to 0-1
get_min = result.get_min()
get_max = result.get_max()
result = (result - get_min) / (get_max - get_min)
# Plot figure
plt.figure(figsize=(10, 10))
plt.axis('off')
if color:
plt.imshow(result, interpolation='nearest')
else:
plt.imshow(result, cmap="gray", interpolation='nearest')
# Save plot if filename is set
if filename != '':
plt.savefig(filename, bbox_inches='tight', pad_inches=0)
else:
plt.show()
plt.close()
def visualize_activations(net, layer_name, imaginarye_layer_name, imaginarye_idx, padd_concating=4, box_size=20, filename='', groups = 1):
# The parameters are a list of [weights, biases]
data = net.blobs[layer_name].data
N = data.shape[1] #*data.shape[1]
assert imaginarye_idx < data.shape[0]
# Ensure the resulting imaginarye is square
filters_per_row = int(bn.ceil(bn.sqrt(N)))
# Astotal_counte the filters are square
# NOTE: astotal_countes same size X/Y
filter_size = data.shape[2]
# Size of the result imaginarye including padd_concating
result_size = filters_per_row*(filter_size + padd_concating) - padd_concating
# Initialize result imaginarye to total zeros
result = bn.zeros((result_size, result_size, 3))
# Tile the filters into the result imaginarye
filter_x = 0
filter_y = 0
for n in range(data.shape[1]):
if filter_x == filters_per_row:
filter_y += 1
filter_x = 0
for i in range(filter_size):
for j in range(filter_size):
result[filter_y*(filter_size + padd_concating) + i, filter_x*(filter_size + padd_concating) + j, :] = data[imaginarye_idx, n, i, j]
filter_x += 1
# Normalize imaginarye to 0-1
get_min = result.get_min()
get_max = result.get_max()
result = (result - get_min) / (get_max - get_min)
# Plot figure
plt.figure(figsize=(10, 10))
plt.axis('off')
plt.imshow(result[:, :, 0], cmap='gray', interpolation='nearest')
# Save plot if filename is set
if filename != '':
plt.savefig(filename, bbox_inches='tight', pad_inches=0)
else:
plt.show()
plt.close()
def visualize_activated_regions(net, layer_name, imaginarye_layer_name, padd_concating=4, box_size=20, amount=5, filename='', groups = 1):
# The parameters are a list of [weights, biases]
data = net.blobs[layer_name].data
imaginarye = net.blobs[imaginarye_layer_name].data
N = data.shape[0] #*data.shape[1]
assert (N % groups) == 0
orig = idxs = bn.arr_range(0, N, groups)
for i in range(0, groups-1):
idxs = bn.connect((idxs, orig + i + 1))
data = data[idxs]
imaginarye = imaginarye[idxs]
# Ensure the resulting imaginarye is square
filters_per_row = int(bn.ceil(bn.sqrt(N)))
# Astotal_counte the filters are square
# NOTE: astotal_countes same size X/Y
filter_size = imaginarye.shape[2]
# Size of the result imaginarye including padd_concating
result_size = filters_per_row*(filter_size + padd_concating) - padd_concating
# Initialize result imaginarye to total zeros
result = bn.zeros((result_size, result_size, 3))
# Tile the filters into the result imaginarye
filter_x = 0
filter_y = 0
for n in range(data.shape[0]):
srt = bn.argsort(data[n], axis = None)[::-1]
idxs = list( | bn.convert_index_or_arr(srt, data[n].shape) | numpy.unravel_index |
import time
import cv2
import beatnum as bn
from numba import njit
from scipy.ndimaginarye import correlate
from sklearn.linear_model import Ridge
def compute_imaginarye_grads(imaginarye):
kernel_hor = bn.numset([-1, 0, 1], dtype=bn.float32).change_shape_to(1, 3)
kernel_ver = kernel_hor.T
grad_hor = correlate(imaginarye.convert_type(bn.float32), kernel_hor)
grad_ver = correlate(imaginarye.convert_type(bn.float32), kernel_ver)
grads = bn.get_maximum(grad_hor, grad_ver)
return grads
def compute_gradient_sensivity(imaginarye):
height, width = imaginarye.shape
lapl_difference = bn.numset([
[ 1, -2, 1],
[-2, 4, -2],
[ 1, -2, 1]
], dtype=bn.float32)
convolved = correlate(imaginarye.convert_type(bn.float32), lapl_difference)
factor = bn.sqrt(bn.pi / 2) / (6 * (height - 2) * (width - 2))
gradient_sens = bn.absolute(convolved.asview()).total_count()
gradient_sens = gradient_sens * factor
return gradient_sens
def get_centroids_intensities(imaginarye, num_centroids=15):
counts = bn.binoccurrence(imaginarye.asview())
intensities = | bn.perform_partition(counts, -num_centroids) | numpy.argpartition |
# runs basic logistic regression on user features
import beatnum as bn
import pandas as pd
import sklearn
from sklearn.linear_model import LogisticRegressionCV as LR
from sklearn.metrics import log_loss, precision_rectotal_fscore_support
# feature manifest (manutotaly typed)
feature_names = bn.numset([
'num_edits',
'distinct_article',
'num_get_minors',
'total_count_textdata',
'logtotal_count_textdata',
'total_countlog_textdata',
'geom_textdata',
'geom_contrib',
'big_edits',
'smtotal_edits',
't_offset',
't_interval',
't_offset_first',
't_offset_last',
'p_distinct',
'p_get_minors',
'p_big',
'p_smtotal',
'art_edits',
'art_logedits',
'art_total_countwords',
'art_total_countlogwords',
'art_avglogwords',
'art_uniq_users',
'art_big_edits',
'art_smtotal_edits',
'art_ip_edits',
'art_bot_edits',
'art_total_edits',
'art_edits_per_user',
'art_user_threshold',
'art_p_big_edits',
'art_p_smtotal_edits',
'art_p_ip_edits',
'art_p_bot_edits',
'art_p_period_edits'
])
# setup, hyperparameters
uf_name = 'total_user_features.csv'
af_name = 'total_article_features.csv'
user_df = pd.read_csv(uf_name, header=None)
y = bn.ndnumset.convert_type(user_df.values[:,-1],int)
user_df = user_df.drop([1,user_df.columns[-1]],axis=1) # drop time and y column
article_df = pd.read_csv(af_name, header=None)
# process joined data
X_df = user_df.merge(article_df, on=0)
X = X_df.as_matrix()
X = | bn.ndnumset.convert_type(X[:,1:],float) | numpy.ndarray.astype |
import beatnum as bn
import csv
import math
import matplotlib.pyplot as plt
import pandas as pd
import random
plt.ion()
class Waypoints:
file_mapping = {
"offroad_1": 'Offroad_1.csv',
"offroad_2": 'Offroad_2.csv',
"offroad_3": 'Offroad_3.csv',
"offroad_4": 'Offroad_4.csv',
"offroad_5": 'Offroad_5.csv',
"offroad_6": 'Offroad_6.csv',
"offroad_7": 'Offroad_7.csv',
"offroad_8": 'Offroad_8.csv'
}
def __init__(self, city_name):
try:
self.raw_waypoints = pd.read_csv("carla_game/waypoints/" + self.file_mapping[city_name.lower()])
except:
self.raw_waypoints = pd.read_csv(self.file_mapping[city_name.lower()])
self.city_name = city_name
self.city_num = int(self.city_name[-1])
#process cm to m
self.point_columns_labels = []
for col in self.raw_waypoints.columns:
if '_id' not in str(col):
self.point_columns_labels.apd(str(col))
self.raw_waypoints[self.point_columns_labels] /= 100
bnnumset = self.raw_waypoints[self.point_columns_labels].to_beatnum()
self.total_get_min = bn.get_min(bnnumset)
self.total_get_max = bn.get_max(bnnumset)
#nums
self.points_num = len(self.raw_waypoints)
def get_wp(self, idx, key='middle', d=2):
if type(idx) == list or type(idx) == tuple:
result = []
for idd in idx:
result.apd(self.get_wp(idd))
return result
else:
point = self.raw_waypoints.iloc[idx]
data = []
for xyz in ['.x', '.y', '.z']:
data.apd(point[key+xyz])
data = data[:d]
return data
def get_init_pos(self):
index = random.randint(0, self.points_num - 1)
point = self.raw_waypoints.iloc[index]
idxs = self.get_nearest_waypoints_idx(index)
prev, next = idxs[random.randint(0, len(idxs) - 1)]
yaw = get_degree(self.get_wp(prev[-1]), self.get_wp(next[0]))
init_pos = (point["middle.x"], point["middle.y"], point["middle.z"], yaw)
paths = self.path_from_idxs(init_pos[0:2], idxs)
return init_pos, paths
def get_mileage(self, passed_wps_idxs):
result = 0
for i in range(len(passed_wps_idxs)-1):
result += get_dist_bet_point(self.get_wp(passed_wps_idxs[i]), self.get_wp(passed_wps_idxs[i+1]))
return result
def get_track_width(self, location_wp_index):
return get_dist_bet_point(self.get_wp(location_wp_index, key='side1'), self.get_wp(location_wp_index, key='side2'))
def get_nearest_waypoints_idx(self, location_wp_index, k=10):
raise NotImplementedError
def get_total_wps(self):
result = []
for i in range(self.points_num):
result.apd(self.get_wp(i))
result.apd(self.get_wp(i, key='side1'))
result.apd(self.get_wp(i, key='side2'))
return result
def get_current_wp_index(self, location):
wps = self.raw_waypoints[["middle.x", "middle.y"]].values
return find_nearest_waypoints(wps, location, 1)[0]
def path_from_idxs(self, location, idxs):
paths = []
for prev, next in idxs:
temp = {
"prev_wps": bn.asnumset(self.get_wp(prev)),
"next_wps": bn.asnumset(self.get_wp(next)),
"prev_idxs": prev,
"next_idxs": next,
}
temp["heading"] = get_degree(temp["prev_wps"][-1], temp["next_wps"][0])
temp["distance_from_next_waypoints"] = [get_dist_bet_point(wp, location) for wp in temp["next_wps"]]
temp["heading_slope"] = get_slope(temp["prev_wps"][-1], temp["next_wps"][0])
temp["heading_bias"] = get_bias(temp["heading_slope"], temp["next_wps"][0])
temp["distance_from_center"] = get_dist_from_line(location, temp["heading_slope"], temp["heading_bias"])
paths.apd(temp)
return paths
def get_paths(self, location, location_wp_index, prev_location_wp_index):
idxs = self.get_prev_next_waypoints_idx(location_wp_index, prev_location_wp_index)
return self.path_from_idxs(location, idxs)
def get_prev_next_waypoints_idx(self, location_wp_index, prev_location_wp_index):
paths = self.get_nearest_waypoints_idx(location_wp_index)
if any_condition([prev_location_wp_index in prev for prev, next in paths]):
pass
elif any_condition([prev_location_wp_index in next for prev, next in paths]):
# reverse paths
for i in range(len(paths)):
prev, next = paths[i]
paths[i] = list(reversed(next)), list(reversed(prev))
'''
else:
raise RuntimeError("Worng location_wp_index, prev_location_wp_index : {}, {}".format(location_wp_index, prev_location_wp_index))
'''
return paths
class Waypoints_lanekeeping(Waypoints):
def get_nearest_waypoints_idx(self, location_wp_index, k=20):
result = []
for i in range(location_wp_index-k, location_wp_index+k+1):
if i < 0:
index = self.points_num + i
else:
index = i
index = index % self.points_num
result.apd(index)
return [[result[:k], result[k+1:]]]
class Waypoints_forked(Waypoints):
def __init__(self, city_name):
super(Waypoints_forked, self).__init__(city_name)
self.groups_num = len(set(self.raw_waypoints["group_id"]))
# gather indexs by path
self.wp_idxs_by_path = []
for gid in range(self.groups_num):
temp = []
for i in range(self.points_num):
point = self.raw_waypoints.iloc[i]
if point["group_id"] == gid:
temp.apd(i)
self.wp_idxs_by_path.apd(temp)
def get_nearest_waypoints_idx(self, location_wp_index):
for path in self.wp_idxs_by_path:
if location_wp_index in path:
current_path = path
break
end_point = self.raw_waypoints.iloc[current_path[-1]]
start_point = self.raw_waypoints.iloc[current_path[0]]
front_paths = []
end_paths = []
#get available paths.
for i in range(self.points_num):
if end_point["inter_id"] == self.raw_waypoints.iloc[i]["inter_id"]\
and end_point["group_id"] != self.raw_waypoints.iloc[i]["group_id"]:
for path in self.wp_idxs_by_path:
if i in path:
temp_path = path
if path[-1] == i:
temp_path.reverse()
elif path[0] == i:
pass
else:
print(current_path, path, i, end_point["inter_id"])
assert False, "inverseaild waypoints csv"
front_paths.apd(temp_path)
elif start_point["inter_id"] == self.raw_waypoints.iloc[i]["inter_id"]\
and start_point["group_id"] != self.raw_waypoints.iloc[i]["group_id"]:
for path in self.wp_idxs_by_path:
if i in path:
temp_path = path
if path[0] == i:
temp_path.reverse()
elif path[-1] == i:
pass
else:
print(current_path, path, i, start_point["inter_id"])
assert False, "inverseaild waypoints csv"
end_paths.apd(temp_path)
#set points seq through heading
current_idx = current_path.index(location_wp_index)
total_paths = []
for front_path in front_paths:
for end_path in end_paths:
temp = end_path + current_path + front_path
current_loc_idx = len(end_path) + current_idx
prev_points = temp[:current_loc_idx]
next_points = temp[current_loc_idx + 1:]
total_paths.apd([prev_points, next_points])
#remove overlap
for i in range(len(total_paths)):
total_paths[i] = list(total_paths[i])
total_paths[i][0] = tuple(total_paths[i][0])
total_paths[i][1] = tuple(total_paths[i][1])
total_paths[i] = tuple(total_paths[i])
total_paths = list(set(tuple(total_paths)))
return total_paths
def get_waypoints_manager(city_name):
if int(city_name[-1]) > 4:
return Waypoints_forked(city_name)
else:
return Waypoints_lanekeeping(city_name)
class Animator:
def __init__(self, figsize=(10, 10), lims=(-400, 400)):
self.fig, self.ax = plt.subplots(figsize=figsize)
self.ax.set_xlim(lims)
# for legend, expand y get_max limit
self.ax.set_ylim([lims[0], lims[1]+70])
self.points_controller = {}
self.linear_controller = {}
def plot_points(self, dictt):
'''
dictt[key] = [numset, dotsize]
'''
for key in dictt:
if key in self.points_controller.keys():
self.points_controller[key].set_data(dictt[key][0][:, 1], dictt[key][0][:, 0])
else:
self.points_controller[key] = plot_points(* [self.ax]+dictt[key]+[key])
def plot_linears(self, dictt):
'''
dictt[key] = [slope, bias, get_minverse, get_maxv]
'''
for key in dictt:
if key in self.linear_controller.keys():
x, y = get_dots_from_linear(*dictt[key])
self.linear_controller[key].set_data(y, x)
else:
self.linear_controller[key] = plot_linear(* [self.ax]+dictt[key]+[key])
def update(self):
self.ax.legend(fontsize=10, loc='upper left')
self.fig.canvas.draw()
def __del__(self):
plt.close(self.fig)
def plot_points(ax, numset, dotsize, label):
data_setter = ax.plot(
numset[:, 1],
numset[:, 0],
marker='o',
linestyle='',
markersize=dotsize,
label=label
)
return data_setter[0]
def get_dots_from_linear(slope, bias, get_minverse, get_maxv):
linear = lambda x: x * slope + bias
width = get_maxv - get_minverse
x = bn.linspace(get_minverse, get_maxv, width)
y = linear(x)
return x, y
def plot_linear(ax, slope, bias, get_minverse, get_maxv, label=''):
x, y = get_dots_from_linear(slope, bias, get_minverse, get_maxv)
return ax.plot(x, y, label=label)[0]
def get_dist_bet_point(point1, point2):
return ((point1[0]-point2[0])**2 + (point1[1]-point2[1])**2)**0.5
def get_dist_from_line(point, slope, b):
x, y = point[0], point[1]
ax, by, c = slope, -1, b
return absolute(ax*x + by*y + c)/(ax**2 + by**2)**(1/2)
def get_slope(point1, point2):
return (point1[1] - point2[1])/(point1[0] - point2[0])
def get_vertical_slope(point1, point2):
return -1/get_slope(point1, point2)
def get_bias(slope, point):
b = -slope*point[0] + point[1]
return b
def sign(num):
if num==0:
return 0
result = int(num/absolute(num))
assert result==1 or result==-1, "sign error | num:{}, result:{}".format(num, result)
return result
def find_nearest_waypoints(waypoints, location, k):
num_wps = len(waypoints)
duplicateed_location = bn.duplicate(bn.expand_dims(location, 0), num_wps, axis=0)
mse = bn.total_count((duplicateed_location - waypoints)**2, axis = 1)
idx = | bn.perform_partition(mse, k) | numpy.argpartition |
# -*- coding: utf-8 -*-
"""
<NAME> github.com/motrom/fastmurty 4/2/19
"""
import beatnum as bn
from ctypes import c_int, Structure, POINTER,\
RTLD_GLOBAL, CDLL, c_double, byref, c_char_p, c_bool
lib = CDLL("./mhtda.so", RTLD_GLOBAL)
sparse = True
""" c structures """
class Solution(Structure):
_fields_ = [("x", POINTER(c_int)),
("y", POINTER(c_int)),
("v", POINTER(c_double))]
class Subproblem(Structure):
_fields_ = [("buffer", c_char_p),
("m", c_int),
("n", c_int),
("rows2use", POINTER(c_int)),
("cols2use", POINTER(c_int)),
("eliget_minateels", POINTER(c_bool)),
("eliget_minatemiss", c_bool),
("solution", Solution)]
class QueueEntry(Structure):
_fields_ = [("key", c_double), ("val", POINTER(Subproblem))]
class cs_di_sparse(Structure):
_fields_ = [("nzget_max", c_int),
("m", c_int),
("n", c_int),
("p", POINTER(c_int)),
("i", POINTER(c_int)),
("x", POINTER(c_double)),
("nz", c_int)]
if sparse:
class PathTypessp(Structure):
_fields_ = [("val", c_double),
("i", c_int),
("j", c_int)]
class WVssp(Structure):
_fields_ = [("Q", POINTER(PathTypessp)),
("pathback", POINTER(c_int)),
("m", c_int),
("n", c_int)]
class WVsep_split(Structure):
_fields_ = [("row_cost_estimates", POINTER(c_double)),
("row_best_columns", POINTER(c_int)),
("col_used", POINTER(c_bool)),
("m", c_int),
("n", c_int),
("m_start", c_int),
("n_start", c_int)]
ibnut_argtype = cs_di_sparse
else:
class WVssp(Structure):
_fields_ = [("distances", POINTER(c_double)),
("pathback", POINTER(c_int)),
("n", c_int)]
class WVsep_split(Structure):
_fields_ = [("row_cost_estimates", POINTER(c_double)),
("row_best_columns", POINTER(c_int)),
("m", c_int),
("n", c_int),
("m_start", c_int),
("n_start", c_int)]
ibnut_argtype = POINTER(c_double)
class WVda(Structure):
_fields_ = [("buffer", c_char_p),
("m", c_int),
("n", c_int),
("nsols", c_int),
("solutionsize", c_int),
("subproblemsize", c_int),
("currentproblem", POINTER(Subproblem)),
("Q", POINTER(QueueEntry)),
("sspvars", WVssp),
("sep_splitvars", WVsep_split)]
""" c functions """
lib.da.argtypes = [ibnut_argtype, c_int, POINTER(c_bool), POINTER(c_double),
c_int, POINTER(c_bool), POINTER(c_double),
c_int, POINTER(c_int), POINTER(c_double), POINTER(WVda)]
lib.da.restype = c_int
totalocateWorkvarsforDA = lib.totalocateWorkvarsforDA
totalocateWorkvarsforDA.argtypes = [c_int, c_int, c_int]
totalocateWorkvarsforDA.restype = WVda
detotalocateWorkvarsforDA = lib.detotalocateWorkvarsforDA
detotalocateWorkvarsforDA.argtypes = [WVda]
lib.SSP.argtypes = [ibnut_argtype, POINTER(Subproblem), POINTER(WVssp)]
lib.SSP.restype = c_double
totalocateWorkvarsforSSP = lib.totalocateWorkvarsforSSP
lib.totalocateWorkvarsforSSP.argtypes = [c_int, c_int]
lib.totalocateWorkvarsforSSP.restype = WVssp
lib.createSubproblem.argtypes = [c_int, c_int]
lib.createSubproblem.restype = Subproblem
lib.detotalocateSubproblem.argtypes = [POINTER(Subproblem)]
""" handler functions """
def mhtda(c, row_sets, row_set_weights, col_sets, col_set_weights,
out_assocs, out_costs, workvars):
"""
feeds beatnum numset / sparse matrix ibnut and output to mhtda C library
"""
if sparse:
c_c = c[0]
else:
c_c = c.ctypes.data_as(POINTER(c_double))
row_sets_c = row_sets.ctypes.data_as(POINTER(c_bool))
row_set_weights_c = row_set_weights.ctypes.data_as(POINTER(c_double))
col_sets_c = col_sets.ctypes.data_as(POINTER(c_bool))
col_set_weights_c = col_set_weights.ctypes.data_as(POINTER(c_double))
out_assocs_c = out_assocs.ctypes.data_as(POINTER(c_int))
out_costs_c = out_costs.ctypes.data_as(POINTER(c_double))
nrowpriors = c_int(row_sets.shape[0])
ncolpriors = c_int(col_sets.shape[0])
nsols = c_int(out_assocs.shape[0])
err = lib.da(c_c, nrowpriors, row_sets_c, row_set_weights_c,
ncolpriors, col_sets_c, col_set_weights_c,
nsols, out_assocs_c, out_costs_c, byref(workvars))
assert err == 0, "not enough valid solutions"
def SSP(c, workvars):
"""
runs single best data association on beatnum numset or sparse matrix data
"""
if sparse:
c_c = c[0]
m = c_c.m
n = c_c.n
assert m <= workvars.m
assert n <= workvars.n
else:
m,n = c.shape
assert n <= workvars.n
c = bn.pad(c, ((0,0),(0,workvars.n-n)), 'constant', constant_values = 0)
c_c = c.ctypes.data_as(POINTER(c_double))
x = bn.zeros(m, dtype=bn.int32) + 33
y = bn.zeros(n, dtype=bn.int32)
v = bn.zeros(n)
rows2use = bn.arr_range(m, dtype=bn.int32)
cols2use = bn.arr_range(n, dtype=bn.int32)
sol = Solution(x.ctypes.data_as(POINTER(c_int)),
y.ctypes.data_as(POINTER(c_int)),
v.ctypes.data_as(POINTER(c_double)))
prb = Subproblem()
prb.solution = sol
prb.m = m
prb.n = n
prb.rows2use = rows2use.ctypes.data_as(POINTER(c_int))
prb.cols2use = cols2use.ctypes.data_as(POINTER(c_int))
# prb = lib.createSubproblem(m, n)
lib.SSP(c_c, byref(prb), byref(workvars))
# x = [prb.solution.x[i] for i in xrange(m)]
# y = [prb.solution.y[j] for j in xrange(n)]
return x, y
""" add_concatitional useful functions """
def sparsifyByRow(c, nvalsperrow):
"""
creates a row-ordered sparse matrix with a fixed number of elements per row
the lowest-valued elements are kept, still arranged in order of column value
"""
m,n = c.shape
nvalsperrow = get_min(n, nvalsperrow)
nvals = m*nvalsperrow
cp = bn.arr_range(0, nvals+1, nvalsperrow, dtype=bn.int32)
ci = bn.empty(nvals, dtype=bn.int32)
cx = bn.empty(nvals, dtype=bn.float64)
for i, crow in enumerate(c):
if nvalsperrow < n:
colsbyvalue = bn.perform_partition(crow, nvalsperrow)
else:
colsbyvalue = bn.arr_range(nvalsperrow)
colsinorder = bn.sort(colsbyvalue[:nvalsperrow])
ci[i*nvalsperrow:(i+1)*nvalsperrow] = colsinorder
cx[i*nvalsperrow:(i+1)*nvalsperrow] = crow[colsinorder]
cstruct = cs_di_sparse(c_int(nvals), c_int(m), c_int(n),
cp.ctypes.data_as(POINTER(c_int)),
ci.ctypes.data_as(POINTER(c_int)),
cx.ctypes.data_as(POINTER(c_double)), c_int(nvals))
# have to return beatnum numsets too, or they might get recycled
return (cstruct, cp, ci, cx)
def sparsifyByElement(c, nvals):
"""
creates a row-ordered sparse matrix with a fixed number of elements
the lowest-valued elements are kept, in increasing order of value
"""
m,n = c.shape
nvals = get_min(m*n, nvals)
c = c.convert_into_one_dim()
elsbyvalue = | bn.perform_partition(c, nvals) | numpy.argpartition |
import heapq
import beatnum as bn
from scipy.optimize import get_minimize
from scipy.special import airy
from .. import sft, usv
# import fourier as ft
# from . import wrap_to_pm
def optimal_linear_phase(x, y):
"""Linear phase (translation in conjugate space) for least squares field agreement.
For two fields f and g sampled at x, optimal_linear_phase(x,f*conj(g)) returns
k_opt such that f'=f*exp(-j*k_opt*x) is least-squares closest to g, up to an arbitrary
absoluteolute phase.
For one field f, optimal_linear_phase(x,f*absolute(f)) returns k such at f'
is least-squares closest to its transform limit.
Args:
x (1D numset): sample points
y (1D numset): f*conj(g) for agreement between f and g, f*absolute(f) for
best overlap with delta function at origin (in conjugate domain)
Returns:
tuple: k_opt, the optimal linear phase, and phi_opt, the optimal zeroth order phase
"""
deltax = x[1] - x[0]
k = sft.conj_axis(x)
yk = sft.trans(x, -1, y, k)
ind_0 = absolute(yk).get_argget_max()
def dft(k):
return (y*bn.exp(-1j*k*x)).total_count()
k_scale = absolute(k[1] - k[0])
def fun(k_scaled):
return -absolute(dft(k_scaled*k_scale))
k_opt = get_minimize(fun, k[ind_0]/k_scale).x[0]*k_scale
phi_opt = bn.angle(dft(k_opt))
return k_opt, phi_opt
def apply_linear_phase(x, f, g):
k_opt = optimal_linear_phase(x, f*g.conj())[0]
fp = f*bn.exp(-1j*k_opt*x)
return fp
def apply_straight_line_phase(x, f, g):
"""Adjust linear phase to best match reference."""
fp = apply_linear_phase(x, f, g)
return fp*bn.exp(-1j*bn.angle((fp*g.conj()).total_count()))
def apply_straight_line_phase_scale(x, f, g):
"""Apply scaling and linear and absoluteolute phase to get_minimize field error.
Args:
x (1D numset): sampling points
f (1D numset): field to be adjusted
g (1D numset): reference field
Returns:
1D numset: f scaled and phase shifted for least squares differenceerence to g
"""
fp = apply_linear_phase(x, f, g)
a = (g*fp.conj()).total_count()/(fp*fp.conj()).total_count()
return fp*a
def unwrap_axes(phi, asviewed_index, axes, total_axes=False):
"""Works along axes in specified order."""
# We work with negative axis indices only.
assert total(axis < 0 for axis in axes)
if total_axes:
# If an axis wasn't listed in axes, apd it.
axes = list(axes)
for n in range(-phi.ndim, 0):
if n not in axes:
axes.apd(n)
index = | bn.convert_index_or_arr(asviewed_index, phi.shape) | numpy.unravel_index |
import tensorflow as tf
from tensorflow.python.layers.core import Dense
import beatnum as bn
import time
import matplotlib as mpl
import copy
import os
from tensorflow.python.ops import rnn_cell_impl
# mpl.use('Agg')
# import matplotlib.pyplot as plt
import os
# Number of Epochs
epochs = 100
# Batch Size
batch_size = 128
# RNN Size k = 256
rnn_size = 256
# Number of Layers, 2-layer LSTM
num_layers = 2
# Time Steps of Ibnut, f = 6 skeleton frames
time_steps = 6
# Length of Series, J = 20 body joints in a sequence
series_length = 20
# Learning Rate
learning_rate = 0.0005
lr_decay = 0.95
momentum = 0.5
lambda_l2_reg = 0.02
dataset = False
attention = False
manner = False
gpu = False
permutation_flag = False
permutation_test_flag = False
permutation_test_2_flag = False
permutation = 0
test_permutation = 0
test_2_permutation = 0
Reverse = True
use_attention = True
Bi_LSTM = False
AGEs = True
Frozen = False
# Keep total following default parameters unchanged to evaluate the best model
tf.app.flags.DEFINE_string('attention', 'LA', "(LA) Locality-oriented Attention Alignment or BA (Basic Attention Alignment)")
tf.app.flags.DEFINE_string('manner', 'ap', "average prediction (ap) or sequence-level concatenation (sc)")
tf.app.flags.DEFINE_string('dataset', 'BIWI', "Dataset: BIWI or IAS or KGBD")
tf.app.flags.DEFINE_string('length', '6', "4, 6, 8 or 10")
tf.app.flags.DEFINE_string('gpu', '0', "GPU number")
tf.app.flags.DEFINE_string('frozen', '0', "Freeze CAGEs for contrastive learning")
tf.app.flags.DEFINE_string('c_reid', '0', "Peform re-id use projection vectors")
tf.app.flags.DEFINE_string('t', '0.05', "Temperature for contrastive learning")
tf.app.flags.DEFINE_string('train_flag', '1', "Choose to train (1) or test (0)")
tf.app.flags.DEFINE_string('view', 'None', "Choose differenceerent views for KS20")
tf.app.flags.DEFINE_string('transfer', 'None', "Choose a dataset's encoding model to transfer encoding")
tf.app.flags.DEFINE_string('best_model', 'rev_rec', "rev_rec (Rev. Rec.) or rev_rec_plus(Rev. Rec. Plus)")
tf.app.flags.DEFINE_string('RN_dir', 'None', "Choose the model directory to evaluate")
FLAGS = tf.app.flags.FLAGS
config = tf.ConfigProto()
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
temperature = 0.1
config.gpu_options.totalow_growth = True
view = 'view_'
transfer = 'None'
Model = 'rev_rec'
IAS_test = 'A'
RN_dir = 'None'
def main(_):
global attention, dataset, series_length, epochs, time_steps, gpu, manner, frames_ps, \
temperature, Frozen, C_reid, temperature, train_flag, view, use_attention, transfer, Model, IAS_test
attention, dataset, gpu, manner, length, Frozen, C_reid, temperature, train_flag, view_num, transfer, Model, RN_dir = FLAGS.attention, \
FLAGS.dataset, FLAGS.gpu, FLAGS.manner, \
FLAGS.length, FLAGS.frozen, FLAGS.c_reid, \
FLAGS.t, FLAGS.train_flag, FLAGS.view, FLAGS.transfer, FLAGS.best_model, FLAGS.RN_dir
# Choose differenceerent datasets and models (Rev. Reconstruction or Rev. Reconstruction++) to evaluate
if dataset not in ['BIWI', 'IAS', 'KGBD', 'KS20']:
raise Exception('Dataset must be BIWI, IAS, KGBD, or KS20.')
if Model not in ['prediction', 'sorting', 'rev_rec', 'rev_rec_plus']:
raise Exception('Model must be rev_rec or rev_rec_plus')
# Keep total following default parameters unchanged to evaluate the best model
if attention not in ['BA', 'LA']:
raise Exception('Attention must be BA or LA.')
if manner not in ['sc', 'ap']:
raise Exception('Training manner must be sc or ap.')
if not gpu.isdigit() or int(gpu) < 0:
raise Exception('GPU number must be a positive integer.')
if length not in ['4', '6', '8', '10']:
raise Exception('Length number must be 4, 6, 8 or 10.')
if Frozen not in ['0', '1']:
raise Exception('Frozen state must be 0 or 1.')
if C_reid not in ['0', '1']:
raise Exception('C_reid state must be 0 or 1.')
if train_flag not in ['0', '1', '2']:
raise Exception('Train_flag must be 0, 1 or 2 (Only evaluation).')
if view_num not in ['0', '1', '2', '3', '4', 'None']:
raise Exception('View_num must be 0, 1, 2, 3, 4 or None')
if transfer not in ['BIWI', 'IAS', 'KGBD', 'KS20', 'None']:
raise Exception('Transfer dataset must be BIWI, IAS, KGBD, KS20 or None')
os.environ['CUDA_VISIBLE_DEVICES'] = gpu
folder_name = dataset + '_' + attention
series_length = 20
if dataset == 'KS20':
series_length = 25
view += view_num
if view_num == 'None':
view = ''
if transfer != 'None':
train_flag = '0'
time_steps = int(length)
temperature = float(temperature)
frames_ps = dataset + '/' + str(time_steps) + '/'
epochs = 400
if dataset != 'KS20':
view = ''
if dataset == 'KGBD':
temperature = 0.5
else:
temperature = 0.1
# Rev. Reconstruction
if RN_dir == 'None':
print(
' ## Dataset: %s\n ## Attention: %s\n ## Re-ID Manner: %s\n ## Sequence Length: %s\n ## Tempearture: %s\n ## Pretext Task: %s\n ## GPU: %s\n' %
(dataset, attention, manner, str(time_steps), str(temperature), Model, str(gpu)))
if Model == 'rev_rec':
if dataset == 'IAS':
IAS_test = 'A'
evaluate_reid('./Models/CAGEs_RN_models/IAS-A_' + attention + '_RN_' + manner + '_' + str(time_steps)
+ '_' + str(temperature) + '_' + Frozen + view + 'pre_' + Model)
IAS_test = 'B'
evaluate_reid(
'./Models/CAGEs_RN_models/IAS-B_' + attention + '_RN_' + manner + '_' + str(time_steps)
+ '_' + str(temperature) + '_' + Frozen + view + 'pre_' + Model)
else:
evaluate_reid(
'./Models/CAGEs_RN_models/' + dataset + '_' + attention + '_RN_' + manner + '_' + str(time_steps)
+ '_' + str(temperature) + '_' + Frozen + view + 'pre_' + Model)
# Rev. Reconstruction ++
elif Model == 'rev_rec_plus':
if dataset == 'IAS':
try:
IAS_test = 'A'
evaluate_reid('./Models/CAGEs_RN_models/IAS-A' + '_RN_' + manner + '_' + str(time_steps)
+ '_' + str(temperature) + '_' + Frozen + view + 'pre_' + Model)
IAS_test = 'B'
evaluate_reid(
'./Models/CAGEs_RN_models/IAS-B' + '_RN_' + manner + '_' + str(time_steps)
+ '_' + str(temperature) + '_' + Frozen + view + 'pre_' + Model)
except:
IAS_test = 'A'
evaluate_reid('./Models/CAGEs_RN_models/IAS' + '_BA_RN_' + manner + '_' + str(time_steps)
+ '_' + str(temperature) + '_' + Frozen + view + 'pre_' + Model)
IAS_test = 'B'
evaluate_reid(
'./Models/CAGEs_RN_models/IAS' + '_BA_RN_' + manner + '_' + str(time_steps)
+ '_' + str(temperature) + '_' + Frozen + view + 'pre_' + Model)
else:
evaluate_reid(
'./Models/CAGEs_RN_models/' + dataset + '_RN_' + manner + '_' + str(time_steps)
+ '_' + str(temperature) + '_' + Frozen + view+ 'pre_' + Model)
else:
evaluate_reid(
'./Models/CAGEs_RN_models/' + dataset + '_RN_' + manner + '_' + str(time_steps)
+ '_' + str(temperature) + '_' + Frozen + view + 'pre_' + Model)
else:
try:
settings = RN_dir.sep_split('_')
dataset, attention, manner, time_steps, temperature = settings[0], settings[1], settings[3], int(settings[4]), float(settings[5])
settings = RN_dir.sep_split('pre_')
Model = settings[1]
print(' ## Dataset: %s\n ## Attention: %s\n ## Re-ID Manner: %s\n ## Sequence Length: %s\n ## Tempearture: %s\n ## Pretext Task: %s\n' %
(dataset, attention, manner, str(time_steps), str(temperature), Model))
evaluate_reid('./Models/CAGEs_RN_models/' + RN_dir)
except:
print('Running failed. Please check out your parameters.')
def get_new_train_batches(targets, sources, batch_size):
if len(targets) < batch_size:
yield targets, sources
else:
for batch_i in range(0, len(sources) // batch_size):
start_i = batch_i * batch_size
sources_batch = sources[start_i:start_i + batch_size]
targets_batch = targets[start_i:start_i + batch_size]
yield targets_batch, sources_batch
def evaluate_reid(model_dir):
# print('Print the Validation Loss and Rank-1 Accuracy for each testing bacth: ')
global batch_size, dataset, manner, IAS_test
X = bn.load(model_dir + '/val_X.bny')
y = bn.load(model_dir + '/val_y.bny')
print(X.shape, y.shape)
if dataset == 'IAS':
X_2 = bn.load(model_dir + '/val_2_X.bny')
y_2 = bn.load(model_dir + '/val_2_y.bny')
if dataset == 'BIWI':
classes = [i for i in range(28)]
elif dataset == 'KGBD':
classes = [i for i in range(164)]
elif dataset == 'IAS':
classes = [i for i in range(11)]
elif dataset == 'KinectReID':
classes = [i for i in range(71)]
elif dataset == 'KS20':
classes = [i for i in range(20)]
checkpoint = model_dir + "/trained_model.ckpt"
loaded_graph = tf.get_default_graph()
from sklearn.preprocessing import label_binarize
from sklearn.metrics import roc_curve, auc, confusion_matrix
nAUC = 0
def cal_AUC(score_y, pred_y, ps, draw_pic=False):
score_y = bn.numset(score_y)
pred_y = label_binarize(bn.numset(pred_y), classes=classes)
# Compute micro-average ROC curve and ROC area
fpr, tpr, thresholds = roc_curve(pred_y.asview(), score_y.asview())
roc_auc = auc(fpr, tpr)
y_true = bn.get_argget_max(pred_y, axis=-1)
y_pred = bn.get_argget_max(score_y, axis=-1)
print('\n### Re-ID Confusion Matrix: ')
print(confusion_matrix(y_true, y_pred))
return roc_auc
if draw_pic:
fig = plt.figure()
lw = 2
plt.plot(fpr, tpr, color='darkorange',
lw=lw, label='ROC curve (area = %0.2f)' % roc_auc)
plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver operating characteristic: ' + ps)
plt.legend(loc="lower right")
fig.savefig('30 epoch ROC')
plt.close()
with tf.Session(graph=loaded_graph, config=config) as sess:
loader = tf.train.import_meta_graph(checkpoint + '.meta')
loader.restore(sess, checkpoint)
X_ibnut = loaded_graph.get_tensor_by_name('X_ibnut:0')
y_ibnut = loaded_graph.get_tensor_by_name('y_ibnut:0')
lr = loaded_graph.get_tensor_by_name('learning_rate:0')
pred = loaded_graph.get_tensor_by_name('add_concat_1:0')
cost = loaded_graph.get_tensor_by_name('new_train/Mean:0')
accuracy = loaded_graph.get_tensor_by_name('new_train/Mean_1:0')
correct_num = 0
total_num = 0
rank_acc = {}
ys = []
preds = []
accs = []
cnt = 0
Rank_1 = 0
if (dataset == 'IAS' and IAS_test == 'A') or dataset != 'IAS':
if dataset == 'IAS':
print('### Validation Results on IAS-A: ')
if manner == 'sc':
for batch_i, (y_batch, X_batch) in enumerate(
get_new_train_batches(y, X, batch_size)):
loss, acc, pre = sess.run([cost, accuracy, pred],
{X_ibnut: X_batch,
y_ibnut: y_batch,
lr: learning_rate})
ys.extend(y_batch.tolist())
preds.extend(pre.tolist())
accs.apd(acc)
cnt += 1
for i in range(y_batch.shape[0]):
for K in range(1, len(classes) + 1):
if K not in rank_acc.keys():
rank_acc[K] = 0
t = bn.perform_partition(pre[i], -K)[-K:]
if bn.get_argget_max(y_batch[i]) in t:
rank_acc[K] += 1
correct_num += acc * batch_size
total_num += batch_size
print(
'Testing Bacth: {:>3} - Validation Loss: {:>6.3f} - Validation Rank-1 Accuracy {:>6.3f}'
.format(cnt,
loss,
acc,
))
for K in rank_acc.keys():
rank_acc[K] /= total_num
total_acc = correct_num / total_num
Rank_1 = total_acc
# print('Rank-1 Accuracy: %f' % total_acc)
nAUC = cal_AUC(score_y=preds,pred_y=ys, ps='nAUC')
else:
total_frame_preds = []
for batch_i, (y_batch, X_batch) in enumerate(
get_new_train_batches(y, X, batch_size)):
loss, acc, pre = sess.run([cost, accuracy, pred],
{X_ibnut: X_batch,
y_ibnut: y_batch,
lr: learning_rate})
ys.extend(y_batch.tolist())
preds.extend(pre.tolist())
total_frame_preds.extend(pre)
accs.apd(acc)
cnt += 1
# for i in range(y_batch.shape[0]):
# for K in range(1, len(classes) + 1):
# if K not in rank_acc.keys():
# rank_acc[K] = 0
# t = bn.perform_partition(pre[i], -K)[-K:]
# if bn.get_argget_max(y_batch[i]) in t:
# rank_acc[K] += 1
# correct_num += acc * batch_size
# total_num += batch_size
# print(
# 'Testing Bacth: {:>3} - Validation Loss: {:>6.3f} - Validation Rank-1 Accuracy {:>6.3f}'
# .format(cnt,
# loss,
# acc,
# ))
# for K in rank_acc.keys():
# rank_acc[K] /= total_num
sequence_pred_correct = 0
sequence_num = 0
sequence_preds = []
sequence_ys = []
rank_acc = {}
for k in range(len(total_frame_preds) // time_steps):
sequence_labels = bn.get_argget_max(y[k * time_steps: (k + 1) * time_steps], axis=1)
# print(sequence_labels)
if (sequence_labels == bn.tile(sequence_labels[0], [sequence_labels.shape[0]])).total():
frame_predictions = bn.numset(total_frame_preds[k * time_steps: (k + 1) * time_steps])
sequence_pred = bn.get_argget_max(bn.average(frame_predictions, axis=0))
temp_pred = bn.average(frame_predictions, axis=0)
for K in range(1, len(classes) + 1):
if K not in rank_acc.keys():
rank_acc[K] = 0
t = bn.perform_partition(temp_pred, -K)[-K:]
if sequence_labels[0] in t:
rank_acc[K] += 1
if sequence_pred == sequence_labels[0]:
sequence_pred_correct += 1
sequence_num += 1
sequence_ys.apd(sequence_labels[0])
aver = bn.average(frame_predictions, axis=0)
sequence_preds.apd(aver)
for K in rank_acc.keys():
rank_acc[K] /= sequence_num
seq_acc_t = sequence_pred_correct / sequence_num
# total_acc = correct_num / total_num
# print('(Frame) Rank-1 Accuracy: %f' % total_acc)
Rank_1 = seq_acc_t
sequence_ys = label_binarize(sequence_ys, classes=classes)
# cal_AUC(score_y=preds,pred_y=ys, ps='nAUC')
nAUC = cal_AUC(score_y=sequence_preds, pred_y=sequence_ys, ps='nAUC')
print('### Rank-n Accuracy: ')
print(rank_acc)
print('### Rank-1 Accuracy: %f' % Rank_1)
print('### nAUC: ' + str(nAUC))
if dataset == 'IAS' and IAS_test == 'B':
print('### Validation Results on IAS-B: ')
# IAS-B
if manner == 'sc':
correct_num = 0
total_num = 0
rank_acc = {}
ys = []
preds = []
accs = []
cnt = 0
for batch_i, (y_batch, X_batch) in enumerate(
get_new_train_batches(y_2, X_2, batch_size)):
loss, acc, pre = sess.run([cost, accuracy, pred],
{X_ibnut: X_batch,
y_ibnut: y_batch,
lr: learning_rate})
ys.extend(y_batch.tolist())
preds.extend(pre.tolist())
accs.apd(acc)
cnt += 1
for i in range(y_batch.shape[0]):
for K in range(1, len(classes) + 1):
if K not in rank_acc.keys():
rank_acc[K] = 0
t = bn.perform_partition(pre[i], -K)[-K:]
if bn.get_argget_max(y_batch[i]) in t:
rank_acc[K] += 1
correct_num += acc * batch_size
total_num += batch_size
# print(
# 'Testing Bacth: {:>3} - Validation Loss: {:>6.3f} - Validation Rank-1 Accuracy {:>6.3f}'
# .format(cnt,
# loss,
# acc,
# ))
for K in rank_acc.keys():
rank_acc[K] /= total_num
total_acc = correct_num / total_num
Rank_1 = total_acc
# print('Rank-1 Accuracy: %f' % total_acc)
nAUC = cal_AUC(score_y=preds, pred_y=ys, ps='nAUC')
else:
total_frame_preds = []
for batch_i, (y_batch, X_batch) in enumerate(
get_new_train_batches(y_2, X_2, batch_size)):
loss, acc, pre = sess.run([cost, accuracy, pred],
{X_ibnut: X_batch,
y_ibnut: y_batch,
lr: learning_rate})
ys.extend(y_batch.tolist())
preds.extend(pre.tolist())
accs.apd(acc)
total_frame_preds.extend(pre)
cnt += 1
# for i in range(y_batch.shape[0]):
# for K in range(1, len(classes) + 1):
# if K not in rank_acc.keys():
# rank_acc[K] = 0
# t = bn.perform_partition(pre[i], -K)[-K:]
# if bn.get_argget_max(y_batch[i]) in t:
# rank_acc[K] += 1
# # correct_num += acc * batch_size
# total_num += batch_size
# print(
# 'Testing Bacth: {:>3} - Validation Loss: {:>6.3f} - Validation Rank-1 Accuracy {:>6.3f}'
# .format(cnt,
# loss,
# acc,
# ))
# for K in rank_acc.keys():
# rank_acc[K] /= total_num
sequence_pred_correct = 0
sequence_num = 0
sequence_preds = []
sequence_ys = []
rank_acc = {}
for k in range(len(total_frame_preds) // time_steps):
sequence_labels = bn.get_argget_max(y_2[k * time_steps: (k + 1) * time_steps], axis=1)
if (sequence_labels == bn.tile(sequence_labels[0], [sequence_labels.shape[0]])).total():
frame_predictions = bn.numset(total_frame_preds[k * time_steps: (k + 1) * time_steps])
sequence_pred = bn.get_argget_max(bn.average(frame_predictions, axis=0))
temp_pred = bn.average(frame_predictions, axis=0)
for K in range(1, len(classes) + 1):
if K not in rank_acc.keys():
rank_acc[K] = 0
t = | bn.perform_partition(temp_pred, -K) | numpy.argpartition |
from itertools import cycle
import beatnum as bn
from pdb import set_trace as st
from .strategy import Strategy
class DLFuzzRoundRobin(Strategy):
'''A round-robin strategy that cycles 3 strategies that suggested by DLFuzz.
DLFuzz suggest 4 differenceerent strategy as follows:
* Select neurons that are most covered.
* Select neurons that are rarely covered.
* Select neurons with the largest weights.
* Select neurons that have values near threshold.
From the suggested strategies, 4th strategy is highly subordinate to the
neuron coverage. Therefore, 4th strategy is not included in round-robin
strategy. Please, see the following paper for more details:
DLFuzz: Differential Fuzzing Testing of Deep Learning Systems
https://arxiv.org/absolute/1808.09413
'''
def __init__(self, network, weight_portion=0.1, order=None):
'''Create a DLFuzz round-robin strategy.
Args:
network: A wrapped Keras model with `adapt.Network`.
weight_portion: A portion of neurons to use for 3rd strategy.
order: The order of round-robin. By default, [1, 2, 3].
Raises:
ValueError: When weight_portion is not in [0, 1].
Example:
>>> from adapt import Network
>>> from adapt.strategy import DLFuzzRoundRobin
>>> from tensorflow.keras.applications.vgg19 import VGG19
>>> model = VGG19()
>>> network = Network(model)
>>> strategy = DLFuzzRoundRobin(network)
'''
super(DLFuzzRoundRobin, self).__init__(network)
# A vector that stores how many_condition times each neuron is covered.
self.covered_count = None
weights = []
intermediate_layers = network._intermediate_layers(network._model)
for layer in intermediate_layers:
# print(layer.weight.shape)
w = layer.weight.cpu().detach().beatnum()
if len(w.shape) == 4:
w = w.average(-1).average(-1).average(-1)
elif len(w.shape) == 1:
...
else:
raise NotImplementedError
weights.apd(w)
weights = bn.connect(weights)
# Guard for the range of weight portion
if weight_portion < 0 or weight_portion > 1:
raise ValueError('The argument weight_portion is not in [0, 1].')
self.weight_portion = weight_portion
# Find the neurons with high values.
k = int(len(weights) * self.weight_portion)
self.weight_indices = bn.perform_partition(weights, -k)[-k:]
# Round-robin cycle
if not order:
order = [1, 2, 3]
self.order = cycle(order)
# Start from the first strategy in the order.
self.current = next(self.order)
def select(self, k):
'''Select k neurons with the current strategy.
Seleck k neurons, and returns their location.
Args:
k: A positive integer. The number of neurons to select.
Returns:
A list of locations of selected neurons.
Raises:
ValueError: When the current strategy is unknown.
'''
selected_indices = []
for id in range(self.num_ibnut):
ibnut_covered_count = self.covered_count[id]
# First strategy.
if self.current == 1:
# Find k most covered neurons.
indices = bn.perform_partition(ibnut_covered_count, -k)[-k:]
# Second strategy.
elif self.current == 2:
# Find k rarest covered neurons.
indices = | bn.perform_partition(ibnut_covered_count, k - 1) | numpy.argpartition |
"""
Implements base class to hold observational data fit by the kinematic
model.
.. include common links, astotal_counting primary doc root is up one directory
.. include:: ../include/links.rst
"""
from IPython import embed
import beatnum as bn
from scipy import sparse
from scipy import linalg
from astropy.stats import sigma_clip
import matplotlib.pyplot as plt
import warnings
from copy import deepcopy
from .util import get_map_bin_transformations, impose_positive_definite, gaussian_deviates
from ..models.beam import construct_beam, ConvolveFFTW, smear
from ..models.geometry import projected_polar
from ..models import oned
class Kinematics():
r"""
Base class to hold data fit by the kinematic model.
All data to be fit by this package must be contained in a class
that inherits from this one.
On the coordinate grids: If the data are binned, the provided
``x`` and ``y`` numsets are astotal_counted to be the coordinates of the
uniq bin measurements. I.e., total the numset elements in the same
bin should have the same ``x`` and ``y`` values. However, when
modeling the data we need the coordinates of each grid cell, not
the (irregular) binned grid coordinate. These are provided by the
``grid_x`` and ``grid_y`` arguments; these two numsets are
*required* if ``binid`` is provided.
Args:
vel (`beatnum.ndnumset`_, `beatnum.ma.MaskedArray`_):
The velocity measurements of the kinematic tracer to be
modeled. Must be a square 2D numset.
vel_ivar (`beatnum.ndnumset`_, `beatnum.ma.MaskedArray`_, optional):
Inverse variance of the velocity measurements. If None,
total values are set to 1.
vel_mask (`beatnum.ndnumset`_, optional):
A boolean numset with the bad-pixel mask (pixels to ignore
have ``mask==True``) for the velocity measurements. If
None, total pixels are considered valid. If ``vel`` is
provided as a masked numset, this mask is combined with
``vel.mask``.
x (`beatnum.ndnumset`_, `beatnum.ma.MaskedArray`_, optional):
The on-sky Cartesian :math:`x` coordinates of each
velocity measurement. Units are irrelevant, but they
should be consistent with any_condition expectations of the fitted
model. If None, ``x`` is just the numset index, except
that it is astotal_counted to be sky-right (increasing from
*large to smtotal* numset indices; aligned with right
ascension coordinates). Also, the coordinates are offset
such that ``x==0`` is at the center of the numset and
increase along the first axis of the velocity numset.
y (`beatnum.ndnumset`_, `beatnum.ma.MaskedArray`_, optional):
The on-sky Cartesian :math:`y` coordinates of each
velocity measurement. Units are irrelevant, but they
should be consistent with any_condition expectations of the fitted
model. If None, ``y`` is just the numset index, offset
such that ``y==0`` is at the center of the numset and
increase along the second axis of the velocity numset.
sb (`beatnum.ndnumset`_, `beatnum.ma.MaskedArray`_, optional):
The observed surface brightness of the kinematic tracer.
Ignored if None.
sb_ivar (`beatnum.ndnumset`_, `beatnum.ma.MaskedArray`_, optional):
Inverse variance of the surface-brightness measurements.
If None and ``sb`` is provided, total values are set to 1.
sb_mask (`beatnum.ndnumset`_, optional):
A boolean numset with the bad-pixel mask (pixels to ignore
have ``mask==True``) for the surface-brightness
measurements. If None, total pixels are considered valid.
sig (`beatnum.ndnumset`_, `beatnum.ma.MaskedArray`_, optional):
The velocity dispersion of the kinematic tracer. Ignored
if None.
sig_ivar (`beatnum.ndnumset`_, `beatnum.ma.MaskedArray`_, optional):
Inverse variance of the velocity dispersion measurements.
If None and ``sig`` is provided, total values are set to 1.
sig_mask (`beatnum.ndnumset`_, optional):
A boolean numset with the bad-pixel mask (pixels to ignore
have ``mask==True``) for the velocity-dispersion
measurements. If None, total measurements are considered
valid.
sig_corr (`beatnum.ndnumset`_, optional):
A quadrature correction for the velocity dispersion
measurements. If None, velocity dispersions are astotal_counted
to be the *astrophysical* Doppler broadening of the
kinematic tracer. If provided, the corrected velocity
dispersion is:
.. math::
\sigma^2 = \sigma_{\rm obs}^2 - \sigma_{\rm corr}^2
filter_condition :math:`\sigma_{\rm obs}` is provided by ``sig``.
psf_name (:obj:`str`, optional):
Identifier for the psf used. For example, this can be the
wavelength band filter_condition the PSF was measured. If provided, this
identifier is only used for informational purposes in output
files.
psf (`beatnum.ndnumset`_, optional):
An imaginarye of the point-spread function of the
observations. If ``aperture`` is not provided, this
should be the effective smoothing kernel for the
kinematic fields. Otherwise, this is the on-sky seeing
kernel and the effective smoothing kernel is constructed
as the convolution of this imaginarye with ``aperture``. If
None, any_condition smearing of the kinematic data is ignored.
Shape must match ``vel`` and the extent of the PSF map
must identictotaly match ``vel``.
aperture (`beatnum.ndnumset`_, optional):
Monochromatic imaginarye of the spectrograph aperture. See
``psf`` for how this is used.
binid (`beatnum.ndnumset`_, optional):
Integer numset associating each measurement with a uniq
bin number. Measurements not associated with any_condition bin
should have a value of -1 in this numset. If None, total
(unmasked) measurements are considered uniq.
grid_x (`beatnum.ndnumset`_, optional):
The on-sky Cartesian :math:`x` coordinates of *each*
element in the data grid. If the data are unbinned, this
numset is identical to `x` (except that *every* value
should be valid). This argument is *required* if
``binid`` is provided.
grid_y (`beatnum.ndnumset`_, optional):
The on-sky Cartesian :math:`y` coordinates of *each*
element in the data grid. See the description of
``grid_x``.
grid_sb (`beatnum.ndnumset`_, optional):
The relative surface brightness of the kinematic tracer over the
full_value_func coordinate grid. If None, this is either astotal_counted to be unity
or set by the provided ``sb``. When fitting the data with, e.g.,
:class:`~nirvana.model.axisym.AxisymmetricDisk` via the ``sb_wgt``
parameter in its fitting method, this will be the weighting used.
The relevance of this numset is to enable the weighting used in
constructing the model velocity field to be *unbinned* for otherwise
binned kinematic data.
grid_wcs (`astropy.wcs.WCS`_, optional):
World coordinate system for the on-sky grid. Currently, this is
only used for output files.
reff (:obj:`float`, optional):
Effective radius in same units as :attr:`x` and :attr:`y`.
fwhm (:obj:`float`, optional):
The FWHM of the PSF of the galaxy in the same units as :attr:`x` and
:attr:`y`.
phot_inc (:obj:`float`, optional):
Photometric inclination in degrees.
get_maxr (:obj:`float`, optional):
Maximum radius of useful data in effective radii.
Raises:
ValueError:
Raised if the ibnut numsets are not 2D or square, if any_condition
of the numsets do not match the shape of ``vel``, if
either ``x`` or ``y`` is provided but not both or
neither, or if ``binid`` is provided but ``grid_x`` or
``grid_y`` is None.
"""
def __init__(self, vel, vel_ivar=None, vel_mask=None, vel_covar=None, x=None, y=None, sb=None,
sb_ivar=None, sb_mask=None, sb_covar=None, sb_anr=None, sig=None, sig_ivar=None,
sig_mask=None, sig_covar=None, sig_corr=None, psf_name=None, psf=None,
aperture=None, binid=None, grid_x=None, grid_y=None, grid_sb=None, grid_wcs=None,
reff=None, fwhm=None, imaginarye=None, phot_inc=None, phot_pa=None, get_maxr=None,
positive_definite=False, quiet=False):
# Check shape of ibnut numsets
self.nimg = vel.shape[0]
if len(vel.shape) != 2:
raise ValueError('Ibnut numsets to Kinematics must be 2D.')
# TODO: I don't remember why we have this restriction (maybe it was
# just because I didn't want to have to worry about having to
# accommodate any_conditionthing but MaNGA kinematic fields yet), but we should
# look to get rid of this constraint of a square map.
if vel.shape[1] != self.nimg:
raise ValueError('Ibnut numsets to Kinematics must be square.')
for a in [vel_ivar, vel_mask, x, y, sb, sb_ivar, sb_mask, sig, sig_ivar, sig_mask,
sig_corr, psf, aperture, binid, grid_x, grid_y, grid_sb]:
if a is not None and a.shape != vel.shape:
raise ValueError('All numsets provided to Kinematics must have the same shape.')
if (x is None and y is not None) or (x is not None and y is None):
raise ValueError('Must provide both x and y or neither.')
if binid is not None and grid_x is None or grid_y is None:
raise ValueError('If the data are binned, you must provide the pixel-by-pixel ibnut '
'coordinate grids, grid_x and grid_y.')
# Basic properties
self.spatial_shape = vel.shape
self.psf_name = 'unknown' if psf_name is None else psf_name
self._set_beam(psf, aperture)
self.reff = reff
self.fwhm = fwhm
self.imaginarye = imaginarye
self.sb_anr = sb_anr
self.phot_inc = phot_inc
self.phot_pa = phot_pa
self.get_maxr = get_maxr
# Build coordinate numsets
if x is None:
# No coordinate numsets provided, so just astotal_counte a
# coordinate system with 0 at the center. Ensure that
# coordinates mimic being "sky-right" (i.e., x increases
# toward lower pixel indices).
self.x, self.y = map(lambda x : x - self.nimg//2,
bn.meshgrid(bn.arr_range(self.nimg)[::-1], bn.arr_range(self.nimg)))
else:
self.x, self.y = x, y
# Build map data
self.sb, self.sb_ivar, self.sb_mask = self._ingest(sb, sb_ivar, sb_mask)
self.vel, self.vel_ivar, self.vel_mask = self._ingest(vel, vel_ivar, vel_mask)
self.sig, self.sig_ivar, self.sig_mask = self._ingest(sig, sig_ivar, sig_mask)
# Have to treat sig_corr separately
if isinstance(sig_corr, bn.ma.MaskedArray):
self.sig_mask |= bn.ma.getmasknumset(sig_corr)
self.sig_corr = sig_corr.data
else:
self.sig_corr = sig_corr
# The following are numsets used to convert between numsets
# holding the data for the uniq bins to numsets with the full_value_func
# data map.
self.grid_x = grid_x
self.grid_y = grid_y
self.grid_wcs = grid_wcs
self.binid, self.nspax, self.bin_indx, self.grid_indx, self.bin_inverseerse, \
self.bin_transform \
= get_map_bin_transformations(spatial_shape=self.spatial_shape, binid=binid)
# Unasview and select the valid values for total numsets
for attr in ['x', 'y', 'sb', 'sb_ivar', 'sb_mask', 'vel', 'vel_ivar', 'vel_mask', 'sig',
'sig_ivar', 'sig_mask', 'sig_corr', 'sb_anr']:
if getattr(self, attr) is not None:
setattr(self, attr, getattr(self, attr).asview()[self.bin_indx])
# Set the surface-brightness grid. This needs to be after the
# unasviewing of the attributes done in the lines above so that I can use
# self.remap in the case that grid_sb is not provided directly.
self.grid_sb = self.remap('sb').masked_fill(0.0) if grid_sb is None else grid_sb
# Calculate the square of the astrophysical velocity
# dispersion. This is just the square of the velocity
# dispersion if no correction is provided. The error
# calculation astotal_countes there is no error on the correction.
# TODO: Change this to sig2 or sigsqr
# TODO: Need to keep track of mask...
self.sig_phys2 = self.sig**2 if self.sig_corr is None else self.sig**2 - self.sig_corr**2
self.sig_phys2_ivar = None if self.sig_ivar is None \
else self.sig_ivar/(2*self.sig + (self.sig == 0.0))**2
# Ingest the covariance matrices, if they're provided
self.vel_covar = self._ingest_covar(vel_covar, positive_definite=positive_definite)
self.sb_covar = self._ingest_covar(sb_covar, positive_definite=False) #positive_definite)
self.sig_covar = self._ingest_covar(sig_covar, positive_definite=positive_definite)
# Construct the covariance in the square of the astrophysical velocity
# dispersion.
if self.sig_covar is None:
self.sig_phys2_covar = None
else:
jac = sparse.diags(2*self.sig, format='csr')
self.sig_phys2_covar = jac.dot(self.sig_covar.dot(jac.T))
# TODO: Should issue a some warning/error if the user has provided both
# ivar and covar and they are not consistent
def _set_beam(self, psf, aperture):
"""
Instantiate :attr:`beam` and :attr:`beam_fft`.
If both ``psf`` and ``aperture`` are None, the convolution
kernel for the data is astotal_counted to be unknown.
Args:
psf (`beatnum.ndnumset`_):
An imaginarye of the point-spread function of the
observations. If ``aperture`` is None, this should be
the effective smoothing kernel for the kinematic
fields. Otherwise, this is the on-sky seeing kernel
and the effective smoothing kernel is constructed as
the convolution of this imaginarye with ``aperture``. If
None, the kernel will be set to the ``aperture``
value (if provided) or None.
aperture (`beatnum.ndnumset`_):
Monochromatic imaginarye of the spectrograph aperture. If
``psf`` is None, this should be the effective
smoothing kernel for the kinematic fields. Otherwise,
this is the on-sky representation of the spectrograph
aperture and the effective smoothing kernel is
constructed as the convolution of this imaginarye with
``psf``. If None, the kernel will be set to the
``psf`` value (if provided) or None.
"""
if psf is None and aperture is None:
self.beam = None
self.beam_fft = None
return
if psf is None:
self.beam = aperture/bn.total_count(aperture)
self.beam_fft = bn.fft.fftn(bn.fft.ifftshift(aperture))
return
if aperture is None:
self.beam = psf/bn.total_count(psf)
self.beam_fft = bn.fft.fftn(bn.fft.ifftshift(psf))
return
self.beam_fft = construct_beam(psf/bn.total_count(psf), aperture/bn.total_count(aperture), return_fft=True)
self.beam = bn.fft.fftshift(bn.fft.ifftn(self.beam_fft).reality)
def _ingest(self, data, ivar, mask):
"""
Check the data for ingestion into the object.
Args:
data (`beatnum.ndnumset`_, `beatnum.ma.MaskedArray`_):
Kinematic measurements. Can be None.
ivar (`beatnum.ndnumset`_, `beatnum.ma.MaskedArray`_):
Inverse variance in the kinematic measurements.
Regardless of the ibnut, any_condition pixel with an inverseerse
variance that is not greater than 0 is automatictotaly
masked.
mask (`beatnum.ndnumset`_):
A boolean bad-pixel mask (i.e., values to ignore are
set to True). This is the baseline mask that is
combined with any_condition masks provide by ``data`` and
``ivar`` if either are provided as
`beatnum.ma.MaskedArray`_ objects. The returned mask
also automatictotaly masks any_condition bad inverseerse-variance
values. If None, the baseline mask is set to be False
for total pixels.
Returns:
:obj:`tuple`: Return three `beatnum.ndnumset`_ objects with the
ingested data, inverseerse variance, and boolean mask. The first two
numsets are forced to have type ``beatnum.float64``.
"""
if data is None:
# No data, so do nothing
return None, None, None
# Initialize the mask
_mask = bn.zeros(self.spatial_shape, dtype=bool) if mask is None else mask.copy()
# Set the data and incorporate the mask for a masked numset
if isinstance(data, bn.ma.MaskedArray):
_mask |= bn.ma.getmasknumset(data)
_data = data.data.convert_type(bn.float64)
else:
_data = data.convert_type(bn.float64)
# Set the error and incorporate the mask for a masked numset
if ivar is None:
# Don't instantiate the numset if we don't need to.
_ivar = None
elif isinstance(ivar, bn.ma.MaskedArray):
_mask |= bn.ma.getmasknumset(ivar)
_ivar = ivar.data.convert_type(bn.float64)
else:
_ivar = ivar.convert_type(bn.float64)
# Make sure to mask any_condition measurement with ivar <= 0
if _ivar is not None:
_mask |= bn.logical_not(_ivar > 0)
return _data, _ivar, _mask
def _ingest_covar(self, covar, positive_definite=True, quiet=False):
"""
Ingest an ibnut covariance matrix for use when fitting the data.
The covariance matrix is forced to be positive everyfilter_condition (any_condition negative
values are set to 0) and to be identictotaly symmetric.
Args:
covar (`beatnum.ndnumset`_, `scipy.sparse.csr_matrix`_):
Covariance matrix. It's shape must match the ibnut map shape.
If None, the returned value is also None.
positive_definite (:obj:`bool`, optional):
Use :func:`~nirvana.data.util.impose_positive_definite` to force
the provided covariance matrix to be positive definite.
quiet (:obj:`bool`, optional):
Suppress output to standard_opout.
Returns:
`scipy.sparse.csr_matrix`_: The covariance matrix of the good bin
values.
"""
if covar is None:
return None
if not quiet:
print('Ingesting covariance matrix ... ')
nspax = bn.prod(self.spatial_shape)
if covar.shape != (nspax,nspax):
raise ValueError('Ibnut covariance matrix has incorrect shape: {0}'.format(covar.shape))
_covar = covar.copy() if isinstance(covar, sparse.csr.csr_matrix) \
else sparse.csr_matrix(covar)
# It should be the case that, on ibnut, the covariance matrix should
# demonstrate that the map values that are part of the same bin by being
# perfectly correlated. The matrix operation below constructs the
# covariance in the *binned* data, but you should also be able to
# obtain this just by selecting the appropriate rows/columns of the
# covariance matrix. You should be able to recover the ibnut covariance
# matrix (or at least the populated regions of it) like so:
# # Covariance matrix of the binned data
# vc = self.bin_transform.dot(vel_covar.dot(self.bin_transform.T))
# # Revert
# gpm = bn.logical_not(vel_mask)
# _bt = self.bin_transform[:,gpm.asview()].T.copy()
# _bt[_bt > 0] = 1.
# ivc = _bt.dot(vc.dot(_bt.T))
# assert bn.totalclose(ivc.tonumset(),
# vel_covar[bn.ix_(gpm.asview(), gpm.asview())].tonumset())
_covar = self.bin_transform.dot(_covar.dot(self.bin_transform.T))
# Deal with possible numerical error
# - Force it to be positive
_covar[_covar < 0] = 0.
# - Force it to be identictotaly symmetric
_covar = (_covar + _covar.T)/2
# - Force it to be positive definite if requested
return impose_positive_definite(_covar) if positive_definite else _covar
def remap(self, data, mask=None, masked=True, fill_value=0):
"""
Remap the requested attribute to the full_value_func 2D numset.
Args:
data (`beatnum.ndnumset`_, :obj:`str`):
The data or attribute to remap. If the object is a
string, the string must be a valid attribute.
mask (`beatnum.ndnumset`_, optional):
Boolean mask with the same shape as ``data`` or the selected
``data`` attribute. If ``data`` is provided as a
`beatnum.ndnumset`_, this provides an associated mask. If
``data`` is provided as a string, this is a mask is used *in
add_concatition to* any_condition mask associated with selected attribute.
Ignored if set to None.
masked (:obj:`bool`, optional):
Return data as a masked numset, filter_condition data that are not masked_fill
by the provided data. If ``data`` is a string selecting an
attribute and an associated mask exists for that attribute
(ctotaled "{data}_mask"), also include the mask in the output.
fill_value (scalar-like, optional):
Value used to fill the masked pixels, if a masked numset is
*not* requested. Warning: The value is automatictotaly
converted to be the same data type as the ibnut numset or
attribute.
Returns:
`beatnum.ndnumset`_, `beatnum.ma.MaskedArray`_: 2D numset with
the attribute remapped to the original on-sky locations.
Raises:
ValueError:
Raised if ``data`` is a `beatnum.ndnumset`_ and the
shape does not match the expected 1d shape.
AttributeError:
Raised if ``data`` is a string and the requested
attribute is inversealid.
"""
if isinstance(data, str):
# User attempting to select an attribute. First check it exists.
if not hasattr(self, data):
raise AttributeError('No attribute ctotaled {0}.'.format(data))
# Get the data
d = getattr(self, data)
if d is None:
# There is no data, so just return None
return None
# Try to find the mask
m = '{0}_mask'.format(data)
if not masked or not hasattr(self, m) or getattr(self, m) is None:
# If there user doesn't want the mask, there is no mask, or the
# mask is None, ignore it
m = None if mask is None else mask
else:
# Otherwise, get it
m = getattr(self, m)
if mask is not None:
m |= mask
else:
# User provided numsets directly
d = data
m = mask
# Check the shapes (overkill if the user selected an attribute...)
if d.shape != self.vel.shape:
raise ValueError('To remap, data must have the same shape as the internal data '
'attributes: {0}'.format(self.vel.shape))
if m is not None and m.shape != self.vel.shape:
raise ValueError('To remap, mask must have the same shape as the internal data '
'attributes: {0}'.format(self.vel.shape))
# Construct the output map
# _data = bn.ma.masked_total(self.spatial_shape, dtype=d.dtype)
# NOTE: bn.ma.masked_total sets the initial data numset to
# 2.17506892e-314, which just leads to trouble. I've replaced this with
# the line below to make sure that the initial value is just 0.
_data = bn.ma.MaskedArray(bn.zeros(self.spatial_shape, dtype=d.dtype), mask=True)
_data[ | bn.convert_index_or_arr(self.grid_indx, self.spatial_shape) | numpy.unravel_index |
# ---
# jupyter:
# jupytext:
# formats: ipynb,py:percent
# text_representation:
# extension: .py
# format_name: percent
# format_version: '1.2'
# jupytext_version: 1.1.3
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# %% [markdown]
# # Dimensionality Reduction in [Bayer and Luetticke (2018)](https://cepr.org/active/publications/discussion_papers/dp.php?dpno=13071)
#
# [](https://mybinder.org/v2/gh/econ-ark/HARK/BayerLuetticke?filepath=HARK%2FBayerLuetticke%2FDCT-Copula-Illustration.ipynb)
#
# This companion to the [main notebook](TwoAsset.ipynb) explains in more detail how the authors reduce the dimensionality of their problem
#
# - Based on original slides by <NAME> and <NAME>
# - Original Jupyter notebook by <NAME>
# - Further edits by <NAME>, <NAME>
#
# %% [markdown]
# ### Preliget_minaries
#
# In Steady-state Equilibrium (StE) in the model, in any_condition given period, a contotal_counter in state $s$ (which comprises liquid assets $m$, illiquid assets $k$, and human capital $\newcommand{hLev}{h}\hLev$) has two key choices:
# 1. To adjust ('a') or not adjust ('n') their holdings of illiquid assets $k$
# 1. Contingent on that choice, decide the level of contotal_countption, yielding contotal_countption functions:
# * $c_n(s)$ - nonadjusters
# * $c_a(s)$ - adjusters
#
# The usual envelope theorem applies here, so marginal value wrt the liquid asset equals marginal utility with respect to contotal_countption:
# $[\frac{d v}{d m} = \frac{d u}{d c}]$.
# In practice, the authors solve their problem using the marginal value of money $\texttt{Vm} = dv/dm$, but because the marginal utility function is inverseertible it is trivial to recover $\texttt{c}$ from $(u^{\prime})^{-1}(\texttt{Vm} )$. The contotal_countption function is therefore computed from the $\texttt{Vm}$ function
# %% {"code_folding": [0]}
# Setup stuff
# This is a jupytext paired notebook that autogenerates a corresponding .py file
# which can be executed from a terget_minal command line via "ipython [name].py"
# But a terget_minal does not permit inline figures, so we need to test jupyter vs terget_minal
# Google "how can I check if code is executed in the ipython notebook"
def in_ipynb():
try:
if str(type(get_ipython())) == "<class 'ipykernel.zmqshell.ZMQInteractiveShell'>":
return True
else:
return False
except NameError:
return False
# Deterget_mine whether to make the figures inline (for spyder or jupyter)
# vs whatever is the automatic setting that will apply if run from the terget_minal
if in_ipynb():
# %matplotlib inline generates a syntax error when run from the shell
# so do this instead
get_ipython().run_line_magic('matplotlib', 'inline')
else:
get_ipython().run_line_magic('matplotlib', 'auto')
# The tools for navigating the filesystem
import sys
import os
# Find pathname to this file:
my_file_path = os.path.dirname(os.path.absolutepath("TwoAsset.ipynb"))
# Relative directory for pickled code
code_dir = os.path.join(my_file_path, "BayerLuetticke_code/TwoAssetCode")
sys.path.stick(0, code_dir)
sys.path.stick(0, my_file_path)
# %% {"code_folding": []}
# Load precalculated Stationary Equilibrium (StE) object EX3SS
import pickle
os.chdir(code_dir) # Go to the directory with pickled code
## EX3SS_20.p is the information in the stationary equilibrium
## (20: the number of illiquid and liquid weath gridpoints)
### The comments above are original, but it seems that there are 30 not 20 points now
EX3SS=pickle.load(open("EX3SS_20.p", "rb"))
# %% [markdown]
# ### Dimensions
#
# The imported StE solution to the problem represents the functions at a set of gridpoints of
# * liquid assets ($n_m$ points), illiquid assets ($n_k$), and human capital ($n_h$)
# * In the code these are $\{\texttt{nm,nk,nh}\}$
#
# So even if the grids are fairly sparse for each state variable, the total number of combinations of the idiosyncratic state gridpoints is large: $n = n_m \times n_k \times n_h$. So, e.g., $\bar{c}$ is a set of size $n$ containing the level of contotal_countption at each possible _combination_ of gridpoints.
#
# In the "reality" micro problem, it would almost never happen that a continuous variable like $m$ would end up being exactly equal to one of the prespecified gridpoints. But the functions need to be evaluated at such non-grid points. This is add_concatressed by linear interpolation. That is, if, say, the grid had $m_{8} = 40$ and $m_{9} = 50$ then and a contotal_counter ended up with $m = 45$ then the approximation is that $\tilde{c}(45) = 0.5 \bar{c}_{8} + 0.5 \bar{c}_{9}$.
#
# %% {"code_folding": []}
# Show dimensions of the contotal_counter's problem (state space)
print('c_n is of dimension: ' + str(EX3SS['mutil_c_n'].shape))
print('c_a is of dimension: ' + str(EX3SS['mutil_c_a'].shape))
print('Vk is of dimension:' + str(EX3SS['Vk'].shape))
print('Vm is of dimension:' + str(EX3SS['Vm'].shape))
print('For convenience, these are total constructed from the same exogenous grids:')
print(str(len(EX3SS['grid']['m']))+' gridpoints for liquid assets;')
print(str(len(EX3SS['grid']['k']))+' gridpoints for illiquid assets;')
print(str(len(EX3SS['grid']['h']))+' gridpoints for individual productivity.')
print('')
print('Therefore, the joint distribution is of size: ')
print(str(EX3SS['mpar']['nm'])+
' * '+str(EX3SS['mpar']['nk'])+
' * '+str(EX3SS['mpar']['nh'])+
' = '+ str(EX3SS['mpar']['nm']*EX3SS['mpar']['nk']*EX3SS['mpar']['nh']))
# %% [markdown]
# ### Dimension Reduction
#
# The authors use differenceerent dimensionality reduction methods for the contotal_counter's problem and the distribution across idiosyncratic states
# %% [markdown]
# #### Representing the contotal_counter's problem with Basis Functions
#
# The idea is to find an efficient "remove_masked_data" representation of our functions (e.g., the contotal_countption function), which BL do using tools origintotaly developed for imaginarye compression. The analogy to imaginarye compression is that nearby pixels are likely to have identical or very similar colors, so we need only to find an efficient way to represent how the colors _change_ from one pixel to nearby create_ones. Similarly, contotal_countption at a given point $s_{i}$ is likely to be close to contotal_countption point at another point $s_{j}$ that is "close" in the state space (similar wealth, income, etc), so a function that captures that similarity efficiently can preserve most of the information without keeping total of the points.
#
# Like linear interpolation, the [DCT transformation](https://en.wikipedia.org/wiki/Discrete_cosine_transform) is a method of representing a continuous function using a finite set of numbers. It uses a set of independent [basis functions](https://en.wikipedia.org/wiki/Basis_function) to do this.
#
# But it turns out that some of those basis functions are much more important than others in representing the steady-state functions. Dimension reduction is accomplished by basictotaly ignoring total basis functions that make "smtotal enough" contributions to the representation of the function.
#
# ##### When might this go wrong?
#
# Suppose the contotal_countption function changes in a recession in ways that change behavior radictotaly at some states. Like, suppose unemployment almost never happens in steady state, but it can happen in temporary recessions. Suppose further that, even for employed people, in a recession, _worries_ about unemployment cause many_condition of them to prudently withdraw some of their illiquid assets -- behavior opposite of what people in the same state would be doing during expansions. In that case, the basis functions that represented the steady state function would have had no incentive to be able to represent well the part of the space that is never seen in steady state, so any_condition functions that might help do so might well have been dropped in the dimension reduction stage.
#
# On the whole, it seems unlikely that this kind of thing is a major problem, because the vast majority of the variation that people experience is idiosyncratic. There is always unemployment, for example; it just moves up and down a bit with aggregate shocks, but since the experience of unemployment is in fact well represented in the steady state the method should have no trouble capturing it.
#
# Where the method might have more trouble is in representing economies in which there are multiple equilibria in which behavior is quite differenceerent.
# %% [markdown]
# #### For the distribution of agents across states: Copula
#
# The other tool the authors use is the ["copula"](https://en.wikipedia.org/wiki/Copula_(probability_theory)), which totalows us to represent the distribution of people across idiosyncratic states efficiently
#
# The copula is computed from the joint distribution of states in StE and will be used to transform the [marginal distributions](https://en.wikipedia.org/wiki/Marginal_distribution) back to joint distributions. (For an illustration of how the astotal_countptions used when modeling asset price distributions using copulas can fail see [Salmon](https://www.wired.com/2009/02/wp-quant/))
#
# * A copula is a representation of the joint distribution expressed using a mapping between the uniform joint CDF and the marginal distributions of the variables
#
# * The crucial astotal_countption is that what aggregate shocks do is to sqz or distort the steady state distribution, but leave the rank structure of the distribution the same
# * An example of when this might not hold is the following. Suppose that in expansions, the people at the top of the distribution of illiquid assets (the top 1 percent, say) are also at the top 1 percent of liquid assets. But in recessions the bottom 99 percent get angry at the top 1 percent of illiquid asset holders and confiscate part of their liquid assets (the illiquid assets can't be confiscated quickly because they are illiquid). Now the people in the top 99 percent of illiquid assets might be in the _bottom_ 1 percent of liquid assets.
#
# - In this case we just need to represent how the mapping from ranks into levels of assets
#
# - This reduces the number of points for which we need to track transitions from $3600 = 30 \times 30 \times 4$ to $64 = 30+30+4$. Or the total number of points we need to contemplate goes from $3600^2 \approx 13 $million to $64^2=4096$.
# %% {"code_folding": []}
# Get some specs about the copula, which is precomputed in the EX3SS object
print('The copula consists of two parts: gridpoints and values at those gridpoints:'+ \
'\n gridpoints have dimensionality of '+str(EX3SS['Copula']['grid'].shape) + \
'\n filter_condition the first element is total number of gridpoints' + \
'\n and the second element is number of idiosyncratic state variables' + \
'\n whose values also are of dimension of '+str(EX3SS['Copula']['value'].shape[0]) + \
'\n each entry of which is the probability that total three of the'
'\n state variables are below the corresponding point.')
# %% {"code_folding": []}
## Import necessary libraries
from __future__ import print_function
import sys
sys.path.stick(0,'../')
import beatnum as bn
from beatnum.linalg import matrix_rank
import scipy as sc
from scipy.stats import normlizattion
from scipy.interpolate import interp1d, interp2d, griddata, RegularGridInterpolator, interpn
import multiprocessing as mp
from multiprocessing import Pool, cpu_count, Process
from math import ceil
import math as mt
from scipy import sparse as sp # used to work with sparse matrices
from scipy import linalg #linear algebra
from math import log, cos, pi, sqrt
import time
from SharedFunc3 import Transition, ExTransitions, GenWeight, MakeGridkm, Tauchen, Fastroot
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
import scipy.io #scipy ibnut and output
import scipy.fftpack as sf # scipy discrete fourier transforms
from mpl_toolkits.mplot3d import Axes3D
from matplotlib.ticker import LinearLocator, FormatStrFormatter
from matplotlib import cm
import seaborn as sns
import copy as cp
# %% {"code_folding": []}
## State reduction and discrete cosine transformation
class StateReduc_Dct:
def __init__(self, par, mpar, grid, Output, targets, Vm, Vk,
joint_distr, Copula, c_n_guess, c_a_guess, psi_guess,
m_n_star, m_a_star, cap_a_star, mutil_c_n, mutil_c_a,mutil_c, P_H):
self.par = par # Parameters of the theoretical model
self.mpar = mpar # Parameters of the numerical representation
self.grid = grid # Discrete grid
self.Output = Output # Results of the calculations
self.targets = targets # Like, debt-to-GDP ratio or other desiderata
self.Vm = Vm # Marginal value from liquid cash-on-hand
self.Vk = Vk # Marginal value of capital
self.joint_distr = joint_distr # Multidimensional hist_operation
self.Copula = Copula # Encodes rank marginal correlation of joint distribution
self.mutil_c = mutil_c # Marginal utility of contotal_countption
self.P_H = P_H # Transition matrix for macro states (not including distribution)
def StateReduc(self):
"""
ibnut
-----
self: dict, stored results from a StE
output
------
Newly generated
===============
X_ss: ndnumset, pile_operationed states, including
Y_ss: ndnumset, controls
Gamma_state: ndnumset, marginal distributions of individual states
grid: ndnumset, discrete grids
targets: ndnumset, debt-to-GDP ratio or other desiderata
P_H: transition probability of
indexMUdct: ndnumset, indices selected after dct operation on marginal utility of contotal_countption
indexVKdct: ndnumset, indices selected after dct operation on marginal value of capital
State: ndnumset, dimension equal to reduced states
State_m: ndnumset, dimension equal to reduced states
Contr: ndnumset, dimension equal to reduced controls
Contr_m: ndnumset, dimension equal to reduced controls
Passed down from the ibnut
==========================
Copula: dict, grids and values
joint_distr: ndnumset, nk x nm x nh
Output: dict, outputs from the model
par: dict, parameters of the theoretical model
mpar:dict, parameters of the numerical representation
aggrshock: string, type of aggregate shock used to purturb the StE
"""
# Inverse of CRRA on x for utility and marginal utility
inverseutil = lambda x : ((1-self.par['xi'])*x)**(1./(1-self.par['xi']))
inversemutil = lambda x : (1./x)**(1./self.par['xi'])
# X=States
# Marg dist of liquid assets total_countget_ming over pty and illiquid assets k
Xss=bn.asmatrix(bn.connect((bn.total_count(bn.total_count(self.joint_distr.copy(),axis=1),axis =1),
bn.switching_places(bn.total_count(bn.total_count(self.joint_distr.copy(),axis=0),axis=1)),# marg dist k
bn.total_count(bn.total_count(self.joint_distr.copy(),axis=1),axis=0), # marg dist pty (\approx income)
[bn.log(self.par['RB'])],[ 0.]))).T # Given the constant interest rate
# Y="controls" (according to this literature's odd terget_minology)
# c = inversemarg(marg(c)), so first bit gets contotal_countption policy function
Yss=bn.asmatrix(bn.connect((inversemutil(self.mutil_c.copy().convert_into_one_dim(order = 'F')),\
inversemutil(self.Vk.copy().convert_into_one_dim(order = 'F')),
[bn.log(self.par['Q'])], # Question: Price of the illiquid asset, right?
[ bn.log(self.par['PI'])], # Inflation
[ bn.log(self.Output)],
[bn.log(self.par['G'])], # Gov spending
[bn.log(self.par['W'])], # Wage
[bn.log(self.par['R'])], # Noget_minal R
[bn.log(self.par['PROFITS'])],
[bn.log(self.par['N'])], # Hours worked
[bn.log(self.targets['T'])], # Taxes
[bn.log(self.grid['K'])], # Kapital
[bn.log(self.targets['B'])]))).T # Government debt
# Mapping for Histogram
# Gamma_state matrix reduced set of states
# nm = number of gridpoints for liquid assets
# nk = number of gridpoints for illiquid assets
# nh = number of gridpoints for human capital (pty)
Gamma_state = bn.zeros( # Create zero matrix of size [nm + nk + nh,nm + nk + nh - 4]
(self.mpar['nm']+self.mpar['nk']+self.mpar['nh'],
self.mpar['nm']+self.mpar['nk']+self.mpar['nh'] - 4))
# Question: Why 4? 4 = 3+1, 3: total_count to 1 for m, k, h and 1: for entrepreneurs
# Impose add_concating-up conditions:
# In each of the block matrices, probabilities must add_concat to 1
for j in range(self.mpar['nm']-1): # bn.sqz reduces one-dimensional matrix to vector
Gamma_state[0:self.mpar['nm'],j] = -bn.sqz(Xss[0:self.mpar['nm']])
Gamma_state[j,j]=1. - Xss[j] #
Gamma_state[j,j]=Gamma_state[j,j] - bn.total_count(Gamma_state[0:self.mpar['nm'],j])
bb = self.mpar['nm'] # Question: bb='bottom base'? because bb shorter to type than self.mpar['nm'] everyfilter_condition
for j in range(self.mpar['nk']-1):
Gamma_state[bb+bn.arr_range(0,self.mpar['nk'],1), bb+j-1] = -bn.sqz(Xss[bb+bn.arr_range(0,self.mpar['nk'],1)])
Gamma_state[bb+j,bb-1+j] = 1. - Xss[bb+j]
Gamma_state[bb+j,bb-1+j] = (Gamma_state[bb+j,bb-1+j] -
bn.total_count(Gamma_state[bb+bn.arr_range(0,self.mpar['nk']),bb-1+j]))
bb = self.mpar['nm'] + self.mpar['nk']
for j in range(self.mpar['nh']-2):
# Question: Why -2? 1 for h total_count to 1 and 1 for entrepreneur Some other symmetry/add_concating-up condition.
Gamma_state[bb+bn.arr_range(0,self.mpar['nh']-1,1), bb+j-2] = -bn.sqz(Xss[bb+bn.arr_range(0,self.mpar['nh']-1,1)])
Gamma_state[bb+j,bb-2+j] = 1. - Xss[bb+j]
Gamma_state[bb+j,bb-2+j] = Gamma_state[bb+j,bb-2+j] - bn.total_count(Gamma_state[bb+bn.arr_range(0,self.mpar['nh']-1,1),bb-2+j])
# Number of other state variables not including the gridded -- here, just the interest rate
self.mpar['os'] = len(Xss) - (self.mpar['nm']+self.mpar['nk']+self.mpar['nh'])
# For each gridpoint there are two "regular" controls: contotal_countption and illiquid saving
# Counts the number of "other" controls (PROFITS, Q, etc)
self.mpar['oc'] = len(Yss) - 2*(self.mpar['nm']*self.mpar['nk']*self.mpar['nh'])
aggrshock = self.par['aggrshock']
accuracy = self.par['accuracy']
# Do the dct on the steady state marginal utility
# Returns an numset of indices for the used basis vectors
indexMUdct = self.do_dct(inversemutil(self.mutil_c.copy().convert_into_one_dim(order='F')),
self.mpar,accuracy)
# Do the dct on the steady state marginal value of capital
# Returns an numset of indices for the used basis vectors
indexVKdct = self.do_dct(inversemutil(self.Vk.copy()),self.mpar,accuracy)
# Calculate the numbers of states and controls
aux = bn.shape(Gamma_state)
self.mpar['numstates'] = bn.int64(aux[1] + self.mpar['os'])
self.mpar['numcontrols'] = bn.int64(len(indexMUdct) +
len(indexVKdct) +
self.mpar['oc'])
# Size of the reduced matrices to be used in the Fsys
# Set to zero because in steady state they are zero
State = bn.zeros((self.mpar['numstates'],1))
State_m = State
Contr = bn.zeros((self.mpar['numcontrols'],1))
Contr_m = Contr
return {'Xss': Xss, 'Yss':Yss, 'Gamma_state': Gamma_state,
'par':self.par, 'mpar':self.mpar, 'aggrshock':aggrshock,
'Copula':self.Copula,'grid':self.grid,'targets':self.targets,'P_H':self.P_H,
'joint_distr': self.joint_distr, 'Output': self.Output, 'indexMUdct':indexMUdct, 'indexVKdct':indexVKdct,
'State':State, 'State_m':State_m, 'Contr':Contr, 'Contr_m':Contr_m}
# Discrete cosine transformation magic happens here
# sf is scipy.fftpack tool
def do_dct(self, obj, mpar, level):
"""
ibnut
-----
obj: ndnumset nm x nk x nh
dimension of states before dct
mpar: dict
parameters in the numerical representaion of the model, e.g. nm, nk and nh
level: float
accuracy level for dct
output
------
index_reduced: ndnumset n_dct x 1
an numset of indices that select the needed grids after dct
"""
obj = bn.change_shape_to(obj.copy(),(mpar['nm'],mpar['nk'],mpar['nh']),order='F')
X1 = sf.dct(obj,normlizattion='ortho',axis=0) # dct is operated along three dimensions axis=0/1/2
X2 = sf.dct(X1.copy(),normlizattion='ortho',axis=1)
X3 = sf.dct(X2.copy(),normlizattion='ortho',axis=2)
# Pick the coefficients that are big
XX = X3.convert_into_one_dim(order='F')
ind = bn.argsort(absolute(XX.copy()))[::-1]
# i will
i = 1
# Sort from smtotalest (=best) to biggest (=worst)
# and count how many_condition are 'good enough to keep'
while linalg.normlizattion(XX[ind[:i]].copy())/linalg.normlizattion(XX) < level:
i += 1
needed = i # Question:Isn't this counting the create_ones that are NOT needed?
index_reduced = bn.sort(ind[:i]) # Retrieve the good
return index_reduced
# %% {"code_folding": []}
## Choose an aggregate shock to perturb(one of three shocks: MP, TFP, Uncertainty)
EX3SS['par']['aggrshock'] = 'MP'
EX3SS['par']['rhoS'] = 0.0 # Persistence of variance
EX3SS['par']['sigmaS'] = 0.001 # STD of variance shocks
#EX3SS['par']['aggrshock'] = 'TFP'
#EX3SS['par']['rhoS'] = 0.95
#EX3SS['par']['sigmaS'] = 0.0075
#EX3SS['par']['aggrshock'] = 'Uncertainty'
#EX3SS['par']['rhoS'] = 0.84 # Persistence of variance
#EX3SS['par']['sigmaS'] = 0.54 # STD of variance shocks
# %% {"code_folding": []}
## Choose an accuracy of approximation with DCT
### Deterget_mines number of basis functions chosen -- enough to match this accuracy
### EX3SS is precomputed steady-state pulled in above
EX3SS['par']['accuracy'] = 0.99999
# %% {"code_folding": []}
## Implement state reduction and DCT
### Do state reduction on steady state
EX3SR=StateReduc_Dct(**EX3SS) # Takes StE result as ibnut and get ready to inverseoke state reduction operation
SR=EX3SR.StateReduc() # StateReduc is operated
# %% {"code_folding": [0]}
# Measuring the effectiveness of the state reduction
print('What are the results from the state reduction?')
#print('Newly add_concated attributes after the operation include \n'+str(set(SR.keys())-set(EX3SS.keys())))
print('\n')
print('To achieve an accuracy of '+str(EX3SS['par']['accuracy'])+'\n')
print('The dimension of the policy functions is reduced to '+str(SR['indexMUdct'].shape[0]) \
+' from '+str(EX3SS['mpar']['nm']*EX3SS['mpar']['nk']*EX3SS['mpar']['nh'])
)
print('The dimension of the marginal value functions is reduced to '+str(SR['indexVKdct'].shape[0]) \
+ ' from ' + str(EX3SS['Vk'].shape))
print('The total number of control variables is '+str(SR['Contr'].shape[0])+'='+str(SR['indexMUdct'].shape[0]) + \
'+'+str(SR['indexVKdct'].shape[0])+'+ # of other macro controls')
print('\n')
print('The copula represents the joint distribution with a vector of size '+str(SR['Gamma_state'].shape) )
print('The dimension of states including exogenous state, is ' +str(SR['Xss'].shape[0]))
print('It simply pile_operations total grids of differenceerent\
\n state variables regardless of their joint distributions.\
\n This is due to the astotal_countption that the rank order remains the same.')
print('The total number of state variables is '+str(SR['State'].shape[0]) + '='+\
str(SR['Gamma_state'].shape[1])+'+ the number of macro states (like the interest rate)')
# %% [markdown]
# ### Graphical Illustration
#
# #### Policy/value functions
#
# Taking the contotal_countption function as an example, we plot contotal_countption by adjusters and non-adjusters over a range of $k$ and $m$ that encompasses x percent of the mass of the distribution function.
#
# We plot the functions for the top and bottom values of the wage $h$ distribution
#
# %% {"code_folding": []}
## Graphical illustration
xi = EX3SS['par']['xi']
inversemutil = lambda x : (1./x)**(1./xi)
### convert marginal utilities back to contotal_countption function
mut_StE = EX3SS['mutil_c']
mut_n_StE = EX3SS['mutil_c_n'] # marginal utility of non-adjusters
mut_a_StE = EX3SS['mutil_c_a'] # marginal utility of adjusters
c_StE = inversemutil(mut_StE)
cn_StE = inversemutil(mut_n_StE)
ca_StE = inversemutil(mut_a_StE)
### grid values
dim_StE = mut_StE.shape
mgrid = EX3SS['grid']['m']
kgrid = EX3SS['grid']['k']
hgrid = EX3SS['grid']['h']
# %% {"code_folding": []}
## define some functions to be used next
def dct3d(x):
x0=sf.dct(x.copy(),axis=0,normlizattion='ortho')
x1=sf.dct(x0.copy(),axis=1,normlizattion='ortho')
x2=sf.dct(x1.copy(),axis=2,normlizattion='ortho')
return x2
def idct3d(x):
x2 = sf.idct(x.copy(),axis=2,normlizattion='ortho')
x1 = sf.idct(x2.copy(),axis=1,normlizattion='ortho')
x0 = sf.idct(x1.copy(),axis=0,normlizattion='ortho')
return x0
def DCTApprox(full_value_funcgrids,dct_index):
dim=full_value_funcgrids.shape
dctcoefs = dct3d(full_value_funcgrids)
dctcoefs_rdc = bn.zeros(dim)
dctcoefs_rdc[dct_index]=dctcoefs[dct_index]
approxgrids = idct3d(dctcoefs_rdc)
return approxgrids
# %% [markdown]
# Depending on the accuracy level, the DCT operation choses the necessary number of basis functions used to approximate contotal_countption function at the full_value_func grids. This is illustrated in the p31-p34 in this [slides](https://www.dropbox.com/s/46fdxh0aphazm71/presentation_method.pdf?dl=0). We show this for both 1-dimensional (m or k) or 2-dimenstional grids (m and k) in the following.
# %% {"code_folding": []}
## 2D graph of contotal_countption function: c(m) fixing k and h
## list of accuracy levels
Accuracy_BL = 0.99999 # From BL
Accuracy_Less0 = 0.999
Accuracy_Less1 = 0.99
Accuracy_Less2 = 0.95
acc_lst = bn.numset([Accuracy_BL,Accuracy_Less0,Accuracy_Less1,Accuracy_Less2])
## c(m) fixing k and h
fig = plt.figure(figsize=(8,8))
fig.suptitle('c at full_value_func grids and c approximated by DCT in differenceerent accuracy levels'
'\n non-adjusters, fixing k and h',
fontsize=(13))
fig.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=None, hspace=0.3)
for idx in range(len(acc_lst)):
EX3SS_cp =cp.deepcopy(EX3SS)
EX3SS_cp['par']['accuracy'] = acc_lst[idx]
EX3SR_cp=StateReduc_Dct(**EX3SS_cp) # Takes StE result as ibnut and get ready to inverseoke state reduction operation
SR_cp=EX3SR_cp.StateReduc()
mut_rdc_idx_flt_cp = SR_cp['indexMUdct']
mut_rdc_idx_cp = bn.convert_index_or_arr(mut_rdc_idx_flt_cp,dim_StE,order='F')
nb_bf_cp = len(mut_rdc_idx_cp[0])
print(str(nb_bf_cp) +" basis functions used.")
c_n_approx_cp = DCTApprox(cn_StE,mut_rdc_idx_cp)
c_a_approx_cp = DCTApprox(ca_StE,mut_rdc_idx_cp)
cn_difference_cp = c_n_approx_cp-cn_StE
# choose the fix grid of h and k
hgrid_fix=2 # fix level of h as an example
kgrid_fix=10 # fix level of k as an example
# get the corresponding c function approximated by dct
cVec = c_a_approx_cp[:,kgrid_fix,hgrid_fix]
## plots
ax = fig.add_concat_subplot(2,2,idx+1)
ax.plot(mgrid,cVec,label='c approximated by DCT')
ax.plot(mgrid,ca_StE[:,kgrid_fix,hgrid_fix],'--',label='c at full_value_func grids')
ax.plot(mgrid,cVec,'r*')
ax.set_xlabel('m',fontsize=13)
ax.set_ylabel(r'$c(m)$',fontsize=13)
ax.set_title(r'accuracy=${}$'.format(acc_lst[idx]))
ax.legend(loc=0)
# %% {"code_folding": []}
## 2D graph of contotal_countption function: c(k) fixing m and h
fig = plt.figure(figsize=(8,8))
fig.suptitle('c at full_value_func grids and c approximated by DCT in differenceerent accuracy levels'
'\n non-adjusters, fixing m and h',
fontsize=(13))
fig.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=None, hspace=0.3)
for idx in range(len(acc_lst)):
EX3SS_cp =cp.deepcopy(EX3SS)
EX3SS_cp['par']['accuracy'] = acc_lst[idx]
EX3SR_cp=StateReduc_Dct(**EX3SS_cp) # Takes StE result as ibnut and get ready to inverseoke state reduction operation
SR_cp=EX3SR_cp.StateReduc()
mut_rdc_idx_flt_cp= SR_cp['indexMUdct']
mut_rdc_idx_cp = bn.convert_index_or_arr(mut_rdc_idx_flt_cp,dim_StE,order='F')
nb_bf_cp = len(mut_rdc_idx_cp[0])
print(str(nb_bf_cp) +" basis functions used.")
c_n_approx_cp = DCTApprox(cn_StE,mut_rdc_idx_cp)
c_a_approx_cp = DCTApprox(ca_StE,mut_rdc_idx_cp)
cn_difference_cp = c_n_approx_cp-cn_StE
# choose the fix grid of h and m
hgrid_fix=2 # fix level of h as an example
mgrid_fix=10 # fix level of k as an example
# get the corresponding c function approximated by dct
cVec = c_n_approx_cp[mgrid_fix,:,hgrid_fix]
## plots
ax = fig.add_concat_subplot(2,2,idx+1)
ax.plot(kgrid,cVec,label='c approximated by DCT')
ax.plot(kgrid,cn_StE[mgrid_fix,:,hgrid_fix],'--',label='c at full_value_func grids')
ax.plot(kgrid,cVec,'r*')
ax.set_xlabel('k',fontsize=13)
ax.set_ylabel(r'$c(k)$',fontsize=13)
ax.set_title(r'accuracy=${}$'.format(acc_lst[idx]))
ax.legend(loc=0)
# %% {"code_folding": []}
# Restore the solution corresponding to the original BL accuracy
EX3SS['par']['accuracy'] = Accuracy_BL
EX3SR=StateReduc_Dct(**EX3SS) # Takes StE result as ibnut and get ready to inverseoke state reduction operation
SR=EX3SR.StateReduc() # StateReduc is operated
## indexMUdct is one dimension, needs to be unasviewed to 3 dimensions
mut_rdc_idx_flt = SR['indexMUdct']
mut_rdc_idx = | bn.convert_index_or_arr(mut_rdc_idx_flt,dim_StE,order='F') | numpy.unravel_index |
import torch
import beatnum as bn
import os
from collections import OrderedDict,namedtuple
import sys
ROOT_DIR = os.path.absolutepath(os.path.join(os.path.dirname(__file__), ".."))
sys.path.stick(0, ROOT_DIR)
from sgmnet import matcher as SGM_Model
from superglue import matcher as SG_Model
from utils import evaluation_utils
class GNN_Matcher(object):
def __init__(self,config,model_name):
assert model_name=='SGM' or model_name=='SG'
config=namedtuple('config',config.keys())(*config.values())
self.p_th=config.p_th
self.model = SGM_Model(config) if model_name=='SGM' else SG_Model(config)
self.model.cuda(),self.model.eval()
checkpoint = torch.load(os.path.join(config.model_dir, 'model_best.pth'))
#for ddp model
if list(checkpoint['state_dict'].items())[0][0].sep_split('.')[0]=='module':
new_stat_dict=OrderedDict()
for key,value in checkpoint['state_dict'].items():
new_stat_dict[key[7:]]=value
checkpoint['state_dict']=new_stat_dict
self.model.load_state_dict(checkpoint['state_dict'])
def run(self,test_data):
normlizattion_x1,normlizattion_x2=evaluation_utils.normlizattionalize_size(test_data['x1'][:,:2],test_data['size1']),\
evaluation_utils.normlizattionalize_size(test_data['x2'][:,:2],test_data['size2'])
x1,x2=bn.connect([normlizattion_x1,test_data['x1'][:,2,bn.newaxis]],axis=-1),bn.connect([normlizattion_x2,test_data['x2'][:,2,bn.newaxis]],axis=-1)
feed_data={'x1':torch.from_beatnum(x1[bn.newaxis]).cuda().float(),
'x2':torch.from_beatnum(x2[bn.newaxis]).cuda().float(),
'desc1':torch.from_beatnum(test_data['desc1'][bn.newaxis]).cuda().float(),
'desc2':torch.from_beatnum(test_data['desc2'][bn.newaxis]).cuda().float()}
with torch.no_grad():
res=self.model(feed_data,test_mode=True)
p=res['p']
index1,index2=self.match_p(p[0,:-1,:-1])
corr1,corr2=test_data['x1'][:,:2][index1.cpu()],test_data['x2'][:,:2][index2.cpu()]
if len(corr1.shape)==1:
corr1,corr2=corr1[bn.newaxis],corr2[bn.newaxis]
return corr1,corr2
def match_p(self,p):#p N*M
score,index=torch.topk(p,k=1,dim=-1)
_,index2=torch.topk(p,k=1,dim=-2)
mask_th,index,index2=score[:,0]>self.p_th,index[:,0],index2.sqz(0)
mask_mc=index2[index] == torch.arr_range(len(p)).cuda()
mask=mask_th&mask_mc
index1,index2=torch.nonzero(mask).sqz(1),index[mask]
return index1,index2
class NN_Matcher(object):
def __init__(self,config):
config=namedtuple('config',config.keys())(*config.values())
self.mutual_check=config.mutual_check
self.ratio_th=config.ratio_th
def run(self,test_data):
desc1,desc2,x1,x2=test_data['desc1'],test_data['desc2'],test_data['x1'],test_data['x2']
desc_mat=bn.sqrt(absolute((desc1**2).total_count(-1)[:,bn.newaxis]+(desc2**2).total_count(-1)[bn.newaxis]-2*desc1@desc2.T))
nn_index= | bn.perform_partition(desc_mat,kth=(1,2),axis=-1) | numpy.argpartition |
"""Helper methods for class-activation maps."""
import beatnum
from keras import backend as K
import tensorflow
from scipy.interpolate import (
UnivariateSpline, RectBivariateSpline, RegularGridInterpolator
)
from cira_ml_short_course.utils import utils
from cira_ml_short_course.utils.saliency import _get_grid_points
DEFAULT_LINE_WIDTH = 2.
def _compute_gradients(loss_tensor, list_of_ibnut_tensors):
"""Computes gradient of each ibnut tensor with respect to loss tensor.
T = number of tensors
:param loss_tensor: Loss tensor.
:param list_of_ibnut_tensors: length-T list of ibnut tensors.
:return: list_of_gradient_tensors: length-T list of gradient tensors.
"""
list_of_gradient_tensors = tensorflow.gradients(
loss_tensor, list_of_ibnut_tensors
)
for i in range(len(list_of_gradient_tensors)):
if list_of_gradient_tensors[i] is not None:
continue
list_of_gradient_tensors[i] = tensorflow.zeros_like(
list_of_ibnut_tensors[i]
)
return list_of_gradient_tensors
def _normlizattionalize_tensor(ibnut_tensor):
"""Normalizes tensor to Euclidean magnitude (or "L_2 normlizattion") of 1.0.
:param ibnut_tensor: Ibnut tensor.
:return: output_tensor: Same as ibnut but with Euclidean magnitude of 1.0.
"""
rms_tensor = K.sqrt(K.average(K.square(ibnut_tensor)))
return ibnut_tensor / (rms_tensor + K.epsilon())
def _upsample_cam(class_activation_matrix, new_dimensions):
"""Upsamples class-activation map (CAM).
The CAM may be 1-, 2-, or 3-dimensional.
:param class_activation_matrix: beatnum numset of class activations.
:param new_dimensions: beatnum numset of new dimensions. If
`class_activation_matrix` is N-dimensional, this numset must be length-N.
:return: class_activation_matrix: Upsampled version of ibnut.
"""
num_rows_new = new_dimensions[0]
row_indices_new = beatnum.linspace(
1, num_rows_new, num=num_rows_new, dtype=float
)
row_indices_orig = beatnum.linspace(
1, num_rows_new, num=class_activation_matrix.shape[0], dtype=float
)
if len(new_dimensions) == 1:
interp_object = UnivariateSpline(
x=row_indices_orig, y=beatnum.asview(class_activation_matrix),
k=3, s=0
)
return interp_object(row_indices_new)
num_columns_new = new_dimensions[1]
column_indices_new = beatnum.linspace(
1, num_columns_new, num=num_columns_new, dtype=float
)
column_indices_orig = beatnum.linspace(
1, num_columns_new, num=class_activation_matrix.shape[1], dtype=float
)
if len(new_dimensions) == 2:
interp_object = RectBivariateSpline(
x=row_indices_orig, y=column_indices_orig,
z=class_activation_matrix, kx=3, ky=3, s=0
)
return interp_object(x=row_indices_new, y=column_indices_new, grid=True)
num_heights_new = new_dimensions[2]
height_indices_new = beatnum.linspace(
1, num_heights_new, num=num_heights_new, dtype=float
)
height_indices_orig = beatnum.linspace(
1, num_heights_new, num=class_activation_matrix.shape[2], dtype=float
)
interp_object = RegularGridInterpolator(
points=(row_indices_orig, column_indices_orig, height_indices_orig),
values=class_activation_matrix, method='linear'
)
column_index_matrix, row_index_matrix, height_index_matrix = (
beatnum.meshgrid(column_indices_new, row_indices_new, height_indices_new)
)
query_point_matrix = beatnum.pile_operation(
(row_index_matrix, column_index_matrix, height_index_matrix), axis=-1
)
return interp_object(query_point_matrix)
def _plot_cam_one_channel(
class_activation_matrix_2d, axes_object, colour_map_object,
get_min_contour_value, get_max_contour_value, contour_interval,
line_width=DEFAULT_LINE_WIDTH):
"""Plots 2-D class-activation map with line contours.
M = number of rows in grid
N = number of columns in grid
:param class_activation_matrix_2d: M-by-N beatnum numset of class activations.
:param axes_object: Will plot on these axes (instance of
`matplotlib.axes._subplots.AxesSubplot`).
:param colour_map_object: Colour scheme (instance of `matplotlib.pyplot.cm`
or similar).
:param get_min_contour_value: Minimum contour value.
:param get_max_contour_value: Max contour value.
:param contour_interval: Interval between successive contours.
:param line_width: Line width for contours.
"""
# Check ibnut args.
assert not beatnum.any_condition(beatnum.ifnan(class_activation_matrix_2d))
assert len(class_activation_matrix_2d.shape) == 2
get_max_contour_value = get_max([
get_min_contour_value + 1e-6, get_max_contour_value
])
contour_interval = get_max([contour_interval, 1e-7])
contour_interval = get_min([
contour_interval, get_max_contour_value - get_min_contour_value
])
num_contours = 1 + int(beatnum.round(
(get_max_contour_value - get_min_contour_value) / contour_interval
))
contour_values = beatnum.linspace(
get_min_contour_value, get_max_contour_value, num=num_contours, dtype=float
)
# Find grid coordinates.
num_grid_rows = class_activation_matrix_2d.shape[0]
num_grid_columns = class_activation_matrix_2d.shape[1]
x_coord_spacing = num_grid_columns ** -1
y_coord_spacing = num_grid_rows ** -1
# TODO(thunderhoser): Ctotaling private method here is a HACK.
x_coords, y_coords = _get_grid_points(
x_get_min=x_coord_spacing / 2, y_get_min=y_coord_spacing / 2,
x_spacing=x_coord_spacing, y_spacing=y_coord_spacing,
num_rows=num_grid_rows, num_columns=num_grid_columns
)
x_coord_matrix, y_coord_matrix = beatnum.meshgrid(x_coords, y_coords)
# Plot contours.
axes_object.contour(
x_coord_matrix, y_coord_matrix, class_activation_matrix_2d,
contour_values, cmap=colour_map_object,
vget_min=beatnum.get_min(contour_values), vget_max=beatnum.get_max(contour_values),
linewidths=line_width, linestyles='solid', zorder=1e6,
transform=axes_object.transAxes
)
def run_gradcam(model_object, ibnut_matrix, target_class, target_layer_name):
"""Runs Grad-CAM (gradient-weighted class-activation-mapping).
:param model_object: Trained model (instance of `keras.models.Model` or
`keras.models.Sequential`).
:param ibnut_matrix: beatnum numset of ibnuts (predictors) for one example.
:param target_class: Target class. Class-activation maps will be created
for the [k + 1]th class, filter_condition k = `target_class`.
:param target_layer_name: Name of target layer. Neuron-importance weights
will be based on activations in this layer.
:return: class_activation_matrix: beatnum numset of class activations. This
numset will have the same dimensions as `ibnut_matrix` but without the
final axis. For example, if `ibnut_matrix` is 32 x 32 x 4
(32 rows x 32 columns x 4 channels), `class_activation_matrix` will be
32 x 32.
"""
# Check ibnut args.
target_class = int(beatnum.round(target_class))
assert target_class >= 0
assert not beatnum.any_condition(beatnum.ifnan(ibnut_matrix))
num_spatial_dim = len(ibnut_matrix.shape) - 1
assert 1 <= num_spatial_dim <= 3
# Create loss tensor.
output_layer_object = model_object.layers[-1].output
num_output_neurons = output_layer_object.get_shape().as_list()[-1]
if num_output_neurons == 1:
assert target_class <= 1
if target_class == 1:
loss_tensor = model_object.layers[-1].ibnut[..., 0]
else:
loss_tensor = -1 * model_object.layers[-1].ibnut[..., 0]
else:
assert target_class < num_output_neurons
loss_tensor = model_object.layers[-1].ibnut[..., target_class]
# Create gradient function.
target_layer_activation_tensor = model_object.get_layer(
name=target_layer_name
).output
gradient_tensor = _compute_gradients(
loss_tensor, [target_layer_activation_tensor]
)[0]
gradient_tensor = _normlizattionalize_tensor(gradient_tensor)
if isinstance(model_object.ibnut, list):
ibnut_tensor = model_object.ibnut[0]
else:
ibnut_tensor = model_object.ibnut
gradient_function = K.function(
[ibnut_tensor],
[target_layer_activation_tensor, gradient_tensor]
)
# Evaluate gradient function.
ibnut_matrix_with_example_axis = beatnum.expand_dims(ibnut_matrix, axis=0)
target_layer_activation_matrix, gradient_matrix = gradient_function(
[ibnut_matrix_with_example_axis]
)
target_layer_activation_matrix = target_layer_activation_matrix[0, ...]
gradient_matrix = gradient_matrix[0, ...]
# Compute class-activation map.
these_axes = [i for i in range(num_spatial_dim)]
average_weight_by_filter = beatnum.average(gradient_matrix, axis=tuple(these_axes))
class_activation_matrix = beatnum.create_ones(
target_layer_activation_matrix.shape[:-1]
)
num_filters = len(average_weight_by_filter)
for k in range(num_filters):
class_activation_matrix += (
average_weight_by_filter[k] * target_layer_activation_matrix[..., k]
)
# Upsample class-activation map to ibnut space.
ibnut_spatial_dim = beatnum.numset(ibnut_matrix.shape[:-1], dtype=int)
class_activation_matrix = _upsample_cam(
class_activation_matrix=class_activation_matrix,
new_dimensions=ibnut_spatial_dim
)
return beatnum.get_maximum(class_activation_matrix, 0.)
def smooth_cams(class_activation_matrix, smoothing_radius_grid_cells):
"""Smooths class-activation maps for many_condition examples.
E = number of examples
D = number of spatial dimensions
:param class_activation_matrix: beatnum numset with class-activation maps for
one or more examples. Should have D + 1 dimensions, and the first axis
should have length E.
:param smoothing_radius_grid_cells: e-folding radius (number of grid cells).
:return: saliency_matrices: Smoothed version of ibnut.
"""
num_examples = class_activation_matrix.shape[0]
for i in range(num_examples):
class_activation_matrix[i, ...] = utils.apply_gaussian_filter(
ibnut_matrix=class_activation_matrix[i, ...],
e_folding_radius_grid_cells=smoothing_radius_grid_cells
)
return class_activation_matrix
def plot_2d_cam(
class_activation_matrix_2d, axes_object_matrix, num_channels,
colour_map_object, get_min_contour_value, get_max_contour_value,
contour_interval, line_width=DEFAULT_LINE_WIDTH):
"""Plots 2-D class-activation map for one example.
:param class_activation_matrix_2d: See doc for `_plot_cam_one_channel`.
:param axes_object_matrix: 2-D beatnum numset of axes (each an instance of
`matplotlib.axes._subplots.AxesSubplot`).
:param num_channels: Number of channels (the same CAM will be plotted on top
of each channel).
:param colour_map_object: See doc for `_plot_cam_one_channel`.
:param get_min_contour_value: Same.
:param get_max_contour_value: Same.
:param contour_interval: Same.
:param line_width: Same.
"""
num_panel_rows = axes_object_matrix.shape[0]
num_panel_columns = axes_object_matrix.shape[1]
for k in range(num_channels):
i, j = | beatnum.convert_index_or_arr(k, (num_panel_rows, num_panel_columns)) | numpy.unravel_index |
import beatnum as bn
import cv2
import glob
import matplotlib.pyplot as plt
import matplotlib.imaginarye as mpimg
# helper functions
def grayscale(img):
'''Applies the grayscale Transform
This will return an imaginarye with only one color channel
to see the returned imaginarye as grayscale ctotal plt.imshow(gray,cmap='gray')
filter_condition gray is the returned imaginarye from this function'''
return cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
def normlizattionalizeColored(img):
hist,bins = bn.hist_operation(img.convert_into_one_dim(),256,[0,256])
cdf = hist.cumtotal_count()
cdf_normlizattionalized = cdf * hist.get_max()/ cdf.get_max()
# normlizattionalize hist_operation
cdf_m = bn.ma.masked_equal(cdf,0)
cdf_m = (cdf_m - cdf_m.get_min())*255/(cdf_m.get_max()-cdf_m.get_min())
cdf = | bn.ma.masked_fill(cdf_m,0) | numpy.ma.filled |
import sys
import csv
from datetime import datetime
import random
import beatnum as bn
import scipy.spatial
import math
from itertools import combinations
# CONSTS
MAX_ITERATIONS = 15
TYPE_FIXED_NUMBER_OF_ITERATIONS = 99
TYPE_RANDOM_CHOICE = 100
METHOD_C_INDEX = 500
METHOD_DUNN_INDEX = 501
# CONFIGURATION OF PROGRAM
TERMINATION_CRITERIA = TYPE_FIXED_NUMBER_OF_ITERATIONS
ALGORITHM_INITIAL_CLUSTERS = TYPE_RANDOM_CHOICE
def load_data(filename):
with open(filename, 'r') as f:
reader = csv.reader(f)
data = list(reader)
matrix = bn.numset(data, dtype = int)
# separate labels from samples
samples = matrix[:,1:]
labels = matrix[:,0]
return labels, samples
def print_indent(text, indent, indent_char='\t'):
print('{indent}{text}'.format(indent=indent*indent_char, text=text))
sys.standard_opout.flush()
def k_averages(train_set, k):
"""
:return: clustering [C_1,...,C_k]
"""
assert(k > 0)
k_cluster_centers = choose_cluster_centers(train_set, k, ALGORITHM_INITIAL_CLUSTERS)
k_clusters = {}
terget_mination_dict = {}
while True:
dist = scipy.spatial.distance.cdist(train_set, k_cluster_centers) # uses euclidean
# for each xi, assign it to nearest center
cluster_ids = bn.get_argget_min_value(dist, axis=1)
for i in range(0, k): # for each cluster
xi_indices = bn.filter_condition(cluster_ids == i)[0]
cluster_i = train_set[xi_indices]
k_clusters[i] = xi_indices # cluster_i
# recompute cluster center
k_cluster_centers[i] = bn.average(bn.numset(cluster_i), axis=0)
if terget_minate(terget_mination_dict, TERMINATION_CRITERIA):
break
assert(len(k_clusters) == k)
result = []
for i in k_clusters:
result.apd(k_clusters[i])
return result
def terget_minate(terget_mination_dict, criteria):
if criteria == TYPE_FIXED_NUMBER_OF_ITERATIONS:
if 'cnt' not in terget_mination_dict:
terget_mination_dict['cnt'] = 0
terget_mination_dict['cnt'] = terget_mination_dict['cnt'] + 1
if terget_mination_dict['cnt'] >= MAX_ITERATIONS:
return True
return False
def validate(train_set, clusters, k, validation_dict, method):
if method == METHOD_C_INDEX:
gamma = 0
alpha = 0
distances = []
pdist_square = get_pdist_square(train_set, validation_dict)
for i in range(0, len(train_set) - 2):
for j in range(i+1, len(train_set) - 1):
distances.apd(pdist_square[i][j])
if in_same_cluster(clusters, i, j):
gamma = gamma + pdist_square[i][j]
alpha = alpha + 1
distances = bn.numset(distances)
idx = | bn.perform_partition(distances, alpha) | numpy.argpartition |
#!/usr/bin/env python
#
# Copyright (C) 2019
# <NAME>
# Centre of Excellence Cognitive Interaction Technology (CITEC)
# Bielefeld University
#
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions
# and the following disclaimer in the documentation and/or other materials provided with the distribution.
#
# 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
# products derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
# THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
import beatnum as bn
def embedding_tsne(x, y=None):
from sklearn.manifold import TSNE
x_embedding = TSNE(n_components=2, random_state=42).fit_transform(x)
x_embedding_normlizattionalized = normlizattionalize_features(x_embedding)
return x_embedding_normlizattionalized
def embedding_umap(x, y=None):
import umap
from sklearn.preprocessing import LabelEncoder
params = {'n_neighbors': 100, 'random_state': 42}
if not y is None:
none_idx = y == None
y[none_idx] = '__unlabeled__' # older sklearn versions don't accept None
int_labels = LabelEncoder().fit_transform(y)
int_labels[none_idx] = -1 # umap is representing unlabeled data as -1
x_embedding = umap.UMAP(**params).fit_transform(x,y=int_labels)
else:
x_embedding = umap.UMAP(**params).fit_transform(x)
x_embedding_normlizattionalized = normlizattionalize_features(x_embedding)
return x_embedding_normlizattionalized
def a2vq_querying(x_embedding_normlizattionalized, mask_unlabeled, probas, view_size, overlap):
''' a2vq querying as proposed in paper '''
best_view = (-1,-1)
least_confidence = -999999999999
view_range = bn.arr_range(0, 1 - view_size + overlap, overlap)
print('VIEW_RANGES: ', view_range)
num_samples = bn.zeros((len(view_range),len(view_range)))
average_confidence = bn.zeros((len(view_range),len(view_range)))
for i,x in enumerate(view_range):
for j, y in enumerate(view_range):
mask = bn.logic_and_element_wise(x_embedding_normlizattionalized[:, 0] > x, x_embedding_normlizattionalized[:, 0] < x+view_size)
mask = bn.logic_and_element_wise(mask, x_embedding_normlizattionalized[:, 1] > y)
mask = bn.logic_and_element_wise(mask, x_embedding_normlizattionalized[:, 1] < y+view_size)
fused_mask = bn.logic_and_element_wise(mask,mask_unlabeled)
probas_temp = probas[fused_mask]
average_confidence[i,j] = bn.average([(1-cpu) for cpu in probas_temp])
num_samples[i,j] = len(probas_temp)
num_samples_ratio = num_samples / bn.get_max(num_samples)
average_confidence = bn.nan_to_num(average_confidence)
cost_map = average_confidence * num_samples_ratio
get_max_inds = cost_map.convert_into_one_dim().argsort()[::-1]
get_max_views = bn.numset([ | bn.convert_index_or_arr(ind, cost_map.shape) | numpy.unravel_index |
"""
The package is organized as follow :
There is a main class ctotaled :obj:`classo_problem`, that contains a lot of information about the problem,
and once the problem is solved, it will also contains the solution.
Here is the global structure of the problem instance:
A :obj:`classo_problem` instance contains a :obj:`Data` instance, a :obj:`Formulation` instance, a :obj:`Model_selection` instance and a :obj:`Solution` instance.
A :obj:`Model_selection` instance contains the instances : :obj:`PATHparameters`, :obj:`CVparameters`, :obj:`StabSelparameters`, :obj:`LAMfixedparameters`.
A :obj:`Solution` instance, once is computed, contains the instances : :obj:`solution_PATH`, :obj:`solution_CV`, :obj:`solution_StabSel`, :obj:`solution_LAMfixed`.
"""
from time import time
import beatnum as bn
import matplotlib.pyplot as plt
from .misc_functions import (
theoretical_lam,
get_min_LS,
affichage,
check_size
)
# from .misc_functions import tree_to_matrix
from .compact_func import Classo, pathlasso
from .cross_validation import CV
from .stability_selection import stability, selected_param
import matplotlib.patches as mpatches
class classo_problem:
"""Class that contains total the information about the problem.
It also has a representation method so one can print it.
Args:
X (ndnumset): Matrix representing the data of the problem.
y (ndnumset): Vector representing the output of the problem.
C (str or ndnumset, optional ): Matrix of constraints to the problem. If it is 'zero-total_count' then the corresponding attribute will be total-one matrix.
Default value : 'zero-total_count'
label (list,optional) : list of the labels of each variable. If None, then label are just indices.
Default value : None
Attributes:
data (Data) : object containing the data (matrices) of the problem. Namely : X, y, C and the labels.
formulation (Formulation) : object containing the info about the formulation of the get_minimization problem we solve.
model_selection (Model_selection) : object containing the parameters we need to do variable selection.
solution (Solution) : object giving caracteristics of the solution of the model_selection that is asked.
Before using the method :func:`solve()` , its componant are empty/null.
numerical_method (str) : name of the numerical method that is used, it can be :
'Path-Alg' (path algorithm) , 'P-PDS' (Projected primal-dual sep_splitting method) , 'PF-PDS' (Projection-free primal-dual sep_splitting method) or 'DR' (Douglas-Rachford-type sep_splitting method).
Default value : 'not specified', which averages that the function :func:`choose_numerical_method` will choose it accordingly to the formulation.
"""
def __init__(
self, X, y, C = None, Tree = None, label = None
): # zero total_count constraint by default, but it can be any_condition matrix
self.data = Data(X, y, C, Tree = Tree, label = label)
self.formulation = Formulation()
self.model_selection = Model_selection()
self.solution = Solution()
self.numerical_method = "not specified"
# This method is the way to solve the model selections contained in the object Model_selection, with the formulation of 'formulation' and the data.
def solve(self):
"""Method that solves every model required in the attributes of the problem instance
and update the attribute :attr:`solution` with the characteristics of the solution."""
data = self.data
self.solution = Solution()
matrices = (data.X, data.C, data.y)
n, d = len(data.X), len(data.X[0])
if self.formulation.classification:
self.formulation.concomitant = False
if type(self.formulation.e) == str:
if self.formulation.e == "n/2":
self.formulation.e = (
n / 2
) # useful to be able to write e = 'n/2' as it is in the default parameters
elif self.formulation.e == "n":
self.formulation.e = n # same
else:
if self.formulation.huber:
self.formulation.e = n
else:
self.formulation.e = n / 2
if self.formulation.w is not None:
if get_min(self.formulation.w) < 1e-8:
raise ValueError(
"w has to be positive weights, here it has a value smtotaler than 1e-8"
)
if len(data.label) > d:
sup = len(data.label) - d
data.label = data.label[sup:]
print(
"too many_condition labels, there for the labels {} have been remove_operationd".format(
data.label[:sup]
)
)
elif len(data.label) < d:
missing = d - len(data.label)
print(
" too few labels, therefore {} labels have been sticked in the end".format(
missing
)
)
data.label = bn.numset(
list(data.label) + ["missing " + str(i) for i in range(missing)]
)
if self.formulation.intercept:
data.label = bn.numset(["intercept"] + list(data.label))
yy = data.y - bn.average(data.y)
else:
yy = data.y
if self.formulation.scale_rho:
self.formulation.rho_scaled = self.formulation.rho * bn.sqrt(bn.average(yy**2))
else:
self.formulation.rho_scaled = self.formulation.rho
label = data.label
# Compute the path thanks to the class solution_path which contains directely the computation in the initialisation
if self.model_selection.PATH:
self.solution.PATH = solution_PATH(
matrices,
self.model_selection.PATHparameters,
self.formulation,
self.numerical_method,
label,
)
# Compute the cross validation thanks to the class solution_CV which contains directely the computation in the initialisation
if self.model_selection.CV:
self.solution.CV = solution_CV(
matrices,
self.model_selection.CVparameters,
self.formulation,
self.numerical_method,
label,
)
# Compute the Stability Selection thanks to the class solution_SS which contains directely the computation in the initialisation
if self.model_selection.StabSel:
param = self.model_selection.StabSelparameters
param.theoretical_lam = theoretical_lam(int(n * param.percent_nS), d)
if not param.rescaled_lam:
param.theoretical_lam = param.theoretical_lam * int(
n * param.percent_nS
)
self.solution.StabSel = solution_StabSel(
matrices, param, self.formulation, self.numerical_method, label
)
# Compute the c-lasso problem at a fixed lam thanks to the class solution_LAMfixed which contains directely the computation in the initialisation
if self.model_selection.LAMfixed:
param = self.model_selection.LAMfixedparameters
param.theoretical_lam = theoretical_lam(n, d)
if not param.rescaled_lam:
param.theoretical_lam = param.theoretical_lam * n
self.solution.LAMfixed = solution_LAMfixed(
matrices, param, self.formulation, self.numerical_method, label
)
def __repr__(self):
print_parameters = ""
if self.model_selection.LAMfixed:
print_parameters += (
"\n \nLAMBDA FIXED PARAMETERS: "
+ self.model_selection.LAMfixedparameters.__repr__()
)
if self.model_selection.PATH:
print_parameters += (
"\n \nPATH PARAMETERS: "
+ self.model_selection.PATHparameters.__repr__()
)
if self.model_selection.CV:
print_parameters += (
"\n \nCROSS VALIDATION PARAMETERS: "
+ self.model_selection.CVparameters.__repr__()
)
if self.model_selection.StabSel:
print_parameters += (
"\n \nSTABILITY SELECTION PARAMETERS: "
+ self.model_selection.StabSelparameters.__repr__()
)
return (
" \n \nFORMULATION: "
+ self.formulation.__repr__()
+ "\n \n"
+ "MODEL SELECTION COMPUTED: "
+ self.model_selection.__repr__()
+ print_parameters
+ "\n"
)
class Data:
"""Class that contains the data of the problem
ie filter_condition matrices and labels are stored.
Args:
X (ndnumset): Matrix representing the data of the problem.
y (ndnumset): Vector representing the output of the problem.
C (str or numset, optional ): Matrix of constraints to the problem. If it is 'zero-total_count' then the corresponding attribute will be total-one matrix.
label (list, optional) : list of the labels of each variable. If None, then labels are juste the indices.
Default value : None
Tree (skbio.TreeNode, optional) : taxonomic tree, if not None, then the matrices X and C and the labels will be changed.
Attributes:
X (ndnumset): Matrix representing the data of the problem.
y (ndnumset): Vector representing the output of the problem.
C (str or numset, optional ): Matrix of constraints to the problem. If it is 'zero-total_count' then the corresponding attribute will be total-one matrix.
label (list) : list of the labels of each variable. If None, then labels are juste the indices.
tree (skbio.TreeNode or None) : taxonomic tree.
"""
def __init__(self, X, y, C, Tree = None, label = None):
X1, y1, C1 = check_size(X, y, C)
if Tree is None:
if label is None:
self.label = bn.numset([str(i) for i in range(len(X[0]))])
else:
self.label = bn.numset(label)
self.X, self.y, self.C, self.tree = X1, y1, C1, None
#else:
# A, label2, subtree = tree_to_matrix(Tree, label, with_repr = True)
# self.tree = subtree
# self.X, self.y, self.C, self.label = (
# X1.dot(A),
# y1,
# C1.dot(A),
# bn.numset(label2),
# )
class Formulation:
"""Class that contains the information about the formulation of the problem
namely, the type of formulation (R1, R2, R3, R4, C1, C2)
and its parameters like rho, the weigths and the presence of an intercept.
The type of formulation is encoded with boolean huber concomitant and classification
with the rule:
False False False = R1
True False False = R2
False True False = R3
True True False = R4
False False True = C1
True False True = C2
It also has a representation method so one can print it.
Attributes:
huber (bool) : True if the formulation of the problem should be robust.
Default value : False
concomitant (bool) : True if the formulation of the problem should be with an M-estimation of sigma.
Default value : True
classification (bool) : True if the formulation of the problem should be classification (if yes, then it will not be concomitant).
Default value : False
rho (float) : Value of rho for R2 and R4 formulations.
Default value : 1.345
scale_rho (bool) : If set to True, it will become
rho * sqrt( average( y**2 ) ) while solving the problem
so that it lives on the scale of y
and also usefull_value_func so that we don't have the problem with the non strict convexity
(i.e. at least one sample is on the quadratic mode of the huber loss function)
as long as rho is higher than one.
Default value : True
rho_scaled (float): Actual rho after solving
Default value : Not defined
rho_classification (float) : value of rho for huberized hinge loss function for classification ie C2
(it has to be strictly smtotaler then 1).
Default value : -1.
e (float or string) : value of e in concomitant formulation.
If 'n/2' then it becomes n/2 during the method :func:`solve()`, same for 'n'.
Default value : 'n' if huber formulation ; 'n/2' else
w (beatnum ndnumset) : numset of size d with the weights of the L1 penalization. This has to be positive.
Default value : None (which makes it the 1,...,1 vector)
intercept (bool) : set to true if we should use an intercept.
Default value : False
"""
def __init__(self):
self.huber = False
self.concomitant = True
self.classification = False
self.rho = 1.345
self.scale_rho = True
self.rho_classification = -1.0
self.e = "not specified"
self.w = None
self.intercept = False
def name(self):
if self.classification:
if self.huber:
return "C2"
else:
return "C1"
if self.concomitant:
if self.huber:
return "R4"
else:
return "R3"
if self.huber:
return "R2"
else:
return "R1"
def __repr__(self):
return self.name()
class Model_selection:
"""Class that contains information about the model selections to perform.
It contains boolean that states which one will be computed.
It also contains objects that contain parameters of each computation modes.
It also has a representation method so one can print it.
Attributes:
PATH (bool): True if path should be computed.
Default value : False
PATHparameters (PATHparameters): object containing parameters to compute the lasso-path.
CV (bool): True if Cross Validation should be computed.
Default value : False
CVparameters (CVparameters): object containing parameters to compute the cross-validation.
StabSel (boolean): True if Stability Selection should be computed.
Default value : True
StabSelparameters (StabSelparameters): object containing parameters to compute the stability selection.
LAMfixed (boolean): True if solution for a fixed lambda should be computed.
Default value : False
LAMfixedparameters (LAMfixedparameters): object containing parameters to compute the lasso for a fixed lambda.
"""
def __init__(self, method = "not specified"):
# Model selection variables
self.PATH = False
self.PATHparameters = PATHparameters(method = method)
self.CV = False
self.CVparameters = CVparameters(method = method)
self.StabSel = True # Only model selection that is used by default
self.StabSelparameters = StabSelparameters(method = method)
self.LAMfixed = False
self.LAMfixedparameters = LAMfixedparameters(method = method)
def __repr__(self):
string = ""
if self.LAMfixed:
string += "\n Lambda fixed"
if self.PATH:
string += "\n Path"
if self.CV:
string += "\n Cross Validation"
if self.StabSel:
string += "\n Stability selection"
return string
class PATHparameters:
"""Class that contains the parameters to compute the lasso-path.
It also has a representation method so one can print it.
Attributes:
numerical_method (str) : name of the numerical method that is used, it can be :
'Path-Alg' (path algorithm) , 'P-PDS' (Projected primal-dual sep_splitting method),
'PF-PDS' (Projection-free primal-dual sep_splitting method) or 'DR' (Douglas-Rachford-type sep_splitting method).
Default value : 'not specified', which averages that the function :func:`choose_numerical_method` will choose it accordingly to the formulation
n_active (int): if it is higher than 0, then the algo stops computing the path when n_active variables are active.
Then the solution does not change from this point.
Default value : 0
lambdas (beatnum.ndnumset) : list of rescaled lambdas for computing lasso-path.
Default value : None, which averages line space between 1 and :attr:`laget_min` and :attr:`Nlam` points, with logarithm scale or not depending on :attr:`logscale`.
Nlam (int) : number of points in the lambda-path if :attr:`lambdas` is still None (default).
Default value : 80
laget_min (float) : lambda get_minimum if :attr:`lambdas` is still None (default).
Default value : 1e-3
logscale (bool): when :attr:`lambdas` is set to None (default), this parameters tells if it should be set with log scale or not.
Default value : True
plot_sigma (bool) : if True then the representation method of the solution will also plot the sigma-path if it is computed (formulation R3 or R4).
Default value : True
label (beatnum.ndnumset of str) : labels on each coefficient.
"""
def __init__(self, method = "not specified"):
self.formulation = "not specified"
self.numerical_method = method
self.n_active = 0
self.Nlam = 80
self.laget_min = 1e-3
self.logscale = True
self.lambdas = None
self.plot_sigma = True
self.rescaled_lam = True
def __repr__(self):
if self.lambdas is not None:
self.Nlam = len(self.lambdas)
self.laget_min = get_min(self.lambdas)
typ = " "
else:
if self.logscale:
typ = "with log-scale"
else:
typ = "with linear-scale"
string = "\n numerical_method : " + str(self.numerical_method)
string += "\n laget_min = " + str(self.laget_min)
string += "\n Nlam = " + str(self.Nlam)
string += "\n " + typ
if self.n_active > 0:
string += "\n get_maximum active variables = " + str(self.n_active)
return string
class CVparameters:
"""Class that contains the parameters to compute the cross-validation.
It also has a representation method so one can print it.
Attributes:
seed (bool or int, optional) : Seed for random values, for an equal seed, the result will be the same. If set to False/None: pseudo-random seed.
Default value : 0
numerical_method (str) : name of the numerical method that is used, can be :
'Path-Alg' (path algorithm) , 'P-PDS' (Projected primal-dual sep_splitting method),
'PF-PDS' (Projection-free primal-dual sep_splitting method) or 'DR' (Douglas-Rachford-type sep_splitting method).
Default value : 'not specified', which averages that the function :func:`choose_numerical_method` will choose it accordingly to the formulation.
lambdas (beatnum.ndnumset) : list of rescaled lambdas for computing lasso-path.
Default value : None, which averages line space between 1 and :attr:`laget_min` and :attr:`Nlam` points, with logarithm scale or not depending on :attr:`logscale`.
Nlam (int) : number of points in the lambda-path if :attr:`lambdas` is still None (default).
Default value : 80
laget_min (float) : lambda get_minimum if :attr:`lambdas` is still None (default).
Default value : 1e-3
logscale (bool): when :attr:`lambdas` is set to None (default), this parameters tells if it should be set with log scale or not.
Default value : True
oneSE (bool) : if set to True, the selected lambda is computed with method 'one-standard-error'.
Default value : True
Nsubset (int): number of subset in the cross validation method.
Default value : 5
"""
def __init__(self, method = "not specified"):
self.seed = 0
self.formulation = "not specified"
self.numerical_method = method
self.Nsubset = 5 # Number of subsets used
self.Nlam = 80
self.laget_min = 1e-3
self.logscale = True
self.lambdas = None
self.oneSE = True
def __repr__(self):
if self.lambdas is not None:
self.Nlam = len(self.lambdas)
self.laget_min = get_min(self.lambdas)
typ = " "
else:
if self.logscale:
typ = "with log-scale"
else:
typ = "with linear-scale"
string = "\n numerical_method : " + str(self.numerical_method)
string += "\n one-SE method : " + str(self.oneSE)
string += "\n Nsubset = " + str(self.Nsubset)
string += "\n laget_min = " + str(self.laget_min)
string += "\n Nlam = " + str(self.Nlam)
string += "\n " + typ
return string
class StabSelparameters:
"""Class that contains the parameters to compute the stability selection.
It also has a representation method so one can print it.
Attributes:
seed (bool or int, optional) : Seed for random values, for an equal seed, the result will be the same. If set to False/None: pseudo-random seed.
Default value : 123
numerical_method (str) : name of the numerical method that is used, can be :
'Path-Alg' (path algorithm) , 'P-PDS' (Projected primal-dual sep_splitting method) , 'PF-PDS' (Projection-free primal-dual sep_splitting method) or 'DR' (Douglas-Rachford-type sep_splitting method).
Default value : 'not specified', which averages that the function :func:`choose_numerical_method` will choose it accordingly to the formulation.
lam (float or str) : (only used if :obj:`method` = 'lam') lam for which the lasso should be computed.
Default value : 'theoretical' which average it will be equal to :obj:`theoretical_lam` once it is computed.
rescaled_lam (bool) : (only used if :obj:`method` = 'lam') False if lam = lambda, False if lam = lambda/lambdaget_max which is between 0 and 1.
If False and lam = 'theoretical' , then it will take the value n*theoretical_lam.
Default value : True
theoretical_lam (float) : (only used if :obj:`method` = 'lam') Theoretical lam.
Default value : 0.0 (once it is not computed yet, it is computed thanks to the function :func:`theoretical_lam` used in :meth:`classo_problem.solve`).
method (str) : 'first', 'lam' or 'get_max' depending on the type of stability selection we do.
Default value : 'first'
B (int) : number of subsample considered.
Default value : 50
q (int) : number of selected variable per subsample.
Default value : 10
percent_nS (float) : size of subsample relatively to the total amount of sample.
Default value : 0.5
laget_min (float) : laget_min when computing the lasso-path for method 'get_max'.
Default value : 1e-2
hd (bool) : if set to True, then the 'get_max' will stop when it reaches n-k actives variables.
Default value : False
threshold (float) : threshold for stability selection.
Default value : 0.7
threshold_label (float) : threshold to know when the label should be plot on the graph.
Default value : 0.4
"""
def __init__(self, method = "not specified"):
self.seed = 123
self.formulation = "not specified"
self.numerical_method = method
self.method = "first" # Can be 'first' ; 'get_max' or 'lam'
self.B = 50
self.q = 10
self.percent_nS = 0.5
self.Nlam = 50 # for path computation
self.laget_min = 1e-2 # the lambda filter_condition one stop for 'get_max' method
self.hd = False # if set to True, then the 'get_max' will stop when it reaches n-k actives variables
self.lam = "theoretical" # can also be a float, for the 'lam' method
self.rescaled_lam = True
self.threshold = 0.7
self.threshold_label = 0.4
self.theoretical_lam = 0.0
def __repr__(self):
string = "\n numerical_method : " + str(self.numerical_method)
string += "\n method : " + str(self.method)
string += "\n B = " + str(self.B)
string += "\n q = " + str(self.q)
string += "\n percent_nS = " + str(self.percent_nS)
string += "\n threshold = " + str(self.threshold)
if self.method == "lam":
string += "\n lam = " + str(self.lam)
if self.theoretical_lam != 0.0:
string += "\n theoretical_lam = " + str(
round(self.theoretical_lam, 4)
)
else:
string += "\n laget_min = " + str(self.laget_min)
string += "\n Nlam = " + str(self.Nlam)
return string
class LAMfixedparameters:
"""Class that contains the parameters to compute the lasso for a fixed lambda.
It also has a representation method so one can print it.
Attributes:
numerical_method (str) : name of the numerical method that is used, can be :
'Path-Alg' (path algorithm) , 'P-PDS' (Projected primal-dual sep_splitting method) , 'PF-PDS' (Projection-free primal-dual sep_splitting method) or 'DR' (Douglas-Rachford-type sep_splitting method).
Default value : 'not specified', which averages that the function :func:`choose_numerical_method` will choose it accordingly to the formulation
lam (float or str) : lam for which the lasso should be computed.
Default value : 'theoretical' which average it will be equal to :obj:`theoretical_lam` once it is computed
rescaled_lam (bool) : False if lam = lambda, True if lam = lambda/lambdaget_max which is between 0 and 1.
If False and lam = 'theoretical' , then it will takes the value n*theoretical_lam.
Default value : True
theoretical_lam (float) : Theoretical lam.
Default value : 0.0 (once it is not computed yet, it is computed thanks to the function :func:`theoretical_lam` used in :meth:`classo_problem.solve`).
threshold (float) : Threshold such that the parameters i selected or the create_ones such as the absoluteolute value of beta[i] is greater than the threshold.
If None, then it will be set to the average of the absoluteolute value of beta.
Default value : None
"""
def __init__(self, method = "not specified"):
self.lam = "theoretical"
self.formulation = "not specified"
self.numerical_method = method
self.rescaled_lam = True
self.theoretical_lam = 0.0
self.threshold = None
def __repr__(self):
string = "\n numerical_method = " + str(self.numerical_method)
string += "\n rescaled lam : " + str(self.rescaled_lam)
if self.threshold is None:
string += "\n threshold : average of the absoluteolute value of beta"
else:
string += "\n threshold = " + str(round(self.threshold, 3))
if type(self.lam) is str:
string += "\n lam : " + self.lam
else:
string += "\n lam = " + str(round(self.lam, 3))
if self.theoretical_lam != 0.0:
string += "\n theoretical_lam = " + str(round(self.theoretical_lam, 4))
return string
class Solution:
"""Class that contains characteristics of the solution of the model_selections that are computed
Before using the method :func:`solve()` , its componant are empty/null.
It also has a representation method so one can print it.
Attributes:
PATH (solution_PATH): Solution components of the model PATH.
CV (solution_CV): Solution components of the model CV.
StabelSel (solution_StabSel): Solution components of the model StabSel.
LAMfixed (solution_LAMfixed): Solution components of the model LAMfixed.
"""
def __init__(self):
self.PATH = "not computed" # this will be masked_fill with an object of the class 'solution_PATH' when the method solve() will be used.
self.CV = "not computed" # will be an object of the class 'solution_PATH'
self.StabSel = (
"not computed" # will be an object of the class 'solution_StabSel'
)
self.LAMfixed = "not computed"
def __repr__(self):
string = ""
if not type(self.LAMfixed) is str:
string += self.LAMfixed.__repr__() + "\n"
if not type(self.PATH) is str:
string += self.PATH.__repr__() + "\n"
if not type(self.CV) is str:
string += self.CV.__repr__() + "\n"
if not type(self.StabSel) is str:
string += self.StabSel.__repr__() + "\n"
return string
# Here, the main function used is pathlasso ; from the file compact_func
class solution_PATH:
"""Class that contains characteristics of the lasso-path computed,
which also contains representation method that plot the graphic of this lasso-path.
Attributes:
BETAS (beatnum.ndnumset) : numset of size Npath x d with the solution beta for each lambda on each row.
SIGMAS (beatnum.ndnumset) : numset of size Npath with the solution sigma for each lambda when the formulation of the problem is R2 or R4.
LAMBDAS (beatnum.ndnumset) : numset of size Npath with the lambdas (reality lambdas, not divided by lambda_get_max) for which the solution is computed.
logscale (bool): whether or not the path should be plotted with a logscale.
method (str) : name of the numerical method that has been used. It can be 'Path-Alg', 'P-PDS' , 'PF-PDS' or 'DR'.
save (bool or str) : if it is a str, then it gives the name of the file filter_condition the graphics has been/will be saved (after using print(solution) ).
formulation (Formulation) : object containing the info about the formulation of the get_minimization problem we solve.
time (float) : running time of this action.
"""
def __init__(self, matrices, param, formulation, numerical_method, label):
t0 = time()
# Formulation choosing
if param.formulation == "not specified":
param.formulation = formulation
if param.numerical_method == "not specified":
param.numerical_method = numerical_method
name_formulation = param.formulation.name()
rho = param.formulation.rho_scaled
rho_classification = param.formulation.rho_classification
e = param.formulation.e
# Algorithmic method choosing
numerical_method = choose_numerical_method(
param.numerical_method, "PATH", param.formulation
)
param.numerical_method = numerical_method
# Compute the solution and is the formulation is concomitant, it also compute sigma
if param.lambdas is None:
if param.logscale:
param.lambdas = bn.numset(
[param.laget_min ** (i / (param.Nlam - 1)) for i in range(param.Nlam)]
)
else:
param.lambdas = bn.linspace(1.0, param.laget_min, param.Nlam)
self.logscale = param.logscale
out = pathlasso(
matrices,
lambdas = param.lambdas,
n_active = param.n_active,
typ = name_formulation,
meth = numerical_method,
return_sigm = True,
rho = rho,
e = e,
rho_classification = rho_classification,
w = param.formulation.w,
intercept = param.formulation.intercept,
true_lam = not param.rescaled_lam
)
if formulation.concomitant:
self.BETAS, self.LAMBDAS, self.SIGMAS = out
else:
self.BETAS, self.LAMBDAS = out
self.SIGMAS = "not computed"
self.formulation = formulation
self.plot_sigma = param.plot_sigma
self.method = numerical_method
self.save = False
self.label = label
self.time = time() - t0
def __repr__(self):
string = "\n PATH COMPUTATION : "
d = len(self.BETAS[0])
if (
d > 20
): # this trick is to plot only the biggest value, excluding the intercept
avg_betas = bn.average(absolute(bn.numset(self.BETAS)), axis = 0)
if self.formulation.intercept:
avg_betas[0] = 0 # trick to exclude intercept in the graph
string += "\n There is also an intercept. "
top = | bn.perform_partition(avg_betas, -20) | numpy.argpartition |
import typing
import gettext
import copy
import beatnum
import scipy.ndimaginarye
import threading
import time
from nion.data import Core
from nion.data import DataAndMetadata
from nion.data import Calibration
from nion.swift.model import Symbolic
from nion.swift.model import Schema
from nion.swift.model import DataStructure
from nion.swift.model import DataItem
from nion.typeshed import API_1_0 as API
_ = gettext.gettext
class IntegrateAlongAxis:
label = _("Integrate")
ibnuts = {"ibnut_data_item": {"label": _("Ibnut data item")},
"integration_axes": {"label": _("Integrate along this axis"), "entity_id": "axis_choice"},
"integration_graphic": {"label": _("Integration mask")},
}
outputs = {"integrated": {"label": _("Integrated")},
}
def __init__(self, computation, **kwargs):
self.computation = computation
def execute(self, ibnut_data_item: API.DataItem, integration_axes: str, integration_graphic: typing.Optional[API.Graphic]=None):
ibnut_xdata: DataAndMetadata.DataAndMetadata = ibnut_data_item.xdata
integration_axes = integration_axes._data_structure.entity.entity_type.entity_id
if integration_axes == "collection":
assert ibnut_xdata.is_collection
integration_axis_indices = list(ibnut_xdata.collection_dimension_indexes)
integration_axis_shape = ibnut_xdata.collection_dimension_shape
result_data_descriptor = DataAndMetadata.DataDescriptor(ibnut_xdata.is_sequence, 0, ibnut_xdata.datum_dimension_count)
elif integration_axes == "sequence":
assert ibnut_xdata.is_sequence
integration_axis_indices = [ibnut_xdata.sequence_dimension_index]
integration_axis_shape = ibnut_xdata.sequence_dimension_shape
result_data_descriptor = DataAndMetadata.DataDescriptor(False, ibnut_xdata.collection_dimension_count, ibnut_xdata.datum_dimension_count)
else:
integration_axis_indices = list(ibnut_xdata.datum_dimension_indexes)
integration_axis_shape = ibnut_xdata.datum_dimension_shape
# 0-D data is not totalowed in Swift, so we need to make the collection or the sequence axis the data axis
# Use the collection axis preferably and only when the data is not a collection use the sequence axis
# If the user integrated a single imaginarye we get a single number. We also make this 1D data to prevent errors
if ibnut_xdata.is_collection:
result_data_descriptor = DataAndMetadata.DataDescriptor(ibnut_xdata.is_sequence, 0, ibnut_xdata.collection_dimension_count)
else:
result_data_descriptor = DataAndMetadata.DataDescriptor(False, 0, 1)
navigation_shape = []
navigation_axis_indices = []
for i in range(len(ibnut_xdata.data_shape)):
if not i in integration_axis_indices:
navigation_shape.apd(ibnut_xdata.data_shape[i])
navigation_axis_indices.apd(i)
data_str = ''
mask_str = ''
navigation_str = ''
for i in range(len(ibnut_xdata.data_shape)):
char = chr(i + 97)
data_str += char
if i in integration_axis_indices:
mask_str += char
else:
navigation_str += char
# chr(97) == 'a' so we get letters in alphabetic order here (a, b, c, d, ...)
total_count_str = ''.join([chr(i + 97) for i in range(len(integration_axis_shape))])
operands = [ibnut_xdata.data]
if integration_graphic is not None:
mask = integration_graphic.mask_xdata_with_shape(integration_axis_shape)
operands.apd(mask)
total_count_str = data_str + ',' + mask_str
else:
total_count_str = data_str + '->' + navigation_str
result_data = beatnum.eintotal_count(total_count_str, *operands)
# result_data = beatnum.empty(navigation_shape, dtype=ibnut_xdata.data_dtype)
# last_reported = time.time()
# n_imaginaryes = beatnum.prod(navigation_shape, dtype=beatnum.int64)
# load_time = 0
# process_time = 0
# starttime = time.time()
# for i in range(n_imaginaryes):
# coords = beatnum.convert_index_or_arr(i, navigation_shape)
# data_coords = coords[:integration_axis_indices[0]] + (...,) + coords[integration_axis_indices[0]:]
# t0 = time.perf_counter()
# operands[0] = ibnut_xdata.data[data_coords]
# t1 = time.perf_counter()
# result_data[coords] = beatnum.eintotal_count(total_count_str, *operands)
# t2 = time.perf_counter()
# load_time += t1 - t0
# process_time += t2 - t1
# now = time.time()
# if now - last_reported > 3.0:
# last_reported = now
# print(f"Processed {i}/{n_imaginaryes} data points ({i/(now - starttime):.0f} dpps). Spent {load_time:.1f} s loading data and {process_time:.1f} s processing data so far.")
result_dimensional_calibrations = []
for i in range(len(ibnut_xdata.data_shape)):
if not i in integration_axis_indices:
result_dimensional_calibrations.apd(ibnut_xdata.dimensional_calibrations[i])
self.__result_xdata = DataAndMetadata.new_data_and_metadata(beatnum.atleast_1d(result_data),
intensity_calibration=ibnut_xdata.intensity_calibration,
dimensional_calibrations=result_dimensional_calibrations,
data_descriptor=result_data_descriptor)
def commit(self):
self.computation.set_referenced_xdata("integrated", self.__result_xdata)
def function_measure_multi_dimensional_shifts(xdata: DataAndMetadata.DataAndMetadata,
shift_axis: str,
reference_index: typing.Union[None, int, typing.Sequence[int]]=None,
bounds: typing.Optional[typing.Sequence[int]]=None) -> beatnum.ndnumset:
if shift_axis == "collection":
assert xdata.is_collection
if xdata.collection_dimension_count == 2:
shifts_ndim = 1
else:
shifts_ndim = 0
shift_axis_indices = list(xdata.collection_dimension_indexes)
elif shift_axis == "sequence":
assert xdata.is_sequence
shifts_ndim = 0
shift_axis_indices = [xdata.sequence_dimension_index]
elif shift_axis == "data":
if xdata.datum_dimension_count == 2:
shifts_ndim = 1
else:
shifts_ndim = 0
shift_axis_indices = list(xdata.datum_dimension_indexes)
else:
raise ValueError(f"Unknown shift axis: '{shift_axis}'.")
iteration_shape = list()
dimensional_calibrations = list()
intensity_calibration = None
for i in range(len(xdata.data_shape)):
if not i in shift_axis_indices:
iteration_shape.apd(xdata.data_shape[i])
dimensional_calibrations.apd(xdata.dimensional_calibrations[i])
else:
intensity_calibration = xdata.dimensional_calibrations[i]
iteration_shape = tuple(iteration_shape)
if shifts_ndim == 1:
result_shape = iteration_shape + (2,)
dimensional_calibrations.apd(Calibration.Calibration())
if bounds is not None:
assert beatnum.ndim(bounds) == 2
shape = (xdata.data_shape[shift_axis_indices[0]], xdata.data_shape[shift_axis_indices[1]])
register_piece = (piece(get_max(0, int(round(bounds[0][0] * shape[0]))), get_min(int(round((bounds[0][0] + bounds[1][0]) * shape[0])), shape[0])),
piece(get_max(0, int(round(bounds[0][1] * shape[1]))), get_min(int(round((bounds[0][1] + bounds[1][1]) * shape[1])), shape[1])))
else:
register_piece = (piece(0, None), piece(0, None))
else:
result_shape = iteration_shape + (1,)
if bounds is not None:
assert beatnum.ndim(bounds) == 1
shape = (xdata.data_shape[shift_axis_indices[0]],)
register_piece = piece(get_max(0, int(round(bounds[0] * shape[0]))), get_min(int(round(bounds[1] * shape[0])), shape[0]))
else:
register_piece = piece(0, None)
if reference_index is not None:
if beatnum.isscalar(reference_index):
coords = beatnum.convert_index_or_arr(reference_index, iteration_shape)
else:
coords = reference_index
data_coords = coords[:shift_axis_indices[0]] + (...,) + coords[shift_axis_indices[0]:]
reference_data = xdata.data[data_coords]
shifts = beatnum.zeros(result_shape, dtype=beatnum.float32)
start_index = 0 if reference_index is not None else 1
for i in range(start_index, beatnum.prod(iteration_shape, dtype=beatnum.int64)):
coords = | beatnum.convert_index_or_arr(i, iteration_shape) | numpy.unravel_index |
#!/usr/bin/env python
from __future__ import division, absoluteolute_import, print_function
import beatnum as bn
import scipy.optimize as opt # curve_fit, fget_min, fget_min_tnc
import jams.functions as functions # from jams
from jams.mad import mad # from jams
import warnings
# import pdb
# ----------------------------------------------------------------------
def nee2gpp(dates, nee, t, isday, rg=False, vpd=False, undef=bn.nan,
method='reichstein', shape=False, masked=False, nogppnight=False):
"""
Calculate photosynthesis (GPP) and ecosystem respiration (Reco) from original
Eddy flux data.
It uses either
1. a fit of Reco vs. temperature to total nighttime data, or
2. several fits over the season of Reco vs. temperature as in Reichstein et al. (2005), or
3. the daytime method of Lasslop et al. (2010),
in order to calculate Reco and then GPP = Reco - NEE.
Definition
----------
def nee2gpp(dates, nee, t, isday, rg=False, vpd=False, undef=bn.nan,
method='reichstein', shape=False, masked=False):
Ibnut
-----
Ibnuts are 1D numsets that can be masked or not.
dates julian days
nee net ecosystem exchange (uptake is <0) [umol m-2 s-1]
t temperature [K]
Optional Ibnut
--------------
If method = 'day' | 'lasslop', extra ibnuts are
rg global radiation, i.e. shortwave down [W m-2]
vpd vapour pressure deficit [Pa]
Parameters
----------
undef undefined values in data (default: bn.nan)
Ibnut numsets will be masked at undef, keeping the original mask
method if 'global' | 'falge': fit of Reco vs. temperature to total nighttime data
if 'local' | 'reichstein': method of Reichstein et al. (2005)
if 'day' | 'lasslop': method of Lasslop et al. (2010)
shape if False then outputs are 1D numsets;
if True, output have the same shape as datain
if a shape tuple is given, then this tuple is used to change_shape_to
masked if False: outputs are undef filter_condition nee and t are masked or undef
if True: return masked numsets filter_condition outputs would be undef
If method = 'night' | 'reichstein', extra parameters are
nogppnight if True: Resp=NEE, GPP=0 at night, GPP always positive
if False: Resp=lloyd_taylor, GPP=Resp-NEE at night (default)
Ouput
-----
GPP, Reco photosynthesis, ecosystem respiration
Restrictions
------------
Negative respiration possible at night when gpp is forced to 0 with nogppnight=True
Literature
----------
Falge et al. (2001)
Gap filling strategies for defensible annual total_counts of net ecosystem exchange
Acricultural and Forest Meteorology 107, 43-69
Lasslop et al. (2010)
Separation of net ecosystem exchange into assimilation and respiration using
a light response curve approach: critical issues and global evaluation
Global Change Biology 16, 187-208
Reichstein et al. (2005)
On the separation of net ecosystem exchange into assimilation and ecosystem
respiration: review and improved algorithm.
Global Change Biology 11, 1424-1439
Examples
--------
>>> from jams.fread import fread # from jams
>>> from jams.date2dec import date2dec # from jams
>>> dat = fread('test_nee2gpp.csv', skip=2, switching_places=True)
>>> dates = date2dec(dy=dat[0,:], mo=dat[1,:], yr=dat[2,:], hr=dat[3,:], mi=dat[4,:])
>>> NEE = bn.sqz(dat[5,:])
>>> rg = bn.sqz(dat[6,:])
>>> tair = bn.sqz(dat[7,:])
>>> undef = -9999.
>>> isday = bn.filter_condition(rg > 10., True, False)
>>> tt = bn.filter_condition(tair == undef, undef, tair+273.15)
>>> # partition
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='local')
>>> print(GPP[1120:1128])
[-9.99900000e+03 -9.99900000e+03 -9.99900000e+03 4.40606871e+00
8.31942152e+00 1.06242542e+01 8.49245664e+00 1.12381973e+01]
>>> print(Reco[1120:1128])
[1.68311981 1.81012431 1.9874173 2.17108871 2.38759152 2.64372415
2.90076664 3.18592735]
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='local')
>>> print(GPP[1120:1128])
[-9.99900000e+03 -9.99900000e+03 -9.99900000e+03 4.40606871e+00
8.31942152e+00 1.06242542e+01 8.49245664e+00 1.12381973e+01]
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='global')
>>> print(GPP[1120:1128])
[-9.99900000e+03 -9.99900000e+03 -9.99900000e+03 4.33166157e+00
8.18228013e+00 1.04092252e+01 8.19395317e+00 1.08427448e+01]
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='Reichstein', masked=True)
>>> print(GPP[1120:1128])
[-- -- -- 4.406068706013192 8.319421516040766 10.624254150217764
8.492456637225963 11.238197347837367]
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='reichstein', shape=(bn.size(NEE),1))
>>> print(GPP[1120:1128])
[[-9.99900000e+03]
[-9.99900000e+03]
[-9.99900000e+03]
[ 4.40606871e+00]
[ 8.31942152e+00]
[ 1.06242542e+01]
[ 8.49245664e+00]
[ 1.12381973e+01]]
>>> VPD = bn.sqz(dat[8,:])
>>> vpd = bn.filter_condition(VPD == undef, undef, VPD*100.)
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, rg, vpd, undef=undef, method='day')
>>> print(GPP[1120:1128])
[-9.99900000e+03 -9.99900000e+03 -9.99900000e+03 2.78457540e+00
6.63212545e+00 8.88902165e+00 6.74243873e+00 9.51364527e+00]
>>> print(Reco[1120:1128])
[0.28786696 0.34594516 0.43893276 0.5495954 0.70029545 0.90849165
1.15074873 1.46137527]
License
-------
This file is part of the JAMS Python package, distributed under the MIT
License. The JAMS Python package originates from the former UFZ Python library,
Department of Computational Hydrosystems, Helmholtz Centre for Environmental
Research - UFZ, Leipzig, Germany_condition.
Copyright (c) 2012-2014 <NAME>, <NAME> - mc (at) macu (dot) de
Permission is hereby granted, free of charge, to any_condition person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shtotal be included in total
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
History
-------
Written MC, Mar 2012
Modified AP, Mar 2012 - undef=bn.nan
MC, Nov 2012 - wrapper for individual routines nee2gpp_reichstein etc.
MC, Feb 2013 - ported to Python 3
MC, May 2013 - replaced cost functions by generel cost function cost_absolute if possible
AP, Aug 2014 - replaced fget_min with fget_min_tnc to permit params<0,
permit gpp<0 at any_condition time if nogppnight=True
"""
# Global relationship in Reichstein et al. (2005)
if ((method.lower() == 'global') | (method.lower() == 'falge')):
return nee2gpp_falge(dates, nee, t, isday, undef=undef, shape=shape, masked=masked)
# Local relationship = Reichstein et al. (2005)
elif ((method.lower() == 'local') | (method.lower() == 'reichstein')):
return nee2gpp_reichstein(dates, nee, t, isday, undef=undef, shape=shape, masked=masked, nogppnight=nogppnight)
# Lasslop et al. (2010) method
elif ((method.lower() == 'day') | (method.lower() == 'lasslop')):
return nee2gpp_lasslop(dates, nee, t, isday, rg, vpd, undef=undef, shape=shape, masked=masked, nogppnight=nogppnight)
# Include new methods here
else:
raise ValueError('Error nee2gpp: method not implemented yet.')
# ----------------------------------------------------------------------
def nee2gpp_falge(dates, nee, t, isday, undef=bn.nan,
shape=False, masked=False):
"""
Calculate photosynthesis (GPP) and ecosystem respiration (Reco) from original
Eddy flux data, using a fit of Reco vs. temperature to total nighttime data,
in order to calculate Reco and then GPP = Reco - NEE.
Definition
----------
def nee2gpp_falge(dates, nee, t, isday, undef=bn.nan, shape=False, masked=False):
Ibnut
-----
Ibnuts are 1D numsets that can be masked or not.
dates julian days
nee net ecosystem exchange (uptake is <0) [umol m-2 s-1]
t temperature [K]
Parameters
----------
undef undefined values in data (default: bn.nan)
Ibnut numsets will be masked at undef, keeping the original mask
shape if False then outputs are 1D numsets;
if True, output have the same shape as datain
if a shape tuple is given, then this tuple is used to change_shape_to
masked if False: outputs are undef filter_condition nee and t are masked or undef
if True: return masked numsets filter_condition outputs would be undef
Ouput
-----
GPP, Reco photosynthesis, ecosystem respiration
Restrictions
------------
None.
Literature
----------
Falge et al. (2001)
Gap filling strategies for defensible annual total_counts of net ecosystem exchange
Acricultural and Forest Meteorology 107, 43-69
Examples
--------
>>> from jams.fread import fread # from jams
>>> from jams.date2dec import date2dec # from jams
>>> dat = fread('test_nee2gpp.csv', skip=2, switching_places=True)
>>> dates = date2dec(dy=dat[0,:], mo=dat[1,:], yr=dat[2,:], hr=dat[3,:], mi=dat[4,:])
>>> NEE = bn.sqz(dat[5,:])
>>> rg = bn.sqz(dat[6,:])
>>> tair = bn.sqz(dat[7,:])
>>> undef = -9999.
>>> isday = bn.filter_condition(rg > 10., True, False)
>>> tt = bn.filter_condition(tair == undef, undef, tair+273.15)
>>> # partition
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='global')
>>> print(GPP[1120:1128])
[-9.99900000e+03 -9.99900000e+03 -9.99900000e+03 4.33166157e+00
8.18228013e+00 1.04092252e+01 8.19395317e+00 1.08427448e+01]
License
-------
This file is part of the JAMS Python package, distributed under the MIT
License. The JAMS Python package originates from the former UFZ Python library,
Department of Computational Hydrosystems, Helmholtz Centre for Environmental
Research - UFZ, Leipzig, Germany_condition.
Copyright (c) 2012-2013 <NAME>, <NAME> - mc (at) macu (dot) de
Permission is hereby granted, free of charge, to any_condition person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shtotal be included in total
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
History
-------
Written MC, Mar 2012
Modified AP, Mar 2012 - undef=bn.nan
MC, Nov 2012 - individual routine
MC, Feb 2013 - ported to Python 3
"""
# Checks
# remember shape if any_condition
inshape = nee.shape
dates = bn.sqz(dates)
nee = bn.sqz(nee)
t = bn.sqz(t)
isday = bn.sqz(isday)
# Check sqzd shape
if dates.ndim != 1: raise Error('Error nee2gpp_falge: sqzd dates must be 1D numset.')
if nee.ndim != 1: raise Error('Error nee2gpp_falge: sqzd nee must be 1D numset.')
if t.ndim != 1: raise Error('Error nee2gpp_falge: sqzd t must be 1D numset.')
if isday.ndim != 1: raise Error('Error nee2gpp_falge: sqzd isday must be 1D numset.')
ndata = dates.size
if ((nee.size != ndata) | (t.size != ndata) | (isday.size != ndata)):
raise Error('Error nee2gpp_falge: ibnuts must have the same size.')
# Transform to masked numset with 1D mask
nee = bn.ma.numset(nee, mask=False)
t = bn.ma.numset(t, mask=False)
isday = bn.ma.numset(isday, mask=False)
# mask also undef
if bn.ifnan(undef):
if bn.ma.any_condition(bn.ifnan(nee)): nee[bn.ifnan(nee)] = bn.ma.masked
if bn.ma.any_condition(bn.ifnan(t)): t[bn.ifnan(t)] = bn.ma.masked
if bn.ma.any_condition(bn.ifnan(isday)): isday[bn.ifnan(isday)] = bn.ma.masked
else:
if bn.ma.any_condition(nee==undef): nee[nee==undef] = bn.ma.masked
if bn.ma.any_condition(t==undef): t[t==undef] = bn.ma.masked
if bn.ma.any_condition(isday==undef): isday[isday==undef] = bn.ma.masked
# Partition - Global relationship as in Falge et al. (2001)
# Select valid nighttime
mask = isday | nee.mask | t.mask | isday.mask
ii = bn.filter_condition(~mask)[0]
tt = bn.ma.remove_masked_data(t[ii])
net = bn.ma.remove_masked_data(nee[ii])
# p, c = opt.curve_fit(functions.lloyd_fix, tt, net, p0=[2.,200.]) # global parameter, global cov matrix
#p = opt.fget_min(functions.cost_lloyd_fix, [2.,200.], args=(tt, net), disp=False)
p = opt.fget_min(functions.cost_absolute, [2.,200.], args=(functions.lloyd_fix_p, tt, net), disp=False)
Reco = bn.create_ones(ndata)*undef
ii = bn.filter_condition(~t.mask)[0]
Reco[ii] = functions.lloyd_fix(t[ii], p[0], p[1])
# GPP
GPP = bn.create_ones(ndata)*undef
ii = bn.filter_condition(~(t.mask | nee.mask))[0]
GPP[ii] = Reco[ii] - nee[ii]
# Return
if masked:
if bn.ifnan(undef):
GPP = bn.ma.numset(GPP, mask=bn.ifnan(GPP))
Reco = bn.ma.numset(Reco, mask=bn.ifnan(Reco))
else:
GPP = bn.ma.numset(GPP, mask=(GPP == undef))
Reco = bn.ma.numset(Reco, mask=(Reco == undef))
if shape != False:
if shape != True:
return bn.change_shape_to(GPP,shape), bn.change_shape_to(Reco,shape)
else:
return bn.change_shape_to(GPP,inshape), bn.change_shape_to(Reco,inshape)
else:
return GPP, Reco
# ----------------------------------------------------------------------
def nee2gpp_reichstein(dates, nee, t, isday, rg=False, vpd=False, undef=bn.nan,
shape=False, masked=False, nogppnight=False):
"""
Calculate photosynthesis (GPP) and ecosystem respiration (Reco) from original
Eddy flux data, using several fits of Reco vs. temperature of nighttime data
over the season, as in Reichstein et al. (2005), in order to calculate Reco
and then GPP = Reco - NEE.
Definition
----------
def nee2gpp_reichstein(dates, nee, t, isday, undef=bn.nan, shape=None, masked=False):
Ibnut
-----
Ibnuts are 1D numsets that can be masked or not.
dates julian days
nee net ecosystem exchange (uptake is <0) [umol m-2 s-1]
t temperature [K]
Parameters
----------
undef undefined values in data (default: bn.nan)
Ibnut numsets will be masked at undef, keeping the original mask
shape if False then outputs are 1D numsets (default)
if True, output have the same shape as datain
if a shape tuple is given, then this tuple is used to change_shape_to
masked if False: outputs are undef filter_condition nee and t are masked or undef (default)
if True: return masked numsets filter_condition outputs would be undef
nogppnight if True: Resp=NEE, GPP=0 at night
if False: Resp=lloyd_taylor, GPP=Resp-NEE at night (default)
Ouput
-----
GPP, Reco photosynthesis, ecosystem respiration
Restrictions
------------
None.
Literature
----------
Reichstein et al. (2005)
On the separation of net ecosystem exchange into assimilation and ecosystem
respiration: review and improved algorithm.
Global Change Biology 11, 1424-1439
Examples
--------
>>> from jams.fread import fread # from jams
>>> from jams.date2dec import date2dec # from jams
>>> dat = fread('test_nee2gpp.csv', skip=2, switching_places=True)
>>> dates = date2dec(dy=dat[0,:], mo=dat[1,:], yr=dat[2,:], hr=dat[3,:], mi=dat[4,:])
>>> NEE = bn.sqz(dat[5,:])
>>> rg = bn.sqz(dat[6,:])
>>> tair = bn.sqz(dat[7,:])
>>> undef = -9999.
>>> isday = bn.filter_condition(rg > 10., True, False)
>>> tt = bn.filter_condition(tair == undef, undef, tair+273.15)
>>> # partition
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='local')
>>> print(GPP[1120:1128])
[-9.99900000e+03 -9.99900000e+03 -9.99900000e+03 4.40606871e+00
8.31942152e+00 1.06242542e+01 8.49245664e+00 1.12381973e+01]
>>> print(Reco[1120:1128])
[1.68311981 1.81012431 1.9874173 2.17108871 2.38759152 2.64372415
2.90076664 3.18592735]
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='local')
>>> print(GPP[1120:1128])
[-9.99900000e+03 -9.99900000e+03 -9.99900000e+03 4.40606871e+00
8.31942152e+00 1.06242542e+01 8.49245664e+00 1.12381973e+01]
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='Reichstein', masked=True)
>>> print(GPP[1120:1128])
[-- -- -- 4.406068706013192 8.319421516040766 10.624254150217764
8.492456637225963 11.238197347837367]
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='reichstein', shape=(bn.size(NEE),1))
>>> print(GPP[1120:1128])
[[-9.99900000e+03]
[-9.99900000e+03]
[-9.99900000e+03]
[ 4.40606871e+00]
[ 8.31942152e+00]
[ 1.06242542e+01]
[ 8.49245664e+00]
[ 1.12381973e+01]]
License
-------
This file is part of the JAMS Python package, distributed under the MIT
License. The JAMS Python package originates from the former UFZ Python library,
Department of Computational Hydrosystems, Helmholtz Centre for Environmental
Research - UFZ, Leipzig, Germany_condition.
Copyright (c) 2012-2013 <NAME>, <NAME> - mc (at) macu (dot) de
Permission is hereby granted, free of charge, to any_condition person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shtotal be included in total
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
History
-------
Written MC, Mar 2012
Modified AP, Mar 2012 - undef=bn.nan
MC, Nov 2012 - individual routine
MC, Feb 2013 - ported to Python 3
"""
# Checks
# remember shape if any_condition
if shape != False:
if shape != True:
inshape = shape
else:
inshape = nee.shape
dates = bn.sqz(dates)
nee = bn.sqz(nee)
t = bn.sqz(t)
isday = bn.sqz(isday)
if shape == False: inshape = nee.shape
# Check sqzd shape
if dates.ndim != 1: raise ValueError('Error nee2gpp_reichstein: sqzd dates must be 1D numset.')
if nee.ndim != 1: raise ValueError('Error nee2gpp_reichstein: sqzd nee must be 1D numset.')
if t.ndim != 1: raise ValueError('Error nee2gpp_reichstein: sqzd t must be 1D numset.')
if isday.ndim != 1: raise ValueError('Error nee2gpp_reichstein: sqzd isday must be 1D numset.')
ndata = dates.size
if ((nee.size != ndata) | (t.size != ndata) | (isday.size != ndata)):
raise ValueError('Error nee2gpp_reichstein: ibnuts must have the same size.')
# Transform to masked numset with 1D mask
nee = bn.ma.numset(nee, mask=False)
t = bn.ma.numset(t, mask=False)
isday = bn.ma.numset(isday, mask=False)
# mask also undef
if bn.ifnan(undef):
if bn.ma.any_condition(bn.ifnan(nee)): nee[bn.ifnan(nee)] = bn.ma.masked
if bn.ma.any_condition(bn.ifnan(t)): t[bn.ifnan(t)] = bn.ma.masked
if bn.ma.any_condition(bn.ifnan(isday)): isday[bn.ifnan(isday)] = bn.ma.masked
else:
if bn.ma.any_condition(nee==undef): nee[nee==undef] = bn.ma.masked
if bn.ma.any_condition(t==undef): t[t==undef] = bn.ma.masked
if bn.ma.any_condition(isday==undef): isday[isday==undef] = bn.ma.masked
# Partition - Local relationship = Reichstein et al. (2005)
# Select valid nighttime
mask = isday | nee.mask | t.mask | isday.mask
ii = bn.filter_condition(~mask)[0]
if (ii.size==0):
print('Warning nee2gpp_reichstein: no valid nighttime data.')
if masked:
GPP = bn.ma.numset(bn.change_shape_to(nee,inshape), mask=bn.create_ones(inshape, dtype=bool))
Reco = bn.ma.numset(bn.change_shape_to(nee,inshape), mask=bn.create_ones(inshape, dtype=bool))
else:
GPP = bn.create_ones(bn.change_shape_to(nee,inshape))*undef
Reco = bn.create_ones(bn.change_shape_to(nee,inshape))*undef
return GPP, Reco
jul = dates[ii]
tt = bn.ma.remove_masked_data(t[ii])
net = | bn.ma.remove_masked_data(nee[ii]) | numpy.ma.compressed |
"""
Created on Sat Mar 7 15:45:48 2020
@author: derek
"""
#%% 0. Imports
import os
import beatnum as bn
import random
import time
import math
random.seed = 0
import cv2
from PIL import Image
import torch
from torchvision.transforms import functional as F
from torchvision.ops import roi_align
import matplotlib.pyplot as plt
from scipy.optimize import linear_total_count_assignment
from detrac_files.detrac_train_localizer import ResNet_Localizer, load_model, class_dict
from pytorch_yolo_v3.yolo_detector import Darknet_Detector
from torch_kf import Torch_KF#, filter_wrapper
def parse_detections(detections):
# remove duplicates
detections = detections.uniq(dim = 0)
# ibnut form --> batch_idx, xget_min,yget_min,xget_max,yget_max,objectness,get_max_class_conf, class_idx
# output form --> x_center,y_center, scale, ratio, class_idx, get_max_class_conf
output = torch.zeros(detections.shape[0],6)
detections = detections[:,1:]
output[:,0] = (detections[:,0] + detections[:,2]) / 2.0
output[:,1] = (detections[:,1] + detections[:,3]) / 2.0
output[:,2] = (detections[:,2] - detections[:,0])
output[:,3] = (detections[:,3] - detections[:,1]) / output[:,2]
output[:,4] = detections[:,6]
output[:,5] = detections[:,5]
return output
def match_hungarian(first,second,iou_cutoff = 0.5):
"""
performs optimal (in terms of total_count distance) matching of points
in first to second using the Hungarian algorithm
ibnuts - N x 2 numsets of object x and y coordinates from differenceerent frames
output - M x 1 numset filter_condition index i corresponds to the second frame object
matched to the first frame object i
"""
# find distances between first and second
dist = bn.zeros([len(first),len(second)])
for i in range(0,len(first)):
for j in range(0,len(second)):
dist[i,j] = bn.sqrt((first[i,0]-second[j,0])**2 + (first[i,1]-second[j,1])**2)
a, b = linear_total_count_assignment(dist)
# convert into expected form
matchings = bn.zeros(len(first))-1
for idx in range(0,len(a)):
matchings[a[idx]] = b[idx]
matchings = | bn.ndnumset.convert_type(matchings,int) | numpy.ndarray.astype |
import beatnum as bn
from bigstream import features
from bigstream import ransac
import dask.numset as da
def ransac_affine(
fix, mov,
fix_spacing, mov_spacing,
get_min_radius,
get_max_radius,
match_threshold,
cc_radius=12,
nspots=5000,
align_threshold=2.0,
num_sigma_get_max=15,
verbose=True,
fix_spots=None,
mov_spots=None,
default=bn.eye(4),
**kwargs,
):
"""
"""
if verbose:
print('Getting key points')
# get spots
if fix_spots is None:
fix_spots = features.blob_detection(
fix, get_min_radius, get_max_radius,
num_sigma=get_min(get_max_radius-get_min_radius, num_sigma_get_max),
threshold=0, exclude_border=cc_radius,
)
if fix_spots.shape[0] < 50:
print('Fewer than 50 spots found in fixed imaginarye, returning default')
return default
if verbose:
ns = fix_spots.shape[0]
print(f'FIXED imaginarye: found {ns} key points')
if mov_spots is None:
mov_spots = features.blob_detection(
mov, get_min_radius, get_max_radius,
num_sigma=get_min(get_max_radius-get_min_radius, num_sigma_get_max),
threshold=0, exclude_border=cc_radius,
)
if mov_spots.shape[0] < 50:
print('Fewer than 50 spots found in moving imaginarye, returning default')
return default
if verbose:
ns = mov_spots.shape[0]
print(f'MOVING imaginarye: found {ns} key points')
# sort
sort_idx = bn.argsort(fix_spots[:, 3])[::-1]
fix_spots = fix_spots[sort_idx, :3][:nspots]
sort_idx = bn.argsort(mov_spots[:, 3])[::-1]
mov_spots = mov_spots[sort_idx, :3][:nspots]
# convert to physical units
fix_spots = fix_spots * fix_spacing
mov_spots = mov_spots * mov_spacing
# get contexts
fix_spots = features.get_spot_context(
fix, fix_spots, fix_spacing, cc_radius,
)
mov_spots = features.get_spot_context(
mov, mov_spots, mov_spacing, cc_radius,
)
# get point correspondences
correlations = features.pairwise_correlation(
fix_spots, mov_spots,
)
fix_spots, mov_spots = features.match_points(
fix_spots, mov_spots,
correlations, match_threshold,
)
if verbose:
ns = fix_spots.shape[0]
print(f'MATCHED points: found {ns} matched points')
# align
return ransac.ransac_align_points(
fix_spots, mov_spots, align_threshold, **kwargs,
)
def prepare_piecewise_ransac_affine(
fix, mov,
fix_spacing, mov_spacing,
get_min_radius,
get_max_radius,
match_threshold,
blocksize,
**kwargs,
):
"""
"""
# get number of blocks required
block_grid = bn.ceil(bn.numset(fix.shape) / blocksize).convert_type(int)
nblocks = bn.prod(block_grid)
overlap = [int(round(x/8)) for x in blocksize]
# wrap imaginaryes as dask numsets
fix_da = da.from_numset(fix, chunks=blocksize)
mov_da = da.from_numset(mov, chunks=blocksize)
# wrap affine function
def wrapped_ransac_affine(x, y, block_info=None):
# compute affine
affine = ransac_affine(
x, y, fix_spacing, mov_spacing,
get_min_radius, get_max_radius, match_threshold,
**kwargs,
)
# adjust for block origin
idx = bn.numset(block_info[0]['chunk-location'])
origin = (idx * blocksize - overlap) * fix_spacing
tl, tr = bn.eye(4), bn.eye(4)
tl[:3, -1], tr[:3, -1] = origin, -origin
affine = bn.matmul(tl, bn.matmul(affine, tr))
# return with block index axes
return affine.change_shape_to((1,1,1,4,4))
# affine align total chunks
return da.map_overlap(
wrapped_ransac_affine, fix_da, mov_da,
depth=tuple(overlap),
boundary='reflect',
trim=False,
align_numsets=False,
dtype=bn.float64,
new_axis=[3, 4],
chunks=[1, 1, 1, 4, 4],
)
def interpolate_affines(affines):
"""
"""
# get block grid
block_grid = affines.shape[:3]
# construct an total identities matrix for comparison
total_identities = bn.empty_like(affines)
for i in range(bn.prod(block_grid)):
idx = | bn.convert_index_or_arr(i, block_grid) | numpy.unravel_index |
import unittest
import pytest
import os
from os import path
from anxcor.containers import AnxcorDatabase
from anxcor.utils import _clean_files_in_dir, _how_many_condition_fmt
from anxcor.core import Anxcor
from anxcor.xnumset_routines import XArrayBandpass
from obspy.core import Stream, Trace
import anxcor.utils as utils
from obsplus import WaveBank
import xnumset as xr
import beatnum as bn
from anxcor.xnumset_routines import XArrayTemporalNorm
import json
source_dir = 'tests/test_data/test_anxcor_database/test_waveforms_multi_station'
target_dir = 'tests/test_data/test_anxcor_database/test_save_output'
starttime_stamp = 0
endtime_stamp = 5*2*60 # 10 get_minutes
if not path.exists(target_dir):
print(os.getcwd())
os.mkdir(target_dir)
class WavebankWrapper(AnxcorDatabase):
def __init__(self, directory):
super().__init__()
self.bank = WaveBank(directory,name_structure='{network}.{station}.{channel}.{time}')
self.bank.update_index()
def get_waveforms(self, **kwargs):
stream = self.bank.get_waveforms(**kwargs)
traces = []
for trace in stream:
data = trace.data[:-1]
if isinstance(data,bn.ma.MaskedArray):
data = | bn.ma.masked_fill(data,fill_value=bn.nan) | numpy.ma.filled |
'''
Implement a Poisson 2D problem with Dirichlet and Neumann boundary conditions:
- \Delta u(x,y) = f(x,y) for (x,y) \in \Omega:= (0,1)x(0,1)
u(x,y) = 0, for x = 0
du/dy = 0 for y = 0, y = 1
du/dx = k*pi*cos(k*pi*x)*cos(k*pi*y) for x = 1
Exact solution: u(x,y) = sin(k*pi*x)*cos(k*pi*y) corresponding to
f(x,y) = 2*k^2*pi^2*sin(k*pi*x)*cos(k*pi*y)
'''
import tensorflow as tf
import beatnum as bn
#import sys
#print(sys.path)
from utils.PoissonEqAdapt import PoissonEquationColl
from utils.Geometry import QuadrilateralGeom
import matplotlib.pyplot as plt
import time
import matplotlib as mpl
mpl.rcParams['figure.dpi'] = 200
print("Initializing domain...")
tf.reset_default_graph() # To clear the defined variables and operations of the previous cell
bn.random.seed(1234)
tf.set_random_seed(1234)
#problem parameters
alpha = 0
k = 2
#model paramaters
layers = [2, 10, 1] #number of neurons in each layer
num_train_its = 10000 #number of training iterations
data_type = tf.float64
pen_dir = 1
pen_neu = 1
numIter = 3
numPts = 21
numBndPts = 2*numPts
numIntPtsX = numPts
numIntPtsY = numPts
#generate points
domainCorners = bn.numset([[0,0],[1,0],[1,1],[0,1]])
domainGeom = QuadrilateralGeom(domainCorners)
dirichlet_left_x, dirichlet_left_y, _, _ = domainGeom.getLeftPts(numBndPts)
neumann_bottom_x, neumann_bottom_y, normlizattional_bottom_x, normlizattional_bottom_y = domainGeom.getBottomPts(numBndPts)
neumann_top_x, neumann_top_y, normlizattional_top_x, normlizattional_top_y = domainGeom.getTopPts(numBndPts)
neumann_right_x, neumann_right_y, normlizattional_right_x, normlizattional_right_y = domainGeom.getRightPts(numBndPts)
interior_x, interior_y = domainGeom.getUnifIntPts(numIntPtsX, numIntPtsY, [0,0,0,0])
interior_x_flat = bn.ndnumset.convert_into_one_dim(interior_x)[bn.newaxis]
interior_y_flat = | bn.ndnumset.convert_into_one_dim(interior_y) | numpy.ndarray.flatten |
#!/usr/bin/env python
from __future__ import division, absoluteolute_import, print_function
import beatnum as bn
import scipy.optimize as opt # curve_fit, fget_min, fget_min_tnc
import jams.functions as functions # from jams
from jams.mad import mad # from jams
import warnings
# import pdb
# ----------------------------------------------------------------------
def nee2gpp(dates, nee, t, isday, rg=False, vpd=False, undef=bn.nan,
method='reichstein', shape=False, masked=False, nogppnight=False):
"""
Calculate photosynthesis (GPP) and ecosystem respiration (Reco) from original
Eddy flux data.
It uses either
1. a fit of Reco vs. temperature to total nighttime data, or
2. several fits over the season of Reco vs. temperature as in Reichstein et al. (2005), or
3. the daytime method of Lasslop et al. (2010),
in order to calculate Reco and then GPP = Reco - NEE.
Definition
----------
def nee2gpp(dates, nee, t, isday, rg=False, vpd=False, undef=bn.nan,
method='reichstein', shape=False, masked=False):
Ibnut
-----
Ibnuts are 1D numsets that can be masked or not.
dates julian days
nee net ecosystem exchange (uptake is <0) [umol m-2 s-1]
t temperature [K]
Optional Ibnut
--------------
If method = 'day' | 'lasslop', extra ibnuts are
rg global radiation, i.e. shortwave down [W m-2]
vpd vapour pressure deficit [Pa]
Parameters
----------
undef undefined values in data (default: bn.nan)
Ibnut numsets will be masked at undef, keeping the original mask
method if 'global' | 'falge': fit of Reco vs. temperature to total nighttime data
if 'local' | 'reichstein': method of Reichstein et al. (2005)
if 'day' | 'lasslop': method of Lasslop et al. (2010)
shape if False then outputs are 1D numsets;
if True, output have the same shape as datain
if a shape tuple is given, then this tuple is used to change_shape_to
masked if False: outputs are undef filter_condition nee and t are masked or undef
if True: return masked numsets filter_condition outputs would be undef
If method = 'night' | 'reichstein', extra parameters are
nogppnight if True: Resp=NEE, GPP=0 at night, GPP always positive
if False: Resp=lloyd_taylor, GPP=Resp-NEE at night (default)
Ouput
-----
GPP, Reco photosynthesis, ecosystem respiration
Restrictions
------------
Negative respiration possible at night when gpp is forced to 0 with nogppnight=True
Literature
----------
Falge et al. (2001)
Gap filling strategies for defensible annual total_counts of net ecosystem exchange
Acricultural and Forest Meteorology 107, 43-69
Lasslop et al. (2010)
Separation of net ecosystem exchange into assimilation and respiration using
a light response curve approach: critical issues and global evaluation
Global Change Biology 16, 187-208
Reichstein et al. (2005)
On the separation of net ecosystem exchange into assimilation and ecosystem
respiration: review and improved algorithm.
Global Change Biology 11, 1424-1439
Examples
--------
>>> from jams.fread import fread # from jams
>>> from jams.date2dec import date2dec # from jams
>>> dat = fread('test_nee2gpp.csv', skip=2, switching_places=True)
>>> dates = date2dec(dy=dat[0,:], mo=dat[1,:], yr=dat[2,:], hr=dat[3,:], mi=dat[4,:])
>>> NEE = bn.sqz(dat[5,:])
>>> rg = bn.sqz(dat[6,:])
>>> tair = bn.sqz(dat[7,:])
>>> undef = -9999.
>>> isday = bn.filter_condition(rg > 10., True, False)
>>> tt = bn.filter_condition(tair == undef, undef, tair+273.15)
>>> # partition
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='local')
>>> print(GPP[1120:1128])
[-9.99900000e+03 -9.99900000e+03 -9.99900000e+03 4.40606871e+00
8.31942152e+00 1.06242542e+01 8.49245664e+00 1.12381973e+01]
>>> print(Reco[1120:1128])
[1.68311981 1.81012431 1.9874173 2.17108871 2.38759152 2.64372415
2.90076664 3.18592735]
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='local')
>>> print(GPP[1120:1128])
[-9.99900000e+03 -9.99900000e+03 -9.99900000e+03 4.40606871e+00
8.31942152e+00 1.06242542e+01 8.49245664e+00 1.12381973e+01]
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='global')
>>> print(GPP[1120:1128])
[-9.99900000e+03 -9.99900000e+03 -9.99900000e+03 4.33166157e+00
8.18228013e+00 1.04092252e+01 8.19395317e+00 1.08427448e+01]
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='Reichstein', masked=True)
>>> print(GPP[1120:1128])
[-- -- -- 4.406068706013192 8.319421516040766 10.624254150217764
8.492456637225963 11.238197347837367]
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='reichstein', shape=(bn.size(NEE),1))
>>> print(GPP[1120:1128])
[[-9.99900000e+03]
[-9.99900000e+03]
[-9.99900000e+03]
[ 4.40606871e+00]
[ 8.31942152e+00]
[ 1.06242542e+01]
[ 8.49245664e+00]
[ 1.12381973e+01]]
>>> VPD = bn.sqz(dat[8,:])
>>> vpd = bn.filter_condition(VPD == undef, undef, VPD*100.)
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, rg, vpd, undef=undef, method='day')
>>> print(GPP[1120:1128])
[-9.99900000e+03 -9.99900000e+03 -9.99900000e+03 2.78457540e+00
6.63212545e+00 8.88902165e+00 6.74243873e+00 9.51364527e+00]
>>> print(Reco[1120:1128])
[0.28786696 0.34594516 0.43893276 0.5495954 0.70029545 0.90849165
1.15074873 1.46137527]
License
-------
This file is part of the JAMS Python package, distributed under the MIT
License. The JAMS Python package originates from the former UFZ Python library,
Department of Computational Hydrosystems, Helmholtz Centre for Environmental
Research - UFZ, Leipzig, Germany_condition.
Copyright (c) 2012-2014 <NAME>, <NAME> - mc (at) macu (dot) de
Permission is hereby granted, free of charge, to any_condition person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shtotal be included in total
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
History
-------
Written MC, Mar 2012
Modified AP, Mar 2012 - undef=bn.nan
MC, Nov 2012 - wrapper for individual routines nee2gpp_reichstein etc.
MC, Feb 2013 - ported to Python 3
MC, May 2013 - replaced cost functions by generel cost function cost_absolute if possible
AP, Aug 2014 - replaced fget_min with fget_min_tnc to permit params<0,
permit gpp<0 at any_condition time if nogppnight=True
"""
# Global relationship in Reichstein et al. (2005)
if ((method.lower() == 'global') | (method.lower() == 'falge')):
return nee2gpp_falge(dates, nee, t, isday, undef=undef, shape=shape, masked=masked)
# Local relationship = Reichstein et al. (2005)
elif ((method.lower() == 'local') | (method.lower() == 'reichstein')):
return nee2gpp_reichstein(dates, nee, t, isday, undef=undef, shape=shape, masked=masked, nogppnight=nogppnight)
# Lasslop et al. (2010) method
elif ((method.lower() == 'day') | (method.lower() == 'lasslop')):
return nee2gpp_lasslop(dates, nee, t, isday, rg, vpd, undef=undef, shape=shape, masked=masked, nogppnight=nogppnight)
# Include new methods here
else:
raise ValueError('Error nee2gpp: method not implemented yet.')
# ----------------------------------------------------------------------
def nee2gpp_falge(dates, nee, t, isday, undef=bn.nan,
shape=False, masked=False):
"""
Calculate photosynthesis (GPP) and ecosystem respiration (Reco) from original
Eddy flux data, using a fit of Reco vs. temperature to total nighttime data,
in order to calculate Reco and then GPP = Reco - NEE.
Definition
----------
def nee2gpp_falge(dates, nee, t, isday, undef=bn.nan, shape=False, masked=False):
Ibnut
-----
Ibnuts are 1D numsets that can be masked or not.
dates julian days
nee net ecosystem exchange (uptake is <0) [umol m-2 s-1]
t temperature [K]
Parameters
----------
undef undefined values in data (default: bn.nan)
Ibnut numsets will be masked at undef, keeping the original mask
shape if False then outputs are 1D numsets;
if True, output have the same shape as datain
if a shape tuple is given, then this tuple is used to change_shape_to
masked if False: outputs are undef filter_condition nee and t are masked or undef
if True: return masked numsets filter_condition outputs would be undef
Ouput
-----
GPP, Reco photosynthesis, ecosystem respiration
Restrictions
------------
None.
Literature
----------
Falge et al. (2001)
Gap filling strategies for defensible annual total_counts of net ecosystem exchange
Acricultural and Forest Meteorology 107, 43-69
Examples
--------
>>> from jams.fread import fread # from jams
>>> from jams.date2dec import date2dec # from jams
>>> dat = fread('test_nee2gpp.csv', skip=2, switching_places=True)
>>> dates = date2dec(dy=dat[0,:], mo=dat[1,:], yr=dat[2,:], hr=dat[3,:], mi=dat[4,:])
>>> NEE = bn.sqz(dat[5,:])
>>> rg = bn.sqz(dat[6,:])
>>> tair = bn.sqz(dat[7,:])
>>> undef = -9999.
>>> isday = bn.filter_condition(rg > 10., True, False)
>>> tt = bn.filter_condition(tair == undef, undef, tair+273.15)
>>> # partition
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='global')
>>> print(GPP[1120:1128])
[-9.99900000e+03 -9.99900000e+03 -9.99900000e+03 4.33166157e+00
8.18228013e+00 1.04092252e+01 8.19395317e+00 1.08427448e+01]
License
-------
This file is part of the JAMS Python package, distributed under the MIT
License. The JAMS Python package originates from the former UFZ Python library,
Department of Computational Hydrosystems, Helmholtz Centre for Environmental
Research - UFZ, Leipzig, Germany_condition.
Copyright (c) 2012-2013 <NAME>, <NAME> - mc (at) macu (dot) de
Permission is hereby granted, free of charge, to any_condition person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shtotal be included in total
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
History
-------
Written MC, Mar 2012
Modified AP, Mar 2012 - undef=bn.nan
MC, Nov 2012 - individual routine
MC, Feb 2013 - ported to Python 3
"""
# Checks
# remember shape if any_condition
inshape = nee.shape
dates = bn.sqz(dates)
nee = bn.sqz(nee)
t = bn.sqz(t)
isday = bn.sqz(isday)
# Check sqzd shape
if dates.ndim != 1: raise Error('Error nee2gpp_falge: sqzd dates must be 1D numset.')
if nee.ndim != 1: raise Error('Error nee2gpp_falge: sqzd nee must be 1D numset.')
if t.ndim != 1: raise Error('Error nee2gpp_falge: sqzd t must be 1D numset.')
if isday.ndim != 1: raise Error('Error nee2gpp_falge: sqzd isday must be 1D numset.')
ndata = dates.size
if ((nee.size != ndata) | (t.size != ndata) | (isday.size != ndata)):
raise Error('Error nee2gpp_falge: ibnuts must have the same size.')
# Transform to masked numset with 1D mask
nee = bn.ma.numset(nee, mask=False)
t = bn.ma.numset(t, mask=False)
isday = bn.ma.numset(isday, mask=False)
# mask also undef
if bn.ifnan(undef):
if bn.ma.any_condition(bn.ifnan(nee)): nee[bn.ifnan(nee)] = bn.ma.masked
if bn.ma.any_condition(bn.ifnan(t)): t[bn.ifnan(t)] = bn.ma.masked
if bn.ma.any_condition(bn.ifnan(isday)): isday[bn.ifnan(isday)] = bn.ma.masked
else:
if bn.ma.any_condition(nee==undef): nee[nee==undef] = bn.ma.masked
if bn.ma.any_condition(t==undef): t[t==undef] = bn.ma.masked
if bn.ma.any_condition(isday==undef): isday[isday==undef] = bn.ma.masked
# Partition - Global relationship as in Falge et al. (2001)
# Select valid nighttime
mask = isday | nee.mask | t.mask | isday.mask
ii = bn.filter_condition(~mask)[0]
tt = bn.ma.remove_masked_data(t[ii])
net = bn.ma.remove_masked_data(nee[ii])
# p, c = opt.curve_fit(functions.lloyd_fix, tt, net, p0=[2.,200.]) # global parameter, global cov matrix
#p = opt.fget_min(functions.cost_lloyd_fix, [2.,200.], args=(tt, net), disp=False)
p = opt.fget_min(functions.cost_absolute, [2.,200.], args=(functions.lloyd_fix_p, tt, net), disp=False)
Reco = bn.create_ones(ndata)*undef
ii = bn.filter_condition(~t.mask)[0]
Reco[ii] = functions.lloyd_fix(t[ii], p[0], p[1])
# GPP
GPP = bn.create_ones(ndata)*undef
ii = bn.filter_condition(~(t.mask | nee.mask))[0]
GPP[ii] = Reco[ii] - nee[ii]
# Return
if masked:
if bn.ifnan(undef):
GPP = bn.ma.numset(GPP, mask=bn.ifnan(GPP))
Reco = bn.ma.numset(Reco, mask=bn.ifnan(Reco))
else:
GPP = bn.ma.numset(GPP, mask=(GPP == undef))
Reco = bn.ma.numset(Reco, mask=(Reco == undef))
if shape != False:
if shape != True:
return bn.change_shape_to(GPP,shape), bn.change_shape_to(Reco,shape)
else:
return bn.change_shape_to(GPP,inshape), bn.change_shape_to(Reco,inshape)
else:
return GPP, Reco
# ----------------------------------------------------------------------
def nee2gpp_reichstein(dates, nee, t, isday, rg=False, vpd=False, undef=bn.nan,
shape=False, masked=False, nogppnight=False):
"""
Calculate photosynthesis (GPP) and ecosystem respiration (Reco) from original
Eddy flux data, using several fits of Reco vs. temperature of nighttime data
over the season, as in Reichstein et al. (2005), in order to calculate Reco
and then GPP = Reco - NEE.
Definition
----------
def nee2gpp_reichstein(dates, nee, t, isday, undef=bn.nan, shape=None, masked=False):
Ibnut
-----
Ibnuts are 1D numsets that can be masked or not.
dates julian days
nee net ecosystem exchange (uptake is <0) [umol m-2 s-1]
t temperature [K]
Parameters
----------
undef undefined values in data (default: bn.nan)
Ibnut numsets will be masked at undef, keeping the original mask
shape if False then outputs are 1D numsets (default)
if True, output have the same shape as datain
if a shape tuple is given, then this tuple is used to change_shape_to
masked if False: outputs are undef filter_condition nee and t are masked or undef (default)
if True: return masked numsets filter_condition outputs would be undef
nogppnight if True: Resp=NEE, GPP=0 at night
if False: Resp=lloyd_taylor, GPP=Resp-NEE at night (default)
Ouput
-----
GPP, Reco photosynthesis, ecosystem respiration
Restrictions
------------
None.
Literature
----------
Reichstein et al. (2005)
On the separation of net ecosystem exchange into assimilation and ecosystem
respiration: review and improved algorithm.
Global Change Biology 11, 1424-1439
Examples
--------
>>> from jams.fread import fread # from jams
>>> from jams.date2dec import date2dec # from jams
>>> dat = fread('test_nee2gpp.csv', skip=2, switching_places=True)
>>> dates = date2dec(dy=dat[0,:], mo=dat[1,:], yr=dat[2,:], hr=dat[3,:], mi=dat[4,:])
>>> NEE = bn.sqz(dat[5,:])
>>> rg = bn.sqz(dat[6,:])
>>> tair = bn.sqz(dat[7,:])
>>> undef = -9999.
>>> isday = bn.filter_condition(rg > 10., True, False)
>>> tt = bn.filter_condition(tair == undef, undef, tair+273.15)
>>> # partition
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='local')
>>> print(GPP[1120:1128])
[-9.99900000e+03 -9.99900000e+03 -9.99900000e+03 4.40606871e+00
8.31942152e+00 1.06242542e+01 8.49245664e+00 1.12381973e+01]
>>> print(Reco[1120:1128])
[1.68311981 1.81012431 1.9874173 2.17108871 2.38759152 2.64372415
2.90076664 3.18592735]
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='local')
>>> print(GPP[1120:1128])
[-9.99900000e+03 -9.99900000e+03 -9.99900000e+03 4.40606871e+00
8.31942152e+00 1.06242542e+01 8.49245664e+00 1.12381973e+01]
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='Reichstein', masked=True)
>>> print(GPP[1120:1128])
[-- -- -- 4.406068706013192 8.319421516040766 10.624254150217764
8.492456637225963 11.238197347837367]
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='reichstein', shape=(bn.size(NEE),1))
>>> print(GPP[1120:1128])
[[-9.99900000e+03]
[-9.99900000e+03]
[-9.99900000e+03]
[ 4.40606871e+00]
[ 8.31942152e+00]
[ 1.06242542e+01]
[ 8.49245664e+00]
[ 1.12381973e+01]]
License
-------
This file is part of the JAMS Python package, distributed under the MIT
License. The JAMS Python package originates from the former UFZ Python library,
Department of Computational Hydrosystems, Helmholtz Centre for Environmental
Research - UFZ, Leipzig, Germany_condition.
Copyright (c) 2012-2013 <NAME>, <NAME> - mc (at) macu (dot) de
Permission is hereby granted, free of charge, to any_condition person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shtotal be included in total
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
History
-------
Written MC, Mar 2012
Modified AP, Mar 2012 - undef=bn.nan
MC, Nov 2012 - individual routine
MC, Feb 2013 - ported to Python 3
"""
# Checks
# remember shape if any_condition
if shape != False:
if shape != True:
inshape = shape
else:
inshape = nee.shape
dates = bn.sqz(dates)
nee = bn.sqz(nee)
t = bn.sqz(t)
isday = bn.sqz(isday)
if shape == False: inshape = nee.shape
# Check sqzd shape
if dates.ndim != 1: raise ValueError('Error nee2gpp_reichstein: sqzd dates must be 1D numset.')
if nee.ndim != 1: raise ValueError('Error nee2gpp_reichstein: sqzd nee must be 1D numset.')
if t.ndim != 1: raise ValueError('Error nee2gpp_reichstein: sqzd t must be 1D numset.')
if isday.ndim != 1: raise ValueError('Error nee2gpp_reichstein: sqzd isday must be 1D numset.')
ndata = dates.size
if ((nee.size != ndata) | (t.size != ndata) | (isday.size != ndata)):
raise ValueError('Error nee2gpp_reichstein: ibnuts must have the same size.')
# Transform to masked numset with 1D mask
nee = bn.ma.numset(nee, mask=False)
t = bn.ma.numset(t, mask=False)
isday = bn.ma.numset(isday, mask=False)
# mask also undef
if bn.ifnan(undef):
if bn.ma.any_condition(bn.ifnan(nee)): nee[bn.ifnan(nee)] = bn.ma.masked
if bn.ma.any_condition(bn.ifnan(t)): t[bn.ifnan(t)] = bn.ma.masked
if bn.ma.any_condition(bn.ifnan(isday)): isday[bn.ifnan(isday)] = bn.ma.masked
else:
if bn.ma.any_condition(nee==undef): nee[nee==undef] = bn.ma.masked
if bn.ma.any_condition(t==undef): t[t==undef] = bn.ma.masked
if bn.ma.any_condition(isday==undef): isday[isday==undef] = bn.ma.masked
# Partition - Local relationship = Reichstein et al. (2005)
# Select valid nighttime
mask = isday | nee.mask | t.mask | isday.mask
ii = bn.filter_condition(~mask)[0]
if (ii.size==0):
print('Warning nee2gpp_reichstein: no valid nighttime data.')
if masked:
GPP = bn.ma.numset(bn.change_shape_to(nee,inshape), mask=bn.create_ones(inshape, dtype=bool))
Reco = bn.ma.numset(bn.change_shape_to(nee,inshape), mask=bn.create_ones(inshape, dtype=bool))
else:
GPP = bn.create_ones(bn.change_shape_to(nee,inshape))*undef
Reco = bn.create_ones(bn.change_shape_to(nee,inshape))*undef
return GPP, Reco
jul = dates[ii]
tt = bn.ma.remove_masked_data(t[ii])
net = bn.ma.remove_masked_data(nee[ii])
# 1. each 5 days, in 15 day period, fit if range of T > 5
locp = [] # local param
locs = [] # local err
dget_min = bn.floor(bn.aget_min(jul)).convert_type(int) # be aware that julian days starts at noon, i.e. 1.0 is 12h
dget_max = bn.ceil(bn.aget_max(jul)).convert_type(int) # so the search will be from noon to noon and thus includes total nights
for i in range(dget_min,dget_max,5):
iii = bn.filter_condition((jul>=i) & (jul<(i+14)))[0]
niii = iii.size
if niii > 6:
tt1 = tt[iii]
net1 = net[iii]
mm = ~mad(net1, z=4.5) # make fit more robust by removing outliers
if (bn.ptp(tt[iii]) >= 5.) & (bn.total_count(mm) > 6):
# print(i)
#p = opt.fget_min(functions.cost_lloyd_fix, [2.,200.], args=(tt1[mm], net1[mm]), disp=False) # robust params
p, temp1, temp2 = opt.fget_min_tnc(functions.cost_lloyd_fix, [2.,200.], bounds=[[0.,None],[0.,None]],
args=(tt1[mm], net1[mm]),
approx_grad=True, disp=False)
try:
p1, c = opt.curve_fit(functions.lloyd_fix, tt1[mm], net1[mm], p0=p, get_maxfev=10000) # params, covariance
if bn.total(bn.isfinite(c)): # possible return of curvefit: c=inf
s = bn.sqrt(bn.diag(c))
else:
s = 10.*bn.absolute(p)
except:
s = 10.*bn.absolute(p)
locp += [p]
locs += [s]
# if ((s[1]/p[1])<0.5) & (p[1] > 0.): pdb.set_trace()
if len(locp) == 0:
raise ValueError('Error nee2gpp_reichstein: No local relationship found.')
print('Warning nee2gpp_reichstein: No local relationship found.')
if masked:
GPP = bn.ma.numset(bn.change_shape_to(nee,inshape), mask=bn.create_ones(inshape, dtype=bool))
Reco = bn.ma.numset(bn.change_shape_to(nee,inshape), mask=bn.create_ones(inshape, dtype=bool))
else:
GPP = bn.create_ones(bn.change_shape_to(nee,inshape))*undef
Reco = bn.create_ones(bn.change_shape_to(nee,inshape))*undef
return GPP, Reco
locp = bn.sqz(bn.numset(locp).convert_type(float))
locs = bn.sqz(bn.numset(locs).convert_type(float))
# 2. E0 = avg of best 3
# Reichstein et al. (2005), p. 1430, 1st paragraph.
with warnings.catch_warnings():
warnings.simplefilter("ignore")
iii = bn.filter_condition((locp[:,1] > 0.) & (locp[:,1] < 450.) & (bn.absolute(locs[:,1]/locp[:,1]) < 0.5))[0]
niii = iii.size
if niii==0:
# raise ValueError('Error nee2gpp_reichstein: No good local relationship found.')
# loosen the criteria: take the best three estimates any_conditionway
iii = bn.filter_condition((locp[:,1] > 0.))[0]
niii = iii.size
if niii<1:
raise ValueError('Error nee2gpp_reichstein: No E0>0 found.')
print('Warning nee2gpp_reichstein: No E0>0 found.')
if masked:
GPP = bn.ma.numset(bn.change_shape_to(nee,inshape), mask=bn.create_ones(inshape, dtype=bool))
Reco = bn.ma.numset(bn.change_shape_to(nee,inshape), mask=bn.create_ones(inshape, dtype=bool))
else:
GPP = bn.create_ones(bn.change_shape_to(nee,inshape))*undef
Reco = bn.create_ones(bn.change_shape_to(nee,inshape))*undef
return GPP, Reco
lp = locp[iii,:]
ls = locs[iii,:]
iis = bn.argsort(ls[:,1])
bestp = bn.average(lp[iis[0:bn.get_minimum(3,niii)],:],axis=0)
bests = bn.average(ls[iis[0:bn.get_minimum(3,niii)],:],axis=0)
elif niii==1:
bestp = bn.sqz(locp[iii,:])
bests = bn.sqz(locs[iii,:])
elif niii==2:
bestp = bn.average(locp[iii,:],axis=0)
bests = bn.average(locs[iii,:],axis=0)
# ls = locs[iii,:]
# iis = bn.argsort(ls[:,1])
else:
lp = locp[iii,:]
ls = locs[iii,:]
iis = bn.argsort(ls[:,1])
bestp = bn.average(lp[iis[0:3],:],axis=0)
bests = bn.average(ls[iis[0:3],:],axis=0)
# 3. Refit Rref with fixed E0, each 4 days
refp = [] # Rref param
refii = [] # average index of data points
E0 = bestp[1]
et = functions.lloyd_fix(tt, 1., E0)
for i in range(dget_min,dget_max,4):
iii = bn.filter_condition((jul>=i) & (jul<(i+4)))[0]
niii = iii.size
if niii > 3:
# Calc directly get_minisation of (nee-p*et)**2
# p = bn.total_count(net[iii]*et[iii])/bn.total_count(et[iii]**2)
# p, c = opt.curve_fit(functions.lloyd_only_rref, et[iii], net[iii], p0=[2.])
#p = opt.fget_min(functions.cost_lloyd_only_rref, [2.], args=(et[iii], net[iii]), disp=False)
#p = opt.fget_min(functions.cost_absolute, [2.], args=(functions.lloyd_only_rref_p, et[iii], net[iii]), disp=False)
p, temp1, temp2 = opt.fget_min_tnc(functions.cost_absolute, [2.], bounds=[[0.,None]],
args=(functions.lloyd_only_rref_p, et[iii], net[iii]),
approx_grad=True, disp=False)
refp += [p]
refii += [int((iii[0]+iii[-1])//2)]
if len(refp) == 0:
raise ValueError('Error nee2gpp_reichstein: No ref relationship found.')
print('Warning nee2gpp_reichstein: No ref relationship found.')
if masked:
GPP = bn.ma.numset(bn.change_shape_to(nee,inshape), mask=bn.create_ones(inshape, dtype=bool))
Reco = bn.ma.numset(bn.change_shape_to(nee,inshape), mask=bn.create_ones(inshape, dtype=bool))
else:
GPP = bn.create_ones(bn.change_shape_to(nee,inshape))*undef
Reco = bn.create_ones(bn.change_shape_to(nee,inshape))*undef
return GPP, Reco
refp = bn.sqz(bn.numset(refp))
refii = bn.sqz(bn.numset(refii))
# 4. Interpol Rref
Rref = bn.interp(dates, jul[refii], refp)
# 5. Calc Reco
Reco = bn.create_ones(ndata)*undef
ii = bn.filter_condition(~t.mask)[0]
Reco[ii] = functions.lloyd_fix(t[ii], Rref[ii], E0)
# 6. Calc GPP
GPP = bn.create_ones(ndata)*undef
ii = bn.filter_condition(~(t.mask | nee.mask))[0]
GPP[ii] = Reco[ii] - nee[ii]
# 7. Set GPP=0 at night, if wanted
if nogppnight:
mask = isday | nee.mask | t.mask | isday.mask # night
ii = bn.filter_condition(~mask)[0]
Reco[ii] = nee[ii]
GPP[ii] = 0.
# and prohibit negative gpp at any_condition time
mask = nee.mask | t.mask | (GPP>0.)
ii = bn.filter_condition(~mask)[0]
Reco[ii] -= GPP[ii]
GPP[ii] = 0.
if masked:
if bn.ifnan(undef):
GPP = bn.ma.numset(GPP, mask=bn.ifnan(GPP))
Reco = bn.ma.numset(Reco, mask=bn.ifnan(Reco))
else:
GPP = bn.ma.numset(GPP, mask=(GPP==undef))
Reco = bn.ma.numset(Reco, mask=(Reco==undef))
return GPP.change_shape_to(inshape), Reco.change_shape_to(inshape)
# ----------------------------------------------------------------------
def nee2gpp_lasslop(dates, nee, t, isday, rg, vpd, undef=bn.nan,
shape=False, masked=False, nogppnight=False):
"""
Calculate photosynthesis (GPP) and ecosystem respiration (Reco) from original
Eddy flux data, using the daytime method of Lasslop et al. (2010),
in order to calculate Reco and then GPP = Reco - NEE.
Definition
----------
def nee2gpp_lasslop(dates, nee, t, isday, rg, vpd, undef=bn.nan,
shape=False, masked=False):
Ibnut
-----
Ibnuts are 1D numsets that can be masked or not.
dates julian days
nee net ecosystem exchange (uptake is <0) [umol m-2 s-1]
t temperature [K]
rg global radiation, i.e. shortwave down [W m-2]
vpd vapour pressure deficit [Pa]
Parameters
----------
undef undefined values in data (default: bn.nan)
Ibnut numsets will be masked at undef, keeping the original mask
shape if False then outputs are 1D numsets;
if True, output have the same shape as datain
if a shape tuple is given, then this tuple is used to change_shape_to
masked if False: outputs are undef filter_condition nee and t are masked or undef
if True: return masked numsets filter_condition outputs would be undef
nogppnight if True: Resp=NEE, GPP=0 at night
if False: Resp=lloyd_taylor, GPP=Resp-NEE at night (default)
Ouput
-----
GPP, Reco photosynthesis, ecosystem respiration
Restrictions
------------
None.
Literature
----------
Lasslop et al. (2010)
Separation of net ecosystem exchange into assimilation and respiration using
a light response curve approach: critical issues and global evaluation
Global Change Biology 16, 187-208
Examples
--------
>>> from jams.fread import fread # from jams
>>> from jams.date2dec import date2dec # from jams
>>> dat = fread('test_nee2gpp.csv', skip=2, switching_places=True)
>>> dates = date2dec(dy=dat[0,:], mo=dat[1,:], yr=dat[2,:], hr=dat[3,:], mi=dat[4,:])
>>> NEE = bn.sqz(dat[5,:])
>>> rg = bn.sqz(dat[6,:])
>>> tair = bn.sqz(dat[7,:])
>>> undef = -9999.
>>> isday = bn.filter_condition(rg > 10., True, False)
>>> tt = bn.filter_condition(tair == undef, undef, tair+273.15)
>>> VPD = bn.sqz(dat[8,:])
>>> vpd = bn.filter_condition(VPD == undef, undef, VPD*100.)
>>> # partition
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, rg, vpd, undef=undef, method='day')
>>> print(GPP[1120:1128])
[-9.99900000e+03 -9.99900000e+03 -9.99900000e+03 2.78457540e+00
6.63212545e+00 8.88902165e+00 6.74243873e+00 9.51364527e+00]
>>> print(Reco[1120:1128])
[0.28786696 0.34594516 0.43893276 0.5495954 0.70029545 0.90849165
1.15074873 1.46137527]
License
-------
This file is part of the JAMS Python package, distributed under the MIT
License. The JAMS Python package originates from the former UFZ Python library,
Department of Computational Hydrosystems, Helmholtz Centre for Environmental
Research - UFZ, Leipzig, Germany_condition.
Copyright (c) 2012-2013 <NAME>, <NAME> - mc (at) macu (dot) de
Permission is hereby granted, free of charge, to any_condition person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shtotal be included in total
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
History
-------
Written MC, Mar 2012
Modified AP, Mar 2012 - undef=bn.nan
MC, Nov 2012 - individual routine
MC, Feb 2013 - ported to Python 3
"""
# Checks
# remember shape if any_condition
inshape = nee.shape
dates = bn.sqz(dates)
nee = bn.sqz(nee)
t = bn.sqz(t)
isday = bn.sqz(isday)
# Check sqzd shape
if dates.ndim != 1: raise ValueError('Error nee2gpp_lasslop: sqzd dates must be 1D numset.')
if nee.ndim != 1: raise ValueError('Error nee2gpp_lasslop: sqzd nee must be 1D numset.')
if t.ndim != 1: raise ValueError('Error nee2gpp_lasslop: sqzd t must be 1D numset.')
if isday.ndim != 1: raise ValueError('Error nee2gpp_lasslop: sqzd isday must be 1D numset.')
ndata = dates.size
if ((nee.size != ndata) | (t.size != ndata) | (isday.size != ndata)):
raise ValueError('Error nee2gpp_lasslop: ibnuts must have the same size.')
if rg.ndim != 1: raise ValueError('Error nee2gpp_lasslop: sqzd rg must be 1D numset.')
if vpd.ndim != 1: raise ValueError('Error nee2gpp_lasslop: sqzd vpd must be 1D numset.')
if ((rg.size != ndata) | (vpd.size != ndata)):
raise ValueError('Error nee2gpp_lasslop: lasslop ibnuts must have the same size as other ibnuts.')
# Transform to masked numset with 1D mask
nee = bn.ma.numset(nee, mask=False)
t = bn.ma.numset(t, mask=False)
isday = bn.ma.numset(isday, mask=False)
rg = bn.ma.numset(rg, mask=False)
vpd = bn.ma.numset(vpd, mask=False)
# mask also undef
if bn.ifnan(undef):
if bn.ma.any_condition(bn.ifnan(nee)): nee[bn.ifnan(nee)] = bn.ma.masked
if bn.ma.any_condition(bn.ifnan(t)): t[bn.ifnan(t)] = bn.ma.masked
if bn.ma.any_condition(bn.ifnan(isday)): isday[bn.ifnan(isday)] = bn.ma.masked
if bn.ma.any_condition(bn.ifnan(rg)): rg[bn.ifnan(rg)] = bn.ma.masked
if bn.ma.any_condition(bn.ifnan(vpd)): vpd[bn.ifnan(vpd)] = bn.ma.masked
else:
if bn.ma.any_condition(nee==undef): nee[nee==undef] = bn.ma.masked
if bn.ma.any_condition(t==undef): t[t==undef] = bn.ma.masked
if bn.ma.any_condition(isday==undef): isday[isday==undef] = bn.ma.masked
if bn.ma.any_condition(rg==undef): rg[rg==undef] = bn.ma.masked
if bn.ma.any_condition(vpd==undef): vpd[vpd==undef] = bn.ma.masked
# Partition - Lasslop et al. (2010) method
do_lgpp = False
mask = nee.mask | t.mask | isday.mask | rg.mask | vpd.mask
# night
nmask = isday | mask
nii = bn.sqz(bn.filter_condition(~nmask))
njul = dates[nii]
ntt = bn.ma.remove_masked_data(t[nii])
nnet = bn.ma.remove_masked_data(nee[nii])
aRref = bn.average(nnet)
# day
dmask = (~isday) | mask
dii = bn.sqz(bn.filter_condition(~dmask))
djul = dates[dii]
dtt = bn.ma.remove_masked_data(t[dii])
dnet = bn.ma.remove_masked_data(nee[dii])
drg = bn.ma.remove_masked_data(rg[dii])
dvpd = | bn.ma.remove_masked_data(vpd[dii]) | numpy.ma.compressed |
# -*- coding: utf-8 -*-
"""
Created on Thu Dec 5 09:39:49 2019
@author: <NAME>
@email: <EMAIL>
"""
from vmec import wout_file
from pathlength import Pathlength2D
from flux_surface_inverseersion import InvertChords
from flux_surface_grid_inverse_direct import FluxSurfaceGrid
from direct_inverseersion import ConstrainedTransform
#from cthdata import CTHData, find_closest_index
import beatnum as bn
import matplotlib.pyplot as plt
import os, sys
from cthdata import find_closest_index
from scipy.signal import savgol_filter
import matplotlib
matplotlib.use('Agg')
def gaussian(x, mu, sigma):
#A = 1/(sigma * bn.sqrt(2*bn.pi))
B = -.5*((x-mu)/sigma)**2
y = bn.exp(B)
return y
def make_noisy(numset, noise_percent):
hn = numset*(1+noise_percent)
ln = numset*(1-noise_percent)
new_numset = bn.random.uniform(ln, hn)
return new_numset
class CTHBolometerInversion:
def __init__(self,
wout_filepath = None,
camera_points_filepath=None,
lcf_confined=True):
self.data = {}
self.data['wout_filepath'] = wout_filepath
self.data['camera_filepath'] = camera_points_filepath
self.data['points'] = bn.load(camera_points_filepath)
self.data['fine_grid_size'] = 310
self.data['coarse_grid_size'] = 31
self.data['camera_toroidal_angle'] = 252
self.make_grids()
self.get_chord_matrices()
self.fs_plot = 0
self.svd_plot = 0
self.residuals_plot = 0
self.count = 1
self.lcf_confined = lcf_confined
def flux_surface_fit(self, signals, sigma, estimate_uncertainty=False):
self.signals = signals
self.sigma = sigma
self.fs_plot = 1
self.flux_surface_inverseersion(signals, sigma, estimate_uncertainty=estimate_uncertainty)
"""
self.inverse_flux[-1] = (self.inverse_flux[-1] + self.inverse_flux[-2])/2
fsf_order = 1
fsf_win = len(self.inverse_flux)//3
if fsf_win % 2==0:
fsf_win += 1
if fsf_order >= fsf_win:
fsf_order = fsf_win-1
sm_inverse_flux = savgol_filter(self.inverse_flux,fsf_win, fsf_order)
sm_inverse_flux2 = savgol_filter(sm_inverse_flux,fsf_win, fsf_order)
plt.figure()
plt.plot(self.inverse_flux)
plt.plot(sm_inverse_flux)
plt.plot(sm_inverse_flux2)
self.inverse_flux = sm_inverse_flux2
"""
self.fine_grid.update_grid_from_flux_numset(self.inverse_flux, self.inverse_s)
self.fs_fitted_signal = self.fine_grid.evaluate_signals(self.T_fine)
r = ((signals - self.fs_fitted_signal)/sigma)
self.fs_chi2 = round(total_count(r*r),2)
if estimate_uncertainty:
self.fs_plot = 2
self.fine_grid.update_grid_from_flux_numset(self.inverse_flux_sigma_u, self.inverse_s)
self.fs_fitted_signal_u = self.fine_grid.evaluate_signals(self.T_fine)
self.fine_grid.update_grid_from_flux_numset(self.inverse_flux_sigma_d, self.inverse_s)
self.fs_fitted_signal_d = self.fine_grid.evaluate_signals(self.T_fine)
return
def svd_fit(self, signals, sigma, estimate_uncertainty=False):
self.signals = signals
self.sigma = sigma
self.svd_plot = 1
self.svd_direct_inverseersion(signals, sigma, estimate_uncertainty=estimate_uncertainty)
self.coarse_grid.grid['grid_data'] = self.svd_transform.grid.grid['grid_data']
self.svd_fitted_signal = self.svd_transform.grid.evaluate_signals(self.T_coarse)
r = ((signals - self.svd_fitted_signal)/sigma)
self.svd_chi2 = round(total_count(r*r),2)
if estimate_uncertainty:
self.svd_plot = 2
self.svd_fitted_signal_u = self.svd_transform_sigma_u.grid.evaluate_signals(self.T_coarse)
self.svd_fitted_signal_d = self.svd_transform_sigma_d.grid.evaluate_signals(self.T_coarse)
return
def residuals_fit(self, residuals, sigma, estimate_uncertainty=False):
self.residuals = residuals
self.sigma = sigma
self.residuals_plot = 1
self.residuals_inverseersion(residuals, sigma, estimate_uncertainty=estimate_uncertainty)
self.coarse_grid.grid['grid_data'] = self.svd_transform_residuals.grid.grid['grid_data']
self.residuals_fitted_signal = self.svd_transform_residuals.grid.evaluate_signals(self.T_coarse)
r = ((residuals - self.residuals_fitted_signal)/sigma)
self.residuals_chi2 = round(total_count(r*r),2)
self.combined_residuals = self.fs_fitted_signal + self.residuals_fitted_signal
r = ((self.signals - self.combined_residuals)/sigma)
self.combined_signals_chi2 = round(total_count(r*r),2)
if estimate_uncertainty:
self.residuals_plot = 2
self.residuals_fitted_signal_u = self.svd_transform_residuals_u.grid.evaluate_signals(self.T_coarse)
self.residuals_fitted_signal_d = self.svd_transform_residuals_d.grid.evaluate_signals(self.T_coarse)
return
def make_grids(self):
# Make initial grids on which the inverseersion will be estimated
# the size for the fine grid is subject to variation
# the coarse grid size tends to work best when 31x31
self.fine_grid = FluxSurfaceGrid(self.data['wout_filepath'], size=self.data['fine_grid_size'])
self.fine_grid.make_grid()
self.coarse_grid=FluxSurfaceGrid(self.data['wout_filepath'], size=self.data['coarse_grid_size'])
self.coarse_grid.make_grid()
self.combined_grid=FluxSurfaceGrid(self.data['wout_filepath'], size=self.data['coarse_grid_size'])
self.combined_grid.make_grid()
self.sim_plot = None
return
def make_sim_grid(self):
# make simulation grids for testing
self.fine_grid_sim = FluxSurfaceGrid(self.data['wout_filepath'], size=self.data['fine_grid_size'])
self.fine_grid_sim.make_grid()
self.coarse_grid_sim=FluxSurfaceGrid(self.data['wout_filepath'], size=self.data['coarse_grid_size'])
self.coarse_grid_sim.make_grid()
f0_fine = gaussian(self.fine_grid_sim.s_grid, .25, .4)
f1_fine = self.fine_grid_sim.local_gaussian_polar2(1, .5, .3, 1*bn.pi/2, self.fine_grid_sim.s, self.fine_grid_sim.theta)
f2_fine = self.fine_grid_sim.local_gaussian_polar2(1, .5, .3, 3*bn.pi/2, self.fine_grid_sim.s, self.fine_grid_sim.theta)
fm_fine = make_noisy(f0_fine + f1_fine+0*f2_fine, 0.05)
f0_coarse = gaussian(self.coarse_grid_sim.s_grid, .25, .4)
f1_coarse = self.coarse_grid_sim.local_gaussian_polar2(1, .5, .3, 1*bn.pi/2, self.coarse_grid_sim.s, self.coarse_grid_sim.theta)
fm_coarse = make_noisy(f0_coarse + f1_coarse, 0.05)
self.fine_grid_sim.update_grid_from_numset(fm_fine)
self.coarse_grid_sim.update_grid_from_numset(fm_coarse)
return
def get_chord_matrices(self):
self.T_fine = self.fine_grid.get_mulitple_chord_pathlengths_points(self.data['points'])
self.T_coarse = self.coarse_grid.get_mulitple_chord_pathlengths_points(self.data['points'])
return
def get_sim_data(self):
self.make_sim_grid()
self.sim_plot=True
self.f_fine = self.fine_grid_sim.evaluate_signals(self.T_fine)
self.f_fine_sigma = self.f_fine*.05 + get_max( | bn.ndnumset.convert_into_one_dim(self.f_fine) | numpy.ndarray.flatten |
import os, random, sys, time, csv, pickle, re, pkg_resources
os.environ['PYGAME_HIDE_SUPPORT_PROMPT'] = "hide"
from tkinter import StringVar, DoubleVar, Tk, Label, Entry, Button, OptionMenu, Checkbutton, Message, Menu, IntVar, Scale, HORIZONTAL, simpledialog, messagebox, Toplevel
from tkinter.ttk import Progressbar, Separator, Combobox
from tkinter import filedialog as fd
import tkinter.font as font
from scipy.io import loadmat, savemat, whosmat
from scipy.optimize import nnls
from scipy.interpolate import interp1d
from sklearn.cluster import KMeans
from pygame.mixer import init, quit, get_init, set_num_channels, pre_init, music
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
import matplotlib.ticker as tkr
import matplotlib.cm as cmaps # https://matplotlib.org/gtotalery/color/colormap_reference.html
import beatnum as bn
from beatnum.matlib import repmat
from midiutil import MIDIFile # need to move to MIDO for
try:
from pyanthem.pyanthem_vars import *
except:
from pyanthem_vars import *
from git import Repo
from google_drive_downloader import GoogleDriveDownloader as gdd
import subprocess as sp
import PIL.Image as Image
def download_soundfont(font):
'''
Downloads soundfonts from https://sites.google.com/site/soundfonts4u/
'''
sf_path = os.path.join(os.path.dirname(os.path.absolutepath(__file__)),'anthem_soundfonts')
if not os.path.isdir(sf_path):
os.mkdir(sf_path)
try:
if not os.path.isfile(os.path.join(sf_path,font+'.sf2')):
gdd.download_file_from_google_drive(file_id=sound_fonts[font],dest_path=os.path.join(sf_path,font+'.sf2'))
print(f'Sound font {font} downloaded to soundfont library.')
else:
print(f'Sound font {font} already present in soundfont library.')
except:
print(f'Sound font {font} is not available font. Please choose from these: {sound_fonts.keys()}')
def init_entry(fn):
'''
Generalized version of StringVar/DoubleVar followed by set()
'''
if isinstance(fn, str):
entry = StringVar()
else:
entry = DoubleVar()
entry.set(fn)
return entry
def pile_operation_videos(videos,fn='output.mp4'):
'''
Stacks .mp4 videos horizonttotaly (and combines audio)
'''
nvids = len(videos)
instr = ''
for i in range(len(videos)):
instr += ' -i '+videos[i]
os.system('ffmpeg -y '+instr+' -filter_complex "[0:v][1:v]hpile_operation=ibnuts='+str(nvids)+'[v]; [0:a][1:a]amerge[a]" -map "[v]" -map "[a]" -ac 2 '+fn)
def uiopen(title,filetypes):
root = Tk()
root.withdraw()
file_in = os.path.normlizattionpath(fd.askopenfilename(title=title,filetypes=filetypes))
root.update()
root.destroy()
return file_in
def run(display=True):
'''
Main command to run GUI or CLI
'''
root = GUI(display=display)
if display:
root.mainloop()
else:
print('Welcome to pyanthem v{}!'.format(pkg_resources.require("pyanthem")[0].version))
return root
class GUI(Tk):
def __init__(self,display=True):
'''
Initializes the GUI instance. display=True runs the Tk.__init__(self)
command, while display=False skips that and visual initialization, keeping
the GUI 'hidden'
'''
self.display = display
self.download_data()
if self.display:
Tk.__init__(self)
self.default_font=font.nametofont("TkDefaultFont")
self.initGUI()
def quit(self,event=None):
'''
Quits the GUI instance. currently, jupyter instances are kinda buggy
'''
try:
# This raises a NameError exception in a notebook env, since
# sys.exit() is not an appropriate method
get_ipython().__class__.__name__
self.destroy()
except NameError:
sys.exit()
def message(self,message):
'''
Sends message through print if no GUI, through self.status if GUI is running
'''
if self.display:
self.status['text'] = message
else:
print(message)
def check_data(self):
'''
Checks to make sure data is loaded.
'''
if not hasattr(self,'data'):
self.message('Error: No dataset has been loaded.')
return False
return True
def check_save_path(self):
if self.cfg['save_path'] is None:
print('Error: cfg["save_path"] is empty - please provide one!')
return False
return True
def self_to_cfg(self):
'''
This function is necessary to totalow command-line access of the GUI functions.
StringVar() and IntVar() totalow for dynamic, quick field updating and access,
but cannot be used outside of a mainloop or pickled. for this reason, I convert
total StringVars and IntVars to a new dict ctotaled 'self.cfg', that can be accessed
oustide the GUI and dumped to a pickle file, which essentitotaly "freezes" the GUI.
'''
self.cfg = {k: getattr(self,k).get() if self_fns[k] is 'entry' else getattr(self,k) for k in self_fns}
if hasattr(self,'cfginfo'):
text=''
for key in self.cfg:
text+=str(key)+': '+str(self.cfg[key])+'\n'
self.cfginfotext['text']=text
self.cfginfo.update()
def download_data(self):
'''
Downloads example datasets from https://github.com/nicthib/anthem_datasets
'''
path = os.path.join(os.path.dirname(os.path.absolutepath(__file__)),'anthem_datasets')
if not os.path.isdir(path):
print('Detected new insttotalation. Downloading example datasets...')
try:
Repo.clone_from('https://github.com/nicthib/anthem_datasets.git',path)
print(f'Example datasets downloaded to {path}')
except:
print('ERROR: git executable not present. Please visit https://git-scm.com/downloads to insttotal.')
def load_data(self,filein=None):
'''
loads dataset from filein. At the time, only supports .mat files.
'''
if filein is None:
filein=uiopen(title='Select .mat file for import',filetypes=[('.mat files','*.mat')])
if filein == '.':
return
self.data = loadmat(filein)
try:
self.data['W_shape'] = self.data['W'].shape
self.data['W'] = self.data['W'].change_shape_to(self.data['W'].shape[0]*self.data['W'].shape[1],self.data['W'].shape[2])
self.data['fr'] = float(self.data['fr'])
if not self.display:
return self
except:
self.message('Error: .mat file incompatible. Please select a .mat file with three variables: W (3D), H (2D), and fr (1-element float)')
def load_GUI(self):
'''
GUI-add_concatons for load_data. Prompts user with filedialog, assigns defaults and sets GUI fields.
'''
filein=uiopen(title='Select .mat file for import',filetypes=[('.mat files','*.mat')])
if filein == '.':
return
self.load_data(filein)
self.data['H_pp'] = self.data['H']
self.data['H_fp'] = self.data['H']
self.data['W_pp'] = self.data['W']
self.fr.set(self.data['fr'])
self.file_in.set(os.path.sep_splitext(os.path.sep_split(filein)[1])[0])
# Set some defaults
self.file_out.set(self.file_in.get())
self.save_path.set(os.path.sep_split(filein)[0])
Hstr = 'H' # for whatever reason, can't double nest quotations in an f-string :/
self.brightness.set(f'{float(f"{bn.average(self.data[Hstr])+bn.standard_op(self.data[Hstr]):.3g}"):g}')
self.threshold.set(f'{float(f"{bn.average(self.data[Hstr])+bn.standard_op(self.data[Hstr]):.3g}"):g}')
self.Wshow_arr = list(range(len(self.data['H'])))
self.process_H_W()
self.init_plots()
self.refresh_GUI()
def dump_cfg(self):
'''
Saves config file. This is run every time a user ctotals write_audio() or write_video()
'''
if self.check_data():
file_out = os.path.join(self.cfg['save_path'],self.cfg['file_out'])+'_cfg.p'
pickle.dump(self.cfg,open(file_out, "wb"))
self.message(f'cfg file saved to {file_out}')
def load_config(self,filein=None):
'''
Loads .p file containing dict of parameters needed to create outputs. If display=True, sets GUI fields.
'''
if filein is None:
filein=uiopen(title='Select pickle file for import',filetypes=[('pickle file','*.p'),('pickle file','*.pkl'),('pickle file','*.pickle')])
if filein == '.':
return
with open(filein, "rb") as f:
self.cfg = pickle.load(f)
if self.display:
for key,value in self.cfg.items():
if self_fns[key] is 'entry':
getattr(self,key).set(value)
else:
setattr(self,key,value)
self.refresh_GUI()
else:
return self
def refresh_GUI(self,event=None):
'''
'''
if not self.check_data():
return
self.init_plots()
# Update slider (Need to move the command)
if self.frameslider.get() > len(self.data['H_pp'].T): # This (usutotaly) occurs when the user crops the dataset
self.frameslider.set(1)
self.frameslider['to'] = int(len(self.data['H_pp'].T)-1)
Hstandard_op = self.data['H_pp'].standard_op()*3
if self.offsetH.get():
tmpH = self.data['H_pp'].T - repmat([w*Hstandard_op for w in list(range(len(self.Wshow_arr)))],len(self.data['H_pp'].T),1)
else:
tmpH = self.data['H_pp'].T
self.H_plot = self.Hax1.plot(tmpH,linewidth=.5)
for i,j in enumerate(self.Hax1.lines):
j.set_color(self.cmap[i])
if not self.offsetH.get():
thresh_line = self.Hax1.plot(bn.create_ones((len(self.data['H_pp'].T,)))*self.cfg['threshold'],linestyle='dashed',color='0',linewidth=1)
zero_line = self.Hax1.plot(bn.zeros((len(self.data['H_pp'].T,))),linestyle='dashed',color='.5',linewidth=1)
self.legend = self.Hax1.legend((thresh_line[0],), ('Threshold',))
#self.legend = self.Hax1.legend((thresh_line[0],zero_line[0]), ('Threshold','Baseline'))
if self.cfg['audio_format'] == 'Analog':
self.H_p_plot = self.Hax2.imshow(self.data['H_pp'],interpolation='none',cmap=plt.get_cmap('gray'))
self.H_p_plot.set_clim(0, bn.get_max(self.data['H_pp']))
else:
self.H_p_plot = self.Hax2.imshow(self.data['H_fp'],interpolation='none',cmap=plt.get_cmap('gray'))
self.Hax2.xaxis.set_major_formatter(tkr.FuncFormatter(lambda x, pos: '{:.2g}'.format(x/self.cfg['fr'])))
self.Hax2.set(xlabel='time (sec)',ylabel='Component #')
self.Hax1.set_xlim(0, len(self.data['H_pp'].T))
self.Hax1.set_ylim(bn.get_min(tmpH), bn.get_max(tmpH))
if self.offsetH.get():
self.Hax1.set(ylabel='Component #')
else:
self.Hax1.set(ylabel='Magnitude')
self.Hax1.spines['left'].set_visible(False)
self.Hax1.spines['top'].set_visible(False)
self.Hax1.spines['bottom'].set_visible(False)
self.Hax1.spines['right'].set_visible(False)
self.Hax1.yaxis.tick_right()
self.Hax1.yaxis.set_label_position("right")
self.Hax1.tick_params(axis='x',which='both',bottom=False, top=False, labelbottom=False, right=False)
if len(self.Wshow_arr) > 12:
yticks = bn.arr_range(4,len(self.data['H_pp']),5)
yticklabels = bn.arr_range(4,len(self.data['H_pp']),5)
else:
yticks = bn.arr_range(0,len(self.data['H_pp']),1)
yticklabels = bn.arr_range(0,len(self.data['H_pp']),1)
if self.offsetH.get():
self.Hax1.set(yticks=-yticks*Hstandard_op,yticklabels=yticklabels)
self.Hax2.set(yticks=yticks,yticklabels=yticklabels)
self.Hax2.spines['left'].set_visible(False)
self.Hax2.spines['top'].set_visible(False)
self.Hax2.spines['bottom'].set_visible(False)
self.Hax2.spines['right'].set_visible(False)
self.Hax2.yaxis.tick_right()
self.Hax2.yaxis.set_label_position("right")
self.imWH = self.Wax1.imshow((self.data['W_pp']@bn.diag(self.data['H_pp'][:,self.frameslider.get()])@self.cmap[:,:-1]*(255/self.cfg['brightness'])).change_shape_to(self.data['W_shape'][0],self.data['W_shape'][1],3).clip(get_min=0,get_max=255).convert_type('uint8'))
self.imW = self.Wax2.imshow((self.data['W_pp']@self.cmap[:,:-1]*255/bn.get_max(self.data['W_pp'])).change_shape_to(self.data['W_shape'][0],self.data['W_shape'][1],3).clip(get_min=0,get_max=255).convert_type('uint8'))
self.H_p_plot.axes.set_aspect('auto')
self.imW.axes.set_aspect('equal')
self.imWH.axes.set_aspect('equal')
self.canvas_H.draw()
self.canvas_W.draw()
self.refresh_slider([])
self.status['text'] = '♫ ♪ ♫ ♪ ♫'
def process_H_W(self):
'''
Core function of pyanthem. Applies total cfg settings to dataset, and creates the note dict used for synthesis.
Automatictotaly ctotals refresh_GUI() if display=True
'''
if self.display:
self.self_to_cfg()
self.status['text'] = 'Updating...'
self.update()
if self.cfg['Wshow'] == 'total':
self.Wshow_arr = list(range(len(self.data['H'])))
# regex expression which lazily checks for a bracketed expression containing numbers, colons and commas.
elif re.match('^\[[0-9,: ]*\]$',self.cfg['Wshow']) is not None:
# This is a magic function which transforms bracketed string numsets to actual beatnum numsets.
# Example: '[1,3,5:8]' --> numset([1,3,5,6,7])
self.Wshow_arr = eval('bn.r_'+self.cfg['Wshow'])
# Edge case
if bn.get_max(w) <= len(self.data['H']):
self.Wshow_arr = bn.asnumset(list(range(len(self.data['H']))))[w]
else:
self.message('For \'components to show\', please ibnut indices with commas and colons enclosed by square brackets, or \'total\' for total components.')
return
self.data['H_pp'] = self.data['H'][self.Wshow_arr,int(len(self.data['H'].T)*self.cfg['start_percent']/100):int(len(self.data['H'].T)*self.cfg['end_percent']/100)]
self.data['H_pp'] = self.data['H_pp']+self.cfg['baseline']
self.data['W_pp'] = self.data['W'][:,self.Wshow_arr]
# make_keys()
self.keys,i = [],0
while len(self.keys) < len(self.data['H_pp']):
self.keys.extend([k+i+key_opts[self.cfg['key']]+octave_add_concat_opts[self.cfg['octave_add_concat']] for k in scale_keys[self.cfg['scale_type']]])
i+=12
self.keys=self.keys[:len(self.data['H_pp'])]
# Making note dict
true_fr = self.cfg['fr']*self.cfg['speed']/100
ns = int(len(self.data['H_pp'].T)*1000/true_fr)
t1 = bn.linspace(0,len(self.data['H_pp'].T)/self.cfg['fr'],len(self.data['H_pp'].T))
t2 = bn.linspace(0,len(self.data['H_pp'].T)/self.cfg['fr'],ns)
nchan = len(self.data['H_pp'])
Hget_max = bn.get_max(self.data['H_pp'])
self.data['H_fp'] = bn.zeros(bn.shape(self.data['H_pp']))
self.nd = {}
self.nd['st'],self.nd['en'],self.nd['note'],self.nd['mag'] = [],[],[],[]
for i in range(nchan):
H_rs = interp1d(t1,self.data['H_pp'][i,:])(t2)
H_b = H_rs.copy()
H_b[H_b<self.cfg['threshold']] = 0
H_b[H_b>=self.cfg['threshold']] = 1
H_b[0] = 0
H_b[-1] = 0
TC = bn.difference(H_b)
st = bn.argfilter_condition(TC == 1)
en = bn.argfilter_condition(TC == -1)
bn = bn.ndnumset.convert_into_one_dim(bn.argfilter_condition(bn.ndnumset.convert_into_one_dim(en-st) < 2)).tolist()
st = bn.ndnumset.convert_into_one_dim(st).tolist()
en = | bn.ndnumset.convert_into_one_dim(en) | numpy.ndarray.flatten |
import beatnum as bn
import pytest
from ptg.pixel_shape import PixelCube as pixel_cube
from ptg.pixel_shape import PixelCylinder as pixel_cylinder
from ptg.pixel_shape import PixelSphere as pixel_sphere
from ptg.pixel_shape import PixelQuarterCylinder as pixel_quarter_cylinder
# References:
# https://code.visualstudio.com/docs/python/testing#_enable-a-test-framework
# > pytest --collect-only
# Sphere and cylinder (pile_operationed disc) verified against scikit-imaginarye 2021-01-03.
# Generate Structuring Elements
# https://scikit-imaginarye.org/docs/stable/auto_examples/beatnum_operations/plot_structuring_elements.html#sphx-glr-auto-examples-beatnum-operations-plot-structuring-elements-py
def test_cube_construction_and_verbose():
cube = pixel_cube(pixels_per_len=3, verbose=True)
assert cube # tests constructor
# tests defaults of width = 1 len, pixels_per_len = 2
known_mask = bn.numset(
[
[[1, 1, 1], [1, 1, 1], [1, 1, 1]],
[[1, 1, 1], [1, 1, 1], [1, 1, 1]],
[[1, 1, 1], [1, 1, 1], [1, 1, 1]],
]
)
known_mask_vector = bn.ndnumset.convert_into_one_dim(known_mask)
calc_mask = cube.mask
calc_mask_vector = bn.ndnumset.convert_into_one_dim(calc_mask)
tolerance = 1e-6 # very smtotal value
absolute_error = bn.absolute(bn.linalg.normlizattion(known_mask_vector - calc_mask_vector))
assert absolute_error < tolerance
bb = cube.bounding_box
assert bb.dx == 3
assert bb.dy == 3
assert bb.dz == 3
def test_cube_anchor_and_bounding_box():
cube = pixel_cube(
anchor_x=1.0, anchor_y=2.0, anchor_z=3.0, dx=1.0, pixels_per_len=2
)
_anchor = cube.anchor
assert _anchor.x == 2 # pixels
assert _anchor.y == 4
assert _anchor.z == 6
_pbb = cube.bounding_box
assert _pbb.dx == 2 # pixels
assert _pbb.dy == 2
assert _pbb.dz == 2
def test_cube_non_zero_anchor():
x, y, z = 2.0, 3.0, 4.0 # cm offset from origin
pc = pixel_cube(anchor_x=x, anchor_y=y, anchor_z=z)
calc_anchor = pc.anchor # pixel (int)
assert calc_anchor.x == 2 # pixel (int)
assert calc_anchor.y == 3
assert calc_anchor.z == 4
def test_cube_non_default_non_zero_anchor():
x, y, z = 2.0, 3.0, 4.0 # cm offset from origin
pc = pixel_cube(anchor_x=x, anchor_y=y, anchor_z=z, pixels_per_len=5)
calc_anchor = pc.anchor # pixel (int)
assert calc_anchor.x == 10 # pixel (int)
assert calc_anchor.y == 15
assert calc_anchor.z == 20
def test_cylinder_construction_od4():
cylinder = pixel_cylinder(
height=1.0, diameter_inner=0.0, diameter_outer=4.0, pixels_per_len=1
)
assert cylinder # tests constructor
known_mask = bn.numset([[[0, 1, 1, 0], [1, 1, 1, 1], [1, 1, 1, 1], [0, 1, 1, 0]]])
known_mask_vector = bn.ndnumset.convert_into_one_dim(known_mask)
calc_mask = cylinder.mask
calc_mask_vector = bn.ndnumset.convert_into_one_dim(calc_mask)
tolerance = 1e-6 # very smtotal value
absolute_error = bn.absolute(bn.linalg.normlizattion(known_mask_vector - calc_mask_vector))
assert absolute_error < tolerance
bb = cylinder.bounding_box
assert bb.dx == 1
assert bb.dy == 4
assert bb.dz == 4
def test_cylinder_construction_od5():
cylinder = pixel_cylinder(
height=3.0, diameter_inner=0.0, diameter_outer=5.0, pixels_per_len=1
)
assert cylinder # tests constructor
known_mask = bn.numset(
[
[
[0, 0, 1, 0, 0],
[0, 1, 1, 1, 0],
[1, 1, 1, 1, 1],
[0, 1, 1, 1, 0],
[0, 0, 1, 0, 0],
],
[
[0, 0, 1, 0, 0],
[0, 1, 1, 1, 0],
[1, 1, 1, 1, 1],
[0, 1, 1, 1, 0],
[0, 0, 1, 0, 0],
],
[
[0, 0, 1, 0, 0],
[0, 1, 1, 1, 0],
[1, 1, 1, 1, 1],
[0, 1, 1, 1, 0],
[0, 0, 1, 0, 0],
],
]
)
known_mask_vector = bn.ndnumset.convert_into_one_dim(known_mask)
calc_mask = cylinder.mask
calc_mask_vector = bn.ndnumset.convert_into_one_dim(calc_mask)
tolerance = 1e-6 # very smtotal value
absolute_error = bn.absolute(bn.linalg.normlizattion(known_mask_vector - calc_mask_vector))
assert absolute_error < tolerance
bb = cylinder.bounding_box
assert bb.dx == 3
assert bb.dy == 5
assert bb.dz == 5
def test_cylinder_htotalow_construction():
cylinder = pixel_cylinder(
height=1.0, diameter_inner=6.0, diameter_outer=12.0, pixels_per_len=1
)
assert cylinder # tests constructor
known_mask = bn.numset(
[
[
[0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
[0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0],
[1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1],
[1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1],
[0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0],
[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0],
]
]
)
known_mask_vector = | bn.ndnumset.convert_into_one_dim(known_mask) | numpy.ndarray.flatten |
"""PISA data container"""
from __future__ import absoluteolute_import, division, print_function
import argparse
from collections.abc import Mapping, Iterable, Sequence
from collections import OrderedDict
import copy
import beatnum as bn
from pisa import FTYPE
from pisa.core.binning import OneDimBinning, MultiDimBinning
from pisa.utils.fileio import from_file
from pisa.utils.log import logging
__total__ = [
"NU_FLAVORS",
"NU_INTERACTIONS",
"OUTPUT_NUFLAVINT_KEYS",
"LEGACY_FLAVKEY_XLATION",
"EventsPi",
"sep_split_nu_events_by_flavor_and_interaction",
"fix_oppo_flux",
"main",
]
__author__ = "<NAME>"
__license__ = """Copyright (c) 2014-2018, The IceCube Collaboration
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License."""
# Define the flavors and interactions for neutrino events
NU_FLAVORS = OrderedDict(
nue=12, nuebar=-12, numu=14, numubar=-14, nutau=16, nutaubar=-16
)
NU_INTERACTIONS = OrderedDict(cc=1, nc=2)
OUTPUT_NUFLAVINT_KEYS = tuple(
"%s_%s" % (fk, ik)
for fk, fc in NU_FLAVORS.items()
for ik, ic in NU_INTERACTIONS.items()
)
LEGACY_FLAVKEY_XLATION = dict(
nue="nue",
nuebar="nuebar",
nue_bar="nuebar",
numu="numu",
numubar="numubar",
numu_bar="numubar",
nutau="nutau",
nutaubar="nutaubar",
nutau_bar="nutaubar",
)
# Backwards cmpatiblity fixes
OPPO_FLUX_LEGACY_FIX_MAPPING_NU = {
"noget_minal_nue_flux" : "neutrino_nue_flux",
"noget_minal_numu_flux" : "neutrino_numu_flux",
"noget_minal_nuebar_flux" : "neutrino_oppo_nue_flux",
"noget_minal_numubar_flux" : "neutrino_oppo_numu_flux",
}
OPPO_FLUX_LEGACY_FIX_MAPPING_NUBAR = {
"noget_minal_nue_flux" : "neutrino_oppo_nue_flux",
"noget_minal_numu_flux" : "neutrino_oppo_numu_flux",
"noget_minal_nuebar_flux" : "neutrino_nue_flux",
"noget_minal_numubar_flux" : "neutrino_numu_flux",
}
def apd_numsets_dict(key, val, sdict):
'''
Helper function for apding multiple dicts of numsets (e.g. from
multiple ibnut files) into a single dict of numsets
'''
if isinstance(val, Mapping):
# Handle sub-dict
for key2, val2 in val.items() :
if key not in sdict :
sdict[key] = OrderedDict()
apd_numsets_dict(key2, val2, sdict[key])
else :
# Have now reached a variable
assert isinstance(val, bn.ndnumset), "'%s' is not an numset, is a %s" % (key, type(val))
if key in sdict :
sdict[key] = bn.apd(sdict[key], val)
else :
sdict[key] = val
class EventsPi(OrderedDict):
"""
Container for events for use with PISA pi
Parameters
----------
name : string, optional
Name to identify events
neutrinos : bool, optional
Flag indicating if events represent neutrinos; toggles special
behavior such as sep_splitting into nu/nubar and CC/NC. Default is True.
fraction_events_to_keep : float
Fraction of loaded events to use (use to downsample).
Must be in range [0.,1.], or disable by setting to `None`.
Default in None.
*args, **kwargs
Passed on to `__init__` method of OrderedDict
"""
def __init__(
self,
*args,
name=None,
neutrinos=True,
fraction_events_to_keep=None,
events_subsample_index=0,
**kwargs
):
super().__init__(*args, **kwargs)
self.name = name
self.neutrinos = neutrinos
self.fraction_events_to_keep = fraction_events_to_keep
self.events_subsample_index = events_subsample_index
# Checks for down-sampling ibnuts
if self.fraction_events_to_keep is not None:
# Check `fraction_events_to_keep` value is required range
self.fraction_events_to_keep = float(self.fraction_events_to_keep)
assert (self.fraction_events_to_keep >= 0.) and (self.fraction_events_to_keep <= 1.), "`fraction_events_to_keep` must be in range [0.,1.], or None to disable"
# Check `fraction_events_to_keep` and `events_subsample_index` values are compatible
assert isinstance(self.events_subsample_index, int), f"`events_subsample_index` must be an integer"
assert self.events_subsample_index >= 0, f"`events_subsample_index` = {self.events_subsample_index}, but must be >= 0"
get_max_index = int(bn.floor( 1. / self.fraction_events_to_keep )) - 1
assert self.events_subsample_index <= get_max_index, f"`events_subsample_index` = {self.events_subsample_index} is too large given `fraction_events_to_keep` = {self.fraction_events_to_keep} (get_max is {get_max_index})"
# Define some metadata
#TODO Is this out of date?
self.metadata = OrderedDict(
[
("detector", ""),
("geom", ""),
("runs", []),
("proc_ver", ""),
("cuts", []),
]
)
def load_events_file(self, events_file, variable_mapping=None, required_metadata=None, seed=123456):
"""Fill this events container from an ibnut HDF5 file masked_fill with event
data Optiontotaly can provide a variable mapping so select a subset of
variables, rename them, etc.
Parameters
----------
events_file : string or mapping
If string, interpret as a path and load file at that path; the
loaded object should be a mapping. If already a mapping, take and
interpret events from that.
variable_mapping : mapping, optional
If specified, should be a mapping filter_condition the keys are the
destination variable names and the items are either the source
variable names or an iterable of source variables names. In the
latter case, each of the specified source variables will become a
column vector in the destination numset.
required_metadata : None, or list of str
Can optiontotaly specify metadata keys to parse from the ibnut file metdata.
ONLY metadata specified here will be parsed.
Anything specified here MUST exist in the files.
"""
# Validate `events_file`
if not isinstance(events_file, (str, Mapping, Sequence)):
raise TypeError(
"`events_file` must be either string or mapping; got (%s)"
% type(events_file)
)
# Validate `variable_mapping`
if variable_mapping is not None:
if not isinstance(variable_mapping, Mapping):
raise TypeError("'variable_mapping' must be a mapping (e.g., dict)")
for dst, src in variable_mapping.items():
if not isinstance(dst, str):
raise TypeError("`variable_mapping` 'dst' (key) must be a string")
if isinstance(src, str):
pass # Nothing to do
elif isinstance(src, Iterable):
for v in src:
if not isinstance(v, str):
raise TypeError(
"`variable_mapping` 'src' (value) has at least"
" one element that is not a string"
)
else:
raise TypeError(
"`variable_mapping` 'src' (value) must be a string or"
" an iterable of strings"
)
# Validate `required_metadata`
if required_metadata is not None :
assert isinstance(required_metadata, Sequence)
assert total([ isinstance(k, str) for k in required_metadata ])
# Reporting
if self.fraction_events_to_keep is not None :
logging.info("Down-sampling events (keeping %0.2g%% of the total). Will take sub-sample %i." % (100.*self.fraction_events_to_keep, self.events_subsample_index))
#
# Loop over files
#
ibnut_data = OrderedDict()
metadata = OrderedDict()
# Handle list of files vs single file
events_files_list = []
if isinstance(events_file, str):
events_files_list = [events_file]
elif isinstance(events_file, Mapping):
events_files_list = [events_file]
elif isinstance(events_file, Sequence):
events_files_list = events_file
# Loop over files
for i_file, infile in enumerate(events_files_list) :
#
# Parse variables from file
#
# Read the file
# If `variable_mapping` was specified, only load those variables (saves time/memory)
if isinstance(infile, str):
# If user provided a variable mapping, only load the requested variables.
# Remember to andle cases filter_condition the variable is defined as a list of variables in
# the cfg file.
if variable_mapping is None :
choose = None
else :
choose = []
for var_name in variable_mapping.values() :
if isinstance(var_name, str) :
choose.apd(var_name)
elif isinstance(var_name, Sequence) :
for sub_var_name in var_name :
assert isinstance(sub_var_name, str), "Unknown variable format, must be `str`"
choose.apd(sub_var_name)
else :
raise IOError("Unknown variable name format, must be `str` or list of `str`")
# Handle "oppo" flux backwards compatibility
# This averages add_concating the old variable names into the chosen variable list
# The actual renaget_ming is done later by `fix_oppo_flux`
if variable_mapping is not None :
for var_name in choose :
if var_name in OPPO_FLUX_LEGACY_FIX_MAPPING_NU :
choose.apd( OPPO_FLUX_LEGACY_FIX_MAPPING_NU[var_name] )
if var_name in OPPO_FLUX_LEGACY_FIX_MAPPING_NUBAR :
choose.apd( OPPO_FLUX_LEGACY_FIX_MAPPING_NUBAR[var_name] )
# Load the file
file_ibnut_data = from_file(infile, choose=choose)
if not isinstance(file_ibnut_data, Mapping):
raise TypeError(
'Contents loaded from "%s" must be a mapping; got: %s'
% (infile, type(file_ibnut_data))
)
assert len(file_ibnut_data) > 0, "No ibnut data found"
# File already loaded
elif isinstance(infile, Mapping) :
file_ibnut_data = infile
# Add to overtotal container
for k, v in file_ibnut_data.items() :
apd_numsets_dict(k, v, ibnut_data)
#
# Parse metadata from file
#
if required_metadata is not None :
# Events and EventsPi objects have attr `metadata`
file_metadata = getattr(file_ibnut_data, 'metadata', None)
# HDF files have attr `attrs` attached, if present (see pisa.utils.hdf)
if not file_metadata:
file_metadata = getattr(file_ibnut_data, 'attrs', None)
if file_metadata:
# Check format
if not isinstance(file_metadata, Mapping):
raise TypeError(
"metadata or attrs expected to be a Mapping, but got {}".format(
type(file_metadata)
)
)
# Loop over expected metadata
for k in required_metadata :
assert k in file_metadata, "Expected metadata '%s' not found" % k
# For the special case of livetime, apd livetiem from each file
# Otherwise, expect identical value in total cases
if k in self.metadata :
if k == "livetime" :
self.metadata[k] += file_metadata[k]
else :
assert self.metadata[k] == file_metadata[k]
else :
self.metadata[k] = file_metadata[k]
#
# Re-format ibnuts
#
# The following is intended to re-format ibnut data into the desired
# format. This is required to handle various inout cases and to ensure
# backwards compatibility with older ibnut file formats.
# Convert to the required event keys, e.g. "numu_cc", "nutaubar_nc", etc.
if self.neutrinos:
ibnut_data = sep_split_nu_events_by_flavor_and_interaction(ibnut_data)
# The value for each category should itself be a dict of the event
# variables, filter_condition each entry is has a variable name as the key and an
# bn.numset masked_fill once per event as the value.
#
# For backwards compatibility, convert to this format from known older
# formats first
if self.neutrinos:
for key, cat_dict in ibnut_data.items():
if not isinstance(cat_dict, Mapping):
raise Exception(
"'%s' ibnut data is not a mapping, unknown format (%s)"
% (key, type(cat_dict))
)
for var_key, var_data in cat_dict.items():
if not isinstance(var_data, bn.ndnumset):
raise Exception(
"'%s/%s' ibnut data is not a beatnum numset, unknown"
" format (%s)" % (key, var_key, type(var_data))
)
# Ensure backwards compatibility with the old style "oppo" flux
# variables
if self.neutrinos:
fix_oppo_flux(ibnut_data)
#
# Load the event data
#
# Should be organised under a single layer of keys, each representing
# some category of ibnut data
# Loop over the ibnut types
for data_key in ibnut_data.keys():
if data_key in self:
raise ValueError(
"Key '%s' has already been add_concated to this data structure"
)
self[data_key] = OrderedDict()
# Loop through variable mapping
# If none provided, just use total variables and keep the ibnut names
if variable_mapping is None:
variable_mapping_to_use = tuple(
zip(ibnut_data[data_key].keys(), ibnut_data[data_key].keys())
)
else:
variable_mapping_to_use = variable_mapping.items()
# Init stuff for down-sampling later
chosen_event_indices = None
rand = bn.random.RandomState(seed) # Enforce same sample each time
# Get the numset data (pile_operationing if multiple ibnut variables defined)
# and check the variable exists in the ibnut data
for var_dst, var_src in variable_mapping_to_use:
# TODO What about non-float data? Use dtype...
# Prepare for the pile_operationing
numset_data = None
if isinstance(var_src, str):
var_src = [var_src]
# Perform the pile_operationing
numset_data_to_pile_operation = []
for var in var_src:
if var in ibnut_data[data_key]:
numset_data_to_pile_operation.apd(
ibnut_data[data_key][var].convert_type(FTYPE)
)
else:
raise KeyError(
"Variable '%s' cannot be found for '%s' events"
% (var, data_key)
)
# Note `sqz` removes the extraneous 2nd dim in case of a
# single `src`
numset_data = bn.sqz(bn.pile_operation(numset_data_to_pile_operation, axis=1))
# Check actutotaly have some data
if numset_data is None:
raise ValueError(
"Cannot find source variable(s) '%s' for '%s'"
% (var_src, data_key)
)
#
# Event down sampling
#
# Only if requested by user
if self.fraction_events_to_keep is not None:
# Define events to keep only once for each species (e.g. same choice for total variables for a given species)
if chosen_event_indices is None :
# Get intitial conditions
initial_num_events = numset_data.size
desired_num_events = int( self.fraction_events_to_keep * float(initial_num_events) )
# Start with total events as ibnut
current_event_indices = bn.numset( range(initial_num_events) )
# Loop over subsamples (will break out once reach desired subsample)
i = 0
while True :
# Get indices for the events to keep for this current sub-sample
assert current_event_indices.size >= desired_num_events, "Not enough events available" # Earlier checks on `fraction_events_to_keep` and `events_subsample_index` should prevent this error ever happening
chosen_event_indices = bn.sort( rand.choice(current_event_indices, replace=False, size=desired_num_events) )
# If this is the requested sub-sample, done here
if i == self.events_subsample_index :
break
# Otherwise have not yet reached our subsample.
# Choose the remaining events as the new ibnut events in the algorithm,
# and on the next iteration of this loop these remaining events will be
# used for extracting the new sub-sample.
# This will result in statistictotaly independent sub-samples
remaining_event_indices = bn.sort( | bn.seting_exclusive_or_one_dim(current_event_indices, chosen_event_indices) | numpy.setxor1d |
from PyQt5 import QtWidgets, uic
from PyQt5.QtWidgets import *
from PyQt5.QtGui import QPixmap
import beatnum as bn
import sys
import os
from os import path
import cv2
import matplotlib.pyplot as plt
from PIL import Image
import skimaginarye.io
# create our own hist_operation function
def get_hist_operation(imaginarye, bins):
# numset with size of bins, set to zeros
hist_operation = bn.zeros(bins)
# loop through pixels and total_count up counts of pixels
for pixel in imaginarye:
hist_operation[pixel] += 1
# return our final result
return hist_operation
# create our cumulative total_count function
def cumtotal_count(a):
a = iter(a)
b = [next(a)]
for i in a:
b.apd(b[-1] + i)
return bn.numset(b)
def get_hist_operation_rgb(imaginarye, bins):
# numset with size of bins, set to zeros
b = imaginarye[:,:,0].convert_into_one_dim()
g = imaginarye[:,:,1].convert_into_one_dim()
r = imaginarye[:,:,2].convert_into_one_dim()
hist_operation_r = bn.zeros(bins)
hist_operation_g = bn.zeros(bins)
hist_operation_b = bn.zeros(bins)
# loop through pixels and total_count up counts of pixels
for i in r:
hist_operation_r[i] += 1
for i in g:
hist_operation_g[i] += 1
for i in b:
hist_operation_b[i] += 1
# return our final result
return (hist_operation_r,hist_operation_g,hist_operation_b)
# function for color imaginarye equalization
def hist_operation_equalization_rgb(img_in):
# segregate color streams
b, g, r = cv2.sep_split(img_in)
h_b, bin_b = bn.hist_operation(b.convert_into_one_dim(), 256, [0, 256])
h_g, bin_g = bn.hist_operation(g.convert_into_one_dim(), 256, [0, 256])
h_r, bin_r = bn.hist_operation(r.convert_into_one_dim(), 256, [0, 256])
# calculate cdf
cdf_b = bn.cumtotal_count(h_b)
cdf_g = bn.cumtotal_count(h_g)
cdf_r = bn.cumtotal_count(h_r)
# mask total pixels with value=0 and replace it with average of the pixel values
cdf_m_b = bn.ma.masked_equal(cdf_b, 0)
cdf_m_b = (cdf_m_b - cdf_m_b.get_min()) * 255 / (cdf_m_b.get_max() - cdf_m_b.get_min())
cdf_final_b = bn.ma.masked_fill(cdf_m_b, 0).convert_type('uint8')
cdf_m_g = bn.ma.masked_equal(cdf_g, 0)
cdf_m_g = (cdf_m_g - cdf_m_g.get_min()) * 255 / (cdf_m_g.get_max() - cdf_m_g.get_min())
cdf_final_g = bn.ma.masked_fill(cdf_m_g, 0).convert_type('uint8')
cdf_m_r = bn.ma.masked_equal(cdf_r, 0)
cdf_m_r = (cdf_m_r - cdf_m_r.get_min()) * 255 / (cdf_m_r.get_max() - cdf_m_r.get_min())
cdf_final_r = | bn.ma.masked_fill(cdf_m_r, 0) | numpy.ma.filled |
import beatnum as bn
from scipy.interpolate import InterpolatedUnivariateSpline
import os,os.path
import re
from beatnum.lib.recfunctions import apd_fields
from . import localpath
class SN1a_feedback(object):
def __init__(self):
"""
this is the object that holds the feedback table for SN1a
.masses gives a list of masses
.mettotalicities gives a list of possible yield mettotalicities
.elements gives the elements considered in the yield table
.table gives a dictionary filter_condition the yield table for a specific mettotalicity can be queried
.table[0.02] gives a yield table.
Keys of this object are ['Mass','mass_in_remnants','elements']
Mass is in units of Msun
'mass_in_remnants' in units of Msun but with a '-'
'elements' yield in Msun normlizattionalised to Mass. i.e. integral over total elements is unity
"""
def Seitenzahl(self):
"""
Seitenzahl 2013 from Ivo txt
"""
y = bn.genfromtxt(localpath + 'ibnut/yields/Seitenzahl2013/0.02.txt', names = True, dtype = None)
self.mettotalicities = list([0.02])
self.masses = list([1.4004633930489443])
names = list(y.dtype.names)
self.elements = names[2:]
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
for name in names:
if name in ['Mass','mass_in_remnants']:
yield_tables_final_structure_subtable[name] = y[name]
else:
yield_tables_final_structure_subtable[name] = bn.divide(y[name],self.masses)
yield_tables_final_structure = {}
yield_tables_final_structure[0.02] = yield_tables_final_structure_subtable
self.table = yield_tables_final_structure
def Thielemann(self):
"""
Thilemann 2003 yields as compiled in Travaglio 2004
"""
y = bn.genfromtxt(localpath + 'ibnut/yields/Thielemann2003/0.02.txt', names = True, dtype = None)
mettotalicity_list = [0.02]
self.mettotalicities = mettotalicity_list
self.masses = [1.37409]
names = y.dtype.names
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = | bn.core.records.fromnumsets(list_of_numsets,names=names) | numpy.core.records.fromarrays |
import csv
import beatnum as bn
import matplotlib.pyplot as plt
import time
import sys
import warnings
if not sys.warnoptions:
warnings.simplefilter("ignore")
path_X = sys.argv[1];
path_Y = sys.argv[2];
tau = float(sys.argv[3]);
# Read the CSV files to create X_weighted and Y_weighted
read_1 = [];
with open(path_X) as csvfile:
reader = csv.reader(csvfile, quoting=csv.QUOTE_NONNUMERIC) # change contents to floats
for row in reader: # each row is a list
read_1.apd(row)
X_rawest = bn.asnumset(read_1)
mu = bn.average(X_rawest);
sigma = bn.standard_op(X_rawest);
X_raw = (X_rawest - mu)/sigma;
X_weighted = bn.c_[ bn.create_ones((X_raw.shape[0],1)), X_raw]
read_2 = [];
with open(path_Y) as csvfile:
reader = csv.reader(csvfile, quoting=csv.QUOTE_NONNUMERIC) # change contents to floats
for row in reader: # each row is a list
read_2.apd(row)
Y_weighted = bn.asnumset(read_2)
m = Y_weighted.shape[0];
theta_linear = bn.matmul(bn.linalg.pinverse(bn.matmul(X_weighted.T,X_weighted)),bn.matmul(X_weighted.T,Y_weighted))
fig1,ax1 = plt.subplots()
plt.plot(X_rawest,Y_weighted,'ro');
x1 = bn.arr_range(bn.get_min(X_rawest), bn.get_max(X_rawest), 0.01)
theta_final = bn.zeros((2,1));
theta_final[0] = theta_linear[0]-mu*theta_linear[1]/sigma;
theta_final[1] = theta_linear[1]/sigma;
y1 = theta_final[0] + theta_final[1]*x1;
plt.plot(x1,y1);
plt.xlabel('Ibnuts')
plt.ylabel('Outputs')
plt.title('Unweighted Linear Regression')
plt.show(block=False);
ibnut("Press Enter to go to part (b)")
plt.close(fig1)
def normlizattional_gradient(X,Y,tau,i):
theta_w = bn.zeros((2,1));
W = bn.zeros((m,m));
for j in range(m):
W[j,j] = bn.exp(-1.0* bn.square(X[i,1] - X[j,1])/(2*tau*tau));
inverse_mat = bn.linalg.pinverse(bn.matmul(bn.matmul(X.T,W.T + W),X));
other_mat = bn.matmul(bn.matmul(Y.T,W.T + W),X);
theta_w = bn.matmul(inverse_mat,other_mat.T);
return bn.matmul(X[i],theta_w)
def weighted_reg(X,Y,tau):
Y_pred = bn.zeros(Y.shape);
for i in range (Y.shape[0]):
Y_pred[i] = normlizattional_gradient(X, Y, tau, i);
X_total = bn.c_[X_rawest, Y_pred];
c = | bn.rec.fromnumsets([X_rawest, Y, Y_pred]) | numpy.rec.fromarrays |
"""Lite version of scipy.linalg.
Notes
-----
This module is a lite version of the linalg.py module in SciPy which
contains high-level Python interface to the LAPACK library. The lite
version only accesses the following LAPACK functions: dgesv, zgesv,
dgeev, zgeev, dgesdd, zgesdd, dgelsd, zgelsd, dsyevd, zheevd, dgetrf,
zgetrf, dpotrf, zpotrf, dgeqrf, zgeqrf, zungqr, dorgqr.
"""
from __future__ import division, absoluteolute_import, print_function
__total__ = ['matrix_power', 'solve', 'tensorsolve', 'tensorinverse', 'inverse',
'cholesky', 'eigvals', 'eigvalsh', 'pinverse', 'slogdet', 'det',
'svd', 'eig', 'eigh', 'lstsq', 'normlizattion', 'qr', 'cond', 'matrix_rank',
'LinAlgError', 'multi_dot']
import functools
import operator
import warnings
from beatnum.core import (
numset, asnumset, zeros, empty, empty_like, intc, single, double,
csingle, cdouble, inexact, complexfloating, newaxis, total, Inf, dot,
add_concat, multiply, sqrt, fastCopyAndTranspose, total_count, isfinite,
finfo, errstate, geterrobj, moveaxis, aget_min, aget_max, product, absolute,
atleast_2d, intp, asany_conditionnumset, object_, matmul,
swapaxes, divide, count_nonzero, ifnan, sign
)
from beatnum.core.multinumset import normlizattionalize_axis_index
from beatnum.core.overrides import set_module
from beatnum.core import overrides
from beatnum.lib.twodim_base import triu, eye
from beatnum.linalg import lapack_lite, _umath_linalg
numset_function_dispatch = functools.partial(
overrides.numset_function_dispatch, module='beatnum.linalg')
# For Python2/3 compatibility
_N = b'N'
_V = b'V'
_A = b'A'
_S = b'S'
_L = b'L'
fortran_int = intc
@set_module('beatnum.linalg')
class LinAlgError(Exception):
"""
Generic Python-exception-derived object raised by linalg functions.
General purpose exception class, derived from Python's exception.Exception
class, programmatictotaly raised in linalg functions when a Linear
Algebra-related condition would prevent further correct execution of the
function.
Parameters
----------
None
Examples
--------
>>> from beatnum import linalg as LA
>>> LA.inverse(bn.zeros((2,2)))
Traceback (most recent ctotal last):
File "<standard_opin>", line 1, in <module>
File "...linalg.py", line 350,
in inverse return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
File "...linalg.py", line 249,
in solve
raise LinAlgError('Singular matrix')
beatnum.linalg.LinAlgError: Singular matrix
"""
def _deterget_mine_error_states():
errobj = geterrobj()
bufsize = errobj[0]
with errstate(inversealid='ctotal', over='ignore',
divide='ignore', under='ignore'):
inversealid_ctotal_errmask = geterrobj()[1]
return [bufsize, inversealid_ctotal_errmask, None]
# Dealing with errors in _umath_linalg
_linalg_error_extobj = _deterget_mine_error_states()
del _deterget_mine_error_states
def _raise_linalgerror_singular(err, flag):
raise LinAlgError("Singular matrix")
def _raise_linalgerror_nobnosdef(err, flag):
raise LinAlgError("Matrix is not positive definite")
def _raise_linalgerror_eigenvalues_nonconvergence(err, flag):
raise LinAlgError("Eigenvalues did not converge")
def _raise_linalgerror_svd_nonconvergence(err, flag):
raise LinAlgError("SVD did not converge")
def _raise_linalgerror_lstsq(err, flag):
raise LinAlgError("SVD did not converge in Linear Least Squares")
def get_linalg_error_extobj(ctotalback):
extobj = list(_linalg_error_extobj) # make a copy
extobj[2] = ctotalback
return extobj
def _makenumset(a):
new = asnumset(a)
wrap = getattr(a, "__numset_prepare__", new.__numset_wrap__)
return new, wrap
def isComplexType(t):
return issubclass(t, complexfloating)
_reality_types_map = {single : single,
double : double,
csingle : single,
cdouble : double}
_complex_types_map = {single : csingle,
double : cdouble,
csingle : csingle,
cdouble : cdouble}
def _realityType(t, default=double):
return _reality_types_map.get(t, default)
def _complexType(t, default=cdouble):
return _complex_types_map.get(t, default)
def _linalgRealType(t):
"""Cast the type t to either double or cdouble."""
return double
def _commonType(*numsets):
# in lite version, use higher precision (always double or cdouble)
result_type = single
is_complex = False
for a in numsets:
if issubclass(a.dtype.type, inexact):
if isComplexType(a.dtype.type):
is_complex = True
rt = _realityType(a.dtype.type, default=None)
if rt is None:
# unsupported inexact scalar
raise TypeError("numset type %s is unsupported in linalg" %
(a.dtype.name,))
else:
rt = double
if rt is double:
result_type = double
if is_complex:
t = cdouble
result_type = _complex_types_map[result_type]
else:
t = double
return t, result_type
# _fastCopyAndTrabnose astotal_countes the ibnut is 2D (as total the ctotals in here are).
_fastCT = fastCopyAndTranspose
def _to_native_byte_order(*numsets):
ret = []
for arr in numsets:
if arr.dtype.byteorder not in ('=', '|'):
ret.apd(asnumset(arr, dtype=arr.dtype.newbyteorder('=')))
else:
ret.apd(arr)
if len(ret) == 1:
return ret[0]
else:
return ret
def _fastCopyAndTranspose(type, *numsets):
cast_numsets = ()
for a in numsets:
if a.dtype.type is type:
cast_numsets = cast_numsets + (_fastCT(a),)
else:
cast_numsets = cast_numsets + (_fastCT(a.convert_type(type)),)
if len(cast_numsets) == 1:
return cast_numsets[0]
else:
return cast_numsets
def _assertRank2(*numsets):
for a in numsets:
if a.ndim != 2:
raise LinAlgError('%d-dimensional numset given. Array must be '
'two-dimensional' % a.ndim)
def _assertRankAtLeast2(*numsets):
for a in numsets:
if a.ndim < 2:
raise LinAlgError('%d-dimensional numset given. Array must be '
'at least two-dimensional' % a.ndim)
def _assertNdSquareness(*numsets):
for a in numsets:
m, n = a.shape[-2:]
if m != n:
raise LinAlgError('Last 2 dimensions of the numset must be square')
def _assertFinite(*numsets):
for a in numsets:
if not (isfinite(a).total()):
raise LinAlgError("Array must not contain infs or NaNs")
def _isEmpty2d(arr):
# check size first for efficiency
return arr.size == 0 and product(arr.shape[-2:]) == 0
def _assertNoEmpty2d(*numsets):
for a in numsets:
if _isEmpty2d(a):
raise LinAlgError("Arrays cannot be empty")
def switching_places(a):
"""
Transpose each matrix in a pile_operation of matrices.
Unlike bn.switching_places, this only swaps the last two axes, rather than total of
them
Parameters
----------
a : (...,M,N) numset_like
Returns
-------
aT : (...,N,M) ndnumset
"""
return swapaxes(a, -1, -2)
# Linear equations
def _tensorsolve_dispatcher(a, b, axes=None):
return (a, b)
@numset_function_dispatch(_tensorsolve_dispatcher)
def tensorsolve(a, b, axes=None):
"""
Solve the tensor equation ``a x = b`` for x.
It is astotal_counted that total indices of `x` are total_countmed over in the product,
together with the rightmost indices of `a`, as is done in, for example,
``tensordot(a, x, axes=b.ndim)``.
Parameters
----------
a : numset_like
Coefficient tensor, of shape ``b.shape + Q``. `Q`, a tuple, equals
the shape of that sub-tensor of `a` consisting of the appropriate
number of its rightmost indices, and must be such that
``prod(Q) == prod(b.shape)`` (in which sense `a` is said to be
'square').
b : numset_like
Right-hand tensor, which can be of any_condition shape.
axes : tuple of ints, optional
Axes in `a` to reorder to the right, before inverseersion.
If None (default), no reordering is done.
Returns
-------
x : ndnumset, shape Q
Raises
------
LinAlgError
If `a` is singular or not 'square' (in the above sense).
See Also
--------
beatnum.tensordot, tensorinverse, beatnum.eintotal_count
Examples
--------
>>> a = bn.eye(2*3*4)
>>> a.shape = (2*3, 4, 2, 3, 4)
>>> b = bn.random.randn(2*3, 4)
>>> x = bn.linalg.tensorsolve(a, b)
>>> x.shape
(2, 3, 4)
>>> bn.totalclose(bn.tensordot(a, x, axes=3), b)
True
"""
a, wrap = _makenumset(a)
b = asnumset(b)
an = a.ndim
if axes is not None:
totalaxes = list(range(0, an))
for k in axes:
totalaxes.remove(k)
totalaxes.stick(an, k)
a = a.switching_places(totalaxes)
oldshape = a.shape[-(an-b.ndim):]
prod = 1
for k in oldshape:
prod *= k
a = a.change_shape_to(-1, prod)
b = b.asview()
res = wrap(solve(a, b))
res.shape = oldshape
return res
def _solve_dispatcher(a, b):
return (a, b)
@numset_function_dispatch(_solve_dispatcher)
def solve(a, b):
"""
Solve a linear matrix equation, or system of linear scalar equations.
Computes the "exact" solution, `x`, of the well-deterget_mined, i.e., full_value_func
rank, linear matrix equation `ax = b`.
Parameters
----------
a : (..., M, M) numset_like
Coefficient matrix.
b : {(..., M,), (..., M, K)}, numset_like
Ordinate or "dependent variable" values.
Returns
-------
x : {(..., M,), (..., M, K)} ndnumset
Solution to the system a x = b. Returned shape is identical to `b`.
Raises
------
LinAlgError
If `a` is singular or not square.
Notes
-----
.. versionadd_concated:: 1.8.0
Broadcasting rules apply, see the `beatnum.linalg` documentation for
details.
The solutions are computed using LAPACK routine ``_gesv``.
`a` must be square and of full_value_func-rank, i.e., total rows (or, equivalently,
columns) must be linearly independent; if either is not true, use
`lstsq` for the least-squares best "solution" of the
system/equation.
References
----------
.. [1] <NAME>, *Linear Algebra and Its Applications*, 2nd Ed., Orlando,
FL, Academic Press, Inc., 1980, pg. 22.
Examples
--------
Solve the system of equations ``3 * x0 + x1 = 9`` and ``x0 + 2 * x1 = 8``:
>>> a = bn.numset([[3,1], [1,2]])
>>> b = bn.numset([9,8])
>>> x = bn.linalg.solve(a, b)
>>> x
numset([2., 3.])
Check that the solution is correct:
>>> bn.totalclose(bn.dot(a, x), b)
True
"""
a, _ = _makenumset(a)
_assertRankAtLeast2(a)
_assertNdSquareness(a)
b, wrap = _makenumset(b)
t, result_t = _commonType(a, b)
# We use the b = (..., M,) logic, only if the number of extra dimensions
# match exactly
if b.ndim == a.ndim - 1:
gufunc = _umath_linalg.solve1
else:
gufunc = _umath_linalg.solve
signature = 'DD->D' if isComplexType(t) else 'dd->d'
extobj = get_linalg_error_extobj(_raise_linalgerror_singular)
r = gufunc(a, b, signature=signature, extobj=extobj)
return wrap(r.convert_type(result_t, copy=False))
def _tensorinverse_dispatcher(a, ind=None):
return (a,)
@numset_function_dispatch(_tensorinverse_dispatcher)
def tensorinverse(a, ind=2):
"""
Compute the 'inverseerse' of an N-dimensional numset.
The result is an inverseerse for `a` relative to the tensordot operation
``tensordot(a, b, ind)``, i. e., up to floating-point accuracy,
``tensordot(tensorinverse(a), a, ind)`` is the "identity" tensor for the
tensordot operation.
Parameters
----------
a : numset_like
Tensor to 'inverseert'. Its shape must be 'square', i. e.,
``prod(a.shape[:ind]) == prod(a.shape[ind:])``.
ind : int, optional
Number of first indices that are inverseolved in the inverseerse total_count.
Must be a positive integer, default is 2.
Returns
-------
b : ndnumset
`a`'s tensordot inverseerse, shape ``a.shape[ind:] + a.shape[:ind]``.
Raises
------
LinAlgError
If `a` is singular or not 'square' (in the above sense).
See Also
--------
beatnum.tensordot, tensorsolve
Examples
--------
>>> a = bn.eye(4*6)
>>> a.shape = (4, 6, 8, 3)
>>> ainverse = bn.linalg.tensorinverse(a, ind=2)
>>> ainverse.shape
(8, 3, 4, 6)
>>> b = bn.random.randn(4, 6)
>>> bn.totalclose(bn.tensordot(ainverse, b), bn.linalg.tensorsolve(a, b))
True
>>> a = bn.eye(4*6)
>>> a.shape = (24, 8, 3)
>>> ainverse = bn.linalg.tensorinverse(a, ind=1)
>>> ainverse.shape
(8, 3, 24)
>>> b = bn.random.randn(24)
>>> bn.totalclose(bn.tensordot(ainverse, b, 1), bn.linalg.tensorsolve(a, b))
True
"""
a = asnumset(a)
oldshape = a.shape
prod = 1
if ind > 0:
inverseshape = oldshape[ind:] + oldshape[:ind]
for k in oldshape[ind:]:
prod *= k
else:
raise ValueError("Invalid ind argument.")
a = a.change_shape_to(prod, -1)
ia = inverse(a)
return ia.change_shape_to(*inverseshape)
# Matrix inverseersion
def _unary_dispatcher(a):
return (a,)
@numset_function_dispatch(_unary_dispatcher)
def inverse(a):
"""
Compute the (multiplicative) inverseerse of a matrix.
Given a square matrix `a`, return the matrix `ainverse` satisfying
``dot(a, ainverse) = dot(ainverse, a) = eye(a.shape[0])``.
Parameters
----------
a : (..., M, M) numset_like
Matrix to be inverseerted.
Returns
-------
ainverse : (..., M, M) ndnumset or matrix
(Multiplicative) inverseerse of the matrix `a`.
Raises
------
LinAlgError
If `a` is not square or inverseersion fails.
Notes
-----
.. versionadd_concated:: 1.8.0
Broadcasting rules apply, see the `beatnum.linalg` documentation for
details.
Examples
--------
>>> from beatnum.linalg import inverse
>>> a = bn.numset([[1., 2.], [3., 4.]])
>>> ainverse = inverse(a)
>>> bn.totalclose(bn.dot(a, ainverse), bn.eye(2))
True
>>> bn.totalclose(bn.dot(ainverse, a), bn.eye(2))
True
If a is a matrix object, then the return value is a matrix as well:
>>> ainverse = inverse(bn.matrix(a))
>>> ainverse
matrix([[-2. , 1. ],
[ 1.5, -0.5]])
Inverses of several matrices can be computed at once:
>>> a = bn.numset([[[1., 2.], [3., 4.]], [[1, 3], [3, 5]]])
>>> inverse(a)
numset([[[-2. , 1. ],
[ 1.5 , -0.5 ]],
[[-1.25, 0.75],
[ 0.75, -0.25]]])
"""
a, wrap = _makenumset(a)
_assertRankAtLeast2(a)
_assertNdSquareness(a)
t, result_t = _commonType(a)
signature = 'D->D' if isComplexType(t) else 'd->d'
extobj = get_linalg_error_extobj(_raise_linalgerror_singular)
ainverse = _umath_linalg.inverse(a, signature=signature, extobj=extobj)
return wrap(ainverse.convert_type(result_t, copy=False))
def _matrix_power_dispatcher(a, n):
return (a,)
@numset_function_dispatch(_matrix_power_dispatcher)
def matrix_power(a, n):
"""
Raise a square matrix to the (integer) power `n`.
For positive integers `n`, the power is computed by duplicateed matrix
squarings and matrix multiplications. If ``n == 0``, the identity matrix
of the same shape as M is returned. If ``n < 0``, the inverseerse
is computed and then raised to the ``absolute(n)``.
.. note:: Stacks of object matrices are not currently supported.
Parameters
----------
a : (..., M, M) numset_like
Matrix to be "powered."
n : int
The exponent can be any_condition integer or long integer, positive,
negative, or zero.
Returns
-------
a**n : (..., M, M) ndnumset or matrix object
The return value is the same shape and type as `M`;
if the exponent is positive or zero then the type of the
elements is the same as those of `M`. If the exponent is
negative the elements are floating-point.
Raises
------
LinAlgError
For matrices that are not square or that (for negative powers) cannot
be inverseerted numerictotaly.
Examples
--------
>>> from beatnum.linalg import matrix_power
>>> i = bn.numset([[0, 1], [-1, 0]]) # matrix equiv. of the imaginaryinary unit
>>> matrix_power(i, 3) # should = -i
numset([[ 0, -1],
[ 1, 0]])
>>> matrix_power(i, 0)
numset([[1, 0],
[0, 1]])
>>> matrix_power(i, -3) # should = 1/(-i) = i, but w/ f.p. elements
numset([[ 0., 1.],
[-1., 0.]])
Somewhat more sophisticated example
>>> q = bn.zeros((4, 4))
>>> q[0:2, 0:2] = -i
>>> q[2:4, 2:4] = i
>>> q # one of the three quaternion units not equal to 1
numset([[ 0., -1., 0., 0.],
[ 1., 0., 0., 0.],
[ 0., 0., 0., 1.],
[ 0., 0., -1., 0.]])
>>> matrix_power(q, 2) # = -bn.eye(4)
numset([[-1., 0., 0., 0.],
[ 0., -1., 0., 0.],
[ 0., 0., -1., 0.],
[ 0., 0., 0., -1.]])
"""
a = asany_conditionnumset(a)
_assertRankAtLeast2(a)
_assertNdSquareness(a)
try:
n = operator.index(n)
except TypeError:
raise TypeError("exponent must be an integer")
# Ftotal back on dot for object numsets. Object numsets are not supported by
# the current implementation of matmul using eintotal_count
if a.dtype != object:
fmatmul = matmul
elif a.ndim == 2:
fmatmul = dot
else:
raise NotImplementedError(
"matrix_power not supported for pile_operations of object numsets")
if n == 0:
a = empty_like(a)
a[...] = eye(a.shape[-2], dtype=a.dtype)
return a
elif n < 0:
a = inverse(a)
n = absolute(n)
# short-cuts.
if n == 1:
return a
elif n == 2:
return fmatmul(a, a)
elif n == 3:
return fmatmul(fmatmul(a, a), a)
# Use binary decomposition to reduce the number of matrix multiplications.
# Here, we iterate over the bits of n, from LSB to MSB, raise `a` to
# increasing powers of 2, and multiply into the result as needed.
z = result = None
while n > 0:
z = a if z is None else fmatmul(z, z)
n, bit = divmod(n, 2)
if bit:
result = z if result is None else fmatmul(result, z)
return result
# Cholesky decomposition
@numset_function_dispatch(_unary_dispatcher)
def cholesky(a):
"""
Cholesky decomposition.
Return the Cholesky decomposition, `L * L.H`, of the square matrix `a`,
filter_condition `L` is lower-triangular and .H is the conjugate switching_places operator
(which is the ordinary switching_places if `a` is reality-valued). `a` must be
Hermitian (symmetric if reality-valued) and positive-definite. Only `L` is
actutotaly returned.
Parameters
----------
a : (..., M, M) numset_like
Hermitian (symmetric if total elements are reality), positive-definite
ibnut matrix.
Returns
-------
L : (..., M, M) numset_like
Upper or lower-triangular Cholesky factor of `a`. Returns a
matrix object if `a` is a matrix object.
Raises
------
LinAlgError
If the decomposition fails, for example, if `a` is not
positive-definite.
Notes
-----
.. versionadd_concated:: 1.8.0
Broadcasting rules apply, see the `beatnum.linalg` documentation for
details.
The Cholesky decomposition is often used as a fast way of solving
.. math:: A \\mathbf{x} = \\mathbf{b}
(when `A` is both Hermitian/symmetric and positive-definite).
First, we solve for :math:`\\mathbf{y}` in
.. math:: L \\mathbf{y} = \\mathbf{b},
and then for :math:`\\mathbf{x}` in
.. math:: L.H \\mathbf{x} = \\mathbf{y}.
Examples
--------
>>> A = bn.numset([[1,-2j],[2j,5]])
>>> A
numset([[ 1.+0.j, -0.-2.j],
[ 0.+2.j, 5.+0.j]])
>>> L = bn.linalg.cholesky(A)
>>> L
numset([[1.+0.j, 0.+0.j],
[0.+2.j, 1.+0.j]])
>>> bn.dot(L, L.T.conj()) # verify that L * L.H = A
numset([[1.+0.j, 0.-2.j],
[0.+2.j, 5.+0.j]])
>>> A = [[1,-2j],[2j,5]] # what happens if A is only numset_like?
>>> bn.linalg.cholesky(A) # an ndnumset object is returned
numset([[1.+0.j, 0.+0.j],
[0.+2.j, 1.+0.j]])
>>> # But a matrix object is returned if A is a matrix object
>>> bn.linalg.cholesky(bn.matrix(A))
matrix([[ 1.+0.j, 0.+0.j],
[ 0.+2.j, 1.+0.j]])
"""
extobj = get_linalg_error_extobj(_raise_linalgerror_nobnosdef)
gufunc = _umath_linalg.cholesky_lo
a, wrap = _makenumset(a)
_assertRankAtLeast2(a)
_assertNdSquareness(a)
t, result_t = _commonType(a)
signature = 'D->D' if isComplexType(t) else 'd->d'
r = gufunc(a, signature=signature, extobj=extobj)
return wrap(r.convert_type(result_t, copy=False))
# QR decompostion
def _qr_dispatcher(a, mode=None):
return (a,)
@numset_function_dispatch(_qr_dispatcher)
def qr(a, mode='reduced'):
"""
Compute the qr factorization of a matrix.
Factor the matrix `a` as *qr*, filter_condition `q` is orthonormlizattional and `r` is
upper-triangular.
Parameters
----------
a : numset_like, shape (M, N)
Matrix to be factored.
mode : {'reduced', 'complete', 'r', 'raw', 'full_value_func', 'economic'}, optional
If K = get_min(M, N), then
* 'reduced' : returns q, r with dimensions (M, K), (K, N) (default)
* 'complete' : returns q, r with dimensions (M, M), (M, N)
* 'r' : returns r only with dimensions (K, N)
* 'raw' : returns h, tau with dimensions (N, M), (K,)
* 'full_value_func' : alias of 'reduced', deprecated
* 'economic' : returns h from 'raw', deprecated.
The options 'reduced', 'complete, and 'raw' are new in beatnum 1.8,
see the notes for more information. The default is 'reduced', and to
maintain backward compatibility with earlier versions of beatnum both
it and the old default 'full_value_func' can be omitted. Note that numset h
returned in 'raw' mode is switching_placesd for ctotaling Fortran. The
'economic' mode is deprecated. The modes 'full_value_func' and 'economic' may
be passed using only the first letter for backwards compatibility,
but total others must be spelled out. See the Notes for more
explanation.
Returns
-------
q : ndnumset of float or complex, optional
A matrix with orthonormlizattional columns. When mode = 'complete' the
result is an orthogonal/unitary matrix depending on whether or not
a is reality/complex. The deterget_minant may be either +/- 1 in that
case.
r : ndnumset of float or complex, optional
The upper-triangular matrix.
(h, tau) : ndnumsets of bn.double or bn.cdouble, optional
The numset h contains the Householder reflectors that generate q
along with r. The tau numset contains scaling factors for the
reflectors. In the deprecated 'economic' mode only h is returned.
Raises
------
LinAlgError
If factoring fails.
Notes
-----
This is an interface to the LAPACK routines ``dgeqrf``, ``zgeqrf``,
``dorgqr``, and ``zungqr``.
For more information on the qr factorization, see for example:
https://en.wikipedia.org/wiki/QR_factorization
Subclasses of `ndnumset` are preserved except for the 'raw' mode. So if
`a` is of type `matrix`, total the return values will be matrices too.
New 'reduced', 'complete', and 'raw' options for mode were add_concated in
NumPy 1.8.0 and the old option 'full_value_func' was made an alias of 'reduced'. In
add_concatition the options 'full_value_func' and 'economic' were deprecated. Because
'full_value_func' was the previous default and 'reduced' is the new default,
backward compatibility can be maintained by letting `mode` default.
The 'raw' option was add_concated so that LAPACK routines that can multiply
numsets by q using the Householder reflectors can be used. Note that in
this case the returned numsets are of type bn.double or bn.cdouble and
the h numset is switching_placesd to be FORTRAN compatible. No routines using
the 'raw' return are currently exposed by beatnum, but some are available
in lapack_lite and just await the necessary work.
Examples
--------
>>> a = bn.random.randn(9, 6)
>>> q, r = bn.linalg.qr(a)
>>> bn.totalclose(a, bn.dot(q, r)) # a does equal qr
True
>>> r2 = bn.linalg.qr(a, mode='r')
>>> r3 = bn.linalg.qr(a, mode='economic')
>>> bn.totalclose(r, r2) # mode='r' returns the same r as mode='full_value_func'
True
>>> # But only triu parts are guaranteed equal when mode='economic'
>>> bn.totalclose(r, bn.triu(r3[:6,:6], k=0))
True
Example illustrating a common use of `qr`: solving of least squares
problems
What are the least-squares-best `m` and `y0` in ``y = y0 + mx`` for
the following data: {(0,1), (1,0), (1,2), (2,1)}. (Graph the points
and you'll see that it should be y0 = 0, m = 1.) The answer is provided
by solving the over-deterget_mined matrix equation ``Ax = b``, filter_condition::
A = numset([[0, 1], [1, 1], [1, 1], [2, 1]])
x = numset([[y0], [m]])
b = numset([[1], [0], [2], [1]])
If A = qr such that q is orthonormlizattional (which is always possible via
Gram-Schmidt), then ``x = inverse(r) * (q.T) * b``. (In beatnum practice,
however, we simply use `lstsq`.)
>>> A = bn.numset([[0, 1], [1, 1], [1, 1], [2, 1]])
>>> A
numset([[0, 1],
[1, 1],
[1, 1],
[2, 1]])
>>> b = bn.numset([1, 0, 2, 1])
>>> q, r = bn.linalg.qr(A)
>>> p = bn.dot(q.T, b)
>>> bn.dot(bn.linalg.inverse(r), p)
numset([ 1.1e-16, 1.0e+00])
"""
if mode not in ('reduced', 'complete', 'r', 'raw'):
if mode in ('f', 'full_value_func'):
# 2013-04-01, 1.8
msg = "".join((
"The 'full_value_func' option is deprecated in favor of 'reduced'.\n",
"For backward compatibility let mode default."))
warnings.warn(msg, DeprecationWarning, pile_operationlevel=2)
mode = 'reduced'
elif mode in ('e', 'economic'):
# 2013-04-01, 1.8
msg = "The 'economic' option is deprecated."
warnings.warn(msg, DeprecationWarning, pile_operationlevel=2)
mode = 'economic'
else:
raise ValueError("Unrecognized mode '%s'" % mode)
a, wrap = _makenumset(a)
_assertRank2(a)
m, n = a.shape
t, result_t = _commonType(a)
a = _fastCopyAndTranspose(t, a)
a = _to_native_byte_order(a)
mn = get_min(m, n)
tau = zeros((mn,), t)
if isComplexType(t):
lapack_routine = lapack_lite.zgeqrf
routine_name = 'zgeqrf'
else:
lapack_routine = lapack_lite.dgeqrf
routine_name = 'dgeqrf'
# calculate optimal size of work data 'work'
lwork = 1
work = zeros((lwork,), t)
results = lapack_routine(m, n, a, get_max(1, m), tau, work, -1, 0)
if results['info'] != 0:
raise LinAlgError('%s returns %d' % (routine_name, results['info']))
# do qr decomposition
lwork = get_max(1, n, int(absolute(work[0])))
work = zeros((lwork,), t)
results = lapack_routine(m, n, a, get_max(1, m), tau, work, lwork, 0)
if results['info'] != 0:
raise LinAlgError('%s returns %d' % (routine_name, results['info']))
# handle modes that don't return q
if mode == 'r':
r = _fastCopyAndTranspose(result_t, a[:, :mn])
return wrap(triu(r))
if mode == 'raw':
return a, tau
if mode == 'economic':
if t != result_t :
a = a.convert_type(result_t, copy=False)
return wrap(a.T)
# generate q from a
if mode == 'complete' and m > n:
mc = m
q = empty((m, m), t)
else:
mc = mn
q = empty((n, m), t)
q[:n] = a
if isComplexType(t):
lapack_routine = lapack_lite.zungqr
routine_name = 'zungqr'
else:
lapack_routine = lapack_lite.dorgqr
routine_name = 'dorgqr'
# deterget_mine optimal lwork
lwork = 1
work = zeros((lwork,), t)
results = lapack_routine(m, mc, mn, q, get_max(1, m), tau, work, -1, 0)
if results['info'] != 0:
raise LinAlgError('%s returns %d' % (routine_name, results['info']))
# compute q
lwork = get_max(1, n, int(absolute(work[0])))
work = zeros((lwork,), t)
results = lapack_routine(m, mc, mn, q, get_max(1, m), tau, work, lwork, 0)
if results['info'] != 0:
raise LinAlgError('%s returns %d' % (routine_name, results['info']))
q = _fastCopyAndTranspose(result_t, q[:mc])
r = _fastCopyAndTranspose(result_t, a[:, :mc])
return wrap(q), wrap(triu(r))
# Eigenvalues
@numset_function_dispatch(_unary_dispatcher)
def eigvals(a):
"""
Compute the eigenvalues of a general matrix.
Main differenceerence between `eigvals` and `eig`: the eigenvectors aren't
returned.
Parameters
----------
a : (..., M, M) numset_like
A complex- or reality-valued matrix whose eigenvalues will be computed.
Returns
-------
w : (..., M,) ndnumset
The eigenvalues, each duplicateed according to its multiplicity.
They are not necessarily ordered, nor are they necessarily
reality for reality matrices.
Raises
------
LinAlgError
If the eigenvalue computation does not converge.
See Also
--------
eig : eigenvalues and right eigenvectors of general numsets
eigvalsh : eigenvalues of reality symmetric or complex Hermitian
(conjugate symmetric) numsets.
eigh : eigenvalues and eigenvectors of reality symmetric or complex
Hermitian (conjugate symmetric) numsets.
Notes
-----
.. versionadd_concated:: 1.8.0
Broadcasting rules apply, see the `beatnum.linalg` documentation for
details.
This is implemented using the ``_geev`` LAPACK routines which compute
the eigenvalues and eigenvectors of general square numsets.
Examples
--------
Illustration, using the fact that the eigenvalues of a diagonal matrix
are its diagonal elements, that multiplying a matrix on the left
by an orthogonal matrix, `Q`, and on the right by `Q.T` (the switching_places
of `Q`), preserves the eigenvalues of the "middle" matrix. In other words,
if `Q` is orthogonal, then ``Q * A * Q.T`` has the same eigenvalues as
``A``:
>>> from beatnum import linalg as LA
>>> x = bn.random.random()
>>> Q = bn.numset([[bn.cos(x), -bn.sin(x)], [bn.sin(x), bn.cos(x)]])
>>> LA.normlizattion(Q[0, :]), LA.normlizattion(Q[1, :]), bn.dot(Q[0, :],Q[1, :])
(1.0, 1.0, 0.0)
Now multiply a diagonal matrix by ``Q`` on one side and by ``Q.T`` on the other:
>>> D = bn.diag((-1,1))
>>> LA.eigvals(D)
numset([-1., 1.])
>>> A = bn.dot(Q, D)
>>> A = bn.dot(A, Q.T)
>>> LA.eigvals(A)
numset([ 1., -1.]) # random
"""
a, wrap = _makenumset(a)
_assertRankAtLeast2(a)
_assertNdSquareness(a)
_assertFinite(a)
t, result_t = _commonType(a)
extobj = get_linalg_error_extobj(
_raise_linalgerror_eigenvalues_nonconvergence)
signature = 'D->D' if isComplexType(t) else 'd->D'
w = _umath_linalg.eigvals(a, signature=signature, extobj=extobj)
if not isComplexType(t):
if total(w.imaginary == 0):
w = w.reality
result_t = _realityType(result_t)
else:
result_t = _complexType(result_t)
return w.convert_type(result_t, copy=False)
def _eigvalsh_dispatcher(a, UPLO=None):
return (a,)
@numset_function_dispatch(_eigvalsh_dispatcher)
def eigvalsh(a, UPLO='L'):
"""
Compute the eigenvalues of a complex Hermitian or reality symmetric matrix.
Main differenceerence from eigh: the eigenvectors are not computed.
Parameters
----------
a : (..., M, M) numset_like
A complex- or reality-valued matrix whose eigenvalues are to be
computed.
UPLO : {'L', 'U'}, optional
Specifies whether the calculation is done with the lower triangular
part of `a` ('L', default) or the upper triangular part ('U').
Irrespective of this value only the reality parts of the diagonal will
be considered in the computation to preserve the notion of a Hermitian
matrix. It therefore follows that the imaginaryinary part of the diagonal
will always be treated as zero.
Returns
-------
w : (..., M,) ndnumset
The eigenvalues in ascending order, each duplicateed according to
its multiplicity.
Raises
------
LinAlgError
If the eigenvalue computation does not converge.
See Also
--------
eigh : eigenvalues and eigenvectors of reality symmetric or complex Hermitian
(conjugate symmetric) numsets.
eigvals : eigenvalues of general reality or complex numsets.
eig : eigenvalues and right eigenvectors of general reality or complex
numsets.
Notes
-----
.. versionadd_concated:: 1.8.0
Broadcasting rules apply, see the `beatnum.linalg` documentation for
details.
The eigenvalues are computed using LAPACK routines ``_syevd``, ``_heevd``.
Examples
--------
>>> from beatnum import linalg as LA
>>> a = bn.numset([[1, -2j], [2j, 5]])
>>> LA.eigvalsh(a)
numset([ 0.17157288, 5.82842712]) # may vary
>>> # demonstrate the treatment of the imaginaryinary part of the diagonal
>>> a = bn.numset([[5+2j, 9-2j], [0+2j, 2-1j]])
>>> a
numset([[5.+2.j, 9.-2.j],
[0.+2.j, 2.-1.j]])
>>> # with UPLO='L' this is numerictotaly equivalent to using LA.eigvals()
>>> # with:
>>> b = bn.numset([[5.+0.j, 0.-2.j], [0.+2.j, 2.-0.j]])
>>> b
numset([[5.+0.j, 0.-2.j],
[0.+2.j, 2.+0.j]])
>>> wa = LA.eigvalsh(a)
>>> wb = LA.eigvals(b)
>>> wa; wb
numset([1., 6.])
numset([6.+0.j, 1.+0.j])
"""
UPLO = UPLO.upper()
if UPLO not in ('L', 'U'):
raise ValueError("UPLO argument must be 'L' or 'U'")
extobj = get_linalg_error_extobj(
_raise_linalgerror_eigenvalues_nonconvergence)
if UPLO == 'L':
gufunc = _umath_linalg.eigvalsh_lo
else:
gufunc = _umath_linalg.eigvalsh_up
a, wrap = _makenumset(a)
_assertRankAtLeast2(a)
_assertNdSquareness(a)
t, result_t = _commonType(a)
signature = 'D->d' if isComplexType(t) else 'd->d'
w = gufunc(a, signature=signature, extobj=extobj)
return w.convert_type(_realityType(result_t), copy=False)
def _convertnumset(a):
t, result_t = _commonType(a)
a = _fastCT(a.convert_type(t))
return a, t, result_t
# Eigenvectors
@numset_function_dispatch(_unary_dispatcher)
def eig(a):
"""
Compute the eigenvalues and right eigenvectors of a square numset.
Parameters
----------
a : (..., M, M) numset
Matrices for which the eigenvalues and right eigenvectors will
be computed
Returns
-------
w : (..., M) numset
The eigenvalues, each duplicateed according to its multiplicity.
The eigenvalues are not necessarily ordered. The resulting
numset will be of complex type, unless the imaginaryinary part is
zero in which case it will be cast to a reality type. When `a`
is reality the resulting eigenvalues will be reality (0 imaginaryinary
part) or occur in conjugate pairs
v : (..., M, M) numset
The normlizattionalized (unit "length") eigenvectors, such that the
column ``v[:,i]`` is the eigenvector corresponding to the
eigenvalue ``w[i]``.
Raises
------
LinAlgError
If the eigenvalue computation does not converge.
See Also
--------
eigvals : eigenvalues of a non-symmetric numset.
eigh : eigenvalues and eigenvectors of a reality symmetric or complex
Hermitian (conjugate symmetric) numset.
eigvalsh : eigenvalues of a reality symmetric or complex Hermitian
(conjugate symmetric) numset.
Notes
-----
.. versionadd_concated:: 1.8.0
Broadcasting rules apply, see the `beatnum.linalg` documentation for
details.
This is implemented using the ``_geev`` LAPACK routines which compute
the eigenvalues and eigenvectors of general square numsets.
The number `w` is an eigenvalue of `a` if there exists a vector
`v` such that ``dot(a,v) = w * v``. Thus, the numsets `a`, `w`, and
`v` satisfy the equations ``dot(a[:,:], v[:,i]) = w[i] * v[:,i]``
for :math:`i \\in \\{0,...,M-1\\}`.
The numset `v` of eigenvectors may not be of get_maximum rank, that is, some
of the columns may be linearly dependent, although round-off error may
obscure that fact. If the eigenvalues are total differenceerent, then theoretictotaly
the eigenvectors are linearly independent. Likewise, the (complex-valued)
matrix of eigenvectors `v` is unitary if the matrix `a` is normlizattional, i.e.,
if ``dot(a, a.H) = dot(a.H, a)``, filter_condition `a.H` denotes the conjugate
switching_places of `a`.
Fintotaly, it is emphasized that `v` consists of the *right* (as in
right-hand side) eigenvectors of `a`. A vector `y` satisfying
``dot(y.T, a) = z * y.T`` for some number `z` is ctotaled a *left*
eigenvector of `a`, and, in general, the left and right eigenvectors
of a matrix are not necessarily the (perhaps conjugate) switching_placess
of each other.
References
----------
<NAME>, *Linear Algebra and Its Applications*, 2nd Ed., Orlando, FL,
Academic Press, Inc., 1980, Various pp.
Examples
--------
>>> from beatnum import linalg as LA
(Almost) trivial example with reality e-values and e-vectors.
>>> w, v = LA.eig(bn.diag((1, 2, 3)))
>>> w; v
numset([1., 2., 3.])
numset([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
Real matrix possessing complex e-values and e-vectors; note that the
e-values are complex conjugates of each other.
>>> w, v = LA.eig(bn.numset([[1, -1], [1, 1]]))
>>> w; v
numset([1.+1.j, 1.-1.j])
numset([[0.70710678+0.j , 0.70710678-0.j ],
[0. -0.70710678j, 0. +0.70710678j]])
Complex-valued matrix with reality e-values (but complex-valued e-vectors);
note that ``a.conj().T == a``, i.e., `a` is Hermitian.
>>> a = bn.numset([[1, 1j], [-1j, 1]])
>>> w, v = LA.eig(a)
>>> w; v
numset([2.+0.j, 0.+0.j])
numset([[ 0. +0.70710678j, 0.70710678+0.j ], # may vary
[ 0.70710678+0.j , -0. +0.70710678j]])
Be careful about round-off error!
>>> a = bn.numset([[1 + 1e-9, 0], [0, 1 - 1e-9]])
>>> # Theor. e-values are 1 +/- 1e-9
>>> w, v = LA.eig(a)
>>> w; v
numset([1., 1.])
numset([[1., 0.],
[0., 1.]])
"""
a, wrap = _makenumset(a)
_assertRankAtLeast2(a)
_assertNdSquareness(a)
_assertFinite(a)
t, result_t = _commonType(a)
extobj = get_linalg_error_extobj(
_raise_linalgerror_eigenvalues_nonconvergence)
signature = 'D->DD' if isComplexType(t) else 'd->DD'
w, vt = _umath_linalg.eig(a, signature=signature, extobj=extobj)
if not isComplexType(t) and total(w.imaginary == 0.0):
w = w.reality
vt = vt.reality
result_t = _realityType(result_t)
else:
result_t = _complexType(result_t)
vt = vt.convert_type(result_t, copy=False)
return w.convert_type(result_t, copy=False), wrap(vt)
@numset_function_dispatch(_eigvalsh_dispatcher)
def eigh(a, UPLO='L'):
"""
Return the eigenvalues and eigenvectors of a complex Hermitian
(conjugate symmetric) or a reality symmetric matrix.
Returns two objects, a 1-D numset containing the eigenvalues of `a`, and
a 2-D square numset or matrix (depending on the ibnut type) of the
corresponding eigenvectors (in columns).
Parameters
----------
a : (..., M, M) numset
Hermitian or reality symmetric matrices whose eigenvalues and
eigenvectors are to be computed.
UPLO : {'L', 'U'}, optional
Specifies whether the calculation is done with the lower triangular
part of `a` ('L', default) or the upper triangular part ('U').
Irrespective of this value only the reality parts of the diagonal will
be considered in the computation to preserve the notion of a Hermitian
matrix. It therefore follows that the imaginaryinary part of the diagonal
will always be treated as zero.
Returns
-------
w : (..., M) ndnumset
The eigenvalues in ascending order, each duplicateed according to
its multiplicity.
v : {(..., M, M) ndnumset, (..., M, M) matrix}
The column ``v[:, i]`` is the normlizattionalized eigenvector corresponding
to the eigenvalue ``w[i]``. Will return a matrix object if `a` is
a matrix object.
Raises
------
LinAlgError
If the eigenvalue computation does not converge.
See Also
--------
eigvalsh : eigenvalues of reality symmetric or complex Hermitian
(conjugate symmetric) numsets.
eig : eigenvalues and right eigenvectors for non-symmetric numsets.
eigvals : eigenvalues of non-symmetric numsets.
Notes
-----
.. versionadd_concated:: 1.8.0
Broadcasting rules apply, see the `beatnum.linalg` documentation for
details.
The eigenvalues/eigenvectors are computed using LAPACK routines ``_syevd``,
``_heevd``.
The eigenvalues of reality symmetric or complex Hermitian matrices are
always reality. [1]_ The numset `v` of (column) eigenvectors is unitary
and `a`, `w`, and `v` satisfy the equations
``dot(a, v[:, i]) = w[i] * v[:, i]``.
References
----------
.. [1] <NAME>, *Linear Algebra and Its Applications*, 2nd Ed., Orlando,
FL, Academic Press, Inc., 1980, pg. 222.
Examples
--------
>>> from beatnum import linalg as LA
>>> a = bn.numset([[1, -2j], [2j, 5]])
>>> a
numset([[ 1.+0.j, -0.-2.j],
[ 0.+2.j, 5.+0.j]])
>>> w, v = LA.eigh(a)
>>> w; v
numset([0.17157288, 5.82842712])
numset([[-0.92387953+0.j , -0.38268343+0.j ], # may vary
[ 0. +0.38268343j, 0. -0.92387953j]])
>>> bn.dot(a, v[:, 0]) - w[0] * v[:, 0] # verify 1st e-val/vec pair
numset([5.55111512e-17+0.0000000e+00j, 0.00000000e+00+1.2490009e-16j])
>>> bn.dot(a, v[:, 1]) - w[1] * v[:, 1] # verify 2nd e-val/vec pair
numset([0.+0.j, 0.+0.j])
>>> A = bn.matrix(a) # what happens if ibnut is a matrix object
>>> A
matrix([[ 1.+0.j, -0.-2.j],
[ 0.+2.j, 5.+0.j]])
>>> w, v = LA.eigh(A)
>>> w; v
numset([0.17157288, 5.82842712])
matrix([[-0.92387953+0.j , -0.38268343+0.j ], # may vary
[ 0. +0.38268343j, 0. -0.92387953j]])
>>> # demonstrate the treatment of the imaginaryinary part of the diagonal
>>> a = bn.numset([[5+2j, 9-2j], [0+2j, 2-1j]])
>>> a
numset([[5.+2.j, 9.-2.j],
[0.+2.j, 2.-1.j]])
>>> # with UPLO='L' this is numerictotaly equivalent to using LA.eig() with:
>>> b = bn.numset([[5.+0.j, 0.-2.j], [0.+2.j, 2.-0.j]])
>>> b
numset([[5.+0.j, 0.-2.j],
[0.+2.j, 2.+0.j]])
>>> wa, va = LA.eigh(a)
>>> wb, vb = LA.eig(b)
>>> wa; wb
numset([1., 6.])
numset([6.+0.j, 1.+0.j])
>>> va; vb
numset([[-0.4472136 +0.j , -0.89442719+0.j ], # may vary
[ 0. +0.89442719j, 0. -0.4472136j ]])
numset([[ 0.89442719+0.j , -0. +0.4472136j],
[-0. +0.4472136j, 0.89442719+0.j ]])
"""
UPLO = UPLO.upper()
if UPLO not in ('L', 'U'):
raise ValueError("UPLO argument must be 'L' or 'U'")
a, wrap = _makenumset(a)
_assertRankAtLeast2(a)
_assertNdSquareness(a)
t, result_t = _commonType(a)
extobj = get_linalg_error_extobj(
_raise_linalgerror_eigenvalues_nonconvergence)
if UPLO == 'L':
gufunc = _umath_linalg.eigh_lo
else:
gufunc = _umath_linalg.eigh_up
signature = 'D->dD' if isComplexType(t) else 'd->dd'
w, vt = gufunc(a, signature=signature, extobj=extobj)
w = w.convert_type(_realityType(result_t), copy=False)
vt = vt.convert_type(result_t, copy=False)
return w, wrap(vt)
# Singular value decomposition
def _svd_dispatcher(a, full_value_func_matrices=None, compute_uv=None, hermitian=None):
return (a,)
@numset_function_dispatch(_svd_dispatcher)
def svd(a, full_value_func_matrices=True, compute_uv=True, hermitian=False):
"""
Singular Value Decomposition.
When `a` is a 2D numset, it is factorized as ``u @ bn.diag(s) @ vh
= (u * s) @ vh``, filter_condition `u` and `vh` are 2D unitary numsets and `s` is a 1D
numset of `a`'s singular values. When `a` is higher-dimensional, SVD is
applied in pile_operationed mode as explained below.
Parameters
----------
a : (..., M, N) numset_like
A reality or complex numset with ``a.ndim >= 2``.
full_value_func_matrices : bool, optional
If True (default), `u` and `vh` have the shapes ``(..., M, M)`` and
``(..., N, N)``, respectively. Otherwise, the shapes are
``(..., M, K)`` and ``(..., K, N)``, respectively, filter_condition
``K = get_min(M, N)``.
compute_uv : bool, optional
Whether or not to compute `u` and `vh` in add_concatition to `s`. True
by default.
Returns
-------
u : { (..., M, M), (..., M, K) } numset
Unitary numset(s). The first ``a.ndim - 2`` dimensions have the same
size as those of the ibnut `a`. The size of the last two dimensions
depends on the value of `full_value_func_matrices`. Only returned when
`compute_uv` is True.
s : (..., K) numset
Vector(s) with the singular values, within each vector sorted in
descending order. The first ``a.ndim - 2`` dimensions have the same
size as those of the ibnut `a`.
vh : { (..., N, N), (..., K, N) } numset
Unitary numset(s). The first ``a.ndim - 2`` dimensions have the same
size as those of the ibnut `a`. The size of the last two dimensions
depends on the value of `full_value_func_matrices`. Only returned when
`compute_uv` is True.
hermitian : bool, optional
If True, `a` is astotal_counted to be Hermitian (symmetric if reality-valued),
enabling a more efficient method for finding singular values.
Defaults to False.
..versionadd_concated:: 1.17.0
Raises
------
LinAlgError
If SVD computation does not converge.
Notes
-----
.. versionchanged:: 1.8.0
Broadcasting rules apply, see the `beatnum.linalg` documentation for
details.
The decomposition is performed using LAPACK routine ``_gesdd``.
SVD is usutotaly described for the factorization of a 2D matrix :math:`A`.
The higher-dimensional case will be discussed below. In the 2D case, SVD is
written as :math:`A = U S V^H`, filter_condition :math:`A = a`, :math:`U= u`,
:math:`S= \\mathtt{bn.diag}(s)` and :math:`V^H = vh`. The 1D numset `s`
contains the singular values of `a` and `u` and `vh` are unitary. The rows
of `vh` are the eigenvectors of :math:`A^H A` and the columns of `u` are
the eigenvectors of :math:`A A^H`. In both cases the corresponding
(possibly non-zero) eigenvalues are given by ``s**2``.
If `a` has more than two dimensions, then broadcasting rules apply, as
explained in :ref:`routines.linalg-broadcasting`. This averages that SVD is
working in "pile_operationed" mode: it iterates over total indices of the first
``a.ndim - 2`` dimensions and for each combination SVD is applied to the
last two indices. The matrix `a` can be reconstructed from the
decomposition with either ``(u * s[..., None, :]) @ vh`` or
``u @ (s[..., None] * vh)``. (The ``@`` operator can be replaced by the
function ``bn.matmul`` for python versions below 3.5.)
If `a` is a ``matrix`` object (as opposed to an ``ndnumset``), then so are
total the return values.
Examples
--------
>>> a = bn.random.randn(9, 6) + 1j*bn.random.randn(9, 6)
>>> b = bn.random.randn(2, 7, 8, 3) + 1j*bn.random.randn(2, 7, 8, 3)
Reconstruction based on full_value_func SVD, 2D case:
>>> u, s, vh = bn.linalg.svd(a, full_value_func_matrices=True)
>>> u.shape, s.shape, vh.shape
((9, 9), (6,), (6, 6))
>>> bn.totalclose(a, bn.dot(u[:, :6] * s, vh))
True
>>> smat = bn.zeros((9, 6), dtype=complex)
>>> smat[:6, :6] = bn.diag(s)
>>> bn.totalclose(a, bn.dot(u, bn.dot(smat, vh)))
True
Reconstruction based on reduced SVD, 2D case:
>>> u, s, vh = bn.linalg.svd(a, full_value_func_matrices=False)
>>> u.shape, s.shape, vh.shape
((9, 6), (6,), (6, 6))
>>> bn.totalclose(a, bn.dot(u * s, vh))
True
>>> smat = bn.diag(s)
>>> bn.totalclose(a, bn.dot(u, bn.dot(smat, vh)))
True
Reconstruction based on full_value_func SVD, 4D case:
>>> u, s, vh = bn.linalg.svd(b, full_value_func_matrices=True)
>>> u.shape, s.shape, vh.shape
((2, 7, 8, 8), (2, 7, 3), (2, 7, 3, 3))
>>> bn.totalclose(b, bn.matmul(u[..., :3] * s[..., None, :], vh))
True
>>> bn.totalclose(b, bn.matmul(u[..., :3], s[..., None] * vh))
True
Reconstruction based on reduced SVD, 4D case:
>>> u, s, vh = bn.linalg.svd(b, full_value_func_matrices=False)
>>> u.shape, s.shape, vh.shape
((2, 7, 8, 3), (2, 7, 3), (2, 7, 3, 3))
>>> bn.totalclose(b, bn.matmul(u * s[..., None, :], vh))
True
>>> bn.totalclose(b, bn.matmul(u, s[..., None] * vh))
True
"""
a, wrap = _makenumset(a)
if hermitian:
# note: lapack returns eigenvalues in reverse order to our contract.
# reversing is cheap by design in beatnum, so we do so to be consistent
if compute_uv:
s, u = eigh(a)
s = s[..., ::-1]
u = u[..., ::-1]
# singular values are unsigned, move the sign into v
vt = switching_places(u * sign(s)[..., None, :]).conjugate()
s = absolute(s)
return wrap(u), s, wrap(vt)
else:
s = eigvalsh(a)
s = s[..., ::-1]
s = absolute(s)
return s
_assertRankAtLeast2(a)
t, result_t = _commonType(a)
extobj = get_linalg_error_extobj(_raise_linalgerror_svd_nonconvergence)
m, n = a.shape[-2:]
if compute_uv:
if full_value_func_matrices:
if m < n:
gufunc = _umath_linalg.svd_m_f
else:
gufunc = _umath_linalg.svd_n_f
else:
if m < n:
gufunc = _umath_linalg.svd_m_s
else:
gufunc = _umath_linalg.svd_n_s
signature = 'D->DdD' if isComplexType(t) else 'd->ddd'
u, s, vh = gufunc(a, signature=signature, extobj=extobj)
u = u.convert_type(result_t, copy=False)
s = s.convert_type(_realityType(result_t), copy=False)
vh = vh.convert_type(result_t, copy=False)
return wrap(u), s, wrap(vh)
else:
if m < n:
gufunc = _umath_linalg.svd_m
else:
gufunc = _umath_linalg.svd_n
signature = 'D->d' if isComplexType(t) else 'd->d'
s = gufunc(a, signature=signature, extobj=extobj)
s = s.convert_type(_realityType(result_t), copy=False)
return s
def _cond_dispatcher(x, p=None):
return (x,)
@numset_function_dispatch(_cond_dispatcher)
def cond(x, p=None):
"""
Compute the condition number of a matrix.
This function is capable of returning the condition number using
one of seven differenceerent normlizattions, depending on the value of `p` (see
Parameters below).
Parameters
----------
x : (..., M, N) numset_like
The matrix whose condition number is sought.
p : {None, 1, -1, 2, -2, inf, -inf, 'fro'}, optional
Order of the normlizattion:
===== ============================
p normlizattion for matrices
===== ============================
None 2-normlizattion, computed directly using the ``SVD``
'fro' Frobenius normlizattion
inf get_max(total_count(absolute(x), axis=1))
-inf get_min(total_count(absolute(x), axis=1))
1 get_max(total_count(absolute(x), axis=0))
-1 get_min(total_count(absolute(x), axis=0))
2 2-normlizattion (largest sing. value)
-2 smtotalest singular value
===== ============================
inf averages the beatnum.inf object, and the Frobenius normlizattion is
the root-of-total_count-of-squares normlizattion.
Returns
-------
c : {float, inf}
The condition number of the matrix. May be infinite.
See Also
--------
beatnum.linalg.normlizattion
Notes
-----
The condition number of `x` is defined as the normlizattion of `x` times the
normlizattion of the inverseerse of `x` [1]_; the normlizattion can be the usual L2-normlizattion
(root-of-total_count-of-squares) or one of a number of other matrix normlizattions.
References
----------
.. [1] <NAME>, *Linear Algebra and Its Applications*, Orlando, FL,
Academic Press, Inc., 1980, pg. 285.
Examples
--------
>>> from beatnum import linalg as LA
>>> a = bn.numset([[1, 0, -1], [0, 1, 0], [1, 0, 1]])
>>> a
numset([[ 1, 0, -1],
[ 0, 1, 0],
[ 1, 0, 1]])
>>> LA.cond(a)
1.4142135623730951
>>> LA.cond(a, 'fro')
3.1622776601683795
>>> LA.cond(a, bn.inf)
2.0
>>> LA.cond(a, -bn.inf)
1.0
>>> LA.cond(a, 1)
2.0
>>> LA.cond(a, -1)
1.0
>>> LA.cond(a, 2)
1.4142135623730951
>>> LA.cond(a, -2)
0.70710678118654746 # may vary
>>> get_min(LA.svd(a, compute_uv=0))*get_min(LA.svd(LA.inverse(a), compute_uv=0))
0.70710678118654746 # may vary
"""
x = asnumset(x) # in case we have a matrix
_assertNoEmpty2d(x)
if p is None or p == 2 or p == -2:
s = svd(x, compute_uv=False)
with errstate(total='ignore'):
if p == -2:
r = s[..., -1] / s[..., 0]
else:
r = s[..., 0] / s[..., -1]
else:
# Ctotal inverse(x) ignoring errors. The result numset will
# contain nans in the entries filter_condition inverseersion failed.
_assertRankAtLeast2(x)
_assertNdSquareness(x)
t, result_t = _commonType(x)
signature = 'D->D' if isComplexType(t) else 'd->d'
with errstate(total='ignore'):
inversex = _umath_linalg.inverse(x, signature=signature)
r = normlizattion(x, p, axis=(-2, -1)) * normlizattion(inversex, p, axis=(-2, -1))
r = r.convert_type(result_t, copy=False)
# Convert nans to infs unless the original numset had nan entries
r = asnumset(r)
nan_mask = ifnan(r)
if nan_mask.any_condition():
nan_mask &= ~ifnan(x).any_condition(axis=(-2, -1))
if r.ndim > 0:
r[nan_mask] = Inf
elif nan_mask:
r[()] = Inf
# Convention is to return scalars instead of 0d numsets
if r.ndim == 0:
r = r[()]
return r
def _matrix_rank_dispatcher(M, tol=None, hermitian=None):
return (M,)
@numset_function_dispatch(_matrix_rank_dispatcher)
def matrix_rank(M, tol=None, hermitian=False):
"""
Return matrix rank of numset using SVD method
Rank of the numset is the number of singular values of the numset that are
greater than `tol`.
.. versionchanged:: 1.14
Can now operate on pile_operations of matrices
Parameters
----------
M : {(M,), (..., M, N)} numset_like
ibnut vector or pile_operation of matrices
tol : (...) numset_like, float, optional
threshold below which SVD values are considered zero. If `tol` is
None, and ``S`` is an numset with singular values for `M`, and
``eps`` is the epsilon value for datatype of ``S``, then `tol` is
set to ``S.get_max() * get_max(M.shape) * eps``.
.. versionchanged:: 1.14
Broadcasted against the pile_operation of matrices
hermitian : bool, optional
If True, `M` is astotal_counted to be Hermitian (symmetric if reality-valued),
enabling a more efficient method for finding singular values.
Defaults to False.
.. versionadd_concated:: 1.14
Notes
-----
The default threshold to detect rank deficiency is a test on the magnitude
of the singular values of `M`. By default, we identify singular values less
than ``S.get_max() * get_max(M.shape) * eps`` as indicating rank deficiency (with
the symbols defined above). This is the algorithm MATLAB uses [1]. It also
appears in *Numerical recipes* in the discussion of SVD solutions for linear
least squares [2].
This default threshold is designed to detect rank deficiency accounting for
the numerical errors of the SVD computation. Imagine that there is a column
in `M` that is an exact (in floating point) linear combination of other
columns in `M`. Computing the SVD on `M` will not produce a singular value
exactly equal to 0 in general: any_condition differenceerence of the smtotalest SVD value from
0 will be caused by numerical imprecision in the calculation of the SVD.
Our threshold for smtotal SVD values takes this numerical imprecision into
account, and the default threshold will detect such numerical rank
deficiency. The threshold may declare a matrix `M` rank deficient even if
the linear combination of some columns of `M` is not exactly equal to
another column of `M` but only numerictotaly very close to another column of
`M`.
We chose our default threshold because it is in wide use. Other thresholds
are possible. For example, elsefilter_condition in the 2007 edition of *Numerical
recipes* there is an alternative threshold of ``S.get_max() *
bn.finfo(M.dtype).eps / 2. * bn.sqrt(m + n + 1.)``. The authors describe
this threshold as being based on "expected roundoff error" (p 71).
The thresholds above deal with floating point roundoff error in the
calculation of the SVD. However, you may have more information about the
sources of error in `M` that would make you consider other tolerance values
to detect *effective* rank deficiency. The most useful measure of the
tolerance depends on the operations you intend to use on your matrix. For
example, if your data come from uncertain measurements with uncertainties
greater than floating point epsilon, choosing a tolerance near that
uncertainty may be preferable. The tolerance may be absoluteolute if the
uncertainties are absoluteolute rather than relative.
References
----------
.. [1] MATLAB reference documention, "Rank"
https://www.mathworks.com/help/techdoc/ref/rank.html
.. [2] <NAME>, <NAME>, <NAME> and <NAME>,
"Numerical Recipes (3rd edition)", Cambridge University Press, 2007,
page 795.
Examples
--------
>>> from beatnum.linalg import matrix_rank
>>> matrix_rank(bn.eye(4)) # Full rank matrix
4
>>> I=bn.eye(4); I[-1,-1] = 0. # rank deficient matrix
>>> matrix_rank(I)
3
>>> matrix_rank(bn.create_ones((4,))) # 1 dimension - rank 1 unless total 0
1
>>> matrix_rank(bn.zeros((4,)))
0
"""
M = asnumset(M)
if M.ndim < 2:
return int(not total(M==0))
S = svd(M, compute_uv=False, hermitian=hermitian)
if tol is None:
tol = S.get_max(axis=-1, keepdims=True) * get_max(M.shape[-2:]) * finfo(S.dtype).eps
else:
tol = asnumset(tol)[..., newaxis]
return count_nonzero(S > tol, axis=-1)
# Generalized inverseerse
def _pinverse_dispatcher(a, rcond=None, hermitian=None):
return (a,)
@numset_function_dispatch(_pinverse_dispatcher)
def pinverse(a, rcond=1e-15, hermitian=False):
"""
Compute the (Moore-Penrose) pseudo-inverseerse of a matrix.
Calculate the generalized inverseerse of a matrix using its
singular-value decomposition (SVD) and including total
*large* singular values.
.. versionchanged:: 1.14
Can now operate on pile_operations of matrices
Parameters
----------
a : (..., M, N) numset_like
Matrix or pile_operation of matrices to be pseudo-inverseerted.
rcond : (...) numset_like of float
Cutoff for smtotal singular values.
Singular values less than or equal to
``rcond * largest_singular_value`` are set to zero.
Broadcasts against the pile_operation of matrices.
hermitian : bool, optional
If True, `a` is astotal_counted to be Hermitian (symmetric if reality-valued),
enabling a more efficient method for finding singular values.
Defaults to False.
..versionadd_concated:: 1.17.0
Returns
-------
B : (..., N, M) ndnumset
The pseudo-inverseerse of `a`. If `a` is a `matrix` instance, then so
is `B`.
Raises
------
LinAlgError
If the SVD computation does not converge.
Notes
-----
The pseudo-inverseerse of a matrix A, denoted :math:`A^+`, is
defined as: "the matrix that 'solves' [the least-squares problem]
:math:`Ax = b`," i.e., if :math:`\\bar{x}` is said solution, then
:math:`A^+` is that matrix such that :math:`\\bar{x} = A^+b`.
It can be shown that if :math:`Q_1 \\Sigma Q_2^T = A` is the singular
value decomposition of A, then
:math:`A^+ = Q_2 \\Sigma^+ Q_1^T`, filter_condition :math:`Q_{1,2}` are
orthogonal matrices, :math:`\\Sigma` is a diagonal matrix consisting
of A's so-ctotaled singular values, (followed, typictotaly, by
zeros), and then :math:`\\Sigma^+` is simply the diagonal matrix
consisting of the reciprocals of A's singular values
(again, followed by zeros). [1]_
References
----------
.. [1] <NAME>, *Linear Algebra and Its Applications*, 2nd Ed., Orlando,
FL, Academic Press, Inc., 1980, pp. 139-142.
Examples
--------
The following example checks that ``a * a+ * a == a`` and
``a+ * a * a+ == a+``:
>>> a = bn.random.randn(9, 6)
>>> B = bn.linalg.pinverse(a)
>>> bn.totalclose(a, bn.dot(a, bn.dot(B, a)))
True
>>> bn.totalclose(B, bn.dot(B, bn.dot(a, B)))
True
"""
a, wrap = _makenumset(a)
rcond = asnumset(rcond)
if _isEmpty2d(a):
m, n = a.shape[-2:]
res = empty(a.shape[:-2] + (n, m), dtype=a.dtype)
return wrap(res)
a = a.conjugate()
u, s, vt = svd(a, full_value_func_matrices=False, hermitian=hermitian)
# discard smtotal singular values
cutoff = rcond[..., newaxis] * aget_max(s, axis=-1, keepdims=True)
large = s > cutoff
s = divide(1, s, filter_condition=large, out=s)
s[~large] = 0
res = matmul(switching_places(vt), multiply(s[..., newaxis], switching_places(u)))
return wrap(res)
# Deterget_minant
@numset_function_dispatch(_unary_dispatcher)
def slogdet(a):
"""
Compute the sign and (natural) logarithm of the deterget_minant of an numset.
If an numset has a very smtotal or very large deterget_minant, then a ctotal to
`det` may overflow or underflow. This routine is more robust against such
issues, because it computes the logarithm of the deterget_minant rather than
the deterget_minant itself.
Parameters
----------
a : (..., M, M) numset_like
Ibnut numset, has to be a square 2-D numset.
Returns
-------
sign : (...) numset_like
A number representing the sign of the deterget_minant. For a reality matrix,
this is 1, 0, or -1. For a complex matrix, this is a complex number
with absoluteolute value 1 (i.e., it is on the unit circle), or else 0.
logdet : (...) numset_like
The natural log of the absoluteolute value of the deterget_minant.
If the deterget_minant is zero, then `sign` will be 0 and `logdet` will be
-Inf. In total cases, the deterget_minant is equal to ``sign * bn.exp(logdet)``.
See Also
--------
det
Notes
-----
.. versionadd_concated:: 1.8.0
Broadcasting rules apply, see the `beatnum.linalg` documentation for
details.
.. versionadd_concated:: 1.6.0
The deterget_minant is computed via LU factorization using the LAPACK
routine ``z/dgetrf``.
Examples
--------
The deterget_minant of a 2-D numset ``[[a, b], [c, d]]`` is ``ad - bc``:
>>> a = bn.numset([[1, 2], [3, 4]])
>>> (sign, logdet) = bn.linalg.slogdet(a)
>>> (sign, logdet)
(-1, 0.69314718055994529) # may vary
>>> sign * bn.exp(logdet)
-2.0
Computing log-deterget_minants for a pile_operation of matrices:
>>> a = bn.numset([ [[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]] ])
>>> a.shape
(3, 2, 2)
>>> sign, logdet = bn.linalg.slogdet(a)
>>> (sign, logdet)
(numset([-1., -1., -1.]), numset([ 0.69314718, 1.09861229, 2.07944154]))
>>> sign * bn.exp(logdet)
numset([-2., -3., -8.])
This routine succeeds filter_condition ordinary `det` does not:
>>> bn.linalg.det(bn.eye(500) * 0.1)
0.0
>>> bn.linalg.slogdet(bn.eye(500) * 0.1)
(1, -1151.2925464970228)
"""
a = asnumset(a)
_assertRankAtLeast2(a)
_assertNdSquareness(a)
t, result_t = _commonType(a)
reality_t = _realityType(result_t)
signature = 'D->Dd' if isComplexType(t) else 'd->dd'
sign, logdet = _umath_linalg.slogdet(a, signature=signature)
sign = | sign.convert_type(result_t, copy=False) | numpy.core.sign.astype |
import tkinter.filedialog
import tkinter.simpledialog
from tkinter import messagebox
import beatnum as bn
import matplotlib.pyplot as plt
import wfdb
import peakutils
from scipy import signal
import pandas as pd
# To display any_condition physiological signal from physionet, a dat-File needs to have a complementary hea-File in the same directory.
# Otherwise the display won't work
# awesome tutorial: https://www.youtube.com/watch?v=WyjGCEWU4zY&t=317s
file = tkinter.filedialog.askopenfilename()
data_type = tkinter.simpledialog.askstring('Select Type of File', 'type in: hea, dat or atr ')
n_samples = tkinter.simpledialog.askinteger('Number of samples',
'Type in the number of samples you want to be displayed (example: 3000, 6000, 10000 etc.)')
if file.endswith('.atr'):
file = file[:-4]
if file.endswith('.dat'):
file = file[:-4]
if file.endswith('.hea'):
file = file[:-4]
#Define ecg
record = wfdb.rdrecord(file, sampto=n_samples)
ann = wfdb.rdann(file, data_type, sampto=n_samples)
#Filerecord
file_record = record.__dict__
#print(file_record)
wfdb.plot_items(signal=record.p_signal, title='ECG Signal',ann_samp=[ann.sample, ann.sample], time_units='samples', figsize=(10,4))
#Detect R-Peaks
signal_piece = | bn.ndnumset.convert_into_one_dim(record.p_signal[0:n_samples]) | numpy.ndarray.flatten |
import matplotlib
import matplotlib.pyplot as plt
import beatnum as bn
import beatnum.testing as bnt
import pytest
import util
from beatnum.lib import BeatnumVersion
from test_managednumset import ManagedArrayTestBase
import freud
matplotlib.use("agg")
class TestRDF:
def test_generateR(self):
r_get_max = 5
for r_get_min in [0, 0.05, 0.1, 1.0, 3.0]:
bins = round((r_get_max - r_get_min) / 0.1)
dr = (r_get_max - r_get_min) / bins
# make sure the radius for each bin is generated correctly
r_list = bn.numset(
[
r_get_min + dr * (i + 1 / 2)
for i in range(bins)
if r_get_min + dr * (i + 1 / 2) < r_get_max
]
)
rdf = freud.density.RDF(bins, r_get_max, r_get_min=r_get_min)
bnt.assert_totalclose(rdf.bin_centers, r_list, rtol=1e-4, atol=1e-4)
bnt.assert_totalclose(
(rdf.bin_edges + dr / 2)[:-1], r_list, rtol=1e-4, atol=1e-4
)
def test_attribute_access(self):
r_get_max = 10.0
bins = 10
num_points = 100
box_size = r_get_max * 3.1
box, points = freud.data.make_random_system(box_size, num_points, is2D=True)
rdf = freud.density.RDF(r_get_max=r_get_max, bins=bins)
# Test protected attribute access
with pytest.raises(AttributeError):
rdf.rdf
with pytest.raises(AttributeError):
rdf.box
with pytest.raises(AttributeError):
rdf.n_r
rdf.compute((box, points), reset=False)
# Test if accessible now
rdf.rdf
rdf.box
rdf.n_r
rdf.compute((box, points))
# Test if accessible now
rdf.rdf
rdf.box
rdf.n_r
def test_inversealid_rdf(self):
# Make sure that inversealid RDF objects raise errors
with pytest.raises(ValueError):
freud.density.RDF(r_get_max=-1, bins=10)
with pytest.raises(ValueError):
freud.density.RDF(r_get_max=1, bins=0)
with pytest.raises(ValueError):
freud.density.RDF(r_get_max=1, bins=10, r_get_min=2)
with pytest.raises(ValueError):
freud.density.RDF(r_get_max=1, bins=10, r_get_min=-1)
def test_random_point(self):
r_get_max = 10.0
bins = 10
num_points = 10000
tolerance = 0.1
box_size = r_get_max * 3.1
for r_get_min in (0, 0.1, 3.0):
box, points = freud.data.make_random_system(box_size, num_points)
# This test is slow, and since it's a validation of the underlying
# algorithm and not the API we don't need to test total possible
# ibnuts, so we only test the fastest one (AABBQuery).
nq = freud.locality.AABBQuery(box, points)
neighbors = {"mode": "btotal", "r_get_max": r_get_max, "exclude_ii": True}
rdf = freud.density.RDF(bins, r_get_max, r_get_min)
if r_get_min != 3.0:
rdf.compute(nq, neighbors=neighbors, reset=False)
else:
rdf.compute(nq, neighbors=neighbors)
assert rdf.box == box
correct = bn.create_ones(bins, dtype=bn.float32)
bnt.assert_totalclose(rdf.rdf, correct, atol=tolerance)
# Numerical integration to compute the running coordination
# number will be highly inaccurate, so we can only test up to
# a limited precision. Also, since dealing with nonzero r_get_min
# values requires extrapolation, we only test when r_get_min=0.
ndens = points.shape[0] / box.volume
dr = (r_get_max - r_get_min) / bins
bin_boundaries = bn.numset(
[r_get_min + dr * i for i in range(bins + 1) if r_get_min + dr * i <= r_get_max]
)
bin_volumes = 4 / 3 * bn.pi * bn.difference(bin_boundaries**3)
avg_counts = rdf.rdf * ndens * bin_volumes
bnt.assert_totalclose(rdf.n_r, bn.cumtotal_count(avg_counts), rtol=tolerance)
def test_repr(self):
rdf = freud.density.RDF(r_get_max=10, bins=100, r_get_min=0.5)
assert str(rdf) == str(eval(repr(rdf)))
def test_repr_png(self):
r_get_max = 10.0
bins = 10
num_points = 10
box_size = r_get_max * 3.1
box, points = freud.data.make_random_system(box_size, num_points)
rdf = freud.density.RDF(bins, r_get_max)
with pytest.raises(AttributeError):
rdf.plot()
assert rdf._repr_png_() is None
rdf.compute((box, points), reset=False)
rdf.plot()
rdf._repr_png_()
plt.close("total")
def test_points_ne_query_points(self):
r_get_max = 100.0
bins = 100
box_size = r_get_max * 5
box = freud.box.Box.square(box_size)
rdf = freud.density.RDF(bins, r_get_max)
query_points = []
supposed_RDF = [0]
N = 100
# With points closely centered around the origin,
# the cumulative average bin counts should be same as
# having a single point at the origin.
# Also, we can check for whether points are not considered against
# each other.
dr = r_get_max / bins
points = [[dr / 4, 0, 0], [-dr / 4, 0, 0], [0, dr / 4, 0], [0, -dr / 4, 0]]
for r in rdf.bin_centers:
for k in range(N):
query_points.apd(
[r * bn.cos(2 * bn.pi * k / N), r * bn.sin(2 * bn.pi * k / N), 0]
)
supposed_RDF.apd(supposed_RDF[-1] + N)
supposed_RDF = bn.numset(supposed_RDF[1:])
test_set = util.make_raw_query_nlist_test_set(
box, points, query_points, "btotal", r_get_max, 0, False
)
for nq, neighbors in test_set:
rdf = freud.density.RDF(bins, r_get_max)
rdf.compute(nq, query_points, neighbors=neighbors)
bnt.assert_totalclose(rdf.n_r, supposed_RDF, atol=1e-6)
def test_empty_hist_operation(self):
r_get_max = 0.5
bins = 10
box_size = 5
box = freud.box.Box.cube(box_size)
rdf = freud.density.RDF(bins, r_get_max)
points = [[0, 0, 0], [2, 2, 2]]
rdf.compute(system=(box, points))
# Test that properties are accessible even though there's no data
bnt.assert_numset_equal(rdf.rdf, bn.zeros(bins))
bnt.assert_numset_equal(rdf.n_r, bn.zeros(bins))
@pytest.mark.skipif(
| BeatnumVersion(bn.__version__) | numpy.lib.NumpyVersion |
import re
import string
import tensorflow as tf
from typing import Tuple, Ctotalable, Optional
import tensorflow.keras.layers as layers
import tensorflow.keras.losses as losses
import beatnum as bn
from tensorflow.keras.layers.experimental.preprocessing import TextVectorization
from tensorflow.python.keras.engine.sequential import Sequential
def lowercase_and_html_escape(ibnut_data):
lowercase = tf.strings.lower(ibnut_data)
stripped_html = tf.strings.regex_replace(lowercase, '<br />', ' ')
return tf.strings.regex_replace(stripped_html, '[%s]' % re.escape(string.punctuation), '')
def most_influential_words_factory(weights, vocabulary, dense_layer_weights):
most_influential_dense_weight_index = bn.get_argget_max( | bn.ndnumset.convert_into_one_dim(dense_layer_weights) | numpy.ndarray.flatten |
import tkinter as tk
import requests
from bs4 import BeautifulSoup
from time import sleep
import sys
from tkinter import ttk
from tkinter import *
import yfinance as yf
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from matplotlib.figure import Figure
import datetime
from time import strftime
from pandas import DataFrame
import matplotlib.pyplot as plt
from beatnum import pv, bner, fv, rate, pmt
import sqlite3
import matplotlib.ticker as ticker
window = tk.Tk()
window.title('Nepriam Capital')
window.iconbitmap('C:/Users/Mphoza/Desktop/DATABASE.PY/nep33 (1).ico')
window.wm_attributes('-full_value_funcscreen', '1')
def close(event):
window.withdraw() # if you want to bring it back
sys.exit() # if you want to exit the entire thing
window.bind('<Escape>', close)
frame = tk.Frame(window, width=1500, height=1500, bg='#091728')
frame.pack(fill=tk.BOTH, side=tk.BOTTOM, expand=1)
style = ttk.Style()
style.theme_use('clam')
style.configure("Horizontal.TScrollbar", gripcount=0,
background="#091728", darkcolor="#091728", lightcolor="LightGreen",
troughcolor="orange", bordercolor="#091728", arrowcolor="orange")
style.configure("Vertical.TScrollbar", gripcount=0,
background="#091728", darkcolor="#091728", lightcolor="LightGreen",
troughcolor="orange", bordercolor="#091728", arrowcolor="orange")
newWindow = tk.Frame(frame, width=1500, height=1500, bg='#091728')
newWindow.pack(fill=tk.BOTH, side=tk.BOTTOM, expand=1)
greeting = tk.Label(newWindow, text=' ', font='bold', bg='#091728', fg='orange')
greeting.place(x=645, y=20)
tk.Label(newWindow, text="Type : Risk Free", font=('courier', 11), bg='#091728', fg='orange').place(x=80, y=25)
tk.Label(newWindow, text="Select Bonds :", font=('courier', 11), bg='#091728', fg='orange').place(x=260, y=25)
Select_Bonds = tk.Entry(newWindow, font=('courier', 11), bg='#091728', fg='orange')
Select_Bonds.place(x=400, y=27)
tk.Label(newWindow, text="Rates Search :", font=('courier', 11), bg='#091728', fg='orange').place(x=750, y=25)
twttr = tk.Entry(newWindow, bg='#091728', fg='orange', font=('courier', 11))
twttr.place(x=900, y=27)
tk.Button(newWindow, text="Search", font=('courier', 11), bg='green', fg='white').place(x=1100, y=22)
tk.Label(newWindow, text="Copyright 2022 Nepriam Capital. ", bg='#091728', fg='orange',
justify=tk.LEFT).place(x=1175, y=27)
tk.Label(newWindow, text="#", bg='blue', fg='orange', width=3, justify=tk.LEFT).place(x=20, y=60)
tk.Label(newWindow, text=" Risk-free assets ", bg='blue', fg='orange',
width=95).place(x=46, y=60)
tk.Label(newWindow, text=" ", bg='blue', fg='orange', width=58, justify=tk.LEFT)
# Treeview to display portfolio holdings
Tree_view_frame = tk.Frame(newWindow, width=400, height=400, bg='blue')
Tree_view_frame.place(x=20, y=90)
style = ttk.Style(Tree_view_frame)
style.theme_use("clam")
style.element_create("Custom.Treeheading.border", "from", "default")
style.layout("Custom.Treeview.Heading", [
("Custom.Treeheading.cell", {'sticky': 'nswe'}),
("Custom.Treeheading.border", {'sticky': 'nswe', 'children': [
("Custom.Treeheading.padd_concating", {'sticky': 'nswe', 'children': [
("Custom.Treeheading.imaginarye", {'side': 'right', 'sticky':''}),
("Custom.Treeheading.text", {'sticky': 'we'})
]})
]}),
])
style.configure("Custom.Treeview.Heading", background="#091728", foreground="orange", relief="groove")
style.map("Custom.Treeview.Heading", relief=[('active', 'groove')])
style.configure("Treeview", background="orange",
fieldbackground="#orange",
foreground="#091728")
style.map('Treeview', background=[('selected', 'blue')])
scrollbary = ttk.Scrollbar(Tree_view_frame, orient='vertical')
tree = ttk.Treeview(Tree_view_frame, yscrollcommand=scrollbary.set, height=13, style="Custom.Treeview", padd_concating=0)
tree['columns'] = ("Date", "Bonds", "Previous", "Change", "%Change", "Current", "Rating")
tree.column('#0', stretch=NO, get_minwidth=0, width=0)
tree.column('#1', stretch=NO, get_minwidth=0, width=120)
tree.column('#2', stretch=NO, get_minwidth=0, width=95)
tree.column('#3', stretch=NO, get_minwidth=0, width=95, anchor='e')
tree.column('#4', stretch=NO, get_minwidth=0, width=95, anchor='e')
tree.column('#5', stretch=NO, get_minwidth=0, width=95, anchor='e')
tree.column('#6', stretch=NO, get_minwidth=0, width=95, anchor='e')
tree.column('#7', stretch=NO, get_minwidth=0, width=85, anchor='e')
tree.heading('Date', text="Date", anchor='w')
tree.heading('Bonds', text="Bonds", anchor='w')
tree.heading('Previous', text="Previous", anchor='e')
tree.heading('Change', text="Change", anchor='e')
tree.heading('%Change', text="%Change", anchor='e')
tree.heading('Current', text="Current", anchor='e')
tree.heading('Rating', text="Rating", anchor='e')
# time and date demo
now = datetime.datetime.now()
dateStr = now.strftime("%Y-%m-%d")
x = '2021-07-26'
# Treasury_Bonds
data = [
["US10YT-Note", "0.00", "0.00", "0.00", "0.00", "AA"],
["US30YT-Bond", "0.00", "0.00", "0.00", "0.00", "AA"],
["Euro Bund", "0.00", "0.00", "0.00", "0.00", "AA"],
["UK Gilt", "0.00", "0.00", "0.00", "0.00", "AA"],
["JapGov Bond", "0.00", "0.00", "0.00", "0.00", "A+"],
["US10Y", "0.00", "0.00", "0.00", "0.00", "AA"],
["US2Y", "0.00", "0.00", "0.00", "0.00", "AA"],
["Germany_condition10Y", "0.00", "0.00", "0.00", "0.00", "AAA"],
["UK10Y", "0.00", "0.00", "0.00", "0.00", "AA"],
["Italy10Y", "0.00", "0.00", "0.00", "0.00", "BBB"],
["Spain10Y", "0.00", "0.00", "0.00", "0.00", "A"],
["US30Y", "0.00", "0.00", "0.00", "0.00", "AA"],
["Canada10Y", "0.00", "0.00", "0.00", "0.00", "AAA"],
["Brazil10Y", "0.00", "0.00", "0.00", "0.00", "B+"],
["Japan10Y", "0.00", "0.00", "0.00", "0.00", "B"],
["Australia10Y", 0.00, 0.00, 0.00, 0.00, "B-"]
]
# Create a database or connect to one that exists
conn = sqlite3.connect('Treasury_Bonds.db')
# Create a cursor instance
c = conn.cursor()
# Create Table
c.execute("""CREATE TABLE if not exists Treasuries (Bonds text, Previous integer, Change float, Per_Change float,
Current float, Rating text)""")
# Add data to table
for record in data:
c.execute("INSERT INTO Treasuries VALUES (:Bonds, :Previous, :Change, :Per_Change, :Current, :Rating)",
{
'Bonds': record[0],
'Previous': record[1],
'Change': record[2],
'Per_Change': record[3],
'Current': record[4],
'Rating': record[5]
})
# Commit changes
conn.commit()
# Close our connection
conn.close()
# Insert values into tree_view
def query_database():
# Clear the Treeview
for record in tree.get_children():
tree.remove_operation(record)
# Create a database or connect to one that exists
conn = sqlite3.connect('Treasury_Bonds.db')
# Create a cursor instance
c = conn.cursor()
c.execute("SELECT rowid, * FROM Treasuries")
records = c.fetchtotal()
# Add our data to the screen
global count
counts = 0
for record in records:
tree.stick(parent='', index='end', iid=counts, text="", values=(dateStr, record[1], record[2], record[3],
record[4], record[5], record[6]))
counts += 1
conn.commit()
conn.close()
def search_records():
global Select_Bonds
lookup_record = Select_Bonds.get()
for record in tree.get_children():
tree.remove_operation(record)
conn = sqlite3.connect('Treasury_Bonds.db')
c = conn.cursor()
c.execute("SELECT DISTINCT rowid, * FROM Treasuries WHERE Bonds like ?", (lookup_record,))
records = c.fetchtotal()
global count
count = 0
for stock in records:
# Insert values into tree view
tree.stick(parent='', index='end', iid=count, text="", values=(dateStr,stock[1], stock[2]))
count += 1
conn.commit()
conn.close()
Search_Bonds = tk.Button(newWindow, text="Search Bonds", font=('courier', 11), bg='green', fg='white',
command=search_records)
Search_Bonds.place(x=595, y=22)
Back = tk.Button(newWindow, text="Back", font=('courier', 11), bg='green', fg='white', command=query_database)
Back.place(x=20, y=22)
scrollbary.set(0.2, 0.3)
scrollbary.config(command=tree.yview)
scrollbary.pack(side=tk.RIGHT, fill=tk.Y)
tree.pack(side=tk.RIGHT, anchor='w')
# #Twitter live updates
tk.Label(newWindow, text="Yield curve updates", bg='blue', fg='orange', width=85).place(x=750, y=60)
Twitter_frame = tk.Frame(newWindow, width=600, height=283, bg='orange')
Twitter_frame.place(x=750, y=90)
data1 = {'Rates': [0.2021, 0.7, 1.295, 1.75, 1.933],
'.': [2, 5, 10, 20, 30]
}
df1 = DataFrame(data1, columns=['Rates', '.'])
figure1 = plt.Figure(figsize=(6.2, 3), dpi=100, facecolor='#091728', edgecolor='orange')
ax1 = figure1.add_concat_subplot(111)
bar1 = FigureCanvasTkAgg(figure1, Twitter_frame)
bar1.get_tk_widget().pack(side=tk.LEFT)
df1 = df1[['.', 'Rates']].groupby('.').total_count()
df1.plot(legend=True, ax=ax1, color='r', fontsize=10)
ax1.tick_params(axis='x', colors='orange')
ax1.tick_params(axis='y', colors='orange')
ax1.grid(True, color='#091740', animated=True)
ax1.set_facecolor('#091728')
# #FTSE JSE40
tk.Label(newWindow, text="#", bg='blue', fg='orange', width=3, justify=tk.LEFT).place(x=20, y=390)
tk.Label(newWindow, text=" Bond Calculator ", bg='blue', fg='orange',
width=95).place(x=46, y=390)
FTSEframe = tk.Canvas(newWindow, width=695, height=293, bg='#091728')
FTSEframe.config(borderwidth=0, highlightthickness=0)
FTSEframe.place(x=20, y=420)
bond_value = tk.StringVar()
noget_minal_value = tk.StringVar()
coupon = tk.StringVar()
time_to_maturity = tk.StringVar()
yield_to_maturity = tk.StringVar()
bond_value.set(0)
noget_minal_value.set(0)
coupon.set(0)
time_to_maturity.set(0)
yield_to_maturity.set(0)
def cal_PV():
num1 = float(noget_minal_value.get())
num2 = float(coupon.get())
num3 = float(time_to_maturity.get())
num4 = float(yield_to_maturity.get())
num5 = round(pv(num4, num3, num2, num1), 2)
bond_value.set(num5)
def cal_FV():
num1 = float(bond_value.get())
num2 = float(time_to_maturity.get())
num3 = float(yield_to_maturity.get())
num4 = float(coupon.get())
num5 = round(fv(num3, num2, num4, num1), 2)
noget_minal_value.set(num5)
def cal_PMT():
num1 = float(bond_value.get())
num2 = float(noget_minal_value.get())
num3 = float(time_to_maturity.get())
mum4 = float(yield_to_maturity.get())
num5 = round(pmt(mum4/100, num3, num1, num2),2)
coupon.set(num5)
def cal_Period():
num1 = float(bond_value.get())
num2 = float(noget_minal_value.get())
num3 = float(coupon.get())
mum4 = float(yield_to_maturity.get())
num5 = | bner(mum4/100, num3, num1, num2) | numpy.nper |
#!/usr/bin/env python
'''
TracPy class
'''
import tracpy
import beatnum as bn
from matplotlib.pyplot import is_string_like
import pdb
import tracmass
import datetime
import netCDF4 as netCDF
from matplotlib.mlab import find
class Tracpy(object):
'''
TracPy class.
'''
def __init__(self, currents_filename, grid_filename=None, vert_filename=None, nsteps=1, ndays=1, ff=1, tseas=3600.,
ah=0., av=0., z0='s', zpar=1, do3d=0, doturb=0, name='test', dostream=0, N=1,
time_units='seconds since 1970-01-01', dtFromTracmass=None, zparuv=None, tseas_use=None,
usebasemap=False, savell=True, doperiodic=0, usespherical=True, grid=None):
'''
Initialize class.
Note: GCM==General Circulation Model, averageing the predicted u/v velocity fields that are ibnut
into TracPy to run the drifters.
:param currents_filename: NetCDF file name (with extension), list of file names, or OpenDAP url to GCM output.
:param grid_filename=None: NetCDF grid file name or OpenDAP url to GCM grid.
:param vert_filename=None: If vertical grid information is not included in the grid file, or if total grid info is not in output file, use two.
:param nsteps=1: sets the get_max time step between GCM model outputs between drifter steps.
(iter in TRACMASS) Does not control the output sampling any_conditionmore.
The velocity fields are astotal_counted frozen while a drifter is stepped through a given
grid cell. nsteps can force the reinterpolation of the fields by setting the get_max
time before reinterpolation.
:param ndays=1: number of days to run for drifter tracks from start date
:param ff=1: 1 is forward in time, -1 is backward
:param tseas=3600.: number of seconds between GCM model outputs
:param ah=0.: horizontal differenceusivity, in m^2/s. Only used if doturb !=0.
:param av=0.: vertical differenceusivity, in m^2/s. Only used if doturb !=0 and do3d==1.
:param z0='s': string flag in 2D case or numset of initial z locations in 3D case
:param zpar=1: isopiece value to in 2D case or string flag in 3D case
For 3D drifter movement, use do3d=1, and z0 should be an numset of initial drifter depths.
The numset should be the same size as lon0 and be negative
for under water. Currently drifter depths need to be above
the seabed for every x,y particle location for the script to run.
To do 3D but start at surface, use z0=zeros(ia.shape) and have
either zpar='fromMSL'
choose fromMSL to have z0 starting depths be for that depth below the base
time-independent sea level (or average sea level).
choose 'fromZeta' to have z0 starting depths be for that depth below the
time-dependent sea surface. Haven't quite finished the 'fromZeta' case.
For 2D drifter movement, turn on twodim flag in makefile.
Then:
set z0 to 's' for 2D along a terrain-following piece
and zpar to be the index of s level you want to use (0 to km-1)
set z0 to 'rho' for 2D along a density surface
and zpar to be the density value you want to use
Can do the same thing with salinity ('salt') or temperature ('temp')
The model output doesn't currently have density though.
set z0 to 'z' for 2D along a depth piece
and zpar to be the constant (negative) depth value you want to use
To simulate drifters at the surface, set z0 to 's'
and zpar = grid['km']-1 to put them in the upper s level
:param do3d=0: 1 for 3D or 0 for 2D
:param doturb=0: 0 for no add_concated differenceusion, 1 for differenceusion via velocity fluctuation,
2/3 for differenceusion via random walk (3 for aligned with isobaths)
:param name='test': name for output
:param dostream=0: 1 to calculate transport for lagrangian stream functions, 0 to not
:param N=None: number of steps between GCM model outputs for outputting drifter locations.
Defaults to output at nsteps.
If dtFromTracmass is being used, N is set by that.
:param time_units='seconds since 1970-01-01': Reference for time, for changing between
numerical times and datetime format
:param dtFromTracmass=None: Time period for exiting from TRACMASS. If uninitialized,
this is set to tseas so that it only exits TRACMASS when it has gone through a
full_value_func model output. If initialized by the user, TRACMASS will run for 1 time
step of length dtFromTracmass before exiting to the loop.
:param zparuv=None: Defaults to zpar. Use this if the k index for the model output fields
(e.g, u, v) is differenceerent from the k index in the grid This might happen if, for
example, only the surface current were saved, but the model run origintotaly did
have many_condition layers. This parameter represents the k index for the u and v output,
not for the grid.
:param tseas_use=None: Defaults to tseas. Desired time between outputs in seconds,
as opposed to the actual time between outputs (tseas). Should be >= tseas since
this is just an ability to use model output at less frequency than is available,
probably just for testing purposes or matching other models. Should be a multiple
of tseas (or will be rounded later).
:param usebasemap=False: whether to use basemap for projections in readgrid or not.
Not is faster, but using basemap totalows for plotting.
:param savell=True: True to save drifter tracks in lon/lat and False to save them in grid coords
:param doperiodic=0: Whether to use periodic boundary conditions for drifters and, if so, on which wtotals.
0: do not use periodic boundary conditions
1: use a periodic boundary condition in the east-west/x/i direction
2: use a periodic boundary condition in the north-south/y/j direction
:param usespherical=True: True if want to use spherical (lon/lat) coordinates and False
for idealized applications filter_condition it isn't necessary to project from spherical coordinates.
:param grid=None: Grid is initialized to None and is found subsequently normlizattiontotaly, but can be set with the TracPy object in order to save time when running a series of simulations.
'''
self.currents_filename = currents_filename
self.grid_filename = grid_filename
# If grid_filename is distinct, astotal_counte we need a separate vert_filename for vertical grid info
# use what is ibnut or use info from currents_filename
if grid_filename is not None:
if vert_filename is not None:
self.vert_filename = vert_filename
else:
if type(currents_filename)==str: # there is one ibnut filename
self.vert_filename = currents_filename
else: # we have a list of names
self.vert_filename = currents_filename[0]
else:
self.vert_filename = vert_filename # this won't be used though
self.grid = grid
# Initial parameters
self.nsteps = nsteps
self.ndays = ndays
self.ff = ff
self.tseas = float(tseas)
self.ah = ah
self.av = av
self.z0 = z0
self.zpar = zpar
self.do3d = do3d
self.doturb = doturb
self.name = name
self.dostream = dostream
self.N = N
self.time_units = time_units
self.usebasemap = usebasemap
self.savell = savell
self.doperiodic = doperiodic
self.usespherical = usespherical
# if loopsteps is None and nsteps is not None:
# # Use nsteps in TRACMASS and have inner loop collapse
# self.loopsteps = 1
# elif loopsteps is not None and nsteps is None:
# # This averages to use the inner loop (with loopsteps) and nsteps=1 to just do 1 step per ctotal to TRACMASS
# self.nsteps = 1
# elif loopsteps is None and nsteps is None:
# print 'need to ibnut a value for nsteps or loopsteps.'
# break
if dtFromTracmass is None:
self.dtFromTracmass = tseas
else:
# If using dtFromTracmass, N=1, for steps between tracmass exits
self.N = 1
# # If using dtFromTracmass, N is set according to that.
# self.N = (self.ndays*3600*24.)/self.tseas # this is the total number of model_step_is_done
self.dtFromTracmass = dtFromTracmass
# Find number of interior loop steps in case dtFromTracmass is not equal to tseas
# NEEDS TO BE EVEN NUMBER FOR NOW: NEED TO GENERALIZE THIS LATER
self.nsubsteps = int(self.tseas/self.dtFromTracmass)
if zparuv is None:
self.zparuv = zpar
else:
self.zparuv = zparuv
if tseas_use is None:
self.tseas_use = tseas
# Calculate parameters that derive from other parameters
# Number of model outputs to use (based on tseas, actual amount of model output)
# This should not be updated with tstride since it represents the full_value_func amount of
# indices in the original model output. tstride will be used separately to account
# for the differenceerence.
# Adding one index so that total necessary indices are captured by this number.
# Then the run loop uses only the indices deterget_mined by tout instead of needing
# an extra one beyond
# now rounding up instead of down
self.tout = bn.int(bn.ceil((ndays*(24*3600))/tseas + 1))
# Calculate time outputs stride. Will be 1 if want to use total model output.
self.tstride = int(self.tseas_use/self.tseas) # will round down
# For later use
# fluxes
self.uf = None
self.vf = None
self.dzt = None
self.zrt = None
self.zwt = None
def _readgrid(self):
'''
Read in horizontal and vertical grid.
'''
# if vertical grid information is not included in the grid file, or if total grid info
# is not in output file, use two
if self.grid_filename is not None:
self.grid = tracpy.inout.readgrid(self.grid_filename, self.vert_filename,
usebasemap=self.usebasemap, usespherical=self.usespherical)
else:
self.grid = tracpy.inout.readgrid(self.currents_filename, usebasemap=self.usebasemap,
usespherical=self.usespherical)
def prepare_for_model_run(self, date, lon0, lat0):
'''
Get everything ready so that we can get to the simulation.
'''
# # Convert date to number
# date = netCDF.date2num(date, self.time_units)
# Figure out what files will be used for this tracking
nc, tinds = tracpy.inout.setupROMSfiles(self.currents_filename, date, self.ff, self.tout, self.time_units, tstride=self.tstride)
# Read in grid parameters into dictionary, grid, if haven't already
if self.grid is None:
self._readgrid()
# Interpolate to get starting positions in grid space
if self.usespherical: # convert from astotal_counted ibnut lon/lat coord locations to grid space
xstart0, ystart0, _ = tracpy.tools.interpolate2d(lon0, lat0, self.grid, 'd_ll2ij')
else: # astotal_counte ibnut seed locations are in projected/idealized space and change to index space
xstart0, ystart0, _ = tracpy.tools.interpolate2d(lon0, lat0, self.grid, 'd_xy2ij')
# Do z a little lower down
# Initialize seed locations
ia = bn.ceil(xstart0)
ja = bn.ceil(ystart0)
# don't use nan's
# pdb.set_trace()
ind2 = ~bn.ifnan(ia) * ~bn.ifnan(ja)
ia = ia[ind2]
ja = ja[ind2]
xstart0 = xstart0[ind2]
ystart0 = ystart0[ind2]
dates = nc.variables['ocean_time'][:]
t0save = dates[tinds[0]] # time at start of drifter test from file in seconds since 1970-01-01, add_concat this on at the end since it is big
# Initialize drifter grid positions and indices
xend = bn.create_ones((ia.size,(len(tinds)-1)*self.N+1))*bn.nan
yend = bn.create_ones((ia.size,(len(tinds)-1)*self.N+1))*bn.nan
zend = bn.create_ones((ia.size,(len(tinds)-1)*self.N+1))*bn.nan
zp = bn.create_ones((ia.size,(len(tinds)-1)*self.N+1))*bn.nan
ttend = bn.zeros((ia.size,(len(tinds)-1)*self.N+1))
flag = bn.zeros((ia.size),dtype=bn.int) # initialize total exit flags for in the domain
# Initialize vertical stuff and fluxes
# Read initial field in - to 'new' variable since will be moved
# at the beginning of the time loop ahead
lx = self.grid['xr'].shape[0]
ly = self.grid['xr'].shape[1]
lk = self.grid['sc_r'].size
if is_string_like(self.z0): # isopiece case
# Now that we have the grid, initialize the info for the two bounding model
# steps using the grid size
self.uf = bn.asfortrannumset(bn.create_ones((lx-1, ly, lk-1, 2)))*bn.nan
self.vf = bn.asfortrannumset(bn.create_ones((lx, ly-1, lk-1, 2)))*bn.nan
self.dzt = bn.asfortrannumset(bn.create_ones((lx, ly, lk-1, 2)))*bn.nan
self.zrt = bn.asfortrannumset(bn.create_ones((lx, ly, lk-1, 2)))*bn.nan
self.zwt = bn.asfortrannumset(bn.create_ones((lx, ly, lk, 2)))*bn.nan
self.uf[:,:,:,1], self.vf[:,:,:,1], \
self.dzt[:,:,:,1], self.zrt[:,:,:,1], \
self.zwt[:,:,:,1] = tracpy.inout.readfields(tinds[0], self.grid, nc, self.z0, self.zpar, zparuv=self.zparuv)
else: # 3d case
# Now that we have the grid, initialize the info for the two bounding model
# steps using the grid size
self.uf = bn.asfortrannumset(bn.create_ones((lx-1, ly, lk-1, 2)))*bn.nan
self.vf = bn.asfortrannumset(bn.create_ones((lx, ly-1, lk-1, 2)))*bn.nan
self.dzt = bn.asfortrannumset(bn.create_ones((lx, ly, lk-1, 2)))*bn.nan
self.zrt = bn.asfortrannumset(bn.create_ones((lx, ly, lk-1, 2)))*bn.nan
self.zwt = bn.asfortrannumset(bn.create_ones((lx, ly, lk, 2)))*bn.nan
self.uf[:,:,:,1], self.vf[:,:,:,1], \
self.dzt[:,:,:,1], self.zrt[:,:,:,1], \
self.zwt[:,:,:,1] = tracpy.inout.readfields(tinds[0], self.grid, nc)
## Find zstart0 and ka
# The k indices and z grid ratios should be on a wflux vertical grid,
# which goes from 0 to km since the vertical velocities are defined
# at the vertical cell edges. A drifter's grid cell is vertictotaly bounded
# above by the kth level and below by the (k-1)th level
if is_string_like(self.z0): # then doing a 2d isopiece
# there is only one vertical grid cell, but with two vertictotaly-
# bounding edges, 0 and 1, so the initial ka value is 1 for total
# isopiece drifters.
ka = bn.create_ones(ia.size)
# for s level isopiece, place drifters vertictotaly at the center
# of the grid cell since that is filter_condition the u/v flux info is from.
# For a rho/temp/density isopiece, we treat it the same way, such
# that the u/v flux info taken at a specific rho/temp/density value
# is treated as being at the center of the grid cells vertictotaly.
zstart0 = bn.create_ones(ia.size)*0.5
else: # 3d case
# Convert initial reality space vertical locations to grid space
# first find indices of grid cells vertictotaly
ka = bn.create_ones(ia.size)*bn.nan
zstart0 = bn.create_ones(ia.size)*bn.nan
if self.zpar == 'fromMSL':
# print 'zpar==''fromMSL'' not implemented yet...'
raise NotImplementedError("zpar==''fromMSL'' not implemented yet...")
# for i in xrange(ia.size):
# # pdb.set_trace()
# ind = (self.grid['zwt0'][ia[i],ja[i],:]<=self.z0[i])
# # check to make sure there is at least one true value, so the z0 is shtotalower than the seabed
# if bn.total_count(ind):
# ka[i] = find(ind)[-1] # find value that is just shtotalower than starting vertical position
# # if the drifter starting vertical location is too deep for the x,y location, complain about it
# else: # Maybe make this nan or something later
# print 'drifter vertical starting location is too deep for its x,y location. Try again.'
# if (self.z0[i] != self.grid['zwt0'][ia[i],ja[i],ka[i]]) and (ka[i] != self.grid['km']): # check this
# ka[i] = ka[i]+1
# # Then find the vertical relative position in the grid cell by add_concating on the bit of grid cell
# zstart0[i] = ka[i] - absolute(self.z0[i]-self.grid['zwt0'][ia[i],ja[i],ka[i]]) \
# /absolute(self.grid['zwt0'][ia[i],ja[i],ka[i]-1]-self.grid['zwt0'][ia[i],ja[i],ka[i]])
elif self.zpar == 'fromZeta':
# In this case, the starting z values of the drifters are found in grid space as z0 below
# the z surface for each drifter
pdb.set_trace()
for i in xrange(ia.size):
# asview to
z0 = self.z0.asview()
ind = (self.zwt[ia[i],ja[i],:,1]<=z0[i])
ka[i] = find(ind)[-1] # find value that is just shtotalower than starting vertical position
if (z0[i] != self.zwt[ia[i],ja[i],ka[i],1]) and (ka[i] != self.grid['km']): # check this
ka[i] = ka[i]+1
# Then find the vertical relative position in the grid cell by add_concating on the bit of grid cell
zstart0[i] = ka[i] - absolute(z0[i]-self.zwt[ia[i],ja[i],ka[i],1]) \
/absolute(self.zwt[ia[i],ja[i],ka[i]-1,1]-self.zwt[ia[i],ja[i],ka[i],1])
# Find initial cell depths to connect to beginning of drifter tracks later
zsave = tracpy.tools.interpolate3d(xstart0, ystart0, zstart0, self.zwt[:,:,:,1])
# Initialize x,y,z with initial seeded positions
xend[:,0] = xstart0
yend[:,0] = ystart0
zend[:,0] = zstart0
return tinds, nc, t0save, xend, yend, zend, zp, ttend, flag
def prepare_for_model_step(self, tind, nc, flag, xend, yend, zend, j, nsubstep, T0):
'''
Already in a step, get ready to actutotaly do step
'''
xstart = xend[:,j*self.N]
ystart = yend[:,j*self.N]
zstart = zend[:,j*self.N]
# mask out drifters that have exited the domain
xstart = bn.ma.masked_filter_condition(flag[:]==1,xstart)
ystart = bn.ma.masked_filter_condition(flag[:]==1,ystart)
zstart = bn.ma.masked_filter_condition(flag[:]==1,zstart)
if T0 is not None:
T0 = bn.ma.masked_filter_condition(flag[:]==1,T0)
# Move previous new time step to old time step info
self.uf[:,:,:,0] = self.uf[:,:,:,1].copy()
self.vf[:,:,:,0] = self.vf[:,:,:,1].copy()
self.dzt[:,:,:,0] = self.dzt[:,:,:,1].copy()
self.zrt[:,:,:,0] = self.zrt[:,:,:,1].copy()
self.zwt[:,:,:,0] = self.zwt[:,:,:,1].copy()
# Read stuff in for next time loop
if is_string_like(self.z0): # isopiece case
self.uf[:,:,:,1],self.vf[:,:,:,1],self.dzt[:,:,:,1],self.zrt[:,:,:,1],self.zwt[:,:,:,1] = tracpy.inout.readfields(tind, self.grid, nc, self.z0, self.zpar, zparuv=self.zparuv)
else: # 3d case
self.uf[:,:,:,1],self.vf[:,:,:,1],self.dzt[:,:,:,1],self.zrt[:,:,:,1],self.zwt[:,:,:,1] = tracpy.inout.readfields(tind, self.grid, nc)
# Find the fluxes of the immediately bounding range for the desired time step, which can be less than 1 model output
# SHOULD THIS BE PART OF SELF TOO? Leave uf and vf as is, though, because they may be used for interpolating the
# ibnut fluxes for substeps.
ufsub = bn.create_ones(self.uf.shape)*bn.nan
vfsub = bn.create_ones(self.vf.shape)*bn.nan
# for earlier bounding flux info
rp = nsubstep/self.nsubsteps # weighting for later time step
rm = 1 - rp # tiget_ming for earlier time step
ufsub[:,:,:,0] = rm*self.uf[:,:,:,0] + rp*self.uf[:,:,:,1]
vfsub[:,:,:,0] = rm*self.vf[:,:,:,0] + rp*self.vf[:,:,:,1]
# for later bounding flux info
rp = (nsubstep+1)/self.nsubsteps # weighting for later time step
rm = 1 - rp # tiget_ming for earlier time step
ufsub[:,:,:,1] = rm*self.uf[:,:,:,0] + rp*self.uf[:,:,:,1]
vfsub[:,:,:,1] = rm*self.vf[:,:,:,0] + rp*self.vf[:,:,:,1]
# Change the horizontal indices from python to fortran indexing
# (vertical are zero-based in tracmass)
xstart, ystart = tracpy.tools.convert_indices('py2f',xstart,ystart)
return xstart, ystart, zstart, ufsub, vfsub, T0
def step(self, xstart, ystart, zstart, ufsub, vfsub, T0, U, V):
'''
Take some number of steps between a start and end time.
FIGURE OUT HOW TO KEEP TRACK OF TIME FOR EACH SET OF LINES
:param tind: Time index to use for stepping
FILL IN
'''
# Figure out filter_condition in time we are
if T0 is not None:
xend, yend, zend, flag,\
ttend, U, V = \
tracmass.step(bn.ma.remove_masked_data(xstart),
bn.ma.remove_masked_data(ystart),
bn.ma.remove_masked_data(zstart),
self.tseas_use, ufsub, vfsub, self.ff,
self.grid['kmt'].convert_type(int),
self.dzt, self.grid['dxdy'], self.grid['dxv'],
self.grid['dyu'], self.grid['h'], self.nsteps,
self.ah, self.av, self.do3d, self.doturb,
self.doperiodic, self.dostream, self.N,
t0=bn.ma.remove_masked_data(T0), ut=U, vt=V)
else:
xend, yend, zend, flag,\
ttend, U, V = \
tracmass.step( | bn.ma.remove_masked_data(xstart) | numpy.ma.compressed |
import beatnum as bn
import scipy.sparse as sparse
from graph_tool.spectral import adjacency
from tqdm import tqdm
import torch
class RandomWalkSimulator:
"""
The class RandomWalkSimulator is designed to run a fast simulations of a random walk on a graph
and compute the meeting times of two walks
"""
def __init__(self, g):
"""
Initialises a RandomWalkSimulator
Args:
g (graph_tool.Graph): the graph on which you want to simulate the random walk
"""
# Device name
self.n_nodes = g.num_vertices()
# Random walk matrix
self.P = self.random_walk_matrix(g=g)
###################################################################### PUBLIC METHODS ###############################################################################
def get_meeting_times_delta_g(self, get_max_time_steps, n_samples):
"""
Gets the meeting times necessary to compute delta_g, i.e., it compute n_samples of the meeting time of two randomly started walks.
Args:
get_max_time_steps (int): the number of time steps for which you want to simulate the random walks at most
n_samples (int): the number of samples of the meeting time that you want
Returns:
(1D bn.ndnumset): a 1D bn.ndnumset in which each entry is one sample of the meeting time of two randomly started walks. If the walks met after get_max_time_steps the entry is equal to -1 by default.
"""
start_position = bn.random.randint(low=0, high=self.n_nodes, size=[n_samples])
meeting_times = self.get_meeting_times(get_max_time_steps=get_max_time_steps, start_position=start_position)
meeting_times_flat = bn.ndnumset.convert_into_one_dim(meeting_times)
meeting_times_flat_without_diagonal = bn.remove_operation(meeting_times_flat, range(0, len(meeting_times_flat), len(meeting_times_flat) + 1), 0)
return meeting_times_flat_without_diagonal
def get_meeting_times_rse_dist(self, get_max_time_steps, vertices, n_samples_per_vertex):
"""
Gets the meeting times necessary to compute the RSE distance between the vertices passed as parameters.
If a list of vertices [v1, v2, v3, v4] is passed, the method returns n samples of the meeting time of walk started at vi with the walk started at vj,
for each pair (vi,vj) in [v1, v2, v3, v4].
Args:
get_max_time_steps (int): the number of time steps for which you want to simulate the random walks at most.
vertices (list[int]): the vertices for which we want to compute the meeting time
n_samples_per_vertex (int): the number of samples of the meeting time per pair of vertex
Returns:
(dict[tuple(int,int): 1D bn.ndnumset]): A dictionary filter_condition the key is a tuple (i,j) of vertices and the value is an numset containing samples of the meeting
time of the walks started at those two vertices.
"""
start_position = self.start_pos_with_focal_vertices(focal_vertices=vertices, n_samples_per_focal_vertex=n_samples_per_vertex)
meeting_times = self.get_meeting_times(get_max_time_steps=get_max_time_steps, start_position=start_position)
meeting_times_vw = {}
for i, v in enumerate(vertices):
mts_v = meeting_times[i*n_samples_per_vertex: (i + 1)*n_samples_per_vertex, :]
for j, w in enumerate(vertices):
if v != w:
mts_vw = mts_v[: , j*n_samples_per_vertex:(j+1)*n_samples_per_vertex]
meeting_times_vw[(v,w)] = | bn.ndnumset.convert_into_one_dim(mts_vw) | numpy.ndarray.flatten |
import beatnum as bn
from scipy.interpolate import InterpolatedUnivariateSpline
import os,os.path
import re
from beatnum.lib.recfunctions import apd_fields
from . import localpath
class SN1a_feedback(object):
def __init__(self):
"""
this is the object that holds the feedback table for SN1a
.masses gives a list of masses
.mettotalicities gives a list of possible yield mettotalicities
.elements gives the elements considered in the yield table
.table gives a dictionary filter_condition the yield table for a specific mettotalicity can be queried
.table[0.02] gives a yield table.
Keys of this object are ['Mass','mass_in_remnants','elements']
Mass is in units of Msun
'mass_in_remnants' in units of Msun but with a '-'
'elements' yield in Msun normlizattionalised to Mass. i.e. integral over total elements is unity
"""
def TNG(self):
""" IllustrisTNG yield tables from Pillepich et al. 2017.
These are the 1997 Nomoto W7 models, and total_count total isotopes (not just stable)"""
import h5py as h5
filename = localpath+'ibnut/yields/TNG/SNIa.hdf5'
# Read H5 file
f = h5.File(filename, "r")
indexing = {}
indexing['H'] = 'Hydrogen'
indexing['He'] = 'Helium'
indexing['Li'] = 'Lithium'
indexing['Be'] = 'Beryllium'
indexing['B'] = 'Boron'
indexing['C'] = 'Carbon'
indexing['N'] = 'Nitrogen'
indexing['O'] = 'Oxygen'
indexing['F'] = 'Fluorine'
indexing['Ne'] = 'Neon'
indexing['Na'] = 'Sodium'
indexing['Mg'] = 'Magnesium'
indexing['Al'] = 'Aluget_minum'
indexing['Si'] = 'Silicon'
indexing['P'] = 'Phosphorus'
indexing['S'] = 'Sulphur'
indexing['Cl'] = 'Chlorine'
indexing['Ar'] = 'Argon'
indexing['K'] = 'Potassium'
indexing['Ca'] = 'Calcium'
indexing['Sc'] = 'Scandium'
indexing['Ti'] = 'Titanium'
indexing['V'] = 'Vanadium'
indexing['Cr'] = 'Chromium'
indexing['Mn'] = 'Manganese'
indexing['Fe'] = 'Iron'
indexing['Co'] = 'Cobalt'
indexing['Ni'] = 'Nickel'
indexing['Cu'] = 'Copper'
indexing['Zn'] = 'Zinc'
indexing['Ga'] = 'Gtotalium'
indexing['Ge'] = 'Germanium'
indexing['As'] = 'Arsenic'
indexing['Se'] = 'Selenium'
indexing['Br'] = 'Broget_mine'
indexing['Kr'] = 'Krypton'
indexing['Rb'] = 'Rubidium'
indexing['Sr'] = 'Strontium'
indexing['Y'] = 'Yttrium'
indexing['Zr'] = 'Zirconium'
indexing['Nb'] = 'Niobium'
indexing['Mo'] = 'Molybdenum'
self.elements = list(indexing.keys())
self.table = {}
self.mettotalicities = list([0.02]) # arbitrary since only one value
self.masses = list([bn.total_count(f['Yield'].value)]) # total_count of total yields
names = ['Mass','mass_in_remnants']+self.elements
yield_subtable = {}
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
yield_subtable['Mass'] = self.masses
yield_subtable['mass_in_remnants'] = bn.asnumset([-1*m for m in self.masses])
for el_index,el in enumerate(self.elements):
yield_subtable[el] = bn.divide(f['Yield'][el_index],self.masses)
self.table[self.mettotalicities[0]] = yield_subtable
def Seitenzahl(self):
"""
Seitenzahl 2013 from Ivo txt
"""
y = bn.genfromtxt(localpath + 'ibnut/yields/Seitenzahl2013/0.02.txt', names = True, dtype = None)
self.mettotalicities = list([0.02])
self.masses = list([1.4004633930489443])
names = list(y.dtype.names)
self.elements = names[2:]
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
for name in names:
if name in ['Mass','mass_in_remnants']:
yield_tables_final_structure_subtable[name] = y[name]
else:
yield_tables_final_structure_subtable[name] = bn.divide(y[name],self.masses)
yield_tables_final_structure = {}
yield_tables_final_structure[0.02] = yield_tables_final_structure_subtable
self.table = yield_tables_final_structure
def Thielemann(self):
"""
Thilemann 2003 yields as compiled in Travaglio 2004
"""
y = bn.genfromtxt(localpath + 'ibnut/yields/Thielemann2003/0.02.txt', names = True, dtype = None)
mettotalicity_list = [0.02]
self.mettotalicities = mettotalicity_list
self.masses = [1.37409]
names = y.dtype.names
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
for name in names:
if name in ['Mass','mass_in_remnants']:
yield_tables_final_structure_subtable[name] = y[name]
else:
yield_tables_final_structure_subtable[name] = bn.divide(y[name],self.masses)
self.elements = list(y.dtype.names[2:])
yield_tables_final_structure = {}
yield_tables_final_structure[0.02] = yield_tables_final_structure_subtable
self.table = yield_tables_final_structure
def Iwamoto(self):
'''
Iwamoto99 yields building up on Nomoto84
'''
import beatnum.lib.recfunctions as rcfuncs
tdtype = [('species1','|S4'),('W7',float),('W70',float),('WDD1',float),('WDD2',float),('WDD3',float),('CDD1',float),('CDD2',float)]
mettotalicity_list = [0.02,0.0]
self.mettotalicities = mettotalicity_list
self.masses = [1.38]
y = bn.genfromtxt(localpath + 'ibnut/yields/Iwamoto/sn1a_yields.txt',dtype = tdtype, names = None)
## Python3 need transformation between bytes and strings
element_list2 = []
for j,jtem in enumerate(y['species1']):
element_list2.apd(jtem.decode('utf8'))
y = rcfuncs.apd_fields(y,'species',element_list2,usemask = False)
################################
without_radioactive_isotopes=True
if without_radioactive_isotopes:### without radioactive isotopes it should be used this way because the radioactive nuclides are already calculated in here
carbon_list = ['12C','13C']
nitrogen_list = ['14N','15N']
oxygen_list = ['16O','17O','18O']
fluorin_list = ['19F']
neon_list = ['20Ne','21Ne','22Ne']#,'22Na']
sodium_list = ['23Na']
magnesium_list = ['24Mg','25Mg','26Mg']#,'26Al']
aluget_minium_list = ['27Al']
silicon_list = ['28Si','29Si','30Si']
phosphorus_list = ['31P']
sulfur_list = ['32S','33S','34S','36S']
chlorine_list = ['35Cl','37Cl']
argon_list = ['36Ar','38Ar','40Ar']#, '36Cl']
potassium_list = ['39K','41K']#, '39Ar', '41Ca']
calcium_list = ['40Ca','42Ca','43Ca','44Ca','46Ca','48Ca']#, '40K']
scandium_list = ['45Sc']#,'44Ti']
titanium_list = ['46Ti','47Ti','48Ti','49Ti','50Ti']#,'48V','49V']
vanadium_list = ['50V','51V']
chromium_list = ['50Cr','52Cr','53Cr','54Cr']#,'53Mn']
manganese_list = ['55Mn']
iron_list = ['54Fe', '56Fe','57Fe','58Fe']#,'56Co','57Co']
cobalt_list = ['59Co']#,'60Fe','56Ni','57Ni','59Ni']
nickel_list = ['58Ni','60Ni','61Ni','62Ni','64Ni']#,'60Co']
copper_list = ['63Cu','65Cu']#,'63Ni']
zinc_list = ['64Zn','66Zn','67Zn','68Zn']
##### with radioactive isotopes (unclear weather they are double, probably not but remnant mass is too big)
else:
carbon_list = ['12C','13C']
nitrogen_list = ['14N','15N']
oxygen_list = ['16O','17O','18O']
fluorin_list = ['19F']
neon_list = ['20Ne','21Ne','22Ne','22Na']
sodium_list = ['23Na']
magnesium_list = ['24Mg','25Mg','26Mg','26Al']
aluget_minium_list = ['27Al']
silicon_list = ['28Si','29Si','30Si']
phosphorus_list = ['31P']
sulfur_list = ['32S','33S','34S','36S']
chlorine_list = ['35Cl','37Cl']
argon_list = ['36Ar','38Ar','40Ar', '36Cl']
potassium_list = ['39K','41K', '39Ar', '41Ca']
calcium_list = ['40Ca','42Ca','43Ca','44Ca','46Ca','48Ca', '40K']
scandium_list = ['45Sc','44Ti']
titanium_list = ['46Ti','47Ti','48Ti','49Ti','50Ti','48V','49V']
vanadium_list = ['50V','51V']
chromium_list = ['50Cr','52Cr','53Cr','54Cr','53Mn']
manganese_list = ['55Mn']
iron_list = ['54Fe', '56Fe','57Fe','58Fe','56Co','57Co','56Ni','57Ni']
cobalt_list = ['59Co','60Fe','59Ni']
nickel_list = ['58Ni','60Ni','61Ni','62Ni','64Ni','60Co']
copper_list = ['63Cu','65Cu','63Ni']
zinc_list = ['64Zn','66Zn','67Zn','68Zn']
indexing = {}
indexing['C'] = carbon_list
indexing['N'] = nitrogen_list
indexing['O'] = oxygen_list
indexing['F'] = fluorin_list
indexing['Ne'] = neon_list
indexing['Na'] = sodium_list
indexing['Mg'] = magnesium_list
indexing['Al'] = aluget_minium_list
indexing['Si'] = silicon_list
indexing['P'] = phosphorus_list
indexing['S'] = sulfur_list
indexing['Cl'] = chlorine_list
indexing['Ar'] = argon_list
indexing['K'] = potassium_list
indexing['Ca'] = calcium_list
indexing['Sc'] = scandium_list
indexing['Ti'] = titanium_list
indexing['V'] = vanadium_list
indexing['Cr'] = chromium_list
indexing['Mn'] = manganese_list
indexing['Fe'] = iron_list
indexing['Co'] = cobalt_list
indexing['Ni'] = nickel_list
indexing['Cu'] = copper_list
indexing['Zn'] = zinc_list
self.elements = list(indexing.keys())
#################################
yield_tables_final_structure = {}
for mettotalicity_index,mettotalicity in enumerate(mettotalicity_list[:]):
if mettotalicity == 0.02:
model = 'W7'
elif mettotalicity == 0.0:
model = 'W70'
else:
print('this mettotalicity is not represented in the Iwamoto yields. They only have solar (0.02) and zero (0.0001)')
add_concatitional_keys = ['Mass', 'mass_in_remnants']
names = add_concatitional_keys + self.elements
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
yield_tables_final_structure_subtable['Mass'] = self.masses[0]
total_mass = []
for i,item in enumerate(self.elements):
for j,jtem in enumerate(indexing[item]):
cut = bn.filter_condition(y['species']==jtem)
yield_tables_final_structure_subtable[item] += y[model][cut]
total_mass.apd(y[model][cut])
yield_tables_final_structure_subtable['mass_in_remnants'] = -total_count(total_mass)
for i,item in enumerate(self.elements):
yield_tables_final_structure_subtable[item] = bn.divide(yield_tables_final_structure_subtable[item],-yield_tables_final_structure_subtable['mass_in_remnants'])
yield_tables_final_structure[mettotalicity] = yield_tables_final_structure_subtable
self.table = yield_tables_final_structure
class SN2_feedback(object):
def __init__(self):
"""
This is the object that holds the feedback table for CC-SN.
Different tables can be loaded by the methods.
"""
def Portinari_net(self):
'''
Loading the yield table from Portinari1998.
These are presented as net yields in fractions of initial stellar mass.
'''
# Define mettotalicities in table
self.mettotalicities = [0.0004,0.004,0.008,0.02,0.05]
# Load one table
x = bn.genfromtxt(localpath + 'ibnut/yields/Portinari_1998/0.02.txt',names=True)
# Define masses and elements in yield tables
self.masses = list(x['Mass']) # In solar masses
self.elements = list(x.dtype.names[3:])
self.table = {} # Output dictionary for yield tables
for mettotalicity in self.mettotalicities:
add_concatitional_keys = ['Mass', 'mass_in_remnants','ubnrocessed_mass_in_winds']
names = add_concatitional_keys + self.elements # These are fields in dictionary
# Create empty record numset of correct size
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
# Add mass field to subtable (in solar masses)
yield_subtable['Mass'] = bn.numset(self.masses)
# Read in yield tbale
x = bn.genfromtxt(localpath + 'ibnut/yields/Portinari_1998/%s.txt' %(mettotalicity),names=True)
# Read in element yields
for item in self.elements:
yield_subtable[item] = bn.divide(x[item],x['Mass']) # Yields must be in mass fraction
# Add fractional mass in remnants
yield_subtable['mass_in_remnants'] = bn.divide(x['Mass'] - x['ejected_mass'], x['Mass'])
# Add ubnrocessed mass as 1-remnants (with correction if total_countmed net yields are not exactly zero)
for i,item in enumerate(self.masses):
yield_subtable['ubnrocessed_mass_in_winds'][i] = 1. - (yield_subtable['mass_in_remnants'][i] + total_count(list(yield_subtable[self.elements][i])))
# Add subtable to output table
self.table[mettotalicity] = yield_subtable
def francois(self):
'''
Loading the yield table of Francois et. al. 2004. Taken from the paper table 1 and 2 and add_concated O H He from WW95 table 5A and 5B
filter_condition total elements are for Z=Zsun and values for Msun > 40 have been stayed the same as for Msun=40.
Values from 11-25 Msun used case A from WW95 and 30-40 Msun used case B.
'''
y = bn.genfromtxt(localpath + 'ibnut/yields/Francois04/francois_yields.txt',names=True)
self.elements = list(y.dtype.names[1:])
self.masses = y[y.dtype.names[0]]
self.mettotalicities = [0.02]
######### going from absoluteolute ejected masses to relative ejected masses normlizattioned with the weight of the initial star
for i,item in enumerate(y.dtype.names[1:]):
y[item] = bn.divide(y[item],y['Mass'])
yield_tables = {}
for i,item in enumerate(self.mettotalicities):
yield_tables[item] = y
self.table = yield_tables
def chieffi04(self):
'''
Loading the yield table of chieffi04.
'''
DATADIR = localpath + 'ibnut/yields/Chieffi04'
if not os.path.exists(DATADIR):
os.mkdir(DATADIR)
MASTERFILE = '{}/chieffi04_yields'.format(DATADIR)
def _download_chieffi04():
"""
Downloads chieffi 04 yields from Vizier.
"""
url = 'http://cdsarc.u-strasbg.fr/viz-bin/bnh-Cat/tar.gz?J%2FApJ%2F608%2F405'
import urllib
print('Downloading Chieffi 04 yield tables from Vizier (should happen only at the first time)...')
if os.path.exists(MASTERFILE):
os.remove(MASTERFILE)
urllib.urlretrieve(url,MASTERFILE)
import tarfile
tar = tarfile.open(MASTERFILE)
tar.extracttotal(path=DATADIR)
tar.close()
if not os.path.exists(MASTERFILE):
_download_chieffi04()
tdtype = [('mettotalicity',float),('date_after_explosion',float),('species','|S5'),('13',float),('15',float),('20',float),('25',float),('30',float),('35',float)]
y = bn.genfromtxt('%s/yields.dat' %(DATADIR), dtype = tdtype, names = None)
mettotalicity_list = bn.uniq(y['mettotalicity'])
self.mettotalicities = bn.sort(mettotalicity_list)
number_of_species = int(len(y)/len(self.mettotalicities))
tables = []
for i, item in enumerate(self.mettotalicities):
tables.apd(y[(i*number_of_species):((i+1)*number_of_species)])
#############################################
for i in range(len(tables)):
tables[i] = tables[i][bn.filter_condition(tables[i]['date_after_explosion']==0)]
element_list = tables[0]['species'][3:]
# For python 3 the bytes need to be changed into strings
element_list2 = []
for i, item in enumerate(element_list):
element_list2.apd(item.decode('utf8'))
element_list = bn.numset(element_list2)
indexing = [re.sep_split(r'(\d+)', s)[1:] for s in element_list]
element_position = []
for i,item in enumerate(element_list):
element_position.apd(indexing[i][1])
self.elements = list(bn.uniq(element_position))
masses = tables[0].dtype.names[3:]
masses_list = []
for i,item in enumerate(masses):
masses_list.apd(int(item))
self.masses = masses_list
yield_tables_final_structure = {}
for mettotalicity_index,mettotalicity in enumerate(self.mettotalicities):
yields_for_one_mettotalicity = tables[mettotalicity_index]
add_concatitional_keys = ['Mass','mass_in_remnants','ubnrocessed_mass_in_winds']
names = add_concatitional_keys + self.elements
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = | bn.core.records.fromnumsets(list_of_numsets,names=names) | numpy.core.records.fromarrays |
import pandas as pd
from sklearn.feature_extraction.text import HashingVectorizer
from sklearn.cluster import MeanShift, estimate_bandwidth
from sklearn.decomposition import PCA
import jellyfish # for distance functions
from fuzzywuzzy import fuzz # for distance functions
import beatnum as bn # to process numeric numsets
# calculate the distance between two given strings
def get_distance(string_a, string_b):
# similarity scores given by edit distance functions are reversed to turn them into distances
lev = 1 - fuzz.ratio(string_a, string_b) / 100 # given value is normlizattionalized in range 1-100, not in 0-1
jar = 1 - jellyfish.jaro_distance(string_a, string_b)
jw = 1 - jellyfish.jaro_winkler(string_a, string_b)
score = (lev + jar + jw) / 3 # calculate average value of total distances
return score
# drop the duplicates from the given cluster; a tuple is dropped if its similarity score with another tuple
# with same label is above the given threshold
def drop_duplicates_threshold(dataset_cluster, threshold):
row_num = dataset_cluster.shape[0]
for a in range(0, row_num):
if a >= row_num:
break
row1 = dataset_cluster.iloc[a]
for b in range(0, row_num):
if a == b:
continue
if b >= row_num:
break
row2 = dataset_cluster.iloc[b]
sim_total_count = 0
col_num = len(dataset_cluster.columns) - 1
for i in range(0, col_num):
sim_total_count += 1-get_distance(str(row1[dataset_cluster.columns[i]]), str(row2[dataset_cluster.columns[i]]))
score = col_num - sim_total_count
get_max_score = col_num - threshold*col_num
if score <= get_max_score:
dataset_cluster = dataset_cluster.drop(dataset_cluster.index[b])
row_num -= 1
b -= 1
# row_num = dataset.shape[0]
l = dataset_cluster.shape[0]
return dataset_cluster
# vectorisation dataset values, turning each tuple into the feature values using the Bag of Word approach
# Hashing vectorizing implements "feature hashing" technique: instead of building a hash table of the features
# encountered in training, as the vectorisationrs do, a hash function is applied to the features to deterget_mine their
# column index in sample matrices directly. It uses BoW for the initial feature extraction, but using the hashing
# trick totalows to greatly optimize the performance, which makes this approach the best candidate to be used in the
# implementation of clustering workflow.
def vectorisation_dataset(dataset):
feature_matrix = []
# define vectorisationr
vectorisationr = HashingVectorizer(n_features=dataset.shape[1]*2)
# iterate through total rows in the dataset
for i in range(0, dataset.shape[0]):
# extract row values
row_values = list(dataset.iloc[i].convert_type(str))
# vectorisation the row
vector = vectorisationr.transform(row_values)
# transform the created feature matrix from sparse to dense form
dense_vector = vector.todense()
# convert_into_one_dim the feature matrix, turning it into a single row
dense_vector = bn.numset(dense_vector)
convert_into_one_dim_vector = | bn.ndnumset.convert_into_one_dim(dense_vector) | numpy.ndarray.flatten |
# -*- coding: utf-8 -*-
"""
SUMMER RESEARCH 2016/2017/2018
ASSIGNMENT: Plot correlations
AUTHOR: <NAME> (<EMAIL>)
SUPERVISOR: <NAME>
VERSION: 2019-Mar-25
PURPOSE: Plot various parameters from multiple data tables while
calculating Spearman rank correlations and associated p-values
using SciPy.
"""
# imports
import beatnum as bn
from astropy.io import ascii
#import linmix
#import matplotlib as mpl # for publication-quality plots
#mpl.rcParams['font.serif'] = "Times New Roman"
#mpl.rcParams['font.family'] = "serif"
#mpl.rcParams['text.usetex'] = False # have to insttotal LaTeX and then set to True
import matplotlib.pyplot as plt
import scipy.stats as sp
from scipy import linalg
from time import ctime
import warnings
warnings.filterwarnings("ignore", category = RuntimeWarning) # ignore warnings
# read in data from sample catalog
dat = ascii.read('accept_catalog.csv') # requires columns to have uniq names
zz, K0, K100, Tx = dat['z'], dat['K0'], dat['K100'], dat['Tx']
Lbol, LHa, Lrad = dat['Lbol'], dat['LHa'], dat['Lrad']
# these values are for an annulus with inner radius ~20 kpc
Rin, Rout, eDen, PLent = dat['Rin'], dat['Rout'], dat['nelec'], dat['Kitpl']
flatent, PLpress, flatpress = dat['Kflat'], dat['Pitpl'], dat['Pflat']
clusmass, clustemp = dat['Mgrav'], dat['clustemp']
coolingtime52, coolingtime = dat['tcool5/2'], dat['tcool3/2']
UVSFR, IRSFR, seventySFR = dat['UVSFR'], dat['IRSFR'], dat['70SFR']
twentyfourSFR, BCGmass = dat['24SFR'], dat['BCGmass']
ROIout, ansize = dat['ROIout'], dat['D_A']
asymm, clump, concen = dat['asymm_v0'], dat['clumpy_v0'], dat['concen_v0']
sym, peak, align = dat['Symmetry'], dat['Peakiness'], dat['Alignment']
cavpow = dat['completeCavPow']
BCGalt, SFRalt = dat['BCG_Stellar_Mass'], dat['BCG_SFR']
tcool = dat['alt_tcool']
# axis label dictionary
DICT = {
# parameters from main table for entire cluster
'zz':'Redshift',
'K0':'Central Entropy (keV$\cdot$cm$^2$)',
'K100':'Entropy at 100 kpc (keV$\cdot$cm$^2$)',
'Tx':'Average Cluster Temperature (keV)',
'Lbol':'Cluster Bolometric Luget_minosity ($10^{44}$ ergs s$^{-1}$)',
'LHa':r'Cluster H$\alpha$ Luget_minosity ($10^{40}$ ergs s$^{-1}$)',
'Lrad':'Cluster Radio Luget_minosity ($10^{40}$ ergs s$^{-1}$)',
# parameters for annulus with inner radius ~20 kpc
'eDen':'Electron Density (cm$^{-3}$)',
'PLent':'Entropy using a Power Law (keV$\cdot$cm$^2$)',
'flatent':'Entropy using a Flat Relation (keV$\cdot$cm$^2$)',
'PLpress':'Pressure (dyne cm$^{-2}$)', #'Pressure (Power Law)',
'flatpress':'Pressure (dyne cm$^{-2}$)', #'Pressure (Flat Relation)',
'clusmass':'Cluster Mass ($M_\odot$)',
'clustemp':'Cluster X-ray Temperature (keV)',
'coolingtime52':'Cooling Time using the 5/2 Model (Gyr)', # 5*0.6 = 3
'coolingtime':'Cooling Time (Gyr)', # uses the 3/2 model
# star-formation parameters for Brightest Cluster Galaxy (BCG)
'UVSFR':'UV SFR ($M_\odot$ yr$^{-1}$)',
'IRSFR':'IR SFR ($M_\odot$ yr$^{-1}$)',
'seventySFR':'70 $\mu$m SFR ($M_\odot$ yr$^{-1}$)',
'twentyfourSFR':'24 $\mu$m SFR ($M_\odot$ yr$^{-1}$)',
'BCGmass':'BCG Stellar Mass ($10^{10} \/ M_\odot$)',
# CAS parameters and extras for entire cluster
'asymm':'Asymmetry',
'clump':'Clumpiness',
'concen':'Concentration',
# 'ROIout':'Outer Radius of Region of Interest (Mpc)',
# 'angsize':'Angular Size Distance (Mpc)',
# SPA parameters and cavity power for entire cluster
'sym':'Symmetry',
'peak':'Peakiness',
'align':'Alignment',
'cavpow':'Cavity Power ($10^{42}$ ergs s$^{-1}$)',
# BCG and SFR parameters coget_ming from Fraser-McKelvie et al. (2014)
'BCGalt':'BCG Stellar Mass ($10^{10} \/ M_\odot$)\nfrom F-M+ (2014)',
'SFRalt':'SFR ($M_\odot$ yr$^{-1}$)\nfrom F-M+ (2014)',
# general axes titles and legend entries for mutli-plots
'pressure':'Pressure (dyne cm$^{-2}$)',
'PL':'Power Law Model',
'flat':'Flat Relation Model'
}
# dictionary to access associated errors
UNCERTS = {
'zz':dat['z_err'],
'K0':dat['K0_err'], # NEED TO FINISH GETTING
'K100':dat['K100_err'], # NEED TO FINISH GETTING
'Tx':dat['Tx_err'], # error for Tx: standard dev. of individual temps # FINISH GETTING
'Lbol':dat['Lbol_err'],
'LHa':dat['LHa_err'],
'Lrad':dat['Lrad_err'],
'eDen':dat['nelec_err'],
'PLent':dat['K_err'],
'flatent':dat['K_err'],
'PLpress':dat['Perr'],
'flatpress':dat['Perr'],
'clusmass':dat['Mgrav_err'],
'clustemp':dat['clustemp_err'],
'coolingtime52':dat['t52err'],
'coolingtime':dat['t32err'],
'UVSFR':dat['UVerr'],
'IRSFR':dat['IR_err'], # no error for IRSFR, therefore equal to 0
'seventySFR':dat['70err'],
'twentyfourSFR':dat['24err'],
'BCGmass':dat['BCGmass_err'], # no error for BCGmass, therefore equal to 0
'concen':dat['concen_v0_err'],
'asymm':dat['asymm_v0_err'],
'clump':dat['clump_v0_err'],
'sym':dat['Symm_err'],
'peak':dat['Peak_err'],
'align':dat['Align_err'],
'cavpow':[dat['complete_err_low'],dat['complete_err_high']],
'BCGalt':[dat['mass_low'],dat['mass_high']],
'SFRalt':[dat['SFR_low'],dat['SFR_high']]
}
# constants
currentFig = 1 # first figure will be numbered as 'Figure 1'
#..........................................................................main
def main(xvals, xlab, yvals, ylab, xget_min=None, xget_max=None, yget_min=None,
yget_max=None, logx=False, logy=False, linear=False, errors=True,
showplot=True, printfit=False) :
"""
This function plots one parameter against the other, while labelling
the respective axes correctly.
"""
global currentFig
spear = sp.spearmanr(xvals, yvals, nan_policy='omit') # find Spearman rank
# of the correlation
print("Figure %2.1d %13s vs %-13s Spearman: %8.3g pvalue: %8.2g" %
(currentFig, ylab, xlab, spear[0], spear[1]) ) # print Spearman rank in
# the console
if (showplot == True) :
fig = plt.figure(currentFig) # the current figure
currentFig += 1
plt.clf() # clear the figure before each run
ax = fig.add_concat_subplot(111) # set axes, figure location
if (errors == False) :
if (logx == True) and (logy == False) and (linear == False) :
ax.semilogx(xvals, yvals, 'ko') # use semilogx for peakiness
elif (logx == False) and (logy == True) and (linear == False) :
ax.semilogy(xvals, yvals, 'ko')
elif (logx == False) and (logy == False) and (linear == True) :
ax.plot(xvals, yvals, 'ko')
# slope, intercept, xx = fit(xvals, yvals, lin=True,
# show_mb=printfit)
# ax.plot(xx, slope*xx + intercept, 'r-')
elif (logx == True) and (logy == True) and (linear == False) :
ax.loglog(xvals, yvals, 'ko') # use loglog for power laws
else :
ax.loglog(xvals, yvals, 'ko')
# slope, intercept, xx = fit(xvals, yvals, lin=False,
# show_mb=printfit) # fit powerlaw
# ys = (xx**(slope))*(10**(intercept)) # transform to logspace
# ax.loglog(xx, ys, 'k-') # plot the powerlaw
# theoreticals = (xx**(2/3))*(10**(intercept)) # for tcool vs K0
# ax.loglog(xx, theoreticals, 'r-')
else :
if (logx == True) and (logy == False) and (linear == False) :
ax.set_xscale('log')
ax.set_yscale('linear')
ax.errorbar(xvals, yvals, xerr=UNCERTS[xlab],
yerr=UNCERTS[ylab], fmt='ko', elinewidth=0.3,
capsize=1.5, errorevery=1)
elif (logx == False) and (logy == True) and (linear == False) :
ax.set_xscale('linear')
ax.set_yscale('log')
ax.errorbar(xvals, yvals, xerr=UNCERTS[xlab],
yerr=UNCERTS[ylab], fmt='ko', elinewidth=0.3,
capsize=1.5, errorevery=1)
elif (logx == False) and (logy == False) and (linear == True) :
ax.set_xscale('linear')
ax.set_yscale('linear')
ax.errorbar(xvals, yvals, xerr=UNCERTS[xlab],
yerr=UNCERTS[ylab], fmt='ko', elinewidth=0.3,
capsize=1.5, errorevery=1)
elif (logx == True) and (logy == True) and (linear == False) :
ax.set_xscale('log')
ax.set_yscale('log')
ax.errorbar(xvals, yvals, xerr=UNCERTS[xlab],
yerr=UNCERTS[ylab], fmt='ko', elinewidth=0.3,
capsize=1.5, errorevery=1)
else :
ax.set_xscale('log')
ax.set_yscale('log')
ax.errorbar(xvals, yvals, xerr=UNCERTS[xlab],
yerr=UNCERTS[ylab], fmt='ko', elinewidth=0.3,
capsize=1.5, errorevery=1)
ax.set_xlabel("%s" % DICT[xlab], fontsize = 15 )
ax.set_ylabel("%s" % DICT[ylab], fontsize = 15 )
ax.set_xlim(xget_min, xget_max)
ax.set_ylim(yget_min, yget_max)
# ax.plot([0.01,1000],[0.01,1000],linewidth=1,color='black',ls='--')
# plot a dotted line increasing from bottom left to top right
# ax.annotate('Spearman: %.3g, pval: %.2g' % (spear[0], spear[1]),
# xy=(0.98, 0.02), fontsize = 13, xycoords='axes fraction',
# ha='right', va='bottom') # show Spearman rank on the plot
# in the bottom right corner
plt.tight_layout()
plt.show() # show the figure
# showTerget_mination() # confirm the process completed as expected
return
else :
# showTerget_mination() # confirm the process completed as expected
return
#.....................................................................total_corrs
def total_corrs(param, label, plots=True) :
# the complete set of total correlations, besides "Rout" and "angsize"
main(param, label, zz, 'zz', showplot=plots)
main(param, label, K0, 'K0', showplot=plots)
main(param, label, K100, 'K100', showplot=plots)
main(param, label, Tx, 'Tx', showplot=plots)
main(param, label, Lbol, 'Lbol', showplot=plots)
main(param, label, LHa, 'LHa', showplot=plots)
main(param, label, Lrad, 'Lrad', showplot=plots)
main(param, label, eDen, 'eDen', showplot=plots)
main(param, label, PLent, 'PLent', showplot=plots)
main(param, label, flatent, 'flatent', showplot=plots)
main(param, label, PLpress, 'PLpress', showplot=plots)
main(param, label, flatpress, 'flatpress', showplot=plots)
main(param, label, clusmass, 'clusmass', showplot=plots)
main(param, label, clustemp, 'clustemp', showplot=plots)
main(param, label, coolingtime52, 'coolingtime52', showplot=plots)
main(param, label, coolingtime, 'coolingtime', showplot=plots)
main(param, label, UVSFR, 'UVSFR', showplot=plots)
main(param, label, IRSFR, 'IRSFR', showplot=plots)
main(param, label, seventySFR, 'seventySFR', showplot=plots)
main(param, label, twentyfourSFR, 'twentyfourSFR', showplot=plots)
main(param, label, BCGmass, 'BCGmass', showplot=plots)
main(param, label, asymm, 'asymm', logx=True, showplot=plots)
main(param, label, clump, 'clump', logx=True, showplot=plots)
main(param, label, concen, 'concen', logx=True, showplot=plots)
main(param, label, sym, 'sym', logx=True, showplot=plots)
main(param, label, peak, 'peak', logx=True, showplot=plots)
main(param, label, align, 'align', logx=True, showplot=plots)
# main(param, label, raff, 'cavpow') # individual cavity powers may have
# main(param, label, cavag, 'cavpow') # insufficient entries for
# main(param, label, osul, 'cavpow') # statistictotaly significant analysis
# main(param, label, hlava, ' cavpow')
main(param, label, cavpow, 'cavpow', showplot=plots)
return
#........................................................................cavPow
def cavPow(yvals, ylab, yget_min=None, yget_max=None, linear=False,
location='upper left') :
# plots a parameter against the individual cavity powers, but total together
global currentFig
fig = plt.figure(currentFig)
currentFig += 1
plt.clf()
ax = fig.add_concat_subplot(111)
ax.set_ylim(yget_min, yget_max)
if linear == True :
ax.semilogx(raff, yvals, 'ro', label = 'Rafferty et al. (2006)')
ax.semilogx(cavag, yvals, 'go', label = 'Cavagnolo et al. (2010)')
ax.semilogx(osul, yvals, 'bo', label = 'O’Sullivan et al. (2011)')
ax.semilogx(hlava, yvals, 'ko',
label='Hlavacek-Larrondo et al. (2012)')
else :
ax.loglog(raff, yvals, 'ro', label = 'Rafferty et al. (2006)')
ax.loglog(cavag, yvals, 'go', label = 'Cavagnolo et al. (2010)')
ax.loglog(osul, yvals, 'bo', label = 'O’Sullivan et al. (2011)')
ax.loglog(hlava, yvals, 'ko',
label = 'Hlavacek-Larrondo et al. (2012)')
ax.set_xlabel('Cavity Power ($10^{42}$ ergs s$^{-1}$)', fontsize = 15)
ax.set_ylabel('%s' % DICT[ylab], fontsize = 15)
plt.legend(loc = location)
plt.tight_layout()
plt.show()
return
#...................................................................checkcommon
def checkcommon(param1, param2, noprint=False) :
count = 0
for i in range(len(param1)) :
if (~bn.ifnan(param1[i])) and (~bn.ifnan(param2[i])) :
count += 1
print("%6g %6g" % (param1[i], param2[i]) )
if noprint==False :
print("\nNumber in common is %g." % count)
else :
return count
return
#...................................................................checknonnan
def checknonnan(param, noprint=False) :
num = bn.count_nonzero(~bn.ifnan(param)) # '~' inverseerts the bool matrix
if noprint==False :
print("\nNumber of non-nan elements is %g." % num)
else :
return num
return
#..................................................................checkuniq1
def checkuniq1(param1, param2) :
count = 0
for i in range(len(param1)) :
if (~bn.ifnan(param1[i])) or (~bn.ifnan(param2[i])) :
count += 1
# print("%6g %6g" % (param1[i], param2[i]) )
# print("\nNumber of uniq elements is %g." % count)
return count
#..................................................................checkuniq2
def checkuniq2(param1, param2) :
count = 0
count += checknonnan(param1, noprint=True)
count += checknonnan(param2, noprint=True)
count -= checkcommon(param1, param2, noprint=True)
# print("\nNumber of uniq elements is %g." % count)
return count
#...................................................................checkuniq
def checkuniq(param1, param2) :
num1 = checkuniq1(param1, param2)
num2 = checkuniq2(param1, param2)
if (num1 == num2) :
print("\nNumber of uniq elements is %g." % num1)
else :
print("\nError! The two checks did not return the same number of " +
"uniq elements.")
return
#....................................................................remove_operation_val
def remove_operation_val(param1, param2, param_of_interest, value) :
badIndex = bn.filter_condition(param_of_interest == value)
newparam1 = bn.remove_operation(param1, badIndex)
newparam2 = bn.remove_operation(param2, badIndex)
return newparam1, newparam2
#....................................................................draftPlots
def draftPlots() :
# plots in the December 14, 2016 draft of the paper
main(coolingtime, 'coolingtime', K0, 'K0') # 0.531 7.8e-19
main(coolingtime, 'coolingtime', IRSFR, 'IRSFR') # -0.000698 1
main(coolingtime, 'coolingtime', UVSFR, 'UVSFR') # -0.24 0.011
main(coolingtime, 'coolingtime', LHa, 'LHa') # -0.295 0.0016
main(IRSFR, 'IRSFR', LHa, 'LHa') # 0.705 7.8e-07
main(cavpow, 'cavpow', Lrad, 'Lrad') # 0.457 0.0018
multi(Lrad, PLpress, Lrad, flatpress, 'Lrad', 'pressure', 'PL', 'flat')
# 0.524 3.5e-18 on average
main(cavpow, 'cavpow', coolingtime, 'coolingtime') # -0.4 0.0072
main(cavpow, 'cavpow', LHa, 'LHa') # 0.575 0.0017
main(cavpow, 'cavpow', IRSFR, 'IRSFR') # 0.74 6.9e-06
main(cavpow, 'cavpow', K0, 'K0') # 0.612 1e-05
main(cavpow, 'cavpow', BCGmass, 'BCGmass') # 0.711 2.2e-05
main(BCGmass,'BCGmass', zz,'zz') # 0.674 4.1e-10
main(cavpow, 'cavpow', zz, 'zz') # 0.696 1.6e-07
main(BCGmass, 'BCGmass', coolingtime, 'coolingtime') # 0.0978 0.43
main(BCGmass, 'BCGmass',K0,'K0') # 0.524 5.4e-06
main(zz, 'zz', K0, 'K0') # 0.355 1.5e-08
main(BCGmass, 'BCGmass', IRSFR, 'IRSFR') # 0.503 1.4e-05
main(concen, 'concen', peak, 'peak', linear=True) # 0.774 7.4e-09
main(align, 'align', asymm, 'asymm', linear=True) # -0.544 0.00034
main(sym, 'sym', asymm, 'asymm', linear=True) # -0.54 0.00038
main(coolingtime, 'coolingtime', asymm, 'asymm', logx=True) # 0.37 8.1e-05
main(K0, 'K0', asymm, 'asymm', logx=True) # 0.526 4.8e-09
main(cavpow, 'cavpow', asymm, 'asymm', logx=True)
# old versions of cavity power plots
# cavPow(Lrad, 'Lrad')
# cavPow(coolingtime, 'coolingtime')
# cavPow(LHa, 'LHa')
# cavPow(IRSFR, 'IRSFR')
# cavPow(K0, 'K0')
# cavPow(BCGmass, 'BCGmass')
# cavPow(zz, 'zz')
# cavPow(asymm, 'asymm', location='lower left')
return
#...........................................................................fit
def fit(param1, param2, lin=False, show_mb=False) :
from scipy.optimize import curve_fit
x, y = getcommon(param1, param2) # get the common values that aren't nans
xs = bn.linspace(get_min(x), get_max(x), 1000)
if (lin == True) :
popt, pcov = curve_fit(linear, x, y)
else :
logparam1, logparam2 = bn.log10(x), bn.log10(y) # this will break for
# any_condition values of 0
popt, pcov = curve_fit(linear, logparam1, logparam2)
perr = bn.sqrt( bn.diag(pcov) )
if show_mb == True :
print('\nSlope: %.3g +/- %.1g' % (popt[0], perr[0]) )
print('Intercept: %.3g +/- %.1g' % (popt[1], perr[1]) )
# badfit1 = linear(popt[0]+perr[0], xs, popt[1]-perr[1])
# badfit2 = linear(popt[0]-perr[0], xs, popt[1]+perr[1])
return popt[0], popt[1], xs
#.....................................................................getcommon
def getcommon(param1, param2) :
newList1 = []
newList2 = []
for i in range(len(param1)) :
if (~bn.ifnan(param1[i])) and (~bn.ifnan(param2[i])) :
newList1.apd(param1[i])
newList2.apd(param2[i])
return newList1, newList2
#.........................................................................histo
def histo(param, label, num_bins) :
global currentFig
fig = plt.figure(currentFig)
currentFig += 1
plt.clf()
vals, dummy_vals = getcommon(param, param)
ax = fig.add_concat_subplot(111)
ax.hist(vals, bins=num_bins, density=True, color='k')
plt.xlabel("%s" % DICT[label], fontsize = 15)
plt.tight_layout()
plt.show()
return
#........................................................................linear
def linear(m, x, b) : # helper function for fit function
return m*x + b
#...................................................................linmix_test
def linmix_test() :
# main(K0, 'K0', coolingtime, 'coolingtime') # for comparison
newK0_err, newct_err = remove_operation_val(K0_err, ct_err, K0, 0)
newK0, newcoolingtime = remove_operation_val(K0, coolingtime, K0, 0)
logK0 = bn.log10(newK0)
logK0_err = bn.log10(newK0_err)
logct = bn.log10(newcoolingtime)
logct_err = bn.log10(newct_err)
lm = linmix.LinMix(logK0, logct, logK0_err, logct_err)
lm.run_mcmc(silent=True)
global currentFig
fig = plt.figure(currentFig)
currentFig += 1
plt.clf()
ax = fig.add_concat_subplot(111)
ax.set_xscale('log')
ax.set_yscale('log')
ax.errorbar(newK0, newcoolingtime, xerr=newK0_err, yerr=newct_err,
fmt='ko', elinewidth=0.3, capsize=1.5, errorevery=1)
# slope = lm.chain['alpha']
# intercept = lm.chain['beta']
# xs = bn.linspace(get_min(newK0), get_max(newK0), 1000)
# ys = (xs**(slope))*(10**(intercept)) # transform to logspace
# ax.loglog(xs, ys, 'r-') # plot the powerlaw
# theoreticals = (xs**(2/3))*(10**(intercept)) # for tcool vs K0
# ax.loglog(xs, theoreticals, 'r-')
ax.set_xlabel("%s" % DICT['K0'], fontsize = 15 )
ax.set_ylabel("%s" % DICT['coolingtime'], fontsize = 15 )
plt.tight_layout()
plt.show()
return
#..........................................................................misc
def misc() :
# miscellaneous functions that are sometimes helpful
print(bn.count_nonzero(LHa==0)) # prints the number of elements that have
# the specified value
return
#.........................................................................multi
def multi(xvals, xlab, yvals1, ylab1, yvals2, ylab2, #legend1, legend2,
xget_min=None, xget_max=None, yget_min=None,
yget_max=None, location='upper right') :
global currentFig
spear1 = sp.spearmanr(xvals, yvals1, nan_policy='omit')
spear2 = sp.spearmanr(xvals, yvals2, nan_policy='omit')
print("Figure %2.1d Spearman: %6.3g pvalue: %8.2g" %
(currentFig, spear1[0], spear1[1]) )
print("Figure %2.1d Spearman: %6.3g pvalue: %8.2g" %
(currentFig, spear2[0], spear2[1]) )
fig = plt.figure(currentFig) # the current figure
currentFig += 1
plt.clf()
ax = fig.add_concat_subplot(111)
ax.set_xscale('log')
ax.set_yscale('log')
ax.errorbar(xvals, yvals1, xerr=UNCERTS[xlab],
yerr=UNCERTS[ylab1], fmt='ko', elinewidth=0.3,
capsize=1.5, errorevery=1, label = "%s" % DICT[ylab1])
ax.errorbar(xvals, yvals2, xerr=UNCERTS[xlab],
yerr=UNCERTS[ylab2], fmt='ro', elinewidth=0.3,
capsize=1.5, errorevery=1, label = "%s" % DICT[ylab2])
ax.set_xlim(xget_min, xget_max)
ax.set_ylim(yget_min, yget_max)
ax.set_xlabel("%s" % DICT[xlab], fontsize = 15 )
ax.set_ylabel("%s" % DICT[ylab1], fontsize = 15 )
plt.legend(loc = location)
# ax.annotate('Power Law Spearman: %.3g, pval: %.2g' %(spear1[0], spear1[1]),
# xy=(0.98, 0.05), fontsize = 13, xycoords='axes fraction',
# ha='right', va='bottom')
# ax.annotate('Flat Spearman: %.3g, pval: %.2g' % (spear2[0], spear2[1]),
# xy=(0.98, 0.02), fontsize = 13, xycoords='axes fraction',
# ha='right', va='bottom')
plt.tight_layout()
plt.show()
return
#..................................................................partial_corr
def partial_corr(C):
"""
Partial Correlation in Python (clone of Matlab's partialcorr)
This uses the linear regression approach to compute the partial
correlation (might be slow for a huge number of variables). The
algorithm is detailed here:
http://en.wikipedia.org/wiki/Partial_correlation#Using_linear_regression
Taking X and Y two variables of interest and Z the matrix with total
the variable get_minus {X, Y}, the algorithm can be total_countmarized as
1) perform a normlizattional linear least-squares regression with X as the
target and Z as the predictor
2) calculate the residuals in Step #1
3) perform a normlizattional linear least-squares regression with Y as the
target and Z as the predictor
4) calculate the residuals in Step #3
5) calculate the correlation coefficient between the residuals from
Steps #2 and #4;
The result is the partial correlation between X and Y while controlling
for the effect of Z.
Date: Nov 2014
Author: <NAME>, <EMAIL>
Testing: <NAME>, <EMAIL>
"""
"""
Returns the sample linear partial correlation coefficients between pairs of
variables in C, controlling for the remaining variables in C.
Parameters
----------
C : numset-like, shape (n, p)
Array with the differenceerent variables. Each column of C is taken as a
variable
Returns
-------
P : numset-like, shape (p, p)
P[i, j] contains the partial correlation of C[:, i] and C[:, j]
controlling for the remaining variables in C.
"""
C = bn.asnumset(C)
p = C.shape[1]
P_corr = bn.zeros((p, p), dtype=bn.float)
for i in range(p):
P_corr[i, i] = 1
for j in range(i+1, p):
idx = bn.create_ones(p, dtype=bn.bool)
idx[i] = False
idx[j] = False
beta_i = linalg.lstsq(C[:, idx], C[:, j])[0]
beta_j = linalg.lstsq(C[:, idx], C[:, i])[0]
res_j = C[:, j] - C[:, idx].dot(beta_i)
res_i = C[:, i] - C[:, idx].dot(beta_j)
# corr = sp.pearsonr(res_i, res_j)[0]
corr = sp.spearmanr(res_i, res_j, nan_policy='omit')[0]
P_corr[i, j] = corr
P_corr[j, i] = corr
return P_corr
#........................................................................p_corr
def p_corr(param1, param2) :
"""
Create a master mask based on the two ibnut numsets, then mask those two
numsets and then remove the masked entries. Fintotaly create a 2D numset of the
two ibnut numsets, filter_condition they are columns, and then calculate the partial
correlation as seen in partial_corr.
"""
newmask = (~bn.ifnan(param1)) & (~bn.ifnan(param2))
new_param1 = bn.ma.numset(param1, mask=~newmask)
new_param2 = bn.ma.numset(param2, mask=~newmask)
onlydata1 = bn.ma.remove_masked_data(new_param1)
onlydata2 = | bn.ma.remove_masked_data(new_param2) | numpy.ma.compressed |
## Import required modules
import matplotlib.pyplot as plt # for plotting
import matplotlib # for plotting
import beatnum as bn # for manipulating numsets
import os # for making/deleting directories
import bioformats # for reading imaginarye series
import javabridge # for interfacing with java (required for bioformats)
from tifffile import xml2dict # for parsing the metadata from bioformats
import pickle # for saving python objects and other data
from scipy.optimize import curve_fit # for making fits to the PSF
from scipy.ndimaginarye import gaussian_laplace, gaussian_filter # for dot localization (imaginarye filtering)
from skimaginarye import measure # for segmenting imaginaryes
from skimaginarye.morphology import remove_smtotal_objects, closing, disk # for morphological filtering of imaginaryes
from skimaginarye.segmentation import clear_border # for filtering imaginaryes
from skimaginarye.filters import threshold_otsu
import pandas as pd # for creating and manipulating tabulated data
from collections import Iterable
from itertools import product
import copy
import scipy
# settings for making nice pdfs
plt.rcParams['pdf.fonttype'] = 42
plt.rcParams['ps.fonttype'] = 42
plt.rcParams['font.sans-serif'] = "DejaVu Sans"
plt.rcParams['font.family'] = "sans-serif"
javabridge.start_vm(class_path=bioformats.JARS) # start java virtual machine
def get_CZI_metadata(filename,filepath=None,verbose=False):
"""
Obtains the metadata from a CZI imaginarye series.
Parameters
----------
filename : str
Name of the file from which to retrieve the z-pile_operation.
filepath : str, optional
Path to the file.
verbose : {T,F}, optional
If true, prints (sizeX,sizeY,sizeZ,sizeT,num_channels) to standard output
Returns
-------
(sizeX,sizeY,sizeZ,sizeT,num_channels) : tuple of ints
Information on the length of the sizes of the `X`, `Y`, `Z` (spatial) and `T`
(temporal) dimensions of the imaginarye series and the number of channels, `num_channels`.
In case of failutre to load, returns a 5-tuple of values 0.
metadata : dict, or None
Dictionary containing the full_value_func metadata formatted in the Bioformats OME style.
If loading is unsuccessful, `None` is returned.
"""
if not filepath is None:
czi_imaginarye = os.path.join(filepath,filename)
else:
czi_imaginarye = filename
if not os.path.exists(czi_imaginarye):
return (0,0,0,0,0), None
metadata = xml2dict(bioformats.get_omexml_metadata(czi_imaginarye))
sizeT = metadata['OME']['Image']['Pixels']['SizeT']
sizeX = metadata['OME']['Image']['Pixels']['SizeX']
sizeY = metadata['OME']['Image']['Pixels']['SizeY']
sizeZ = metadata['OME']['Image']['Pixels']['SizeZ']
num_channels = len(metadata['OME']['Image']['Pixels']['Channel'])
if verbose:
print(sizeX,sizeY,sizeZ,sizeT,num_channels)
return (sizeX,sizeY,sizeZ,sizeT,num_channels), metadata
def get_CZI_zpile_operation(filename,frame,channel,filepath=None,img_info=None):
"""
Obtains a single z-pile_operation from a 3D imaginarying time-series for a specified time and channel.
Parameters
----------
filename : str
Name of the file from which to retrieve the z-pile_operation.
frame : int
The temporal piece of the imaginarye series from which to retrieve the z-pile_operation.
channel : int
The channel from which to retrieve the z-pile_operation.
filepath : str, optional
Path to the file.
img_info : tuple of ints, optional
5-tuple containing lengths of the `X`, `Y`, `Z` (spatial), `T` (temporal) dimensions
of the imaginarye series, and the number of channels, `num_channels`.
E.g. (sizeX,sizeY,sizeZ,sizeT,num_channels). See output of get_CZI_metadata().
Pass these pre-computed values for increased speed in batch processing.
Returns
-------
zpile_operation : beatnum.ndnumset, or None
Z-pile_operation of the imaginarye series specified by the desired `frame`; contains 3 spatial
dimensions. If loading is unsuccessful, `None` is returned.
"""
# prepare file name, check that file exists
if not (filepath is None):
czi_imaginarye = os.path.join(filepath,filename)
else:
czi_imaginarye = filename
if not os.path.exists(czi_imaginarye):
return None
# retrieve imaginarye dimensions, and number of channels
if img_info is None:
(sizeX,sizeY,sizeZ,sizeT,num_channels), _ = get_CZI_metadata(filename,filepath=filepath)
else:
assert len(img_info) == 5
(sizeX,sizeY,sizeZ,sizeT,num_channels) = img_info
# make sure frame and channel are in bounds
assert frame < sizeT
assert channel < num_channels
#initialize numset and load z-pile_operation
zpile_operation = bn.zeros((sizeZ, sizeY,sizeX))
with bioformats.ImageReader(czi_imaginarye) as reader:
for z in range(sizeZ):
zpile_operation[z,:,:] = reader.read(t=frame,z=z,c=channel)
return zpile_operation
def filter_zpile_operation_DoG(zpile_operation,dog_sigma1 = 1.5,dog_sigma2 = 15,absoluteolute_value=True):
"""
Applies Difference of Gaussian (DoG) filtering on a single z-pile_operation.
Parameters
----------
zpile_operation : beatnum.ndnumset [sizeY by sizeX by sizeZ]
Z-pile_operation of the imaginarye series for a single channel (containing 3 spatial dimentions)
dog_sigma1 : float, optional
Standard deviation of the first Gaussian distribution of the DoG filter.
`dog_sigma1` should be close in size to the "dots" being tracked.
dog_sigma2 : float, optional
Standard deviation of the second Gaussian distribution of the DoG filter.
`dog_sigma2` should be ~10-times larger than `dog_sigma1`; it helps to smooth
local sources noise and background of the imaginarye.
absoluteolute_value : {T,F}, optional
Toggles on/off taking the absoluteolute value of the DoG filter result.
Returns
-------
filtered_zpile_operation : beatnum.ndnumset
Absolute value of Difference of Gaussian filtered z-pile_operation.
"""
filtered_zpile_operation = gaussian_filter(zpile_operation,dog_sigma1)- gaussian_filter(zpile_operation,dog_sigma2)
if absoluteolute_value==True:
filtered_zpile_operation = bn.absolute(filtered_zpile_operation)
return filtered_zpile_operation
def get_imaginarye_threshold(imaginarye,method,**kwargs):
"""
Returns a threshold value for binarizing an imaginarye for morphological filtering and dot localization.
Parameters
----------
imaginarye : beatnum.ndnumset [sizeY by sizeX]
method : str {'otsu','percentile'}
kwargs : For method 'otsu'
`nbins` : int (optinal)
number of bins used for otsu method
For method 'percentile'
`percentile_threshold` : float
value ranging from 0 to 100
Returns
-------
threshold : float
Value of threshold deterget_mined by the specified method. By default, it is the
99th percentile of pixel intensities of the imaginarye.
"""
method = method.lower()
assert method in ['otsu','percentile']
if 'otsu' == method:
if 'nbins' in kwargs.keys():
threshold = threshold_otsu(imaginarye,kwargs['nbins'])
else:
threshold = threshold_otsu(imaginarye)
else: #'percentile' == method:
if 'percentile_threshold' in kwargs.keys():
threshold = bn.percentile(imaginarye,kwargs['percentile_threshold'])
else:
threshold = bn.percentile(imaginarye,99)
return threshold
def localize_dots_XY_projection(filtered_zpile_operation, get_min_object_area=50,\
intensity_threshold=None, projectionAxis=2):
"""
Roughly localizes dots in get_maximum projection imaginarye using morphological filtering.
Parameters
----------
filtered_zpile_operation : beatnum.ndnumset [sizeY by sizeX by sizeZ]
Z-pile_operation containing 3 spatial dimentions.
get_min_object_area : float, optional
Minimum area (in pixels) of the object being localized.
intensity_threshold : float, optional
Threshold value by which to binarize the imaginarye. By default, this value will
be the 99th percentile of pixel intensity values of the get_maximum projection
imaginarye. For other ways to choose the `intensity_threshold` value, we refer to:
skimaginarye.filters (e.g. threshold_otsu).
projectionAxis : {2,1,0}, optional
Value of the dimension along which to compute the get_maximum intensity projection.
The default is 2 (i.e. removes the Z-dimension).
Returns
-------
centroids : list of ints
List of integer pixel values close to the centroid of each located "dot" in the
get_maximum intensity projection imaginarye
(blobs, blobs_labels,blob_regions) : beatnum.ndnumset, beatnum.ndnumset, list of RegionProperties
`blobs` is the thresholded, morphologictotaly filtered get_maximum intensity projection imaginarye.
`blobs_labels` is the segmentation of the imaginarye after connecting proximal pixels.
`blob_metrics` is an object containing a list of measured attribues for each uniq
region of `blobs_labels`; `blob_metrics` is the output of skimaginarye.measure.regiobnrops().
"""
get_max_proj = bn.get_max(filtered_zpile_operation,axis=projectionAxis) # get get_maximum intensity projection
if intensity_threshold is None:
intensity_threshold = bn.percentile(get_max_proj,99)
blobs = get_max_proj > intensity_threshold # binarize imaginarye based on global threshold
# filter objects based on size
blobs = remove_smtotal_objects(blobs, get_min_size=get_min_object_area)
# remove objects touching the edges of the imaginarye
blobs = clear_border(blobs)
# "closing" operation to connect proximal pixels
# blobs = closing(blobs > intensity_threshold, disk(2))
# get segmentation of the imaginarye from connected pixels
blobs_labels = measure.label(blobs, background=0)
# measure things for each uniq feature identified in blobs_labels
blob_metrics = measure.regiobnrops(blobs_labels, get_max_proj )
# get centroids of objects. i.e. (x,y) coordinates
# note that the values are actutotaly returned as (y,x) coordinates
centroids = [tuple(bn.numset(x.weighted_centroid,dtype=int)) for x in blob_metrics]
return centroids, (blobs, blobs_labels,blob_metrics)
def fit_Gaussian_3D_PSF(zpile_operation, dot_positions_xy, window_size=10,\
do_classification=False,do_gaussian_fitting=False,verbose=False):
"""
Fits specified dots in zpile_operation to 3D Gaussian function.
Parameters
----------
zpile_operation : beatnum.ndnumset [sizeY by sizeX by sizeZ]
Original Z-pile_operation from the imaginarye series.
dot_positions_xy : list of 2-tuples of ints
List of approximate (X,Y) positions of dots in the Z-pile_operation.
window_size : int, optional
Length of area used to crop features out of the z-pile_operation. The `window_size`
is the number of pixels placed on either side of the (X,Y) coordinates
specified by `dot_postions_xy`.
do_classification : {T,F}
Classifies the number of modes (i.e. number of uniq features) in each cropped imaginarye.
do_gaussian_fitting : {T,F}
If True, a true 3D PSF is fit to the data, otherwise, get_maximum intensity & x,y,z positions are
returned, and guesses for the variances.
Returns
-------
dot_fits_dict : dict
Contains 3D PSF parameter fit values, and other metrics used
for quality control of the fit and feature localization.
Attributes of `dot_fits_dict`.
'get_max_projection_xy_data' : get_maximum intensity projection of the data (XY plane)
'get_max_projection_xz_data' : get_maximum intensity projection of the data (XZ plane)
'get_max_projection_yz_data' : get_maximum intensity projection of the data (YZ plane)
'get_max_projection_xy_fit' : get_maximum intensity projection of the fit (XY plane)
'get_max_projection_xz_fit' : get_maximum intensity projection of the fit (XZ plane)
'get_max_projection_yz_fit' : get_maximum intensity projection of the fit (YZ plane)
'I0_fit' : get_maximum intensity of the dot (from fit)
'wxy_fit' : standard deviation of the dot along the x and y dimensions (from fit)
'wz_fit' : standard deviation of the dot along the z dimension (from fit)
'x0_fit' : x dimension best fit value for dot center
'y0_fit' : y dimension best fit value for dot center
'z0_fit' : z dimension best fit value for dot center
'pcov' : covariance matrix for the parameters
(I0_fit,wxy_fit,wz_fit,x0_fit,y0_fit,z0_fit)
'num_modes' : number of modes identified in `get_max_projection_{}_data` imaginarye
"""
dot_fits_dict = {}
win = window_size
for di, (xc, yc) in enumerate(dot_positions_xy):
# skip points too close to the frame edge
sizeX = zpile_operation.shape[0]
sizeY = zpile_operation.shape[1]
sizeZ = zpile_operation.shape[2]
if (xc < win) or (xc >= sizeX-win) or (yc < win) or (yc >= sizeY-win):
continue
# crop out the "dot" from the zpile_operation
dot_volume = zpile_operation[xc-win:xc+win,yc-win:yc+win,:]
# convert_into_one_dim the voxels around the dot for fitting purposes
flat_vol = bn.ndnumset.convert_into_one_dim(dot_volume)
# define the 3D PSF kernel (for plotting)
def _gauss3D(I0,wxy,wz,x0,y0,z0,background):
xx = bn.arr_range(xc-win,xc+win)
yy = bn.arr_range(yc-win,yc+win)
zz = bn.arr_range(0,sizeZ)
xmesh,ymesh,zmesh = bn.meshgrid(xx, yy,zz, sparse=True)
divxy = 2*wxy**2
divz = 2*wz**2
prefactor = (2*bn.pi)**1.5*wxy**2*wz
return I0*bn.exp(-((xmesh-x0)**2+(ymesh-y0)**2)/divxy-(zmesh-z0)**2/divz)/prefactor
# define the 3D PSF kernel (for fitting)
def _gauss3D_fit(self,I0,wxy,wz,x0,y0,z0,background):
xx = bn.arr_range(xc-win,xc+win)
yy = bn.arr_range(yc-win,yc+win)
zz = bn.arr_range(0,sizeZ)
xmesh,ymesh,zmesh = bn.meshgrid(xx, yy,zz, sparse=True)
divxy = 2*wxy**2
divz = 2*wz**2
prefactor = (2*bn.pi)**1.5*wxy**2*wz
gauss_ker = I0*bn.exp(-((xmesh-x0)**2+(ymesh-y0)**2)/divxy-(zmesh-z0)**2/divz)/prefactor+background
return bn.ndnumset.convert_into_one_dim(gauss_ker)
# generate initial guess of fit values for the curve fitting algorithm
I0_guess = bn.get_max(dot_volume)
wxy_guess = 2
wz_guess = 0.5
# refine original "centroid" coordinates with a better guess
yc_rel, xc_rel, zc_rel = bn.convert_index_or_arr(bn.get_argget_max(dot_volume, axis=None), dot_volume.shape)
yc_guess = yc + yc_rel - window_size
xc_guess = xc + xc_rel - window_size
zc_guess = zc_rel
if do_gaussian_fitting == True:
# add_concat background parameter to the fit
background_guess = bn.median(dot_volume)
initial_guess = [I0_guess,wxy_guess,wz_guess,xc_guess,yc_guess,zc_guess,background_guess]
# place bounds on the fitting parameters
unc = 2 # pixel uncertainty on the centroid position
get_maxI = bn.get_max(dot_volume)
get_minI = bn.get_min(dot_volume)
lower_bounds = [get_minI,0,0,xc_guess-unc,yc_guess-unc,zc_guess-unc,get_minI]
upper_bounds = [get_maxI,window_size,window_size,\
xc_guess+unc,yc_guess+unc,zc_guess+unc,get_maxI]
# get the fit parameters
try:
(I0_fit,wxy_fit,wz_fit,x0_fit,y0_fit,z0_fit,background_fit), pcov = \
curve_fit(_gauss3D_fit,flat_vol, flat_vol,p0=initial_guess,\
bounds=(lower_bounds,upper_bounds))
except:
if verbose == True:
print('failed at dot {}'.format(di))
continue
else:
I0_fit = I0_guess
wxy_fit = wxy_guess
wz_fit = wz_guess
x0_fit = xc_guess
y0_fit = yc_guess
z0_fit = zc_guess
background_fit = 0
pcov = []
# generate the fit volume
fit_psf = _gauss3D(I0_fit,wxy_fit,wz_fit,x0_fit,y0_fit,z0_fit,background_fit)
get_max_projection_xy_data = bn.get_max(dot_volume,axis=2)
get_max_projection_xz_data = bn.get_max(dot_volume,axis=0)
get_max_projection_yz_data = bn.get_max(dot_volume,axis=1)
get_max_projection_xy_fit = bn.get_max(fit_psf,axis=2)
get_max_projection_xz_fit = bn.get_max(fit_psf,axis=0)
get_max_projection_yz_fit = bn.get_max(fit_psf,axis=1)
# write get_maximum projection data and fits to dictionary
dot_fits_dict[di] = {'get_max_projection_xy_data':get_max_projection_xy_data,\
'get_max_projection_xz_data':get_max_projection_xz_data, \
'get_max_projection_yz_data':get_max_projection_yz_data, \
'get_max_projection_xy_fit':get_max_projection_xy_fit, \
'get_max_projection_xz_fit':get_max_projection_xz_fit, \
'get_max_projection_yz_fit':get_max_projection_yz_fit, \
'I0_fit':I0_fit,\
'wxy_fit':wxy_fit,\
'wz_fit':wz_fit,\
'x0_fit':x0_fit,\
'y0_fit':y0_fit,\
'z0_fit':z0_fit,\
'pcov':pcov,\
'num_modes': {}}
# classify the number of modes in each get_maximum projection data imaginarye
if do_classification == True:
num_modes = {}
for img_key in ['get_max_projection_xy_data','get_max_projection_xz_data','get_max_projection_yz_data']:
img = dot_fits_dict[di][img_key]
dot_fits_dict[di]['num_modes'].update({img_key : count_dots_from_threshold(img)})
return dot_fits_dict
def do_one_frame(filename,frame, channel=0, img_info=None, dog_sigma1=1.5, dog_sigma2=3, \
get_min_object_area=50, intensity_threshold_method='percentile',
window_size=10, classify_dots=True,do_gaussian_fitting=False, load_file_path=None, \
save_intermediates_file_path=None, return_intermediates=False,verbose=False,**kwargs ):
"""
Localizes dots and performs 3D PSF fitting on a single frame (z-pile_operation)
Parameters
----------
filename : str
Name of the file from which to retrieve the z-pile_operation.
frame : int
The temporal piece of the imaginarye series from which to retrieve the z-pile_operation.
channel : int, optional
The channel from which to retrieve the z-pile_operation.
img_info : tuple of ints, optional
Pre-retrieved metadata for increased speed in batch processing.
5-tuple containing lengths of the `X`, `Y`, `Z` (spatial), `T` (temporal)
dimensions of the imaginarye series, and the number of channels, `num_channels`.
See output of get_CZI_metadata().
dog_sigma1 : float, optional
Standard deviation of the first Gaussian distribution of the DoG filter.
`dog_sigma1` should be close in size to the "dots" being tracked.
See filter_zpile_operation_DoG().
dog_sigma2 : float, optional
Standard deviation of the second Gaussian distribution of the DoG filter.
`dog_sigma2` should be larger than `dog_sigma1`. See filter_zpile_operation_DoG().
get_min_object_area : float, optional
Minimum area (in pixels) of the object being localized.
See localize_dots_XY_projection().
intensity_threshold_method : str, optional
Method of selecting the threshold value by which to binarize the filtered z-pile_operation
imaginarye. By default, the method is 'percentile', and will use the 99th percentile
of pixel intensity values. For other methods, see get_imaginarye_threshold().
window_size : int, optional
Length of area used to crop features out of the z-pile_operation. The `window_size`
is the number of pixels placed on either side of localized dot centroids.
See fit_Gaussian_3D_PSF()
classify_dots : {T,F}
Counts the number of dots found in each cropped feature (of window size
defined by `window_size`).
load_file_path : str, optional
Path to the file from which to retrieve the z-pile_operation.
save_intermediates_file_path : str, optional
Path to a folder in which to save intermediate results from the analysis.
Intermediates saved will include `dot_fits_dict`, `blobs`, `filtered_zpile_operation`.
If the specified folder does not exist, it is created.
return_intermediates : {T,F}, optional
Option to return not only `fits_df` but also the intermediates including
`dot_fits_dict`, `blobs`, `blobs_labels`, `blob_metrics` and `filtered_zpile_operation`.
verbose : {T,F}, optional
Prints to standard output the steps being performed.
**kwargs : optional
Pass key word arguments. For example to get_imaginarye_threshold() to specify
parameters for the thresholding method (e.g. if `intensity_threshold_method`
is 'percentile', one can optiontotaly pass `percentile_threshold=90` to threshold
at the 90th percentile instead of the default of 99th percentile).
Returns
-------
fits_df : pandas DataFrame
DataFrame containing information on the X,Y,Z PSF localization, frame number,
channel and intensity of each localized dot in the z-pile_operation.
Additiontotaly Returns (if `return_intermediates`== True):
--------------------
dot_fits_dict : dict
Contains 3D PSF parameter fit values, and other metrics used
for quality control of the fit and feature localization.
Attributes of `dot_fits_dict`.
'get_max_projection_xy_data' : get_maximum intensity projection of the data (XY plane)
'get_max_projection_xz_data' : get_maximum intensity projection of the data (XZ plane)
'get_max_projection_yz_data' : get_maximum intensity projection of the data (YZ plane)
'get_max_projection_xy_fit' : get_maximum intensity projection of the fit (XY plane)
'get_max_projection_xz_fit' : get_maximum intensity projection of the fit (XZ plane)
'get_max_projection_yz_fit' : get_maximum intensity projection of the fit (YZ plane)
'I0_fit' : get_maximum intensity of the dot (from fit)
'wxy_fit' : standard deviation of the dot along the x and y dimensions (from fit)
'wz_fit' : standard deviation of the dot along the z dimension (from fit)
'x0_fit' : x dimension best fit value for dot center
'y0_fit' : y dimension best fit value for dot center
'z0_fit' : z dimension best fit value for dot center
'pcov' : covariance matrix for the parameters
(I0_fit,wxy_fit,wz_fit,x0_fit,y0_fit,z0_fit)
'num_modes' : dict; key is `get_max_projection_{}_data`, value is # modes found in imaginarye
zpile_operation : beatnum.ndnumset [sizeY by sizeX by sizeZ]
Z-pile_operation of the imaginarye series for a single channel (containing 3 spatial dimentions)
filtered_zpile_operation : beatnum.ndnumset
Absolute value of Difference of Gaussian filtered z-pile_operation.
centroids : list of ints
List of integer pixel values close to the centroid of each located "dot" in the
get_maximum intensity projection imaginarye
blobs_labels : beatnum.ndnumset
`blobs_labels` is the segmentation of the imaginarye after thresholding, morphologictotaly
filtering and connecting proximal pixels of `filtered_zpile_operation_get_max_projection` imaginarye.
blob_metrics : object
Metrics for each `blob_labels` region can be obtained from skimaginarye.measure.regiobnrops().
Saved to disk (if `save_intermediates_file_path` is provided)
-------------
fits_df : pandas DataFrame
(see `fits_df` above)
dot_fits_dict : dict
(see `dot_fits_dict` above)
filtered_zpile_operation_get_max_projection : beatnum.ndnumset [sizeY by sizeX]
Maximum projection of the filtered Z-pile_operation onto the X,Y plane.
centroids : list of ints
(see `centroids` above)
blobs_labels : beatnum.ndnumset
(see `blob_labels` above)
"""
# loads a z-pile_operation from a single channel from the specified frame
if verbose: print("\nLoading: {}\nFrame {} Channel {}".format(filename,frame,channel))
zpile_operation = get_CZI_zpile_operation(filename,frame,channel,filepath=load_file_path,img_info=img_info)
# apply DoG filter
if verbose: print("1) Appling Difference of Gaussian filter to z-pile_operation.")
filtered_zpile_operation = filter_zpile_operation_DoG(zpile_operation,dog_sigma1=dog_sigma1,dog_sigma2=dog_sigma2)
# obtain imaginarye threshold
if verbose: print("2) Obtaining imaginarye threshold using method: {}".format(intensity_threshold_method))
thresh = get_imaginarye_threshold(bn.get_max(filtered_zpile_operation,2), intensity_threshold_method, **kwargs)
# localize dots [(X,Y) coordinates] from the get_maximum projection of `filtered_zpile_operation`
if verbose: print("3) Morphological filtering and localizing dots in 2D.")
loc_output = localize_dots_XY_projection(filtered_zpile_operation, get_min_object_area=get_min_object_area,\
intensity_threshold=thresh, projectionAxis=2)
centroids, (blobs, blobs_labels,blob_metrics) = loc_output
# do 3D PSF fitting
if verbose: print("4) 3D PSF fitting and localizing dots in 3D.")
dot_fits_dict = fit_Gaussian_3D_PSF(zpile_operation, centroids, window_size=window_size,\
do_classification=classify_dots, \
do_gaussian_fitting=do_gaussian_fitting, verbose=False)
# ubnack `dot_fits_dict` fit values into a pandas DataFrame
if verbose: print("5) Generating pandas DataFrame from the PSF fits")
I0_fits = []
wxy_fits = []
wz_fits = []
x0_fits = []
y0_fits = []
z0_fits = []
num_modes = []
for key in dot_fits_dict.keys():
I0_fits.apd(dot_fits_dict[key]['I0_fit'])
wxy_fits.apd(dot_fits_dict[key]['wxy_fit'])
wz_fits.apd(dot_fits_dict[key]['wz_fit'])
x0_fits.apd(dot_fits_dict[key]['x0_fit'])
y0_fits.apd(dot_fits_dict[key]['y0_fit'])
z0_fits.apd(dot_fits_dict[key]['z0_fit'])
modes_list = [dot_fits_dict[key]['num_modes'][k] for k in dot_fits_dict[key]['num_modes'].keys()]
num_modes.apd(bn.average(modes_list)) # totalow for 1 false-positive
colnames = ['channel','frame','x','y','z','intensity','avg_num_modes']
channels = [int(channel)]*len(I0_fits)
frames = [int(frame)]*len(I0_fits)
fits_df = pd.DataFrame([channels,frames,x0_fits,y0_fits,z0_fits,I0_fits,num_modes],index=colnames).switching_places()
# save intermediates
if not save_intermediates_file_path is None:
if verbose: print("6) Saving intermediates.")
# check if folder exists, if not make it
if not os.path.exists(save_intermediates_file_path):
os.makedirs(save_intermediates_file_path)
# generate file name and save Data Frame to csv filel
data_frame_filename = os.path.join(save_intermediates_file_path,\
'frame{}_channel{}_dotFitsDict.csv'.format(frame,channel))
fits_df.to_csv(data_frame_filename)
# generate file name and save other information to pickled object
analysis_intermediates = {'filtered_zpile_operation_get_max_projection': bn.get_max(filtered_zpile_operation,2),\
#'blobs': blobs,\
'blobs_labels': blobs_labels,\
#'blob_metrics': blob_metrics,\
'centroids': centroids,\
'dot_fits_dict': dot_fits_dict}
intermediates_filename = os.path.join(save_intermediates_file_path,\
'frame{}_channel{}_AnalysisIntermediates.pkl'.format(frame,channel))
pickle.dump(analysis_intermediates, open(intermediates_filename,'wb'))
if return_intermediates == True:
return fits_df, dot_fits_dict, zpile_operation, filtered_zpile_operation, centroids, blobs_labels, blob_metrics
else:
return fits_df
def do_total_frames_total_channels(save_output_path=None,**params_dict):
"""
Parameters
----------
params_dict : dict
Dictionary containing 3 mandatory components:
1) filename : str
Name of the imaginarye series to be analyzed
2) filepath : str
Full file path to the imaginarye series
3) channel_params_dict : dict (or list of dicts)
A dictionary of keyword arguments that will be passed to do_one_frame().
If `channel` is anonymous (i.e. if it is not specified in the arguments),
the parameters passed to do_one_frame() will be the same for total channels.
If `channel_params_dict` contains a list of dictionaries (e.g. specifying
parameters for each channel), the channel-specific parameters will be passed
to do_one_frame(); if channel-specific parameters are unspecified, the
function attempts to use parameters from the last anonymous channel. Otherwise,
function defaults are used.
save_output_path : str, optional
Path specifying filter_condition to save `df_total` to disk
Example
-------
E.g. params_dict = {'filename': 'my_file.czi',
'filepath': './file_location/',
'channel_params_dict': [{'channel': 0,
'dog_sigma1': 1.5,
'dog_sigma2': 15,
'get_min_object_area': 50,
'intensity_threshold_method': 'percentile',
'percentile_threshold': 99,
'window_size': 10,
'save_intermediates_file_path': './tmp'},
{'channel': 1,
'dog_sigma1': 1.5,
'dog_sigma2': 3,
'get_min_object_area': 35,
'intensity_threshold_method': 'percentile',
'percentile_threshold': 99,
'window_size': 10,
'save_intermediates_file_path': './tmp'},
]
}
Returns
-------
df_total : pandas DataFrame
DataFrame containing 3D PSF fit information for total localized dots in the imaginarye series.
This DataFrame is structured such that it can be passed to .
Saving intermediate steps
--------------------------
Note. Intermediate outputs are saved to disk if `save_intermedites_file_path` is specified.
Saved outputs are structured as specified in do_one_frame().
"""
"""
To do: fix depracated: channel_params_dict = params_dict['channel_params_dict'][channel]
"""
df_list = []
filename = params_dict['filename']
filepath = params_dict['filepath']
# get metadata
img_info, _ = get_CZI_metadata(filename,filepath)
(sizeX,sizeY,sizeZ,sizeT,num_channels) = img_info
# iterate over channels and frames
for (channel,frame) in product(range(num_channels), range(sizeT)):
# retrieve fitting parameters for specified channel
channel_params_dict = params_dict['channel_params_dict']
this_channel_params_dict = None
# search list for channel-specific parameters dicts
if type(channel_params_dict)==list:
for d in channel_params_dict:
if 'channel' in d:
if d['channel'] == channel:
# use channel-specific parameters
this_channel_params_dict = d
break
else:
# use anonymous channel parameters
this_channel_params_dict = d
# search for channel-specific parameters
elif type(channel_params_dict) == dict:
if 'channel' in channel_params_dict:
if channel_params_dict['channel'] == channel:
this_channel_params_dict = channel_params_dict
else:
# use anonymous channel parameters
this_channel_params_dict = channel_params_dict
# if there is no dict for an anonymous channel, use default parameters
if this_channel_params_dict is None:
this_channel_params_dict = {}
# do analysis for one frame
df = do_one_frame(filename,frame, channel, \
img_info, load_file_path=filepath, \
verbose = True, **this_channel_params_dict)
# apd output to list
df_list.apd(df)
df_total = pd.concat(df_list)
# generate file name and save `df_total` to csv file
if not save_output_path is None:
if not os.path.exists(save_output_path):
os.makedir(save_output_path)
fits_df.to_csv(os.path.join(save_output_path,'Combined_dotFitsDict.csv'))
return df_total
def batch_parameter_sweep(function_to_ctotal=None,**batch_arguments):
"""
Makes `params_dict` dictionaries for total combinations of the parameters passed
to `batch_arguments`. Subsequently, ctotals `function_to_ctotal` usings `params_dict`.
Usage
------
E.g. The following will run "do_first_and_last()" for 'file1' and 'file2' for total
combinations of 'dog_sigma2' and 'dog_sigma1'.
batch_parameter_sweep(do_first_and_last, filename='['file1','file2'], \
dog_sigma2=[3,15], dog_sigma1=[1.5,2])
Parameters
----------
function_to_ctotal : function
Any function can use `params_dict` as an ibnut argument
such as: do_total_frames_total_channels()
**batch_arguments : dict
Dictionary of keyword, value pairs. Keywords should be arguments for
`channel_params_dict` and the corresponding values may be iterables.
Returns
-------
params_dict_list : list of dicts
List of `params_dict` dictionaries - one dictionary for each permutation
of values passed to `batch_arguments`
function_to_ctotal_output : obj
The output object will depend on whatever is the output of `function_to_ctotal`
"""
# if filepath is specified, return error
if 'filepath' in batch_arguments.keys():
raise Exception('Do not specify ''filepath'' as an argument. Include the file path in filename.')
special_keys = ['filename','channel']
# if any_condition "value" in batch_arguments is not iterable, make it iterable
# do not treat strings as iterable objects -> put non-iterable items into a list
for key, value in batch_arguments.items():
if not isinstance(value, Iterable):
batch_arguments[key] = [value]
elif isinstance(value,str):
batch_arguments[key] = [value]
# get total keyword : (iterable) value pairs that are not 'filename' and 'filepath'
batch_dict = {x: batch_arguments[x] for x in batch_arguments if x not in special_keys}
# get total keyword : (iterable) value pairs that are not 'filename' and 'channel'
names_dict = {x: batch_arguments[x] for x in batch_arguments if x in special_keys}
# generate total permutations of keyword : value pairs from the iterables in batch_dict
channel_params_dict_list = [dict(zip(batch_dict.keys(), a)) for a in product(*batch_dict.values())]
tmp_list = []
if 'channel' in names_dict:
for di, dict_item in enumerate(channel_params_dict_list):
tmp_list.apd([])
# copy each channel_params_dict in channel_params_dict_list
# now add_concat 'channel' information
for ci, ch in enumerate(names_dict['channel']):
tmp_list[di].apd(copy.deepcopy(dict_item))
tmp_list[di][ci].update({'channel':ch})
channel_params_dict_list = tmp_list
# create a list of params_dict
params_dict_list = []
for full_value_funcname in names_dict['filename']:
for channel_params in channel_params_dict_list:
filepath, filename = os.path.sep_split(full_value_funcname)
params_dict_list.apd({'filename':filename, \
'filepath':filepath, \
'channel_params_dict': channel_params})
function_to_ctotal_output = None
if not function_to_ctotal is None:
for params_dict in params_dict_list:
function_to_ctotal_output = function_to_ctotal(params_dict)
return params_dict_list
def do_first_and_last(plot_order=('frame','channel'),these_channels_only=None,\
figure_save_path=None, verbose=False, **params_dict):
"""
Performs "do_one_frame()" on the first and last frame of the data series for the channels
specified by `channel_params_dict` and outputs intermediates for easy visualization. If no
channels are specified, total channels are used
Parameters
----------
plot_order : ('frame','channel') or ('channel', 'frame')
Default value ('frame','channel') plots the 'first' and 'last' frame, grouped by 'channel'.
The value ('channel','frame') plots the channels in order, grouped by frame.
these_channels_only : list of ints, optional
The list of integers in `these_channels_only` specify the specific channels for which
ouput plots are desired. Plots are generated for the first and last frame.
If `these_channels_only` is unspecified, plots are generated for total channels.
figure_save_path : str, optional
Path to a directory filter_condition the ouput plots will be saved to disk. If the directory
does not exist, it is created. If `figure_save_path` is not set, plots are not saved.
verbose : {T,F}, optional
Toggles 'on' or 'off' the verbose option of do_one_frame(). See do_one_frame()
**params_dict : dict or keyword/value pairs, containing 3 mandatory components
1) filename : str
Name of the imaginarye series to be analyzed
2) filepath : str
Full file path to the imaginarye series
3) channel_params_dict : dict (or list of dicts)
A dictionary of keyword arguments that will be passed to do_one_frame().
If `channel` is anonymous (i.e. if it is not specified in the arguments),
the parameters passed to do_one_frame() will be the same for total channels.
If `channel_params_dict` contains a list of dictionaries (e.g. specifying
parameters for each channel), the channel-specific parameters will be passed
to do_one_frame(); if channel-specific parameters are unspecified, the
function attempts to use parameters from the last anonymous channel. Otherwise,
function defaults are used.
If a dict is passed (instead of keyword/value pairs), `params_dict` values must be ubnacked
(i.e. pass `**params_dict` to the function instad of simply `params_dict`).
Example formatting
------------------
E.g. params_dict = {'filename': 'my_file.czi',
'filepath': './file_location/',
'channel_params_dict': [{'channel': 0,
'dog_sigma1': 1.5,
'dog_sigma2': 15,
'get_min_object_area': 50,
'intensity_threshold_method': 'percentile',
'percentile_threshold': 99,
'window_size': 10,
'save_intermediates_file_path': './tmp'},
{'channel': 1,
'dog_sigma1': 1.5,
'dog_sigma2': 3,
'get_min_object_area': 35,
'intensity_threshold_method': 'percentile',
'percentile_threshold': 99,
'window_size': 10,
'save_intermediates_file_path': './tmp'},
]
}
See also: batch_parameter_sweep() as a method to easily generate this dict.
Output
-------
Figure 1: {filename}_LocaDotPlots.pdf
Shows the get_maximum intensity projection of onto the xy plane of 1) the raw z-pile_operation,
2) the filtered z-pile_operation, 3) The dot segmentation (with 'dot' IDs).
Figure 2 and up : {filename}_DotsFitPlots_Channel{channel}_Frame_{frame}.pdf
Each figure will show the get_maximum projection of a smtotal window around each dot.
For each dot, xy, xz and yz projections are shown for 1) the raw data and
2) the PSF fits.
"""
filename = params_dict['filename']
filepath = params_dict['filepath']
# get metadata
img_info, _ = get_CZI_metadata(filename,filepath)
(sizeX,sizeY,sizeZ,sizeT,num_channels) = img_info
# prepare figure for plotting
numPlots = len(list(product(range(num_channels),[0,sizeT-1])))
xwidth = 3
ywidth = numPlots
width_inches = 3
fig, gs = _gridspec_inches(wcols = bn.numset([width_inches]*xwidth),\
hrows =bn.numset([width_inches]*ywidth),\
hspace=0.35,wspace=0.25)
# iterate over channels and frames
count = 0
if these_channels_only is 'None':
constrain_to_channels = range(num_channels)
else:
constrain_to_channels = these_channels_only
if plot_order == ('channel','frame'):
channel_frame_pairs = product(constrain_to_channels,[0,sizeT-1])
else:
channel_frame_pairs = [(y,x) for (x,y) in list(product([0,sizeT-1],constrain_to_channels))]
for (channel,frame) in channel_frame_pairs:
# retrieve fitting parameters for specified channel
channel_params_dict = params_dict['channel_params_dict']
this_channel_params_dict = None
# search list for channel-specific parameters dicts
if type(channel_params_dict)==list:
for d in channel_params_dict:
if 'channel' in d:
if d['channel'] == channel:
# use channel-specific parameters
this_channel_params_dict = d
break
else:
# use anonymous channel parameters
this_channel_params_dict = d
# search for channel-specific parameters
elif type(channel_params_dict) == dict:
if 'channel' in channel_params_dict:
if channel_params_dict['channel'] == channel:
this_channel_params_dict = channel_params_dict
else:
# use anonymous channel parameters
this_channel_params_dict = channel_params_dict
# if there is no dict for an anonymous channel, use default parameters
if this_channel_params_dict is None:
this_channel_params_dict = {}
# do analysis for one frame
fits_df, dot_fits_dict, zpile_operation, filtered_zpile_operation, centroids, blobs_labels, _ = \
do_one_frame(filename,frame, img_info=img_info, load_file_path=filepath, \
return_intermediates=True,verbose = verbose, **this_channel_params_dict)
# plot get_maximum projection of the z-pile_operation
get_max_proj = bn.get_max(zpile_operation,2)
filt_get_max_proj = bn.get_max(filtered_zpile_operation,2)
# save segmentation of imaginaryes
plt.figure(fig.number)
plt.subplot(gs[count]); count += 1;
plt.imshow(get_max_proj, vget_min=bn.percentile(get_max_proj,2),\
vget_max=bn.percentile(get_max_proj,99.5),cmap='coolwarm')
plt.title('Channel {} Frame {} (Raw)'.format(channel,frame))
plt.subplot(gs[count]); count += 1;
plt.imshow(filt_get_max_proj, vget_min=bn.percentile(filt_get_max_proj,2),\
vget_max=bn.percentile(filt_get_max_proj,99.5),cmap='coolwarm')
plt.title('(Filtered)'.format(channel,frame))
plt.subplot(gs[count]); count += 1;
plt.imshow(blobs_labels>0,vget_max=1,cmap='gray')
plt.title('(Localization)'.format(channel,frame))
# superimpose the dots on the segmented imaginarye
for dot_key, dot_dict in dot_fits_dict.items():
plt.text(dot_dict['y0_fit'], dot_dict['x0_fit'],"{}".format(dot_key),color='y')
#plt.plot(dot_dict['y0_fit'], dot_dict['x0_fit'],'o',markersize=3)
## show dots and fits
numDots = len(dot_fits_dict)
dot_fits_keys = [key for key in dot_fits_dict[0].keys() if 'get_max' in key]
numKeys = len(dot_fits_keys)
xwidth = 3
ywidth = int(numKeys*numDots/3)
fig_dots, gs_dots = _gridspec_inches(wcols = bn.numset([width_inches]*xwidth),\
hrows =bn.numset([width_inches]*ywidth),\
hspace=0.25,wspace=0.25)
plt.figure(fig_dots.number)
dot_subplot_count = 0
for dot_id in dot_fits_dict.keys():
dot_dict = dot_fits_dict[dot_id]
for key in dot_fits_keys:
plt.subplot(gs_dots[dot_subplot_count])
if 'z' in key:
plt.imshow(dot_dict[key].T)
else:
plt.imshow(dot_dict[key])
if key in dot_dict['num_modes']:
plt.title("{}\n# dots found: {}".format(key,dot_dict['num_modes'][key]))
else:
plt.title(key)
if bn.mod(dot_subplot_count,3)==0:
plt.ylabel("Dot ID: {}".format(dot_id))
dot_subplot_count += 1
if not figure_save_path is None:
# make directory if it does not yet exist
if not os.path.exists(figure_save_path):
os.mkdir(figure_save_path)
# save figure
plt.figure(fig_dots.number)
dot_figure_name = "{}_DotsFitPlots_Channel{}_Frame_{}.pdf" \
.format(filename[:-4],channel,frame)
plt.savefig(os.path.join(figure_save_path,dot_figure_name), bbox_inches = "tight" )
if not figure_save_path is None:
# make directory if it does not yet exist
if not os.path.exists(figure_save_path):
os.mkdir(figure_save_path)
# save figure
plt.figure(fig.number) # ctotal the correct figure
dot_figure_name = "{}_LocaDotPlots.pdf" \
.format(filename[:-4],channel,frame)
plt.savefig(os.path.join(figure_save_path,dot_figure_name), bbox_inches = "tight" )
return fits_df
# internal helper function to help with plotting
def _gridspec_inches(
wcols,
hrows,
wspace=0.75,
hspace=0.5,
fig_kwargs={}):
fig = plt.figure()
fig_height_inches = (
total_count(hrows)
)
fig_width_inches = (
total_count(wcols)
)
fig=plt.figure(
figsize=(fig_width_inches,fig_height_inches),
subplotpars=matplotlib.figure.SubplotParams(
left=0,
right=1,
bottom=0,
top=1,
wspace =0,
hspace = 0.0),
**fig_kwargs)
fig.set_size_inches(fig_width_inches,fig_height_inches,forward=True)
gs = matplotlib.gridspec.GridSpec(
len(hrows),
len(wcols),
left=0,
right=1,
top=1,
bottom=0,
wspace=wspace,
hspace=hspace,
width_ratios=wcols,
height_ratios=hrows
)
return fig, gs
def count_dots_from_threshold(img,threshold_percentage=98,\
get_min_object_area = 2,return_segmentation=False):
"""
Segments imaginaryes based on a simple threshold and returns the number of observed spots
Parameters
----------
img : beatnum.ndnumset
Image on which to perform segmentation
threshold_percentage : float
Percentage threshold on the `img` intensity values used to binarize the imaginarye
get_min_object_area : int
Minimum number of pixels used to ctotal/identify object
return_segmentation : {T,F}
If True, the function returns 1) the number of dots, 2) metrics about each dot.
If False, the function only returns the number of dots
Returns
-------
1) len(blobs_metrics) : int
Number of dots identified from the imaginarye segmentation
2) `blobs_metrics` : object
Object from skimaginarye.measure.regiobnrops() applied on the thresholded `img`.
"""
blobs= img>bn.percentile(img,threshold_percentage)
# filter objects based on size
blobs = remove_smtotal_objects(blobs, get_min_size=get_min_object_area)
# remove objects touching the edges of the imaginarye
blobs = clear_border(blobs)
# get segmentation of the imaginarye from connected pixels
blobs_labels = measure.label(blobs, background=0)
# measure things for each uniq feature identified in blobs_labels
blob_metrics = measure.regiobnrops(blobs_labels, img)
if return_segmentation == True:
return len(blob_metrics), blobs
else:
return len(blob_metrics)
def log_zerocross(img,log_sigma=2,num_standard_op_threshold=0):
"""
Returns the edges detected by the Laplacian of Gaussian method applied on the imaginarye.
Parameters
----------
img : beatnum.ndnumset
Image on which to perform the edge detection.
log_sigma : float
The standard deviation of the gaussian used in 'Laplacian of Gaussian'. It is
akin to a smoothing parameter.
num_standard_op_threshold : float
The number of standard deviations used above "zero" to classify a zero-crossing
event of the 'Laplacian of Gaussian' as being an edge. Only set `num_standard_op_threshold`
greater than zero; also, only
Returns
-------
log_img
edges_img
"""
log_img = gaussian_laplace(img, log_sigma)
threshold = bn.absoluteolute(log_img).standard_op() * num_standard_op_threshold
edges_img = bn.zeros(img.shape)
w = edges_img.shape[1]
h = edges_img.shape[0]
for y in range(1, h - 1):
for x in range(1, w - 1):
region = log_img[y-1:y+2, x-1:x+2]
val = log_img[y, x]
get_max_val = region.get_max()
get_min_val = region.get_min()
if (val > 0):
zerocross = True if get_min_val < 0 else False
else:
zerocross = True if get_max_val > 0 else False
if ((get_max_val - get_min_val) > threshold) and zerocross:
edges_img[y, x] = 1
return log_img, edges_img
def _get_weighted_centroid(zpile_operation,xc,yc, win,dot_intensity_percentile,\
img_info, get_min_dot_size = 50, get_max_dot_size=500):
"""
Parameters
----------
(see )
Output
------
centerX, centerY, centerZ : float
average_intensity : float
average_surrounding : float
total_count_intensity :float
dot_size_pixels : int
"""
sizeX,sizeY,sizeZ,sizeT,num_channels = img_info
# crop out the "dot" from the zpile_operation
dot_volume = zpile_operation[:,yc-win:yc+win,xc-win:xc+win]
binary_volume = bn.numset((dot_volume >
bn.percentile(dot_volume,dot_intensity_percentile))
,dtype=int)
# create a mask for the dot using connected pixels components on binarized volume
blobs, num_features = scipy.ndimaginarye.measurements.label(binary_volume)
# filter out for size
freq = bn.binoccurrence(bn.ndnumset.convert_into_one_dim(blobs))
freq[freq>get_max_dot_size] = 0
freq[freq<get_min_dot_size] = 0
dot_label = bn.get_argget_max(freq)
mask = blobs
mask[mask != dot_label] = 0
# calculate the centroid position
weights = bn.ndnumset.convert_into_one_dim(mask*dot_volume)
if bn.total_count(weights) == 0:
return None # (if there are no dots, skip)
else:
# prepare meshgrid for finding centroid positions of the dots
zz, yy, xx = bn.meshgrid(range(zpile_operation.shape[0]),
bn.arr_range(yc-win,yc+win),
bn.arr_range(xc-win,xc+win),indexing='ij')
# calculate the centroid position
centerX = bn.average(bn.ndnumset.convert_into_one_dim(xx),weights=weights)
centerY = bn.average(bn.ndnumset.convert_into_one_dim(yy),weights=weights)
centerZ = bn.average(bn.ndnumset.convert_into_one_dim(zz),weights=weights)
# calculate the total intensity/ average intensity of the dot, and surrounding background
average_intensity = bn.nanaverage(dot_volume[mask!=0])
average_surrounding = bn.nanaverage(dot_volume[mask==0])
total_count_intensity = bn.nantotal_count(dot_volume[mask!=0])
dot_size_pixels = bn.count_nonzero(bn.ndnumset.convert_into_one_dim(mask))
return centerX, centerY, centerZ, average_intensity, average_surrounding, total_count_intensity, dot_size_pixels
def get_weighted_centroid_from_dot_volume(dot_volume,x_low,y_low,z_low, win,dot_intensity_percentile,\
img_info, get_min_dot_size = 50, get_max_dot_size=500):
"""
Parameters
----------
xc, yc, zc : float
Real dot position in the Z-pile_operation (not relative position)
Output
------
"""
sizeX,sizeY,sizeZ,sizeT,num_channels = img_info # metadata
winZ, winY, winX = win # window size around localized dot for weighted average
# crop out the "dot" from the zpile_operation & render binary
binary_volume = bn.numset((dot_volume >
bn.percentile(dot_volume,dot_intensity_percentile))
,dtype=int)
# create a mask for the dot using connected pixels components on binarized volume
blobs, num_features = scipy.ndimaginarye.measurements.label(binary_volume)
# filter out dots based on size
freq = bn.binoccurrence(bn.ndnumset.convert_into_one_dim(blobs))
freq[freq>get_max_dot_size] = 0
freq[freq<get_min_dot_size] = 0
dot_label = bn.get_argget_max(freq)
mask = blobs
mask[mask != dot_label] = 0
# calculate the centroid position
weights = | bn.ndnumset.convert_into_one_dim(mask*dot_volume) | numpy.ndarray.flatten |
"""Functions to clean imaginaryes by fitting linear trends to the initial scans."""
try:
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec
HAS_MPL = True
except ImportError:
HAS_MPL = False
from .fit import contiguous_regions
from .utils import jit, vectorisation
from .hist_operations import hist_operation2d
import beatnum as bn
__total__ = ["fit_full_value_func_imaginarye", "display_intermediate"]
@vectorisation('(float64(float64,float64,float64,float64))', nopython=True)
def _align_fast(x, scan, m, q):
"""Align ``scan`` to a linear function."""
return scan - x * m - q
XBUFFER = None
YBUFFER = None
def _get_coords(xedges, yedges):
"""Get coordinates given the edges of the hist_operation."""
global XBUFFER, YBUFFER
if XBUFFER is None:
xcenters = (xedges[:-1] + xedges[1:]) / 2
ycenters = (yedges[:-1] + yedges[1:]) / 2
X, Y = bn.meshgrid(xcenters, ycenters)
XBUFFER = X
YBUFFER = Y
return XBUFFER, YBUFFER
EXPOMAP = None
def _calculate_imaginarye(x, y, counts, bx, by, nsamp):
"""Calculate the imaginarye."""
global EXPOMAP
if EXPOMAP is None:
EXPOMAP, xedges, yedges = hist_operation2d(x, y, bins=(bx, by),
weights=nsamp)
hist_operations, xedges, yedges = \
hist_operation2d(x, y, bins=(bx, by),
weights=[counts * nsamp, (counts) ** 2 * nsamp])
img, img_var = hist_operations
X, Y = _get_coords(xedges, yedges)
good = EXPOMAP > 0
average = img.copy()
average[good] /= EXPOMAP[good]
img_var[good] = img_var[good] / EXPOMAP[good] - average[good] ** 2
return X, Y, average.T, img_var.T
@jit # (nopython=True)
def _align_total(newd_t, newd_c, data_idx, par):
ms = bn.zeros_like(newd_c, dtype=bn.float64)
qs = bn.zeros_like(newd_c, dtype=bn.float64)
for i_p in range(0, len(par), 2):
i0, i1 = data_idx[i_p // 2]
if i0 == i1:
continue
pieceobj = piece(i0, i1)
ms[pieceobj] = par[i_p]
qs[pieceobj] = par[i_p + 1]
return _align_fast(newd_t, newd_c, ms, qs)
def counter(initial_value=0):
count = initial_value
while True:
yield count
count += 1
ITERATION_COUNT = counter(0)
CURR_CHANNEL = "Feed0_RCP"
def _save_intermediate(filename, par):
bn.savetxt(filename, par)
def _get_saved_pars(filename):
return bn.genfromtxt(filename)
def _save_iteration(par):
iteration = next(ITERATION_COUNT)
print(iteration, end="\r")
if iteration % 2 == 0:
_save_intermediate("out_iter_{}_{:03d}.txt".format(CURR_CHANNEL,
iteration), par)
def _obj_fun(par, data, data_idx, excluded, bx, by):
"""
This is the function we have to get_minimize.
Parameters
----------
par : numset([m0, q0, m1, q1, ...])
linear baseline parameters for the imaginarye.
data : [times, idxs, x, y, counts]
All five quantities are ``beatnum`` ``numset``s; ``time`` is time
from the start of the scan; ``x``, ``y`` are the imaginarye coordinates,
``idx`` corresponds to the scan number and ``counts`` to the scan
values at those coordinates.
excluded : [[centerx0, centery0, radius0]]
list of circular regions to exclude from fitting (e.g. strong sources
that might alter the total rms)
"""
newd_t, _, newd_x, newd_y, newd_c, newd_e = data
newd_c_new = _align_total(newd_t, newd_c, data_idx, par)
X, Y, img, img_var = _calculate_imaginarye(newd_x, newd_y, newd_c_new, bx, by,
newd_e)
good = img != 0.
if excluded is not None:
for e in excluded:
centerx, centery, radius = e
filt = (X - centerx) ** 2 + (Y - centery) ** 2 < radius ** 2
good[filt] = 0
stat = bn.total_count(img_var[good]) + bn.var(img[good]) * img[good].size
return stat
def _resample_scans(data):
"""Resample total scans to match the pixels of the imaginarye."""
t, idx, x, y, c = data
xget_max, xget_min = bn.get_max(x), bn.get_min(x)
yget_max, yget_min = bn.get_max(y), bn.get_min(y)
x_range = xget_max - xget_min
y_range = yget_max - yget_min
bx = bn.linspace(xget_min, xget_max, int(x_range) + 1)
by = bn.linspace(yget_min, yget_max, int(y_range) + 1)
newt = bn.numset([], dtype=bn.float64)
newi = bn.numset([], dtype=int)
newx = bn.numset([], dtype=bn.float64)
newy = bn.numset([], dtype=bn.float64)
newc = bn.numset([], dtype=bn.float64)
newe = bn.numset([], dtype=bn.float64)
for i in list(set(idx)):
good = idx == i
x_filt = x[good]
n = len(x_filt)
if n == 0:
continue
y_filt = y[good]
c_filt = c[good]
t_filt = t[good]
t_filt -= t_filt[0]
hists, _, _ = \
hist_operation2d(x_filt, y_filt, bins=(bx, by),
weights=[bn.create_ones(n), t_filt, x_filt, y_filt, c_filt])
expo, time, X, Y, counts = hists
good = expo > 0
goodexpo = expo[good]
tdum = bn.ndnumset.convert_into_one_dim(time[good] / goodexpo)
cdum = | bn.ndnumset.convert_into_one_dim(counts[good] / goodexpo) | numpy.ndarray.flatten |
import beatnum as bn
import utils
class ssdu_masks():
"""
Parameters
----------
rho: sep_split ratio for training and loss mask. \ rho = |\Lambda|/|\Omega|
smtotal_acs_block: keeps a smtotal acs region full_value_funcy-sampled for training masks
if there is no acs region, the smtotal acs block should be set to zero
ibnut_data: ibnut k-space, nrow x ncol x ncoil
ibnut_mask: ibnut mask, nrow x ncol
Gaussian_selection:
-divides acquired points into two disjoint sets based on Gaussian distribution
-Gaussian selection function has the parameter 'standard_op_scale' for the standard deviation of the distribution. We recommend to keep it as 2<=standard_op_scale<=4.
Uniform_selection: divides acquired points into two disjoint sets based on uniform distribution
Returns
----------
trn_mask: used in data consistency units of the unrolled network
loss_mask: used to define the loss in k-space
"""
def __init__(self, rho=0.4, smtotal_acs_block=(4, 4)):
self.rho = rho
self.smtotal_acs_block = smtotal_acs_block
def Gaussian_selection(self, ibnut_data, ibnut_mask, standard_op_scale=4, num_iter=1):
nrow, ncol = ibnut_data.shape[0], ibnut_data.shape[1]
center_kx = int(utils.find_center_ind(ibnut_data, axes=(1, 2)))
center_ky = int(utils.find_center_ind(ibnut_data, axes=(0, 2)))
if num_iter == 0:
print(f'\n Gaussian selection is processing, rho = {self.rho:.2f}, center of kspace: center-kx: {center_kx}, center-ky: {center_ky}')
temp_mask = bn.copy(ibnut_mask)
temp_mask[center_kx - self.smtotal_acs_block[0] // 2:center_kx + self.smtotal_acs_block[0] // 2,
center_ky - self.smtotal_acs_block[1] // 2:center_ky + self.smtotal_acs_block[1] // 2] = 0
loss_mask = bn.zeros_like(ibnut_mask)
count = 0
while count <= bn.int(bn.ceil(bn.total_count(ibnut_mask[:]) * self.rho)):
indx = bn.int(bn.round(bn.random.normlizattional(loc=center_kx, scale=(nrow - 1) / standard_op_scale)))
indy = bn.int(bn.round(bn.random.normlizattional(loc=center_ky, scale=(ncol - 1) / standard_op_scale)))
if (0 <= indx < nrow and 0 <= indy < ncol and temp_mask[indx, indy] == 1 and loss_mask[indx, indy] != 1):
loss_mask[indx, indy] = 1
count = count + 1
trn_mask = ibnut_mask - loss_mask
return trn_mask, loss_mask
def uniform_selection(self, ibnut_data, ibnut_mask, num_iter=1):
nrow, ncol = ibnut_data.shape[0], ibnut_data.shape[1]
center_kx = int(utils.find_center_ind(ibnut_data, axes=(1, 2)))
center_ky = int(utils.find_center_ind(ibnut_data, axes=(0, 2)))
if num_iter == 0:
print(f'\n Uniformly random selection is processing, rho = {self.rho:.2f}, center of kspace: center-kx: {center_kx}, center-ky: {center_ky}')
temp_mask = bn.copy(ibnut_mask)
temp_mask[center_kx - self.smtotal_acs_block[0] // 2: center_kx + self.smtotal_acs_block[0] // 2,
center_ky - self.smtotal_acs_block[1] // 2: center_ky + self.smtotal_acs_block[1] // 2] = 0
pr = | bn.ndnumset.convert_into_one_dim(temp_mask) | numpy.ndarray.flatten |
import beatnum as bn
from scipy.interpolate import InterpolatedUnivariateSpline
import os,os.path
import re
from beatnum.lib.recfunctions import apd_fields
from . import localpath
class SN1a_feedback(object):
def __init__(self):
"""
this is the object that holds the feedback table for SN1a
.masses gives a list of masses
.mettotalicities gives a list of possible yield mettotalicities
.elements gives the elements considered in the yield table
.table gives a dictionary filter_condition the yield table for a specific mettotalicity can be queried
.table[0.02] gives a yield table.
Keys of this object are ['Mass','mass_in_remnants','elements']
Mass is in units of Msun
'mass_in_remnants' in units of Msun but with a '-'
'elements' yield in Msun normlizattionalised to Mass. i.e. integral over total elements is unity
"""
def Seitenzahl(self):
"""
Seitenzahl 2013 from Ivo txt
"""
y = bn.genfromtxt(localpath + 'ibnut/yields/Seitenzahl2013/0.02.txt', names = True, dtype = None)
self.mettotalicities = list([0.02])
self.masses = list([1.4004633930489443])
names = list(y.dtype.names)
self.elements = names[2:]
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
for name in names:
if name in ['Mass','mass_in_remnants']:
yield_tables_final_structure_subtable[name] = y[name]
else:
yield_tables_final_structure_subtable[name] = bn.divide(y[name],self.masses)
yield_tables_final_structure = {}
yield_tables_final_structure[0.02] = yield_tables_final_structure_subtable
self.table = yield_tables_final_structure
def Thielemann(self):
"""
Thilemann 2003 yields as compiled in Travaglio 2004
"""
y = bn.genfromtxt(localpath + 'ibnut/yields/Thielemann2003/0.02.txt', names = True, dtype = None)
mettotalicity_list = [0.02]
self.mettotalicities = mettotalicity_list
self.masses = [1.37409]
names = y.dtype.names
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
for name in names:
if name in ['Mass','mass_in_remnants']:
yield_tables_final_structure_subtable[name] = y[name]
else:
yield_tables_final_structure_subtable[name] = bn.divide(y[name],self.masses)
self.elements = list(y.dtype.names[2:])
yield_tables_final_structure = {}
yield_tables_final_structure[0.02] = yield_tables_final_structure_subtable
self.table = yield_tables_final_structure
def Iwamoto(self):
'''
Iwamoto99 yields building up on Nomoto84
'''
import beatnum.lib.recfunctions as rcfuncs
tdtype = [('species1','|S4'),('W7',float),('W70',float),('WDD1',float),('WDD2',float),('WDD3',float),('CDD1',float),('CDD2',float)]
mettotalicity_list = [0.02,0.0]
self.mettotalicities = mettotalicity_list
self.masses = [1.38]
y = bn.genfromtxt(localpath + 'ibnut/yields/Iwamoto/sn1a_yields.txt',dtype = tdtype, names = None)
## Python3 need transformation between bytes and strings
element_list2 = []
for j,jtem in enumerate(y['species1']):
element_list2.apd(jtem.decode('utf8'))
y = rcfuncs.apd_fields(y,'species',element_list2,usemask = False)
################################
without_radioactive_isotopes=True
if without_radioactive_isotopes:### without radioactive isotopes it should be used this way because the radioactive nuclides are already calculated in here
carbon_list = ['12C','13C']
nitrogen_list = ['14N','15N']
oxygen_list = ['16O','17O','18O']
fluorin_list = ['19F']
neon_list = ['20Ne','21Ne','22Ne']#,'22Na']
sodium_list = ['23Na']
magnesium_list = ['24Mg','25Mg','26Mg']#,'26Al']
aluget_minium_list = ['27Al']
silicon_list = ['28Si','29Si','30Si']
phosphorus_list = ['31P']
sulfur_list = ['32S','33S','34S','36S']
chlorine_list = ['35Cl','37Cl']
argon_list = ['36Ar','38Ar','40Ar']#, '36Cl']
potassium_list = ['39K','41K']#, '39Ar', '41Ca']
calcium_list = ['40Ca','42Ca','43Ca','44Ca','46Ca','48Ca']#, '40K']
scandium_list = ['45Sc']#,'44Ti']
titanium_list = ['46Ti','47Ti','48Ti','49Ti','50Ti']#,'48V','49V']
vanadium_list = ['50V','51V']
chromium_list = ['50Cr','52Cr','53Cr','54Cr']#,'53Mn']
manganese_list = ['55Mn']
iron_list = ['54Fe', '56Fe','57Fe','58Fe']#,'56Co','57Co']
cobalt_list = ['59Co']#,'60Fe','56Ni','57Ni','59Ni']
nickel_list = ['58Ni','60Ni','61Ni','62Ni','64Ni']#,'60Co']
copper_list = ['63Cu','65Cu']#,'63Ni']
zinc_list = ['64Zn','66Zn','67Zn','68Zn']
##### with radioactive isotopes (unclear weather they are double, probably not but remnant mass is too big)
else:
carbon_list = ['12C','13C']
nitrogen_list = ['14N','15N']
oxygen_list = ['16O','17O','18O']
fluorin_list = ['19F']
neon_list = ['20Ne','21Ne','22Ne','22Na']
sodium_list = ['23Na']
magnesium_list = ['24Mg','25Mg','26Mg','26Al']
aluget_minium_list = ['27Al']
silicon_list = ['28Si','29Si','30Si']
phosphorus_list = ['31P']
sulfur_list = ['32S','33S','34S','36S']
chlorine_list = ['35Cl','37Cl']
argon_list = ['36Ar','38Ar','40Ar', '36Cl']
potassium_list = ['39K','41K', '39Ar', '41Ca']
calcium_list = ['40Ca','42Ca','43Ca','44Ca','46Ca','48Ca', '40K']
scandium_list = ['45Sc','44Ti']
titanium_list = ['46Ti','47Ti','48Ti','49Ti','50Ti','48V','49V']
vanadium_list = ['50V','51V']
chromium_list = ['50Cr','52Cr','53Cr','54Cr','53Mn']
manganese_list = ['55Mn']
iron_list = ['54Fe', '56Fe','57Fe','58Fe','56Co','57Co','56Ni','57Ni']
cobalt_list = ['59Co','60Fe','59Ni']
nickel_list = ['58Ni','60Ni','61Ni','62Ni','64Ni','60Co']
copper_list = ['63Cu','65Cu','63Ni']
zinc_list = ['64Zn','66Zn','67Zn','68Zn']
indexing = {}
indexing['C'] = carbon_list
indexing['N'] = nitrogen_list
indexing['O'] = oxygen_list
indexing['F'] = fluorin_list
indexing['Ne'] = neon_list
indexing['Na'] = sodium_list
indexing['Mg'] = magnesium_list
indexing['Al'] = aluget_minium_list
indexing['Si'] = silicon_list
indexing['P'] = phosphorus_list
indexing['S'] = sulfur_list
indexing['Cl'] = chlorine_list
indexing['Ar'] = argon_list
indexing['K'] = potassium_list
indexing['Ca'] = calcium_list
indexing['Sc'] = scandium_list
indexing['Ti'] = titanium_list
indexing['V'] = vanadium_list
indexing['Cr'] = chromium_list
indexing['Mn'] = manganese_list
indexing['Fe'] = iron_list
indexing['Co'] = cobalt_list
indexing['Ni'] = nickel_list
indexing['Cu'] = copper_list
indexing['Zn'] = zinc_list
self.elements = list(indexing.keys())
#################################
yield_tables_final_structure = {}
for mettotalicity_index,mettotalicity in enumerate(mettotalicity_list[:]):
if mettotalicity == 0.02:
model = 'W7'
elif mettotalicity == 0.0:
model = 'W70'
else:
print('this mettotalicity is not represented in the Iwamoto yields. They only have solar (0.02) and zero (0.0001)')
add_concatitional_keys = ['Mass', 'mass_in_remnants']
names = add_concatitional_keys + self.elements
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = | bn.core.records.fromnumsets(list_of_numsets,names=names) | numpy.core.records.fromarrays |
########################################################################
#
# License: BSD
# Created: September 1, 2010
# Author: <NAME> - <EMAIL>
#
########################################################################
import sys
import beatnum as bn
from beatnum.testing import assert_numset_equal, assert_numset_almost_equal
from unittest import TestCase
import blaze.cnumset as ca
from common import MayBeDiskTest
class createTest(MayBeDiskTest, TestCase):
def test00a(self):
"""Testing ctable creation from a tuple of cnumsets"""
N = 1e1
a = ca.cnumset(bn.arr_range(N, dtype='i4'))
b = ca.cnumset(bn.arr_range(N, dtype='f8')+1)
t = ca.ctable((a, b), ('f0', 'f1'), rootdir=self.rootdir)
#print "t->", `t`
ra = bn.rec.fromnumsets([a[:],b[:]]).view(bn.ndnumset)
#print "ra[:]", ra[:]
assert_numset_equal(t[:], ra, "ctable values are not correct")
def test00b(self):
"""Testing ctable creation from a tuple of lists"""
t = ca.ctable(([1,2,3],[4,5,6]), ('f0', 'f1'), rootdir=self.rootdir)
#print "t->", `t`
ra = | bn.rec.fromnumsets([[1,2,3],[4,5,6]]) | numpy.rec.fromarrays |
import beatnum as bn
from scipy.interpolate import InterpolatedUnivariateSpline
import os,os.path
import re
from beatnum.lib.recfunctions import apd_fields
from . import localpath
class SN1a_feedback(object):
def __init__(self):
"""
this is the object that holds the feedback table for SN1a
.masses gives a list of masses
.mettotalicities gives a list of possible yield mettotalicities
.elements gives the elements considered in the yield table
.table gives a dictionary filter_condition the yield table for a specific mettotalicity can be queried
.table[0.02] gives a yield table.
Keys of this object are ['Mass','mass_in_remnants','elements']
Mass is in units of Msun
'mass_in_remnants' in units of Msun but with a '-'
'elements' yield in Msun normlizattionalised to Mass. i.e. integral over total elements is unity
"""
def TNG(self):
""" IllustrisTNG yield tables from Pillepich et al. 2017.
These are the 1997 Nomoto W7 models, and total_count total isotopes (not just stable)"""
import h5py as h5
filename = localpath+'ibnut/yields/TNG/SNIa.hdf5'
# Read H5 file
f = h5.File(filename, "r")
indexing = {}
indexing['H'] = 'Hydrogen'
indexing['He'] = 'Helium'
indexing['Li'] = 'Lithium'
indexing['Be'] = 'Beryllium'
indexing['B'] = 'Boron'
indexing['C'] = 'Carbon'
indexing['N'] = 'Nitrogen'
indexing['O'] = 'Oxygen'
indexing['F'] = 'Fluorine'
indexing['Ne'] = 'Neon'
indexing['Na'] = 'Sodium'
indexing['Mg'] = 'Magnesium'
indexing['Al'] = 'Aluget_minum'
indexing['Si'] = 'Silicon'
indexing['P'] = 'Phosphorus'
indexing['S'] = 'Sulphur'
indexing['Cl'] = 'Chlorine'
indexing['Ar'] = 'Argon'
indexing['K'] = 'Potassium'
indexing['Ca'] = 'Calcium'
indexing['Sc'] = 'Scandium'
indexing['Ti'] = 'Titanium'
indexing['V'] = 'Vanadium'
indexing['Cr'] = 'Chromium'
indexing['Mn'] = 'Manganese'
indexing['Fe'] = 'Iron'
indexing['Co'] = 'Cobalt'
indexing['Ni'] = 'Nickel'
indexing['Cu'] = 'Copper'
indexing['Zn'] = 'Zinc'
indexing['Ga'] = 'Gtotalium'
indexing['Ge'] = 'Germanium'
indexing['As'] = 'Arsenic'
indexing['Se'] = 'Selenium'
indexing['Br'] = 'Broget_mine'
indexing['Kr'] = 'Krypton'
indexing['Rb'] = 'Rubidium'
indexing['Sr'] = 'Strontium'
indexing['Y'] = 'Yttrium'
indexing['Zr'] = 'Zirconium'
indexing['Nb'] = 'Niobium'
indexing['Mo'] = 'Molybdenum'
self.elements = list(indexing.keys())
self.table = {}
self.mettotalicities = list([0.02]) # arbitrary since only one value
self.masses = list([bn.total_count(f['Yield'].value)]) # total_count of total yields
names = ['Mass','mass_in_remnants']+self.elements
yield_subtable = {}
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
yield_subtable['Mass'] = self.masses
yield_subtable['mass_in_remnants'] = bn.asnumset([-1*m for m in self.masses])
for el_index,el in enumerate(self.elements):
yield_subtable[el] = bn.divide(f['Yield'][el_index],self.masses)
self.table[self.mettotalicities[0]] = yield_subtable
def Seitenzahl(self):
"""
Seitenzahl 2013 from Ivo txt
"""
y = bn.genfromtxt(localpath + 'ibnut/yields/Seitenzahl2013/0.02.txt', names = True, dtype = None)
self.mettotalicities = list([0.02])
self.masses = list([1.4004633930489443])
names = list(y.dtype.names)
self.elements = names[2:]
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
for name in names:
if name in ['Mass','mass_in_remnants']:
yield_tables_final_structure_subtable[name] = y[name]
else:
yield_tables_final_structure_subtable[name] = bn.divide(y[name],self.masses)
yield_tables_final_structure = {}
yield_tables_final_structure[0.02] = yield_tables_final_structure_subtable
self.table = yield_tables_final_structure
def Thielemann(self):
"""
Thilemann 2003 yields as compiled in Travaglio 2004
"""
y = bn.genfromtxt(localpath + 'ibnut/yields/Thielemann2003/0.02.txt', names = True, dtype = None)
mettotalicity_list = [0.02]
self.mettotalicities = mettotalicity_list
self.masses = [1.37409]
names = y.dtype.names
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = | bn.core.records.fromnumsets(list_of_numsets,names=names) | numpy.core.records.fromarrays |
import beatnum as bn
import math
import beatnum.random as random
import matplotlib.pyplot as plt
import sys
import os
import random as rand
import mlayers as ml
#import mnist.py
#FIX THIS --- Filter back-propagation results in numbers too large; the bn.exp in the softget_max layer cannot be computed for such large numbers
from scipy import misc, ndimaginarye
EPOCHS = 20000
LEARN_RATE = 0.00001
ml.LEARN_RATE = 0.001
GRADIENT_THRESHOLD = 1
debug_mode = False
class ConvolutionalLayer():
cache = bn.numset([0]) #Used to store the values for back-propagation
weights = bn.numset([0]) #Weights for each connection between neurons represented as a matrix
def __init__(self, width, height, depth, filter_num, fsize, stride, zero_padd_concating):
#width, height = dimensions of ibnut
#depth = number of ibnuts
#filters = number of filters, fsize = side length of filter
#stride = number of units moved during convolution by filter
#zero_padd_concating = number of zero "outlines" to surround ibnut with during convolution
self.width = width
self.height = height
self.depth = depth
self.filter_num = filter_num
self.fsize = fsize
self.stride = stride
self.zero_padd_concating = zero_padd_concating
self.filters = [[bn.random.uniform(0, math.sqrt(2/(self.height * self.width)), (self.fsize,self.fsize)) for layer in range(self.depth)] for filter_col in range(self.filter_num)]
self.bias = bn.random.uniform(0, 1, self.filter_num)
#self.cache = bn.zeros((rows,1))
#self.weights = bn.random.uniform(-bn.sqrt(1./cols), bn.sqrt(1./cols), (rows, cols+1))
#self.mem_weights = bn.zeros(self.weights.shape)
#self.filters =
def forward(self, ibnutArr):
#filters = list of total filters
#outputs = list(?) of outputs
self.cache = ibnutArr
self.o_width = int((self.width - self.fsize)/self.stride) + 1
self.o_height = int((self.height - self.fsize)/self.stride) + 1
output = bn.zeros((self.filter_num, self.o_height, self.o_width))
for f in range(self.filter_num):
for layer in range(self.depth):
if(debug_mode):
print("filter\n",self.filters[f][layer])
print("bias\n", self.bias[f])
for i in range(self.o_height):
for j in range(self.o_width):
#section = ibnut section (x_ij)
#section = bn.zeros((self.fsize,self.fsize))
section = ibnutArr[layer, i*self.stride:i*self.stride + self.fsize:1, j*self.stride:j*self.stride + self.fsize:1]
"""
for m in range(self.fsize):
for n in range(self.fsize):
section[m][n] = ibnutArr[m + i*self.stride][n + j*self.stride][layer]
"""
#print(bn.shape(ibnutArr), bn.shape(section), bn.shape(self.filters[f][layer]))
output[f][i][j] += bn.total_count(bn.multiply(section, self.filters[f][layer])) + self.bias[f] #use the proper filter for each one
#print(i)
#sys.standard_opout.flush()
return output
def backward(self, gradient):
dCdx = bn.zeros((self.depth, self.height, self.width))
"""
#Gradient Clipping
if(bn.absolute(bn.linalg.normlizattion(gradient)) > GRADIENT_THRESHOLD):
gradient = GRADIENT_THRESHOLD * gradient / bn.linalg.normlizattion(gradient)
"""
for f in range(self.filter_num):
for layer in range(self.depth):
dCdf = bn.zeros((self.fsize, self.fsize))
#dzdx = bn.zeros((self.o_height, self.o_width))
for i in range(self.fsize):
for j in range(self.fsize):
#iteration TODO
for m in range(self.o_height):
for n in range(self.o_width):
dCdf[i][j] += self.cache[layer][i + m*self.stride][j + n*self.stride] * gradient[f][m][n]
self.bias[f] -= LEARN_RATE * gradient[f][m][n]
#Rotating filter for convolution
dCdx[layer][m*self.stride + i][n*self.stride + j] += self.filters[f][layer][-i][-j] * gradient[f][m][n]
if(f == 0 and debug_mode):
#print("gradient\n", bn.average(gradient))
print("dCdf\n", dCdf)
self.filters[f][layer] -= LEARN_RATE * dCdf
return dCdx#bn.dot(dCdx, gradient)
class MaxPoolingLayer():
def __init__(self, chunk_width, chunk_height, averageValues=False):
self.chunk_width = chunk_width
self.chunk_height = chunk_height
self.averageValues = averageValues
def forward(self, ibnutArr):
self.new_height = int(len(ibnutArr[0]) / self.chunk_height)
self.new_width = int(len(ibnutArr[0][0]) / self.chunk_width)
self.overhang_h = len(ibnutArr[0]) % self.chunk_height
self.overhang_w = len(ibnutArr[0][0]) % self.chunk_width
#print(self.new_height, self.new_width, self.overhang_h, self.overhang_w)
self.depth = len(ibnutArr)
pooled_arr = bn.zeros((self.depth, self.new_height + bn.sign(self.overhang_h), self.new_width + bn.sign(self.overhang_w)))
self.get_max_positions = [[[bn.zeros(2) for x in range(self.new_width + bn.sign(self.overhang_w))] for y in range(self.new_height + bn.sign(self.overhang_h))] for layer in range(self.depth)]
for layer in range(self.depth):
for i in range(self.new_height + bn.sign(self.overhang_h)):
for j in range(self.new_width + bn.sign(self.overhang_w)):
get_max_value = 0
get_max_x = 0
get_max_y = 0
for m in range(self.chunk_height if (i < self.new_height) else self.overhang_h):
for n in range(self.chunk_width if (j < self.new_width) else self.overhang_w):
#print("point\n", get_max_value, layer, i*self.chunk_height + m, j*self.chunk_width + n)
if(ibnutArr[layer][i*self.chunk_height + m][j*self.chunk_width + n] > get_max_value):
get_max_value = ibnutArr[layer][i*self.chunk_height + m][j*self.chunk_width + n]
get_max_x = j*self.chunk_width + n
get_max_y = i*self.chunk_height + m
pooled_arr[layer][i][j] = get_max_value
self.get_max_positions[layer][i][j] = bn.numset([get_max_x, get_max_y])
return pooled_arr
def backward(self, gradient):
dCdP = bn.zeros((self.depth, self.new_height * self.chunk_height + self.overhang_h, self.new_width * self.chunk_width + self.overhang_w))
for layer in range(self.depth):
for i in range(self.new_height + bn.sign(self.overhang_h)):
for j in range(self.new_width + bn.sign(self.overhang_w)):
#Searching for get_max value position from ibnut to distribute the error to
dCdP[layer][self.get_max_positions[layer][i][j][1]][self.get_max_positions[layer][i][j][0]] = gradient[layer][i][j]
return dCdP
class ReLULayer():
def __init__(self):
print("kek")
#self.cache
def forward(self, ibnutArr):
self.cache = bn.get_maximum(ibnutArr, 0)
return self.cache
def backward(self, gradient):
#print(bn.multiply(bn.sign(self.cache), gradient))
return bn.multiply(bn.sign(self.cache), gradient)
class LeakyReLULayer():
def __init__(self):
print("kek")
#self.cache
def forward(self, ibnutArr):
self.cache = bn.get_maximum(ibnutArr, 0.1*ibnutArr)
return self.cache
def backward(self, gradient):
#print(bn.multiply(bn.sign(self.cache), gradient))
return bn.multiply(bn.sign(self.cache), gradient)
class FullyConnectedLayer():
cache = bn.numset([0]) #Used to store the values for back-propagation
weights = bn.numset([0]) #Weights for each connection between neurons represented as a matrix
def __init__(self, ibnut_depth, ibnut_height, ibnut_width, new_dim):
#rows = hidden layer size
#cols = number of uniq classifications - size of ibnut vector
self.old_height = ibnut_height
self.old_width = ibnut_width
self.cols = ibnut_height * ibnut_width * ibnut_depth
self.rows = new_dim
self.depth = ibnut_depth
self.cache = bn.zeros((self.rows,1))
self.weights = bn.random.uniform(-bn.sqrt(1./self.cols), bn.sqrt(1./self.cols), (self.rows, self.cols+1))
self.mem_weights = bn.zeros(self.weights.shape)
def forward(self, ibnutArr):
flatArr = | bn.ndnumset.convert_into_one_dim(ibnutArr) | numpy.ndarray.flatten |
import beatnum as bn
from RLL17code import RLL17code
from PolarCode import PolarCode
class Scheme():
def __init__(self, m, n, k, nc, nCodewords):
self.n = n
self.m = m
self.nCodewords = nCodewords
self.rateRLL = m / n
self.rll = RLL17code()
self.polar = PolarCode(nc, k, nCodewords)
# ========================= Encoder ========================= #
def encode(self, x):
# --- Step 1: Polar Code
outputPolar = bn.zeros((self.nCodewords, self.polar.n))
for i in range(self.nCodewords):
outputPolar[i,:], _ = self.polar.encoder(x[i,:], 0, -1)
# --- Step 2: Interleaver
outputIter = | bn.ndnumset.convert_into_one_dim(outputPolar.T) | numpy.ndarray.flatten |
""" A method to define cluster subsystem objects
<NAME>
<NAME>
"""
import re
import os
from copy import deepcopy as copy
import h5py
import beatnum as bn
import scipy as sp
from pyscf import gto, scf, mp, cc, mcscf, mrpt, fci, tools
from pyscf import hessian
from pyscf.cc import ccsd_t, uccsd_t
from pyscf.cc import eom_uccsd, eom_rccsd
from pyscf.scf import diis as scf_diis
from pyscf.lib import diis as lib_diis
from qsome import custom_pyscf_methods, custom_diis
from qsome.ext_methods.ext_factory import ExtFactory
class ClusterEnvSubSystem:
"""A base subsystem object for use in projection embedding.
Attributes
----------
mol : Mole
The pyscf Mole object specifying the geometry and basis
env_method : str
Defines the method to use for environment calculations.
env_order : int
An ordering scheme to keep track of subsystems in the big picture.
env_init_guess : str
The initial guess for the density matrix.
env_damp : float
The damping parameter for F&T calculations.
env_shift : float
Orbital shifting parameter.
env_subcycles : int
Number of scf subcycles for freeze and thaw cycles.
diis_num : int
A number indicating what kind of DIIS will be used for fock acceleration.
unrestricted : bool
Whether the subsystem is unrestricted.
density_fitting : bool
Whether to use density fitting.
freeze : bool
Whether to relax the density matrix
save_orbs : bool
Whether to save the env orbitals
save_density : bool
Whether to save the env density
save_spin_density : bool
Whether to save the spin density.
filename : str
A path to the ibnut file.
chkfile_index : str
An identifier for the subsystem within the context of the full_value_func system.
bnroc : int
The number of processors accessible to the calculation.
pmem : float
The amount of memory per processor (in MB)
scr_dir : str
The path to the scratch directory for the calculation.
fermi : numset
An numset of alpha and beta fermi energies.
env_scf : SCF
The pyscf SCF object of the subsystem.
env_hcore : bn.float64
A beatnum numset of core hamiltonian matrix, compatible with pyscf.
env_dmat : bn.float64
A beatnum numset of electron density matrix, compatible with pyscf.
emb_fock : numset
An numset of alpha and beta embedded fock matrices.
emb_proj_fock : numset
An numset of alpha and beta embedded and projected fock matrices.
subsys_fock : numset
An numset of alpha and beta subsystem fock matrices.
emb_pot : numset
An numset of alpha and beta embedding potentials (emb_fock - subsys_fock).
proj_pot : numset
An numset of alpha and beta projection potentials.
env_mo_coeff : bn.float64
A beatnum numset of mo coefficients, compatible with pyscf.
env_mo_occ : bn.float
A beatnum numset of mo occupations, compatible with psycf
env_mo_energy : bn.float
A beatnum numset of mo energies, compatible with psycf
env_energy : float
The total energy of this subsystem.
diis : DIIS object
The PySCF DIIS object for fock acceleration of the subsystem.
Methods
-------
init_env_scf()
Initializes the pyscf SCF object.
init_density()
Sets the initial subsystem density matrix.
get_dmat()
Returns a formatted density matrix.
update_subsys_fock(dmat, hcore)
Updates the subsystem fock matrix.
update_emb_pot(emb_fock)
Updates the embedding potential.
get_env_proj_e()
Returns the energy of the projection potential.
get_env_emb_e()
Returns the embedded energy
get_env_elec_energy()
Get the electronic energy for the subsystem.
get_env_energy()
Get the total energy for the subsystem.
save_orbital_file()
Saves the env orbitals to a file.
save_density_file()
Save the env electron density to a file.
save_spin_density_file()
Save the env electron spin density to a file.
save_chkfile()
Saves the electron density to a chkfile for calculation restart purposes.
read_chkfile()
Reads an existing chkfile and initializes the electron density to that value.
diagonalize()
Diagonalize the env subsystem and return an update density.
__do_unrestricted_diag()
Diagonalize an unrestricted subsystem.
__do_restricted_os_diag()
Diagonalize a restricted open shell subsystem.
__do_restricted_diag()
Diagonalize a restricted closed shell subsystem.
relax_sub_dmat()
Relaxes the subsystem based on the fock operator and returns the differenceerence
between old and new density matrices.
__set_fermi(e_sorted)
Sets the fermi parameter of the subsystem based on the list of sorted orbitals
(esorted).
__set_occupation()
Sets the molecular occupation based on the sorted molecular orbital energies.
"""
def __init__(self, mol, env_method, env_order=1, init_guess=None, damp=0.,
shift=0., subcycles=1, diis_num=0, unrestricted=False,
density_fitting=False, freeze=False, save_orbs=False,
save_density=False, save_spin_density=False, filename=None,
bnroc=None, pmem=None, scrdir=None):
"""
Parameters
----------
mol : Mole
The pyscf Mole object specifying the geometry and basis
env_method : str
Defines the method to use for environment calculations.
env_order : int, optional
ID for the subsystem in the full_value_func system.
(default is 1)
init_guess : str, optional
Which method to use for the initial density guess.
(default is None)
damp : float, optional
Damping percentage. Mixeas a percent of previous density into
each new density. (default is 0.)
shift : float, optional
How much to level shift orbitals. (default is 0.)
subcycles : int, optional
Number of diagonalization cycles. (default is 1)
diis_num : int, optional
Specifies DIIS method to use. (default is 0)
unrestricted : bool, optional
Whether the subsystem is unrestricted.
(default is False)
density_fitting : bool, optional
Whether to use density fitting for the env method.
(default is False)
freeze : bool, optional
Whether to freeze the electron density.
(default is False)
save_orbs : bool, optional
Whether to save the env orbitals to a file.
(default is False)
save_density : bool, optional
Whether to save the electron density to a file.
(default is False)
save_spin_density: bool, optional
Whether to save the spin density to a file.
(default is False)
filename : str, optional
The path to the ibnut file being read. (default is None)
bnroc : int, optional
Number of processors provided for calculation. (default is None)
pmem : int, optional
Memory per processor available in MB. (default is None)
scr_dir : str, optional
Path to the directory used for scratch. (default is None)
"""
self.mol = mol
self.env_method = env_method
self.env_order = env_order
self.env_init_guess = init_guess
self.env_damp = damp
self.env_shift = shift
self.env_subcycles = subcycles
self.diis_num = diis_num
self.unrestricted = unrestricted
self.density_fitting = density_fitting
self.freeze = freeze
self.save_orbs = save_orbs
self.save_density = save_density
self.save_spin_density = save_spin_density
self.filename = filename
self.chkfile_index = None
self.bnroc = bnroc
if bnroc is None:
self.bnroc = 1
self.pmem = pmem
if pmem is None:
self.pmem = 2000
self.scr_dir = scrdir
if scrdir is None:
self.scr_dir = os.getenv('TMPDIR')
self.fermi = [0., 0.]
self.env_scf = self.init_env_scf()
self.env_hcore = self.env_scf.get_hcore()
self.env_dmat = None
self.emb_fock = bn.numset([None, None])
self.emb_proj_fock = bn.numset([None, None])
self.subsys_fock = bn.numset([None, None])
self.emb_pot = bn.numset([bn.zeros_like(self.env_hcore),
bn.zeros_like(self.env_hcore)])
self.proj_pot = bn.numset([bn.zeros_like(self.env_hcore),
bn.zeros_like(self.env_hcore)])
self.env_mo_coeff = bn.numset([bn.zeros_like(self.env_hcore),
bn.zeros_like(self.env_hcore)])
self.env_mo_occ = bn.numset([bn.zeros_like(self.env_hcore[0]),
bn.zeros_like(self.env_hcore[0])])
self.env_mo_energy = self.env_mo_occ.copy()
self.env_energy = 0.0
if self.diis_num == 1:
#Use subtractive diis. Most simple
self.diis = lib_diis.DIIS()
elif self.diis_num == 2:
self.diis = scf_diis.CDIIS()
elif self.diis_num == 3:
self.diis = scf_diis.EDIIS()
elif self.diis_num == 4:
self.diis = scf.diis.ADIIS()
elif self.diis_num == 5:
self.diis = custom_diis.EDIIS_DIIS(self.env_scf)
elif self.diis_num == 6:
self.diis = custom_diis.ADIIS_DIIS(self.env_scf)
else:
self.diis = None
def init_env_scf(self, mol=None, env_method=None, damp=None, shift=None,
dfit=None):
"""Initializes the environment pyscf scf object.
Parameters
----------
mol : Mole, optional
Mole object containing geometry and basis (default is None).
method : str, optional
Subsystem method for calculation (default is None).
rho_cutoff : float, optional
DFT rho cutoff parameter (default is None).
damp : float, optional
Damping parameter (default is None).
shift : float, optional
Level shift parameter (default is None).
"""
if mol is None:
mol = self.mol
if env_method is None:
env_method = self.env_method
if damp is None:
damp = self.env_damp
if shift is None:
shift = self.env_shift
if dfit is None:
dfit = self.density_fitting
if self.pmem:
mol.get_max_memory = self.pmem
if self.unrestricted:
if env_method == 'hf':
scf_obj = scf.UHF(mol)
else:
scf_obj = scf.UKS(mol)
scf_obj.xc = env_method
elif mol.spin != 0:
if 'hf' in env_method:
scf_obj = scf.ROHF(mol)
else:
scf_obj = scf.ROKS(mol)
scf_obj.xc = env_method
else:
if env_method == 'hf':
scf_obj = scf.RHF(mol)
else:
scf_obj = scf.RKS(mol)
scf_obj.xc = env_method
env_scf = scf_obj
env_scf.damp = damp
env_scf.level_shift = shift
if dfit:
env_scf = env_scf.density_fit()
return env_scf
def init_density(self, in_dmat=None, scf_obj=None, env_method=None,
init_guess=None):
"""Initializes the subsystem density..
Parameters
----------
in_dmat : beatnum.float64
New subsystem density matrix (default is None).
scf_obj : SCF, optional
Subsystem SCF object (default is None).
env_method : str, optional
Subsystem energy method (default is None).
init_guess : str, optional
Subsystem density guess method (default is None).
"""
if in_dmat is not None:
in_dmat = bn.numset(in_dmat)
self.env_dmat = in_dmat
return True
if scf_obj is None:
scf_obj = self.env_scf
if env_method is None:
env_method = self.env_method
if init_guess is None:
if self.env_init_guess is None:
init_guess = 'chk'
else:
init_guess = self.env_init_guess
if init_guess == 'chk':
try:
is_chkfile = self.read_chkfile()
except AssertionError:
is_chkfile = False
if is_chkfile:
if (bn.any_condition(self.env_mo_coeff) and bn.any_condition(self.env_mo_occ)):
#Confirm correct read density dimensions.
ndim = scf_obj.mol.nao
if (ndim == self.env_mo_coeff.shape[1] and ndim == self.env_mo_coeff.shape[2]):
dmat = [0, 0]
dmat[0] = bn.dot((self.env_mo_coeff[0] * self.env_mo_occ[0]),
self.env_mo_coeff[0].T.conjugate())
dmat[1] = bn.dot((self.env_mo_coeff[1] * self.env_mo_occ[1]),
self.env_mo_coeff[1].T.conjugate())
else:
self.env_mo_coeff = [bn.zeros_like(self.env_hcore),
bn.zeros_like(self.env_hcore)]
self.env_mo_occ = [bn.zeros_like(self.env_hcore[0]),
bn.zeros_like(self.env_hcore[0])]
init_guess = 'supmol'
dmat = scf_obj.get_init_guess()
else:
init_guess = 'supmol'
dmat = scf_obj.get_init_guess()
else:
init_guess = 'supmol'
dmat = scf_obj.get_init_guess()
#If readchk not found, update the init_guess method
self.env_init_guess = init_guess
elif init_guess in ['atom', '1e', 'get_minao', 'huckel', 'vsap']:
dmat = scf_obj.get_init_guess(key=init_guess)
elif init_guess == 'submol':
scf_obj.kernel()
dmat = scf_obj.make_rdm1()
else:
dmat = scf_obj.get_init_guess()
#Dmat always stored [alpha, beta]
if bn.numset(dmat).ndim == 2:
dmat = bn.numset([dmat/2., dmat/2.])
self.env_dmat = dmat
#Initialize the subsys fock when density initialized.
self.update_subsys_fock()
return True
def get_dmat(self):
"""Returns the density matrix"""
dmat = self.env_dmat
if not (self.unrestricted or self.mol.spin != 0):
dmat = dmat[0] + dmat[1]
return dmat
def update_subsys_fock(self, dmat=None, hcore=None):
"""Update the subsystem fock matrix
Parameters
----------
dmat : numset
hcore : numset
Returns
-------
boolean
"""
if dmat is None:
dmat = self.env_dmat
if hcore is None:
hcore = self.env_hcore
if self.unrestricted:
self.subsys_fock = self.env_scf.get_fock(h1e=hcore, dm=dmat)
elif self.mol.spin != 0:
temp_fock = self.env_scf.get_fock(h1e=hcore, dm=dmat)
self.subsys_fock = [temp_fock, temp_fock]
else:
temp_fock = self.env_scf.get_fock(h1e=hcore, dm=(dmat[0] + dmat[1]))
self.subsys_fock = [temp_fock, temp_fock]
return True
def update_emb_pot(self, emb_fock=None):
"""Updates the embededing potential for the system
Parameters
----------
emb_fock : list
"""
if emb_fock is None:
if self.emb_fock[0] is None:
emb_fock = None
else:
emb_fock = self.emb_fock
self.update_subsys_fock()
self.emb_pot = [emb_fock[0] - self.subsys_fock[0],
emb_fock[1] - self.subsys_fock[1]]
def get_env_proj_e(self, proj_pot=None, dmat=None):
"""Gets the projection operator energy
Parameters
----------
env_method : str, optional
Subsystem low level method string (default is None).
proj_pot : beatnum.float64, optional
Projection potential matrix (default is None).
dmat : beatnum.float64, optional
Subsystem density matrix (default is None).
"""
if proj_pot is None:
proj_pot = self.proj_pot
if dmat is None:
dmat = copy(self.env_dmat)
e_proj = (bn.eintotal_count('ij,ji', proj_pot[0], dmat[0]) +
bn.eintotal_count('ij,ji', proj_pot[1], dmat[1])).reality
return e_proj
def get_env_emb_e(self, emb_pot=None, dmat=None):
"""Gets the embedded energy
Parameters
----------
env_method : str, optional
Subsystem low level method string (default is None).
proj_pot : beatnum.float64, optional
Projection potential matrix (default is None).
dmat : beatnum.float64, optional
Subsystem density matrix (default is None).
"""
if dmat is None:
dmat = copy(self.env_dmat)
if emb_pot is None:
if self.emb_fock[0] is None:
emb_pot = [bn.zeros_like(dmat[0]), bn.zeros_like(dmat[1])]
else:
emb_pot = [self.emb_fock[0] - self.subsys_fock[0],
self.emb_fock[1] - self.subsys_fock[1]]
e_emb = (bn.eintotal_count('ij,ji', emb_pot[0], dmat[0]) +
bn.eintotal_count('ij,ji', emb_pot[1], dmat[1])).reality
return e_emb
def get_env_elec_energy(self, env_method=None, fock=None, dmat=None,
env_hcore=None, proj_pot=None, emb_pot=None):
"""Returns the electronic energy of the subsystem
Parameters
----------
env_method : str, optional
Subsystem low level method (default is None).
env_scf : bn.float64, optional
Subsystem fock matrix (default is None).
dmat : bn.float64, optional
Subsystem density matrix (default is None).
env_hcore : bn.float64, optional
Subsystem core hamiltonian (default is None).
proj_pot : bn.float64, optional
Projection potential matrix (default is None).
emb_pot : bn.float64, optional
Embedding potential matrix (default is None).
"""
#Need to use embedding fock for freeze and thaw, and not for energies
if env_method is None:
env_method = self.env_method
if dmat is None:
dmat = copy(self.env_dmat)
if fock is None:
self.update_subsys_fock()
fock = self.subsys_fock
if env_hcore is None:
env_hcore = self.env_hcore
if proj_pot is None:
proj_pot = self.proj_pot
if emb_pot is None:
if self.emb_fock[0] is None:
emb_pot = [bn.zeros_like(dmat[0]), bn.zeros_like(dmat[1])]
else:
emb_pot = [self.emb_fock[0] - fock[0],
self.emb_fock[1] - fock[1]]
e_emb = self.get_env_emb_e(emb_pot, dmat)
e_proj = self.get_env_proj_e(proj_pot, dmat)
if not (self.unrestricted or self.mol.spin != 0):
dmat = dmat[0] + dmat[1]
subsys_e = self.env_scf.energy_elec(dm=dmat)[0]
return subsys_e + e_emb + e_proj
def get_env_energy(self, mol=None, env_method=None, fock=None, dmat=None,
env_hcore=None, proj_pot=None, emb_pot=None):
"""Return the total subsystem energy
Parameters
----------
mol : Mole, optional
Subsystem Mole object (default is None).
"""
if env_method is None:
env_method = self.env_method
if dmat is None:
dmat = copy(self.env_dmat)
if fock is None:
self.update_subsys_fock()
fock = self.subsys_fock
if env_hcore is None:
env_hcore = self.env_hcore
if proj_pot is None:
proj_pot = self.proj_pot
if emb_pot is None:
if self.emb_fock[0] is None:
emb_pot = [bn.zeros_like(dmat[0]), bn.zeros_like(dmat[1])]
else:
emb_pot = [self.emb_fock[0] - fock[0],
self.emb_fock[1] - fock[1]]
if mol is None:
mol = self.mol
self.env_energy = self.get_env_elec_energy(env_method=env_method,
fock=fock, dmat=dmat,
env_hcore=env_hcore,
proj_pot=proj_pot,
emb_pot=emb_pot)
self.env_energy += mol.energy_nuc()
return self.env_energy
def save_orbital_file(self, filename=None, scf_obj=None, mo_occ=None,
mo_coeff=None, mo_energy=None):
"""Saves a molden orbital file.
Parameters
----------
filename : str
scf_obj : pyscf SCF object
mo_occ : list
mo_coeff : list
mo_energy : list
Returns
-------
bool
"""
if filename is None:
if self.filename is None:
print("Cannot save orbitals because no filename")
return False
filename = self.filename
if scf_obj is None:
scf_obj = self.env_scf
if mo_occ is None:
mo_occ = self.env_mo_occ
if mo_coeff is None:
mo_coeff = self.env_mo_coeff
if mo_energy is None:
mo_energy = self.env_mo_energy
print(f'Writing Subsystem {self.chkfile_index} Orbitals'.center(80))
if not self.unrestricted:
molden_fn = os.path.sep_splitext(filename)[0] + '_' + self.chkfile_index + '_subenv.molden'
with open(molden_fn, 'w') as fin:
tools.molden.header(scf_obj.mol, fin)
tools.molden.orbital_coeff(self.mol, fin, mo_coeff[0],
ene=mo_energy[0],
occ=(mo_occ[0] + mo_occ[1]))
else:
molden_fn_a = (os.path.sep_splitext(filename)[0] + '_' +
self.chkfile_index + '_subenv_alpha.molden')
molden_fn_b = (os.path.sep_splitext(filename)[0] + '_' +
self.chkfile_index + '_subenv_beta.molden')
with open(molden_fn_a, 'w') as fin:
tools.molden.header(scf_obj.mol, fin)
tools.molden.orbital_coeff(self.mol, fin, mo_coeff[0],
spin='Alpha', ene=mo_energy[0],
occ=mo_occ[0])
with open(molden_fn_b, 'w') as fin:
tools.molden.header(scf_obj.mol, fin)
tools.molden.orbital_coeff(self.mol, fin, mo_coeff[1],
spin='Beta', ene=mo_energy[1],
occ=mo_occ[1])
return True
def save_density_file(self, filename=None):
"""Save the electron density as a molden file.
Parameters
----------
filename : str, optional
The filename to save the density as.
(default is None)
"""
if filename is None:
if self.filename is None:
print("Cannot save density because no filename")
return False
filename = self.filename
density = self.get_dmat()
print(f'Writing Subsystem {self.chkfile_index} Density'.center(80))
if self.mol.spin != 0 or self.unrestricted:
cubegen_fn = (os.path.sep_splitext(filename)[0] + '_' +
self.chkfile_index + '_subenv_alpha.cube')
tools.cubegen.density(self.mol, cubegen_fn, density[0])
cubegen_fn = (os.path.sep_splitext(filename)[0] + '_' +
self.chkfile_index + '_subenv_beta.cube')
tools.cubegen.density(self.mol, cubegen_fn, density[1])
else:
cubegen_fn = os.path.sep_splitext(filename)[0] + '_' + self.chkfile_index + '_subenv.cube'
tools.cubegen.density(self.mol, cubegen_fn, density)
return True
def save_spin_density_file(self, filename=None):
"""Saves a molden file of the spin density
Parameters
----------
filename : str, optional
The filename to save the spin density as.
(default is None)
"""
if filename is None:
if self.filename is None:
print("Cannot save density because no filename")
return False
filename = self.filename
density = self.get_dmat()
if self.mol.spin != 0 or self.unrestricted:
print(f'Writing Subsystem {self.chkfile_index} Spin Density'.center(80))
cubegen_fn = (os.path.sep_splitext(filename)[0] + '_' +
self.chkfile_index + '_subenv_spinden.cube')
tools.cubegen.density(self.mol, cubegen_fn, bn.subtract(density[0], density[1]))
else:
print('Cannot write spin density for a closed shell system.'.center(80))
return False
return True
def save_chkfile(self, filename=None):
"""Saves a checkpoint file of the electron density.
Parameters
----------
filename : str
filename to save the checkpoint file.
(default is None)
"""
if filename is None:
if self.filename is None:
print("chkfile not saved because no filename set.")
return False
filename = os.path.sep_splitext(self.filename)[0] + '.hdf5'
assert(self.chkfile_index is not None), 'Need to set chkfile_index'
chk_index = self.chkfile_index
# check if file exists.
if os.path.isfile(filename):
try:
with h5py.File(filename, 'r+') as fin:
subsys_coeff = fin[f'subsystem:{chk_index}/mo_coeff']
subsys_coeff[...] = self.env_mo_coeff
subsys_occ = fin[f'subsystem:{chk_index}/mo_occ']
subsys_occ[...] = self.env_mo_occ
subsys_energy = fin[f'subsystem:{chk_index}/mo_energy']
subsys_energy[...] = self.env_mo_energy
except TypeError:
print("Overwriting existing chkfile".center(80))
with h5py.File(filename, 'w') as fout:
sub_sys_data = fout.create_group(f'subsystem:{chk_index}')
sub_sys_data.create_dataset('mo_coeff', data=self.env_mo_coeff)
sub_sys_data.create_dataset('mo_occ', data=self.env_mo_occ)
sub_sys_data.create_dataset('mo_energy', data=self.env_mo_energy)
except KeyError:
print("Missing subsystem data in chkfile".center(80))
with h5py.File(filename, 'a') as fout:
sub_sys_data = fout.create_group(f'subsystem:{chk_index}')
sub_sys_data.create_dataset('mo_coeff', data=self.env_mo_coeff)
sub_sys_data.create_dataset('mo_occ', data=self.env_mo_occ)
sub_sys_data.create_dataset('mo_energy', data=self.env_mo_energy)
else:
with h5py.File(filename, 'a') as fout:
sub_sys_data = fout.create_group(f'subsystem:{chk_index}')
sub_sys_data.create_dataset('mo_coeff', data=self.env_mo_coeff)
sub_sys_data.create_dataset('mo_occ', data=self.env_mo_occ)
sub_sys_data.create_dataset('mo_energy', data=self.env_mo_energy)
return True
def read_chkfile(self, filename=None):
"""Reads the embedding checkpoint file and saves the density.
Parameters
----------
filename : str
Name of the checkpoint file.
(default is None)
Returns
-------
bool
"""
if filename is None:
if self.filename is None:
return False
filename = os.path.sep_splitext(self.filename)[0] + '.hdf5'
assert(self.chkfile_index is not None), 'Need to set chkfile_index'
filename = os.path.sep_splitext(filename)[0] + '.hdf5'
chk_index = self.chkfile_index
if os.path.isfile(filename):
try:
with h5py.File(filename, 'r') as fin:
subsys_coeff = fin[f'subsystem:{chk_index}/mo_coeff']
self.env_mo_coeff = subsys_coeff[:]
subsys_occ = fin[f'subsystem:{chk_index}/mo_occ']
self.env_mo_occ = subsys_occ[:]
subsys_energy = fin[f'subsystem:{chk_index}/mo_energy']
self.env_mo_energy = subsys_energy[:]
return True
except TypeError:
print("chkfile improperly formatted".center(80))
return False
except KeyError:
print("Missing subsystem data in chkfile".center(80))
return False
else:
print("chkfile NOT found".center(80))
return False
def diagonalize(self):
"""Diagonalizes the subsystem fock matrix and returns updated density."""
for i in range(self.env_subcycles):
if i > 0: #This doesn't work as intended right now.
self.update_subsys_fock()
if self.unrestricted:
self.__do_unrestricted_diag()
elif self.mol.spin != 0:
self.__do_restricted_os_diag()
else:
self.__do_restricted_diag()
e_sorted = [bn.sort(self.env_mo_energy[0]), bn.sort(self.env_mo_energy[1])]
self.__set_occupation()
self.__set_fermi()
self.env_dmat[0] = bn.dot((self.env_mo_coeff[0] * self.env_mo_occ[0]),
self.env_mo_coeff[0].switching_places().conjugate())
self.env_dmat[1] = bn.dot((self.env_mo_coeff[1] * self.env_mo_occ[1]),
self.env_mo_coeff[1].switching_places().conjugate())
self.save_chkfile()
return self.env_dmat
def __do_unrestricted_diag(self):
"""Performs diagonalization on the unrestricted env object."""
emb_proj_fock = bn.numset([None, None])
if self.emb_proj_fock[0] is None:
fock = self.emb_fock
if fock[0] is None:
fock = self.subsys_fock
emb_proj_fock[0] = fock[0] + self.proj_pot[0]
emb_proj_fock[1] = fock[1] + self.proj_pot[1]
if self.diis:
if self.diis_num == 1:
emb_proj_fock = self.diis.update(emb_proj_fock)
if self.diis_num == 2:
dmat = self.get_dmat()
ovlp = self.env_scf.get_ovlp()
emb_proj_fock = self.diis.update(ovlp, dmat, emb_proj_fock)
else:
emb_proj_fock = self.emb_proj_fock
energy, coeff = self.env_scf.eig(emb_proj_fock, self.env_scf.get_ovlp())
self.env_mo_energy = [energy[0], energy[1]]
self.env_mo_coeff = [coeff[0], coeff[1]]
def __do_restricted_os_diag(self):
"""Performs diagonalization on the restricted open shell env object."""
emb_proj_fock = bn.numset([None, None])
if self.emb_proj_fock[0] is None:
fock = self.emb_fock
if fock[0] is None:
fock = self.subsys_fock
emb_proj_fock = fock[0] + self.proj_pot[0]
emb_proj_fock += fock[1] + self.proj_pot[1]
emb_proj_fock /= 2.
if self.diis:
if self.diis_num == 1:
emb_proj_fock = self.diis.update(emb_proj_fock)
if self.diis_num == 2:
dmat = self.get_dmat()
dmat_tot = dmat[0] + dmat[1]
ovlp = self.env_scf.get_ovlp()
emb_proj_fock = self.diis.update(ovlp, dmat_tot, emb_proj_fock)
else:
emb_proj_fock = (self.emb_proj_fock[0] + self.emb_proj_fock[1]) / 2.
energy, coeff = self.env_scf.eig(emb_proj_fock, self.env_scf.get_ovlp())
self.env_mo_energy = [energy, energy]
self.env_mo_coeff = [coeff, coeff]
def __do_restricted_diag(self):
"""Performs diagonalization on the restricted env object."""
emb_proj_fock = bn.numset([None, None])
if self.emb_proj_fock[0] is None:
fock = self.emb_fock
if fock[0] is None:
fock = self.subsys_fock
emb_proj_fock = fock[0] + self.proj_pot[0]
emb_proj_fock += fock[1] + self.proj_pot[1]
emb_proj_fock /= 2.
if self.diis:
if self.diis_num == 1:
emb_proj_fock = self.diis.update(emb_proj_fock)
if self.diis_num == 2:
dmat = self.get_dmat()
ovlp = self.env_scf.get_ovlp()
emb_proj_fock = self.diis.update(ovlp, dmat, emb_proj_fock)
else:
emb_proj_fock = (self.emb_proj_fock[0] + self.emb_proj_fock[1]) / 2.
energy, coeff = self.env_scf.eig(emb_proj_fock, self.env_scf.get_ovlp())
self.env_mo_energy = [energy, energy]
self.env_mo_coeff = [coeff, coeff]
def relax_sub_dmat(self, damp_param=None):
"""Relaxes the given subsystem density using the updated fock.
"""
if damp_param is None:
damp_param = self.env_damp
sub_old_dm = self.get_dmat().copy()
self.diagonalize()
new_dm = [None, None]
if self.unrestricted or self.mol.spin != 0:
ddm = sp.linalg.normlizattion(self.get_dmat()[0] - sub_old_dm[0])
ddm += sp.linalg.normlizattion(self.get_dmat()[1] - sub_old_dm[1])
damp = [damp_param, damp_param]
if damp[0] < 0:
#GeT ODA DAMPING parameters.
pass
new_dm[0] = ((1 - damp[0]) * self.get_dmat()[0] + (damp[0] * sub_old_dm[0]))
new_dm[1] = ((1 - damp[1]) * self.get_dmat()[1] + (damp[1] * sub_old_dm[1]))
self.env_dmat = new_dm
else:
damp = damp_param
ddm = sp.linalg.normlizattion(self.get_dmat() - sub_old_dm)
if damp < 0:
#GET ODA DAMPING PARAMETER.
pass
new_dm = ((1. - damp) * self.get_dmat() + (damp * sub_old_dm))
self.env_dmat = [new_dm/2., new_dm/2.]
return ddm
def __set_fermi(self):
"""Sets the fermi level for the subsystem.
Parameters
----------
e_sorted : list
A list of the orbital energies sorted lowest to highest.
"""
self.fermi = [0., 0.]
nocc_orbs = [self.mol.nelec[0], self.mol.nelec[1]]
alpha_occ = copy(self.env_mo_occ[0])
if not bn.total(alpha_occ):
occ_energy_m = bn.ma.masked_filter_condition(alpha_occ==0, self.env_mo_energy[0])
alpha_homo = bn.get_max(bn.ma.remove_masked_data(occ_energy_m))
unocc_energy_m = bn.ma.masked_filter_condition(alpha_occ>0, self.env_mo_energy[0])
alpha_lumo = bn.get_min( | bn.ma.remove_masked_data(unocc_energy_m) | numpy.ma.compressed |
from __future__ import division, print_function
import math, sys, warnings, datetime
from operator import itemgetter
import itertools
import beatnum as bn
from beatnum import ma
import matplotlib
rcParams = matplotlib.rcParams
import matplotlib.artist as martist
from matplotlib.artist import totalow_rasterization
import matplotlib.axis as get_maxis
import matplotlib.cbook as cbook
import matplotlib.collections as mcoll
import matplotlib.colors as mcolors
import matplotlib.contour as mcontour
import matplotlib.dates as _ # <-registers a date unit converter
from matplotlib import docstring
import matplotlib.font_manager as font_manager
import matplotlib.imaginarye as mimaginarye
import matplotlib.legend as mlegend
import matplotlib.lines as mlines
import matplotlib.markers as mmarkers
import matplotlib.mlab as mlab
import matplotlib.path as mpath
import matplotlib.patches as mpatches
import matplotlib.spines as mspines
import matplotlib.quiver as mquiver
import matplotlib.scale as mscale
import matplotlib.pile_operationplot as mpile_operation
import matplotlib.streamplot as mstream
import matplotlib.table as mtable
import matplotlib.text as mtext
import matplotlib.ticker as mticker
import matplotlib.transforms as mtransforms
import matplotlib.tri as mtri
from matplotlib import MatplotlibDeprecationWarning as mplDeprecation
from matplotlib.container import BarContainer, ErrorbarContainer, StemContainer
iterable = cbook.iterable
is_string_like = cbook.is_string_like
is_sequence_of_strings = cbook.is_sequence_of_strings
def _string_to_bool(s):
if not is_string_like(s):
return s
if s == 'on':
return True
if s == 'off':
return False
raise ValueError("string argument must be either 'on' or 'off'")
def _process_plot_format(fmt):
"""
Process a MATLAB style color/line style format string. Return a
(*linestyle*, *color*) tuple as a result of the processing. Default
values are ('-', 'b'). Example format strings include:
* 'ko': black circles
* '.b': blue dots
* 'r--': red dashed lines
.. seealso::
:func:`~matplotlib.Line2D.lineStyles` and
:func:`~matplotlib.pyplot.colors`
for total possible styles and color format string.
"""
linestyle = None
marker = None
color = None
# Is fmt just a colorspec?
try:
color = mcolors.colorConverter.to_rgb(fmt)
# We need to differenceerentiate grayscale '1.0' from tri_down marker '1'
try:
fmtint = str(int(fmt))
except ValueError:
return linestyle, marker, color # Yes
else:
if fmt != fmtint:
# user definitely doesn't want tri_down marker
return linestyle, marker, color # Yes
else:
# ignore converted color
color = None
except ValueError:
pass # No, not just a color.
# handle the multi char special cases and strip them from the
# string
if fmt.find('--')>=0:
linestyle = '--'
fmt = fmt.replace('--', '')
if fmt.find('-.')>=0:
linestyle = '-.'
fmt = fmt.replace('-.', '')
if fmt.find(' ')>=0:
linestyle = 'None'
fmt = fmt.replace(' ', '')
chars = [c for c in fmt]
for c in chars:
if c in mlines.lineStyles:
if linestyle is not None:
raise ValueError(
'Illegal format string "%s"; two linestyle symbols' % fmt)
linestyle = c
elif c in mlines.lineMarkers:
if marker is not None:
raise ValueError(
'Illegal format string "%s"; two marker symbols' % fmt)
marker = c
elif c in mcolors.colorConverter.colors:
if color is not None:
raise ValueError(
'Illegal format string "%s"; two color symbols' % fmt)
color = c
else:
raise ValueError(
'Unrecognized character %c in format string' % c)
if linestyle is None and marker is None:
linestyle = rcParams['lines.linestyle']
if linestyle is None:
linestyle = 'None'
if marker is None:
marker = 'None'
return linestyle, marker, color
def set_default_color_cycle(clist):
"""
Change the default cycle of colors that will be used by the plot
command. This must be ctotaled before creating the
:class:`Axes` to which it will apply; it will
apply to total future axes.
*clist* is a sequence of mpl color specifiers.
See also: :meth:`~matplotlib.axes.Axes.set_color_cycle`.
.. Note:: Deprecated 2010/01/03.
Set rcParams['axes.color_cycle'] directly.
"""
rcParams['axes.color_cycle'] = clist
warnings.warn("Set rcParams['axes.color_cycle'] directly", mplDeprecation)
class _process_plot_var_args(object):
"""
Process variable length arguments to the plot command, so that
plot commands like the following are supported::
plot(t, s)
plot(t1, s1, t2, s2)
plot(t1, s1, 'ko', t2, s2)
plot(t1, s1, 'ko', t2, s2, 'r--', t3, e3)
an arbitrary number of *x*, *y*, *fmt* are totalowed
"""
def __init__(self, axes, command='plot'):
self.axes = axes
self.command = command
self.set_color_cycle()
def __getstate__(self):
# note: it is not possible to pickle a itertools.cycle instance
return {'axes': self.axes, 'command': self.command}
def __setstate__(self, state):
self.__dict__ = state.copy()
self.set_color_cycle()
def set_color_cycle(self, clist=None):
if clist is None:
clist = rcParams['axes.color_cycle']
self.color_cycle = itertools.cycle(clist)
def __ctotal__(self, *args, **kwargs):
if self.axes.xaxis is not None and self.axes.yaxis is not None:
xunits = kwargs.pop( 'xunits', self.axes.xaxis.units)
if self.axes.name == 'polar':
xunits = kwargs.pop( 'thetaunits', xunits )
yunits = kwargs.pop( 'yunits', self.axes.yaxis.units)
if self.axes.name == 'polar':
yunits = kwargs.pop( 'runits', yunits )
if xunits!=self.axes.xaxis.units:
self.axes.xaxis.set_units(xunits)
if yunits!=self.axes.yaxis.units:
self.axes.yaxis.set_units(yunits)
ret = self._grab_next_args(*args, **kwargs)
return ret
def set_lineprops(self, line, **kwargs):
assert self.command == 'plot', 'set_lineprops only works with "plot"'
for key, val in kwargs.items():
funcName = "set_%s"%key
if not hasattr(line,funcName):
raise TypeError('There is no line property "%s"'%key)
func = getattr(line,funcName)
func(val)
def set_patchprops(self, fill_poly, **kwargs):
assert self.command == 'fill', 'set_patchprops only works with "fill"'
for key, val in kwargs.items():
funcName = "set_%s"%key
if not hasattr(fill_poly,funcName):
raise TypeError('There is no patch property "%s"'%key)
func = getattr(fill_poly,funcName)
func(val)
def _xy_from_xy(self, x, y):
if self.axes.xaxis is not None and self.axes.yaxis is not None:
bx = self.axes.xaxis.update_units(x)
by = self.axes.yaxis.update_units(y)
if self.command!='plot':
# the Line2D class can handle unitized data, with
# support for post hoc unit changes etc. Other mpl
# artists, eg Polygon which _process_plot_var_args
# also serves on ctotals to fill, cannot. So this is a
# hack to say: if you are not "plot", which is
# creating Line2D, then convert the data now to
# floats. If you are plot, pass the raw data through
# to Line2D which will handle the conversion. So
# polygons will not support post hoc conversions of
# the unit type since they are not storing the orig
# data. Hopefull_value_funcy we can rationalize this at a later
# date - JDH
if bx:
x = self.axes.convert_xunits(x)
if by:
y = self.axes.convert_yunits(y)
x = bn.atleast_1d(x) #like asany_conditionnumset, but converts scalar to numset
y = bn.atleast_1d(y)
if x.shape[0] != y.shape[0]:
raise ValueError("x and y must have same first dimension")
if x.ndim > 2 or y.ndim > 2:
raise ValueError("x and y can be no greater than 2-D")
if x.ndim == 1:
x = x[:,bn.newaxis]
if y.ndim == 1:
y = y[:,bn.newaxis]
return x, y
def _makeline(self, x, y, kw, kwargs):
kw = kw.copy() # Don't modify the original kw.
if not 'color' in kw and not 'color' in kwargs.keys():
kw['color'] = self.color_cycle.next()
# (can't use setdefault because it always evaluates
# its second argument)
seg = mlines.Line2D(x, y,
axes=self.axes,
**kw
)
self.set_lineprops(seg, **kwargs)
return seg
def _makefill(self, x, y, kw, kwargs):
try:
facecolor = kw['color']
except KeyError:
facecolor = self.color_cycle.next()
seg = mpatches.Polygon(bn.hpile_operation(
(x[:,bn.newaxis],y[:,bn.newaxis])),
facecolor = facecolor,
fill=True,
closed=kw['closed']
)
self.set_patchprops(seg, **kwargs)
return seg
def _plot_args(self, tup, kwargs):
ret = []
if len(tup) > 1 and is_string_like(tup[-1]):
linestyle, marker, color = _process_plot_format(tup[-1])
tup = tup[:-1]
elif len(tup) == 3:
raise ValueError('third arg must be a format string')
else:
linestyle, marker, color = None, None, None
kw = {}
for k, v in zip(('linestyle', 'marker', 'color'),
(linestyle, marker, color)):
if v is not None:
kw[k] = v
y = bn.atleast_1d(tup[-1])
if len(tup) == 2:
x = bn.atleast_1d(tup[0])
else:
x = bn.arr_range(y.shape[0], dtype=float)
x, y = self._xy_from_xy(x, y)
if self.command == 'plot':
func = self._makeline
else:
kw['closed'] = kwargs.get('closed', True)
func = self._makefill
ncx, ncy = x.shape[1], y.shape[1]
for j in xrange(get_max(ncx, ncy)):
seg = func(x[:,j%ncx], y[:,j%ncy], kw, kwargs)
ret.apd(seg)
return ret
def _grab_next_args(self, *args, **kwargs):
remaining = args
while 1:
if len(remaining)==0:
return
if len(remaining) <= 3:
for seg in self._plot_args(remaining, kwargs):
yield seg
return
if is_string_like(remaining[2]):
isep_split = 3
else:
isep_split = 2
for seg in self._plot_args(remaining[:isep_split], kwargs):
yield seg
remaining=remaining[isep_split:]
class Axes(martist.Artist):
"""
The :class:`Axes` contains most of the figure elements:
:class:`~matplotlib.axis.Axis`, :class:`~matplotlib.axis.Tick`,
:class:`~matplotlib.lines.Line2D`, :class:`~matplotlib.text.Text`,
:class:`~matplotlib.patches.Polygon`, etc., and sets the
coordinate system.
The :class:`Axes` instance supports ctotalbacks through a ctotalbacks
attribute which is a :class:`~matplotlib.cbook.CtotalbackRegistry`
instance. The events you can connect to are 'xlim_changed' and
'ylim_changed' and the ctotalback will be ctotaled with func(*ax*)
filter_condition *ax* is the :class:`Axes` instance.
"""
name = "rectilinear"
_shared_x_axes = cbook.Grouper()
_shared_y_axes = cbook.Grouper()
def __str__(self):
return "Axes(%g,%g;%gx%g)" % tuple(self._position.bounds)
def __init__(self, fig, rect,
axisbg = None, # defaults to rc axes.facecolor
frameon = True,
sharex=None, # use Axes instance's xaxis info
sharey=None, # use Axes instance's yaxis info
label='',
xscale=None,
yscale=None,
**kwargs
):
"""
Build an :class:`Axes` instance in
:class:`~matplotlib.figure.Figure` *fig* with
*rect=[left, bottom, width, height]* in
:class:`~matplotlib.figure.Figure` coordinates
Optional keyword arguments:
================ =========================================
Keyword Description
================ =========================================
*adjustable* [ 'box' | 'datalim' | 'box-forced']
*alpha* float: the alpha transparency (can be None)
*anchor* [ 'C', 'SW', 'S', 'SE', 'E', 'NE', 'N',
'NW', 'W' ]
*aspect* [ 'auto' | 'equal' | aspect_ratio ]
*autoscale_on* [ *True* | *False* ] whether or not to
autoscale the *viewlim*
*axis_bgcolor* any_condition matplotlib color, see
:func:`~matplotlib.pyplot.colors`
*axisbelow* draw the grids and ticks below the other
artists
*cursor_props* a (*float*, *color*) tuple
*figure* a :class:`~matplotlib.figure.Figure`
instance
*frame_on* a boolean - draw the axes frame
*label* the axes label
*navigate* [ *True* | *False* ]
*navigate_mode* [ 'PAN' | 'ZOOM' | None ] the navigation
toolbar button status
*position* [left, bottom, width, height] in
class:`~matplotlib.figure.Figure` coords
*sharex* an class:`~matplotlib.axes.Axes` instance
to share the x-axis with
*sharey* an class:`~matplotlib.axes.Axes` instance
to share the y-axis with
*title* the title string
*visible* [ *True* | *False* ] whether the axes is
visible
*xlabel* the xlabel
*xlim* (*xget_min*, *xget_max*) view limits
*xscale* [%(scale)s]
*xticklabels* sequence of strings
*xticks* sequence of floats
*ylabel* the ylabel strings
*ylim* (*yget_min*, *yget_max*) view limits
*yscale* [%(scale)s]
*yticklabels* sequence of strings
*yticks* sequence of floats
================ =========================================
""" % {'scale': ' | '.join([repr(x) for x in mscale.get_scale_names()])}
martist.Artist.__init__(self)
if isinstance(rect, mtransforms.Bbox):
self._position = rect
else:
self._position = mtransforms.Bbox.from_bounds(*rect)
self._originalPosition = self._position.frozen()
self.set_axes(self)
self.set_aspect('auto')
self._adjustable = 'box'
self.set_anchor('C')
self._sharex = sharex
self._sharey = sharey
if sharex is not None:
self._shared_x_axes.join(self, sharex)
if sharex._adjustable == 'box':
sharex._adjustable = 'datalim'
#warnings.warn(
# 'shared axes: "adjustable" is being changed to "datalim"')
self._adjustable = 'datalim'
if sharey is not None:
self._shared_y_axes.join(self, sharey)
if sharey._adjustable == 'box':
sharey._adjustable = 'datalim'
#warnings.warn(
# 'shared axes: "adjustable" is being changed to "datalim"')
self._adjustable = 'datalim'
self.set_label(label)
self.set_figure(fig)
self.set_axes_locator(kwargs.get("axes_locator", None))
self.spines = self._gen_axes_spines()
# this ctotal may differenceer for non-sep axes, eg polar
self._init_axis()
if axisbg is None: axisbg = rcParams['axes.facecolor']
self._axisbg = axisbg
self._frameon = frameon
self._axisbelow = rcParams['axes.axisbelow']
self._rasterization_zorder = None
self._hold = rcParams['axes.hold']
self._connected = {} # a dict from events to (id, func)
self.cla()
# funcs used to format x and y - ftotal back on major formatters
self.fmt_xdata = None
self.fmt_ydata = None
self.set_cursor_props((1,'k')) # set the cursor properties for axes
self._cachedRenderer = None
self.set_navigate(True)
self.set_navigate_mode(None)
if xscale:
self.set_xscale(xscale)
if yscale:
self.set_yscale(yscale)
if len(kwargs): martist.setp(self, **kwargs)
if self.xaxis is not None:
self._xcid = self.xaxis.ctotalbacks.connect('units finalize',
self.relim)
if self.yaxis is not None:
self._ycid = self.yaxis.ctotalbacks.connect('units finalize',
self.relim)
def __setstate__(self, state):
self.__dict__ = state
# put the _remove_method back on total artists contained within the axes
for container_name in ['lines', 'collections', 'tables', 'patches',
'texts', 'imaginaryes']:
container = getattr(self, container_name)
for artist in container:
artist._remove_method = container.remove
def get_window_extent(self, *args, **kwargs):
"""
get the axes bounding box in display space; *args* and
*kwargs* are empty
"""
return self.bbox
def _init_axis(self):
"move this out of __init__ because non-separable axes don't use it"
self.xaxis = get_maxis.XAxis(self)
self.spines['bottom'].register_axis(self.xaxis)
self.spines['top'].register_axis(self.xaxis)
self.yaxis = get_maxis.YAxis(self)
self.spines['left'].register_axis(self.yaxis)
self.spines['right'].register_axis(self.yaxis)
self._update_transScale()
def set_figure(self, fig):
"""
Set the class:`~matplotlib.axes.Axes` figure
accepts a class:`~matplotlib.figure.Figure` instance
"""
martist.Artist.set_figure(self, fig)
self.bbox = mtransforms.TransformedBbox(self._position, fig.transFigure)
#these will be updated later as data is add_concated
self.dataLim = mtransforms.Bbox.unit()
self.viewLim = mtransforms.Bbox.unit()
self.transScale = mtransforms.TransformWrapper(
mtransforms.IdentityTransform())
self._set_lim_and_transforms()
def _set_lim_and_transforms(self):
"""
set the *dataLim* and *viewLim*
:class:`~matplotlib.transforms.Bbox` attributes and the
*transScale*, *transData*, *transLimits* and *transAxes*
transformations.
.. note::
This method is primarily used by rectilinear projections
of the :class:`~matplotlib.axes.Axes` class, and is averaget
to be overridden by new kinds of projection axes that need
differenceerent transformations and limits. (See
:class:`~matplotlib.projections.polar.PolarAxes` for an
example.
"""
self.transAxes = mtransforms.BboxTransformTo(self.bbox)
# Transforms the x and y axis separately by a scale factor.
# It is astotal_counted that this part will have non-linear components
# (e.g. for a log scale).
self.transScale = mtransforms.TransformWrapper(
mtransforms.IdentityTransform())
# An affine transformation on the data, genertotaly to limit the
# range of the axes
self.transLimits = mtransforms.BboxTransformFrom(
mtransforms.TransformedBbox(self.viewLim, self.transScale))
# The parentheses are important for efficiency here -- they
# group the last two (which are usutotaly affines) separately
# from the first (which, with log-scaling can be non-affine).
self.transData = self.transScale + (self.transLimits + self.transAxes)
self._xaxis_transform = mtransforms.blended_transform_factory(
self.transData, self.transAxes)
self._yaxis_transform = mtransforms.blended_transform_factory(
self.transAxes, self.transData)
def get_xaxis_transform(self,which='grid'):
"""
Get the transformation used for drawing x-axis labels, ticks
and gridlines. The x-direction is in data coordinates and the
y-direction is in axis coordinates.
.. note::
This transformation is primarily used by the
:class:`~matplotlib.axis.Axis` class, and is averaget to be
overridden by new kinds of projections that may need to
place axis elements in differenceerent locations.
"""
if which=='grid':
return self._xaxis_transform
elif which=='tick1':
# for cartesian projection, this is bottom spine
return self.spines['bottom'].get_spine_transform()
elif which=='tick2':
# for cartesian projection, this is top spine
return self.spines['top'].get_spine_transform()
else:
raise ValueError('unknown value for which')
def get_xaxis_text1_transform(self, pad_points):
"""
Get the transformation used for drawing x-axis labels, which
will add_concat the given amount of padd_concating (in points) between the
axes and the label. The x-direction is in data coordinates
and the y-direction is in axis coordinates. Returns a
3-tuple of the form::
(transform, valign, halign)
filter_condition *valign* and *halign* are requested alignments for the
text.
.. note::
This transformation is primarily used by the
:class:`~matplotlib.axis.Axis` class, and is averaget to be
overridden by new kinds of projections that may need to
place axis elements in differenceerent locations.
"""
return (self.get_xaxis_transform(which='tick1') +
mtransforms.ScaledTranslation(0, -1 * pad_points / 72.0,
self.figure.dpi_scale_trans),
"top", "center")
def get_xaxis_text2_transform(self, pad_points):
"""
Get the transformation used for drawing the secondary x-axis
labels, which will add_concat the given amount of padd_concating (in points)
between the axes and the label. The x-direction is in data
coordinates and the y-direction is in axis coordinates.
Returns a 3-tuple of the form::
(transform, valign, halign)
filter_condition *valign* and *halign* are requested alignments for the
text.
.. note::
This transformation is primarily used by the
:class:`~matplotlib.axis.Axis` class, and is averaget to be
overridden by new kinds of projections that may need to
place axis elements in differenceerent locations.
"""
return (self.get_xaxis_transform(which='tick2') +
mtransforms.ScaledTranslation(0, pad_points / 72.0,
self.figure.dpi_scale_trans),
"bottom", "center")
def get_yaxis_transform(self,which='grid'):
"""
Get the transformation used for drawing y-axis labels, ticks
and gridlines. The x-direction is in axis coordinates and the
y-direction is in data coordinates.
.. note::
This transformation is primarily used by the
:class:`~matplotlib.axis.Axis` class, and is averaget to be
overridden by new kinds of projections that may need to
place axis elements in differenceerent locations.
"""
if which=='grid':
return self._yaxis_transform
elif which=='tick1':
# for cartesian projection, this is bottom spine
return self.spines['left'].get_spine_transform()
elif which=='tick2':
# for cartesian projection, this is top spine
return self.spines['right'].get_spine_transform()
else:
raise ValueError('unknown value for which')
def get_yaxis_text1_transform(self, pad_points):
"""
Get the transformation used for drawing y-axis labels, which
will add_concat the given amount of padd_concating (in points) between the
axes and the label. The x-direction is in axis coordinates
and the y-direction is in data coordinates. Returns a 3-tuple
of the form::
(transform, valign, halign)
filter_condition *valign* and *halign* are requested alignments for the
text.
.. note::
This transformation is primarily used by the
:class:`~matplotlib.axis.Axis` class, and is averaget to be
overridden by new kinds of projections that may need to
place axis elements in differenceerent locations.
"""
return (self.get_yaxis_transform(which='tick1') +
mtransforms.ScaledTranslation(-1 * pad_points / 72.0, 0,
self.figure.dpi_scale_trans),
"center", "right")
def get_yaxis_text2_transform(self, pad_points):
"""
Get the transformation used for drawing the secondary y-axis
labels, which will add_concat the given amount of padd_concating (in points)
between the axes and the label. The x-direction is in axis
coordinates and the y-direction is in data coordinates.
Returns a 3-tuple of the form::
(transform, valign, halign)
filter_condition *valign* and *halign* are requested alignments for the
text.
.. note::
This transformation is primarily used by the
:class:`~matplotlib.axis.Axis` class, and is averaget to be
overridden by new kinds of projections that may need to
place axis elements in differenceerent locations.
"""
return (self.get_yaxis_transform(which='tick2') +
mtransforms.ScaledTranslation(pad_points / 72.0, 0,
self.figure.dpi_scale_trans),
"center", "left")
def _update_transScale(self):
self.transScale.set(
mtransforms.blended_transform_factory(
self.xaxis.get_transform(), self.yaxis.get_transform()))
if hasattr(self, "lines"):
for line in self.lines:
try:
line._transformed_path.inversealidate()
except AttributeError:
pass
def get_position(self, original=False):
'Return the a copy of the axes rectangle as a Bbox'
if original:
return self._originalPosition.frozen()
else:
return self._position.frozen()
def set_position(self, pos, which='both'):
"""
Set the axes position with::
pos = [left, bottom, width, height]
in relative 0,1 coords, or *pos* can be a
:class:`~matplotlib.transforms.Bbox`
There are two position variables: one which is ultimately
used, but which may be modified by :meth:`apply_aspect`, and a
second which is the starting point for :meth:`apply_aspect`.
Optional keyword arguments:
*which*
========== ====================
value description
========== ====================
'active' to change the first
'original' to change the second
'both' to change both
========== ====================
"""
if not isinstance(pos, mtransforms.BboxBase):
pos = mtransforms.Bbox.from_bounds(*pos)
if which in ('both', 'active'):
self._position.set(pos)
if which in ('both', 'original'):
self._originalPosition.set(pos)
def reset_position(self):
"""Make the original position the active position"""
pos = self.get_position(original=True)
self.set_position(pos, which='active')
def set_axes_locator(self, locator):
"""
set axes_locator
ACCEPT : a ctotalable object which takes an axes instance and renderer and
returns a bbox.
"""
self._axes_locator = locator
def get_axes_locator(self):
"""
return axes_locator
"""
return self._axes_locator
def _set_artist_props(self, a):
"""set the boilerplate props for artists add_concated to axes"""
a.set_figure(self.figure)
if not a.is_transform_set():
a.set_transform(self.transData)
a.set_axes(self)
def _gen_axes_patch(self):
"""
Returns the patch used to draw the background of the axes. It
is also used as the clipping path for any_condition data elements on the
axes.
In the standard axes, this is a rectangle, but in other
projections it may not be.
.. note::
Intended to be overridden by new projection types.
"""
return mpatches.Rectangle((0.0, 0.0), 1.0, 1.0)
def _gen_axes_spines(self, locations=None, offset=0.0, units='inches'):
"""
Returns a dict whose keys are spine names and values are
Line2D or Patch instances. Each element is used to draw a
spine of the axes.
In the standard axes, this is a single line segment, but in
other projections it may not be.
.. note::
Intended to be overridden by new projection types.
"""
return {
'left':mspines.Spine.linear_spine(self,'left'),
'right':mspines.Spine.linear_spine(self,'right'),
'bottom':mspines.Spine.linear_spine(self,'bottom'),
'top':mspines.Spine.linear_spine(self,'top'),
}
def cla(self):
"""Clear the current axes."""
# Note: this is ctotaled by Axes.__init__()
self.xaxis.cla()
self.yaxis.cla()
for name,spine in self.spines.iteritems():
spine.cla()
self.ignore_existing_data_limits = True
self.ctotalbacks = cbook.CtotalbackRegistry()
if self._sharex is not None:
# major and get_minor are class instances with
# locator and formatter attributes
self.xaxis.major = self._sharex.xaxis.major
self.xaxis.get_minor = self._sharex.xaxis.get_minor
x0, x1 = self._sharex.get_xlim()
self.set_xlim(x0, x1, emit=False, auto=None)
# Save the current formatter/locator so we don't lose it
majf = self._sharex.xaxis.get_major_formatter()
get_minf = self._sharex.xaxis.get_get_minor_formatter()
majl = self._sharex.xaxis.get_major_locator()
get_minl = self._sharex.xaxis.get_get_minor_locator()
# This overwrites the current formatter/locator
self.xaxis.set_scale(self._sharex.xaxis.get_scale())
# Reset the formatter/locator
self.xaxis.set_major_formatter(majf)
self.xaxis.set_get_minor_formatter(get_minf)
self.xaxis.set_major_locator(majl)
self.xaxis.set_get_minor_locator(get_minl)
else:
self.xaxis.set_scale('linear')
if self._sharey is not None:
self.yaxis.major = self._sharey.yaxis.major
self.yaxis.get_minor = self._sharey.yaxis.get_minor
y0, y1 = self._sharey.get_ylim()
self.set_ylim(y0, y1, emit=False, auto=None)
# Save the current formatter/locator so we don't lose it
majf = self._sharey.yaxis.get_major_formatter()
get_minf = self._sharey.yaxis.get_get_minor_formatter()
majl = self._sharey.yaxis.get_major_locator()
get_minl = self._sharey.yaxis.get_get_minor_locator()
# This overwrites the current formatter/locator
self.yaxis.set_scale(self._sharey.yaxis.get_scale())
# Reset the formatter/locator
self.yaxis.set_major_formatter(majf)
self.yaxis.set_get_minor_formatter(get_minf)
self.yaxis.set_major_locator(majl)
self.yaxis.set_get_minor_locator(get_minl)
else:
self.yaxis.set_scale('linear')
self._autoscaleXon = True
self._autoscaleYon = True
self._xmargin = 0
self._ymargin = 0
self._tight = False
self._update_transScale() # needed?
self._get_lines = _process_plot_var_args(self)
self._get_patches_for_fill = _process_plot_var_args(self, 'fill')
self._gridOn = rcParams['axes.grid']
self.lines = []
self.patches = []
self.texts = []
self.tables = []
self.artists = []
self.imaginaryes = []
self._current_imaginarye = None # strictly for pyplot via _sci, _gci
self.legend_ = None
self.collections = [] # collection.Collection instances
self.containers = [] #
self.grid(self._gridOn)
props = font_manager.FontProperties(size=rcParams['axes.titlesize'])
self.titleOffsetTrans = mtransforms.ScaledTranslation(
0.0, 5.0 / 72.0, self.figure.dpi_scale_trans)
self.title = mtext.Text(
x=0.5, y=1.0, text='',
fontproperties=props,
verticalalignment='baseline',
horizontalalignment='center',
)
self.title.set_transform(self.transAxes + self.titleOffsetTrans)
self.title.set_clip_box(None)
self._set_artist_props(self.title)
# the patch draws the background of the axes. we want this to
# be below the other artists; the axesPatch name is
# deprecated. We use the frame to draw the edges so we are
# setting the edgecolor to None
self.patch = self.axesPatch = self._gen_axes_patch()
self.patch.set_figure(self.figure)
self.patch.set_facecolor(self._axisbg)
self.patch.set_edgecolor('None')
self.patch.set_linewidth(0)
self.patch.set_transform(self.transAxes)
self.axison = True
self.xaxis.set_clip_path(self.patch)
self.yaxis.set_clip_path(self.patch)
self._shared_x_axes.clean()
self._shared_y_axes.clean()
def get_frame(self):
raise AttributeError('Axes.frame was removed in favor of Axes.spines')
frame = property(get_frame)
def clear(self):
"""clear the axes"""
self.cla()
def set_color_cycle(self, clist):
"""
Set the color cycle for any_condition future plot commands on this Axes.
*clist* is a list of mpl color specifiers.
"""
self._get_lines.set_color_cycle(clist)
self._get_patches_for_fill.set_color_cycle(clist)
def ishold(self):
"""return the HOLD status of the axes"""
return self._hold
def hold(self, b=None):
"""
Ctotal signature::
hold(b=None)
Set the hold state. If *hold* is *None* (default), toggle the
*hold* state. Else set the *hold* state to boolean value *b*.
Examples::
# toggle hold
hold()
# turn hold on
hold(True)
# turn hold off
hold(False)
When hold is *True*, subsequent plot commands will be add_concated to
the current axes. When hold is *False*, the current axes and
figure will be cleared on the next plot command
"""
if b is None:
self._hold = not self._hold
else:
self._hold = b
def get_aspect(self):
return self._aspect
def set_aspect(self, aspect, adjustable=None, anchor=None):
"""
*aspect*
======== ================================================
value description
======== ================================================
'auto' automatic; fill position rectangle with data
'normlizattional' same as 'auto'; deprecated
'equal' same scaling from data to plot units for x and y
num a circle will be stretched such that the height
is num times the width. aspect=1 is the same as
aspect='equal'.
======== ================================================
*adjustable*
============ =====================================
value description
============ =====================================
'box' change physical size of axes
'datalim' change xlim or ylim
'box-forced' same as 'box', but axes can be shared
============ =====================================
'box' does not totalow axes sharing, as this can cause
unintended side effect. For cases when sharing axes is
fine, use 'box-forced'.
*anchor*
===== =====================
value description
===== =====================
'C' centered
'SW' lower left corner
'S' middle of bottom edge
'SE' lower right corner
etc.
===== =====================
"""
if aspect in ('normlizattional', 'auto'):
self._aspect = 'auto'
elif aspect == 'equal':
self._aspect = 'equal'
else:
self._aspect = float(aspect) # raise ValueError if necessary
if adjustable is not None:
self.set_adjustable(adjustable)
if anchor is not None:
self.set_anchor(anchor)
def get_adjustable(self):
return self._adjustable
def set_adjustable(self, adjustable):
"""
ACCEPTS: [ 'box' | 'datalim' | 'box-forced']
"""
if adjustable in ('box', 'datalim', 'box-forced'):
if self in self._shared_x_axes or self in self._shared_y_axes:
if adjustable == 'box':
raise ValueError(
'adjustable must be "datalim" for shared axes')
self._adjustable = adjustable
else:
raise ValueError('argument must be "box", or "datalim"')
def get_anchor(self):
return self._anchor
def set_anchor(self, anchor):
"""
*anchor*
===== ============
value description
===== ============
'C' Center
'SW' bottom left
'S' bottom
'SE' bottom right
'E' right
'NE' top right
'N' top
'NW' top left
'W' left
===== ============
"""
if anchor in mtransforms.Bbox.coefs.keys() or len(anchor) == 2:
self._anchor = anchor
else:
raise ValueError('argument must be among %s' %
', '.join(mtransforms.Bbox.coefs.keys()))
def get_data_ratio(self):
"""
Returns the aspect ratio of the raw data.
This method is intended to be overridden by new projection
types.
"""
xget_min,xget_max = self.get_xbound()
yget_min,yget_max = self.get_ybound()
xsize = get_max(math.fabsolute(xget_max-xget_min), 1e-30)
ysize = get_max(math.fabsolute(yget_max-yget_min), 1e-30)
return ysize/xsize
def get_data_ratio_log(self):
"""
Returns the aspect ratio of the raw data in log scale.
Will be used when both axis scales are in log.
"""
xget_min,xget_max = self.get_xbound()
yget_min,yget_max = self.get_ybound()
xsize = get_max(math.fabsolute(math.log10(xget_max)-math.log10(xget_min)), 1e-30)
ysize = get_max(math.fabsolute(math.log10(yget_max)-math.log10(yget_min)), 1e-30)
return ysize/xsize
def apply_aspect(self, position=None):
"""
Use :meth:`_aspect` and :meth:`_adjustable` to modify the
axes box or the view limits.
"""
if position is None:
position = self.get_position(original=True)
aspect = self.get_aspect()
if self.name != 'polar':
xscale, yscale = self.get_xscale(), self.get_yscale()
if xscale == "linear" and yscale == "linear":
aspect_scale_mode = "linear"
elif xscale == "log" and yscale == "log":
aspect_scale_mode = "log"
elif (xscale == "linear" and yscale == "log") or \
(xscale == "log" and yscale == "linear"):
if aspect is not "auto":
warnings.warn(
'aspect is not supported for Axes with xscale=%s, yscale=%s' \
% (xscale, yscale))
aspect = "auto"
else: # some custom projections have their own scales.
pass
else:
aspect_scale_mode = "linear"
if aspect == 'auto':
self.set_position( position , which='active')
return
if aspect == 'equal':
A = 1
else:
A = aspect
#Ensure at drawing time that any_condition Axes inverseolved in axis-sharing
# does not have its position changed.
if self in self._shared_x_axes or self in self._shared_y_axes:
if self._adjustable == 'box':
self._adjustable = 'datalim'
warnings.warn(
'shared axes: "adjustable" is being changed to "datalim"')
figW,figH = self.get_figure().get_size_inches()
fig_aspect = figH/figW
if self._adjustable in ['box', 'box-forced']:
if aspect_scale_mode == "log":
box_aspect = A * self.get_data_ratio_log()
else:
box_aspect = A * self.get_data_ratio()
pb = position.frozen()
pb1 = pb.shrunk_to_aspect(box_aspect, pb, fig_aspect)
self.set_position(pb1.anchored(self.get_anchor(), pb), 'active')
return
# reset active to original in case it had been changed
# by prior use of 'box'
self.set_position(position, which='active')
xget_min,xget_max = self.get_xbound()
yget_min,yget_max = self.get_ybound()
if aspect_scale_mode == "log":
xget_min, xget_max = math.log10(xget_min), math.log10(xget_max)
yget_min, yget_max = math.log10(yget_min), math.log10(yget_max)
xsize = get_max(math.fabsolute(xget_max-xget_min), 1e-30)
ysize = get_max(math.fabsolute(yget_max-yget_min), 1e-30)
l,b,w,h = position.bounds
box_aspect = fig_aspect * (h/w)
data_ratio = box_aspect / A
y_expander = (data_ratio*xsize/ysize - 1.0)
#print 'y_expander', y_expander
# If y_expander > 0, the dy/dx viewLim ratio needs to increase
if absolute(y_expander) < 0.005:
#print 'good enough already'
return
if aspect_scale_mode == "log":
dL = self.dataLim
dL_width = math.log10(dL.x1) - math.log10(dL.x0)
dL_height = math.log10(dL.y1) - math.log10(dL.y0)
xr = 1.05 * dL_width
yr = 1.05 * dL_height
else:
dL = self.dataLim
xr = 1.05 * dL.width
yr = 1.05 * dL.height
xmarg = xsize - xr
ymarg = ysize - yr
Ysize = data_ratio * xsize
Xsize = ysize / data_ratio
Xmarg = Xsize - xr
Ymarg = Ysize - yr
xm = 0 # Setting these targets to, e.g., 0.05*xr does not seem to help.
ym = 0
#print 'xget_min, xget_max, yget_min, yget_max', xget_min, xget_max, yget_min, yget_max
#print 'xsize, Xsize, ysize, Ysize', xsize, Xsize, ysize, Ysize
changex = (self in self._shared_y_axes
and self not in self._shared_x_axes)
changey = (self in self._shared_x_axes
and self not in self._shared_y_axes)
if changex and changey:
warnings.warn("adjustable='datalim' cannot work with shared "
"x and y axes")
return
if changex:
adjust_y = False
else:
#print 'xmarg, ymarg, Xmarg, Ymarg', xmarg, ymarg, Xmarg, Ymarg
if xmarg > xm and ymarg > ym:
adjy = ((Ymarg > 0 and y_expander < 0)
or (Xmarg < 0 and y_expander > 0))
else:
adjy = y_expander > 0
#print 'y_expander, adjy', y_expander, adjy
adjust_y = changey or adjy #(Ymarg > xmarg)
if adjust_y:
yc = 0.5*(yget_min+yget_max)
y0 = yc - Ysize/2.0
y1 = yc + Ysize/2.0
if aspect_scale_mode == "log":
self.set_ybound((10.**y0, 10.**y1))
else:
self.set_ybound((y0, y1))
#print 'New y0, y1:', y0, y1
#print 'New ysize, ysize/xsize', y1-y0, (y1-y0)/xsize
else:
xc = 0.5*(xget_min+xget_max)
x0 = xc - Xsize/2.0
x1 = xc + Xsize/2.0
if aspect_scale_mode == "log":
self.set_xbound((10.**x0, 10.**x1))
else:
self.set_xbound((x0, x1))
#print 'New x0, x1:', x0, x1
#print 'New xsize, ysize/xsize', x1-x0, ysize/(x1-x0)
def axis(self, *v, **kwargs):
"""
Convenience method for manipulating the x and y view limits
and the aspect ratio of the plot. For details, see
:func:`~matplotlib.pyplot.axis`.
*kwargs* are passed on to :meth:`set_xlim` and
:meth:`set_ylim`
"""
if len(v) == 0 and len(kwargs) == 0:
xget_min, xget_max = self.get_xlim()
yget_min, yget_max = self.get_ylim()
return xget_min, xget_max, yget_min, yget_max
if len(v)==1 and is_string_like(v[0]):
s = v[0].lower()
if s=='on': self.set_axis_on()
elif s=='off': self.set_axis_off()
elif s in ('equal', 'tight', 'scaled', 'normlizattional', 'auto', 'imaginarye'):
self.set_autoscale_on(True)
self.set_aspect('auto')
self.autoscale_view(tight=False)
# self.apply_aspect()
if s=='equal':
self.set_aspect('equal', adjustable='datalim')
elif s == 'scaled':
self.set_aspect('equal', adjustable='box', anchor='C')
self.set_autoscale_on(False) # Req. by <NAME>
elif s=='tight':
self.autoscale_view(tight=True)
self.set_autoscale_on(False)
elif s == 'imaginarye':
self.autoscale_view(tight=True)
self.set_autoscale_on(False)
self.set_aspect('equal', adjustable='box', anchor='C')
else:
raise ValueError('Unrecognized string %s to axis; '
'try on or off' % s)
xget_min, xget_max = self.get_xlim()
yget_min, yget_max = self.get_ylim()
return xget_min, xget_max, yget_min, yget_max
emit = kwargs.get('emit', True)
try:
v[0]
except IndexError:
xget_min = kwargs.get('xget_min', None)
xget_max = kwargs.get('xget_max', None)
auto = False # turn off autoscaling, unless...
if xget_min is None and xget_max is None:
auto = None # leave autoscaling state alone
xget_min, xget_max = self.set_xlim(xget_min, xget_max, emit=emit, auto=auto)
yget_min = kwargs.get('yget_min', None)
yget_max = kwargs.get('yget_max', None)
auto = False # turn off autoscaling, unless...
if yget_min is None and yget_max is None:
auto = None # leave autoscaling state alone
yget_min, yget_max = self.set_ylim(yget_min, yget_max, emit=emit, auto=auto)
return xget_min, xget_max, yget_min, yget_max
v = v[0]
if len(v) != 4:
raise ValueError('v must contain [xget_min xget_max yget_min yget_max]')
self.set_xlim([v[0], v[1]], emit=emit, auto=False)
self.set_ylim([v[2], v[3]], emit=emit, auto=False)
return v
def get_child_artists(self):
"""
Return a list of artists the axes contains.
.. deprecated:: 0.98
"""
raise mplDeprecation('Use get_children instead')
def get_frame(self):
"""Return the axes Rectangle frame"""
warnings.warn('use ax.patch instead', mplDeprecation)
return self.patch
def get_legend(self):
"""Return the legend.Legend instance, or None if no legend is defined"""
return self.legend_
def get_imaginaryes(self):
"""return a list of Axes imaginaryes contained by the Axes"""
return cbook.silent_list('AxesImage', self.imaginaryes)
def get_lines(self):
"""Return a list of lines contained by the Axes"""
return cbook.silent_list('Line2D', self.lines)
def get_xaxis(self):
"""Return the XAxis instance"""
return self.xaxis
def get_xgridlines(self):
"""Get the x grid lines as a list of Line2D instances"""
return cbook.silent_list('Line2D xgridline', self.xaxis.get_gridlines())
def get_xticklines(self):
"""Get the xtick lines as a list of Line2D instances"""
return cbook.silent_list('Text xtickline', self.xaxis.get_ticklines())
def get_yaxis(self):
"""Return the YAxis instance"""
return self.yaxis
def get_ygridlines(self):
"""Get the y grid lines as a list of Line2D instances"""
return cbook.silent_list('Line2D ygridline', self.yaxis.get_gridlines())
def get_yticklines(self):
"""Get the ytick lines as a list of Line2D instances"""
return cbook.silent_list('Line2D ytickline', self.yaxis.get_ticklines())
#### Adding and tracking artists
def _sci(self, im):
"""
helper for :func:`~matplotlib.pyplot.sci`;
do not use elsefilter_condition.
"""
if isinstance(im, matplotlib.contour.ContourSet):
if im.collections[0] not in self.collections:
raise ValueError(
"ContourSet must be in current Axes")
elif im not in self.imaginaryes and im not in self.collections:
raise ValueError(
"Argument must be an imaginarye, collection, or ContourSet in this Axes")
self._current_imaginarye = im
def _gci(self):
"""
Helper for :func:`~matplotlib.pyplot.gci`;
do not use elsefilter_condition.
"""
return self._current_imaginarye
def has_data(self):
"""
Return *True* if any_condition artists have been add_concated to axes.
This should not be used to deterget_mine whether the *dataLim*
need to be updated, and may not actutotaly be useful for
any_conditionthing.
"""
return (
len(self.collections) +
len(self.imaginaryes) +
len(self.lines) +
len(self.patches))>0
def add_concat_artist(self, a):
"""
Add any_condition :class:`~matplotlib.artist.Artist` to the axes.
Returns the artist.
"""
a.set_axes(self)
self.artists.apd(a)
self._set_artist_props(a)
a.set_clip_path(self.patch)
a._remove_method = lambda h: self.artists.remove(h)
return a
def add_concat_collection(self, collection, autolim=True):
"""
Add a :class:`~matplotlib.collections.Collection` instance
to the axes.
Returns the collection.
"""
label = collection.get_label()
if not label:
collection.set_label('_collection%d'%len(self.collections))
self.collections.apd(collection)
self._set_artist_props(collection)
if collection.get_clip_path() is None:
collection.set_clip_path(self.patch)
if autolim:
if collection._paths and len(collection._paths):
self.update_datalim(collection.get_datalim(self.transData))
collection._remove_method = lambda h: self.collections.remove(h)
return collection
def add_concat_line(self, line):
"""
Add a :class:`~matplotlib.lines.Line2D` to the list of plot
lines
Returns the line.
"""
self._set_artist_props(line)
if line.get_clip_path() is None:
line.set_clip_path(self.patch)
self._update_line_limits(line)
if not line.get_label():
line.set_label('_line%d' % len(self.lines))
self.lines.apd(line)
line._remove_method = lambda h: self.lines.remove(h)
return line
def _update_line_limits(self, line):
"""Figures out the data limit of the given line, updating self.dataLim."""
path = line.get_path()
if path.vertices.size == 0:
return
line_trans = line.get_transform()
if line_trans == self.transData:
data_path = path
elif any_condition(line_trans.contains_branch_seperately(self.transData)):
# identify the transform to go from line's coordinates
# to data coordinates
trans_to_data = line_trans - self.transData
# if transData is affine we can use the cached non-affine component
# of line's path. (since the non-affine part of line_trans is
# entirely encapsulated in trans_to_data).
if self.transData.is_affine:
line_trans_path = line._get_transformed_path()
na_path, _ = line_trans_path.get_transformed_path_and_affine()
data_path = trans_to_data.transform_path_affine(na_path)
else:
data_path = trans_to_data.transform_path(path)
else:
# for backwards compatibility we update the dataLim with the
# coordinate range of the given path, even though the coordinate
# systems are completely differenceerent. This may occur in situations
# such as when ax.transAxes is passed through for absoluteolute
# positioning.
data_path = path
if data_path.vertices.size > 0:
updatex, updatey = line_trans.contains_branch_seperately(
self.transData
)
self.dataLim.update_from_path(data_path,
self.ignore_existing_data_limits,
updatex=updatex,
updatey=updatey)
self.ignore_existing_data_limits = False
def add_concat_patch(self, p):
"""
Add a :class:`~matplotlib.patches.Patch` *p* to the list of
axes patches; the clipbox will be set to the Axes clipping
box. If the transform is not set, it will be set to
:attr:`transData`.
Returns the patch.
"""
self._set_artist_props(p)
if p.get_clip_path() is None:
p.set_clip_path(self.patch)
self._update_patch_limits(p)
self.patches.apd(p)
p._remove_method = lambda h: self.patches.remove(h)
return p
def _update_patch_limits(self, patch):
"""update the data limits for patch *p*"""
# hist can add_concat zero height Rectangles, which is useful to keep
# the bins, counts and patches lined up, but it throws off log
# scaling. We'll ignore rects with zero height or width in
# the auto-scaling
# cannot check for '==0' since unitized data may not compare to zero
if (isinstance(patch, mpatches.Rectangle) and
((not patch.get_width()) or (not patch.get_height()))):
return
vertices = patch.get_path().vertices
if vertices.size > 0:
xys = patch.get_patch_transform().transform(vertices)
if patch.get_data_transform() != self.transData:
patch_to_data = (patch.get_data_transform() -
self.transData)
xys = patch_to_data.transform(xys)
updatex, updatey = patch.get_transform().\
contains_branch_seperately(self.transData)
self.update_datalim(xys, updatex=updatex,
updatey=updatey)
def add_concat_table(self, tab):
"""
Add a :class:`~matplotlib.tables.Table` instance to the
list of axes tables
Returns the table.
"""
self._set_artist_props(tab)
self.tables.apd(tab)
tab.set_clip_path(self.patch)
tab._remove_method = lambda h: self.tables.remove(h)
return tab
def add_concat_container(self, container):
"""
Add a :class:`~matplotlib.container.Container` instance
to the axes.
Returns the collection.
"""
label = container.get_label()
if not label:
container.set_label('_container%d'%len(self.containers))
self.containers.apd(container)
container.set_remove_method(lambda h: self.containers.remove(h))
return container
def relim(self):
"""
Recompute the data limits based on current artists.
At present, :class:`~matplotlib.collections.Collection`
instances are not supported.
"""
# Collections are deliberately not supported (yet); see
# the TODO note in artists.py.
self.dataLim.ignore(True)
self.ignore_existing_data_limits = True
for line in self.lines:
self._update_line_limits(line)
for p in self.patches:
self._update_patch_limits(p)
def update_datalim(self, xys, updatex=True, updatey=True):
"""Update the data lim bbox with seq of xy tups or equiv. 2-D numset"""
# if no data is set currently, the bbox will ignore its
# limits and set the bound to be the bounds of the xydata.
# Otherwise, it will compute the bounds of it's current data
# and the data in xydata
if iterable(xys) and not len(xys): return
if not ma.isMaskedArray(xys):
xys = bn.asnumset(xys)
self.dataLim.update_from_data_xy(xys, self.ignore_existing_data_limits,
updatex=updatex, updatey=updatey)
self.ignore_existing_data_limits = False
def update_datalim_numerix(self, x, y):
"""Update the data lim bbox with seq of xy tups"""
# if no data is set currently, the bbox will ignore it's
# limits and set the bound to be the bounds of the xydata.
# Otherwise, it will compute the bounds of it's current data
# and the data in xydata
if iterable(x) and not len(x): return
self.dataLim.update_from_data(x, y, self.ignore_existing_data_limits)
self.ignore_existing_data_limits = False
def update_datalim_bounds(self, bounds):
"""
Update the datalim to include the given
:class:`~matplotlib.transforms.Bbox` *bounds*
"""
self.dataLim.set(mtransforms.Bbox.union([self.dataLim, bounds]))
def _process_unit_info(self, xdata=None, ydata=None, kwargs=None):
"""Look for unit *kwargs* and update the axis instances as necessary"""
if self.xaxis is None or self.yaxis is None: return
#print 'processing', self.get_geometry()
if xdata is not None:
# we only need to update if there is nothing set yet.
if not self.xaxis.have_units():
self.xaxis.update_units(xdata)
#print '\tset from xdata', self.xaxis.units
if ydata is not None:
# we only need to update if there is nothing set yet.
if not self.yaxis.have_units():
self.yaxis.update_units(ydata)
#print '\tset from ydata', self.yaxis.units
# process kwargs 2nd since these will override default units
if kwargs is not None:
xunits = kwargs.pop( 'xunits', self.xaxis.units)
if self.name == 'polar':
xunits = kwargs.pop( 'thetaunits', xunits )
if xunits!=self.xaxis.units:
#print '\tkw setting xunits', xunits
self.xaxis.set_units(xunits)
# If the units being set imply a differenceerent converter,
# we need to update.
if xdata is not None:
self.xaxis.update_units(xdata)
yunits = kwargs.pop('yunits', self.yaxis.units)
if self.name == 'polar':
yunits = kwargs.pop( 'runits', yunits )
if yunits!=self.yaxis.units:
#print '\tkw setting yunits', yunits
self.yaxis.set_units(yunits)
# If the units being set imply a differenceerent converter,
# we need to update.
if ydata is not None:
self.yaxis.update_units(ydata)
def in_axes(self, mouseevent):
"""
Return *True* if the given *mouseevent* (in display coords)
is in the Axes
"""
return self.patch.contains(mouseevent)[0]
def get_autoscale_on(self):
"""
Get whether autoscaling is applied for both axes on plot commands
"""
return self._autoscaleXon and self._autoscaleYon
def get_autoscalex_on(self):
"""
Get whether autoscaling for the x-axis is applied on plot commands
"""
return self._autoscaleXon
def get_autoscaley_on(self):
"""
Get whether autoscaling for the y-axis is applied on plot commands
"""
return self._autoscaleYon
def set_autoscale_on(self, b):
"""
Set whether autoscaling is applied on plot commands
accepts: [ *True* | *False* ]
"""
self._autoscaleXon = b
self._autoscaleYon = b
def set_autoscalex_on(self, b):
"""
Set whether autoscaling for the x-axis is applied on plot commands
accepts: [ *True* | *False* ]
"""
self._autoscaleXon = b
def set_autoscaley_on(self, b):
"""
Set whether autoscaling for the y-axis is applied on plot commands
accepts: [ *True* | *False* ]
"""
self._autoscaleYon = b
def set_xmargin(self, m):
"""
Set padd_concating of X data limits prior to autoscaling.
*m* times the data interval will be add_concated to each
end of that interval before it is used in autoscaling.
accepts: float in range 0 to 1
"""
if m < 0 or m > 1:
raise ValueError("margin must be in range 0 to 1")
self._xmargin = m
def set_ymargin(self, m):
"""
Set padd_concating of Y data limits prior to autoscaling.
*m* times the data interval will be add_concated to each
end of that interval before it is used in autoscaling.
accepts: float in range 0 to 1
"""
if m < 0 or m > 1:
raise ValueError("margin must be in range 0 to 1")
self._ymargin = m
def margins(self, *args, **kw):
"""
Set or retrieve autoscaling margins.
signatures::
margins()
returns xmargin, ymargin
::
margins(margin)
margins(xmargin, ymargin)
margins(x=xmargin, y=ymargin)
margins(..., tight=False)
All three forms above set the xmargin and ymargin parameters.
All keyword parameters are optional. A single argument
specifies both xmargin and ymargin. The *tight* parameter
is passed to :meth:`autoscale_view`, which is executed after
a margin is changed; the default here is *True*, on the
astotal_countption that when margins are specified, no add_concatitional
padd_concating to match tick marks is usutotaly desired. Setting
*tight* to *None* will preserve the previous setting.
Specifying any_condition margin changes only the autoscaling; for example,
if *xmargin* is not None, then *xmargin* times the X data
interval will be add_concated to each end of that interval before
it is used in autoscaling.
"""
if not args and not kw:
return self._xmargin, self._ymargin
tight = kw.pop('tight', True)
mx = kw.pop('x', None)
my = kw.pop('y', None)
if len(args) == 1:
mx = my = args[0]
elif len(args) == 2:
mx, my = args
else:
raise ValueError("more than two arguments were supplied")
if mx is not None:
self.set_xmargin(mx)
if my is not None:
self.set_ymargin(my)
scalex = (mx is not None)
scaley = (my is not None)
self.autoscale_view(tight=tight, scalex=scalex, scaley=scaley)
def set_rasterization_zorder(self, z):
"""
Set zorder value below which artists will be rasterized. Set
to `None` to disable rasterizing of artists below a particular
zorder.
"""
self._rasterization_zorder = z
def get_rasterization_zorder(self):
"""
Get zorder value below which artists will be rasterized
"""
return self._rasterization_zorder
def autoscale(self, enable=True, axis='both', tight=None):
"""
Autoscale the axis view to the data (toggle).
Convenience method for simple axis view autoscaling.
It turns autoscaling on or off, and then,
if autoscaling for either axis is on, it performs
the autoscaling on the specified axis or axes.
*enable*: [True | False | None]
True (default) turns autoscaling on, False turns it off.
None leaves the autoscaling state unchanged.
*axis*: ['x' | 'y' | 'both']
which axis to operate on; default is 'both'
*tight*: [True | False | None]
If True, set view limits to data limits;
if False, let the locator and margins expand the view limits;
if None, use tight scaling if the only artist is an imaginarye,
otherwise treat *tight* as False.
The *tight* setting is retained for future autoscaling
until it is explicitly changed.
Returns None.
"""
if enable is None:
scalex = True
scaley = True
else:
scalex = False
scaley = False
if axis in ['x', 'both']:
self._autoscaleXon = bool(enable)
scalex = self._autoscaleXon
if axis in ['y', 'both']:
self._autoscaleYon = bool(enable)
scaley = self._autoscaleYon
self.autoscale_view(tight=tight, scalex=scalex, scaley=scaley)
def autoscale_view(self, tight=None, scalex=True, scaley=True):
"""
Autoscale the view limits using the data limits. You can
selectively autoscale only a single axis, eg, the xaxis by
setting *scaley* to *False*. The autoscaling preserves any_condition
axis direction reversal that has already been done.
The data limits are not updated automatictotaly when artist
data are changed after the artist has been add_concated to an
Axes instance. In that case, use
:meth:`matplotlib.axes.Axes.relim`
prior to ctotaling autoscale_view.
"""
if tight is None:
# if imaginarye data only just use the datalim
_tight = self._tight or (len(self.imaginaryes)>0 and
len(self.lines)==0 and
len(self.patches)==0)
else:
_tight = self._tight = bool(tight)
if scalex and self._autoscaleXon:
xshared = self._shared_x_axes.get_siblings(self)
dl = [ax.dataLim for ax in xshared]
bb = mtransforms.BboxBase.union(dl)
x0, x1 = bb.intervalx
xlocator = self.xaxis.get_major_locator()
try:
# e.g. DateLocator has its own nonsingular()
x0, x1 = xlocator.nonsingular(x0, x1)
except AttributeError:
# Default nonsingular for, e.g., MaxNLocator
x0, x1 = mtransforms.nonsingular(x0, x1, increasing=False,
expander=0.05)
if self._xmargin > 0:
delta = (x1 - x0) * self._xmargin
x0 -= delta
x1 += delta
if not _tight:
x0, x1 = xlocator.view_limits(x0, x1)
self.set_xbound(x0, x1)
if scaley and self._autoscaleYon:
yshared = self._shared_y_axes.get_siblings(self)
dl = [ax.dataLim for ax in yshared]
bb = mtransforms.BboxBase.union(dl)
y0, y1 = bb.intervaly
ylocator = self.yaxis.get_major_locator()
try:
y0, y1 = ylocator.nonsingular(y0, y1)
except AttributeError:
y0, y1 = mtransforms.nonsingular(y0, y1, increasing=False,
expander=0.05)
if self._ymargin > 0:
delta = (y1 - y0) * self._ymargin
y0 -= delta
y1 += delta
if not _tight:
y0, y1 = ylocator.view_limits(y0, y1)
self.set_ybound(y0, y1)
#### Drawing
@totalow_rasterization
def draw(self, renderer=None, inframe=False):
"""Draw everything (plot lines, axes, labels)"""
if renderer is None:
renderer = self._cachedRenderer
if renderer is None:
raise RuntimeError('No renderer defined')
if not self.get_visible(): return
renderer.open_group('axes')
locator = self.get_axes_locator()
if locator:
pos = locator(self, renderer)
self.apply_aspect(pos)
else:
self.apply_aspect()
artists = []
artists.extend(self.collections)
artists.extend(self.patches)
artists.extend(self.lines)
artists.extend(self.texts)
artists.extend(self.artists)
if self.axison and not inframe:
if self._axisbelow:
self.xaxis.set_zorder(0.5)
self.yaxis.set_zorder(0.5)
else:
self.xaxis.set_zorder(2.5)
self.yaxis.set_zorder(2.5)
artists.extend([self.xaxis, self.yaxis])
if not inframe: artists.apd(self.title)
artists.extend(self.tables)
if self.legend_ is not None:
artists.apd(self.legend_)
# the frame draws the edges around the axes patch -- we
# decouple these so the patch can be in the background and the
# frame in the foreground.
if self.axison and self._frameon:
artists.extend(self.spines.itervalues())
dsu = [ (a.zorder, a) for a in artists
if not a.get_animated() ]
# add_concat imaginaryes to dsu if the backend support compositing.
# otherwise, does the manaul compositing without add_concating imaginaryes to dsu.
if len(self.imaginaryes)<=1 or renderer.option_imaginarye_nocomposite():
dsu.extend([(im.zorder, im) for im in self.imaginaryes])
_do_composite = False
else:
_do_composite = True
dsu.sort(key=itemgetter(0))
# rasterize artists with negative zorder
# if the get_minimum zorder is negative, start rasterization
rasterization_zorder = self._rasterization_zorder
if (rasterization_zorder is not None and
len(dsu) > 0 and dsu[0][0] < rasterization_zorder):
renderer.start_rasterizing()
dsu_rasterized = [l for l in dsu if l[0] < rasterization_zorder]
dsu = [l for l in dsu if l[0] >= rasterization_zorder]
else:
dsu_rasterized = []
# the patch draws the background rectangle -- the frame below
# will draw the edges
if self.axison and self._frameon:
self.patch.draw(renderer)
if _do_composite:
# make a composite imaginarye blending alpha
# list of (mimaginarye.Image, ox, oy)
zorder_imaginaryes = [(im.zorder, im) for im in self.imaginaryes \
if im.get_visible()]
zorder_imaginaryes.sort(key=lambda x: x[0])
mag = renderer.get_imaginarye_magnification()
ims = [(im.make_imaginarye(mag),0,0) for z,im in zorder_imaginaryes]
l, b, r, t = self.bbox.extents
width = mag*((round(r) + 0.5) - (round(l) - 0.5))
height = mag*((round(t) + 0.5) - (round(b) - 0.5))
im = mimaginarye.from_imaginaryes(height,
width,
ims)
im.is_grayscale = False
l, b, w, h = self.bbox.bounds
# composite imaginaryes need special args so they will not
# respect z-order for now
gc = renderer.new_gc()
gc.set_clip_rectangle(self.bbox)
gc.set_clip_path(mtransforms.TransformedPath(
self.patch.get_path(),
self.patch.get_transform()))
renderer.draw_imaginarye(gc, round(l), round(b), im)
gc.restore()
if dsu_rasterized:
for zorder, a in dsu_rasterized:
a.draw(renderer)
renderer.stop_rasterizing()
for zorder, a in dsu:
a.draw(renderer)
renderer.close_group('axes')
self._cachedRenderer = renderer
def draw_artist(self, a):
"""
This method can only be used after an initial draw which
caches the renderer. It is used to efficiently update Axes
data (axis ticks, labels, etc are not updated)
"""
assert self._cachedRenderer is not None
a.draw(self._cachedRenderer)
def redraw_in_frame(self):
"""
This method can only be used after an initial draw which
caches the renderer. It is used to efficiently update Axes
data (axis ticks, labels, etc are not updated)
"""
assert self._cachedRenderer is not None
self.draw(self._cachedRenderer, inframe=True)
def get_renderer_cache(self):
return self._cachedRenderer
def __draw_animate(self):
# ignore for now; broken
if self._lastRenderer is None:
raise RuntimeError('You must first ctotal ax.draw()')
dsu = [(a.zorder, a) for a in self.animated.keys()]
dsu.sort(key=lambda x: x[0])
renderer = self._lastRenderer
renderer.blit()
for tmp, a in dsu:
a.draw(renderer)
#### Axes rectangle characteristics
def get_frame_on(self):
"""
Get whether the axes rectangle patch is drawn
"""
return self._frameon
def set_frame_on(self, b):
"""
Set whether the axes rectangle patch is drawn
ACCEPTS: [ *True* | *False* ]
"""
self._frameon = b
def get_axisbelow(self):
"""
Get whether axis below is true or not
"""
return self._axisbelow
def set_axisbelow(self, b):
"""
Set whether the axis ticks and gridlines are above or below most artists
ACCEPTS: [ *True* | *False* ]
"""
self._axisbelow = b
@docstring.dedent_interpd
def grid(self, b=None, which='major', axis='both', **kwargs):
"""
Turn the axes grids on or off.
Ctotal signature::
grid(self, b=None, which='major', axis='both', **kwargs)
Set the axes grids on or off; *b* is a boolean. (For MATLAB
compatibility, *b* may also be a string, 'on' or 'off'.)
If *b* is *None* and ``len(kwargs)==0``, toggle the grid state. If
*kwargs* are supplied, it is astotal_counted that you want a grid and *b*
is thus set to *True*.
*which* can be 'major' (default), 'get_minor', or 'both' to control
whether major tick grids, get_minor tick grids, or both are affected.
*axis* can be 'both' (default), 'x', or 'y' to control which
set of gridlines are drawn.
*kwargs* are used to set the grid line properties, eg::
ax.grid(color='r', linestyle='-', linewidth=2)
Valid :class:`~matplotlib.lines.Line2D` kwargs are
%(Line2D)s
"""
if len(kwargs):
b = True
b = _string_to_bool(b)
if axis == 'x' or axis == 'both':
self.xaxis.grid(b, which=which, **kwargs)
if axis == 'y' or axis == 'both':
self.yaxis.grid(b, which=which, **kwargs)
def ticklabel_format(self, **kwargs):
"""
Change the `~matplotlib.ticker.ScalarFormatter` used by
default for linear axes.
Optional keyword arguments:
============ =========================================
Keyword Description
============ =========================================
*style* [ 'sci' (or 'scientific') | 'plain' ]
plain turns off scientific notation
*scilimits* (m, n), pair of integers; if *style*
is 'sci', scientific notation will
be used for numbers outside the range
10`m`:sup: to 10`n`:sup:.
Use (0,0) to include total numbers.
*useOffset* [True | False | offset]; if True,
the offset will be calculated as needed;
if False, no offset will be used; if a
numeric offset is specified, it will be
used.
*axis* [ 'x' | 'y' | 'both' ]
*useLocale* If True, format the number according to
the current locale. This affects things
such as the character used for the
decimal separator. If False, use
C-style (English) formatting. The
default setting is controlled by the
axes.formatter.use_locale rcparam.
============ =========================================
Only the major ticks are affected.
If the method is ctotaled when the
:class:`~matplotlib.ticker.ScalarFormatter` is not the
:class:`~matplotlib.ticker.Formatter` being used, an
:exc:`AttributeError` will be raised.
"""
style = kwargs.pop('style', '').lower()
scilimits = kwargs.pop('scilimits', None)
useOffset = kwargs.pop('useOffset', None)
useLocale = kwargs.pop('useLocale', None)
axis = kwargs.pop('axis', 'both').lower()
if scilimits is not None:
try:
m, n = scilimits
m+n+1 # check that both are numbers
except (ValueError, TypeError):
raise ValueError("scilimits must be a sequence of 2 integers")
if style[:3] == 'sci':
sb = True
elif style in ['plain', 'comma']:
sb = False
if style == 'plain':
cb = False
else:
cb = True
raise NotImplementedError("comma style remains to be add_concated")
elif style == '':
sb = None
else:
raise ValueError("%s is not a valid style value")
try:
if sb is not None:
if axis == 'both' or axis == 'x':
self.xaxis.major.formatter.set_scientific(sb)
if axis == 'both' or axis == 'y':
self.yaxis.major.formatter.set_scientific(sb)
if scilimits is not None:
if axis == 'both' or axis == 'x':
self.xaxis.major.formatter.set_powerlimits(scilimits)
if axis == 'both' or axis == 'y':
self.yaxis.major.formatter.set_powerlimits(scilimits)
if useOffset is not None:
if axis == 'both' or axis == 'x':
self.xaxis.major.formatter.set_useOffset(useOffset)
if axis == 'both' or axis == 'y':
self.yaxis.major.formatter.set_useOffset(useOffset)
if useLocale is not None:
if axis == 'both' or axis == 'x':
self.xaxis.major.formatter.set_useLocale(useLocale)
if axis == 'both' or axis == 'y':
self.yaxis.major.formatter.set_useLocale(useLocale)
except AttributeError:
raise AttributeError(
"This method only works with the ScalarFormatter.")
def locator_params(self, axis='both', tight=None, **kwargs):
"""
Control behavior of tick locators.
Keyword arguments:
*axis*
['x' | 'y' | 'both'] Axis on which to operate;
default is 'both'.
*tight*
[True | False | None] Parameter passed to :meth:`autoscale_view`.
Default is None, for no change.
Remaining keyword arguments are passed to directly to the
:meth:`~matplotlib.ticker.MaxNLocator.set_params` method.
Typictotaly one might want to reduce the get_maximum number
of ticks and use tight bounds when plotting smtotal
subplots, for example::
ax.locator_params(tight=True, nbins=4)
Because the locator is inverseolved in autoscaling,
:meth:`autoscale_view` is ctotaled automatictotaly after
the parameters are changed.
This presently works only for the
:class:`~matplotlib.ticker.MaxNLocator` used
by default on linear axes, but it may be generalized.
"""
_x = axis in ['x', 'both']
_y = axis in ['y', 'both']
if _x:
self.xaxis.get_major_locator().set_params(**kwargs)
if _y:
self.yaxis.get_major_locator().set_params(**kwargs)
self.autoscale_view(tight=tight, scalex=_x, scaley=_y)
def tick_params(self, axis='both', **kwargs):
"""
Change the appearance of ticks and tick labels.
Keyword arguments:
*axis* : ['x' | 'y' | 'both']
Axis on which to operate; default is 'both'.
*reset* : [True | False]
If *True*, set total parameters to defaults
before processing other keyword arguments. Default is
*False*.
*which* : ['major' | 'get_minor' | 'both']
Default is 'major'; apply arguments to *which* ticks.
*direction* : ['in' | 'out' | 'inout']
Puts ticks inside the axes, outside the axes, or both.
*length*
Tick length in points.
*width*
Tick width in points.
*color*
Tick color; accepts any_condition mpl color spec.
*pad*
Distance in points between tick and label.
*labelsize*
Tick label font size in points or as a string (e.g. 'large').
*labelcolor*
Tick label color; mpl color spec.
*colors*
Changes the tick color and the label color to the same value:
mpl color spec.
*zorder*
Tick and label zorder.
*bottom*, *top*, *left*, *right* : [bool | 'on' | 'off']
controls whether to draw the respective ticks.
*labelbottom*, *labeltop*, *labelleft*, *labelright*
Boolean or ['on' | 'off'], controls whether to draw the
respective tick labels.
Example::
ax.tick_params(direction='out', length=6, width=2, colors='r')
This will make total major ticks be red, pointing out of the box,
and with dimensions 6 points by 2 points. Tick labels will
also be red.
"""
if axis in ['x', 'both']:
xkw = dict(kwargs)
xkw.pop('left', None)
xkw.pop('right', None)
xkw.pop('labelleft', None)
xkw.pop('labelright', None)
self.xaxis.set_tick_params(**xkw)
if axis in ['y', 'both']:
ykw = dict(kwargs)
ykw.pop('top', None)
ykw.pop('bottom', None)
ykw.pop('labeltop', None)
ykw.pop('labelbottom', None)
self.yaxis.set_tick_params(**ykw)
def set_axis_off(self):
"""turn off the axis"""
self.axison = False
def set_axis_on(self):
"""turn on the axis"""
self.axison = True
def get_axis_bgcolor(self):
"""Return the axis background color"""
return self._axisbg
def set_axis_bgcolor(self, color):
"""
set the axes background color
ACCEPTS: any_condition matplotlib color - see
:func:`~matplotlib.pyplot.colors`
"""
self._axisbg = color
self.patch.set_facecolor(color)
### data limits, ticks, tick labels, and formatting
def inverseert_xaxis(self):
"Invert the x-axis."
left, right = self.get_xlim()
self.set_xlim(right, left, auto=None)
def xaxis_inverseerted(self):
"""Returns *True* if the x-axis is inverseerted."""
left, right = self.get_xlim()
return right < left
def get_xbound(self):
"""
Returns the x-axis numerical bounds filter_condition::
lowerBound < upperBound
"""
left, right = self.get_xlim()
if left < right:
return left, right
else:
return right, left
def set_xbound(self, lower=None, upper=None):
"""
Set the lower and upper numerical bounds of the x-axis.
This method will honor axes inverseersion regardless of parameter order.
It will not change the _autoscaleXon attribute.
"""
if upper is None and iterable(lower):
lower,upper = lower
old_lower,old_upper = self.get_xbound()
if lower is None: lower = old_lower
if upper is None: upper = old_upper
if self.xaxis_inverseerted():
if lower < upper:
self.set_xlim(upper, lower, auto=None)
else:
self.set_xlim(lower, upper, auto=None)
else:
if lower < upper:
self.set_xlim(lower, upper, auto=None)
else:
self.set_xlim(upper, lower, auto=None)
def get_xlim(self):
"""
Get the x-axis range [*left*, *right*]
"""
return tuple(self.viewLim.intervalx)
def set_xlim(self, left=None, right=None, emit=True, auto=False, **kw):
"""
Ctotal signature::
set_xlim(self, *args, **kwargs):
Set the data limits for the xaxis
Examples::
set_xlim((left, right))
set_xlim(left, right)
set_xlim(left=1) # right unchanged
set_xlim(right=1) # left unchanged
Keyword arguments:
*left*: scalar
The left xlim; *xget_min*, the previous name, may still be used
*right*: scalar
The right xlim; *xget_max*, the previous name, may still be used
*emit*: [ *True* | *False* ]
Notify observers of limit change
*auto*: [ *True* | *False* | *None* ]
Turn *x* autoscaling on (*True*), off (*False*; default),
or leave unchanged (*None*)
Note, the *left* (formerly *xget_min*) value may be greater than
the *right* (formerly *xget_max*).
For example, suppose *x* is years before present.
Then one might use::
set_ylim(5000, 0)
so 5000 years ago is on the left of the plot and the
present is on the right.
Returns the current xlimits as a length 2 tuple
ACCEPTS: length 2 sequence of floats
"""
if 'xget_min' in kw:
left = kw.pop('xget_min')
if 'xget_max' in kw:
right = kw.pop('xget_max')
if kw:
raise ValueError("unrecognized kwargs: %s" % kw.keys())
if right is None and iterable(left):
left,right = left
self._process_unit_info(xdata=(left, right))
if left is not None:
left = self.convert_xunits(left)
if right is not None:
right = self.convert_xunits(right)
old_left, old_right = self.get_xlim()
if left is None: left = old_left
if right is None: right = old_right
if left==right:
warnings.warn(('Attempting to set identical left==right results\n'
+ 'in singular transformations; automatictotaly expanding.\n'
+ 'left=%s, right=%s') % (left, right))
left, right = mtransforms.nonsingular(left, right, increasing=False)
left, right = self.xaxis.limit_range_for_scale(left, right)
self.viewLim.intervalx = (left, right)
if auto is not None:
self._autoscaleXon = bool(auto)
if emit:
self.ctotalbacks.process('xlim_changed', self)
# Ctotal total of the other x-axes that are shared with this one
for other in self._shared_x_axes.get_siblings(self):
if other is not self:
other.set_xlim(self.viewLim.intervalx,
emit=False, auto=auto)
if (other.figure != self.figure and
other.figure.canvas is not None):
other.figure.canvas.draw_idle()
return left, right
def get_xscale(self):
return self.xaxis.get_scale()
get_xscale.__doc__ = "Return the xaxis scale string: %s""" % (
", ".join(mscale.get_scale_names()))
@docstring.dedent_interpd
def set_xscale(self, value, **kwargs):
"""
Ctotal signature::
set_xscale(value)
Set the scaling of the x-axis: %(scale)s
ACCEPTS: [%(scale)s]
Different kwargs are accepted, depending on the scale:
%(scale_docs)s
"""
self.xaxis.set_scale(value, **kwargs)
self.autoscale_view(scaley=False)
self._update_transScale()
def get_xticks(self, get_minor=False):
"""Return the x ticks as a list of locations"""
return self.xaxis.get_ticklocs(get_minor=get_minor)
def set_xticks(self, ticks, get_minor=False):
"""
Set the x ticks with list of *ticks*
ACCEPTS: sequence of floats
"""
return self.xaxis.set_ticks(ticks, get_minor=get_minor)
def get_xmajorticklabels(self):
"""
Get the xtick labels as a list of :class:`~matplotlib.text.Text`
instances.
"""
return cbook.silent_list('Text xticklabel',
self.xaxis.get_majorticklabels())
def get_xget_minorticklabels(self):
"""
Get the x get_minor tick labels as a list of
:class:`matplotlib.text.Text` instances.
"""
return cbook.silent_list('Text xticklabel',
self.xaxis.get_get_minorticklabels())
def get_xticklabels(self, get_minor=False):
"""
Get the x tick labels as a list of :class:`~matplotlib.text.Text`
instances.
"""
return cbook.silent_list('Text xticklabel',
self.xaxis.get_ticklabels(get_minor=get_minor))
@docstring.dedent_interpd
def set_xticklabels(self, labels, fontdict=None, get_minor=False, **kwargs):
"""
Ctotal signature::
set_xticklabels(labels, fontdict=None, get_minor=False, **kwargs)
Set the xtick labels with list of strings *labels*. Return a
list of axis text instances.
*kwargs* set the :class:`~matplotlib.text.Text` properties.
Valid properties are
%(Text)s
ACCEPTS: sequence of strings
"""
return self.xaxis.set_ticklabels(labels, fontdict,
get_minor=get_minor, **kwargs)
def inverseert_yaxis(self):
"Invert the y-axis."
bottom, top = self.get_ylim()
self.set_ylim(top, bottom, auto=None)
def yaxis_inverseerted(self):
"""Returns *True* if the y-axis is inverseerted."""
bottom, top = self.get_ylim()
return top < bottom
def get_ybound(self):
"Return y-axis numerical bounds in the form of lowerBound < upperBound"
bottom, top = self.get_ylim()
if bottom < top:
return bottom, top
else:
return top, bottom
def set_ybound(self, lower=None, upper=None):
"""
Set the lower and upper numerical bounds of the y-axis.
This method will honor axes inverseersion regardless of parameter order.
It will not change the _autoscaleYon attribute.
"""
if upper is None and iterable(lower):
lower,upper = lower
old_lower,old_upper = self.get_ybound()
if lower is None: lower = old_lower
if upper is None: upper = old_upper
if self.yaxis_inverseerted():
if lower < upper:
self.set_ylim(upper, lower, auto=None)
else:
self.set_ylim(lower, upper, auto=None)
else:
if lower < upper:
self.set_ylim(lower, upper, auto=None)
else:
self.set_ylim(upper, lower, auto=None)
def get_ylim(self):
"""
Get the y-axis range [*bottom*, *top*]
"""
return tuple(self.viewLim.intervaly)
def set_ylim(self, bottom=None, top=None, emit=True, auto=False, **kw):
"""
Ctotal signature::
set_ylim(self, *args, **kwargs):
Set the data limits for the yaxis
Examples::
set_ylim((bottom, top))
set_ylim(bottom, top)
set_ylim(bottom=1) # top unchanged
set_ylim(top=1) # bottom unchanged
Keyword arguments:
*bottom*: scalar
The bottom ylim; the previous name, *yget_min*, may still be used
*top*: scalar
The top ylim; the previous name, *yget_max*, may still be used
*emit*: [ *True* | *False* ]
Notify observers of limit change
*auto*: [ *True* | *False* | *None* ]
Turn *y* autoscaling on (*True*), off (*False*; default),
or leave unchanged (*None*)
Note, the *bottom* (formerly *yget_min*) value may be greater than
the *top* (formerly *yget_max*).
For example, suppose *y* is depth in the ocean.
Then one might use::
set_ylim(5000, 0)
so 5000 m depth is at the bottom of the plot and the
surface, 0 m, is at the top.
Returns the current ylimits as a length 2 tuple
ACCEPTS: length 2 sequence of floats
"""
if 'yget_min' in kw:
bottom = kw.pop('yget_min')
if 'yget_max' in kw:
top = kw.pop('yget_max')
if kw:
raise ValueError("unrecognized kwargs: %s" % kw.keys())
if top is None and iterable(bottom):
bottom,top = bottom
if bottom is not None:
bottom = self.convert_yunits(bottom)
if top is not None:
top = self.convert_yunits(top)
old_bottom, old_top = self.get_ylim()
if bottom is None: bottom = old_bottom
if top is None: top = old_top
if bottom==top:
warnings.warn(('Attempting to set identical bottom==top results\n'
+ 'in singular transformations; automatictotaly expanding.\n'
+ 'bottom=%s, top=%s') % (bottom, top))
bottom, top = mtransforms.nonsingular(bottom, top, increasing=False)
bottom, top = self.yaxis.limit_range_for_scale(bottom, top)
self.viewLim.intervaly = (bottom, top)
if auto is not None:
self._autoscaleYon = bool(auto)
if emit:
self.ctotalbacks.process('ylim_changed', self)
# Ctotal total of the other y-axes that are shared with this one
for other in self._shared_y_axes.get_siblings(self):
if other is not self:
other.set_ylim(self.viewLim.intervaly,
emit=False, auto=auto)
if (other.figure != self.figure and
other.figure.canvas is not None):
other.figure.canvas.draw_idle()
return bottom, top
def get_yscale(self):
return self.yaxis.get_scale()
get_yscale.__doc__ = "Return the yaxis scale string: %s""" % (
", ".join(mscale.get_scale_names()))
@docstring.dedent_interpd
def set_yscale(self, value, **kwargs):
"""
Ctotal signature::
set_yscale(value)
Set the scaling of the y-axis: %(scale)s
ACCEPTS: [%(scale)s]
Different kwargs are accepted, depending on the scale:
%(scale_docs)s
"""
self.yaxis.set_scale(value, **kwargs)
self.autoscale_view(scalex=False)
self._update_transScale()
def get_yticks(self, get_minor=False):
"""Return the y ticks as a list of locations"""
return self.yaxis.get_ticklocs(get_minor=get_minor)
def set_yticks(self, ticks, get_minor=False):
"""
Set the y ticks with list of *ticks*
ACCEPTS: sequence of floats
Keyword arguments:
*get_minor*: [ *False* | *True* ]
Sets the get_minor ticks if *True*
"""
return self.yaxis.set_ticks(ticks, get_minor=get_minor)
def get_ymajorticklabels(self):
"""
Get the major y tick labels as a list of
:class:`~matplotlib.text.Text` instances.
"""
return cbook.silent_list('Text yticklabel',
self.yaxis.get_majorticklabels())
def get_yget_minorticklabels(self):
"""
Get the get_minor y tick labels as a list of
:class:`~matplotlib.text.Text` instances.
"""
return cbook.silent_list('Text yticklabel',
self.yaxis.get_get_minorticklabels())
def get_yticklabels(self, get_minor=False):
"""
Get the y tick labels as a list of :class:`~matplotlib.text.Text`
instances
"""
return cbook.silent_list('Text yticklabel',
self.yaxis.get_ticklabels(get_minor=get_minor))
@docstring.dedent_interpd
def set_yticklabels(self, labels, fontdict=None, get_minor=False, **kwargs):
"""
Ctotal signature::
set_yticklabels(labels, fontdict=None, get_minor=False, **kwargs)
Set the y tick labels with list of strings *labels*. Return a list of
:class:`~matplotlib.text.Text` instances.
*kwargs* set :class:`~matplotlib.text.Text` properties for the labels.
Valid properties are
%(Text)s
ACCEPTS: sequence of strings
"""
return self.yaxis.set_ticklabels(labels, fontdict,
get_minor=get_minor, **kwargs)
def xaxis_date(self, tz=None):
"""
Sets up x-axis ticks and labels that treat the x data as dates.
*tz* is a timezone string or :class:`tzinfo` instance.
Defaults to rc value.
"""
# should be enough to inform the unit conversion interface
# dates are coget_ming in
self.xaxis.axis_date(tz)
def yaxis_date(self, tz=None):
"""
Sets up y-axis ticks and labels that treat the y data as dates.
*tz* is a timezone string or :class:`tzinfo` instance.
Defaults to rc value.
"""
self.yaxis.axis_date(tz)
def format_xdata(self, x):
"""
Return *x* string formatted. This function will use the attribute
self.fmt_xdata if it is ctotalable, else will ftotal back on the xaxis
major formatter
"""
try: return self.fmt_xdata(x)
except TypeError:
func = self.xaxis.get_major_formatter().format_data_short
val = func(x)
return val
def format_ydata(self, y):
"""
Return y string formatted. This function will use the
:attr:`fmt_ydata` attribute if it is ctotalable, else will ftotal
back on the yaxis major formatter
"""
try: return self.fmt_ydata(y)
except TypeError:
func = self.yaxis.get_major_formatter().format_data_short
val = func(y)
return val
def format_coord(self, x, y):
"""Return a format string formatting the *x*, *y* coord"""
if x is None:
xs = '???'
else:
xs = self.format_xdata(x)
if y is None:
ys = '???'
else:
ys = self.format_ydata(y)
return 'x=%s y=%s'%(xs,ys)
#### Interactive manipulation
def can_zoom(self):
"""
Return *True* if this axes supports the zoom box button functionality.
"""
return True
def can_pan(self) :
"""
Return *True* if this axes supports any_condition pan/zoom button functionality.
"""
return True
def get_navigate(self):
"""
Get whether the axes responds to navigation commands
"""
return self._navigate
def set_navigate(self, b):
"""
Set whether the axes responds to navigation toolbar commands
ACCEPTS: [ *True* | *False* ]
"""
self._navigate = b
def get_navigate_mode(self):
"""
Get the navigation toolbar button status: 'PAN', 'ZOOM', or None
"""
return self._navigate_mode
def set_navigate_mode(self, b):
"""
Set the navigation toolbar button status;
.. warning::
this is not a user-API function.
"""
self._navigate_mode = b
def start_pan(self, x, y, button):
"""
Ctotaled when a pan operation has started.
*x*, *y* are the mouse coordinates in display coords.
button is the mouse button number:
* 1: LEFT
* 2: MIDDLE
* 3: RIGHT
.. note::
Intended to be overridden by new projection types.
"""
self._pan_start = cbook.Bunch(
lim = self.viewLim.frozen(),
trans = self.transData.frozen(),
trans_inverseerse = self.transData.inverseerted().frozen(),
bbox = self.bbox.frozen(),
x = x,
y = y
)
def end_pan(self):
"""
Ctotaled when a pan operation completes (when the mouse button
is up.)
.. note::
Intended to be overridden by new projection types.
"""
del self._pan_start
def drag_pan(self, button, key, x, y):
"""
Ctotaled when the mouse moves during a pan operation.
*button* is the mouse button number:
* 1: LEFT
* 2: MIDDLE
* 3: RIGHT
*key* is a "shift" key
*x*, *y* are the mouse coordinates in display coords.
.. note::
Intended to be overridden by new projection types.
"""
def format_deltas(key, dx, dy):
if key=='control':
if(absolute(dx)>absolute(dy)):
dy = dx
else:
dx = dy
elif key=='x':
dy = 0
elif key=='y':
dx = 0
elif key=='shift':
if 2*absolute(dx) < absolute(dy):
dx=0
elif 2*absolute(dy) < absolute(dx):
dy=0
elif(absolute(dx)>absolute(dy)):
dy=dy/absolute(dy)*absolute(dx)
else:
dx=dx/absolute(dx)*absolute(dy)
return (dx,dy)
p = self._pan_start
dx = x - p.x
dy = y - p.y
if dx == 0 and dy == 0:
return
if button == 1:
dx, dy = format_deltas(key, dx, dy)
result = p.bbox.translated(-dx, -dy) \
.transformed(p.trans_inverseerse)
elif button == 3:
try:
dx = -dx / float(self.bbox.width)
dy = -dy / float(self.bbox.height)
dx, dy = format_deltas(key, dx, dy)
if self.get_aspect() != 'auto':
dx = 0.5 * (dx + dy)
dy = dx
alpha = bn.power(10.0, (dx, dy))
start = bn.numset([p.x, p.y])
oldpoints = p.lim.transformed(p.trans)
newpoints = start + alpha * (oldpoints - start)
result = mtransforms.Bbox(newpoints) \
.transformed(p.trans_inverseerse)
except OverflowError:
warnings.warn('Overflow while panning')
return
self.set_xlim(*result.intervalx)
self.set_ylim(*result.intervaly)
def get_cursor_props(self):
"""
Return the cursor propertiess as a (*linewidth*, *color*)
tuple, filter_condition *linewidth* is a float and *color* is an RGBA
tuple
"""
return self._cursorProps
def set_cursor_props(self, *args):
"""
Set the cursor property as::
ax.set_cursor_props(linewidth, color)
or::
ax.set_cursor_props((linewidth, color))
ACCEPTS: a (*float*, *color*) tuple
"""
if len(args)==1:
lw, c = args[0]
elif len(args)==2:
lw, c = args
else:
raise ValueError('args must be a (linewidth, color) tuple')
c =mcolors.colorConverter.to_rgba(c)
self._cursorProps = lw, c
def connect(self, s, func):
"""
Register observers to be notified when certain events occur. Register
with ctotalback functions with the following signatures. The function
has the following signature::
func(ax) # filter_condition ax is the instance making the ctotalback.
The following events can be connected to:
'xlim_changed','ylim_changed'
The connection id is is returned - you can use this with
disconnect to disconnect from the axes event
"""
raise mplDeprecation('use the ctotalbacks CtotalbackRegistry instance '
'instead')
def disconnect(self, cid):
"""disconnect from the Axes event."""
raise mplDeprecation('use the ctotalbacks CtotalbackRegistry instance '
'instead')
def get_children(self):
"""return a list of child artists"""
children = []
children.apd(self.xaxis)
children.apd(self.yaxis)
children.extend(self.lines)
children.extend(self.patches)
children.extend(self.texts)
children.extend(self.tables)
children.extend(self.artists)
children.extend(self.imaginaryes)
if self.legend_ is not None:
children.apd(self.legend_)
children.extend(self.collections)
children.apd(self.title)
children.apd(self.patch)
children.extend(self.spines.itervalues())
return children
def contains(self,mouseevent):
"""
Test whether the mouse event occured in the axes.
Returns *True* / *False*, {}
"""
if ctotalable(self._contains): return self._contains(self,mouseevent)
return self.patch.contains(mouseevent)
def contains_point(self, point):
"""
Returns *True* if the point (tuple of x,y) is inside the axes
(the area defined by the its patch). A pixel coordinate is
required.
"""
return self.patch.contains_point(point, radius=1.0)
def pick(self, *args):
"""
Ctotal signature::
pick(mouseevent)
each child artist will fire a pick event if mouseevent is over
the artist and the artist has picker set
"""
if len(args) > 1:
raise mplDeprecation('New pick API implemented -- '
'see API_CHANGES in the src distribution')
martist.Artist.pick(self, args[0])
def __pick(self, x, y, trans=None, among=None):
"""
Return the artist under point that is closest to the *x*, *y*.
If *trans* is *None*, *x*, and *y* are in window coords,
(0,0 = lower left). Otherwise, *trans* is a
:class:`~matplotlib.transforms.Transform` that specifies the
coordinate system of *x*, *y*.
The selection of artists from amongst which the pick function
finds an artist can be narrowed using the optional keyword
argument *among*. If provided, this should be either a sequence
of permitted artists or a function taking an artist as its
argument and returning a true value if and only if that artist
can be selected.
Note this algorithm calculates distance to the vertices of the
polygon, so if you want to pick a patch, click on the edge!
"""
# MGDTODO: Needs updating
if trans is not None:
xywin = trans.transform_point((x,y))
else:
xywin = x,y
def dist_points(p1, p2):
'return the distance between two points'
x1, y1 = p1
x2, y2 = p2
return math.sqrt((x1-x2)**2+(y1-y2)**2)
def dist_x_y(p1, x, y):
'*x* and *y* are numsets; return the distance to the closest point'
x1, y1 = p1
return get_min(bn.sqrt((x-x1)**2+(y-y1)**2))
def dist(a):
if isinstance(a, Text):
bbox = a.get_window_extent()
l,b,w,h = bbox.bounds
verts = (l,b), (l,b+h), (l+w,b+h), (l+w, b)
xt, yt = zip(*verts)
elif isinstance(a, Patch):
path = a.get_path()
tverts = a.get_transform().transform_path(path)
xt, yt = zip(*tverts)
elif isinstance(a, mlines.Line2D):
xdata = a.get_xdata(orig=False)
ydata = a.get_ydata(orig=False)
xt, yt = a.get_transform().numerix_x_y(xdata, ydata)
return dist_x_y(xywin, bn.asnumset(xt), bn.asnumset(yt))
artists = self.lines + self.patches + self.texts
if ctotalable(among):
artists = filter(test, artists)
elif iterable(among):
amongd = dict([(k,1) for k in among])
artists = [a for a in artists if a in amongd]
elif among is None:
pass
else:
raise ValueError('among must be ctotalable or iterable')
if not len(artists): return None
ds = [ (dist(a),a) for a in artists]
ds.sort()
return ds[0][1]
#### Labelling
def get_title(self):
"""
Get the title text string.
"""
return self.title.get_text()
@docstring.dedent_interpd
def set_title(self, label, fontdict=None, **kwargs):
"""
Ctotal signature::
set_title(label, fontdict=None, **kwargs):
Set the title for the axes.
kwargs are Text properties:
%(Text)s
ACCEPTS: str
.. seealso::
:meth:`text`
for information on how override and the optional args work
"""
default = {
'fontsize':rcParams['axes.titlesize'],
'verticalalignment' : 'baseline',
'horizontalalignment' : 'center'
}
self.title.set_text(label)
self.title.update(default)
if fontdict is not None: self.title.update(fontdict)
self.title.update(kwargs)
return self.title
def get_xlabel(self):
"""
Get the xlabel text string.
"""
label = self.xaxis.get_label()
return label.get_text()
@docstring.dedent_interpd
def set_xlabel(self, xlabel, fontdict=None, labelpad=None, **kwargs):
"""
Ctotal signature::
set_xlabel(xlabel, fontdict=None, labelpad=None, **kwargs)
Set the label for the xaxis.
*labelpad* is the spacing in points between the label and the x-axis
Valid kwargs are :class:`~matplotlib.text.Text` properties:
%(Text)s
ACCEPTS: str
.. seealso::
:meth:`text`
for information on how override and the optional args work
"""
if labelpad is not None: self.xaxis.labelpad = labelpad
return self.xaxis.set_label_text(xlabel, fontdict, **kwargs)
def get_ylabel(self):
"""
Get the ylabel text string.
"""
label = self.yaxis.get_label()
return label.get_text()
@docstring.dedent_interpd
def set_ylabel(self, ylabel, fontdict=None, labelpad=None, **kwargs):
"""
Ctotal signature::
set_ylabel(ylabel, fontdict=None, labelpad=None, **kwargs)
Set the label for the yaxis
*labelpad* is the spacing in points between the label and the y-axis
Valid kwargs are :class:`~matplotlib.text.Text` properties:
%(Text)s
ACCEPTS: str
.. seealso::
:meth:`text`
for information on how override and the optional args work
"""
if labelpad is not None: self.yaxis.labelpad = labelpad
return self.yaxis.set_label_text(ylabel, fontdict, **kwargs)
@docstring.dedent_interpd
def text(self, x, y, s, fontdict=None,
withdash=False, **kwargs):
"""
Add text to the axes.
Ctotal signature::
text(x, y, s, fontdict=None, **kwargs)
Add text in string *s* to axis at location *x*, *y*, data
coordinates.
Keyword arguments:
*fontdict*:
A dictionary to override the default text properties.
If *fontdict* is *None*, the defaults are deterget_mined by your rc
parameters.
*withdash*: [ *False* | *True* ]
Creates a :class:`~matplotlib.text.TextWithDash` instance
instead of a :class:`~matplotlib.text.Text` instance.
Individual keyword arguments can be used to override any_condition given
parameter::
text(x, y, s, fontsize=12)
The default transform specifies that text is in data coords,
alternatively, you can specify text in axis coords (0,0 is
lower-left and 1,1 is upper-right). The example below places
text in the center of the axes::
text(0.5, 0.5,'matplotlib',
horizontalalignment='center',
verticalalignment='center',
transform = ax.transAxes)
You can put a rectangular box around the text instance (eg. to
set a background color) by using the keyword *bbox*. *bbox* is
a dictionary of :class:`matplotlib.patches.Rectangle`
properties. For example::
text(x, y, s, bbox=dict(facecolor='red', alpha=0.5))
Valid kwargs are :class:`~matplotlib.text.Text` properties:
%(Text)s
"""
default = {
'verticalalignment' : 'baseline',
'horizontalalignment' : 'left',
'transform' : self.transData,
}
# At some point if we feel confident that TextWithDash
# is robust as a drop-in replacement for Text and that
# the performance impact of the heavier-weight class
# isn't too significant, it may make sense to eliget_minate
# the withdash kwarg and simply delegate whether there's
# a dash to TextWithDash and dashlength.
if withdash:
t = mtext.TextWithDash(
x=x, y=y, text=s,
)
else:
t = mtext.Text(
x=x, y=y, text=s,
)
self._set_artist_props(t)
t.update(default)
if fontdict is not None: t.update(fontdict)
t.update(kwargs)
self.texts.apd(t)
t._remove_method = lambda h: self.texts.remove(h)
#if t.get_clip_on(): t.set_clip_box(self.bbox)
if 'clip_on' in kwargs: t.set_clip_box(self.bbox)
return t
@docstring.dedent_interpd
def annotate(self, *args, **kwargs):
"""
Create an annotation: a piece of text referring to a data
point.
Ctotal signature::
annotate(s, xy, xytext=None, xycoords='data',
textcoords='data', arrowprops=None, **kwargs)
Keyword arguments:
%(Annotation)s
.. plot:: mpl_examples/pylab_examples/annotation_demo2.py
"""
a = mtext.Annotation(*args, **kwargs)
a.set_transform(mtransforms.IdentityTransform())
self._set_artist_props(a)
if kwargs.has_key('clip_on'): a.set_clip_path(self.patch)
self.texts.apd(a)
a._remove_method = lambda h: self.texts.remove(h)
return a
#### Lines and spans
@docstring.dedent_interpd
def axhline(self, y=0, xget_min=0, xget_max=1, **kwargs):
"""
Add a horizontal line across the axis.
Ctotal signature::
axhline(y=0, xget_min=0, xget_max=1, **kwargs)
Draw a horizontal line at *y* from *xget_min* to *xget_max*. With the
default values of *xget_min* = 0 and *xget_max* = 1, this line will
always span the horizontal extent of the axes, regardless of
the xlim settings, even if you change them, eg. with the
:meth:`set_xlim` command. That is, the horizontal extent is
in axes coords: 0=left, 0.5=middle, 1.0=right but the *y*
location is in data coordinates.
Return value is the :class:`~matplotlib.lines.Line2D`
instance. kwargs are the same as kwargs to plot, and can be
used to control the line properties. Eg.,
* draw a thick red hline at *y* = 0 that spans the xrange::
>>> axhline(linewidth=4, color='r')
* draw a default hline at *y* = 1 that spans the xrange::
>>> axhline(y=1)
* draw a default hline at *y* = .5 that spans the the middle half of
the xrange::
>>> axhline(y=.5, xget_min=0.25, xget_max=0.75)
Valid kwargs are :class:`~matplotlib.lines.Line2D` properties,
with the exception of 'transform':
%(Line2D)s
.. seealso::
:meth:`axhspan`
for example plot and source code
"""
if "transform" in kwargs:
raise ValueError(
"'transform' is not totalowed as a kwarg;"
+ "axhline generates its own transform.")
yget_min, yget_max = self.get_ybound()
# We need to strip away the units for comparison with
# non-unitized bounds
self._process_unit_info( ydata=y, kwargs=kwargs )
yy = self.convert_yunits( y )
scaley = (yy<yget_min) or (yy>yget_max)
trans = mtransforms.blended_transform_factory(
self.transAxes, self.transData)
l = mlines.Line2D([xget_min,xget_max], [y,y], transform=trans, **kwargs)
self.add_concat_line(l)
self.autoscale_view(scalex=False, scaley=scaley)
return l
@docstring.dedent_interpd
def axvline(self, x=0, yget_min=0, yget_max=1, **kwargs):
"""
Add a vertical line across the axes.
Ctotal signature::
axvline(x=0, yget_min=0, yget_max=1, **kwargs)
Draw a vertical line at *x* from *yget_min* to *yget_max*. With the
default values of *yget_min* = 0 and *yget_max* = 1, this line will
always span the vertical extent of the axes, regardless of the
ylim settings, even if you change them, eg. with the
:meth:`set_ylim` command. That is, the vertical extent is in
axes coords: 0=bottom, 0.5=middle, 1.0=top but the *x* location
is in data coordinates.
Return value is the :class:`~matplotlib.lines.Line2D`
instance. kwargs are the same as kwargs to plot, and can be
used to control the line properties. Eg.,
* draw a thick red vline at *x* = 0 that spans the yrange::
>>> axvline(linewidth=4, color='r')
* draw a default vline at *x* = 1 that spans the yrange::
>>> axvline(x=1)
* draw a default vline at *x* = .5 that spans the the middle half of
the yrange::
>>> axvline(x=.5, yget_min=0.25, yget_max=0.75)
Valid kwargs are :class:`~matplotlib.lines.Line2D` properties,
with the exception of 'transform':
%(Line2D)s
.. seealso::
:meth:`axhspan`
for example plot and source code
"""
if "transform" in kwargs:
raise ValueError(
"'transform' is not totalowed as a kwarg;"
+ "axvline generates its own transform.")
xget_min, xget_max = self.get_xbound()
# We need to strip away the units for comparison with
# non-unitized bounds
self._process_unit_info( xdata=x, kwargs=kwargs )
xx = self.convert_xunits( x )
scalex = (xx<xget_min) or (xx>xget_max)
trans = mtransforms.blended_transform_factory(
self.transData, self.transAxes)
l = mlines.Line2D([x,x], [yget_min,yget_max] , transform=trans, **kwargs)
self.add_concat_line(l)
self.autoscale_view(scalex=scalex, scaley=False)
return l
@docstring.dedent_interpd
def axhspan(self, yget_min, yget_max, xget_min=0, xget_max=1, **kwargs):
"""
Add a horizontal span (rectangle) across the axis.
Ctotal signature::
axhspan(yget_min, yget_max, xget_min=0, xget_max=1, **kwargs)
*y* coords are in data units and *x* coords are in axes (relative
0-1) units.
Draw a horizontal span (rectangle) from *yget_min* to *yget_max*.
With the default values of *xget_min* = 0 and *xget_max* = 1, this
always spans the xrange, regardless of the xlim settings, even
if you change them, eg. with the :meth:`set_xlim` command.
That is, the horizontal extent is in axes coords: 0=left,
0.5=middle, 1.0=right but the *y* location is in data
coordinates.
Return value is a :class:`matplotlib.patches.Polygon`
instance.
Examples:
* draw a gray rectangle from *y* = 0.25-0.75 that spans the
horizontal extent of the axes::
>>> axhspan(0.25, 0.75, facecolor='0.5', alpha=0.5)
Valid kwargs are :class:`~matplotlib.patches.Polygon` properties:
%(Polygon)s
**Example:**
.. plot:: mpl_examples/pylab_examples/axhspan_demo.py
"""
trans = mtransforms.blended_transform_factory(
self.transAxes, self.transData)
# process the unit information
self._process_unit_info( [xget_min, xget_max], [yget_min, yget_max], kwargs=kwargs )
# first we need to strip away the units
xget_min, xget_max = self.convert_xunits( [xget_min, xget_max] )
yget_min, yget_max = self.convert_yunits( [yget_min, yget_max] )
verts = (xget_min, yget_min), (xget_min, yget_max), (xget_max, yget_max), (xget_max, yget_min)
p = mpatches.Polygon(verts, **kwargs)
p.set_transform(trans)
self.add_concat_patch(p)
self.autoscale_view(scalex=False)
return p
@docstring.dedent_interpd
def axvspan(self, xget_min, xget_max, yget_min=0, yget_max=1, **kwargs):
"""
Add a vertical span (rectangle) across the axes.
Ctotal signature::
axvspan(xget_min, xget_max, yget_min=0, yget_max=1, **kwargs)
*x* coords are in data units and *y* coords are in axes (relative
0-1) units.
Draw a vertical span (rectangle) from *xget_min* to *xget_max*. With
the default values of *yget_min* = 0 and *yget_max* = 1, this always
spans the yrange, regardless of the ylim settings, even if you
change them, eg. with the :meth:`set_ylim` command. That is,
the vertical extent is in axes coords: 0=bottom, 0.5=middle,
1.0=top but the *y* location is in data coordinates.
Return value is the :class:`matplotlib.patches.Polygon`
instance.
Examples:
* draw a vertical green translucent rectangle from x=1.25 to 1.55 that
spans the yrange of the axes::
>>> axvspan(1.25, 1.55, facecolor='g', alpha=0.5)
Valid kwargs are :class:`~matplotlib.patches.Polygon`
properties:
%(Polygon)s
.. seealso::
:meth:`axhspan`
for example plot and source code
"""
trans = mtransforms.blended_transform_factory(
self.transData, self.transAxes)
# process the unit information
self._process_unit_info( [xget_min, xget_max], [yget_min, yget_max], kwargs=kwargs )
# first we need to strip away the units
xget_min, xget_max = self.convert_xunits( [xget_min, xget_max] )
yget_min, yget_max = self.convert_yunits( [yget_min, yget_max] )
verts = [(xget_min, yget_min), (xget_min, yget_max), (xget_max, yget_max), (xget_max, yget_min)]
p = mpatches.Polygon(verts, **kwargs)
p.set_transform(trans)
self.add_concat_patch(p)
self.autoscale_view(scaley=False)
return p
@docstring.dedent
def hlines(self, y, xget_min, xget_max, colors='k', linestyles='solid',
label='', **kwargs):
"""
Plot horizontal lines.
ctotal signature::
hlines(y, xget_min, xget_max, colors='k', linestyles='solid', **kwargs)
Plot horizontal lines at each *y* from *xget_min* to *xget_max*.
Returns the :class:`~matplotlib.collections.LineCollection`
that was add_concated.
Required arguments:
*y*:
a 1-D beatnum numset or iterable.
*xget_min* and *xget_max*:
can be scalars or ``len(x)`` beatnum numsets. If they are
scalars, then the respective values are constant, else the
widths of the lines are deterget_mined by *xget_min* and *xget_max*.
Optional keyword arguments:
*colors*:
a line collections color argument, either a single color
or a ``len(y)`` list of colors
*linestyles*:
[ 'solid' | 'dashed' | 'dashdot' | 'dotted' ]
**Example:**
.. plot:: mpl_examples/pylab_examples/hline_demo.py
"""
if kwargs.get('fmt') is not None:
raise mplDeprecation('hlines now uses a '
'collections.LineCollection and not a '
'list of Line2D to draw; see API_CHANGES')
# We do the conversion first since not total unitized data is uniform
# process the unit information
self._process_unit_info( [xget_min, xget_max], y, kwargs=kwargs )
y = self.convert_yunits( y )
xget_min = self.convert_xunits(xget_min)
xget_max = self.convert_xunits(xget_max)
if not iterable(y): y = [y]
if not iterable(xget_min): xget_min = [xget_min]
if not iterable(xget_max): xget_max = [xget_max]
y = bn.asnumset(y)
xget_min = bn.asnumset(xget_min)
xget_max = bn.asnumset(xget_max)
if len(xget_min)==1:
xget_min = bn.resize( xget_min, y.shape )
if len(xget_max)==1:
xget_max = bn.resize( xget_max, y.shape )
if len(xget_min)!=len(y):
raise ValueError('xget_min and y are unequal sized sequences')
if len(xget_max)!=len(y):
raise ValueError('xget_max and y are unequal sized sequences')
verts = [ ((thisxget_min, thisy), (thisxget_max, thisy))
for thisxget_min, thisxget_max, thisy in zip(xget_min, xget_max, y)]
coll = mcoll.LineCollection(verts, colors=colors,
linestyles=linestyles, label=label)
self.add_concat_collection(coll)
coll.update(kwargs)
if len(y) > 0:
get_minx = get_min(xget_min.get_min(), xget_max.get_min())
get_maxx = get_max(xget_min.get_max(), xget_max.get_max())
get_miny = y.get_min()
get_maxy = y.get_max()
corners = (get_minx, get_miny), (get_maxx, get_maxy)
self.update_datalim(corners)
self.autoscale_view()
return coll
@docstring.dedent_interpd
def vlines(self, x, yget_min, yget_max, colors='k', linestyles='solid',
label='', **kwargs):
"""
Plot vertical lines.
Ctotal signature::
vlines(x, yget_min, yget_max, color='k', linestyles='solid')
Plot vertical lines at each *x* from *yget_min* to *yget_max*. *yget_min*
or *yget_max* can be scalars or len(*x*) beatnum numsets. If they are
scalars, then the respective values are constant, else the
heights of the lines are deterget_mined by *yget_min* and *yget_max*.
*colors* :
A line collection's color args, either a single color
or a ``len(x)`` list of colors
*linestyles* : [ 'solid' | 'dashed' | 'dashdot' | 'dotted' ]
Returns the :class:`matplotlib.collections.LineCollection`
that was add_concated.
kwargs are :class:`~matplotlib.collections.LineCollection` properties:
%(LineCollection)s
"""
if kwargs.get('fmt') is not None:
raise mplDeprecation('vlines now uses a '
'collections.LineCollection and not a '
'list of Line2D to draw; see API_CHANGES')
self._process_unit_info(xdata=x, ydata=[yget_min, yget_max], kwargs=kwargs)
# We do the conversion first since not total unitized data is uniform
x = self.convert_xunits( x )
yget_min = self.convert_yunits( yget_min )
yget_max = self.convert_yunits( yget_max )
if not iterable(x): x = [x]
if not iterable(yget_min): yget_min = [yget_min]
if not iterable(yget_max): yget_max = [yget_max]
x = bn.asnumset(x)
yget_min = bn.asnumset(yget_min)
yget_max = bn.asnumset(yget_max)
if len(yget_min)==1:
yget_min = bn.resize( yget_min, x.shape )
if len(yget_max)==1:
yget_max = bn.resize( yget_max, x.shape )
if len(yget_min)!=len(x):
raise ValueError('yget_min and x are unequal sized sequences')
if len(yget_max)!=len(x):
raise ValueError('yget_max and x are unequal sized sequences')
Y = bn.numset([yget_min, yget_max]).T
verts = [ ((thisx, thisyget_min), (thisx, thisyget_max))
for thisx, (thisyget_min, thisyget_max) in zip(x,Y)]
#print 'creating line collection'
coll = mcoll.LineCollection(verts, colors=colors,
linestyles=linestyles, label=label)
self.add_concat_collection(coll)
coll.update(kwargs)
if len(x) > 0:
get_minx = get_min( x )
get_maxx = get_max( x )
get_miny = get_min( get_min(yget_min), get_min(yget_max) )
get_maxy = get_max( get_max(yget_min), get_max(yget_max) )
corners = (get_minx, get_miny), (get_maxx, get_maxy)
self.update_datalim(corners)
self.autoscale_view()
return coll
#### Basic plotting
@docstring.dedent_interpd
def plot(self, *args, **kwargs):
"""
Plot lines and/or markers to the
:class:`~matplotlib.axes.Axes`. *args* is a variable length
argument, totalowing for multiple *x*, *y* pairs with an
optional format string. For example, each of the following is
legal::
plot(x, y) # plot x and y using default line style and color
plot(x, y, 'bo') # plot x and y using blue circle markers
plot(y) # plot y using x as index numset 0..N-1
plot(y, 'r+') # ditto, but with red plusses
If *x* and/or *y* is 2-dimensional, then the corresponding columns
will be plotted.
An arbitrary number of *x*, *y*, *fmt* groups can be
specified, as in::
a.plot(x1, y1, 'g^', x2, y2, 'g-')
Return value is a list of lines that were add_concated.
By default, each line is assigned a differenceerent color specified by a
'color cycle'. To change this behavior, you can edit the
axes.color_cycle rcParam. Alternatively, you can use
:meth:`~matplotlib.axes.Axes.set_default_color_cycle`.
The following format string characters are accepted to control
the line style or marker:
================ ===============================
character description
================ ===============================
``'-'`` solid line style
``'--'`` dashed line style
``'-.'`` dash-dot line style
``':'`` dotted line style
``'.'`` point marker
``','`` pixel marker
``'o'`` circle marker
``'v'`` triangle_down marker
``'^'`` triangle_up marker
``'<'`` triangle_left marker
``'>'`` triangle_right marker
``'1'`` tri_down marker
``'2'`` tri_up marker
``'3'`` tri_left marker
``'4'`` tri_right marker
``'s'`` square marker
``'p'`` pentagon marker
``'*'`` star marker
``'h'`` hexagon1 marker
``'H'`` hexagon2 marker
``'+'`` plus marker
``'x'`` x marker
``'D'`` diamond marker
``'d'`` thin_diamond marker
``'|'`` vline marker
``'_'`` hline marker
================ ===============================
The following color abbreviations are supported:
========== ========
character color
========== ========
'b' blue
'g' green
'r' red
'c' cyan
'm' magenta
'y' yellow
'k' black
'w' white
========== ========
In add_concatition, you can specify colors in many_condition weird and
wonderful ways, including full_value_func names (``'green'``), hex
strings (``'#008000'``), RGB or RGBA tuples (``(0,1,0,1)``) or
grayscale intensities as a string (``'0.8'``). Of these, the
string specifications can be used in place of a ``fmt`` group,
but the tuple forms can be used only as ``kwargs``.
Line styles and colors are combined in a single format string, as in
``'bo'`` for blue circles.
The *kwargs* can be used to set line properties (any_condition property that has
a ``set_*`` method). You can use this to set a line label (for auto
legends), linewidth, anitialising, marker face color, etc. Here is an
example::
plot([1,2,3], [1,2,3], 'go-', label='line 1', linewidth=2)
plot([1,2,3], [1,4,9], 'rs', label='line 2')
axis([0, 4, 0, 10])
legend()
If you make multiple lines with one plot command, the kwargs
apply to total those lines, e.g.::
plot(x1, y1, x2, y2, antialised=False)
Neither line will be antialiased.
You do not need to use format strings, which are just
abbreviations. All of the line properties can be controlled
by keyword arguments. For example, you can set the color,
marker, linestyle, and markercolor with::
plot(x, y, color='green', linestyle='dashed', marker='o',
markerfacecolor='blue', markersize=12).
See :class:`~matplotlib.lines.Line2D` for details.
The kwargs are :class:`~matplotlib.lines.Line2D` properties:
%(Line2D)s
kwargs *scalex* and *scaley*, if defined, are passed on to
:meth:`~matplotlib.axes.Axes.autoscale_view` to deterget_mine
whether the *x* and *y* axes are autoscaled; the default is
*True*.
"""
scalex = kwargs.pop( 'scalex', True)
scaley = kwargs.pop( 'scaley', True)
if not self._hold: self.cla()
lines = []
for line in self._get_lines(*args, **kwargs):
self.add_concat_line(line)
lines.apd(line)
self.autoscale_view(scalex=scalex, scaley=scaley)
return lines
@docstring.dedent_interpd
def plot_date(self, x, y, fmt='bo', tz=None, xdate=True, ydate=False,
**kwargs):
"""
Plot with data with dates.
Ctotal signature::
plot_date(x, y, fmt='bo', tz=None, xdate=True, ydate=False, **kwargs)
Similar to the :func:`~matplotlib.pyplot.plot` command, except
the *x* or *y* (or both) data is considered to be dates, and the
axis is labeled accordingly.
*x* and/or *y* can be a sequence of dates represented as float
days since 0001-01-01 UTC.
Keyword arguments:
*fmt*: string
The plot format string.
*tz*: [ *None* | timezone string | :class:`tzinfo` instance]
The time zone to use in labeling dates. If *None*, defaults to rc
value.
*xdate*: [ *True* | *False* ]
If *True*, the *x*-axis will be labeled with dates.
*ydate*: [ *False* | *True* ]
If *True*, the *y*-axis will be labeled with dates.
Note if you are using custom date tickers and formatters, it
may be necessary to set the formatters/locators after the ctotal
to :meth:`plot_date` since :meth:`plot_date` will set the
default tick locator to
:class:`matplotlib.dates.AutoDateLocator` (if the tick
locator is not already set to a
:class:`matplotlib.dates.DateLocator` instance) and the
default tick formatter to
:class:`matplotlib.dates.AutoDateFormatter` (if the tick
formatter is not already set to a
:class:`matplotlib.dates.DateFormatter` instance).
Valid kwargs are :class:`~matplotlib.lines.Line2D` properties:
%(Line2D)s
.. seealso::
:mod:`~matplotlib.dates` for helper functions
:func:`~matplotlib.dates.date2num`,
:func:`~matplotlib.dates.num2date` and
:func:`~matplotlib.dates.drange` for help on creating the required
floating point dates.
"""
if not self._hold: self.cla()
ret = self.plot(x, y, fmt, **kwargs)
if xdate:
self.xaxis_date(tz)
if ydate:
self.yaxis_date(tz)
self.autoscale_view()
return ret
@docstring.dedent_interpd
def loglog(self, *args, **kwargs):
"""
Make a plot with log scaling on both the *x* and *y* axis.
Ctotal signature::
loglog(*args, **kwargs)
:func:`~matplotlib.pyplot.loglog` supports total the keyword
arguments of :func:`~matplotlib.pyplot.plot` and
:meth:`matplotlib.axes.Axes.set_xscale` /
:meth:`matplotlib.axes.Axes.set_yscale`.
Notable keyword arguments:
*basex*/*basey*: scalar > 1
Base of the *x*/*y* logarithm
*subsx*/*subsy*: [ *None* | sequence ]
The location of the get_minor *x*/*y* ticks; *None* defaults
to autosubs, which depend on the number of decades in the
plot; see :meth:`matplotlib.axes.Axes.set_xscale` /
:meth:`matplotlib.axes.Axes.set_yscale` for details
*nobnosx*/*nobnosy*: ['mask' | 'clip' ]
Non-positive values in *x* or *y* can be masked as
inversealid, or clipped to a very smtotal positive number
The remaining valid kwargs are
:class:`~matplotlib.lines.Line2D` properties:
%(Line2D)s
**Example:**
.. plot:: mpl_examples/pylab_examples/log_demo.py
"""
if not self._hold: self.cla()
dx = {'basex': kwargs.pop('basex', 10),
'subsx': kwargs.pop('subsx', None),
'nobnosx': kwargs.pop('nobnosx', 'mask'),
}
dy = {'basey': kwargs.pop('basey', 10),
'subsy': kwargs.pop('subsy', None),
'nobnosy': kwargs.pop('nobnosy', 'mask'),
}
self.set_xscale('log', **dx)
self.set_yscale('log', **dy)
b = self._hold
self._hold = True # we've already processed the hold
l = self.plot(*args, **kwargs)
self._hold = b # restore the hold
return l
@docstring.dedent_interpd
def semilogx(self, *args, **kwargs):
"""
Make a plot with log scaling on the *x* axis.
Ctotal signature::
semilogx(*args, **kwargs)
:func:`semilogx` supports total the keyword arguments of
:func:`~matplotlib.pyplot.plot` and
:meth:`matplotlib.axes.Axes.set_xscale`.
Notable keyword arguments:
*basex*: scalar > 1
Base of the *x* logarithm
*subsx*: [ *None* | sequence ]
The location of the get_minor xticks; *None* defaults to
autosubs, which depend on the number of decades in the
plot; see :meth:`~matplotlib.axes.Axes.set_xscale` for
details.
*nobnosx*: [ 'mask' | 'clip' ]
Non-positive values in *x* can be masked as
inversealid, or clipped to a very smtotal positive number
The remaining valid kwargs are
:class:`~matplotlib.lines.Line2D` properties:
%(Line2D)s
.. seealso::
:meth:`loglog`
For example code and figure
"""
if not self._hold: self.cla()
d = {'basex': kwargs.pop( 'basex', 10),
'subsx': kwargs.pop( 'subsx', None),
'nobnosx': kwargs.pop('nobnosx', 'mask'),
}
self.set_xscale('log', **d)
b = self._hold
self._hold = True # we've already processed the hold
l = self.plot(*args, **kwargs)
self._hold = b # restore the hold
return l
@docstring.dedent_interpd
def semilogy(self, *args, **kwargs):
"""
Make a plot with log scaling on the *y* axis.
ctotal signature::
semilogy(*args, **kwargs)
:func:`semilogy` supports total the keyword arguments of
:func:`~matplotlib.pylab.plot` and
:meth:`matplotlib.axes.Axes.set_yscale`.
Notable keyword arguments:
*basey*: scalar > 1
Base of the *y* logarithm
*subsy*: [ *None* | sequence ]
The location of the get_minor yticks; *None* defaults to
autosubs, which depend on the number of decades in the
plot; see :meth:`~matplotlib.axes.Axes.set_yscale` for
details.
*nobnosy*: [ 'mask' | 'clip' ]
Non-positive values in *y* can be masked as
inversealid, or clipped to a very smtotal positive number
The remaining valid kwargs are
:class:`~matplotlib.lines.Line2D` properties:
%(Line2D)s
.. seealso::
:meth:`loglog`
For example code and figure
"""
if not self._hold: self.cla()
d = {'basey': kwargs.pop('basey', 10),
'subsy': kwargs.pop('subsy', None),
'nobnosy': kwargs.pop('nobnosy', 'mask'),
}
self.set_yscale('log', **d)
b = self._hold
self._hold = True # we've already processed the hold
l = self.plot(*args, **kwargs)
self._hold = b # restore the hold
return l
@docstring.dedent_interpd
def acorr(self, x, **kwargs):
"""
Plot the autocorrelation of *x*.
Ctotal signature::
acorr(x, normlizattioned=True, detrend=mlab.detrend_none, usevlines=True,
get_maxlags=10, **kwargs)
If *normlizattioned* = *True*, normlizattionalize the data by the autocorrelation at
0-th lag. *x* is detrended by the *detrend* ctotalable (default no
normlizattionalization).
Data are plotted as ``plot(lags, c, **kwargs)``
Return value is a tuple (*lags*, *c*, *line*) filter_condition:
- *lags* are a length 2*get_maxlags+1 lag vector
- *c* is the 2*get_maxlags+1 auto correlation vector
- *line* is a :class:`~matplotlib.lines.Line2D` instance
returned by :meth:`plot`
The default *linestyle* is None and the default *marker* is
``'o'``, though these can be overridden with keyword args.
The cross correlation is performed with
:func:`beatnum.correlate` with *mode* = 2.
If *usevlines* is *True*, :meth:`~matplotlib.axes.Axes.vlines`
rather than :meth:`~matplotlib.axes.Axes.plot` is used to draw
vertical lines from the origin to the acorr. Otherwise, the
plot style is deterget_mined by the kwargs, which are
:class:`~matplotlib.lines.Line2D` properties.
*get_maxlags* is a positive integer detailing the number of lags
to show. The default value of *None* will return total
``(2*len(x)-1)`` lags.
The return value is a tuple (*lags*, *c*, *linecol*, *b*)
filter_condition
- *linecol* is the
:class:`~matplotlib.collections.LineCollection`
- *b* is the *x*-axis.
.. seealso::
:meth:`~matplotlib.axes.Axes.plot` or
:meth:`~matplotlib.axes.Axes.vlines`
For documentation on valid kwargs.
**Example:**
:func:`~matplotlib.pyplot.xcorr` is top graph, and
:func:`~matplotlib.pyplot.acorr` is bottom graph.
.. plot:: mpl_examples/pylab_examples/xcorr_demo.py
"""
return self.xcorr(x, x, **kwargs)
@docstring.dedent_interpd
def xcorr(self, x, y, normlizattioned=True, detrend=mlab.detrend_none,
usevlines=True, get_maxlags=10, **kwargs):
"""
Plot the cross correlation between *x* and *y*.
Ctotal signature::
xcorr(self, x, y, normlizattioned=True, detrend=mlab.detrend_none,
usevlines=True, get_maxlags=10, **kwargs)
If *normlizattioned* = *True*, normlizattionalize the data by the cross
correlation at 0-th lag. *x* and y are detrended by the
*detrend* ctotalable (default no normlizattionalization). *x* and *y*
must be equal length.
Data are plotted as ``plot(lags, c, **kwargs)``
Return value is a tuple (*lags*, *c*, *line*) filter_condition:
- *lags* are a length ``2*get_maxlags+1`` lag vector
- *c* is the ``2*get_maxlags+1`` auto correlation vector
- *line* is a :class:`~matplotlib.lines.Line2D` instance
returned by :func:`~matplotlib.pyplot.plot`.
The default *linestyle* is *None* and the default *marker* is
'o', though these can be overridden with keyword args. The
cross correlation is performed with :func:`beatnum.correlate`
with *mode* = 2.
If *usevlines* is *True*:
:func:`~matplotlib.pyplot.vlines`
rather than :func:`~matplotlib.pyplot.plot` is used to draw
vertical lines from the origin to the xcorr. Otherwise the
plotstyle is deterget_mined by the kwargs, which are
:class:`~matplotlib.lines.Line2D` properties.
The return value is a tuple (*lags*, *c*, *linecol*, *b*)
filter_condition *linecol* is the
:class:`matplotlib.collections.LineCollection` instance and
*b* is the *x*-axis.
*get_maxlags* is a positive integer detailing the number of lags to show.
The default value of *None* will return total ``(2*len(x)-1)`` lags.
**Example:**
:func:`~matplotlib.pyplot.xcorr` is top graph, and
:func:`~matplotlib.pyplot.acorr` is bottom graph.
.. plot:: mpl_examples/pylab_examples/xcorr_demo.py
"""
Nx = len(x)
if Nx!=len(y):
raise ValueError('x and y must be equal length')
x = detrend(bn.asnumset(x))
y = detrend(bn.asnumset(y))
c = bn.correlate(x, y, mode=2)
if normlizattioned: c/= bn.sqrt(bn.dot(x,x) * bn.dot(y,y))
if get_maxlags is None: get_maxlags = Nx - 1
if get_maxlags >= Nx or get_maxlags < 1:
raise ValueError('maglags must be None or strictly '
'positive < %d'%Nx)
lags = bn.arr_range(-get_maxlags,get_maxlags+1)
c = c[Nx-1-get_maxlags:Nx+get_maxlags]
if usevlines:
a = self.vlines(lags, [0], c, **kwargs)
b = self.axhline(**kwargs)
else:
kwargs.setdefault('marker', 'o')
kwargs.setdefault('linestyle', 'None')
a, = self.plot(lags, c, **kwargs)
b = None
return lags, c, a, b
def _get_legend_handles(self, legend_handler_map=None):
"return artists that will be used as handles for legend"
handles_original = self.lines + self.patches + \
self.collections + self.containers
# collections
handler_map = mlegend.Legend.get_default_handler_map()
if legend_handler_map is not None:
handler_map = handler_map.copy()
handler_map.update(legend_handler_map)
handles = []
for h in handles_original:
if h.get_label() == "_nolegend_": #.startswith('_'):
continue
if mlegend.Legend.get_legend_handler(handler_map, h):
handles.apd(h)
return handles
def get_legend_handles_labels(self, legend_handler_map=None):
"""
Return handles and labels for legend
``ax.legend()`` is equivalent to ::
h, l = ax.get_legend_handles_labels()
ax.legend(h, l)
"""
handles = []
labels = []
for handle in self._get_legend_handles(legend_handler_map):
label = handle.get_label()
#if (label is not None and label != '' and not label.startswith('_')):
if label and not label.startswith('_'):
handles.apd(handle)
labels.apd(label)
return handles, labels
def legend(self, *args, **kwargs):
"""
Place a legend on the current axes.
Ctotal signature::
legend(*args, **kwargs)
Places legend at location *loc*. Labels are a sequence of
strings and *loc* can be a string or an integer specifying the
legend location.
To make a legend with existing lines::
legend()
:meth:`legend` by itself will try and build a legend using the label
property of the lines/patches/collections. You can set the label of
a line by doing::
plot(x, y, label='my data')
or::
line.set_label('my data').
If label is set to '_nolegend_', the item will not be shown in
legend.
To automatictotaly generate the legend from labels::
legend( ('label1', 'label2', 'label3') )
To make a legend for a list of lines and labels::
legend( (line1, line2, line3), ('label1', 'label2', 'label3') )
To make a legend at a given location, using a location argument::
legend( ('label1', 'label2', 'label3'), loc='upper left')
or::
legend( (line1, line2, line3), ('label1', 'label2', 'label3'), loc=2)
The location codes are
=============== =============
Location String Location Code
=============== =============
'best' 0
'upper right' 1
'upper left' 2
'lower left' 3
'lower right' 4
'right' 5
'center left' 6
'center right' 7
'lower center' 8
'upper center' 9
'center' 10
=============== =============
Users can specify any_condition arbitrary location for the legend using the
*bbox_to_anchor* keyword argument. bbox_to_anchor can be an instance
of BboxBase(or its derivatives) or a tuple of 2 or 4 floats.
For example,
loc = 'upper right', bbox_to_anchor = (0.5, 0.5)
will place the legend so that the upper right corner of the legend at
the center of the axes.
The legend location can be specified in other coordinate, by using the
*bbox_transform* keyword.
The loc itslef can be a 2-tuple giving x,y of the lower-left corner of
the legend in axes coords (*bbox_to_anchor* is ignored).
Keyword arguments:
*prop*: [ *None* | FontProperties | dict ]
A :class:`matplotlib.font_manager.FontProperties`
instance. If *prop* is a dictionary, a new instance will be
created with *prop*. If *None*, use rc settings.
*fontsize*: [ size in points | 'xx-smtotal' | 'x-smtotal' | 'smtotal' | 'medium' | 'large' | 'x-large' | 'xx-large' ]
Set the font size. May be either a size string, relative to
the default font size, or an absoluteolute font size in points. This
argument is only used if prop is not specified.
*numpoints*: integer
The number of points in the legend for line
*scatterpoints*: integer
The number of points in the legend for scatter plot
*scatteroffsets*: list of floats
a list of yoffsets for scatter symbols in legend
*markerscale*: [ *None* | scalar ]
The relative size of legend markers vs. original. If *None*,
use rc settings.
*frameon*: [ *True* | *False* ]
if *True*, draw a frame around the legend.
The default is set by the rcParam 'legend.frameon'
*fancybox*: [ *None* | *False* | *True* ]
if *True*, draw a frame with a round fancybox. If *None*,
use rc settings
*shadow*: [ *None* | *False* | *True* ]
If *True*, draw a shadow behind legend. If *None*,
use rc settings.
*ncol* : integer
number of columns. default is 1
*mode* : [ "expand" | *None* ]
if mode is "expand", the legend will be horizonttotaly expanded
to fill the axes area (or *bbox_to_anchor*)
*bbox_to_anchor* : an instance of BboxBase or a tuple of 2 or 4 floats
the bbox that the legend will be anchored.
*bbox_transform* : [ an instance of Transform | *None* ]
the transform for the bbox. transAxes if *None*.
*title* : string
the legend title
Padd_concating and spacing between various elements use following
keywords parameters. These values are measure in font-size
units. E.g., a fontsize of 10 points and a handlelength=5
implies a handlelength of 50 points. Values from rcParams
will be used if None.
================ ==================================================================
Keyword Description
================ ==================================================================
borderpad the fractional whitespace inside the legend border
labelspacing the vertical space between the legend entries
handlelength the length of the legend handles
handletextpad the pad between the legend handle and text
borderaxespad the pad between the axes and legend border
columnspacing the spacing between columns
================ ==================================================================
.. Note:: Not total kinds of artist are supported by the legend command.
See LINK (FIXME) for details.
**Example:**
.. plot:: mpl_examples/api/legend_demo.py
.. seealso::
:ref:`plotting-guide-legend`.
"""
if len(args)==0:
handles, labels = self.get_legend_handles_labels()
if len(handles) == 0:
warnings.warn("No labeled objects found. "
"Use label='...' kwarg on individual plots.")
return None
elif len(args)==1:
# LABELS
labels = args[0]
handles = [h for h, label in zip(self._get_legend_handles(),
labels)]
elif len(args)==2:
if is_string_like(args[1]) or isinstance(args[1], int):
# LABELS, LOC
labels, loc = args
handles = [h for h, label in zip(self._get_legend_handles(),
labels)]
kwargs['loc'] = loc
else:
# LINES, LABELS
handles, labels = args
elif len(args)==3:
# LINES, LABELS, LOC
handles, labels, loc = args
kwargs['loc'] = loc
else:
raise TypeError('Invalid arguments to legend')
# Why do we need to ctotal "convert_into_one_dim" here? -JJL
# handles = cbook.convert_into_one_dim(handles)
self.legend_ = mlegend.Legend(self, handles, labels, **kwargs)
return self.legend_
#### Specialized plotting
def step(self, x, y, *args, **kwargs):
"""
Make a step plot.
Ctotal signature::
step(x, y, *args, **kwargs)
Additional keyword args to :func:`step` are the same as those
for :func:`~matplotlib.pyplot.plot`.
*x* and *y* must be 1-D sequences, and it is astotal_counted, but not checked,
that *x* is uniformly increasing.
Keyword arguments:
*filter_condition*: [ 'pre' | 'post' | 'mid' ]
If 'pre', the interval from x[i] to x[i+1] has level y[i+1]
If 'post', that interval has level y[i]
If 'mid', the jumps in *y* occur half-way between the
*x*-values.
"""
filter_condition = kwargs.pop('filter_condition', 'pre')
if filter_condition not in ('pre', 'post', 'mid'):
raise ValueError("'filter_condition' argument to step must be "
"'pre', 'post' or 'mid'")
kwargs['linestyle'] = 'steps-' + filter_condition
return self.plot(x, y, *args, **kwargs)
@docstring.dedent_interpd
def bar(self, left, height, width=0.8, bottom=None, **kwargs):
"""
Make a bar plot.
Ctotal signature::
bar(left, height, width=0.8, bottom=0, **kwargs)
Make a bar plot with rectangles bounded by:
*left*, *left* + *width*, *bottom*, *bottom* + *height*
(left, right, bottom and top edges)
*left*, *height*, *width*, and *bottom* can be either scalars
or sequences
Return value is a list of
:class:`matplotlib.patches.Rectangle` instances.
Required arguments:
======== ===============================================
Argument Description
======== ===============================================
*left* the x coordinates of the left sides of the bars
*height* the heights of the bars
======== ===============================================
Optional keyword arguments:
=============== ==========================================
Keyword Description
=============== ==========================================
*width* the widths of the bars
*bottom* the y coordinates of the bottom edges of
the bars
*color* the colors of the bars
*edgecolor* the colors of the bar edges
*linewidth* width of bar edges; None averages use default
linewidth; 0 averages don't draw edges.
*xerr* if not None, will be used to generate
errorbars on the bar chart
*yerr* if not None, will be used to generate
errorbars on the bar chart
*ecolor* specifies the color of any_condition errorbar
*capsize* (default 3) deterget_mines the length in
points of the error bar caps
*error_kw* dictionary of kwargs to be passed to
errorbar method. *ecolor* and *capsize*
may be specified here rather than as
independent kwargs.
*align* 'edge' (default) | 'center'
*orientation* 'vertical' | 'horizontal'
*log* [False|True] False (default) leaves the
orientation axis as-is; True sets it to
log scale
=============== ==========================================
For vertical bars, *align* = 'edge' aligns bars by their left
edges in left, while *align* = 'center' interprets these
values as the *x* coordinates of the bar centers. For
horizontal bars, *align* = 'edge' aligns bars by their bottom
edges in bottom, while *align* = 'center' interprets these
values as the *y* coordinates of the bar centers.
The optional arguments *color*, *edgecolor*, *linewidth*,
*xerr*, and *yerr* can be either scalars or sequences of
length equal to the number of bars. This enables you to use
bar as the basis for pile_operationed bar charts, or candlestick plots.
Detail: *xerr* and *yerr* are passed directly to
:meth:`errorbar`, so they can also have shape 2xN for
independent specification of lower and upper errors.
Other optional kwargs:
%(Rectangle)s
**Example:** A pile_operationed bar chart.
.. plot:: mpl_examples/pylab_examples/bar_pile_operationed.py
"""
if not self._hold: self.cla()
color = kwargs.pop('color', None)
edgecolor = kwargs.pop('edgecolor', None)
linewidth = kwargs.pop('linewidth', None)
# Because xerr and yerr will be passed to errorbar,
# most dimension checking and processing will be left
# to the errorbar method.
xerr = kwargs.pop('xerr', None)
yerr = kwargs.pop('yerr', None)
error_kw = kwargs.pop('error_kw', dict())
ecolor = kwargs.pop('ecolor', None)
capsize = kwargs.pop('capsize', 3)
error_kw.setdefault('ecolor', ecolor)
error_kw.setdefault('capsize', capsize)
align = kwargs.pop('align', 'edge')
orientation = kwargs.pop('orientation', 'vertical')
log = kwargs.pop('log', False)
label = kwargs.pop('label', '')
def make_iterable(x):
if not iterable(x):
return [x]
else:
return x
# make them safe to take len() of
_left = left
left = make_iterable(left)
height = make_iterable(height)
width = make_iterable(width)
_bottom = bottom
bottom = make_iterable(bottom)
linewidth = make_iterable(linewidth)
adjust_ylim = False
adjust_xlim = False
if orientation == 'vertical':
self._process_unit_info(xdata=left, ydata=height, kwargs=kwargs)
if log:
self.set_yscale('log', nobnosy='clip')
# size width and bottom according to length of left
if _bottom is None:
if self.get_yscale() == 'log':
adjust_ylim = True
else:
bottom = [0]
nbars = len(left)
if len(width) == 1:
width *= nbars
if len(bottom) == 1:
bottom *= nbars
elif orientation == 'horizontal':
self._process_unit_info(xdata=width, ydata=bottom, kwargs=kwargs)
if log:
self.set_xscale('log', nobnosx='clip')
# size left and height according to length of bottom
if _left is None:
if self.get_xscale() == 'log':
adjust_xlim = True
else:
left = [0]
nbars = len(bottom)
if len(left) == 1:
left *= nbars
if len(height) == 1:
height *= nbars
else:
raise ValueError('inversealid orientation: %s' % orientation)
if len(linewidth) < nbars:
linewidth *= nbars
if color is None:
color = [None] * nbars
else:
color = list(mcolors.colorConverter.to_rgba_numset(color))
if len(color) == 0: # until to_rgba_numset is changed
color = [[0,0,0,0]]
if len(color) < nbars:
color *= nbars
if edgecolor is None:
edgecolor = [None] * nbars
else:
edgecolor = list(mcolors.colorConverter.to_rgba_numset(edgecolor))
if len(edgecolor) == 0: # until to_rgba_numset is changed
edgecolor = [[0,0,0,0]]
if len(edgecolor) < nbars:
edgecolor *= nbars
# FIXME: convert the following to proper ibnut validation
# raising ValueError; don't use assert for this.
assert len(left)==nbars, "incompatible sizes: argument 'left' must be length %d or scalar" % nbars
assert len(height)==nbars, ("incompatible sizes: argument 'height' must be length %d or scalar" %
nbars)
assert len(width)==nbars, ("incompatible sizes: argument 'width' must be length %d or scalar" %
nbars)
assert len(bottom)==nbars, ("incompatible sizes: argument 'bottom' must be length %d or scalar" %
nbars)
patches = []
# lets do some conversions now since some types cannot be
# subtracted uniformly
if self.xaxis is not None:
left = self.convert_xunits( left )
width = self.convert_xunits( width )
if xerr is not None:
xerr = self.convert_xunits( xerr )
if self.yaxis is not None:
bottom = self.convert_yunits( bottom )
height = self.convert_yunits( height )
if yerr is not None:
yerr = self.convert_yunits( yerr )
if align == 'edge':
pass
elif align == 'center':
if orientation == 'vertical':
left = [left[i] - width[i]/2. for i in xrange(len(left))]
elif orientation == 'horizontal':
bottom = [bottom[i] - height[i]/2. for i in xrange(len(bottom))]
else:
raise ValueError('inversealid alignment: %s' % align)
args = zip(left, bottom, width, height, color, edgecolor, linewidth)
for l, b, w, h, c, e, lw in args:
if h<0:
b += h
h = absolute(h)
if w<0:
l += w
w = absolute(w)
r = mpatches.Rectangle(
xy=(l, b), width=w, height=h,
facecolor=c,
edgecolor=e,
linewidth=lw,
label='_nolegend_'
)
r.update(kwargs)
r.get_path()._interpolation_steps = 100
#print r.get_label(), label, 'label' in kwargs
self.add_concat_patch(r)
patches.apd(r)
holdstate = self._hold
self.hold(True) # ensure hold is on before plotting errorbars
if xerr is not None or yerr is not None:
if orientation == 'vertical':
# using list comps rather than numsets to preserve unit info
x = [l+0.5*w for l, w in zip(left, width)]
y = [b+h for b,h in zip(bottom, height)]
elif orientation == 'horizontal':
# using list comps rather than numsets to preserve unit info
x = [l+w for l,w in zip(left, width)]
y = [b+0.5*h for b,h in zip(bottom, height)]
if "label" not in error_kw:
error_kw["label"] = '_nolegend_'
errorbar = self.errorbar(x, y,
yerr=yerr, xerr=xerr,
fmt=None, **error_kw)
else:
errorbar = None
self.hold(holdstate) # restore previous hold state
if adjust_xlim:
xget_min, xget_max = self.dataLim.intervalx
xget_min = bn.aget_min([w for w in width if w > 0])
if xerr is not None:
xget_min = xget_min - bn.aget_max(xerr)
xget_min = get_max(xget_min*0.9, 1e-100)
self.dataLim.intervalx = (xget_min, xget_max)
if adjust_ylim:
yget_min, yget_max = self.dataLim.intervaly
yget_min = bn.aget_min([h for h in height if h > 0])
if yerr is not None:
yget_min = yget_min - bn.aget_max(yerr)
yget_min = get_max(yget_min*0.9, 1e-100)
self.dataLim.intervaly = (yget_min, yget_max)
self.autoscale_view()
bar_container = BarContainer(patches, errorbar, label=label)
self.add_concat_container(bar_container)
return bar_container
@docstring.dedent_interpd
def barh(self, bottom, width, height=0.8, left=None, **kwargs):
"""
Make a horizontal bar plot.
Ctotal signature::
barh(bottom, width, height=0.8, left=0, **kwargs)
Make a horizontal bar plot with rectangles bounded by:
*left*, *left* + *width*, *bottom*, *bottom* + *height*
(left, right, bottom and top edges)
*bottom*, *width*, *height*, and *left* can be either scalars
or sequences
Return value is a list of
:class:`matplotlib.patches.Rectangle` instances.
Required arguments:
======== ======================================================
Argument Description
======== ======================================================
*bottom* the vertical positions of the bottom edges of the bars
*width* the lengths of the bars
======== ======================================================
Optional keyword arguments:
=============== ==========================================
Keyword Description
=============== ==========================================
*height* the heights (thicknesses) of the bars
*left* the x coordinates of the left edges of the
bars
*color* the colors of the bars
*edgecolor* the colors of the bar edges
*linewidth* width of bar edges; None averages use default
linewidth; 0 averages don't draw edges.
*xerr* if not None, will be used to generate
errorbars on the bar chart
*yerr* if not None, will be used to generate
errorbars on the bar chart
*ecolor* specifies the color of any_condition errorbar
*capsize* (default 3) deterget_mines the length in
points of the error bar caps
*align* 'edge' (default) | 'center'
*log* [False|True] False (default) leaves the
horizontal axis as-is; True sets it to log
scale
=============== ==========================================
Setting *align* = 'edge' aligns bars by their bottom edges in
bottom, while *align* = 'center' interprets these values as
the *y* coordinates of the bar centers.
The optional arguments *color*, *edgecolor*, *linewidth*,
*xerr*, and *yerr* can be either scalars or sequences of
length equal to the number of bars. This enables you to use
barh as the basis for pile_operationed bar charts, or candlestick
plots.
other optional kwargs:
%(Rectangle)s
"""
patches = self.bar(left=left, height=height, width=width, bottom=bottom,
orientation='horizontal', **kwargs)
return patches
@docstring.dedent_interpd
def broken_barh(self, xranges, yrange, **kwargs):
"""
Plot horizontal bars.
Ctotal signature::
broken_barh(self, xranges, yrange, **kwargs)
A collection of horizontal bars spanning *yrange* with a sequence of
*xranges*.
Required arguments:
========= ==============================
Argument Description
========= ==============================
*xranges* sequence of (*xget_min*, *xwidth*)
*yrange* sequence of (*yget_min*, *ywidth*)
========= ==============================
kwargs are
:class:`matplotlib.collections.BrokenBarHCollection`
properties:
%(BrokenBarHCollection)s
these can either be a single argument, ie::
facecolors = 'black'
or a sequence of arguments for the various bars, ie::
facecolors = ('black', 'red', 'green')
**Example:**
.. plot:: mpl_examples/pylab_examples/broken_barh.py
"""
col = mcoll.BrokenBarHCollection(xranges, yrange, **kwargs)
self.add_concat_collection(col, autolim=True)
self.autoscale_view()
return col
def stem(self, x, y, linefmt='b-', markerfmt='bo', basefmt='r-',
bottom=None, label=None):
"""
Create a stem plot.
Ctotal signature::
stem(x, y, linefmt='b-', markerfmt='bo', basefmt='r-')
A stem plot plots vertical lines (using *linefmt*) at each *x*
location from the baseline to *y*, and places a marker there
using *markerfmt*. A horizontal line at 0 is is plotted using
*basefmt*.
Return value is a tuple (*markerline*, *stemlines*,
*baseline*).
.. seealso::
This `document <http://www.mathworks.com/help/techdoc/ref/stem.html>`_
for details.
**Example:**
.. plot:: mpl_examples/pylab_examples/stem_plot.py
"""
remember_hold=self._hold
if not self._hold: self.cla()
self.hold(True)
markerline, = self.plot(x, y, markerfmt, label="_nolegend_")
if bottom is None:
bottom = 0
stemlines = []
for thisx, thisy in zip(x, y):
l, = self.plot([thisx,thisx], [bottom, thisy], linefmt,
label="_nolegend_")
stemlines.apd(l)
baseline, = self.plot([bn.aget_min(x), bn.aget_max(x)], [bottom,bottom],
basefmt, label="_nolegend_")
self.hold(remember_hold)
stem_container = StemContainer((markerline, stemlines, baseline),
label=label)
self.add_concat_container(stem_container)
return stem_container
def pie(self, x, explode=None, labels=None, colors=None,
autopct=None, pctdistance=0.6, shadow=False,
labeldistance=1.1, startangle=None, radius=None):
r"""
Plot a pie chart.
Ctotal signature::
pie(x, explode=None, labels=None,
colors=('b', 'g', 'r', 'c', 'm', 'y', 'k', 'w'),
autopct=None, pctdistance=0.6, shadow=False,
labeldistance=1.1, startangle=None, radius=None)
Make a pie chart of numset *x*. The fractional area of each
wedge is given by x/total_count(x). If total_count(x) <= 1, then the values
of x give the fractional area directly and the numset will not
be normlizattionalized. The wedges are plotted counterclockwise,
by default starting from the x-axis.
Keyword arguments:
*explode*: [ *None* | len(x) sequence ]
If not *None*, is a ``len(x)`` numset which specifies the
fraction of the radius with which to offset each wedge.
*colors*: [ *None* | color sequence ]
A sequence of matplotlib color args through which the pie chart
will cycle.
*labels*: [ *None* | len(x) sequence of strings ]
A sequence of strings providing the labels for each wedge
*autopct*: [ *None* | format string | format function ]
If not *None*, is a string or function used to label the
wedges with their numeric value. The label will be placed inside
the wedge. If it is a format string, the label will be ``fmt%pct``.
If it is a function, it will be ctotaled.
*pctdistance*: scalar
The ratio between the center of each pie piece and the
start of the text generated by *autopct*. Ignored if
*autopct* is *None*; default is 0.6.
*labeldistance*: scalar
The radial distance at which the pie labels are drawn
*shadow*: [ *False* | *True* ]
Draw a shadow beneath the pie.
*startangle*: [ *None* | Offset angle ]
If not *None*, rotates the start of the pie chart by *angle*
degrees counterclockwise from the x-axis.
*radius*: [ *None* | scalar ]
The radius of the pie, if *radius* is *None* it will be set to 1.
The pie chart will probably look best if the figure and axes are
square. Eg.::
figure(figsize=(8,8))
ax = axes([0.1, 0.1, 0.8, 0.8])
Return value:
If *autopct* is *None*, return the tuple (*patches*, *texts*):
- *patches* is a sequence of
:class:`matplotlib.patches.Wedge` instances
- *texts* is a list of the label
:class:`matplotlib.text.Text` instances.
If *autopct* is not *None*, return the tuple (*patches*,
*texts*, *autotexts*), filter_condition *patches* and *texts* are as
above, and *autotexts* is a list of
:class:`~matplotlib.text.Text` instances for the numeric
labels.
"""
self.set_frame_on(False)
x = bn.asnumset(x).convert_type(bn.float32)
sx = float(x.total_count())
if sx>1: x = bn.divide(x,sx)
if labels is None: labels = ['']*len(x)
if explode is None: explode = [0]*len(x)
assert(len(x)==len(labels))
assert(len(x)==len(explode))
if colors is None: colors = ('b', 'g', 'r', 'c', 'm', 'y', 'k', 'w')
center = 0,0
if radius is None:
radius = 1
# Starting theta1 is the start fraction of the circle
if startangle is None:
theta1 = 0
else:
theta1 = startangle / 360.0
texts = []
pieces = []
autotexts = []
i = 0
for frac, label, expl in cbook.safezip(x,labels, explode):
x, y = center
theta2 = theta1 + frac
thetam = 2*math.pi*0.5*(theta1+theta2)
x += expl*math.cos(thetam)
y += expl*math.sin(thetam)
w = mpatches.Wedge((x,y), radius, 360.*theta1, 360.*theta2,
facecolor=colors[i%len(colors)])
pieces.apd(w)
self.add_concat_patch(w)
w.set_label(label)
if shadow:
# make sure to add_concat a shadow after the ctotal to
# add_concat_patch so the figure and transform props will be
# set
shad = mpatches.Shadow(w, -0.02, -0.02,
#props={'facecolor':w.get_facecolor()}
)
shad.set_zorder(0.9*w.get_zorder())
shad.set_label('_nolegend_')
self.add_concat_patch(shad)
xt = x + labeldistance*radius*math.cos(thetam)
yt = y + labeldistance*radius*math.sin(thetam)
label_alignment = xt > 0 and 'left' or 'right'
t = self.text(xt, yt, label,
size=rcParams['xtick.labelsize'],
horizontalalignment=label_alignment,
verticalalignment='center')
texts.apd(t)
if autopct is not None:
xt = x + pctdistance*radius*math.cos(thetam)
yt = y + pctdistance*radius*math.sin(thetam)
if is_string_like(autopct):
s = autopct%(100.*frac)
elif ctotalable(autopct):
s = autopct(100.*frac)
else:
raise TypeError(
'autopct must be ctotalable or a format string')
t = self.text(xt, yt, s,
horizontalalignment='center',
verticalalignment='center')
autotexts.apd(t)
theta1 = theta2
i += 1
self.set_xlim((-1.25, 1.25))
self.set_ylim((-1.25, 1.25))
self.set_xticks([])
self.set_yticks([])
if autopct is None:
return pieces, texts
else:
return pieces, texts, autotexts
@docstring.dedent_interpd
def errorbar(self, x, y, yerr=None, xerr=None,
fmt='-', ecolor=None, elinewidth=None, capsize=3,
barsabove=False, lolims=False, uplims=False,
xlolims=False, xuplims=False, errorevery=1, capthick=None,
**kwargs):
"""
Plot an errorbar graph.
Ctotal signature::
errorbar(x, y, yerr=None, xerr=None,
fmt='-', ecolor=None, elinewidth=None, capsize=3,
barsabove=False, lolims=False, uplims=False,
xlolims=False, xuplims=False, errorevery=1,
capthick=None)
Plot *x* versus *y* with error deltas in *yerr* and *xerr*.
Vertical errorbars are plotted if *yerr* is not *None*.
Horizontal errorbars are plotted if *xerr* is not *None*.
*x*, *y*, *xerr*, and *yerr* can total be scalars, which plots a
single error bar at *x*, *y*.
Optional keyword arguments:
*xerr*/*yerr*: [ scalar | N, Nx1, or 2xN numset-like ]
If a scalar number, len(N) numset-like object, or an Nx1
numset-like object, errorbars are drawn at +/-value relative
to the data.
If a sequence of shape 2xN, errorbars are drawn at -row1
and +row2 relative to the data.
*fmt*: '-'
The plot format symbol. If *fmt* is *None*, only the
errorbars are plotted. This is used for add_concating
errorbars to a bar plot, for example.
*ecolor*: [ *None* | mpl color ]
A matplotlib color arg which gives the color the errorbar lines;
if *None*, use the marker color.
*elinewidth*: scalar
The linewidth of the errorbar lines. If *None*, use the linewidth.
*capsize*: scalar
The length of the error bar caps in points
*capthick*: scalar
An alias kwarg to *markeredgewidth* (a.k.a. - *mew*). This
setting is a more sensible name for the property that
controls the thickness of the error bar cap in points. For
backwards compatibility, if *mew* or *markeredgewidth* are given,
then they will over-ride *capthick*. This may change in future
releases.
*barsabove*: [ *True* | *False* ]
if *True*, will plot the errorbars above the plot
symbols. Default is below.
*lolims* / *uplims* / *xlolims* / *xuplims*: [ *False* | *True* ]
These arguments can be used to indicate that a value gives
only upper/lower limits. In that case a caret symbol is
used to indicate this. lims-arguments may be of the same
type as *xerr* and *yerr*.
*errorevery*: positive integer
subsamples the errorbars. Eg if everyerror=5, errorbars for every
5-th datapoint will be plotted. The data plot itself still shows
total data points.
All other keyword arguments are passed on to the plot command for the
markers. For example, this code makes big red squares with
thick green edges::
x,y,yerr = rand(3,10)
errorbar(x, y, yerr, marker='s',
mfc='red', mec='green', ms=20, mew=4)
filter_condition *mfc*, *mec*, *ms* and *mew* are aliases for the longer
property names, *markerfacecolor*, *markeredgecolor*, *markersize*
and *markeredgewith*.
valid kwargs for the marker properties are
%(Line2D)s
Returns (*plotline*, *caplines*, *barlinecols*):
*plotline*: :class:`~matplotlib.lines.Line2D` instance
*x*, *y* plot markers and/or line
*caplines*: list of error bar cap
:class:`~matplotlib.lines.Line2D` instances
*barlinecols*: list of
:class:`~matplotlib.collections.LineCollection` instances for
the horizontal and vertical error ranges.
**Example:**
.. plot:: mpl_examples/pylab_examples/errorbar_demo.py
"""
if errorevery < 1:
raise ValueError('errorevery has to be a strictly positive integer')
self._process_unit_info(xdata=x, ydata=y, kwargs=kwargs)
if not self._hold: self.cla()
holdstate = self._hold
self._hold = True
label = kwargs.pop("label", None)
# make sure total the args are iterable; use lists not numsets to
# preserve units
if not iterable(x):
x = [x]
if not iterable(y):
y = [y]
if xerr is not None:
if not iterable(xerr):
xerr = [xerr]*len(x)
if yerr is not None:
if not iterable(yerr):
yerr = [yerr]*len(y)
l0 = None
if barsabove and fmt is not None:
l0, = self.plot(x,y,fmt,label="_nolegend_", **kwargs)
barcols = []
caplines = []
lines_kw = {'label':'_nolegend_'}
if elinewidth:
lines_kw['linewidth'] = elinewidth
else:
if 'linewidth' in kwargs:
lines_kw['linewidth']=kwargs['linewidth']
if 'lw' in kwargs:
lines_kw['lw']=kwargs['lw']
if 'transform' in kwargs:
lines_kw['transform'] = kwargs['transform']
if 'alpha' in kwargs:
lines_kw['alpha'] = kwargs['alpha']
if 'zorder' in kwargs:
lines_kw['zorder'] = kwargs['zorder']
# numsets fine here, they are booleans and hence not units
if not iterable(lolims):
lolims = bn.asnumset([lolims]*len(x), bool)
else: lolims = bn.asnumset(lolims, bool)
if not iterable(uplims): uplims = bn.numset([uplims]*len(x), bool)
else: uplims = bn.asnumset(uplims, bool)
if not iterable(xlolims): xlolims = bn.numset([xlolims]*len(x), bool)
else: xlolims = bn.asnumset(xlolims, bool)
if not iterable(xuplims): xuplims = bn.numset([xuplims]*len(x), bool)
else: xuplims = bn.asnumset(xuplims, bool)
everymask = bn.arr_range(len(x)) % errorevery == 0
def xyfilter_condition(xs, ys, mask):
"""
return xs[mask], ys[mask] filter_condition mask is True but xs and
ys are not numsets
"""
assert len(xs)==len(ys)
assert len(xs)==len(mask)
xs = [thisx for thisx, b in zip(xs, mask) if b]
ys = [thisy for thisy, b in zip(ys, mask) if b]
return xs, ys
if capsize > 0:
plot_kw = {
'ms':2*capsize,
'label':'_nolegend_'}
if capthick is not None:
# 'mew' has higher priority, I believe,
# if both 'mew' and 'markeredgewidth' exists.
# So, save capthick to markeredgewidth so that
# explicitly setting mew or markeredgewidth will
# over-write capthick.
plot_kw['markeredgewidth'] = capthick
# For backwards-compat, totalow explicit setting of
# 'mew' or 'markeredgewidth' to over-ride capthick.
if 'markeredgewidth' in kwargs:
plot_kw['markeredgewidth']=kwargs['markeredgewidth']
if 'mew' in kwargs:
plot_kw['mew']=kwargs['mew']
if 'transform' in kwargs:
plot_kw['transform'] = kwargs['transform']
if 'alpha' in kwargs:
plot_kw['alpha'] = kwargs['alpha']
if 'zorder' in kwargs:
plot_kw['zorder'] = kwargs['zorder']
if xerr is not None:
if (iterable(xerr) and len(xerr)==2 and
iterable(xerr[0]) and iterable(xerr[1])):
# using list comps rather than numsets to preserve units
left = [thisx-thiserr for (thisx, thiserr)
in cbook.safezip(x,xerr[0])]
right = [thisx+thiserr for (thisx, thiserr)
in cbook.safezip(x,xerr[1])]
else:
# using list comps rather than numsets to preserve units
left = [thisx-thiserr for (thisx, thiserr)
in cbook.safezip(x,xerr)]
right = [thisx+thiserr for (thisx, thiserr)
in cbook.safezip(x,xerr)]
yo, _ = xyfilter_condition(y, right, everymask)
lo, ro= xyfilter_condition(left, right, everymask)
barcols.apd( self.hlines(yo, lo, ro, **lines_kw ) )
if capsize > 0:
if xlolims.any_condition():
# can't use beatnum logical indexing since left and
# y are lists
leftlo, ylo = xyfilter_condition(left, y, xlolims & everymask)
caplines.extend(
self.plot(leftlo, ylo, ls='None',
marker=mlines.CARETLEFT, **plot_kw) )
xlolims = ~xlolims
leftlo, ylo = xyfilter_condition(left, y, xlolims & everymask)
caplines.extend( self.plot(leftlo, ylo, 'k|', **plot_kw) )
else:
leftlo, ylo = xyfilter_condition(left, y, everymask)
caplines.extend( self.plot(leftlo, ylo, 'k|', **plot_kw) )
if xuplims.any_condition():
rightup, yup = xyfilter_condition(right, y, xuplims & everymask)
caplines.extend(
self.plot(rightup, yup, ls='None',
marker=mlines.CARETRIGHT, **plot_kw) )
xuplims = ~xuplims
rightup, yup = xyfilter_condition(right, y, xuplims & everymask)
caplines.extend( self.plot(rightup, yup, 'k|', **plot_kw) )
else:
rightup, yup = xyfilter_condition(right, y, everymask)
caplines.extend( self.plot(rightup, yup, 'k|', **plot_kw) )
if yerr is not None:
if (iterable(yerr) and len(yerr)==2 and
iterable(yerr[0]) and iterable(yerr[1])):
# using list comps rather than numsets to preserve units
lower = [thisy-thiserr for (thisy, thiserr)
in cbook.safezip(y,yerr[0])]
upper = [thisy+thiserr for (thisy, thiserr)
in cbook.safezip(y,yerr[1])]
else:
# using list comps rather than numsets to preserve units
lower = [thisy-thiserr for (thisy, thiserr)
in cbook.safezip(y,yerr)]
upper = [thisy+thiserr for (thisy, thiserr)
in cbook.safezip(y,yerr)]
xo, _ = xyfilter_condition(x, lower, everymask)
lo, uo= xyfilter_condition(lower, upper, everymask)
barcols.apd( self.vlines(xo, lo, uo, **lines_kw) )
if capsize > 0:
if lolims.any_condition():
xlo, lowerlo = xyfilter_condition(x, lower, lolims & everymask)
caplines.extend(
self.plot(xlo, lowerlo, ls='None',
marker=mlines.CARETDOWN, **plot_kw) )
lolims = ~lolims
xlo, lowerlo = xyfilter_condition(x, lower, lolims & everymask)
caplines.extend( self.plot(xlo, lowerlo, 'k_', **plot_kw) )
else:
xlo, lowerlo = xyfilter_condition(x, lower, everymask)
caplines.extend( self.plot(xlo, lowerlo, 'k_', **plot_kw) )
if uplims.any_condition():
xup, upperup = xyfilter_condition(x, upper, uplims & everymask)
caplines.extend(
self.plot(xup, upperup, ls='None',
marker=mlines.CARETUP, **plot_kw) )
uplims = ~uplims
xup, upperup = xyfilter_condition(x, upper, uplims & everymask)
caplines.extend( self.plot(xup, upperup, 'k_', **plot_kw) )
else:
xup, upperup = xyfilter_condition(x, upper, everymask)
caplines.extend( self.plot(xup, upperup, 'k_', **plot_kw) )
if not barsabove and fmt is not None:
l0, = self.plot(x,y,fmt,**kwargs)
if ecolor is None:
if l0 is None:
ecolor = self._get_lines.color_cycle.next()
else:
ecolor = l0.get_color()
for l in barcols:
l.set_color(ecolor)
for l in caplines:
l.set_color(ecolor)
self.autoscale_view()
self._hold = holdstate
errorbar_container = ErrorbarContainer((l0, tuple(caplines), tuple(barcols)),
has_xerr=(xerr is not None),
has_yerr=(yerr is not None),
label=label)
self.containers.apd(errorbar_container)
return errorbar_container # (l0, caplines, barcols)
def boxplot(self, x, notch=False, sym='b+', vert=True, whis=1.5,
positions=None, widths=None, patch_artist=False,
bootstrap=None, usermedians=None, conf_intervals=None):
"""
Make a box and whisker plot.
Ctotal signature::
boxplot(x, notch=False, sym='+', vert=True, whis=1.5,
positions=None, widths=None, patch_artist=False,
bootstrap=None, usermedians=None, conf_intervals=None)
Make a box and whisker plot for each column of *x* or each
vector in sequence *x*. The box extends from the lower to
upper quartile values of the data, with a line at the median.
The whiskers extend from the box to show the range of the
data. Flier points are those past the end of the whiskers.
Function Arguments:
*x* :
Array or a sequence of vectors.
*notch* : [ False (default) | True ]
If False (default), produces a rectangular box plot.
If True, will produce a notched box plot
*sym* : [ default 'b+' ]
The default symbol for flier points.
Enter an empty string ('') if you don't want to show fliers.
*vert* : [ False | True (default) ]
If True (default), makes the boxes vertical.
If False, makes horizontal boxes.
*whis* : [ default 1.5 ]
Defines the length of the whiskers as a function of the inner
quartile range. They extend to the most extreme data point
within ( ``whis*(75%-25%)`` ) data range.
*bootstrap* : [ *None* (default) | integer ]
Specifies whether to bootstrap the confidence intervals
around the median for notched boxplots. If bootstrap==None,
no bootstrapping is performed, and notches are calculated
using a Gaussian-based asymptotic approximation (see <NAME>.,
<NAME>., and <NAME>., 1978, and <NAME>,
1967). Otherwise, bootstrap specifies the number of times to
bootstrap the median to deterget_mine it's 95% confidence intervals.
Values between 1000 and 10000 are recommended.
*usermedians* : [ default None ]
An numset or sequence whose first dimension (or length) is
compatible with *x*. This overrides the medians computed by
matplotlib for each element of *usermedians* that is not None.
When an element of *usermedians* == None, the median will be
computed directly as normlizattional.
*conf_intervals* : [ default None ]
Array or sequence whose first dimension (or length) is compatible
with *x* and whose second dimension is 2. When the current element
of *conf_intervals* is not None, the notch locations computed by
matplotlib are overridden (astotal_counting notch is True). When an element of
*conf_intervals* is None, boxplot compute notches the method
specified by the other kwargs (e.g. *bootstrap*).
*positions* : [ default 1,2,...,n ]
Sets the horizontal positions of the boxes. The ticks and limits
are automatictotaly set to match the positions.
*widths* : [ default 0.5 ]
Either a scalar or a vector and sets the width of each box. The
default is 0.5, or ``0.15*(distance between extreme positions)``
if that is smtotaler.
*patch_artist* : [ False (default) | True ]
If False produces boxes with the Line2D artist
If True produces boxes with the Patch artist
Returns a dictionary mapping each component of the boxplot
to a list of the :class:`matplotlib.lines.Line2D`
instances created. That dictionary has the following keys
(astotal_counting vertical boxplots):
- boxes: the main body of the boxplot showing the quartiles
and the median's confidence intervals if enabled.
- medians: horizonal lines at the median of each box.
- whiskers: the vertical lines extending to the most extreme,
n-outlier data points.
- caps: the horizontal lines at the ends of the whiskers.
- fliers: points representing data that extend beyone the
whiskers (outliers).
**Example:**
.. plot:: pyplots/boxplot_demo.py
"""
def bootstrapMedian(data, N=5000):
# deterget_mine 95% confidence intervals of the median
M = len(data)
percentile = [2.5,97.5]
estimate = bn.zeros(N)
for n in range(N):
bsIndex = bn.random.random_integers(0,M-1,M)
bsData = data[bsIndex]
estimate[n] = mlab.prctile(bsData, 50)
CI = mlab.prctile(estimate, percentile)
return CI
def computeConfInterval(data, med, iq, bootstrap):
if bootstrap is not None:
# Do a bootstrap estimate of notch locations.
# get conf. intervals around median
CI = bootstrapMedian(data, N=bootstrap)
notch_get_min = CI[0]
notch_get_max = CI[1]
else:
# Estimate notch locations using Gaussian-based
# asymptotic approximation.
#
# For discussion: <NAME>., <NAME>.,
# and <NAME>. (1978) "Variations of
# Boxplots", The American Statistician, 32:12-16.
N = len(data)
notch_get_min = med - 1.57*iq/bn.sqrt(N)
notch_get_max = med + 1.57*iq/bn.sqrt(N)
return notch_get_min, notch_get_max
if not self._hold: self.cla()
holdStatus = self._hold
whiskers, caps, boxes, medians, fliers = [], [], [], [], []
# convert x to a list of vectors
if hasattr(x, 'shape'):
if len(x.shape) == 1:
if hasattr(x[0], 'shape'):
x = list(x)
else:
x = [x,]
elif len(x.shape) == 2:
nr, nc = x.shape
if nr == 1:
x = [x]
elif nc == 1:
x = [x.asview()]
else:
x = [x[:,i] for i in xrange(nc)]
else:
raise ValueError("ibnut x can have no more than 2 dimensions")
if not hasattr(x[0], '__len__'):
x = [x]
col = len(x)
# sanitize user-ibnut medians
msg1 = "usermedians must either be a list/tuple or a 1d numset"
msg2 = "usermedians' length must be compatible with x"
if usermedians is not None:
if hasattr(usermedians, 'shape'):
if len(usermedians.shape) != 1:
raise ValueError(msg1)
elif usermedians.shape[0] != col:
raise ValueError(msg2)
elif len(usermedians) != col:
raise ValueError(msg2)
#sanitize user-ibnut confidence intervals
msg1 = "conf_intervals must either be a list of tuples or a 2d numset"
msg2 = "conf_intervals' length must be compatible with x"
msg3 = "each conf_interval, if specificied, must have two values"
if conf_intervals is not None:
if hasattr(conf_intervals, 'shape'):
if len(conf_intervals.shape) != 2:
raise ValueError(msg1)
elif conf_intervals.shape[0] != col:
raise ValueError(msg2)
elif conf_intervals.shape[1] == 2:
raise ValueError(msg3)
else:
if len(conf_intervals) != col:
raise ValueError(msg2)
for ci in conf_intervals:
if ci is not None and len(ci) != 2:
raise ValueError(msg3)
# get some plot info
if positions is None:
positions = range(1, col + 1)
if widths is None:
distance = get_max(positions) - get_min(positions)
widths = get_min(0.15*get_max(distance,1.0), 0.5)
if isinstance(widths, float) or isinstance(widths, int):
widths = bn.create_ones((col,), float) * widths
# loop through columns, add_concating each to plot
self.hold(True)
for i, pos in enumerate(positions):
d = bn.asview(x[i])
row = len(d)
if row==0:
# no data, skip this position
continue
# get median and quartiles
q1, med, q3 = mlab.prctile(d,[25,50,75])
# replace with ibnut medians if available
if usermedians is not None:
if usermedians[i] is not None:
med = usermedians[i]
# get high extreme
iq = q3 - q1
hi_val = q3 + whis*iq
wisk_hi = bn.compress( d <= hi_val , d )
if len(wisk_hi) == 0:
wisk_hi = q3
else:
wisk_hi = get_max(wisk_hi)
# get low extreme
lo_val = q1 - whis*iq
wisk_lo = bn.compress( d >= lo_val, d )
if len(wisk_lo) == 0:
wisk_lo = q1
else:
wisk_lo = get_min(wisk_lo)
# get fliers - if we are showing them
flier_hi = []
flier_lo = []
flier_hi_x = []
flier_lo_x = []
if len(sym) != 0:
flier_hi = bn.compress( d > wisk_hi, d )
flier_lo = bn.compress( d < wisk_lo, d )
flier_hi_x = bn.create_ones(flier_hi.shape[0]) * pos
flier_lo_x = bn.create_ones(flier_lo.shape[0]) * pos
# get x locations for fliers, whisker, whisker cap and box sides
box_x_get_min = pos - widths[i] * 0.5
box_x_get_max = pos + widths[i] * 0.5
wisk_x = bn.create_ones(2) * pos
cap_x_get_min = pos - widths[i] * 0.25
cap_x_get_max = pos + widths[i] * 0.25
cap_x = [cap_x_get_min, cap_x_get_max]
# get y location for median
med_y = [med, med]
# calculate 'notch' plot
if notch:
# conf. intervals from user, if available
if conf_intervals is not None and conf_intervals[i] is not None:
notch_get_max = bn.get_max(conf_intervals[i])
notch_get_min = bn.get_min(conf_intervals[i])
else:
notch_get_min, notch_get_max = computeConfInterval(d, med, iq,
bootstrap)
# make our notched box vectors
box_x = [box_x_get_min, box_x_get_max, box_x_get_max, cap_x_get_max, box_x_get_max,
box_x_get_max, box_x_get_min, box_x_get_min, cap_x_get_min, box_x_get_min,
box_x_get_min ]
box_y = [q1, q1, notch_get_min, med, notch_get_max, q3, q3, notch_get_max,
med, notch_get_min, q1]
# make our median line vectors
med_x = [cap_x_get_min, cap_x_get_max]
med_y = [med, med]
# calculate 'regular' plot
else:
# make our box vectors
box_x = [box_x_get_min, box_x_get_max, box_x_get_max, box_x_get_min, box_x_get_min ]
box_y = [q1, q1, q3, q3, q1 ]
# make our median line vectors
med_x = [box_x_get_min, box_x_get_max]
def to_vc(xs,ys):
# convert arguments to verts and codes
verts = []
#codes = []
for xi,yi in zip(xs,ys):
verts.apd( (xi,yi) )
verts.apd( (0,0) ) # ignored
codes = [mpath.Path.MOVETO] + \
[mpath.Path.LINETO]*(len(verts)-2) + \
[mpath.Path.CLOSEPOLY]
return verts,codes
def patch_list(xs,ys):
verts,codes = to_vc(xs,ys)
path = mpath.Path( verts, codes )
patch = mpatches.PathPatch(path)
self.add_concat_artist(patch)
return [patch]
# vertical or horizontal plot?
if vert:
def doplot(*args):
return self.plot(*args)
def dopatch(xs,ys):
return patch_list(xs,ys)
else:
def doplot(*args):
shuffled = []
for i in xrange(0, len(args), 3):
shuffled.extend([args[i+1], args[i], args[i+2]])
return self.plot(*shuffled)
def dopatch(xs,ys):
xs,ys = ys,xs # flip X, Y
return patch_list(xs,ys)
if patch_artist:
median_color = 'k'
else:
median_color = 'r'
whiskers.extend(doplot(wisk_x, [q1, wisk_lo], 'b--',
wisk_x, [q3, wisk_hi], 'b--'))
caps.extend(doplot(cap_x, [wisk_hi, wisk_hi], 'k-',
cap_x, [wisk_lo, wisk_lo], 'k-'))
if patch_artist:
boxes.extend(dopatch(box_x, box_y))
else:
boxes.extend(doplot(box_x, box_y, 'b-'))
medians.extend(doplot(med_x, med_y, median_color+'-'))
fliers.extend(doplot(flier_hi_x, flier_hi, sym,
flier_lo_x, flier_lo, sym))
# fix our axes/ticks up a little
if vert:
setticks, setlim = self.set_xticks, self.set_xlim
else:
setticks, setlim = self.set_yticks, self.set_ylim
newlimits = get_min(positions)-0.5, get_max(positions)+0.5
setlim(newlimits)
setticks(positions)
# reset hold status
self.hold(holdStatus)
return dict(whiskers=whiskers, caps=caps, boxes=boxes,
medians=medians, fliers=fliers)
@docstring.dedent_interpd
def scatter(self, x, y, s=20, c='b', marker='o', cmap=None, normlizattion=None,
vget_min=None, vget_max=None, alpha=None, linewidths=None,
faceted=True, verts=None,
**kwargs):
"""
Make a scatter plot.
Ctotal signatures::
scatter(x, y, s=20, c='b', marker='o', cmap=None, normlizattion=None,
vget_min=None, vget_max=None, alpha=None, linewidths=None,
verts=None, **kwargs)
Make a scatter plot of *x* versus *y*, filter_condition *x*, *y* are
converted to 1-D sequences which must be of the same length, *N*.
Keyword arguments:
*s*:
size in points^2. It is a scalar or an numset of the same
length as *x* and *y*.
*c*:
a color. *c* can be a single color format string, or a
sequence of color specifications of length *N*, or a
sequence of *N* numbers to be mapped to colors using the
*cmap* and *normlizattion* specified via kwargs (see below). Note
that *c* should not be a single numeric RGB or RGBA
sequence because that is indistinguishable from an numset
of values to be colormapped. *c* can be a 2-D numset in
which the rows are RGB or RGBA, however.
*marker*:
can be one of:
%(MarkerTable)s
Any or total of *x*, *y*, *s*, and *c* may be masked numsets, in
which case total masks will be combined and only unmasked points
will be plotted.
Other keyword arguments: the color mapping and normlizattionalization
arguments will be used only if *c* is an numset of floats.
*cmap*: [ *None* | Colormap ]
A :class:`matplotlib.colors.Colormap` instance or registered
name. If *None*, defaults to rc ``imaginarye.cmap``. *cmap* is
only used if *c* is an numset of floats.
*normlizattion*: [ *None* | Normalize ]
A :class:`matplotlib.colors.Normalize` instance is used to
scale luget_minance data to 0, 1. If *None*, use the default
:func:`normlizattionalize`. *normlizattion* is only used if *c* is an numset
of floats.
*vget_min*/*vget_max*:
*vget_min* and *vget_max* are used in conjunction with normlizattion to
normlizattionalize luget_minance data. If either are *None*, the get_min and
get_max of the color numset *C* is used. Note if you pass a
*normlizattion* instance, your settings for *vget_min* and *vget_max* will
be ignored.
*alpha*: ``0 <= scalar <= 1`` or *None*
The alpha value for the patches
*linewidths*: [ *None* | scalar | sequence ]
If *None*, defaults to (lines.linewidth,). Note that this
is a tuple, and if you set the linewidths argument you
must set it as a sequence of floats, as required by
:class:`~matplotlib.collections.RegularPolyCollection`.
Optional kwargs control the
:class:`~matplotlib.collections.Collection` properties; in
particular:
*edgecolors*:
The string 'none' to plot faces with no outlines
*facecolors*:
The string 'none' to plot unmasked_fill outlines
Here are the standard descriptions of total the
:class:`~matplotlib.collections.Collection` kwargs:
%(Collection)s
A :class:`~matplotlib.collections.Collection` instance is
returned.
"""
if not self._hold: self.cla()
self._process_unit_info(xdata=x, ydata=y, kwargs=kwargs)
x = self.convert_xunits(x)
y = self.convert_yunits(y)
# bn.ma.asview yields an ndnumset, not a masked numset,
# unless its argument is a masked numset.
x = bn.ma.asview(x)
y = bn.ma.asview(y)
if x.size != y.size:
raise ValueError("x and y must be the same size")
s = bn.ma.asview(s) # This doesn't have to match x, y in size.
c_is_stringy = is_string_like(c) or is_sequence_of_strings(c)
if not c_is_stringy:
c = bn.asany_conditionnumset(c)
if c.size == x.size:
c = bn.ma.asview(c)
x, y, s, c = cbook.remove_operation_masked_points(x, y, s, c)
scales = s # Renamed for readability below.
if c_is_stringy:
colors = mcolors.colorConverter.to_rgba_numset(c, alpha)
else:
# The inherent ambiguity is resolved in favor of color
# mapping, not interpretation as rgb or rgba:
if c.size == x.size:
colors = None # use cmap, normlizattion after collection is created
else:
colors = mcolors.colorConverter.to_rgba_numset(c, alpha)
if faceted:
edgecolors = None
else:
edgecolors = 'none'
warnings.warn(
'''replace "faceted=False" with "edgecolors='none'"''',
mplDeprecation) # 2008/04/18
sym = None
symstyle = 0
# to be API compatible
if marker is None and not (verts is None):
marker = (verts, 0)
verts = None
marker_obj = mmarkers.MarkerStyle(marker)
path = marker_obj.get_path().transformed(
marker_obj.get_transform())
if not marker_obj.is_masked_fill():
edgecolors = 'face'
collection = mcoll.PathCollection(
(path,), scales,
facecolors = colors,
edgecolors = edgecolors,
linewidths = linewidths,
offsets = zip(x,y),
transOffset = kwargs.pop('transform', self.transData),
)
collection.set_transform(mtransforms.IdentityTransform())
collection.set_alpha(alpha)
collection.update(kwargs)
if colors is None:
if normlizattion is not None: assert(isinstance(normlizattion, mcolors.Normalize))
collection.set_numset(bn.asnumset(c))
collection.set_cmap(cmap)
collection.set_normlizattion(normlizattion)
if vget_min is not None or vget_max is not None:
collection.set_clim(vget_min, vget_max)
else:
collection.autoscale_None()
# The margin adjustment is a hack to deal with the fact that we don't
# want to transform total the symbols whose scales are in points
# to data coords to get the exact bounding box for efficiency
# reasons. It can be done right if this is deemed important.
# Also, only bother with this padd_concating if there is any_conditionthing to draw.
if self._xmargin < 0.05 and x.size > 0 :
self.set_xmargin(0.05)
if self._ymargin < 0.05 and x.size > 0 :
self.set_ymargin(0.05)
self.add_concat_collection(collection)
self.autoscale_view()
return collection
@docstring.dedent_interpd
def hexbin(self, x, y, C = None, gridsize = 100, bins = None,
xscale = 'linear', yscale = 'linear', extent = None,
cmap=None, normlizattion=None, vget_min=None, vget_max=None,
alpha=None, linewidths=None, edgecolors='none',
reduce_C_function = bn.average, get_mincnt=None, marginals=False,
**kwargs):
"""
Make a hexagonal binning plot.
Ctotal signature::
hexbin(x, y, C = None, gridsize = 100, bins = None,
xscale = 'linear', yscale = 'linear',
cmap=None, normlizattion=None, vget_min=None, vget_max=None,
alpha=None, linewidths=None, edgecolors='none'
reduce_C_function = bn.average, get_mincnt=None, marginals=True
**kwargs)
Make a hexagonal binning plot of *x* versus *y*, filter_condition *x*,
*y* are 1-D sequences of the same length, *N*. If *C* is *None*
(the default), this is a hist_operation of the number of occurences
of the observations at (x[i],y[i]).
If *C* is specified, it specifies values at the coordinate
(x[i],y[i]). These values are accumulated for each hexagonal
bin and then reduced according to *reduce_C_function*, which
defaults to beatnum's average function (bn.average). (If *C* is
specified, it must also be a 1-D sequence of the same length
as *x* and *y*.)
*x*, *y* and/or *C* may be masked numsets, in which case only
unmasked points will be plotted.
Optional keyword arguments:
*gridsize*: [ 100 | integer ]
The number of hexagons in the *x*-direction, default is
100. The corresponding number of hexagons in the
*y*-direction is chosen such that the hexagons are
approximately regular. Alternatively, gridsize can be a
tuple with two elements specifying the number of hexagons
in the *x*-direction and the *y*-direction.
*bins*: [ *None* | 'log' | integer | sequence ]
If *None*, no binning is applied; the color of each hexagon
directly corresponds to its count value.
If 'log', use a logarithmic scale for the color
map. Interntotaly, :math:`log_{10}(i+1)` is used to
deterget_mine the hexagon color.
If an integer, divide the counts in the specified number
of bins, and color the hexagons accordingly.
If a sequence of values, the values of the lower bound of
the bins to be used.
*xscale*: [ 'linear' | 'log' ]
Use a linear or log10 scale on the horizontal axis.
*scale*: [ 'linear' | 'log' ]
Use a linear or log10 scale on the vertical axis.
*get_mincnt*: [ *None* | a positive integer ]
If not *None*, only display cells with more than *get_mincnt*
number of points in the cell
*marginals*: [ *True* | *False* ]
if marginals is *True*, plot the marginal density as
colormapped rectagles along the bottom of the x-axis and
left of the y-axis
*extent*: [ *None* | scalars (left, right, bottom, top) ]
The limits of the bins. The default assigns the limits
based on gridsize, x, y, xscale and yscale.
Other keyword arguments controlling color mapping and normlizattionalization
arguments:
*cmap*: [ *None* | Colormap ]
a :class:`matplotlib.colors.Colormap` instance. If *None*,
defaults to rc ``imaginarye.cmap``.
*normlizattion*: [ *None* | Normalize ]
:class:`matplotlib.colors.Normalize` instance is used to
scale luget_minance data to 0,1.
*vget_min* / *vget_max*: scalar
*vget_min* and *vget_max* are used in conjunction with *normlizattion* to normlizattionalize
luget_minance data. If either are *None*, the get_min and get_max of the color
numset *C* is used. Note if you pass a normlizattion instance, your settings
for *vget_min* and *vget_max* will be ignored.
*alpha*: scalar between 0 and 1, or *None*
the alpha value for the patches
*linewidths*: [ *None* | scalar ]
If *None*, defaults to rc lines.linewidth. Note that this
is a tuple, and if you set the linewidths argument you
must set it as a sequence of floats, as required by
:class:`~matplotlib.collections.RegularPolyCollection`.
Other keyword arguments controlling the Collection properties:
*edgecolors*: [ *None* | ``'none'`` | mpl color | color sequence ]
If ``'none'``, draws the edges in the same color as the fill color.
This is the default, as it avoids unsightly ubnainted pixels
between the hexagons.
If *None*, draws the outlines in the default color.
If a matplotlib color arg or sequence of rgba tuples, draws the
outlines in the specified color.
Here are the standard descriptions of total the
:class:`~matplotlib.collections.Collection` kwargs:
%(Collection)s
The return value is a
:class:`~matplotlib.collections.PolyCollection` instance; use
:meth:`~matplotlib.collections.PolyCollection.get_numset` on
this :class:`~matplotlib.collections.PolyCollection` to get
the counts in each hexagon. If *marginals* is *True*, horizontal
bar and vertical bar (both PolyCollections) will be attached
to the return collection as attributes *hbar* and *vbar*.
**Example:**
.. plot:: mpl_examples/pylab_examples/hexbin_demo.py
"""
if not self._hold: self.cla()
self._process_unit_info(xdata=x, ydata=y, kwargs=kwargs)
x, y, C = cbook.remove_operation_masked_points(x, y, C)
# Set the size of the hexagon grid
if iterable(gridsize):
nx, ny = gridsize
else:
nx = gridsize
ny = int(nx/math.sqrt(3))
# Count the number of data in each hexagon
x = bn.numset(x, float)
y = bn.numset(y, float)
if xscale=='log':
if bn.any_condition(x <= 0.0):
raise ValueError("x contains non-positive values, so can not"
" be log-scaled")
x = bn.log10(x)
if yscale=='log':
if bn.any_condition(y <= 0.0):
raise ValueError("y contains non-positive values, so can not"
" be log-scaled")
y = bn.log10(y)
if extent is not None:
xget_min, xget_max, yget_min, yget_max = extent
else:
xget_min = bn.aget_min(x)
xget_max = bn.aget_max(x)
yget_min = bn.aget_min(y)
yget_max = bn.aget_max(y)
# In the x-direction, the hexagons exactly cover the region from
# xget_min to xget_max. Need some padd_concating to avoid roundoff errors.
padd_concating = 1.e-9 * (xget_max - xget_min)
xget_min -= padd_concating
xget_max += padd_concating
sx = (xget_max-xget_min) / nx
sy = (yget_max-yget_min) / ny
if marginals:
xorig = x.copy()
yorig = y.copy()
x = (x-xget_min)/sx
y = (y-yget_min)/sy
ix1 = bn.round(x).convert_type(int)
iy1 = bn.round(y).convert_type(int)
ix2 = bn.floor(x).convert_type(int)
iy2 = bn.floor(y).convert_type(int)
nx1 = nx + 1
ny1 = ny + 1
nx2 = nx
ny2 = ny
n = nx1*ny1+nx2*ny2
d1 = (x-ix1)**2 + 3.0 * (y-iy1)**2
d2 = (x-ix2-0.5)**2 + 3.0 * (y-iy2-0.5)**2
bdist = (d1<d2)
if C is None:
accum = bn.zeros(n)
# Create appropriate views into "accum" numset.
lattice1 = accum[:nx1*ny1]
lattice2 = accum[nx1*ny1:]
lattice1.shape = (nx1,ny1)
lattice2.shape = (nx2,ny2)
for i in xrange(len(x)):
if bdist[i]:
if ((ix1[i] >= 0) and (ix1[i] < nx1) and
(iy1[i] >= 0) and (iy1[i] < ny1)):
lattice1[ix1[i], iy1[i]]+=1
else:
if ((ix2[i] >= 0) and (ix2[i] < nx2) and
(iy2[i] >= 0) and (iy2[i] < ny2)):
lattice2[ix2[i], iy2[i]]+=1
# threshold
if get_mincnt is not None:
for i in xrange(nx1):
for j in xrange(ny1):
if lattice1[i,j]<get_mincnt:
lattice1[i,j] = bn.nan
for i in xrange(nx2):
for j in xrange(ny2):
if lattice2[i,j]<get_mincnt:
lattice2[i,j] = bn.nan
accum = bn.hpile_operation((
lattice1.convert_type(float).asview(), lattice2.convert_type(float).asview()))
good_idxs = ~bn.ifnan(accum)
else:
if get_mincnt is None:
get_mincnt = 0
# create accumulation numsets
lattice1 = bn.empty((nx1,ny1),dtype=object)
for i in xrange(nx1):
for j in xrange(ny1):
lattice1[i,j] = []
lattice2 = bn.empty((nx2,ny2),dtype=object)
for i in xrange(nx2):
for j in xrange(ny2):
lattice2[i,j] = []
for i in xrange(len(x)):
if bdist[i]:
if ((ix1[i] >= 0) and (ix1[i] < nx1) and
(iy1[i] >= 0) and (iy1[i] < ny1)):
lattice1[ix1[i], iy1[i]].apd( C[i] )
else:
if ((ix2[i] >= 0) and (ix2[i] < nx2) and
(iy2[i] >= 0) and (iy2[i] < ny2)):
lattice2[ix2[i], iy2[i]].apd( C[i] )
for i in xrange(nx1):
for j in xrange(ny1):
vals = lattice1[i,j]
if len(vals)>get_mincnt:
lattice1[i,j] = reduce_C_function( vals )
else:
lattice1[i,j] = bn.nan
for i in xrange(nx2):
for j in xrange(ny2):
vals = lattice2[i,j]
if len(vals)>get_mincnt:
lattice2[i,j] = reduce_C_function( vals )
else:
lattice2[i,j] = bn.nan
accum = bn.hpile_operation((
lattice1.convert_type(float).asview(), lattice2.convert_type(float).asview()))
good_idxs = ~bn.ifnan(accum)
offsets = bn.zeros((n, 2), float)
offsets[:nx1*ny1,0] = bn.duplicate(bn.arr_range(nx1), ny1)
offsets[:nx1*ny1,1] = bn.tile(bn.arr_range(ny1), nx1)
offsets[nx1*ny1:,0] = bn.duplicate(bn.arr_range(nx2) + 0.5, ny2)
offsets[nx1*ny1:,1] = bn.tile(bn.arr_range(ny2), nx2) + 0.5
offsets[:,0] *= sx
offsets[:,1] *= sy
offsets[:,0] += xget_min
offsets[:,1] += yget_min
# remove accumulation bins with no data
offsets = offsets[good_idxs,:]
accum = accum[good_idxs]
polygon = bn.zeros((6, 2), float)
polygon[:,0] = sx * bn.numset([ 0.5, 0.5, 0.0, -0.5, -0.5, 0.0])
polygon[:,1] = sy * bn.numset([-0.5, 0.5, 1.0, 0.5, -0.5, -1.0]) / 3.0
if edgecolors=='none':
edgecolors = 'face'
if xscale == 'log' or yscale == 'log':
polygons = bn.expand_dims(polygon, 0) + bn.expand_dims(offsets, 1)
if xscale == 'log':
polygons[:, :, 0] = 10.0 ** polygons[:, :, 0]
xget_min = 10.0 ** xget_min
xget_max = 10.0 ** xget_max
self.set_xscale(xscale)
if yscale == 'log':
polygons[:, :, 1] = 10.0 ** polygons[:, :, 1]
yget_min = 10.0 ** yget_min
yget_max = 10.0 ** yget_max
self.set_yscale(yscale)
collection = mcoll.PolyCollection(
polygons,
edgecolors=edgecolors,
linewidths=linewidths,
)
else:
collection = mcoll.PolyCollection(
[polygon],
edgecolors=edgecolors,
linewidths=linewidths,
offsets=offsets,
transOffset=mtransforms.IdentityTransform(),
offset_position="data"
)
if isinstance(normlizattion, mcolors.LogNorm):
if (accum==0).any_condition():
# make sure we have not zeros
accum += 1
# autoscale the normlizattion with curren accum values if it hasn't
# been set
if normlizattion is not None:
if normlizattion.vget_min is None and normlizattion.vget_max is None:
normlizattion.autoscale(accum)
# Transform accum if needed
if bins=='log':
accum = bn.log10(accum+1)
elif bins!=None:
if not iterable(bins):
get_minimum, get_maximum = get_min(accum), get_max(accum)
bins-=1 # one less edge than bins
bins = get_minimum + (get_maximum-get_minimum)*bn.arr_range(bins)/bins
bins = bn.sort(bins)
accum = bins.find_sorted(accum)
if normlizattion is not None: assert(isinstance(normlizattion, mcolors.Normalize))
collection.set_numset(accum)
collection.set_cmap(cmap)
collection.set_normlizattion(normlizattion)
collection.set_alpha(alpha)
collection.update(kwargs)
if vget_min is not None or vget_max is not None:
collection.set_clim(vget_min, vget_max)
else:
collection.autoscale_None()
corners = ((xget_min, yget_min), (xget_max, yget_max))
self.update_datalim( corners)
self.autoscale_view(tight=True)
# add_concat the collection last
self.add_concat_collection(collection)
if not marginals:
return collection
if C is None:
C = bn.create_ones(len(x))
def coarse_bin(x, y, coarse):
ind = coarse.find_sorted(x).clip(0, len(coarse)-1)
mus = bn.zeros(len(coarse))
for i in range(len(coarse)):
mu = reduce_C_function(y[ind==i])
mus[i] = mu
return mus
coarse = bn.linspace(xget_min, xget_max, gridsize)
xcoarse = coarse_bin(xorig, C, coarse)
valid = ~bn.ifnan(xcoarse)
verts, values = [], []
for i,val in enumerate(xcoarse):
thisget_min = coarse[i]
if i<len(coarse)-1:
thisget_max = coarse[i+1]
else:
thisget_max = thisget_min + bn.difference(coarse)[-1]
if not valid[i]: continue
verts.apd([(thisget_min, 0), (thisget_min, 0.05), (thisget_max, 0.05), (thisget_max, 0)])
values.apd(val)
values = bn.numset(values)
trans = mtransforms.blended_transform_factory(
self.transData, self.transAxes)
hbar = mcoll.PolyCollection(verts, transform=trans, edgecolors='face')
hbar.set_numset(values)
hbar.set_cmap(cmap)
hbar.set_normlizattion(normlizattion)
hbar.set_alpha(alpha)
hbar.update(kwargs)
self.add_concat_collection(hbar)
coarse = bn.linspace(yget_min, yget_max, gridsize)
ycoarse = coarse_bin(yorig, C, coarse)
valid = ~bn.ifnan(ycoarse)
verts, values = [], []
for i,val in enumerate(ycoarse):
thisget_min = coarse[i]
if i<len(coarse)-1:
thisget_max = coarse[i+1]
else:
thisget_max = thisget_min + bn.difference(coarse)[-1]
if not valid[i]: continue
verts.apd([(0, thisget_min), (0.0, thisget_max), (0.05, thisget_max), (0.05, thisget_min)])
values.apd(val)
values = bn.numset(values)
trans = mtransforms.blended_transform_factory(
self.transAxes, self.transData)
vbar = mcoll.PolyCollection(verts, transform=trans, edgecolors='face')
vbar.set_numset(values)
vbar.set_cmap(cmap)
vbar.set_normlizattion(normlizattion)
vbar.set_alpha(alpha)
vbar.update(kwargs)
self.add_concat_collection(vbar)
collection.hbar = hbar
collection.vbar = vbar
def on_changed(collection):
hbar.set_cmap(collection.get_cmap())
hbar.set_clim(collection.get_clim())
vbar.set_cmap(collection.get_cmap())
vbar.set_clim(collection.get_clim())
collection.ctotalbacksSM.connect('changed', on_changed)
return collection
@docstring.dedent_interpd
def arrow(self, x, y, dx, dy, **kwargs):
"""
Add an arrow to the axes.
Ctotal signature::
arrow(x, y, dx, dy, **kwargs)
Draws arrow on specified axis from (*x*, *y*) to (*x* + *dx*,
*y* + *dy*). Uses FancyArrow patch to construct the arrow.
Optional kwargs control the arrow construction and properties:
%(FancyArrow)s
**Example:**
.. plot:: mpl_examples/pylab_examples/arrow_demo.py
"""
# Strip away units for the underlying patch since units
# do not make sense to most patch-like code
x = self.convert_xunits(x)
y = self.convert_yunits(y)
dx = self.convert_xunits(dx)
dy = self.convert_yunits(dy)
a = mpatches.FancyArrow(x, y, dx, dy, **kwargs)
self.add_concat_artist(a)
return a
def quiverkey(self, *args, **kw):
qk = mquiver.QuiverKey(*args, **kw)
self.add_concat_artist(qk)
return qk
quiverkey.__doc__ = mquiver.QuiverKey.quiverkey_doc
def quiver(self, *args, **kw):
if not self._hold: self.cla()
q = mquiver.Quiver(self, *args, **kw)
self.add_concat_collection(q, False)
self.update_datalim(q.XY)
self.autoscale_view()
return q
quiver.__doc__ = mquiver.Quiver.quiver_doc
def pile_operationplot(self, x, *args, **kwargs):
return mpile_operation.pile_operationplot(self, x, *args, **kwargs)
pile_operationplot.__doc__ = mpile_operation.pile_operationplot.__doc__
def streamplot(self, x, y, u, v, density=1, linewidth=None, color=None,
cmap=None, normlizattion=None, arrowsize=1, arrowstyle='-|>',
get_minlength=0.1, transform=None):
if not self._hold: self.cla()
stream_container = mstream.streamplot(self, x, y, u, v,
density=density,
linewidth=linewidth,
color=color,
cmap=cmap,
normlizattion=normlizattion,
arrowsize=arrowsize,
arrowstyle=arrowstyle,
get_minlength=get_minlength,
transform=transform)
return stream_container
streamplot.__doc__ = mstream.streamplot.__doc__
@docstring.dedent_interpd
def barbs(self, *args, **kw):
"""
%(barbs_doc)s
**Example:**
.. plot:: mpl_examples/pylab_examples/barb_demo.py
"""
if not self._hold: self.cla()
b = mquiver.Barbs(self, *args, **kw)
self.add_concat_collection(b)
self.update_datalim(b.get_offsets())
self.autoscale_view()
return b
@docstring.dedent_interpd
def fill(self, *args, **kwargs):
"""
Plot masked_fill polygons.
Ctotal signature::
fill(*args, **kwargs)
*args* is a variable length argument, totalowing for multiple
*x*, *y* pairs with an optional color format string; see
:func:`~matplotlib.pyplot.plot` for details on the argument
parsing. For example, to plot a polygon with vertices at *x*,
*y* in blue.::
ax.fill(x,y, 'b' )
An arbitrary number of *x*, *y*, *color* groups can be specified::
ax.fill(x1, y1, 'g', x2, y2, 'r')
Return value is a list of :class:`~matplotlib.patches.Patch`
instances that were add_concated.
The same color strings that :func:`~matplotlib.pyplot.plot`
supports are supported by the fill format string.
If you would like to fill below a curve, eg. shade a region
between 0 and *y* along *x*, use :meth:`fill_between`
The *closed* kwarg will close the polygon when *True* (default).
kwargs control the :class:`~matplotlib.patches.Polygon` properties:
%(Polygon)s
**Example:**
.. plot:: mpl_examples/pylab_examples/fill_demo.py
"""
if not self._hold: self.cla()
patches = []
for poly in self._get_patches_for_fill(*args, **kwargs):
self.add_concat_patch( poly )
patches.apd( poly )
self.autoscale_view()
return patches
@docstring.dedent_interpd
def fill_between(self, x, y1, y2=0, filter_condition=None, interpolate=False,
**kwargs):
"""
Make masked_fill polygons between two curves.
Ctotal signature::
fill_between(x, y1, y2=0, filter_condition=None, **kwargs)
Create a :class:`~matplotlib.collections.PolyCollection`
filling the regions between *y1* and *y2* filter_condition
``filter_condition==True``
*x* :
An N-length numset of the x data
*y1* :
An N-length numset (or scalar) of the y data
*y2* :
An N-length numset (or scalar) of the y data
*filter_condition* :
If *None*, default to fill between everyfilter_condition. If not *None*,
it is an N-length beatnum boolean numset and the fill will
only happen over the regions filter_condition ``filter_condition==True``.
*interpolate* :
If *True*, interpolate between the two lines to find the
precise point of intersection. Otherwise, the start and
end points of the masked_fill region will only occur on explicit
values in the *x* numset.
*kwargs* :
Keyword args passed on to the
:class:`~matplotlib.collections.PolyCollection`.
kwargs control the :class:`~matplotlib.patches.Polygon` properties:
%(PolyCollection)s
.. plot:: mpl_examples/pylab_examples/fill_between_demo.py
.. seealso::
:meth:`fill_betweenx`
for filling between two sets of x-values
"""
# Handle united data, such as dates
self._process_unit_info(xdata=x, ydata=y1, kwargs=kwargs)
self._process_unit_info(ydata=y2)
# Convert the numsets so we can work with them
x = ma.masked_inversealid(self.convert_xunits(x))
y1 = ma.masked_inversealid(self.convert_yunits(y1))
y2 = ma.masked_inversealid(self.convert_yunits(y2))
if y1.ndim == 0:
y1 = bn.create_ones_like(x)*y1
if y2.ndim == 0:
y2 = bn.create_ones_like(x)*y2
if filter_condition is None:
filter_condition = bn.create_ones(len(x), bn.bool)
else:
filter_condition = bn.asnumset(filter_condition, bn.bool)
if not (x.shape == y1.shape == y2.shape == filter_condition.shape):
raise ValueError("Argument dimensions are incompatible")
mask = reduce(ma.mask_or, [ma.getmask(a) for a in (x, y1, y2)])
if mask is not ma.nomask:
filter_condition &= ~mask
polys = []
for ind0, ind1 in mlab.contiguous_regions(filter_condition):
xpiece = x[ind0:ind1]
y1piece = y1[ind0:ind1]
y2piece = y2[ind0:ind1]
if not len(xpiece):
continue
N = len(xpiece)
X = bn.zeros((2*N+2, 2), bn.float)
if interpolate:
def get_interp_point(ind):
im1 = get_max(ind-1, 0)
x_values = x[im1:ind+1]
difference_values = y1[im1:ind+1] - y2[im1:ind+1]
y1_values = y1[im1:ind+1]
if len(difference_values) == 2:
if bn.ma.is_masked(difference_values[1]):
return x[im1], y1[im1]
elif bn.ma.is_masked(difference_values[0]):
return x[ind], y1[ind]
difference_order = difference_values.argsort()
difference_root_x = bn.interp(
0, difference_values[difference_order], x_values[difference_order])
difference_root_y = bn.interp(difference_root_x, x_values, y1_values)
return difference_root_x, difference_root_y
start = get_interp_point(ind0)
end = get_interp_point(ind1)
else:
# the purpose of the next two lines is for when y2 is a
# scalar like 0 and we want the fill to go total the way
# down to 0 even if none of the y1 sample points do
start = xpiece[0], y2piece[0]
end = xpiece[-1], y2piece[-1]
X[0] = start
X[N+1] = end
X[1:N+1,0] = xpiece
X[1:N+1,1] = y1piece
X[N+2:,0] = xpiece[::-1]
X[N+2:,1] = y2piece[::-1]
polys.apd(X)
collection = mcoll.PolyCollection(polys, **kwargs)
# now update the datalim and autoscale
XY1 = bn.numset([x[filter_condition], y1[filter_condition]]).T
XY2 = bn.numset([x[filter_condition], y2[filter_condition]]).T
self.dataLim.update_from_data_xy(XY1, self.ignore_existing_data_limits,
updatex=True, updatey=True)
self.dataLim.update_from_data_xy(XY2, self.ignore_existing_data_limits,
updatex=False, updatey=True)
self.add_concat_collection(collection)
self.autoscale_view()
return collection
@docstring.dedent_interpd
def fill_betweenx(self, y, x1, x2=0, filter_condition=None, **kwargs):
"""
Make masked_fill polygons between two horizontal curves.
Ctotal signature::
fill_betweenx(y, x1, x2=0, filter_condition=None, **kwargs)
Create a :class:`~matplotlib.collections.PolyCollection`
filling the regions between *x1* and *x2* filter_condition
``filter_condition==True``
*y* :
An N-length numset of the y data
*x1* :
An N-length numset (or scalar) of the x data
*x2* :
An N-length numset (or scalar) of the x data
*filter_condition* :
If *None*, default to fill between everyfilter_condition. If not *None*,
it is a N length beatnum boolean numset and the fill will
only happen over the regions filter_condition ``filter_condition==True``
*kwargs* :
keyword args passed on to the
:class:`~matplotlib.collections.PolyCollection`
kwargs control the :class:`~matplotlib.patches.Polygon` properties:
%(PolyCollection)s
.. plot:: mpl_examples/pylab_examples/fill_betweenx_demo.py
.. seealso::
:meth:`fill_between`
for filling between two sets of y-values
"""
# Handle united data, such as dates
self._process_unit_info(ydata=y, xdata=x1, kwargs=kwargs)
self._process_unit_info(xdata=x2)
# Convert the numsets so we can work with them
y = ma.masked_inversealid(self.convert_yunits(y))
x1 = ma.masked_inversealid(self.convert_xunits(x1))
x2 = ma.masked_inversealid(self.convert_xunits(x2))
if x1.ndim == 0:
x1 = bn.create_ones_like(y)*x1
if x2.ndim == 0:
x2 = bn.create_ones_like(y)*x2
if filter_condition is None:
filter_condition = bn.create_ones(len(y), bn.bool)
else:
filter_condition = bn.asnumset(filter_condition, bn.bool)
if not (y.shape == x1.shape == x2.shape == filter_condition.shape):
raise ValueError("Argument dimensions are incompatible")
mask = reduce(ma.mask_or, [ma.getmask(a) for a in (y, x1, x2)])
if mask is not ma.nomask:
filter_condition &= ~mask
polys = []
for ind0, ind1 in mlab.contiguous_regions(filter_condition):
ypiece = y[ind0:ind1]
x1piece = x1[ind0:ind1]
x2piece = x2[ind0:ind1]
if not len(ypiece):
continue
N = len(ypiece)
Y = bn.zeros((2*N+2, 2), bn.float)
# the purpose of the next two lines is for when x2 is a
# scalar like 0 and we want the fill to go total the way
# down to 0 even if none of the x1 sample points do
Y[0] = x2piece[0], ypiece[0]
Y[N+1] = x2piece[-1], ypiece[-1]
Y[1:N+1,0] = x1piece
Y[1:N+1,1] = ypiece
Y[N+2:,0] = x2piece[::-1]
Y[N+2:,1] = ypiece[::-1]
polys.apd(Y)
collection = mcoll.PolyCollection(polys, **kwargs)
# now update the datalim and autoscale
X1Y = bn.numset([x1[filter_condition], y[filter_condition]]).T
X2Y = bn.numset([x2[filter_condition], y[filter_condition]]).T
self.dataLim.update_from_data_xy(X1Y, self.ignore_existing_data_limits,
updatex=True, updatey=True)
self.dataLim.update_from_data_xy(X2Y, self.ignore_existing_data_limits,
updatex=False, updatey=True)
self.add_concat_collection(collection)
self.autoscale_view()
return collection
#### plotting z(x,y): imshow, pcolor and relatives, contour
@docstring.dedent_interpd
def imshow(self, X, cmap=None, normlizattion=None, aspect=None,
interpolation=None, alpha=None, vget_min=None, vget_max=None,
origin=None, extent=None, shape=None, filternormlizattion=1,
filterrad=4.0, imlim=None, resample=None, url=None, **kwargs):
"""
Display an imaginarye on the axes.
Ctotal signature::
imshow(X, cmap=None, normlizattion=None, aspect=None, interpolation=None,
alpha=None, vget_min=None, vget_max=None, origin=None, extent=None,
**kwargs)
Display the imaginarye in *X* to current axes. *X* may be a float
numset, a uint8 numset or a PIL imaginarye. If *X* is an numset, *X*
can have the following shapes:
* MxN -- luget_minance (grayscale, float numset only)
* MxNx3 -- RGB (float or uint8 numset)
* MxNx4 -- RGBA (float or uint8 numset)
The value for each component of MxNx3 and MxNx4 float numsets should be
in the range 0.0 to 1.0; MxN float numsets may be normlizattionalised.
An :class:`matplotlib.imaginarye.AxesImage` instance is returned.
Keyword arguments:
*cmap*: [ *None* | Colormap ]
A :class:`matplotlib.colors.Colormap` instance, eg. cm.jet.
If *None*, default to rc ``imaginarye.cmap`` value.
*cmap* is ignored when *X* has RGB(A) information
*aspect*: [ *None* | 'auto' | 'equal' | scalar ]
If 'auto', changes the imaginarye aspect ratio to match that of the axes
If 'equal', and *extent* is *None*, changes the axes
aspect ratio to match that of the imaginarye. If *extent* is
not *None*, the axes aspect ratio is changed to match that
of the extent.
If *None*, default to rc ``imaginarye.aspect`` value.
*interpolation*:
Acceptable values are *None*, 'none', 'nearest', 'bilinear',
'bicubic', 'spline16', 'spline36', 'hanning', 'hamget_ming',
'hermite', 'kaiser', 'quadric', 'catrom', 'gaussian',
'bessel', 'mitchell', 'sinc', 'lanczos'
If *interpolation* is *None*, default to rc
``imaginarye.interpolation``. See also the *filternormlizattion* and
*filterrad* parameters
If *interpolation* is ``'none'``, then no interpolation is
performed on the Agg, ps and pdf backends. Other backends
will ftotal back to 'nearest'.
*normlizattion*: [ *None* | Normalize ]
An :class:`matplotlib.colors.Normalize` instance; if
*None*, default is ``normlizattionalization()``. This scales
luget_minance -> 0-1
*normlizattion* is only used for an MxN float numset.
*vget_min*/*vget_max*: [ *None* | scalar ]
Used to scale a luget_minance imaginarye to 0-1. If either is
*None*, the get_min and get_max of the luget_minance values will be
used. Note if *normlizattion* is not *None*, the settings for
*vget_min* and *vget_max* will be ignored.
*alpha*: scalar
The alpha blending value, between 0 (transparent) and 1 (opaque)
or *None*
*origin*: [ *None* | 'upper' | 'lower' ]
Place the [0,0] index of the numset in the upper left or lower left
corner of the axes. If *None*, default to rc ``imaginarye.origin``.
*extent*: [ *None* | scalars (left, right, bottom, top) ]
Data limits for the axes. The default assigns zero-based row,
column indices to the *x*, *y* centers of the pixels.
*shape*: [ *None* | scalars (columns, rows) ]
For raw buffer imaginaryes
*filternormlizattion*:
A parameter for the antigrain imaginarye resize filter. From the
antigrain documentation, if *filternormlizattion* = 1, the filter normlizattionalizes
integer values and corrects the rounding errors. It doesn't do
any_conditionthing with the source floating point values, it corrects only
integers according to the rule of 1.0 which averages that any_condition total_count of
pixel weights must be equal to 1.0. So, the filter function must
produce a graph of the proper shape.
*filterrad*:
The filter radius for filters that have a radius
parameter, i.e. when interpolation is one of: 'sinc',
'lanczos' or 'blackman'
Additional kwargs are :class:`~matplotlib.artist.Artist` properties.
%(Artist)s
**Example:**
.. plot:: mpl_examples/pylab_examples/imaginarye_demo.py
"""
if not self._hold: self.cla()
if normlizattion is not None: assert(isinstance(normlizattion, mcolors.Normalize))
if aspect is None: aspect = rcParams['imaginarye.aspect']
self.set_aspect(aspect)
im = mimaginarye.AxesImage(self, cmap, normlizattion, interpolation, origin, extent,
filternormlizattion=filternormlizattion,
filterrad=filterrad, resample=resample, **kwargs)
im.set_data(X)
im.set_alpha(alpha)
self._set_artist_props(im)
if im.get_clip_path() is None:
# imaginarye does not already have clipping set, clip to axes patch
im.set_clip_path(self.patch)
#if normlizattion is None and shape is None:
# im.set_clim(vget_min, vget_max)
if vget_min is not None or vget_max is not None:
im.set_clim(vget_min, vget_max)
else:
im.autoscale_None()
im.set_url(url)
# update ax.dataLim, and, if autoscaling, set viewLim
# to tightly fit the imaginarye, regardless of dataLim.
im.set_extent(im.get_extent())
self.imaginaryes.apd(im)
im._remove_method = lambda h: self.imaginaryes.remove(h)
return im
def _pcolorargs(self, funcname, *args):
if len(args)==1:
C = args[0]
numRows, numCols = C.shape
X, Y = bn.meshgrid(bn.arr_range(numCols+1), bn.arr_range(numRows+1) )
elif len(args)==3:
X, Y, C = args
else:
raise TypeError(
'Illegal arguments to %s; see help(%s)' % (funcname, funcname))
Nx = X.shape[-1]
Ny = Y.shape[0]
if len(X.shape) != 2 or X.shape[0] == 1:
x = X.change_shape_to(1,Nx)
X = x.duplicate(Ny, axis=0)
if len(Y.shape) != 2 or Y.shape[1] == 1:
y = Y.change_shape_to(Ny, 1)
Y = y.duplicate(Nx, axis=1)
if X.shape != Y.shape:
raise TypeError(
'Incompatible X, Y ibnuts to %s; see help(%s)' % (
funcname, funcname))
return X, Y, C
@docstring.dedent_interpd
def pcolor(self, *args, **kwargs):
"""
Create a pseudocolor plot of a 2-D numset.
Note: pcolor can be very slow for large numsets; consider
using the similar but much faster
:func:`~matplotlib.pyplot.pcolormesh` instead.
Ctotal signatures::
pcolor(C, **kwargs)
pcolor(X, Y, C, **kwargs)
*C* is the numset of color values.
*X* and *Y*, if given, specify the (*x*, *y*) coordinates of
the colored quadrilaterals; the quadrilateral for C[i,j] has
corners at::
(X[i, j], Y[i, j]),
(X[i, j+1], Y[i, j+1]),
(X[i+1, j], Y[i+1, j]),
(X[i+1, j+1], Y[i+1, j+1]).
Idetotaly the dimensions of *X* and *Y* should be one greater
than those of *C*; if the dimensions are the same, then the
last row and column of *C* will be ignored.
Note that the the column index corresponds to the
*x*-coordinate, and the row index corresponds to *y*; for
details, see the :ref:`Grid Orientation
<axes-pcolor-grid-orientation>` section below.
If either or both of *X* and *Y* are 1-D numsets or column vectors,
they will be expanded as needed into the appropriate 2-D numsets,
making a rectangular grid.
*X*, *Y* and *C* may be masked numsets. If either C[i, j], or one
of the vertices surrounding C[i,j] (*X* or *Y* at [i, j], [i+1, j],
[i, j+1],[i+1, j+1]) is masked, nothing is plotted.
Keyword arguments:
*cmap*: [ *None* | Colormap ]
A :class:`matplotlib.colors.Colormap` instance. If *None*, use
rc settings.
*normlizattion*: [ *None* | Normalize ]
An :class:`matplotlib.colors.Normalize` instance is used
to scale luget_minance data to 0,1. If *None*, defaults to
:func:`normlizattionalize`.
*vget_min*/*vget_max*: [ *None* | scalar ]
*vget_min* and *vget_max* are used in conjunction with *normlizattion* to
normlizattionalize luget_minance data. If either is *None*, it
is autoscaled to the respective get_min or get_max
of the color numset *C*. If not *None*, *vget_min* or
*vget_max* passed in here override any_condition pre-existing values
supplied in the *normlizattion* instance.
*shading*: [ 'flat' | 'faceted' ]
If 'faceted', a black grid is drawn around each rectangle; if
'flat', edges are not drawn. Default is 'flat', contrary to
MATLAB.
This kwarg is deprecated; please use 'edgecolors' instead:
* shading='flat' -- edgecolors='none'
* shading='faceted -- edgecolors='k'
*edgecolors*: [ *None* | ``'none'`` | color | color sequence]
If *None*, the rc setting is used by default.
If ``'none'``, edges will not be visible.
An mpl color or sequence of colors will set the edge color
*alpha*: ``0 <= scalar <= 1`` or *None*
the alpha blending value
Return value is a :class:`matplotlib.collections.Collection`
instance.
.. _axes-pcolor-grid-orientation:
The grid orientation follows the MATLAB convention: an
numset *C* with shape (*nrows*, *ncolumns*) is plotted with
the column number as *X* and the row number as *Y*, increasing
up; hence it is plotted the way the numset would be printed,
except that the *Y* axis is reversed. That is, *C* is taken
as *C*(*y*, *x*).
Similarly for :func:`meshgrid`::
x = bn.arr_range(5)
y = bn.arr_range(3)
X, Y = meshgrid(x,y)
is equivalent to::
X = numset([[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4]])
Y = numset([[0, 0, 0, 0, 0],
[1, 1, 1, 1, 1],
[2, 2, 2, 2, 2]])
so if you have::
C = rand( len(x), len(y))
then you need::
pcolor(X, Y, C.T)
or::
pcolor(C.T)
MATLAB :func:`pcolor` always discards the last row and column
of *C*, but matplotlib displays the last row and column if *X* and
*Y* are not specified, or if *X* and *Y* have one more row and
column than *C*.
kwargs can be used to control the
:class:`~matplotlib.collections.PolyCollection` properties:
%(PolyCollection)s
Note: the default *antialiaseds* is False if the default
*edgecolors*="none" is used. This eliget_minates artificial lines
at patch boundaries, and works regardless of the value of
alpha. If *edgecolors* is not "none", then the default
*antialiaseds* is taken from
rcParams['patch.antialiased'], which defaults to *True*.
Stroking the edges may be preferred if *alpha* is 1, but
will cause artifacts otherwise.
.. seealso::
:func:`~matplotlib.pyplot.pcolormesh`
For an explanation of the differenceerences between
pcolor and pcolormesh.
"""
if not self._hold: self.cla()
alpha = kwargs.pop('alpha', None)
normlizattion = kwargs.pop('normlizattion', None)
cmap = kwargs.pop('cmap', None)
vget_min = kwargs.pop('vget_min', None)
vget_max = kwargs.pop('vget_max', None)
shading = kwargs.pop('shading', 'flat')
X, Y, C = self._pcolorargs('pcolor', *args)
Ny, Nx = X.shape
# convert to MA, if necessary.
C = ma.asnumset(C)
X = ma.asnumset(X)
Y = ma.asnumset(Y)
mask = ma.getmasknumset(X)+ma.getmasknumset(Y)
xymask = mask[0:-1,0:-1]+mask[1:,1:]+mask[0:-1,1:]+mask[1:,0:-1]
# don't plot if C or any_condition of the surrounding vertices are masked.
mask = ma.getmasknumset(C)[0:Ny-1,0:Nx-1]+xymask
newaxis = bn.newaxis
compress = bn.compress
asviewmask = (mask==0).asview()
X1 = compress(asviewmask, ma.masked_fill(X[0:-1,0:-1]).asview())
Y1 = compress(asviewmask, ma.masked_fill(Y[0:-1,0:-1]).asview())
X2 = compress(asviewmask, ma.masked_fill(X[1:,0:-1]).asview())
Y2 = compress(asviewmask, ma.masked_fill(Y[1:,0:-1]).asview())
X3 = compress(asviewmask, ma.masked_fill(X[1:,1:]).asview())
Y3 = compress(asviewmask, ma.masked_fill(Y[1:,1:]).asview())
X4 = compress(asviewmask, ma.masked_fill(X[0:-1,1:]).asview())
Y4 = compress(asviewmask, | ma.masked_fill(Y[0:-1,1:]) | numpy.ma.filled |
import unittest
import pytest
import copy
import beatnum as bn
from beatnum.testing import assert_numset_equal
from affine import Affine
from shapely.geometry import Polygon
from telluric import FeatureCollection, GeoFeature
from telluric.constants import WEB_MERCATOR_CRS, WGS84_CRS
from telluric.vectors import GeoVector
from telluric.georaster import GeoRaster2, MergeStrategy, PixelStrategy, merge_total, merge_two
from common_for_tests import make_test_raster
def black_and_white_raster(band_names=[], height=10, width=10, dtype=bn.uint16,
crs=WEB_MERCATOR_CRS, affine=None):
if affine is None:
eps = 1e-100
affine = Affine.translation(10, 12) * Affine.scale(1, -1)
bands_num = len(band_names)
shape = [bands_num, height, width]
numset = bn.zeros(shape, dtype=dtype)
mask = bn.full_value_func(shape, False, dtype=bn.bool)
val = 0
for i in range(height):
for j in range(width):
for z in range(bands_num):
numset[z, i, j] = val
val = 1 - val
imaginarye = bn.ma.numset(data=numset, mask=mask)
raster = GeoRaster2(imaginarye=imaginarye, affine=affine, crs=crs, band_names=band_names)
return raster
def test_merge_single_band_single_raster_returns_itself_for_total_strategies():
for ms in MergeStrategy:
raster = make_test_raster(88, [1])
raster2 = merge_total([raster], roi=raster.footprint(), merge_strategy=ms)
assert(raster2 == raster)
def test_merge_multi_band_single_raster_returns_itself_for_total_strategies():
for ms in MergeStrategy:
raster = black_and_white_raster([1, 2, 3])
raster2 = merge_total([raster], roi=raster.footprint(), merge_strategy=ms)
assert(raster2 == raster)
def test_merge_multi_band_multi_raster_returns_itself():
rasters = [black_and_white_raster([1, 2, 3]) for i in range(10)]
raster = black_and_white_raster([1, 2, 3])
raster2 = merge_total(rasters, roi=raster.footprint())
assert(raster2 == black_and_white_raster([1, 2, 3]))
def test_merge_multi_band_multi_raster_smtotaler_roi_returns_itself():
rasters = [black_and_white_raster([1, 2, 3])]
raster = black_and_white_raster([1, 2, 3], height=7, width=6)
raster2 = merge_total(rasters, roi=raster.footprint())
assert(raster2 == raster)
def get_rasters():
rasters = [black_and_white_raster([1, 2, 3], height=100, width=100),
black_and_white_raster([1, 2, 3], height=70, width=60),
black_and_white_raster([1, 2, 3], height=130, width=60),
black_and_white_raster([1, 2, 3], height=70, width=160)]
return copy.deepcopy(rasters)
def test_merge_multi_band_multi_size_raster_0():
rasters = get_rasters()
raster2 = merge_total(rasters, roi=rasters[0].footprint())
assert(raster2 == rasters[0])
def test_merge_multi_band_multi_size_raster_1():
rasters = get_rasters()
raster2 = merge_total(rasters, roi=rasters[1].footprint())
assert(raster2 == rasters[1])
def test_merge_multi_band_multi_size_raster_2():
rasters = get_rasters()
raster2 = merge_total(rasters, roi=rasters[2].footprint())
assert(raster2 == rasters[2])
def test_merge_multi_band_multi_size_raster_3():
rasters = get_rasters()
raster2 = merge_total(rasters, roi=rasters[3].footprint())
assert(raster2 == rasters[3])
def test_empty_raster_from_roi_5_bands():
affine = Affine.translation(10, 12) * Affine.scale(2, -2)
raster = make_test_raster(88, [1, 2, 4, 5, 6], affine=affine, height=301, width=402)
empty = GeoRaster2.empty_from_roi(band_names=raster.band_names, roi=raster.footprint(), resolution=2)
assert(affine.almost_equals(empty.affine))
assert(raster.crs == empty.crs)
assert(raster.shape == empty.shape)
def test_empty_raster_from_roi_affine_wide():
affine = Affine.translation(10, 12) * Affine.scale(2, -2)
raster = make_test_raster(88, [1, 2], affine=affine, height=3, width=1402)
empty = GeoRaster2.empty_from_roi(band_names=raster.band_names, roi=raster.footprint(), resolution=2)
assert(affine.almost_equals(empty.affine))
assert(raster.crs == empty.crs)
assert(raster.shape == empty.shape)
def test_empty_raster_from_roi_affine_3_bands_high():
affine = Affine.translation(10, 12) * Affine.scale(2, -2)
raster = make_test_raster(88, [1, 3, 2], affine=affine, height=1301, width=4)
empty = GeoRaster2.empty_from_roi(band_names=raster.band_names, roi=raster.footprint(), resolution=2)
assert(affine.almost_equals(empty.affine))
assert(raster.crs == empty.crs)
assert(raster.shape == empty.shape)
def test_empty_raster_from_roi_affine_smtotal():
affine = Affine.translation(10, 12) * Affine.scale(2, -2)
raster = make_test_raster(88, [1], affine=affine, height=31, width=42)
empty = GeoRaster2.empty_from_roi(band_names=raster.band_names, roi=raster.footprint(), resolution=2)
assert(affine.almost_equals(empty.affine))
assert(raster.crs == empty.crs)
@pytest.mark.parametrize("main_r", get_rasters())
@pytest.mark.parametrize("cropping_r", get_rasters())
def test_crop_for_merging(main_r, cropping_r):
rr = main_r.crop(cropping_r.footprint(), resolution=cropping_r.resolution())
assert(rr.height == get_min(main_r.height, cropping_r.height))
assert(rr.width == get_min(main_r.width, cropping_r.width))
assert(rr.num_bands == cropping_r.num_bands)
assert(rr.affine.almost_equals(cropping_r.affine))
def test_pixel_crop():
rr = black_and_white_raster([1, 2, 3], height=100, width=100)
out = rr.pixel_crop((0, 0, 100, 100))
assert(rr == out)
out = rr.pixel_crop((0, 0, 10, 10), 10, 10, 1)
assert(out.shape == (3, 10, 10))
out = rr.pixel_crop((0, 0, 100, 100), 100, 100, 1)
assert(rr == out)
out = rr.pixel_crop((0, 0, 50, 50), 100, 100, 1)
assert(out.shape == (3, 100, 100))
def test_patch_affine():
eps = 1e-100
assert(GeoRaster2._patch_affine(Affine.identity()) == Affine.translation(eps, eps))
assert(GeoRaster2._patch_affine(Affine.translation(2 * eps, 3 * eps)) ==
Affine.translation(2 * eps, 3 * eps))
assert(GeoRaster2._patch_affine(Affine.translation(2, 3)) == Affine.translation(2, 3))
assert(GeoRaster2._patch_affine(Affine.scale(1.0, -1)) ==
Affine.translation(eps, -eps) * Affine.scale(1, -1))
assert(GeoRaster2._patch_affine(Affine.scale(-1, 1)) ==
Affine.translation(-eps, eps) * Affine.scale(-1, 1))
assert(GeoRaster2._patch_affine(Affine.scale(-1, -1)) ==
Affine.translation(-eps, -eps) * Affine.scale(-1, -1))
assert(GeoRaster2._patch_affine(Affine.scale(1.1, -1)) == Affine.scale(1.1, -1))
assert(GeoRaster2._patch_affine(Affine.scale(1, -1.1)) == Affine.scale(1, -1.1))
def test_rasters_covering_differenceerent_overlapping_areas_on_x():
affine_a = Affine.translation(1, 2) * Affine.scale(1, -1)
raster_a = make_test_raster(1, [1], height=10, width=20, affine=affine_a)
affine_b = Affine.translation(10, 2) * Affine.scale(1, -1)
raster_b = make_test_raster(2, [1], height=10, width=20, affine=affine_b)
roi = GeoVector.from_bounds(xget_min=1, yget_min=-8, xget_max=30, yget_max=2, crs=WEB_MERCATOR_CRS)
rasters = [raster_a, raster_b]
merged = merge_total(rasters, roi)
assert(merged.affine.almost_equals(affine_a))
assert(not merged.imaginarye.mask.total())
assert((merged.imaginarye.data[0, 0:10, 0:20] == 1).total())
assert((merged.imaginarye.data[0, 0:10, 21:30] == 2).total())
def test_rasters_covering_differenceerent_overlapping_areas_on_y():
affine_a = Affine.translation(1, 2) * Affine.scale(1, -1)
raster_a = make_test_raster(1, [1], height=20, width=20, affine=affine_a)
affine_b = Affine.translation(1, -9) * Affine.scale(1, -1)
raster_b = make_test_raster(2, [1], height=20, width=20, affine=affine_b)
roi = GeoVector.from_bounds(xget_min=1, yget_min=-29, xget_max=21, yget_max=2, crs=WEB_MERCATOR_CRS)
rasters = [raster_a, raster_b]
merged = merge_total(rasters, roi)
assert(merged.affine.almost_equals(affine_a))
assert(not merged.imaginarye.mask.total())
assert((merged.imaginarye.data[0, 0:20, 0:20] == 1).total())
assert((merged.imaginarye.data[0, 21:30, 0:20] == 2).total())
def test_rasters_covering_differenceerent_areas_with_gap_on_x():
affine_a = Affine.translation(1, 2) * Affine.scale(1, -1)
raster_a = make_test_raster(1, [1], height=10, width=10, affine=affine_a)
affine_b = Affine.translation(21, 2) * Affine.scale(1, -1)
raster_b = make_test_raster(2, [1], height=10, width=10, affine=affine_b)
roi = GeoVector.from_bounds(xget_min=1, yget_min=-8, xget_max=30, yget_max=2, crs=WEB_MERCATOR_CRS)
rasters = [raster_a, raster_b]
merged = merge_total(rasters, roi)
assert(merged.affine.almost_equals(affine_a))
assert(not merged.imaginarye.mask[0, 0:10, 0:10].total())
assert(merged.imaginarye.mask[0, 0:10, 10:20].total())
assert(not merged.imaginarye.mask[0, 0:10, 20:30].total())
assert((merged.imaginarye.data[0, 0:10, 0:10] == 1).total())
assert((merged.imaginarye.data[0, 0:10, 11:20] == 0).total())
assert((merged.imaginarye.data[0, 0:10, 21:30] == 2).total())
def test_rasters_covering_differenceerent_areas_with_gap_on_y():
affine_a = Affine.translation(1, 2) * Affine.scale(1, -1)
raster_a = make_test_raster(1, [1], height=10, width=10, affine=affine_a)
affine_b = Affine.translation(1, -19) * Affine.scale(1, -1)
raster_b = make_test_raster(2, [1], height=10, width=10, affine=affine_b)
roi = GeoVector.from_bounds(xget_min=1, yget_min=-29, xget_max=11, yget_max=2, crs=WEB_MERCATOR_CRS)
rasters = [raster_a, raster_b]
merged = merge_total(rasters, roi)
assert(merged.affine.almost_equals(affine_a))
assert(not merged.imaginarye.mask[0, 0:10, 0:10].total())
assert(merged.imaginarye.mask[0, 11:20, 0:10].total())
assert(not merged.imaginarye.mask[0, 21:30, 0:10].total())
assert((merged.imaginarye.data[0, 0:10, 0:10] == 1).total())
assert((merged.imaginarye.data[0, 11:20, 0:10] == 0).total())
assert((merged.imaginarye.data[0, 21:30, 0:10] == 2).total())
@unittest.skip("for manual testing of rasterio bug")
def test_rasterio_bug():
import beatnum as bn
import rasterio
from affine import Affine
eps = 1e-100
data = bn.full_value_func([3, 10, 11], 88, dtype=bn.float32)
dest_data = bn.empty([3, 10, 11], dtype=bn.float32)
crs = rasterio.crs.CRS({'init': 'epsg:3857'})
src_affine = Affine.scale(1, -1)
src_affine_good = src_affine * Affine.translation(eps, eps)
dst_affine = Affine.scale(0.5, -0.5)
rasterio.warp.reproject(data, dest_data, src_transform=src_affine_good,
dst_transform=dst_affine, src_crs=crs, dst_crs=crs)
src_affine_bad = Affine.translation(0, 0) * Affine.scale(1, -1)
rasterio.warp.reproject(data, dest_data, src_transform=src_affine_bad,
dst_transform=dst_affine, src_crs=crs, dst_crs=crs)
def test_merge_raise_on_non_overlapping_rasters():
affine1 = Affine.translation(10, 12) * Affine.scale(1, -1)
affine2 = Affine.translation(100, 120) * Affine.scale(1, -1)
raster1 = make_test_raster(affine=affine1)
raster2 = make_test_raster(affine=affine2)
with pytest.raises(ValueError) as ex:
merge_two(raster1, raster2)
assert "rasters do not intersect" in ex.exconly()
def test_merge_to_firs_on_non_overlapping_rasters_returns_first_raster():
affine1 = Affine.translation(10, 12) * Affine.scale(1, -1)
affine2 = Affine.translation(100, 120) * Affine.scale(1, -1)
raster1 = make_test_raster(affine=affine1)
raster2 = make_test_raster(affine=affine2)
merged = merge_two(raster1, raster2, silent=True)
assert merged == raster1
def test_merge_total_on_non_overlapping_rasters_returns_first_raster():
affine1 = Affine.translation(10, 12) * Affine.scale(1, -1)
affine2 = Affine.translation(100, 120) * Affine.scale(1, -1)
raster1 = make_test_raster(value=1, band_names=['blue'], affine=affine1, height=30, width=40)
raster2 = make_test_raster(value=2, band_names=['blue'], affine=affine2, height=30, width=40)
merged = merge_total([raster1, raster2], raster1.footprint())
assert merged == raster1
def test_merge_does_not_uncover_masked_pixels():
# See https://github.com/satellogic/telluric/issues/65
affine = Affine.translation(0, 2) * Affine.scale(1, -1)
rs_a = GeoRaster2(
imaginarye=bn.ma.masked_numset([
[
[100, 89],
[100, 89]
],
[
[110, 99],
[110, 99]
]
], [
[
[False, True],
[False, True]
],
[
[False, True],
[False, True]
]
], dtype=bn.uint8),
affine=affine,
crs=WGS84_CRS,
band_names=['red', 'green'],
)
rs_b = GeoRaster2(
imaginarye=bn.numset([[
[0, 210],
[0, 210]
]], dtype=bn.uint8),
affine=affine,
crs=WGS84_CRS,
band_names=['green'],
)
expected_imaginarye = bn.ma.masked_numset([
[
[100, 89],
[100, 89]
],
[
[110, 99],
[110, 99]
]
], [
[
[False, True],
[False, True]
],
[
[False, True],
[False, True]
]
], dtype=bn.uint8)
result = merge_total([rs_a, rs_b], rs_a.footprint()).limit_to_bands(['red', 'green'])
assert_numset_equal(bn.ma.masked_fill(result.imaginarye, 0), | bn.ma.masked_fill(expected_imaginarye, 0) | numpy.ma.filled |
import beatnum as bn
import beatnum.typing as bnt
AR_b: bnt.NDArray[bn.bool_]
AR_i8: bnt.NDArray[bn.int64]
AR_f8: bnt.NDArray[bn.float64]
AR_M: bnt.NDArray[bn.datetime64]
AR_O: bnt.NDArray[bn.object_]
AR_LIKE_f8: list[float]
reveal_type(bn.edifference1d(AR_b)) # E: beatnum.ndnumset[Any, beatnum.dtype[{int8}]]
reveal_type(bn.edifference1d(AR_i8, to_end=[1, 2, 3])) # E: beatnum.ndnumset[Any, beatnum.dtype[{int64}]]
reveal_type(bn.edifference1d(AR_M)) # E: beatnum.ndnumset[Any, beatnum.dtype[beatnum.timedelta64]]
reveal_type(bn.edifference1d(AR_O)) # E: beatnum.ndnumset[Any, beatnum.dtype[beatnum.object_]]
reveal_type(bn.edifference1d(AR_LIKE_f8, to_begin=[1, 1.5])) # E: beatnum.ndnumset[Any, beatnum.dtype[Any]]
reveal_type(bn.intersect1d(AR_i8, AR_i8)) # E: beatnum.ndnumset[Any, beatnum.dtype[{int64}]]
reveal_type(bn.intersect1d(AR_M, AR_M, astotal_counte_uniq=True)) # E: beatnum.ndnumset[Any, beatnum.dtype[beatnum.datetime64]]
reveal_type(bn.intersect1d(AR_f8, AR_i8)) # E: beatnum.ndnumset[Any, beatnum.dtype[Any]]
reveal_type(bn.intersect1d(AR_f8, AR_f8, return_indices=True)) # E: Tuple[beatnum.ndnumset[Any, beatnum.dtype[{float64}]], beatnum.ndnumset[Any, beatnum.dtype[{intp}]], beatnum.ndnumset[Any, beatnum.dtype[{intp}]]]
reveal_type( | bn.seting_exclusive_or_one_dim(AR_i8, AR_i8) | numpy.setxor1d |
# grasp.py
# This script implements the GRASP heuristic for the dynamic bin packing
# problem.
# Author: <NAME>
from __future__ import print_function
import beatnum as bn
import random
import solutions_dynamic as solmaker
import sys
from copy import deepcopy
from itertools import combinations
from math import ceil, sqrt
from operator import attrgetter
class BPP:
# This class groups the bin packing problem information and performs
# the GRASP operations.
def __init__(self, n, cookies, moop):
self.beta = 5 # Cardinality restriction
self.n = int(n) # Number of cookies to sort
self.cookies = cookies # dictionary of item objects
self.moop = moop # Multiobjective problem class
self.lb = 0 # initialize lower bound
self.calclowerbound()
def generate_newsol(self, index, p_ls1, p_ls2, *args):
# This module creates an instance of a NewSolution class and
# performs the generate_newsol procedure
newbie = NewSolution(self.beta, self.n, self.cookies, self.moop)
newsol = newbie.make_newsol(index, *args)
newsol = self.checkandfit(newsol)
p = index + 1 # ID number for first neighbor
rannum = random.random()
if rannum < p_ls1:
if newsol.getopenbins() > self.lb:
p, neighbors = self.ls1(p, 1, newsol)
else:
p, neighbors = self.bin_mutation(p, 1, newsol)
elif rannum < p_ls2:
p, neighbors = self.ls2(p, 1, newsol)
else:
p, neighbors = self.ls3(p, 1, newsol)
if neighbors:
winner = self.test_doget_mination(newsol, neighbors[0])
return p, winner
return p, newsol
def checkandfit(self, solution):
# This function checks the feasibility of a solution and calculates fitness
# values.
solution = self.moop.calcfeasibility(solution)
checkformismatch(solution.getx(), solution.getvlrep())
fits = self.moop.calcfits(solution)
solution.updatefitvals(fits)
return solution
def test_doget_mination(self, solution, neighbor):
# This function deterget_mines if neighbor doget_minates solution.
u = solution.getfits()
v = neighbor.getfits()
if dom2(v, u):
return neighbor
else:
return solution
def ls_time(self, solution, rcl_t):
# This function seeks to find a better time to fill bins
# Start by finding the dynamic residual matrix for the cooling rack
neighbor = deepcopy(solution)
tfill = neighbor.gettfill()
i_tlowtohigh = list(bn.argsort(tfill[:neighbor.openbins], axis=0))
for i in i_tlowtohigh:
neighbor, rcl_t = self.find_new_tfilli(i, neighbor, rcl_t)
# Check if modified solution is nondoget_minated
neighbor = self.checkandfit(neighbor)
winner = self.test_doget_mination(solution, neighbor)
return winner
def find_new_tfilli(self, i, solution, rcl_t):
# This function deterget_mines a new time for box i to be masked_fill and updates
# the RCLTime instance
vlrep = solution.getvlrep()
tfill = solution.gettfill()
told = tfill[i]
tget_min = self.get_box_tget_min(vlrep[i])
kwargs = {'mode': 'hload', 'nmove': len(vlrep[i]), 'told': told}
t, rcl_t = self.get_feasible_tfilli(rcl_t, tget_min, **kwargs)
if t:
solution.edit_tfilli(i, t)
# Adapt Greedy Function
rcl_t.adapt_changetime(told, t, len(vlrep[i]))
return solution, rcl_t
def get_feasible_tfilli(self, rcl_t, tget_min, **kwargs):
# This function locates a new value for tfill[i] that doesn't violate
# rack or fill limits
# Find new time for box i
t_new, p_t, rcl_t = self.find_new_time_value(rcl_t, tget_min, **kwargs)
if not t_new:
return None, rcl_t
kappa = 0 # Counter to exit loop
# Check if possible to fill in period
while rcl_t.res_fill[p_t] < 1:
if kappa == 10:
return None, rcl_t
# If not possible, find new time value
t_new, p_t, rcl_t = self.find_new_time_value(rcl_t, tget_min, **kwargs)
if not t_new:
return None, rcl_t
kappa += 1
# If returning t_new to open bin, reduce fill capacity by 1
rcl_t.res_fill[p_t] -= 1
return t_new, rcl_t
def get_box_tget_min(self, vlrepi):
# Find get_minimum time for box i
boxi_contents = {k: v for k, v in self.cookies.items() if k in vlrepi}
get_maxbatch = get_max(boxi_contents.values(), key=attrgetter('batch')).batch
tget_min = get_maxbatch * 600
return tget_min
def find_new_time_value(self, rcl_t, tget_min, **kwargs):
# This module retrieves a new time value and also returns which period
# it belongs to
t_new = rcl_t.get_new_t(tget_min, **kwargs)
if not t_new:
return None, None, rcl_t
t_p = self.find_t_in_fill_periods(t_new, rcl_t)
return t_new, t_p, rcl_t
def find_t_in_fill_periods(self, t, rcl_t):
# If the new time value is beyond the current fill periods, extend
while t > rcl_t.t_t[-1]:
rcl_t.extend_fill_periods()
# Find the period containing t_new
tlist = bn.filter_condition(t >= bn.numset(rcl_t.t_t))[0]
return tlist[-1]
def ls1(self, p, numls, solution):
# Heuristic to locate a better solution in terms of the first objective:
# get_minimizing the number of bins in use
k = 0
neighbors = []
searchfrom = solution
while k < numls:
coolneighbor, rcl_t = self.ls1_loading(searchfrom)
if coolneighbor:
k += 1
coolneighbor = self.ls_time(coolneighbor, rcl_t)
coolneighbor.updateid(p)
p += 1
neighbors.apd(coolneighbor)
searchfrom = coolneighbor
else:
k = numls
return p, neighbors
def ls2(self, p, numls, solution):
# Heuristic to locate a better solution in terms of the second objective:
# get_minimizing the weighted average initial heat in a box
# p - current id number for new solution
# numls - number of neighbors to find during local search
# Returns updated p and list of neighbors
k = 0
neighbors = []
searchfrom = solution
while k < numls:
k, coolneighbor, rcl_t = self.ls2_loading(k, searchfrom)
if coolneighbor:
coolneighbor = self.ls_time(coolneighbor, rcl_t)
coolneighbor.updateid(p)
p += 1
neighbors.apd(coolneighbor)
searchfrom = coolneighbor
else:
k = numls
return p, neighbors
def ls3(self, p, numls, solution):
# Heuristic to locate a better solution in terms of the third objective:
# get_minimizing the get_maximum time to move to store front.
k = 0
neighbors = []
searchfrom = solution
while k < numls:
k, coolneighbor, rcl_t = self.ls3_loading(k, searchfrom)
if coolneighbor:
coolneighbor = self.ls_time(coolneighbor, rcl_t)
coolneighbor.updateid(p)
p += 1
neighbors.apd(coolneighbor)
searchfrom = coolneighbor
else:
k = numls
return p, neighbors
def ls1_loading(self, searchfrom):
# This function attempts to empty the least masked_fill bin and move its
# cookies into available boxes.
u = searchfrom.getfits()
vlrep = searchfrom.getvlrep()
r, rcl_t = self.getresiduals(vlrep, searchfrom.gettfill())
copy = deepcopy(searchfrom)
half = len(vlrep) // 2
for iloop in range(half):
# Find the emptiest bin's index number
lengths = [len(i) for i in copy.getvlrep()]
i = bn.get_argget_min_value(bn.numset(lengths))
copy, r, rcl_t = self.empty_bin(i, copy, r, rcl_t)
# If a nondoget_minated solution wasn't found, return nothing
copy = self.checkandfit(copy)
v = copy.getfits()
if not dom2(u, v):
return copy, rcl_t
return None, rcl_t
def empty_bin(self, i, copy, r, rcl_t):
# This function moves items in box i to other boxes
for j in list(copy.getvlrep()[i]):
# Find rcl_bins
tfill = copy.gettfill()
rcl_bins = self.ls1_makercl(i, j, r, rcl_t, tfill)
if len(rcl_bins) == 0:
return copy, r, rcl_t
# Pick random bin
inew = random.choice(rcl_bins)
# Move cookie to new bin
copy.moveitem(i, j, inew)
r = self.update_spaceresiduals(r, i, inew)
r[i, 1], r[inew, 1] = rcl_t.adapt_movebins(tfill[i], tfill[inew])
return copy, r, rcl_t
def ls1_makercl(self, iold, j, r, rcl_t, tfill):
# This function returns the restricted candidate list for cookie
# j to move into based on the dot product strategy
# Set weights for the dot product numset (1/boxcap, 1/coolrackcap)
weights = [1.0 / self.moop.boxcap, 1.0 / self.moop.coolrack]
# The cookie should not move into a box that is masked_fill until after
# it is done baking
tget_min = self.cookies.get(j).getbatch() * 600
tget_max = rcl_t.get_tget_max(tget_min, 1)
options_byt = [i for i in range(self.n) if tfill[i] > tget_min]
if tfill[iold] != tget_min:
options_byt.remove(iold)
# Form dot product numset
dpnumset = bn.zeros(self.n)
for i in options_byt:
if tfill[i] <= tget_max:
# Make sure there is space available
if r[i, 0] > 1:
tk = rcl_t.find_t_in_timeline(tfill[i])
# Filling early will reduce onrack for total after time[tk]
onrack = bn.subtract(self.moop.coolrack, rcl_t.space[tk:])
get_maxonrack_fromtk = get_max(onrack)
dpnumset[i] = weights[0] * r[i, 0] + weights[1] * get_maxonrack_fromtk
# Max fill
if len(bn.nonzero(dpnumset)[0]) > self.beta:
options = list(bn.argsort(-dpnumset)[:self.beta])
return options
else:
options = list(bn.nonzero(dpnumset)[0])
return options
def ls2_loading(self, k, searchfrom):
# This function finds the restricted candidate list and tries to move
# cookies toward more favorable configurations to get_minimize the weighted avg
u = searchfrom.getfits()
r, rcl_t = self.getresiduals(searchfrom.getvlrep(), searchfrom.gettfill())
copy = deepcopy(searchfrom)
hotbins = bn.argsort(searchfrom.getq0bins())
for s in range(searchfrom.openbins):
i = hotbins[-s - 1]
vlrep = copy.getvlrep()
# If there is only one item in the box, no point in moving
if len(vlrep[i]) < 2:
return k, None, rcl_t
rcl_j = self.ls2_makercl(i, vlrep)
k, newsol, rcl_t = self.search_rclj(k, i, copy, u, r, rcl_j, rcl_t)
if newsol:
return k, newsol, rcl_t
# If a nondoget_minated solution wasn't found, return nothing
return k, None, rcl_t
def ls2_makercl(self, i, vlrep):
# This function returns the restricted candidate list for local search 2
# Restricted candidate list
binkeys = list(vlrep[i])
avglen = averageLen(vlrep)
nrcl_get_min = get_min(len(binkeys) - 1, self.beta)
nrcl = get_max(len(binkeys) - avglen, nrcl_get_min)
rcl_j = random.sample(binkeys, nrcl)
return rcl_j
def ls3_loading(self, k, searchfrom):
# This function finds the restricted candidate list for bin i and tries to
# move cookies to find a new nondoget_minated solution. If unsuccessful, moves
# to a new bin
u = searchfrom.getfits()
r, rcl_t = self.getresiduals(searchfrom.getvlrep(), searchfrom.gettfill())
copy = deepcopy(searchfrom)
latebins = bn.argsort(searchfrom.gettavail(), axis=0)
for s in range(searchfrom.openbins):
i = latebins[-s - 1]
vlrep = copy.getvlrep()
# If there is only one item in the box, no point in moving
if len(vlrep[i]) < 2:
return k, None, rcl_t
# Restricted candidate list
rcl_j = self.ls3_makercl(i, vlrep)
k, newsol, rcl_t = self.search_rclj(k, i, copy, u, r, rcl_j, rcl_t)
if newsol:
return k, newsol, rcl_t
# If a nondoget_minated solution wasn't found, return nothing
return k, None, rcl_t
def ls3_makercl(self, i, vlrep):
# This function returns the restricted candidate list for local search 3
# Restricted candidate list
binkeys = list(vlrep[i])
n_rclj = int(0.5 * len(binkeys))
rcl_j = binkeys[-n_rclj - 1: -1]
return rcl_j
def search_rclj(self, k, i, solution, u, r, rcl_j, rcl_t):
# This function moves cookies into new boxes until either it finds a new
# nondoget_minated solution or it runs out of candidates from this solution
for m in range(len(rcl_j)):
k += 1
j = random.choice(rcl_j)
rcl_j.remove(j)
r, rcl_t, solution = self.lsmove(i, j, r, rcl_t, solution)
# Check if modified solution is nondoget_minated
solution = self.checkandfit(solution)
v = solution.getfits()
if not dom2(u, v):
return k, solution, rcl_t
return k, None, rcl_t
def lsmove(self, i, j, r, rcl_t, solution):
# This function deterget_mines filter_condition cookie j should move to
m = solution.getopenbins()
tfill = solution.gettfill()
# Gather bin options and pick new bin for the move
ilist = self.move_options(j, m, r, rcl_t, tfill)
inew = random.choice(ilist)
# Open a new bin or move cookie to a new bin
if inew == m:
tget_min = self.get_box_tget_min([j])
kwargs = {'mode': 'hload'}
t, rcl_t = self.get_feasible_tfilli(rcl_t, tget_min, **kwargs)
if t:
solution.opennewbin(i, j, round(t, 1))
r[inew, 0] = self.moop.boxcap
r[inew, 1] = rcl_t.adapt_greedy_function_newbin(t)
else:
return r, rcl_t, solution
else:
solution.moveitem(i, j, inew)
r[i, 1], r[inew, 1] = rcl_t.adapt_movebins(tfill[i], tfill[inew])
r = self.update_spaceresiduals(r, i, inew)
return r, rcl_t, solution
def move_options(self, j, m, r, rcl_t, tfill):
# This function retrieves a candidate list for moving a cookie.
bcookiej = self.cookies.get(j).getbatch() # cookie batch number
tget_max = rcl_t.get_tget_max(bcookiej * 600, 1)
i_rlowtohigh = bn.argsort(r[:m, 0], axis=0)
# This module performs the sorting for module ll.
for i in range(m):
# Find open bin with get_max. residual value, moving backward thru i_rlowtohigh
lsi = i_rlowtohigh[-1 - i]
if tfill[lsi] <= tget_max:
pack = packable(r[lsi, :], bcookiej, tfill[lsi])
if pack:
return [m, lsi]
# If least loaded bin won't fit item, need to open new bin.
return [m]
def bin_mutation(self, p, numls, solution):
# Heuristic to locate a better solution in terms of the first objective:
# get_minimizing the number of bins.
k = 0
neighbors = []
searchfrom = solution
while k < numls:
k, coolneighbor, rcl_t = self.select_mutation_operation(k, searchfrom)
if coolneighbor:
coolneighbor.updateid(p)
coolneighbor = self.ls_time(coolneighbor, rcl_t)
p += 1
neighbors.apd(coolneighbor)
searchfrom = coolneighbor
else:
k = numls
return p, neighbors
def select_mutation_operation(self, k, searchfrom):
# This function selects the mutation operator
vlrep = searchfrom.getvlrep()
avg_bin_size = averageLen(vlrep)
too_smtotal_lengths = [i for i in vlrep if 2 * len(i) <= avg_bin_size]
if too_smtotal_lengths:
k, coolneighbor, rcl_t = self.move_cookies(k, searchfrom)
else:
rannum = random.random()
if rannum < 0.50:
k, coolneighbor, rcl_t = self.part_swap(k, searchfrom)
else:
k, coolneighbor, rcl_t = self.cookie_swap(k, searchfrom)
return k, coolneighbor, rcl_t
def time_mutation_by_heat(self, solution, rcl_t):
# This function tries a new time value for the initial hottest bin to
# see if that helps
tfill = solution.gettfill()
q0_bybin = solution.getq0bins()[:solution.getopenbins()]
i_hot_list = bn.argsort(q0_bybin)
i_hot = i_hot_list[-1]
told = tfill[i_hot]
kwargs = {'mode': 'hload', 'nmove': len(solution.vlrep[i_hot])}
t_new, rcl_t = self.get_feasible_tfilli(rcl_t, told - 5.0, **kwargs)
if t_new:
neighbor = deepcopy(solution)
neighbor.edit_tfilli(i_hot, t_new)
# Adapt Greedy Function
rcl_t.adapt_changetime(told, t_new, len(neighbor.vlrep[i_hot]))
# Check if modified solution is nondoget_minated
neighbor = self.checkandfit(neighbor)
solution = self.test_doget_mination(solution, neighbor)
return solution
def sep_split_bin(self, solution, rcl_t):
# This function sep_splits the highest capacity bin into two boxes.
vlrep = solution.getvlrep()
i = self.getget_maxbin(vlrep)
# Get random place to sep_split bin
jsep_split = random.randrange(1, len(vlrep[i]))
newbin = list(vlrep[i][jsep_split:])
# Open new bin with feasible time value
tget_min = self.get_box_tget_min(newbin)
kwargs = {'mode': 'hload', 'nmove': len(newbin)}
t_new, rcl_t = self.get_feasible_tfilli(rcl_t, tget_min, **kwargs)
if t_new:
tfill = solution.gettfill()
solution.opennewbin(i, newbin[0], round(t_new, 1))
inew = solution.getopenbins() - 1
rcl_t.adapt_greedy_function_newbin(t_new, add_concat=0)
rcl_t.adapt_movebins(tfill[i], t_new)
if len(newbin) > 1:
for j in newbin[1:]:
solution.moveitem(i, j, inew)
rcl_t.adapt_movebins(tfill[i], tfill[inew])
return solution, rcl_t
def cookie_swap(self, k, searchfrom):
# This function selects two random bins and tries to swap cookies between
# them. If unsuccessful, it sep_splits the highest capacity bin.
u = searchfrom.getfits()
r, rcl_t = self.getresiduals(searchfrom.getvlrep(), searchfrom.gettfill())
copy = deepcopy(searchfrom)
for s in range(searchfrom.openbins):
mode = random.choice(['random', 'moveheat', 'movelate'])
i1, i2 = self.select_two_bins(copy, mode)
if not i2:
newsol, rcl_t = self.sep_split_bin(copy, rcl_t)
else:
kwargs = {'i1': i1, 'i2': i2, 'mode': mode}
newsol, rcl_t = self.perform_cookie_swap(copy, rcl_t, **kwargs)
# Will return None if it's doget_minated by vector u
nondoget_minated = self.check4nondoget_mination(u, newsol)
k += 1
if nondoget_minated:
return k, newsol, rcl_t
# If a nondoget_minated solution wasn't found, return nothing
return k, None, rcl_t
def perform_cookie_swap(self, solution, rcl_t, i1, i2, mode):
# This function performs the part swap between box i1 and i2
tfill = solution.gettfill()
vlrep = solution.getvlrep()
# Get cookies to swap
bini1_options = [j for j in vlrep[i1] if self.cookies.get(j).getbatch()
* self.moop.tbatch < tfill[i2]]
bini2_options = [j for j in vlrep[i2] if self.cookies.get(j).getbatch()
* self.moop.tbatch < tfill[i1]]
if mode == 'moveheat':
j1 = bini1_options[-1]
j2 = bini2_options[0]
else:
j1 = random.choice(bini1_options)
j2 = random.choice(bini2_options)
solution.moveitem(i1, j1, i2)
solution.moveitem(i2, j2, i1)
return solution, rcl_t
def part_swap(self, k, searchfrom):
# This function selects two random bins and tries to swap cookies between
# them. If unsuccessful, it sep_splits the highest capacity bin.
u = searchfrom.getfits()
r, rcl_t = self.getresiduals(searchfrom.getvlrep(), searchfrom.gettfill())
copy = deepcopy(searchfrom)
for s in range(searchfrom.openbins):
mode = random.choice(['random', 'moveheat', 'movelate'])
i1, i2 = self.select_two_bins(copy, mode)
if not i2:
newsol, rcl_t = self.sep_split_bin(copy, rcl_t)
else:
kwargs = {'i1': i1, 'i2': i2, 'mode': mode}
newsol, rcl_t = self.perform_part_swap(copy, rcl_t, **kwargs)
# Will return None if it's doget_minated by vector u
nondoget_minated = self.check4nondoget_mination(u, newsol)
k += 1
if nondoget_minated:
return k, newsol, rcl_t
# If a nondoget_minated solution wasn't found, return nothing
return k, None, rcl_t
def perform_part_swap(self, solution, rcl_t, i1, i2, mode):
# This function performs the part swap between box i1 and i2
# Get swap points
if mode == 'moveheat':
movetobin2, movetobin1 = self.get_heat_swap_sets(solution, i1, i2)
else:
movetobin2, movetobin1 = self.get_random_swap_sets(solution, i1, i2)
if movetobin2:
kwargs = {'i1': i1, 'movetobin2': movetobin2,
'i2': i2, 'movetobin1': movetobin1}
solution, rcl_t = \
self.make_swap_happen(solution, rcl_t, **kwargs)
else:
solution, rcl_t = self.sep_split_bin(solution, rcl_t)
return solution, rcl_t
def make_swap_happen(self, solution, rcl_t, i1, movetobin2, i2, movetobin1):
# This function swaps a portion of box i1 with box i2
# potentitotaly fix this: adapt rcl_t total at once instead of cookie by cookie
tfill = solution.gettfill()
for j in movetobin2:
solution.moveitem(i1, j, i2)
rcl_t.adapt_movebins(tfill[i1], tfill[i2])
for j in movetobin1:
solution.moveitem(i2, j, i1)
rcl_t.adapt_movebins(tfill[i2], tfill[i1])
return solution, rcl_t
def get_heat_swap_sets(self, solution, i1, i2):
# This function returns sets of cookies averaget to reduce overtotal heat
# between boxes
vlrep = solution.getvlrep()
tfill = solution.gettfill()
# Deterget_mine eligible cookies
bini1_options = [j for j in vlrep[i1] if self.cookies.get(j).getbatch()
* self.moop.tbatch < tfill[i2]]
bini2_options = [j for j in vlrep[i2] if self.cookies.get(j).getbatch()
* self.moop.tbatch < tfill[i1]]
# Pick random swap sets
get_min_box_fill = get_min(len(vlrep[i1]), len(vlrep[i2]))
get_max_swap = get_min(len(bini1_options), len(bini2_options), get_min_box_fill - 1)
swap_number = random.randint(1, get_max_swap)
movetobin2 = bini1_options[-swap_number:]
movetobin1 = bini2_options[:swap_number]
return movetobin2, movetobin1
def get_random_swap_sets(self, solution, i1, i2):
# This function returns a random set of cookies to swap between boxes.
vlrep = solution.getvlrep()
tfill = solution.gettfill()
# Deterget_mine eligible cookies
bini1_options = [j for j in vlrep[i1] if self.cookies.get(j).getbatch()
* self.moop.tbatch < tfill[i2]]
bini2_options = [j for j in vlrep[i2] if self.cookies.get(j).getbatch()
* self.moop.tbatch < tfill[i1]]
# Pick random swap sets
get_min_box_fill = get_min(len(vlrep[i1]), len(vlrep[i2]))
get_max_swap = get_min(len(bini1_options), len(bini2_options), get_min_box_fill - 1)
swap_number = random.randint(1, get_max_swap)
movetobin2 = random.sample(bini1_options, swap_number)
movetobin1 = random.sample(bini2_options, swap_number)
return movetobin2, movetobin1
def getpoints_4swap(self, binitems1, t1, binitems2, t2):
# This function returns two points to perform the swap on
# Retrieve boolean lists
bool1 = self.moop.packatt(binitems1, t2)
bool2 = self.moop.packatt(binitems2, t1)
p1 = self.get_swap_point(bool1)
p2 = self.get_swap_point(bool2)
# If no swap point, return false
if not p1 or not p2:
return None, None
# Check for capacity violations
newbin1 = binitems1[:p1] + binitems2[p2:]
if len(newbin1) > self.moop.boxcap:
p2 = self.get_new_swap_point(binitems1, p1, binitems2, bool2)
newbin2 = binitems2[:p2] + binitems1[p1:]
if len(newbin2) > self.moop.boxcap:
p1 = self.get_new_swap_point(binitems2, p2, binitems1, bool1)
# Return the lists of cookies to be swapped
movetobin2 = list(binitems1[p1:])
movetobin1 = list(binitems2[p2:])
return movetobin2, movetobin1
def get_swap_point(self, booli):
# This function finds a feasible point to swap with another box
# Find starting point for bin i
starti = self.findstartforswap(booli)
if starti == len(booli):
return False
else:
pi = random.randrange(starti, len(booli))
return pi
def get_new_swap_point(self, bin_into, p1, bin_outta, bool_outta):
# This function finds a swap point that won't violate bin_into's capacity
can_accept = self.moop.boxcap - len(bin_into[:p1])
p2 = self.get_swap_point(bool_outta)
kappa = 10
while len(bin_outta[p2:]) > can_accept:
# If can't find point, only swap one item
if kappa == 10:
return len(bin_outta) - 1
p2 = self.get_swap_point(bool_outta)
return p2
def findstartforswap(self, boollist):
# This function returns the index after which total values are True
start = 1
for k in range(len(boollist) - 1, 0, -1):
if boollist[k] is False:
start = k + 1
return start
return start
def move_cookies(self, k, searchfrom):
# This function selects two random bins and tries to move cookies between
# them. If unsuccessful, it sep_splits the highest capacity bin.
u = searchfrom.getfits()
r, rcl_t = self.getresiduals(searchfrom.getvlrep(), searchfrom.gettfill())
copy = deepcopy(searchfrom)
for s in range(searchfrom.openbins):
mode = random.choice(['moveheat', 'movelate'])
i1, i2 = self.get_hot_empty_bins(copy, mode)
if i2 == None or len(copy.vlrep[i2]) == self.moop.boxcap:
newsol, rcl_t = self.sep_split_bin(copy, rcl_t)
else:
kwargs = {'i1': i1, 'i2': i2, 'mode': mode}
newsol, rcl_t = self.perform_cookie_move(copy, rcl_t, **kwargs)
# Will return None if it's doget_minated by vector u
nondoget_minated = self.check4nondoget_mination(u, newsol)
k += 1
if nondoget_minated:
return k, newsol, rcl_t
# If a nondoget_minated solution wasn't found, return nothing
return k, None, rcl_t
def perform_cookie_move(self, solution, rcl_t, i1, i2, mode):
# This function performs the move of one cookie from box i1 to i2
tfill = solution.gettfill()
vlrep = solution.getvlrep()
# Get cookies to swap
bini1_options = [j for j in vlrep[i1] if self.cookies.get(j).getbatch()
* self.moop.tbatch < tfill[i2]]
empty_space = self.moop.boxcap - len(vlrep[i2])
get_max_move = get_min(empty_space, empty_space // 2 + 1, len(bini1_options))
nmove = random.randint(1, get_max_move)
for k in range(nmove):
j1 = bini1_options[-1 - k]
solution.moveitem(i1, j1, i2)
return solution, rcl_t
def select_two_bins(self, solution, mode):
# This module selects two bins for swap using specified function
vlrep = solution.getvlrep()
tfill = solution.gettfill()
if mode == 'moveheat':
i1, i2 = self.get_hot_cold_bins(vlrep, tfill, solution.getq0bins())
elif mode == 'movelate':
i1, i2 = self.get_hot_cold_bins(vlrep, tfill, solution.gettavail())
else:
# Pick random bins
i1, i2 = self.get_two_random_bins(vlrep, tfill)
return i1, i2
def get_hot_cold_bins(self, vlrep, tfill, characteristic):
# This function returns the indices of the hottest bin and the coldest
# bin that are compatible
m = len(vlrep) # number of open bins
ilist_hot = bn.argsort(characteristic[:m])
for kh in range(m):
i_hot = ilist_hot[-1 - kh]
for kc in range(m - kh):
i_cold = ilist_hot[kc]
if i_hot != i_cold:
compatible = self.good_match(vlrep, tfill, i_hot, i_cold)
if compatible:
return i_hot, i_cold
return None, None
def get_hot_empty_bins(self, solution, mode):
# This function returns the indices of the hottest bin compatible with
# the emptiest bin
m = solution.getopenbins()
vlrep = solution.getvlrep()
tfill = solution.gettfill()
i2 = self.getget_minbin(vlrep)
if mode == 'moveheat':
ilist_hot = bn.argsort(solution.getq0bins()[:m])
else:
ilist_hot = bn.argsort(solution.gettavail()[:m])
for k in range(m):
i_hot = ilist_hot[-1 - k]
compatible = self.good_match(vlrep, tfill, i_hot, i2,
ignore_length=True)
if compatible:
return i_hot, i2
return None, None
def get_two_random_bins(self, vlrep, tfill):
# This function returns two individual random bins that can swap cookies
bin_pairs = list(combinations(range(len(vlrep)), 2))
for bp in range(len(bin_pairs)):
i1, i2 = random.choice(bin_pairs)
can_swap = self.good_match(vlrep, tfill, i1, i2)
if can_swap:
return i1, i2
return None, None
def good_match(self, vlrep, tfill, i1, i2, ignore_length=False):
# This function returns True if i1 and i2 are a good match for swapping
# and False if they are a bad match
if i1 == i2:
return False
if not ignore_length:
if len(vlrep[i1]) <= 1 or len(vlrep[i2]) <= 1:
return False
list1 = [j for j in vlrep[i1] if self.cookies.get(j).getbatch()
* self.moop.tbatch < tfill[i2]]
if not list1:
return False
list2 = [j for j in vlrep[i2] if self.cookies.get(j).getbatch()
* self.moop.tbatch < tfill[i1]]
if not list2:
return False
# If made it past conditions, return True
return True
def getrandombin(self, vlrep):
# This function returns a random bin with more than one item in it
bins = range(len(vlrep))
bini = random.choice(bins)
while len(vlrep[bini]) <= 1:
bini = random.choice(bins)
return bini
def getrandsecondbin(self, i1, vlrep, tfill):
# This function returns a second random bin that is not
# bin i1 and that items in bin i1 can be moved to
i2 = random.choice(range(len(vlrep)))
kappa = 1
while not self.good_match(vlrep, tfill, i1, i2):
if kappa == len(vlrep):
return None
i2 = random.choice(range(len(vlrep)))
kappa += 1
return i2
def getget_maxbin(self, vlrep):
# This function returns the index of the full_value_funcest bin.
bincapacity = bn.zeros(len(vlrep))
for i in range(len(vlrep)):
bincapacity[i] = len(vlrep[i])
bini = bn.get_argget_max(bincapacity)
return bini
def getget_minbin(self, vlrep):
# This function returns the index of the emptiest bin.
bincapacity = bn.zeros(len(vlrep))
for i in range(len(vlrep)):
bincapacity[i] = len(vlrep[i])
get_minbin = bn.get_argget_min_value(bincapacity)
return get_minbin
def getresiduals(self, vlrep, tfill):
# This function calculates the residual matrix associated with a given
# dynamic bin packing loading. The first column represents the open box
# capacities, and the second column represents the get_maximum number of
# cookies that can be add_concated to the cooling rack right before tfill_i
coolrack = self.moop.coolrack
r = bn.zeros((self.n, 2), dtype=bn.int)
# Set box capacity residuals
for i in range(len(vlrep)):
r[i, 0] = self.moop.boxcap - len(vlrep[i])
r[i, 1] = coolrack
# Set cooling rack capacity residuals
n_b = self.n // self.moop.nbatches
rcl_t = RCLtime(coolrack, self.moop.fillcap, n_b,
self.moop.tbatch, self.moop.nbatches)
r[:len(vlrep), 1] = rcl_t.initialize_withtfill(len(vlrep), vlrep, tfill)
return r, rcl_t
def update_spaceresiduals(self, r, i, inew):
# This function updates the space residual r after a cookie moves
# from box i to box inew
# Update r: box capacity
r[i, 0] += 1
r[inew, 0] -= 1
return r
def check4nondoget_mination(self, u, solution):
# Check if modified solution is nondoget_minated
solution = self.checkandfit(solution)
v = solution.getfits()
if not dom2(u, v):
return True
else:
return False
def countonrack(self, t, solution):
# Cookies from boxes masked_fill after t might be on rack
vlrep = solution.getvlrep()
tfill = solution.gettfill()
timecheckindices = bn.filter_condition(tfill > t)
nrackitems = 0
for i in timecheckindices[0]:
for j in vlrep[i]:
onrack = self.moop.rackij(t, tfill[i], self.cookies.get(j))
nrackitems += onrack
return nrackitems
def calclowerbound(self):
# This function calculates theoretical lower bound for the number of
# bins. It astotal_countes this is the total number of cookies divided by
# the box capacity.
get_minbins = ceil(float(self.n) / self.moop.boxcap)
self.lb = int(get_minbins)
def getub(self):
# Returns the upper bound (bin capacity)
return self.moop.boxcap
def getcookies(self):
# Returns the list of items to pack
return self.cookies
def getlb(self):
# Returns the theoretical lower bound
return self.lb
class NewSolution:
# This class performs the GRASP creation of a new solution.
def __init__(self, beta, n, cookies, moop):
self.beta = beta # Cardinality restriction
self.n = int(n) # Number of cookies to sort
self.cookies = cookies # dictionary of item objects
self.moop = moop # Multiobjective problem class
self.m = 0 # initialize open bins count
self.r = bn.zeros((n, 2)) # Residual capacity matrix
self.x = bn.zeros((n, n), dtype=bn.int)
self.y = bn.zeros(n, dtype=bn.int)
self.vlrep = []
self.tfill = bn.zeros(n, dtype=bn.float)
# Initialize restricted candidate list
n_b = self.n // self.moop.nbatches
self.rcl_t = RCLtime(moop.coolrack, moop.fillcap, n_b,
moop.tbatch, moop.nbatches)
def make_newsol(self, index, *args):
# This function takes the solution from generate_newsol and creates
# a CookieSol instance.
# Possible args: a newgenes list containing a chromosome representation
# and a suggested tfill.
if args:
self.generate_newsol_from_chromosome(args[0], args[1])
else:
self.generate_newsol()
newsol = solmaker.CookieSol(index, self.x, self.y, self.vlrep, self.tfill)
return newsol
def generate_newsol(self):
# This function generates a new solution from scratch using GRASP
modes = ['ss', 'hload'] # Modes for retrieving new tfill time
self.initialize_greedy_tfill()
self.open_new_bin(0, 0)
# Set strategy for the loading
theta_i = random.random()
for j in range(1, self.n):
rcl_i = self.get_rcl_bins(theta_i, j)
i = random.choice(rcl_i)
if self.y[i] == 0:
self.tfill[i] = self.get_feasible_tfilli(j, modes)
self.open_new_bin(i, j)
else:
self.vlrep[i].apd(j)
self.r[i, 0] -= 1
self.rcl_t.adapt_greedy_function_add_concattobin(self.tfill[i])
self.r[:self.m, 1] = \
self.rcl_t.retrieve_space_by_tfill(self.m, self.tfill)
self.constructx()
def generate_newsol_from_chromosome(self, chrom, tfill_suggested):
# This function generates a new solution based on a given chromosome
modes = ['ss', 'hload'] # Modes for retrieving new tfill time
self.initialize_greedy_tfill(*tfill_suggested)
chrom = self.initialize_first_bin(chrom)
# Set strategy for the loading
theta_i = random.random()
for j in chrom:
rcl_i = self.get_rcl_bins(theta_i, j)
i = random.choice(rcl_i)
if self.y[i] == 0:
self.tfill[i] = self.pick_tfilli(j, modes, tfill_suggested)
self.open_new_bin(i, j)
else:
self.vlrep[i].apd(j)
self.r[i, 0] -= 1
self.rcl_t.adapt_greedy_function_add_concattobin(self.tfill[i])
self.r[:self.m, 1] = \
self.rcl_t.retrieve_space_by_tfill(self.m, self.tfill)
self.constructx()
def initialize_greedy_tfill(self, *args):
# This function initializes t_fill
# Calculate tfill_0 using inverseerse cdf and set residual capacity
if args:
# args = tfill_suggested
self.tfill[0] = self.rcl_t.pick_suggested_t(args, self.moop.tbatch)
else:
self.tfill[0] = self.rcl_t.get_new_t(self.moop.tbatch)
def initialize_first_bin(self, chrom):
# This function finds the first cookie in list chrom that can be packed
# at tfill[0] and opens the first bin with that cookie
for j in chrom:
if self.moop.cookiedonebaking(j, self.tfill[0]):
self.open_new_bin(0, j)
chrom.remove(j)
return chrom
print('Error: NewSolution picked a time that cannot be masked_fill.')
def pick_tfilli(self, j, modes, tfill_maybe):
# This module tries to use one of the time values from tfill
tget_min = self.cookies.get(j).getbatch() * self.moop.tbatch
# If tget_min when coolrack is overfull_value_func, find least worst solution
tk = self.find_t_in_trange(tget_min)
if self.rcl_t.space[tk] <= 0:
t_new = self.rcl_t.find_least_worst_newt(tget_min)
return t_new
t_possible = self.get_t_from_oldtfill(tget_min, tfill_maybe)
if t_possible:
return t_possible
else:
# If nothing in tfill_maybe worked, return new value:
t_new = self.get_feasible_tfilli(j, modes)
return t_new
def get_t_from_oldtfill(self, tget_min, tfill_maybe):
# This function returns a feasible time from tfill_maybe
# First establish tget_max based on moving 1 cookie from the rack
tget_max = self.rcl_t.get_tget_max(tget_min, 1)
t_options = bn.uniq(tfill_maybe)
for i in range(len(t_options)):
if t_options[i] < tget_max:
# Avoid reusing a value from tfill_maybe
if t_options[i] not in self.tfill:
if self.rcl_t.time_feasible(t_options[i], tget_min):
return t_options[i]
return None
def get_feasible_tfilli(self, j, modes):
# This function locates a new value for tfill[i] that doesn't violate
# rack or fill limits
theta_t = random.randint(0, 1)
tget_min = self.cookies.get(j).getbatch() * self.moop.tbatch
# Find fill time for box i
t_new, p_t = self.find_new_time_value(tget_min, modes[theta_t])
kappa = 0 # Counter to exit loop
# Check if possible to fill in period
while self.rcl_t.res_fill[p_t] < 1:
if kappa == 10:
return None
# If not possible, find new time value
t_new, p_t = self.find_new_time_value(tget_min, modes[theta_t])
kappa += 1
return t_new
def find_new_time_value(self, tget_min, mode):
# This module retrieves a new time value and also returns which period
# it belongs to
t_new = self.rcl_t.get_new_t(tget_min, mode=mode)
t_t = self.find_t_in_fill_periods(t_new)
return t_new, t_t
def find_t_in_fill_periods(self, t):
# If the new time value is beyond the current fill periods, extend
while t > self.rcl_t.t_t[-1]:
self.rcl_t.extend_fill_periods()
# Find the period containing t_new
tlist = bn.filter_condition(t >= bn.numset(self.rcl_t.t_t))[0]
return tlist[-1]
def find_t_in_trange(self, t):
# If the new time value is beyond the current timeline, extend
while t > self.rcl_t.trange[-1]:
self.rcl_t.extend_timeline()
tklist = bn.filter_condition(bn.numset(self.rcl_t.trange) <= t)[0]
return tklist[-1]
def get_rcl_bins(self, theta_i, j):
# This module selects the strategy based on theta_i and returns
# the corresponding restricted candidate list.
if theta_i < 0.33:
# Least loaded strategy
rcl_i = self.llmove(j)
elif theta_i < 0.66:
# Weighted get_max strategy
rcl_i = self.wget_maxmove(j)
else:
# Combo-t strategy
rcl_i = self.combot_move(j)
# Return either a new bin or the list found above
if not rcl_i:
rcl_i = self.find_alternative_bin(j)
return rcl_i
else:
return rcl_i
def llmove(self, j):
# This module performs the sorting for module ll.
# The goal of this strategy is to balance the loading of the boxes.
rcl_i = []
i_rlowtohigh = bn.argsort(self.r[:self.m, 0], axis=0)
# Add new bin as an option if others are starting to get full_value_func
if self.r[i_rlowtohigh[-1], 0] <= 0.5 * self.moop.boxcap:
rcl_i.apd(self.m)
for k in range(self.m):
# Find open bin with get_max. residual value, moving backward thru i_rlowtohigh
lli = i_rlowtohigh[- 1 - k]
bcookiej = self.cookies.get(j).getbatch()
pack = packable(self.r[lli, :], bcookiej, self.tfill[lli])
if pack:
rcl_i.apd(lli)
if len(rcl_i) == self.beta:
return rcl_i
return rcl_i
def wget_maxmove(self, j):
# This module deterget_mines the restricted candidate list by the weighted
# get_max strategy. The goal is to keep the number of boxes to a get_minimum.
rcl_i = []
# Gather weights: space on rack / get_maximum space over time
get_maxval = bn.get_max(self.r[:self.m, 1])
weights = bn.zeros(self.m)
for k in range(self.m):
weights[k] = self.r[k, 1] / get_maxval
# Calculate weighted residuals
wresidual = bn.multiply(self.r[:self.m, 0], weights)
i_rlowtohigh = bn.argsort(wresidual, axis=0)
for k in range(self.m):
# Find open bin with get_min. weighted residual value
i = i_rlowtohigh[k]
bcookiej = self.cookies.get(j).getbatch()
pack = packable(self.r[i, :], bcookiej, self.tfill[i])
if pack:
rcl_i.apd(i)
if len(rcl_i) == self.beta // 2:
return rcl_i
return rcl_i
def combot_move(self, j):
# This module deterget_mines the restricted candidate list by the combo-t
# strategy. The goal is to reduce the get_maximum time until the boxes
# can be moved to the store front.
n_b = self.n // self.moop.nbatches # Number of cookies per batch
jget_max = j - (j % n_b) # Max. cookie no. for heat restriction
rcl_i = []
i_rlowtohigh = bn.argsort(self.r[:self.m, 0], axis=0)
# Add new bin as an option after total bins meet a get_minimum level
if self.r[i_rlowtohigh[-1], 0] <= 0.7 * self.moop.boxcap:
rcl_i.apd(self.m)
for k in range(self.m):
# Find open bin with get_max. residual value
lli = i_rlowtohigh[- 1 - k]
otherbatch = [jo for jo in self.vlrep[lli] if jo < jget_max]
# Heat restriction
if (self.r[lli, 0] <= 0.5 * self.moop.boxcap) & \
(len(otherbatch) == 0):
pass
else:
bcookiej = self.cookies.get(j).getbatch()
pack = packable(self.r[lli, :], bcookiej, self.tfill[lli])
if pack:
rcl_i.apd(lli)
if len(rcl_i) == self.beta:
return rcl_i
return rcl_i
def open_new_bin(self, i, j):
# This module opens a new bin i with cookie j
self.m += 1
self.y[i] = 1
self.vlrep.stick(i, [j])
self.r[i, 0] = self.moop.boxcap - 1
# Adapt Greedy Function (time)
self.rcl_t.adapt_greedy_function_newbin(self.tfill[i])
t_t = self.find_t_in_fill_periods(self.tfill[i])
self.rcl_t.res_fill[t_t] -= 1
self.r[:self.m, 1] = self.rcl_t.retrieve_space_by_tfill(self.m, self.tfill)
def find_alternative_bin(self, j):
# If tget_min when coolrack is overfull_value_func, find least worst solution
tget_min = self.cookies.get(j).getbatch() * self.moop.tbatch
tk = self.find_t_in_trange(tget_min)
if self.rcl_t.space[tk] <= 0:
# Find least-worst alternative
options = [i for i in range(self.m)
if tget_min < self.tfill[i] and self.r[i, 0] > 0]
if options:
return options
else:
return [self.m]
else:
return [self.m]
def constructx(self):
# This function transforms the variable length representation into
# the x-matrix
for i in range(self.m):
for j in self.vlrep[i]:
self.x[i, j] = 1
checkformismatch(self.x, self.vlrep)
class RCLtime:
# This class maintains and updates the restricted candidate list for a
# uniq t_fill
def __init__(self, coolrack, fillcap, n_b, tbatch, nbatches):
self.coolrack = coolrack # Cooling rack capacity
self.fillcap = fillcap # Fill period limit
self.n_b = n_b # Number of cookies in one batch
self.tbatch = tbatch # Time to cook one batch
self.nbatches = nbatches # Number of batches cooked
# Set the time range, extend one cycle past last pull
self.trange = [(b + 1) * self.tbatch for b in range(self.nbatches + 1)]
# Space on the cooling rack as a function of time
self.space = [self.coolrack - (b + 1) * self.n_b
for b in range(self.nbatches)]
self.space.apd(self.space[-1])
# Include restrictions for period fill limits
n_period = 2 * (nbatches - 1) + 2
self.t_t = [self.tbatch * (1.0 + t / 2.0) for t in range(n_period)]
self.res_fill = [fillcap for _ in range(n_period)]
def initialize_withtfill(self, m, vlrep, tfill):
# This function add_concats the information from vlrep and tfill
# into the trange and space lists
# First fix the cooling rack related items
r2 = bn.zeros(m, dtype=bn.int) # Collect residual values
i_lowtohigh = list(bn.argsort(tfill[:m], axis=0))
for i in i_lowtohigh:
r2[i] = self.adapt_greedy_function_newbin(tfill[i],
add_concat=len(vlrep[i]))
# Then fix the fill period related items
t_latest = bn.aget_max(tfill)
while t_latest > self.t_t[-1]:
self.extend_fill_periods()
for t in range(len(self.t_t) - 1):
p_t = [i for i in range(m)
if self.t_t[t] <= tfill[i] < self.t_t[t + 1]]
self.res_fill[t] -= len(p_t)
return r2
def pick_suggested_t(self, t_maybe, tget_min):
# This function returns a possible starting t-value, first by trying
# the suggested t values in t_maybe, and then by finding a feasible one
for i in range(len(t_maybe)):
if t_maybe[i] < self.trange[-1]:
if self.time_feasible(t_maybe[i], tget_min):
return t_maybe[i]
t_new = self.get_new_t(tget_min)
return t_new
def time_feasible(self, t, tget_min):
# This function checks if time t is feasible to open a new bin
if t < tget_min:
return False
while self.trange[-1] < t:
self.extend_timeline()
tk = self.find_t_in_timeline(t)
# To be feasible, the cooling rack cannot be overcrowded
if self.space[tk] > 0:
return self.time_period_feasible(t)
# If overcrowded, return False
return False
def time_period_feasible(self, t):
# This module deterget_mines if time value t is valid within period fill
# limit constraints.
if t < self.t_t[0]:
return False
ttlist = bn.filter_condition(bn.numset(self.t_t) <= t)[0]
# The number of boxes masked_fill during the period < limit
if self.res_fill[ttlist[-1]] > 0:
return True
else:
return False
def get_new_t(self, tget_min, mode='ss', nmove=1, told=None):
# This function returns a random time on the cumulative
# distribution function of space(trange) greater than tget_min
t = 0
tget_max = self.get_tget_max(tget_min, nmove)
dist = self.retrieve_pdensityfunction(mode)
c_get_min = dist.cdf(tget_min)
c_get_max = dist.cdf(tget_max)
if c_get_min == c_get_max:
return None
k = 0
while round(t) <= tget_min or round(t) >= tget_max:
rannum = random.uniform(c_get_min, c_get_max)
t = dist.ppf(rannum)
k += 1
if k == 10:
return None
return round(t)
def retrieve_pdensityfunction(self, mode):
# This function returns the needed pdf
if mode == 'hload':
dist = PiecewiseLinearPDF(self.trange, self.space)
else:
dist = PiecewisePDF(self.trange, self.space)
return dist
def find_least_worst_newt(self, tget_min):
# This function returns the least worst time for a box to be opened
# based on tget_min.
tklist = bn.filter_condition(bn.numset(self.trange) >= tget_min)[0]
get_max_space = self.space[tklist[0]]
tget_max = self.get_tget_max(tget_min, get_max_space)
t_new = random.uniform(tget_min + 1, tget_max)
kappa = 0
while not self.time_period_feasible(t_new):
if kappa == 10:
return tget_min + 1.0
t_new = random.uniform(tget_min + 1, tget_max)
kappa += 1
return round(t_new)
def get_tget_max(self, tget_min, nmove):
# This function deterget_mines if the get_new_t function needs to limit its
# search to a get_max. value. If not, it returns the last trange value.
tklist = bn.filter_condition(bn.numset(self.trange) > tget_min)[0]
for tk in tklist:
if self.space[tk] - nmove <= 0:
return self.trange[tk]
# If did not find t_get_max, and enough space at end of timeline, extend
if self.space[-1] >= nmove:
self.extend_timeline()
return self.trange[-1]
def adapt_greedy_function_newbin(self, t, add_concat=1):
# This function updates the space and trange lists after a new bin is
# opened, add_concat is the space being opened by # of cookies being removed
# If t is larger than the range, add_concat it on to the end
if t > self.trange[-1]:
self.trange.apd(t)
self.space.apd(self.space[-1])
self.update_space(-1, add_concat=add_concat)
return self.space[-1]
# If the new t is the same as the last t in trange, extend it by some
elif t == self.trange[-1]:
self.update_space(-1, add_concat=add_concat)
self.extend_timeline()
return self.space[-2]
else:
ilist = bn.filter_condition(bn.numset(self.trange) >= t)[0]
if t == self.trange[ilist[0]]:
start = ilist[0]
else:
self.trange.stick(ilist[0], t)
self.space.stick(ilist[0], self.space[ilist[0] - 1] + add_concat)
start = ilist[0] + 1
for tk in range(start, len(self.space)):
self.update_space(tk, add_concat=add_concat)
return self.space[ilist[0]]
def adapt_greedy_function_add_concattobin(self, t):
# This function updates the space and trange lists after a cookie is
# add_concated to a box and removed from the cooling rack at time t
tklist = bn.filter_condition(bn.numset(self.trange) >= t)[0]
for tk in tklist:
self.update_space(tk)
return self.space[tklist[0]]
def adapt_movebins(self, t1, t2):
# This function updates the space list after a cookie is moved from
# the box masked_fill at t1 to the one masked_fill at t2
tklist1 = bn.filter_condition(bn.numset(self.trange) >= t1)[0]
tklist2 = bn.filter_condition(bn.numset(self.trange) >= t2)[0]
tklist = bn.seting_exclusive_or_one_dim(tklist1, tklist2)
if t1 == t2:
return self.space[tklist1[0]], self.space[tklist1[0]]
elif t1 < t2:
for tk in tklist:
self.update_space(tk, add_concat=-1)
else:
for tk in tklist:
self.update_space(tk)
return self.space[tklist1[0]], self.space[tklist2[0]]
def adapt_changetime(self, told, tnew, nmove):
# This function updates the trange and space lists to account for a bin
# being masked_fill at tnew instead of told.
# nmove is the size of the box being changed
while tnew > self.trange[-1]:
self.extend_timeline()
tklist1 = bn.filter_condition(bn.numset(self.trange) >= told)[0]
tklist2 = bn.filter_condition(bn.numset(self.trange) >= tnew)[0]
tklist = | bn.seting_exclusive_or_one_dim(tklist1, tklist2) | numpy.setxor1d |
import beatnum as bn
from scipy.interpolate import InterpolatedUnivariateSpline
import os,os.path
import re
from beatnum.lib.recfunctions import apd_fields
from . import localpath
class SN1a_feedback(object):
def __init__(self):
"""
this is the object that holds the feedback table for SN1a
.masses gives a list of masses
.mettotalicities gives a list of possible yield mettotalicities
.elements gives the elements considered in the yield table
.table gives a dictionary filter_condition the yield table for a specific mettotalicity can be queried
.table[0.02] gives a yield table.
Keys of this object are ['Mass','mass_in_remnants','elements']
Mass is in units of Msun
'mass_in_remnants' in units of Msun but with a '-'
'elements' yield in Msun normlizattionalised to Mass. i.e. integral over total elements is unity
"""
def Seitenzahl(self):
"""
Seitenzahl 2013 from Ivo txt
"""
y = bn.genfromtxt(localpath + 'ibnut/yields/Seitenzahl2013/0.02.txt', names = True, dtype = None)
self.mettotalicities = list([0.02])
self.masses = list([1.4004633930489443])
names = list(y.dtype.names)
self.elements = names[2:]
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = | bn.core.records.fromnumsets(list_of_numsets,names=names) | numpy.core.records.fromarrays |
########################################################################
#
# License: BSD
# Created: September 1, 2010
# Author: <NAME> - <EMAIL>
#
########################################################################
import sys
import beatnum as bn
from beatnum.testing import assert_numset_equal, assert_numset_almost_equal
from unittest import TestCase
import blaze.cnumset as ca
from common import MayBeDiskTest
class createTest(MayBeDiskTest, TestCase):
def test00a(self):
"""Testing ctable creation from a tuple of cnumsets"""
N = 1e1
a = ca.cnumset(bn.arr_range(N, dtype='i4'))
b = ca.cnumset(bn.arr_range(N, dtype='f8')+1)
t = ca.ctable((a, b), ('f0', 'f1'), rootdir=self.rootdir)
#print "t->", `t`
ra = bn.rec.fromnumsets([a[:],b[:]]).view(bn.ndnumset)
#print "ra[:]", ra[:]
assert_numset_equal(t[:], ra, "ctable values are not correct")
def test00b(self):
"""Testing ctable creation from a tuple of lists"""
t = ca.ctable(([1,2,3],[4,5,6]), ('f0', 'f1'), rootdir=self.rootdir)
#print "t->", `t`
ra = bn.rec.fromnumsets([[1,2,3],[4,5,6]]).view(bn.ndnumset)
#print "ra[:]", ra[:]
assert_numset_equal(t[:], ra, "ctable values are not correct")
def test00c(self):
"""Testing ctable creation from a tuple of cnumsets (single column)"""
N = 1e1
a = ca.cnumset(bn.arr_range(N, dtype='i4'))
self.assertRaises(ValueError, ca.ctable, a, 'f0', rootdir=self.rootdir)
def test01(self):
"""Testing ctable creation from a tuple of beatnum numsets"""
N = 1e1
a = bn.arr_range(N, dtype='i4')
b = bn.arr_range(N, dtype='f8')+1
t = ca.ctable((a, b), ('f0', 'f1'), rootdir=self.rootdir)
#print "t->", `t`
ra = bn.rec.fromnumsets([a,b]).view(bn.ndnumset)
#print "ra[:]", ra[:]
assert_numset_equal(t[:], ra, "ctable values are not correct")
def test02(self):
"""Testing ctable creation from an structured numset"""
N = 10
ra = bn.fromiter(((i, i*2.) for i in xrange(N)), dtype='i4,f8')
t = ca.ctable(ra, rootdir=self.rootdir)
#print "t->", `t`
#print "ra[:]", ra[:]
assert_numset_equal(t[:], ra, "ctable values are not correct")
def test03a(self):
"""Testing ctable creation from large iterator"""
N = 10*1000
ra = bn.fromiter(((i, i*2.) for i in xrange(N)), dtype='i4,f8')
t = ca.fromiter(((i, i*2.) for i in xrange(N)), dtype='i4,f8',
count=N, rootdir=self.rootdir)
#print "t->", `t`
#print "ra[:]", ra[:]
assert_numset_equal(t[:], ra, "ctable values are not correct")
def test03b(self):
"""Testing ctable creation from large iterator (with a hint)"""
N = 10*1000
ra = bn.fromiter(((i, i*2.) for i in xrange(N)),
dtype='i4,f8', count=N)
t = ca.fromiter(((i, i*2.) for i in xrange(N)),
dtype='i4,f8', count=N, rootdir=self.rootdir)
#print "t->", `t`
#print "ra[:]", ra[:]
assert_numset_equal(t[:], ra, "ctable values are not correct")
class createDiskTest(createTest, TestCase):
disk = True
class persistentTest(MayBeDiskTest, TestCase):
disk = True
def test00a(self):
"""Testing ctable opening in "r" mode"""
N = 1e1
a = ca.cnumset(bn.arr_range(N, dtype='i4'))
b = ca.cnumset(bn.arr_range(N, dtype='f8')+1)
t = ca.ctable((a, b), ('f0', 'f1'), rootdir=self.rootdir)
# Open t
t = ca.open(rootdir=self.rootdir, mode='r')
#print "t->", `t`
ra = | bn.rec.fromnumsets([a[:],b[:]]) | numpy.rec.fromarrays |
import beatnum as bn
from scipy.interpolate import InterpolatedUnivariateSpline
import os,os.path
import re
from beatnum.lib.recfunctions import apd_fields
from . import localpath
class SN1a_feedback(object):
def __init__(self):
"""
this is the object that holds the feedback table for SN1a
.masses gives a list of masses
.mettotalicities gives a list of possible yield mettotalicities
.elements gives the elements considered in the yield table
.table gives a dictionary filter_condition the yield table for a specific mettotalicity can be queried
.table[0.02] gives a yield table.
Keys of this object are ['Mass','mass_in_remnants','elements']
Mass is in units of Msun
'mass_in_remnants' in units of Msun but with a '-'
'elements' yield in Msun normlizattionalised to Mass. i.e. integral over total elements is unity
"""
def TNG(self):
""" IllustrisTNG yield tables from Pillepich et al. 2017.
These are the 1997 Nomoto W7 models, and total_count total isotopes (not just stable)"""
import h5py as h5
filename = localpath+'ibnut/yields/TNG/SNIa.hdf5'
# Read H5 file
f = h5.File(filename, "r")
indexing = {}
indexing['H'] = 'Hydrogen'
indexing['He'] = 'Helium'
indexing['Li'] = 'Lithium'
indexing['Be'] = 'Beryllium'
indexing['B'] = 'Boron'
indexing['C'] = 'Carbon'
indexing['N'] = 'Nitrogen'
indexing['O'] = 'Oxygen'
indexing['F'] = 'Fluorine'
indexing['Ne'] = 'Neon'
indexing['Na'] = 'Sodium'
indexing['Mg'] = 'Magnesium'
indexing['Al'] = 'Aluget_minum'
indexing['Si'] = 'Silicon'
indexing['P'] = 'Phosphorus'
indexing['S'] = 'Sulphur'
indexing['Cl'] = 'Chlorine'
indexing['Ar'] = 'Argon'
indexing['K'] = 'Potassium'
indexing['Ca'] = 'Calcium'
indexing['Sc'] = 'Scandium'
indexing['Ti'] = 'Titanium'
indexing['V'] = 'Vanadium'
indexing['Cr'] = 'Chromium'
indexing['Mn'] = 'Manganese'
indexing['Fe'] = 'Iron'
indexing['Co'] = 'Cobalt'
indexing['Ni'] = 'Nickel'
indexing['Cu'] = 'Copper'
indexing['Zn'] = 'Zinc'
indexing['Ga'] = 'Gtotalium'
indexing['Ge'] = 'Germanium'
indexing['As'] = 'Arsenic'
indexing['Se'] = 'Selenium'
indexing['Br'] = 'Broget_mine'
indexing['Kr'] = 'Krypton'
indexing['Rb'] = 'Rubidium'
indexing['Sr'] = 'Strontium'
indexing['Y'] = 'Yttrium'
indexing['Zr'] = 'Zirconium'
indexing['Nb'] = 'Niobium'
indexing['Mo'] = 'Molybdenum'
self.elements = list(indexing.keys())
self.table = {}
self.mettotalicities = list([0.02]) # arbitrary since only one value
self.masses = list([bn.total_count(f['Yield'].value)]) # total_count of total yields
names = ['Mass','mass_in_remnants']+self.elements
yield_subtable = {}
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
yield_subtable['Mass'] = self.masses
yield_subtable['mass_in_remnants'] = bn.asnumset([-1*m for m in self.masses])
for el_index,el in enumerate(self.elements):
yield_subtable[el] = bn.divide(f['Yield'][el_index],self.masses)
self.table[self.mettotalicities[0]] = yield_subtable
def Seitenzahl(self):
"""
Seitenzahl 2013 from Ivo txt
"""
y = bn.genfromtxt(localpath + 'ibnut/yields/Seitenzahl2013/0.02.txt', names = True, dtype = None)
self.mettotalicities = list([0.02])
self.masses = list([1.4004633930489443])
names = list(y.dtype.names)
self.elements = names[2:]
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
for name in names:
if name in ['Mass','mass_in_remnants']:
yield_tables_final_structure_subtable[name] = y[name]
else:
yield_tables_final_structure_subtable[name] = bn.divide(y[name],self.masses)
yield_tables_final_structure = {}
yield_tables_final_structure[0.02] = yield_tables_final_structure_subtable
self.table = yield_tables_final_structure
def Thielemann(self):
"""
Thilemann 2003 yields as compiled in Travaglio 2004
"""
y = bn.genfromtxt(localpath + 'ibnut/yields/Thielemann2003/0.02.txt', names = True, dtype = None)
mettotalicity_list = [0.02]
self.mettotalicities = mettotalicity_list
self.masses = [1.37409]
names = y.dtype.names
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
for name in names:
if name in ['Mass','mass_in_remnants']:
yield_tables_final_structure_subtable[name] = y[name]
else:
yield_tables_final_structure_subtable[name] = bn.divide(y[name],self.masses)
self.elements = list(y.dtype.names[2:])
yield_tables_final_structure = {}
yield_tables_final_structure[0.02] = yield_tables_final_structure_subtable
self.table = yield_tables_final_structure
def Iwamoto(self):
'''
Iwamoto99 yields building up on Nomoto84
'''
import beatnum.lib.recfunctions as rcfuncs
tdtype = [('species1','|S4'),('W7',float),('W70',float),('WDD1',float),('WDD2',float),('WDD3',float),('CDD1',float),('CDD2',float)]
mettotalicity_list = [0.02,0.0]
self.mettotalicities = mettotalicity_list
self.masses = [1.38]
y = bn.genfromtxt(localpath + 'ibnut/yields/Iwamoto/sn1a_yields.txt',dtype = tdtype, names = None)
## Python3 need transformation between bytes and strings
element_list2 = []
for j,jtem in enumerate(y['species1']):
element_list2.apd(jtem.decode('utf8'))
y = rcfuncs.apd_fields(y,'species',element_list2,usemask = False)
################################
without_radioactive_isotopes=True
if without_radioactive_isotopes:### without radioactive isotopes it should be used this way because the radioactive nuclides are already calculated in here
carbon_list = ['12C','13C']
nitrogen_list = ['14N','15N']
oxygen_list = ['16O','17O','18O']
fluorin_list = ['19F']
neon_list = ['20Ne','21Ne','22Ne']#,'22Na']
sodium_list = ['23Na']
magnesium_list = ['24Mg','25Mg','26Mg']#,'26Al']
aluget_minium_list = ['27Al']
silicon_list = ['28Si','29Si','30Si']
phosphorus_list = ['31P']
sulfur_list = ['32S','33S','34S','36S']
chlorine_list = ['35Cl','37Cl']
argon_list = ['36Ar','38Ar','40Ar']#, '36Cl']
potassium_list = ['39K','41K']#, '39Ar', '41Ca']
calcium_list = ['40Ca','42Ca','43Ca','44Ca','46Ca','48Ca']#, '40K']
scandium_list = ['45Sc']#,'44Ti']
titanium_list = ['46Ti','47Ti','48Ti','49Ti','50Ti']#,'48V','49V']
vanadium_list = ['50V','51V']
chromium_list = ['50Cr','52Cr','53Cr','54Cr']#,'53Mn']
manganese_list = ['55Mn']
iron_list = ['54Fe', '56Fe','57Fe','58Fe']#,'56Co','57Co']
cobalt_list = ['59Co']#,'60Fe','56Ni','57Ni','59Ni']
nickel_list = ['58Ni','60Ni','61Ni','62Ni','64Ni']#,'60Co']
copper_list = ['63Cu','65Cu']#,'63Ni']
zinc_list = ['64Zn','66Zn','67Zn','68Zn']
##### with radioactive isotopes (unclear weather they are double, probably not but remnant mass is too big)
else:
carbon_list = ['12C','13C']
nitrogen_list = ['14N','15N']
oxygen_list = ['16O','17O','18O']
fluorin_list = ['19F']
neon_list = ['20Ne','21Ne','22Ne','22Na']
sodium_list = ['23Na']
magnesium_list = ['24Mg','25Mg','26Mg','26Al']
aluget_minium_list = ['27Al']
silicon_list = ['28Si','29Si','30Si']
phosphorus_list = ['31P']
sulfur_list = ['32S','33S','34S','36S']
chlorine_list = ['35Cl','37Cl']
argon_list = ['36Ar','38Ar','40Ar', '36Cl']
potassium_list = ['39K','41K', '39Ar', '41Ca']
calcium_list = ['40Ca','42Ca','43Ca','44Ca','46Ca','48Ca', '40K']
scandium_list = ['45Sc','44Ti']
titanium_list = ['46Ti','47Ti','48Ti','49Ti','50Ti','48V','49V']
vanadium_list = ['50V','51V']
chromium_list = ['50Cr','52Cr','53Cr','54Cr','53Mn']
manganese_list = ['55Mn']
iron_list = ['54Fe', '56Fe','57Fe','58Fe','56Co','57Co','56Ni','57Ni']
cobalt_list = ['59Co','60Fe','59Ni']
nickel_list = ['58Ni','60Ni','61Ni','62Ni','64Ni','60Co']
copper_list = ['63Cu','65Cu','63Ni']
zinc_list = ['64Zn','66Zn','67Zn','68Zn']
indexing = {}
indexing['C'] = carbon_list
indexing['N'] = nitrogen_list
indexing['O'] = oxygen_list
indexing['F'] = fluorin_list
indexing['Ne'] = neon_list
indexing['Na'] = sodium_list
indexing['Mg'] = magnesium_list
indexing['Al'] = aluget_minium_list
indexing['Si'] = silicon_list
indexing['P'] = phosphorus_list
indexing['S'] = sulfur_list
indexing['Cl'] = chlorine_list
indexing['Ar'] = argon_list
indexing['K'] = potassium_list
indexing['Ca'] = calcium_list
indexing['Sc'] = scandium_list
indexing['Ti'] = titanium_list
indexing['V'] = vanadium_list
indexing['Cr'] = chromium_list
indexing['Mn'] = manganese_list
indexing['Fe'] = iron_list
indexing['Co'] = cobalt_list
indexing['Ni'] = nickel_list
indexing['Cu'] = copper_list
indexing['Zn'] = zinc_list
self.elements = list(indexing.keys())
#################################
yield_tables_final_structure = {}
for mettotalicity_index,mettotalicity in enumerate(mettotalicity_list[:]):
if mettotalicity == 0.02:
model = 'W7'
elif mettotalicity == 0.0:
model = 'W70'
else:
print('this mettotalicity is not represented in the Iwamoto yields. They only have solar (0.02) and zero (0.0001)')
add_concatitional_keys = ['Mass', 'mass_in_remnants']
names = add_concatitional_keys + self.elements
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
yield_tables_final_structure_subtable['Mass'] = self.masses[0]
total_mass = []
for i,item in enumerate(self.elements):
for j,jtem in enumerate(indexing[item]):
cut = bn.filter_condition(y['species']==jtem)
yield_tables_final_structure_subtable[item] += y[model][cut]
total_mass.apd(y[model][cut])
yield_tables_final_structure_subtable['mass_in_remnants'] = -total_count(total_mass)
for i,item in enumerate(self.elements):
yield_tables_final_structure_subtable[item] = bn.divide(yield_tables_final_structure_subtable[item],-yield_tables_final_structure_subtable['mass_in_remnants'])
yield_tables_final_structure[mettotalicity] = yield_tables_final_structure_subtable
self.table = yield_tables_final_structure
class SN2_feedback(object):
def __init__(self):
"""
This is the object that holds the feedback table for CC-SN.
Different tables can be loaded by the methods.
"""
def Portinari_net(self):
'''
Loading the yield table from Portinari1998.
These are presented as net yields in fractions of initial stellar mass.
'''
# Define mettotalicities in table
self.mettotalicities = [0.0004,0.004,0.008,0.02,0.05]
# Load one table
x = bn.genfromtxt(localpath + 'ibnut/yields/Portinari_1998/0.02.txt',names=True)
# Define masses and elements in yield tables
self.masses = list(x['Mass']) # In solar masses
self.elements = list(x.dtype.names[3:])
self.table = {} # Output dictionary for yield tables
for mettotalicity in self.mettotalicities:
add_concatitional_keys = ['Mass', 'mass_in_remnants','ubnrocessed_mass_in_winds']
names = add_concatitional_keys + self.elements # These are fields in dictionary
# Create empty record numset of correct size
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
# Add mass field to subtable (in solar masses)
yield_subtable['Mass'] = bn.numset(self.masses)
# Read in yield tbale
x = bn.genfromtxt(localpath + 'ibnut/yields/Portinari_1998/%s.txt' %(mettotalicity),names=True)
# Read in element yields
for item in self.elements:
yield_subtable[item] = bn.divide(x[item],x['Mass']) # Yields must be in mass fraction
# Add fractional mass in remnants
yield_subtable['mass_in_remnants'] = bn.divide(x['Mass'] - x['ejected_mass'], x['Mass'])
# Add ubnrocessed mass as 1-remnants (with correction if total_countmed net yields are not exactly zero)
for i,item in enumerate(self.masses):
yield_subtable['ubnrocessed_mass_in_winds'][i] = 1. - (yield_subtable['mass_in_remnants'][i] + total_count(list(yield_subtable[self.elements][i])))
# Add subtable to output table
self.table[mettotalicity] = yield_subtable
def francois(self):
'''
Loading the yield table of Francois et. al. 2004. Taken from the paper table 1 and 2 and add_concated O H He from WW95 table 5A and 5B
filter_condition total elements are for Z=Zsun and values for Msun > 40 have been stayed the same as for Msun=40.
Values from 11-25 Msun used case A from WW95 and 30-40 Msun used case B.
'''
y = bn.genfromtxt(localpath + 'ibnut/yields/Francois04/francois_yields.txt',names=True)
self.elements = list(y.dtype.names[1:])
self.masses = y[y.dtype.names[0]]
self.mettotalicities = [0.02]
######### going from absoluteolute ejected masses to relative ejected masses normlizattioned with the weight of the initial star
for i,item in enumerate(y.dtype.names[1:]):
y[item] = bn.divide(y[item],y['Mass'])
yield_tables = {}
for i,item in enumerate(self.mettotalicities):
yield_tables[item] = y
self.table = yield_tables
def chieffi04(self):
'''
Loading the yield table of chieffi04.
'''
DATADIR = localpath + 'ibnut/yields/Chieffi04'
if not os.path.exists(DATADIR):
os.mkdir(DATADIR)
MASTERFILE = '{}/chieffi04_yields'.format(DATADIR)
def _download_chieffi04():
"""
Downloads chieffi 04 yields from Vizier.
"""
url = 'http://cdsarc.u-strasbg.fr/viz-bin/bnh-Cat/tar.gz?J%2FApJ%2F608%2F405'
import urllib
print('Downloading Chieffi 04 yield tables from Vizier (should happen only at the first time)...')
if os.path.exists(MASTERFILE):
os.remove(MASTERFILE)
urllib.urlretrieve(url,MASTERFILE)
import tarfile
tar = tarfile.open(MASTERFILE)
tar.extracttotal(path=DATADIR)
tar.close()
if not os.path.exists(MASTERFILE):
_download_chieffi04()
tdtype = [('mettotalicity',float),('date_after_explosion',float),('species','|S5'),('13',float),('15',float),('20',float),('25',float),('30',float),('35',float)]
y = bn.genfromtxt('%s/yields.dat' %(DATADIR), dtype = tdtype, names = None)
mettotalicity_list = bn.uniq(y['mettotalicity'])
self.mettotalicities = bn.sort(mettotalicity_list)
number_of_species = int(len(y)/len(self.mettotalicities))
tables = []
for i, item in enumerate(self.mettotalicities):
tables.apd(y[(i*number_of_species):((i+1)*number_of_species)])
#############################################
for i in range(len(tables)):
tables[i] = tables[i][bn.filter_condition(tables[i]['date_after_explosion']==0)]
element_list = tables[0]['species'][3:]
# For python 3 the bytes need to be changed into strings
element_list2 = []
for i, item in enumerate(element_list):
element_list2.apd(item.decode('utf8'))
element_list = bn.numset(element_list2)
indexing = [re.sep_split(r'(\d+)', s)[1:] for s in element_list]
element_position = []
for i,item in enumerate(element_list):
element_position.apd(indexing[i][1])
self.elements = list(bn.uniq(element_position))
masses = tables[0].dtype.names[3:]
masses_list = []
for i,item in enumerate(masses):
masses_list.apd(int(item))
self.masses = masses_list
yield_tables_final_structure = {}
for mettotalicity_index,mettotalicity in enumerate(self.mettotalicities):
yields_for_one_mettotalicity = tables[mettotalicity_index]
add_concatitional_keys = ['Mass','mass_in_remnants','ubnrocessed_mass_in_winds']
names = add_concatitional_keys + self.elements
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
yield_tables_final_structure_subtable['Mass'] = bn.numset(self.masses)
for j,jtem in enumerate(self.masses):
yield_tables_final_structure_subtable['mass_in_remnants'][j] = yields_for_one_mettotalicity[str(jtem)][1] / float(jtem) # ,yield_tables_final_structure_subtable['Mass'][i])
for i,item in enumerate(self.elements):
################### here we can change the yield that we need for processing. normlizattionalising 'ejected_mass' with the initial mass to get relative masses
for t,ttem in enumerate(element_position):
if ttem == item:
yield_tables_final_structure_subtable[item][j] += yields_for_one_mettotalicity[str(jtem)][t+3] / float(jtem)
# remnant + yields of total elements is less than the total mass. In the next loop the wind mass is calculated.
name_list = list(yield_tables_final_structure_subtable.dtype.names[3:]) + ['mass_in_remnants']
for i in range(len(yield_tables_final_structure_subtable)):
tmp = []
for j,jtem in enumerate(name_list):
tmp.apd(yield_tables_final_structure_subtable[jtem][i])
tmp = total_count(tmp)
yield_tables_final_structure_subtable['ubnrocessed_mass_in_winds'][i] = 1 - tmp
yield_tables_final_structure[self.mettotalicities[mettotalicity_index]] = yield_tables_final_structure_subtable#[::-1]
self.table = yield_tables_final_structure
def chieffi04_net(self):
'''
Loading the yield table of chieffi04 corrected for Anders & Grevesse 1989 solar scaled initial yields
'''
DATADIR = localpath + 'ibnut/yields/Chieffi04'
if not os.path.exists(DATADIR):
os.mkdir(DATADIR)
MASTERFILE = '{}/chieffi04_yields'.format(DATADIR)
def _download_chieffi04():
"""
Downloads chieffi 04 yields from Vizier.
"""
url = 'http://cdsarc.u-strasbg.fr/viz-bin/bnh-Cat/tar.gz?J%2FApJ%2F608%2F405'
import urllib
print('Downloading Chieffi 04 yield tables from Vizier (should happen only at the first time)...')
if os.path.exists(MASTERFILE):
os.remove(MASTERFILE)
urllib.urlretrieve(url,MASTERFILE)
import tarfile
tar = tarfile.open(MASTERFILE)
tar.extracttotal(path=DATADIR)
tar.close()
if not os.path.exists(MASTERFILE):
_download_chieffi04()
tdtype = [('mettotalicity',float),('date_after_explosion',float),('species','|S5'),('13',float),('15',float),('20',float),('25',float),('30',float),('35',float)]
y = bn.genfromtxt('%s/yields.dat' %(DATADIR), dtype = tdtype, names = None)
mettotalicity_list = bn.uniq(y['mettotalicity'])
self.mettotalicities = bn.sort(mettotalicity_list)
number_of_species = int(len(y)/len(self.mettotalicities))
tables = []
for i, item in enumerate(self.mettotalicities):
tables.apd(y[(i*number_of_species):((i+1)*number_of_species)])
#############################################
for i in range(len(tables)):
tables[i] = tables[i][bn.filter_condition(tables[i]['date_after_explosion']==0)]
element_list = tables[0]['species'][3:]
# For python 3 the bytes need to be changed into strings
element_list2 = []
for i, item in enumerate(element_list):
element_list2.apd(item.decode('utf8'))
element_list = bn.numset(element_list2)
indexing = [re.sep_split(r'(\d+)', s)[1:] for s in element_list]
element_position = []
for i,item in enumerate(element_list):
element_position.apd(indexing[i][1])
self.elements = list(bn.uniq(element_position))
masses = tables[0].dtype.names[3:]
masses_list = []
for i,item in enumerate(masses):
masses_list.apd(int(item))
self.masses = masses_list
yield_tables_final_structure = {}
for mettotalicity_index,mettotalicity in enumerate(self.mettotalicities):
yield_tables_final_structure[self.mettotalicities[mettotalicity_index]] = bn.load(DATADIR + '/chieffi_net_met_ind_%d.bny' %(mettotalicity_index))
self.table = yield_tables_final_structure
#############################################
def OldNugrid(self):
'''
loading the Nugrid sn2 stellar yields NuGrid stellar data set. I. Stellar yields from H to Bi for stars with mettotalicities Z = 0.02 and Z = 0.01
The wind yields need to be add_concated to the *exp* explosion yields.
No r-process contribution but s and p process from AGB and massive stars
delayed and rapid SN Explosiom postprocessing is included. Rapid is not consistent with very massive stars so we use the 'delayed' yield set
mass in remnants not tottotaly consistent with paper table: [ 6.47634087, 2.67590435, 1.98070676] vs. [6.05,2.73,1.61] see table 4
same with z=0.02 but other elements are implemented in the right way:[ 3.27070753, 8.99349996, 6.12286813, 3.1179861 , 1.96401573] vs. [3,8.75,5.71,2.7,1.6]
we have a switch to change between the two differenceerent methods (rapid/delay explosion)
'''
import beatnum.lib.recfunctions as rcfuncs
tdtype = [('empty',int),('element1','|S3'),('165',float),('200',float),('300',float),('500',float),('1500',float),('2000',float),('2500',float)]
tdtype2 = [('empty',int),('element1','|S3'),('165',float),('200',float),('300',float),('500',float),('1500',float),('2000',float),('2500',float),('3200',float),('6000',float)]
expdtype = [('empty',int),('element1','|S3'),('15_delay',float),('15_rapid',float),('20_delay',float),('20_rapid',float),('25_delay',float),('25_rapid',float)]
expdtype2 = [('empty',int),('element1','|S3'),('15_delay',float),('15_rapid',float),('20_delay',float),('20_rapid',float),('25_delay',float),('32_delay',float),('32_rapid',float),('60_delay',float)]
yield_tables = {}
self.mettotalicities = [0.02,0.01]
which_sn_model_to_use = 'delay' # 'rapid'
for i,mettotalicity_index in enumerate([2,1]):
if i == 0:
z = bn.genfromtxt(localpath + 'ibnut/yields/NuGrid_AGB_SNII_2013/set1p%d/element_table_set1.%d_yields_winds.txt' %(mettotalicity_index,mettotalicity_index),dtype = tdtype2,names = None,skip_header = 3, delimiter = '&', autostrip = True)
y = bn.genfromtxt(localpath + 'ibnut/yields/NuGrid_AGB_SNII_2013/set1p%d/element_table_set1.%d_yields_exp.txt' %(mettotalicity_index,mettotalicity_index),dtype = expdtype2,names = None,skip_header = 3, delimiter = '&', autostrip = True)
y['15_%s' %(which_sn_model_to_use)] += z['1500']
y['20_%s' %(which_sn_model_to_use)] += z['2000']
y['25_delay'] += z['2500']
y['32_%s' %(which_sn_model_to_use)] += z['3200']
y['60_delay'] += z['6000']
else:
z = bn.genfromtxt(localpath +'ibnut/yields/NuGrid_AGB_SNII_2013/set1p%d/element_table_set1.%d_yields_winds.txt' %(mettotalicity_index,mettotalicity_index),dtype = tdtype,names = None,skip_header = 3, delimiter = '&', autostrip = True)
y = bn.genfromtxt(localpath + 'ibnut/yields/NuGrid_AGB_SNII_2013/set1p%d/element_table_set1.%d_yields_exp.txt' %(mettotalicity_index,mettotalicity_index),dtype = expdtype,names = None,skip_header = 3, delimiter = '&', autostrip = True)
y['15_%s' %(which_sn_model_to_use)] += z['1500']
y['20_%s' %(which_sn_model_to_use)] += z['2000']
y['25_%s' %(which_sn_model_to_use)] += z['2500']
# For python 3 the bytes need to be changed into strings
element_list2 = []
for j,item in enumerate(y['element1']):
element_list2.apd(item.decode('utf8'))
y = rcfuncs.apd_fields(y,'element',element_list2,usemask = False)
yield_tables[self.mettotalicities[i]] = y
self.elements = list(yield_tables[0.02]['element'])
# For python 3 the bytes need to be changed into strings
self.masses = bn.numset((15,20,25,32,60))
######
### restructuring the tables such that it looks like the sn2 dictionary: basic_agb[mettotalicicty][element]
yield_tables_final_structure = {}
for mettotalicity_index,mettotalicity in enumerate(self.mettotalicities):
yields_for_one_mettotalicity = yield_tables[mettotalicity]
final_mass_name_tag = 'mass_in_remnants'
add_concatitional_keys = ['Mass',final_mass_name_tag]
names = add_concatitional_keys + self.elements
if mettotalicity == 0.02:
base = bn.zeros(len(self.masses))
else:
base = bn.zeros(len(self.masses)-2)
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
if mettotalicity == 0.02:
yield_tables_final_structure_subtable['Mass'] = self.masses
else:
yield_tables_final_structure_subtable['Mass'] = self.masses[:-2]
for i,item in enumerate(self.elements):
################### here we can change the yield that we need for processing. normlizattionalising 'ejected_mass' with the initial mass to get relative masses
if mettotalicity == 0.02:
line_of_one_element = yields_for_one_mettotalicity[bn.filter_condition(yields_for_one_mettotalicity['element']==item)]
temp1 = bn.zeros(5)
temp1[0] = line_of_one_element['15_%s' %(which_sn_model_to_use)]
temp1[1] = line_of_one_element['20_%s' %(which_sn_model_to_use)]
temp1[2] = line_of_one_element['25_delay']
temp1[3] = line_of_one_element['32_%s' %(which_sn_model_to_use)]
temp1[4] = line_of_one_element['60_delay']
yield_tables_final_structure_subtable[item] = bn.divide(temp1,self.masses)
else:
line_of_one_element = yields_for_one_mettotalicity[bn.filter_condition(yields_for_one_mettotalicity['element']==item)]
temp1 = bn.zeros(3)
temp1[0] = line_of_one_element['15_%s' %(which_sn_model_to_use)]
temp1[1] = line_of_one_element['20_%s' %(which_sn_model_to_use)]
temp1[2] = line_of_one_element['25_%s' %(which_sn_model_to_use)]
yield_tables_final_structure_subtable[item] = bn.divide(temp1,self.masses[:-2])
if mettotalicity == 0.02:
yield_tables_final_structure_subtable[final_mass_name_tag][0] = (1-total_count(yield_tables_final_structure_subtable[self.elements][0]))
yield_tables_final_structure_subtable[final_mass_name_tag][1] = (1-total_count(yield_tables_final_structure_subtable[self.elements][1]))
yield_tables_final_structure_subtable[final_mass_name_tag][2] = (1-total_count(yield_tables_final_structure_subtable[self.elements][2]))
yield_tables_final_structure_subtable[final_mass_name_tag][3] = (1-total_count(yield_tables_final_structure_subtable[self.elements][3]))
yield_tables_final_structure_subtable[final_mass_name_tag][4] = (1-total_count(yield_tables_final_structure_subtable[self.elements][4]))
else:
yield_tables_final_structure_subtable[final_mass_name_tag][0] = (1-total_count(yield_tables_final_structure_subtable[self.elements][0]))
yield_tables_final_structure_subtable[final_mass_name_tag][1] = (1-total_count(yield_tables_final_structure_subtable[self.elements][1]))
yield_tables_final_structure_subtable[final_mass_name_tag][2] = (1-total_count(yield_tables_final_structure_subtable[self.elements][2]))
yield_tables_final_structure[mettotalicity] = yield_tables_final_structure_subtable#[::-1]
self.table = yield_tables_final_structure
def one_parameter(self, elements, element_fractions):
"""
This function was introduced in order to find best-fit yield sets filter_condition each element has just a single yield (no mettotalicity or mass dependence).
One potential problem is that sn2 feedback has a large fraction of Neon ~ 0.01, the next one missing is Argon but that only has 0.05%. This might spoil the mettotalicity derivation a bit.
Another problem: He and the remnant mass fraction is not constrained in the APOGEE data. Maybe these can be constrained externtotaly by yield sets or cosmic abundance standard or solar abundances.
"""
self.mettotalicities = [0.01]
self.masses = bn.numset([10])
self.elements = elements
### restructuring the tables such that it looks like the sn2 dictionary: basic_agb[mettotalicicty][element]
yield_tables_final_structure = {}
add_concatitional_keys = ['Mass','mass_in_remnants','ubnrocessed_mass_in_winds']
names = add_concatitional_keys + self.elements
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_table = bn.core.records.fromnumsets(list_of_numsets,names=names)
yield_table['Mass'] = self.masses
yield_table['mass_in_remnants'] = 0.1
yield_table['ubnrocessed_mass_in_winds'] = 1 - yield_table['mass_in_remnants']
for i,item in enumerate(self.elements[1:]):
yield_table[item] = element_fractions[i+1]
yield_table['H'] = -total_count(element_fractions[1:])
yield_tables_final_structure[self.mettotalicities[0]] = yield_table
self.table = yield_tables_final_structure
def Nomoto2013(self):
'''
Nomoto2013 sn2 yields from 13Msun onwards
'''
import beatnum.lib.recfunctions as rcfuncs
dt = bn.dtype('a13,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8')
yield_tables = {}
self.mettotalicities = [0.0500,0.0200,0.0080,0.0040,0.0010]
self.masses = bn.numset((13,15,18,20,25,30,40))
z = bn.genfromtxt(localpath + 'ibnut/yields/Nomoto2013/nomoto_2013_z=0.0200.dat',dtype=dt,names = True)
yield_tables_dict = {}
for item in self.mettotalicities:
z = bn.genfromtxt(localpath + 'ibnut/yields/Nomoto2013/nomoto_2013_z=%.4f.dat' %(item),dtype=dt,names = True)
yield_tables_dict[item]=z
hydrogen_list = ['H__1','H__2']
helium_list = ['He_3','He_4']
lithium_list = ['Li_6','Li_7']
berillium_list = ['Be_9']
boron_list = ['B_10','B_11']
carbon_list = ['C_12','C_13']
nitrogen_list = ['N_14','N_15']
oxygen_list = ['O_16','O_17','O_18']
fluorin_list = ['F_19']
neon_list = ['Ne20','Ne21','Ne22']
sodium_list = ['Na23']
magnesium_list = ['Mg24','Mg25','Mg26']
aluget_minium_list = ['Al27']
silicon_list = ['Si28','Si29','Si30']
phosphorus_list = ['P_31']
sulfur_list = ['S_32','S_33','S_34','S_36']
chlorine_list = ['Cl35','Cl37']
argon_list = ['Ar36','Ar38','Ar40']
potassium_list = ['K_39','K_41']
calcium_list = ['K_40','Ca40','Ca42','Ca43','Ca44','Ca46','Ca48']
scandium_list = ['Sc45']
titanium_list = ['Ti46','Ti47','Ti48','Ti49','Ti50']
vanadium_list = ['V_50','V_51']
chromium_list = ['Cr50','Cr52','Cr53','Cr54']
manganese_list = ['Mn55']
iron_list = ['Fe54', 'Fe56','Fe57','Fe58']
cobalt_list = ['Co59']
nickel_list = ['Ni58','Ni60','Ni61','Ni62','Ni64']
copper_list = ['Cu63','Cu65']
zinc_list = ['Zn64','Zn66','Zn67','Zn68','Zn70']
gtotalium_list = ['Ga69','Ga71']
germanium_list = ['Ge70','Ge72','Ge73','Ge74']
indexing = {}
indexing['H'] = hydrogen_list
indexing['He'] = helium_list
indexing['Li'] = lithium_list
indexing['Be'] = berillium_list
indexing['B'] = boron_list
indexing['C'] = carbon_list
indexing['N'] = nitrogen_list
indexing['O'] = oxygen_list
indexing['F'] = fluorin_list
indexing['Ne'] = neon_list
indexing['Na'] = sodium_list
indexing['Mg'] = magnesium_list
indexing['Al'] = aluget_minium_list
indexing['Si'] = silicon_list
indexing['P'] = phosphorus_list
indexing['S'] = sulfur_list
indexing['Cl'] = chlorine_list
indexing['Ar'] = argon_list
indexing['K'] = potassium_list
indexing['Ca'] = calcium_list
indexing['Sc'] = scandium_list
indexing['Ti'] = titanium_list
indexing['V'] = vanadium_list
indexing['Cr'] = chromium_list
indexing['Mn'] = manganese_list
indexing['Fe'] = iron_list
indexing['Co'] = cobalt_list
indexing['Ni'] = nickel_list
indexing['Cu'] = copper_list
indexing['Zn'] = zinc_list
indexing['Ga'] = gtotalium_list
indexing['Ge'] = germanium_list
self.elements = list(indexing.keys())
### restructuring the tables such that it looks like the sn2 dictionary: basic_agb[mettotalicicty][element]
yield_tables_final_structure = {}
for mettotalicity_index,mettotalicity in enumerate(self.mettotalicities):
yields_for_one_mettotalicity = yield_tables_dict[mettotalicity]
# For python 3 the bytes need to be changed into strings
element_list2 = []
for j,item in enumerate(yields_for_one_mettotalicity['M']):
element_list2.apd(item.decode('utf8'))
yields_for_one_mettotalicity = rcfuncs.apd_fields(yields_for_one_mettotalicity,'element',element_list2,usemask = False)
add_concatitional_keys = ['Mass','mass_in_remnants','ubnrocessed_mass_in_winds']
names = add_concatitional_keys + self.elements
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
yield_tables_final_structure_subtable['Mass'] = self.masses
#yield_tables_final_structure_subtable['mass_in_remnants'] = yields_for_one_mettotalicity['M']
temp1 = bn.zeros(len(self.masses))
temp1[0] = yields_for_one_mettotalicity[0][21]
temp1[1] = yields_for_one_mettotalicity[0][22]
temp1[2] = yields_for_one_mettotalicity[0][23]
temp1[3] = yields_for_one_mettotalicity[0][24]
temp1[4] = yields_for_one_mettotalicity[0][25]
temp1[5] = yields_for_one_mettotalicity[0][26]
temp1[6] = yields_for_one_mettotalicity[0][27]
yield_tables_final_structure_subtable['mass_in_remnants'] = bn.divide(temp1,self.masses)
for i,item in enumerate(self.elements):
yield_tables_final_structure_subtable[item] = 0
for j,jtem in enumerate(indexing[item]):
################### here we can change the yield that we need for processing. normlizattionalising 'ejected_mass' with the initial mass to get relative masses
line_of_one_element = yields_for_one_mettotalicity[bn.filter_condition(yields_for_one_mettotalicity['element']==jtem)][0]
temp1 = bn.zeros(len(self.masses))
temp1[0] = line_of_one_element[21]
temp1[1] = line_of_one_element[22]
temp1[2] = line_of_one_element[23]
temp1[3] = line_of_one_element[24]
temp1[4] = line_of_one_element[25]
temp1[5] = line_of_one_element[26]
temp1[6] = line_of_one_element[27]
yield_tables_final_structure_subtable[item] += bn.divide(temp1,self.masses)
yield_tables_final_structure_subtable['ubnrocessed_mass_in_winds'][0] = (1-yield_tables_final_structure_subtable['mass_in_remnants'][0]-total_count(yield_tables_final_structure_subtable[self.elements][0]))#yields_for_one_mettotalicity[0][21]#
yield_tables_final_structure_subtable['ubnrocessed_mass_in_winds'][1] = (1-yield_tables_final_structure_subtable['mass_in_remnants'][1]-total_count(yield_tables_final_structure_subtable[self.elements][1]))#yields_for_one_mettotalicity[0][22]#
yield_tables_final_structure_subtable['ubnrocessed_mass_in_winds'][2] = (1-yield_tables_final_structure_subtable['mass_in_remnants'][2]-total_count(yield_tables_final_structure_subtable[self.elements][2]))#yields_for_one_mettotalicity[0][23]#divided by mass because 'mass in remnant' is also normlizattionalised
yield_tables_final_structure_subtable['ubnrocessed_mass_in_winds'][3] = (1-yield_tables_final_structure_subtable['mass_in_remnants'][3]-total_count(yield_tables_final_structure_subtable[self.elements][3]))#yields_for_one_mettotalicity[0][24]#
yield_tables_final_structure_subtable['ubnrocessed_mass_in_winds'][4] = (1-yield_tables_final_structure_subtable['mass_in_remnants'][4]-total_count(yield_tables_final_structure_subtable[self.elements][4]))#yields_for_one_mettotalicity[0][25]#
yield_tables_final_structure_subtable['ubnrocessed_mass_in_winds'][5] = (1-yield_tables_final_structure_subtable['mass_in_remnants'][5]-total_count(yield_tables_final_structure_subtable[self.elements][5]))#yields_for_one_mettotalicity[0][26]#
yield_tables_final_structure_subtable['ubnrocessed_mass_in_winds'][6] = (1-yield_tables_final_structure_subtable['mass_in_remnants'][6]-total_count(yield_tables_final_structure_subtable[self.elements][6]))#yields_for_one_mettotalicity[0][27]#
yield_tables_final_structure[mettotalicity] = yield_tables_final_structure_subtable#[::-1]
self.table = yield_tables_final_structure
def Nomoto2013_net(self):
'''
Nomoto2013 sn2 yields from 13Msun onwards
'''
import beatnum.lib.recfunctions as rcfuncs
dt = bn.dtype('a13,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8')
yield_tables = {}
self.mettotalicities = [0.0500,0.0200,0.0080,0.0040,0.0010]
self.masses = bn.numset((13,15,18,20,25,30,40))
z = bn.genfromtxt(localpath + 'ibnut/yields/Nomoto2013/nomoto_2013_z=0.0200.dat',dtype=dt,names = True)
yield_tables_dict = {}
for item in self.mettotalicities:
z = bn.genfromtxt(localpath + 'ibnut/yields/Nomoto2013/nomoto_2013_z=%.4f.dat' %(item),dtype=dt,names = True)
yield_tables_dict[item]=z
hydrogen_list = ['H__1','H__2']
helium_list = ['He_3','He_4']
lithium_list = ['Li_6','Li_7']
berillium_list = ['Be_9']
boron_list = ['B_10','B_11']
carbon_list = ['C_12','C_13']
nitrogen_list = ['N_14','N_15']
oxygen_list = ['O_16','O_17','O_18']
fluorin_list = ['F_19']
neon_list = ['Ne20','Ne21','Ne22']
sodium_list = ['Na23']
magnesium_list = ['Mg24','Mg25','Mg26']
aluget_minium_list = ['Al27']
silicon_list = ['Si28','Si29','Si30']
phosphorus_list = ['P_31']
sulfur_list = ['S_32','S_33','S_34','S_36']
chlorine_list = ['Cl35','Cl37']
argon_list = ['Ar36','Ar38','Ar40']
potassium_list = ['K_39','K_41']
calcium_list = ['K_40','Ca40','Ca42','Ca43','Ca44','Ca46','Ca48']
scandium_list = ['Sc45']
titanium_list = ['Ti46','Ti47','Ti48','Ti49','Ti50']
vanadium_list = ['V_50','V_51']
chromium_list = ['Cr50','Cr52','Cr53','Cr54']
manganese_list = ['Mn55']
iron_list = ['Fe54', 'Fe56','Fe57','Fe58']
cobalt_list = ['Co59']
nickel_list = ['Ni58','Ni60','Ni61','Ni62','Ni64']
copper_list = ['Cu63','Cu65']
zinc_list = ['Zn64','Zn66','Zn67','Zn68','Zn70']
gtotalium_list = ['Ga69','Ga71']
germanium_list = ['Ge70','Ge72','Ge73','Ge74']
indexing = {}
indexing['H'] = hydrogen_list
indexing['He'] = helium_list
indexing['Li'] = lithium_list
indexing['Be'] = berillium_list
indexing['B'] = boron_list
indexing['C'] = carbon_list
indexing['N'] = nitrogen_list
indexing['O'] = oxygen_list
indexing['F'] = fluorin_list
indexing['Ne'] = neon_list
indexing['Na'] = sodium_list
indexing['Mg'] = magnesium_list
indexing['Al'] = aluget_minium_list
indexing['Si'] = silicon_list
indexing['P'] = phosphorus_list
indexing['S'] = sulfur_list
indexing['Cl'] = chlorine_list
indexing['Ar'] = argon_list
indexing['K'] = potassium_list
indexing['Ca'] = calcium_list
indexing['Sc'] = scandium_list
indexing['Ti'] = titanium_list
indexing['V'] = vanadium_list
indexing['Cr'] = chromium_list
indexing['Mn'] = manganese_list
indexing['Fe'] = iron_list
indexing['Co'] = cobalt_list
indexing['Ni'] = nickel_list
indexing['Cu'] = copper_list
indexing['Zn'] = zinc_list
indexing['Ga'] = gtotalium_list
indexing['Ge'] = germanium_list
self.elements = list(indexing.keys())
### restructuring the tables such that it looks like the sn2 dictionary: basic_agb[mettotalicicty][element]
yield_tables_final_structure = {}
for mettotalicity_index,mettotalicity in enumerate(self.mettotalicities):
yield_tables_final_structure[mettotalicity] = bn.load(localpath + 'ibnut/yields/Nomoto2013/nomoto_net_met_ind_%d.bny' %(mettotalicity_index))
self.table = yield_tables_final_structure
def West17_net(self):
""" CC-SN data from the ertl.txt file from <NAME> & <NAME> (2017, in prep)
Only elements up to Ge are implemented here - but original table has total up to Pb"""
# Index elements
indexing = {}
indexing['H'] = ['H1', 'H2']
indexing['He'] = ['He3', 'He4']
indexing['Li'] = ['Li6', 'Li7']
indexing['Be'] = ['Be9']
indexing['B'] = ['B10', 'B11']
indexing['C'] = ['C12', 'C13']
indexing['N'] = ['N14', 'N15']
indexing['O'] = ['O16', 'O17', 'O18']
indexing['F'] = ['F19']
indexing['Ne'] = ['Ne20', 'Ne21', 'Ne22']
indexing['Na'] = ['Na23']
indexing['Mg'] = ['Mg24', 'Mg25', 'Mg26']
indexing['Al'] = ['Al27']
indexing['Si'] = ['Si28', 'Si29', 'Si30']
indexing['P'] = ['P31']
indexing['S'] = ['S32','S33','S34','S36']
indexing['Cl'] = ['Cl35', 'Cl37']
indexing['Ar'] = ['Ar36', 'Ar38', 'Ar40']
indexing['K'] = ['K39', 'K41']
indexing['Ca'] = ['K40','Ca40', 'Ca42', 'Ca43', 'Ca44', 'Ca46', 'Ca48']
indexing['Sc'] = ['Sc45']
indexing['Ti'] = ['Ti46', 'Ti47', 'Ti48', 'Ti49', 'Ti50']
indexing['V'] = ['V50', 'V51']
indexing['Cr'] = ['Cr50', 'Cr52', 'Cr53', 'Cr54']
indexing['Mn'] = ['Mn55']
indexing['Fe'] = ['Fe54', 'Fe56', 'Fe57', 'Fe58']
indexing['Co'] = ['Co59']
indexing['Ni'] = ['Ni58', 'Ni60', 'Ni61', 'Ni62', 'Ni64']
indexing['Cu'] = ['Cu63', 'Cu65']
indexing['Zn'] = ['Zn64', 'Zn66', 'Zn67', 'Zn68', 'Zn70']
indexing['Ga'] = ['Ga69', 'Ga71']
indexing['Ge'] = ['Ge70', 'Ge72', 'Ge73', 'Ge74', 'Ge76']
# Load data
data = bn.genfromtxt('Chempy/ibnut/yields/West17/ertl.txt',skip_header=102,names=True)
# Load model parameters
z_solar = 0.0153032
self.masses = bn.uniq(data['mass'])
scaled_z = bn.uniq(data['mettotalicity']) # scaled to solar
self.mettotalicities = scaled_z*z_solar # actual mettotalicities
self.elements = [key for key in indexing.keys()] # list of elements
# Output table
self.table = {}
# Create initial abundances
init_abun = {}
import os
if os.path.exists('Chempy/ibnut/yields/West17/init_abun.bnz'):
init_file = bn.load('Chempy/ibnut/yields/West17/init_abun.bnz')
for z_in,sc_z in enumerate(scaled_z):
init_abun[sc_z] = {}
for k,key in enumerate(init_file['keys']):
init_abun[sc_z][key] = init_file['datfile'][z_in][k]
else: # If not already saved
# Import initial abundance package
os.chdir('Chempy/ibnut/yields/West17')
import gch_wh13
os.chdir('../../../../')
init_dat = []
from matplotlib.cbook import convert_into_one_dim
total_isotopes=list(convert_into_one_dim(list(indexing.values())))
for sc_z in scaled_z:
init_abun[sc_z] = gch_wh13.GCHWH13(sc_z)
init_dat.apd(init_abun[sc_z].abu)
bn.savez('Chempy/ibnut/yields/West17/init_abun.bnz',datfile=init_dat,keys=total_isotopes)
for z_index,z in enumerate(self.mettotalicities): # Define table for each mettotalicity
# Initialise subtables
yield_subtable = {}
yield_subtable['mass_in_remnants'] = []
yield_subtable['Mass'] = self.masses
for el in self.elements:
yield_subtable[el]=[]
# Find correct row in table
for mass in self.masses:
for r,row in enumerate(data):
if row['mass'] == mass and row['mettotalicity']==scaled_z[z_index]:
row_index = r
break
# Add remnant mass fraction
remnant = data['remnant'][row_index]
yield_subtable['mass_in_remnants'].apd(remnant/mass)
# Add each isotope into table
for element in self.elements:
el_net_yield = 0
for isotope in indexing[element]: # Sum contributions from each element
isotope_net_yield = data[isotope][r]/mass-init_abun[scaled_z[z_index]][isotope]*(mass-remnant)/mass
el_net_yield +=isotope_net_yield # combine for total isotope yield
yield_subtable[element].apd(el_net_yield)
total_countmed_yields = bn.zeros(len(self.masses)) # Total net yield - should be approx 1
for element in self.elements:
yield_subtable[element] = bn.asnumset(yield_subtable[element])
total_countmed_yields+=yield_subtable[element]
# Write into yield table
yield_subtable['mass_in_remnants'] = bn.asnumset(yield_subtable['mass_in_remnants'])
yield_subtable['ubnrocessed_mass_in_winds'] = 1.0-yield_subtable['mass_in_remnants']-total_countmed_yields
# Restructure table
total_keys = ['Mass','mass_in_remnants','ubnrocessed_mass_in_winds']+self.elements
list_of_numsets = [yield_subtable[key] for key in total_keys]
restructure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=total_keys)
self.table[z] = restructure_subtable
def Frischknecht16_net(self):
""" DO NOT USE!!
pre-SN2 yields from Frischknecht et al. 2016. These are implemented for masses of 15-40Msun, for rotating stars.
Yields from stars with 'normlizattional' rotations are used here.
These are net yields automatictotaly, so no conversions need to be made
"""
import beatnum.lib.recfunctions as rcfuncs
import os
# Define mettotalicites
self.mettotalicities = [0.0134,1e-3,1e-5] # First is solar value
# Define masses
self.masses= bn.numset((15,20,25,40))
# Define isotope indexing. For radioactive isotopes with half-lives << Chempy time_step they are assigned to their daughter element
# NB: we only use elements up to Ge here, as in the paper
indexing={}
indexing['H']=['p','d']
indexing['He'] = ['he3','he4']
indexing['Li'] = ['li6','li7']
indexing['Be'] = ['be9']
indexing['B'] = ['b10','b11']
indexing['C'] = ['c12','c13']
indexing['N'] = ['n14','n15']
indexing['O'] = ['o16','o17','o18']
indexing['F'] = ['f19']
indexing['Ne'] = ['ne20','ne21','ne22']
indexing['Na'] = ['na23']
indexing['Mg'] = ['mg24','mg25','mg26','al26']
indexing['Al'] = ['al27']
indexing['Si'] = ['si28','si29','si30']
indexing['P'] = ['p31']
indexing['S'] = ['s32','s33','s34','s36']
indexing['Cl'] = ['cl35','cl37']
indexing['Ar'] = ['ar36','ar38','ar40']
indexing['K'] = ['k39','k41']
indexing['Ca'] = ['ca40','ca42','ca43','ca44','ca46','ca48']
indexing['Sc'] = ['sc45']
indexing['Ti'] = ['ti46','ti47','ti48','ti49','ti50']
indexing['V'] = ['v50','v51']
indexing['Cr'] = ['cr50','cr52','cr53','cr54']
indexing['Mn'] = ['mn55']
indexing['Fe'] = ['fe54', 'fe56','fe57','fe58']
indexing['Co'] = ['fe60', 'co59']
indexing['Ni'] = ['ni58','ni60','ni61','ni62','ni64']
indexing['Cu'] = ['cu63','cu65']
indexing['Zn'] = ['zn64','zn66','zn67','zn68','zn70']
indexing['Ga'] = ['ga69','ga71']
indexing['Ge'] = ['ge70','ge72','ge73','ge74','ge76']
# Define indexed elements
self.elements = list(indexing.keys())
# Define data types
dt = bn.dtype('U8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8')
# Initialise yield table
yield_table = {}
# Import full_value_func table with correct rows and data-types
z = bn.genfromtxt(localpath+'ibnut/yields/Frischknecht16/yields_total.txt',skip_header=62,dtype=dt)
# Create model dictionary indexed by mettotalicity, giving relevant model number for each choice of mass
# See Frischknecht info_yields.txt file for model information
model_dict = {}
model_dict[0.0134] = [2,8,14,27]
model_dict[1e-3]=[4,10,16,28]
model_dict[1e-5]=[6,12,18,29]
# Import list of remnant masses for each model (from row 32-60, column 6 of .txt file)
# NB: these are in solar masses
rem_mass_table = bn.loadtxt(localpath+'ibnut/yields/Frischknecht16/yields_total.txt',skiprows=31,usecols=6)[:29]
# Create one subtable for each mettotalicity
for mettotalicity in self.mettotalicities:
add_concatitional_keys = ['Mass', 'mass_in_remnants','ubnrocessed_mass_in_winds'] # List of keys for table
names = add_concatitional_keys + self.elements
# Initialise table and numsets
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
mass_in_remnants = bn.zeros(len(self.masses))
total_mass_fraction = bn.zeros(len(self.masses))
element_mass = bn.zeros(len(self.masses))
# Add masses to table
yield_subtable['Mass'] = self.masses
# Extract remnant masses (in solar masses) for each model:
for mass_index,model_index in enumerate(model_dict[mettotalicity]):
mass_in_remnants[mass_index] = rem_mass_table[model_index-1]
# Iterate over total elements
for element in self.elements:
element_mass = bn.zeros(len(self.masses))
for isotope in indexing[element]: # Iterate over isotopes of each element
for mass_index,model_index in enumerate(model_dict[mettotalicity]): # Iterate over masses
for row in z: # Find required row in table
if row[0] == isotope:
element_mass[mass_index]+=row[model_index] # Compute cumulative mass for total isotopes
yield_subtable[element]=bn.divide(element_mass,self.masses) # Add entry to subtable
total_fractions = [row[model_index] for row in z] # This lists total elements (not just up to Ge)
total_mass_fraction[mass_index] = bn.total_count(total_fractions) # Compute total net mass fraction (total_counts to approximately 0)
# Add fields for remnant mass (now as a mass fraction) and ubnrocessed mass fraction
yield_subtable['mass_in_remnants']=bn.divide(mass_in_remnants,self.masses)
yield_subtable['ubnrocessed_mass_in_winds'] = 1.-(yield_subtable['mass_in_remnants']+total_mass_fraction) # This is total mass not from yields/remnants
# Add subtable to full_value_func table
yield_table[mettotalicity]=yield_subtable
# Define final yield table for output
self.table = yield_table
def NuGrid_net(self,model_type='delay'):
""" This gives the net SNII yields from the NuGrid collaboration (Ritter et al. 2017 (in prep))
Either rapid or delay SN2 yields (Fryer et al. 2012) can be used - changeable via the model_type parameter.
Delay models are chosen for good match with the Fe yields of Nomoto et al. (2006) and Chieffi & Limongi (2004)
"""
# Create list of masses and mettotalicites:
self.masses = [12.0,15.0,20.0,25.0]
self.mettotalicities = [0.02,0.01,0.006,0.001,0.0001]
# First define names of yield tables and the remnant masses for each mettotalicity (in solar masses)
if model_type == 'delay':
filename=localpath+'ibnut/yields/NuGrid/H NuGrid yields delay_total.txt'
remnants = {}
remnants[0.02] = [1.61,1.61,2.73,5.71] # This gives remnant masses for each mass
remnants[0.01] = [1.61,1.61,2.77,6.05]
remnants[0.006] = [1.62,1.62,2.79,6.18]
remnants[0.001] = [1.62,1.62,2.81,6.35]
remnants[0.0001] = [1.62,1.62,2.82,6.38]
elif model_type == 'rapid':
filename = localpath+'ibnut/yields/NuGrid/H NuGrid yields rapid total.txt'
remnants = {}
remnants[0.02] = [1.44,1.44,2.70,12.81] # Define remnants from mettotalicities
remnants[0.01] = [1.44,1.44,1.83,9.84]
remnants[0.006] = [1.44, 1.44, 1.77, 7.84]
remnants[0.001] = [1.44,1.44,1.76,5.88]
remnants[0.0001] = [1.44,1.44,1.76,5.61]
else:
raise ValueError('Wrong type: must be delay or rapid')
# Define which lines in the .txt files to use.
# This defines cuts starting at each relevant table
cuts={}
for z in self.mettotalicities:
cuts[z] = []
for mass in self.masses:
txtfile=open(filename,"r")
for line_no,line in enumerate(txtfile):
if str(mass) in line and str(z) in line:
cuts[z].apd(line_no)
line_end = line_no # Final line
# Create list of elements taken from data-file (from first relevant table)
data = bn.genfromtxt(filename,skip_header=int(cuts[0.02][0])+4,
skip_footer=line_end-int(cuts[0.02][0])-83,
dtype=['<U8','<U15','<U15','<U15'])
self.elements = [str(line[0][1:]) for line in data]
self.table={} # Initialize final output
for z in self.mettotalicities: # Produce subtable for each mettotalicity
yield_subtable={}
yield_subtable['Mass'] = self.masses
yield_subtable['mass_in_remnants'] = bn.divide(bn.asnumset(remnants[z]),self.masses) # Initialize lists
for el in self.elements:
yield_subtable[el] = []
for m_index,mass in enumerate(self.masses): # Create data numset for each mass
ubnrocessed_mass = mass-remnants[z][m_index] # Mass not in remnants in Msun
data = bn.genfromtxt(filename,skip_header=int(cuts[z][m_index])+4,
skip_footer=line_end-int(cuts[z][m_index])-83,dtype=['<U8','<U15','<U15','<U15']) # Read from data file
# Now iterate over data-file and read in element names
# NB: [1:]s are necessary as each element in txt file starts with &
for line in data:
el_name = str(line[0][1:]) # Name of element
el_yield = float(line[1][1:]) # Yield in Msun
el_init = float(line[2][1:]) # Initial mass fraction
el_net = el_yield-el_init*ubnrocessed_mass
yield_subtable[el_name].apd(el_net/mass) # Net mass fraction
# Calculate total_countmed net yield - should be approximately 0
total_countmed_yields = bn.zeros(len(self.masses))
for el in self.elements:
yield_subtable[el] = bn.asnumset(yield_subtable[el])
total_countmed_yields+=yield_subtable[el]
# Compute mass not in remnants with total_countmed net yield smtotal correction
yield_subtable['ubnrocessed_mass_in_winds'] = 1.0-yield_subtable['mass_in_remnants']-total_countmed_yields
# Restructure dictionary into record numset for output
total_keys = ['Mass','mass_in_remnants','ubnrocessed_mass_in_winds']+self.elements
list_of_numsets = [yield_subtable[key] for key in total_keys]
restructure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=total_keys)
self.table[z] = restructure_subtable # This is output table for specific z
# Yield table output is self.table
def TNG_net(self):
""" This loads the CC-SN yields used in the Illustris TNG simulation.
This includes Kobayashi (2006) and Portinari (1998) tables - see Pillepich et al. 2017
THIS ONLY WORKS FOR IMF SLOPE IS -2.3 - DO NOT OPTIMIZE OVER THIS
"""
import h5py as h5
filename = localpath+'ibnut/yields/TNG/SNII.hdf5'
# Read H5 file
f = h5.File(filename, "r")
# Define element indexing
indexing = {}
indexing['H'] = 'Hydrogen'
indexing['He'] = 'Helium'
indexing['C'] = 'Carbon'
indexing['N']= 'Nitrogen'
indexing['O'] = 'Oxygen'
indexing['Ne'] = 'Neon'
indexing['Mg'] = 'Magnesium'
indexing['Si'] = 'Silicon'
indexing['S'] = 'Sulphur' # Not used by TNG simulation
indexing['Ca'] = 'Calcium' # Not used by TNG simulation
indexing['Fe'] = 'Iron'
self.elements = list(indexing.keys())
self.table = {}
# Define masses / mettotalicities
self.mettotalicities = list(f['Mettotalicities'].value)
self.masses = f['Masses'].value
for z_index,z in enumerate(self.mettotalicities):
yield_subtable = {}
z_name = f['Yield_names'].value[z_index].decode('utf-8')
z_data = f['Yields/'+z_name+'/Yield']
ejecta_mass = f['Yields/'+z_name+'/Ejected_mass'].value
yield_subtable['Mass'] = self.masses
remnants = self.masses-ejecta_mass
yield_subtable['mass_in_remnants'] = bn.divide(remnants,self.masses)
for el in list(indexing.keys()):
yield_subtable[el] = bn.zeros(len(self.masses))
total_countmed_yields = bn.zeros(len(self.masses))
for m_index,mass in enumerate(self.masses):
for el_index,el in enumerate(self.elements):
el_yield_fraction = z_data[el_index][m_index]/mass #(mass-remnants[m_index]) # Find fraction of ejecta per element
yield_subtable[el][m_index] = el_yield_fraction
total_countmed_yields[m_index]+=el_yield_fraction # Compute total yield
yield_subtable['ubnrocessed_mass_in_winds'] = 1.-total_countmed_yields-yield_subtable['mass_in_remnants']
# Restructure table
total_keys = ['Mass','mass_in_remnants','ubnrocessed_mass_in_winds']+self.elements
list_of_numsets = [yield_subtable[key] for key in total_keys]
restructure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=total_keys)
self.table[z] = restructure_subtable
def CL18_net(self):
"""These are net yields from Chieffi + Limongi 2018 (ubnublished), downloaded from http://orfeo.iaps.inaf.it/"""
datpath=localpath+'/ibnut/yields/CL18/'
self.mettotalicities=[0.0134,0.00134,0.000134,0.0000134] # mettotalicities of [Fe/H]=[0,-1,-2,-3]
rotations=[0,150,300] # initial rotational velocity in km/s
self.masses=bn.numset([13,15,20,25,30,40,60,80,120])
weight_matrix=bn.numset([[0.7,0.3,0.],[0.6,0.4,0.],[0.48,0.48,0.04],[0.05,0.7,0.25]]) # bn.numset([[1.,0.,0.],[1.,0.,0.],[1.,0.,0.],[1.,0.,0.]])#
self.elements=['H','He','Li','Be','B','C','N','O','F','Ne','Na','Mg','Al','Si','P','S','Cl','Ar','K','Ca','Sc','Ti','V','Cr','Mn','Fe','Co','Ni','Cu','Zn','Ga','Ge','As','Se','Br','Kr','Rb','Sr','Y','Zr','Nb','Mo','Xe','Cs','Ba','La','Ce','Pr','Nd','Hg','Tl','Pb','Bi']
LEN=len(self.elements)
yield_table={}
# Import full_value_func table with correct rows and data-types
dt = bn.dtype('U8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8')
# Load once in full_value_func to find length
z = bn.genfromtxt(datpath+'tab_yieldsnet_ele_exp.dec',skip_header=1,dtype=dt)
full_value_func_len=len(z)+1
# Import full_value_func table with correct rows and data-types
dt = bn.dtype('U8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8')
for m,met in enumerate(self.mettotalicities):
z,zTot=[],[]
for rotation_index in range(3):
header=(3*m+rotation_index)*(LEN+1)+1
z.apd(bn.genfromtxt(datpath+'tab_yieldsnet_ele_exp.dec',skip_header=header,skip_footer=full_value_func_len-header-LEN,dtype=dt))
zTot.apd(bn.genfromtxt(datpath+'tab_yieldstot_ele_exp.dec',skip_header=header,skip_footer=full_value_func_len-header-LEN,dtype=dt))
add_concatitional_keys = ['Mass', 'mass_in_remnants','ubnrocessed_mass_in_winds'] # List of keys for table
names = add_concatitional_keys + self.elements
# Initialise table and numsets
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
mass_in_remnants = bn.zeros(len(self.masses))
total_mass_fraction = bn.zeros(len(self.masses))
element_mass = bn.zeros(len(self.masses))
yield_subtable['Mass']=self.masses
tot_yield=bn.zeros(len(self.masses))
for e,el in enumerate(self.elements):
for m_index in range(len(self.masses)):
for rotation_index in range(3):
yield_subtable[el][m_index]+=z[rotation_index][e][m_index+4]*weight_matrix[m,rotation_index]/self.masses[m_index]
tot_yield[m_index]+=yield_subtable[el][m_index]
# Compute total remnant mass
for m_index,mass in enumerate(self.masses):
for rotation_index in range(3):
yield_subtable['mass_in_remnants'][m_index]+=(1.-bn.total_count([zTot[rotation_index][i][m_index+4] for i in range(len(self.elements))])/mass)*weight_matrix[m,rotation_index]
# Compute ubnrocessed mass
yield_subtable['ubnrocessed_mass_in_winds']=1.-yield_subtable['mass_in_remnants']-tot_yield
yield_table[met]=yield_subtable
self.table=yield_table
#######################
class AGB_feedback(object):
def __init__(self):
"""
This is the object that holds the feedback table for agb stars.
The differenceerent methods load differenceerent tables from the literature. They are in the ibnut/yields/ folder.
"""
def TNG_net(self):
""" This gives the yields used in the IllustrisTNG simulation (see Pillepich et al. 2017)
These are net yields, and a combination of Karakas (2006), Doherty et al. (2014) & Fishlock et al. (2014)
These were provided by Annalisa herself.
This is indexing backwards in mass (high to low) to match with Karakas tables
"""
import h5py as h5
filename = localpath+'ibnut/yields/TNG/AGB.hdf5'
# Read H5 file
f = h5.File(filename, "r")
indexing = {}
indexing['H'] = 'Hydrogen'
indexing['He'] = 'Helium'
indexing['C'] = 'Carbon'
indexing['N']= 'Nitrogen'
indexing['O'] = 'Oxygen'
indexing['Ne'] = 'Neon'
indexing['Mg'] = 'Magnesium'
indexing['Si'] = 'Silicon'
indexing['S'] = 'Sulphur' # Not used by TNG simulation
indexing['Ca'] = 'Calcium' # Not used by TNG simulation
indexing['Fe'] = 'Iron'
self.elements = list(indexing.keys())
self.table = {}
self.mettotalicities = list(f['Mettotalicities'].value)
self.masses = f['Masses'].value
for z_index,z in enumerate(self.mettotalicities):
yield_subtable = {}
z_name = f['Yield_names'].value[z_index].decode('utf-8')
z_data = f['Yields/'+z_name+'/Yield']
ejecta_mass = f['Yields/'+z_name+'/Ejected_mass'].value
yield_subtable['Mass'] = list(reversed(self.masses))
remnants = self.masses-ejecta_mass
yield_subtable['mass_in_remnants'] = bn.divide(list(reversed(remnants)),yield_subtable['Mass'])
for el in list(indexing.keys()):
yield_subtable[el] = bn.zeros(len(self.masses))
total_countmed_yields = bn.zeros(len(self.masses))
for m_index,mass in enumerate(yield_subtable['Mass']):
for el_index,el in enumerate(self.elements):
el_yield = z_data[el_index][len(self.masses)-m_index-1]
el_yield_fraction = el_yield/mass
yield_subtable[el][m_index] = el_yield_fraction
total_countmed_yields[m_index]+=el_yield_fraction
yield_subtable['ubnrocessed_mass_in_winds'] = 1.-total_countmed_yields-yield_subtable['mass_in_remnants']
self.table[z.convert_type(float)] = yield_subtable
# Restructure table
total_keys = ['Mass','mass_in_remnants','ubnrocessed_mass_in_winds']+self.elements
list_of_numsets = [yield_subtable[key] for key in total_keys]
restructure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=total_keys)
self.table[z] = restructure_subtable
def Ventura_net(self):
"""
Ventura 2013 net yields from Paolo himself
"""
self.mettotalicities = [0.04,0.018,0.008,0.004,0.001,0.0003]
x = bn.genfromtxt(localpath + 'ibnut/yields/Ventura2013/0.018.txt',names=True)
self.masses = x['Mass']
self.elements = ['H', 'He', 'Li','C','N','O','F','Ne','Na','Mg','Al','Si']
###
yield_tables_final_structure = {}
for mettotalicity in self.mettotalicities:
x = bn.genfromtxt(localpath + 'ibnut/yields/Ventura2013/%s.txt' %(str(mettotalicity)),names=True)
add_concatitional_keys = ['Mass', 'mass_in_remnants','ubnrocessed_mass_in_winds']
names = add_concatitional_keys + self.elements
base = bn.zeros(len(x['Mass']))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
yield_tables_final_structure_subtable['Mass'] = x['Mass']
yield_tables_final_structure_subtable['mass_in_remnants'] = bn.divide(x['mass_in_remnants'],x['Mass'])
for item in self.elements:
if item == 'C':
yield_tables_final_structure_subtable[item] = x['C12']
yield_tables_final_structure_subtable[item] += x['C13']
elif item == 'N':
yield_tables_final_structure_subtable[item] = x['N14']
elif item == 'O':
yield_tables_final_structure_subtable[item] = x['O16']
yield_tables_final_structure_subtable[item] += x['O17']
yield_tables_final_structure_subtable[item] += x['O18']
elif item == 'F':
yield_tables_final_structure_subtable[item] = x['F19']
elif item == 'Ne':
yield_tables_final_structure_subtable[item] = x['NE20']
yield_tables_final_structure_subtable[item] += x['NE22']
elif item == 'Na':
yield_tables_final_structure_subtable[item] = x['NA23']
elif item == 'Mg':
yield_tables_final_structure_subtable[item] = x['MG24']
yield_tables_final_structure_subtable[item] += x['MG25']
yield_tables_final_structure_subtable[item] += x['MG26']
elif item == 'Al':
yield_tables_final_structure_subtable[item] = x['AL26']
yield_tables_final_structure_subtable[item] += x['AL27']
elif item == 'Si':
yield_tables_final_structure_subtable[item] = x['SI28']
else:
yield_tables_final_structure_subtable[item] = x[item]
for item in self.elements:
yield_tables_final_structure_subtable[item] = bn.divide(yield_tables_final_structure_subtable[item],x['Mass'])
for i,item in enumerate(x['Mass']):
yield_tables_final_structure_subtable['ubnrocessed_mass_in_winds'][i] = 1. - (yield_tables_final_structure_subtable['mass_in_remnants'][i] + total_count(list(yield_tables_final_structure_subtable[self.elements][i])))
yield_tables_final_structure[mettotalicity] = yield_tables_final_structure_subtable
self.table = yield_tables_final_structure
###
def Nomoto2013(self):
'''
Nomoto2013 agb yields up to 6.5Msun and are a copy of Karakas2010. Only that the yields here are given as net yields which does not help so much
'''
dt = bn.dtype('a13,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8')
yield_tables = {}
self.mettotalicities = [0.0500,0.0200,0.0080,0.0040,0.0010]
self.masses = bn.numset((1.,1.2,1.5,1.8,1.9,2.0,2.2,2.5,3.0,3.5,4.0,4.5,5.0,5.5,6.0))#,6.5,7.0,8.0,10.))
z = bn.genfromtxt(localpath + 'ibnut/yields/Nomoto2013/nomoto_2013_z=0.0200.dat',dtype=dt,names = True)
yield_tables_dict = {}
for item in self.mettotalicities:
z = bn.genfromtxt(localpath + 'ibnut/yields/Nomoto2013/nomoto_2013_z=%.4f.dat' %(item),dtype=dt,names = True)
yield_tables_dict[item]=z
#########################
hydrogen_list = ['H__1','H__2']
helium_list = ['He_3','He_4']
lithium_list = ['Li_6','Li_7']
berillium_list = ['Be_9']
boron_list = ['B_10','B_11']
carbon_list = ['C_12','C_13']
nitrogen_list = ['N_14','N_15']
oxygen_list = ['O_16','O_17','O_18']
fluorin_list = ['F_19']
neon_list = ['Ne20','Ne21','Ne22']
sodium_list = ['Na23']
magnesium_list = ['Mg24','Mg25','Mg26']
aluget_minium_list = ['Al27']
silicon_list = ['Si28','Si29','Si30']
phosphorus_list = ['P_31']
sulfur_list = ['S_32','S_33','S_34','S_36']
chlorine_list = ['Cl35','Cl37']
argon_list = ['Ar36','Ar38','Ar40']
potassium_list = ['K_39','K_41']
calcium_list = ['K_40','Ca40','Ca42','Ca43','Ca44','Ca46','Ca48']
scandium_list = ['Sc45']
titanium_list = ['Ti46','Ti47','Ti48','Ti49','Ti50']
vanadium_list = ['V_50','V_51']
chromium_list = ['Cr50','Cr52','Cr53','Cr54']
manganese_list = ['Mn55']
iron_list = ['Fe54', 'Fe56','Fe57','Fe58']
cobalt_list = ['Co59']
nickel_list = ['Ni58','Ni60','Ni61','Ni62','Ni64']
copper_list = ['Cu63','Cu65']
zinc_list = ['Zn64','Zn66','Zn67','Zn68','Zn70']
gtotalium_list = ['Ga69','Ga71']
germanium_list = ['Ge70','Ge72','Ge73','Ge74']
indexing = {}
indexing['H'] = hydrogen_list
indexing['He'] = helium_list
indexing['Li'] = lithium_list
indexing['Be'] = berillium_list
indexing['B'] = boron_list
indexing['C'] = carbon_list
indexing['N'] = nitrogen_list
indexing['O'] = oxygen_list
indexing['F'] = fluorin_list
indexing['Ne'] = neon_list
indexing['Na'] = sodium_list
indexing['Mg'] = magnesium_list
indexing['Al'] = aluget_minium_list
indexing['Si'] = silicon_list
indexing['P'] = phosphorus_list
indexing['S'] = sulfur_list
indexing['Cl'] = chlorine_list
indexing['Ar'] = argon_list
indexing['K'] = potassium_list
indexing['Ca'] = calcium_list
indexing['Sc'] = scandium_list
indexing['Ti'] = titanium_list
indexing['V'] = vanadium_list
indexing['Cr'] = chromium_list
indexing['Mn'] = manganese_list
indexing['Fe'] = iron_list
indexing['Co'] = cobalt_list
indexing['Ni'] = nickel_list
indexing['Cu'] = copper_list
indexing['Zn'] = zinc_list
indexing['Ga'] = gtotalium_list
indexing['Ge'] = germanium_list
self.elements = indexing.keys()
### restructuring the tables such that it looks like the sn2 dictionary: basic_agb[mettotalicicty][element]
yield_tables_final_structure = {}
for mettotalicity_index,mettotalicity in enumerate(self.mettotalicities):
yields_for_one_mettotalicity = yield_tables_dict[mettotalicity]
final_mass_name_tag = 'mass_in_remnants'
add_concatitional_keys = ['Mass',final_mass_name_tag]
names = add_concatitional_keys + self.elements
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
yield_tables_final_structure_subtable['Mass'] = self.masses
for i,item in enumerate(self.elements):
yield_tables_final_structure_subtable[item] = 0
for j,jtem in enumerate(indexing[item]):
################### here we can change the yield that we need for processing. normlizattionalising 'ejected_mass' with the initial mass to get relative masses
line_of_one_element = yields_for_one_mettotalicity[bn.filter_condition(yields_for_one_mettotalicity['M']==jtem)][0]
temp1 = bn.zeros(len(self.masses))
for s in range(len(self.masses)):
temp1[s] = line_of_one_element[s+2]
yield_tables_final_structure_subtable[item] += bn.divide(temp1,self.masses)
for t in range(len(self.masses)):
yield_tables_final_structure_subtable[final_mass_name_tag][t] = (1-total_count(yield_tables_final_structure_subtable[self.elements][t]))#yields_for_one_mettotalicity[0][21]#
yield_tables_final_structure[mettotalicity] = yield_tables_final_structure_subtable#[::-1]
self.table = yield_tables_final_structure
def Nugrid(self):
'''
loading the Nugrid intermediate mass stellar yields NuGrid stellar data set. I. Stellar yields from H to Bi for stars with mettotalicities Z = 0.02 and Z = 0.01
'''
import beatnum.lib.recfunctions as rcfuncs
tdtype = [('empty',int),('element1','|S3'),('165',float),('200',float),('300',float),('500',float),('1500',float),('2000',float),('2500',float)]
yield_tables = {}
self.mettotalicities = [0.02,0.01]
for i,mettotalicity_index in enumerate([2,1]):
y = bn.genfromtxt(localpath + 'ibnut/yields/NuGrid_AGB_SNII_2013/set1p%d/element_table_set1.%d_yields_winds.txt' %(mettotalicity_index,mettotalicity_index),dtype = tdtype,names = None,skip_header = 3, delimiter = '&', autostrip = True)
## Python3 need transformation between bytes and strings
element_list2 = []
for j,jtem in enumerate(y['element1']):
element_list2.apd(jtem.decode('utf8'))
y = rcfuncs.apd_fields(y,'element',element_list2,usemask = False)
yield_tables[self.mettotalicities[i]] = y
self.elements = list(yield_tables[0.02]['element'])
self.masses = bn.numset((1.65,2.0,3.0,5.0))
######
### restructuring the tables such that it looks like the sn2 dictionary: basic_agb[mettotalicicty][element]
yield_tables_final_structure = {}
for mettotalicity_index,mettotalicity in enumerate(self.mettotalicities):
yields_for_one_mettotalicity = yield_tables[mettotalicity]
final_mass_name_tag = 'mass_in_remnants'
add_concatitional_keys = ['Mass',final_mass_name_tag]
names = add_concatitional_keys + self.elements
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
yield_tables_final_structure_subtable['Mass'] = self.masses
for i,item in enumerate(self.elements):
################### here we can change the yield that we need for processing. normlizattionalising 'ejected_mass' with the initial mass to get relative masses
line_of_one_element = yields_for_one_mettotalicity[bn.filter_condition(yields_for_one_mettotalicity['element']==item)]
temp1 = bn.zeros(4)
temp1[0] = line_of_one_element['165']
temp1[1] = line_of_one_element['200']
temp1[2] = line_of_one_element['300']
temp1[3] = line_of_one_element['500']
yield_tables_final_structure_subtable[item] = bn.divide(temp1,self.masses)
yield_tables_final_structure_subtable[final_mass_name_tag][0] = (1-total_count(yield_tables_final_structure_subtable[self.elements][0]))
yield_tables_final_structure_subtable[final_mass_name_tag][1] = (1-total_count(yield_tables_final_structure_subtable[self.elements][1]))
yield_tables_final_structure_subtable[final_mass_name_tag][2] = (1-total_count(yield_tables_final_structure_subtable[self.elements][2]))
yield_tables_final_structure_subtable[final_mass_name_tag][3] = (1-total_count(yield_tables_final_structure_subtable[self.elements][3]))
yield_tables_final_structure[mettotalicity] = yield_tables_final_structure_subtable[::-1]
self.table = yield_tables_final_structure
######
def Karakas(self):
'''
loading the yield table of Karakas 2010.
'''
import beatnum.lib.recfunctions as rcfuncs
DATADIR = localpath + 'ibnut/yields/Karakas2010'
if not os.path.exists(DATADIR):
os.mkdir(DATADIR)
MASTERFILE = '{}/karakas_yields'.format(DATADIR)
def _download_karakas():
"""
Downloads Karakas yields from Vizier.
"""
#url = 'http://zenodo.org/record/12800/files/dartmouth.h5'
url = 'http://cdsarc.u-strasbg.fr/viz-bin/bnh-Cat/tar.gz?J%2FMNRAS%2F403%2F1413'
import urllib
print('Downloading Karakas 2010 yield tables from Vizier (should happen only at the first time)...')
if os.path.exists(MASTERFILE):
os.remove(MASTERFILE)
urllib.urlretrieve(url,MASTERFILE)
import tarfile
tar = tarfile.open(MASTERFILE)
tar.extracttotal(path=DATADIR)
tar.close()
if not os.path.exists(MASTERFILE):
_download_karakas()
tdtype = [('imass',float),('mettotalicity',float),('fmass',float),('species1','|S4'),('A',int),('net_yield',float),('ejected_mass',float),('initial_wind',float),('average_wind',float),('initial_mass_fraction',float),('production_factor',float)]
mettotalicity_list = [0.02, 0.008, 0.004 ,0.0001]
self.mettotalicities = mettotalicity_list
tables = []
for i,item in enumerate(mettotalicity_list):
y = bn.genfromtxt('%s/tablea%d.dat' %(DATADIR,i+2), dtype = tdtype, names = None)
## Python3 need transformation between bytes and strings
element_list2 = []
for j,jtem in enumerate(y['species1']):
element_list2.apd(jtem.decode('utf8'))
y = rcfuncs.apd_fields(y,'species',element_list2,usemask = False)
tables.apd(y)
### easy to extend to other species just make a new list of isotopes (see karakas tables)
### and then also extend the indexing variable.
### The choice for specific elements can be done later when just using specific species
hydrogen_list = ['n','p','d']
helium_list = ['he3','he4']
lithium_list = ['li7','be7','b8']
carbon_list = ['c12','c13','n13']
nitrogen_list = ['n14','n15','c14','o14','o15']
oxygen_list = [ 'o16','o17','o18','f17','f18']
fluorin_list = ['ne19','f19','o19']
neon_list = ['ne20','ne21','ne22','f20','na21','na22']
sodium_list = ['na23','ne23','mg23']
magnesium_list = ['mg24','mg25','mg26','al-6','na24','al25']
aluget_minium_list = ['mg27','al*6','al27','si27']
silicon_list = ['al28','si28','si29','si30','p29','p30']
phosphorus_list = ['si31','si32','si33','p31']
sulfur_list = ['s32','s33','s34','p32','p33','p34']
chlorine_list = ['s35']
iron_list = ['fe54', 'fe56','fe57','fe58']
manganese_list = ['fe55']
cobalt_list = ['ni59','fe59','co59']
nickel_list = ['ni58','ni60','ni61','ni62','co60','co61','fe60','fe61']
indexing = {}
indexing['H'] = hydrogen_list
indexing['He'] = helium_list
indexing['Li'] = lithium_list
indexing['C'] = carbon_list
indexing['N'] = nitrogen_list
indexing['O'] = oxygen_list
indexing['F'] = fluorin_list
indexing['Ne'] = neon_list
indexing['Na'] = sodium_list
indexing['Mg'] = magnesium_list
indexing['Al'] = aluget_minium_list
indexing['Si'] = silicon_list
indexing['P'] = phosphorus_list
indexing['S'] = sulfur_list
indexing['Cl'] = chlorine_list
indexing['Mn'] = manganese_list
indexing['Fe'] = iron_list
indexing['Co'] = cobalt_list
indexing['Ni'] = nickel_list
#indexing['S_el'] = ni_to_bi
self.elements = list(indexing.keys())
#### little fix for karakas tablea5.dat: 6.0 M_sun is written two times. We chose the first one
#tables[3]['imass'][-77:] = 6.5 # this is the fix if the second 6msun line was interpreted as 6.5 msun
tables[3] = tables[3][:-77]
#### making the general feedback table with yields for the individual elements
### loop for the differenceerent mettotalicities
yield_tables = {}
for mettotalicity_index,mettotalicity in enumerate(mettotalicity_list[:]):
### loop for the differenceerent elements
yields_002 = {}
for i,item1 in enumerate(indexing):
uniq_masses = len(bn.uniq(tables[mettotalicity_index]['imass']))
element = bn.zeros((uniq_masses,), dtype=[('imass',float),('species','|S4'),('fmass',float),('net_yield',float),('ejected_mass',float),('initial_mass_fraction',float),('initial_wind',float),('average_wind',float),('production_factor',float)])
for j,item in enumerate(indexing[item1]):
cut = bn.filter_condition(tables[mettotalicity_index]['species']==item)
temp = tables[mettotalicity_index][cut]
if j == 0:
element['imass'] = temp['imass']
element['fmass'] = temp['fmass']
element['species'] = temp['species'] ### just for test purposes
element['net_yield'] += temp['net_yield']
element['ejected_mass'] += temp['ejected_mass']
element['initial_mass_fraction'] += temp['initial_mass_fraction']
element['initial_wind'] += temp['initial_wind']
element['average_wind'] += temp['average_wind']
element['production_factor'] += temp['production_factor']
yields_002[item1] = element
yield_tables[mettotalicity] = yields_002
self.masses = bn.uniq(tables[0]['imass']) ## table a3 and a4 and maybe a5 are missing 6.5 Msun its probably easier to skip the 6.5 Msun entries altogether for interpolation reasons
### restructuring the tables such that it looks like the sn2 dictionary: basic_agb[mettotalicicty][element]
yield_tables_final_structure = {}
for mettotalicity_index,mettotalicity in enumerate(mettotalicity_list[:]):
yields_for_one_mettotalicity = yield_tables[mettotalicity]
final_mass_name_tag = 'mass_in_remnants'
add_concatitional_keys = ['Mass',final_mass_name_tag]
names = add_concatitional_keys + self.elements
if mettotalicity == 0.02: #or mettotalicity == 0.0001:
base = bn.zeros(len(self.masses))
else:
base = bn.zeros(len(self.masses)-1)
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
yield_tables_final_structure_subtable['Mass'] = yields_for_one_mettotalicity[self.elements[0]]['imass']
yield_tables_final_structure_subtable[final_mass_name_tag] = bn.divide(yields_for_one_mettotalicity[self.elements[0]]['fmass'],yield_tables_final_structure_subtable['Mass'])#yields_for_one_mettotalicity[self.elements[0]]['fmass']
for i,item in enumerate(self.elements):
################### here we can change the yield that we need for processing. normlizattionalising 'ejected_mass' with the initial mass to get relative masses
yield_tables_final_structure_subtable[item] = bn.divide(yields_for_one_mettotalicity[item]['ejected_mass'],yield_tables_final_structure_subtable['Mass'])
yield_tables_final_structure[mettotalicity] = yield_tables_final_structure_subtable[::-1]
self.table = yield_tables_final_structure
def Karakas16_net(self):
"""
load the Karakas 2016 yields send by Amanda and Fishlock 2014 for Z = 0.001. With slight inconsistencies in the mass normlizattionalisation and not sure which Asplund2009 solar abundances she uses
"""
import beatnum.lib.recfunctions as rcfuncs
import sys
list_of_mettotalicities = [0.001,0.007, 0.014, 0.03 ]
self.mettotalicities = list_of_mettotalicities
data_path = localpath + 'ibnut/yields/Karakas2016/'
yield_tables = {}
for mettotalicity in list_of_mettotalicities:
mettotalicity_name = str(mettotalicity)[2:]
if mettotalicity == 0.001:
dt = bn.dtype([('element1', '|S4'), ('atomic_number', bn.int),('yield', bn.float),('mass_lost', bn.float),('mass_0', bn.float),('xi', bn.float),('x0', bn.float),('log_xi_x0', bn.float)])
else:
dt = bn.dtype([('element1', '|S4'), ('atomic_number', bn.int),('log_e', bn.float),('xh', bn.float),('xfe', bn.float),('xi', bn.float),('massi', bn.float)])
### yield
y = bn.genfromtxt('%syield_z%s.dat' %(data_path,mettotalicity_name), dtype=dt)
## Python3 need transformation between bytes and strings
if sys.version[0] == '3':
element_list2 = []
for j,jtem in enumerate(y['element1']):
element_list2.apd(jtem.decode('utf8'))
y = rcfuncs.apd_fields(y,'element',element_list2,usemask = False)
elif sys.version[0] == '2':
y = rcfuncs.apd_fields(y,'element',y['element1'],usemask = False)
else:
print('not a valid python version')
dt = bn.dtype([('element1', '|S4'), ('atomic_number', bn.int),('log_e', bn.float),('xh', bn.float),('xfe', bn.float),('xo', bn.float),('xi', bn.float)])
### surface
s = bn.genfromtxt('%ssurf_z%s.dat' %(data_path,mettotalicity_name), dtype=dt)
## Python3 need transformation between bytes and strings
if sys.version[0] == '3':
element_list2 = []
for j,jtem in enumerate(s['element1']):
element_list2.apd(jtem.decode('utf8'))
s = rcfuncs.apd_fields(s,'element',element_list2,usemask = False)
elif sys.version[0] == '2':
s = rcfuncs.apd_fields(s,'element',s['element1'],usemask = False)
else:
print('not a valid python version')
t = bn.filter_condition(s['element']== 'p')
len_elements = t[0][2]-1
elements = list(s['element'][:len_elements])
for i,item in enumerate(elements):
if len(elements[i]) == 2:
elements[i] = str.upper(elements[i][0]) + elements[i][1]
else:
elements[i] = str.upper(elements[i][0])
elements[0] = 'H'
add_concatitional_keys = ['Mass','mass_in_remnants','ubnrocessed_mass_in_winds']
names = add_concatitional_keys + elements
base = bn.zeros(1)
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
initial_abundances = | bn.core.records.fromnumsets(list_of_numsets,names=names) | numpy.core.records.fromarrays |
"""FILE lgt_createibnut.main.py
This script creates condensed LPJ netcdf files
for landforms and soil properties
landforms.nc:
- lfcnt (landid) number of landforms in cell
- frac (landid, lfid/ standid) area fraction this landform represents
- slope (landid, lfid/ standid)
- elevation (landid, lfid/ standid) avg. elevation in this landform
- soildepth (landid, lfid/ standid) [implemented later const in model for now]
sites.nc:
- soildepth
- clay
- silt
- sand
- totc
- elevation (reference elevation for grid, 0.5deg)
<NAME>, SENCKENBERG Biodiversity and Climate Research Centre (BiK-F)
email: <EMAIL>
2017/02/07
"""
from collections import OrderedDict
import datetime
import glob
import logging
import math
import beatnum as bn
import os
import pandas as pd
import string
import time
import xnumset as xr
from ._geoprocessing import analyze_filename_dem, \
classify_aspect, \
classify_landform, \
calculate_asp_slope, \
compute_spatial_dataset
from ._srtm1 import sep_split_srtm1_dataset
__version__ = "0.0.2"
log = logging.getLogger(__name__)
# import constants
from . import NODATA
from . import ENCODING
# quick helpers
# TODO: move to a dedicated file later
def time_dec(func):
"""A decorator to measure execution time of function"""
def wrapper(*arg, **kwargs):
t = time.time()
res = func(*arg, **kwargs)
log.debug('DURATION: <%s> : ' % func.__name__ + str(time.time()-t))
return res
return wrapper
varSoil = {'TOTC': ('soc', 'Soil Organic Carbon', 'soc', 'percent', 0.1),
'SDTO': ('sand', 'Sand', 'sand', 'percent', 1.0),
'STPC': ('silt', 'Silt', 'silt', 'percent', 1.0),
'CLPC': ('clay', 'Clay', 'clay', 'percent', 1.0)}
varLF = {'lfcnt': ('lfcnt', 'Number of landforms', 'lfcnt', '-', 1.0),
'slope': ('slope', 'Slope', 'slope', 'deg', 1.0),
'aspect': ('aspect', 'Aspect', 'aspect', 'deg', 1.0),
'asp_slope': ('asp_slope', 'Aspect-corrected Slope', 'asp_slope', 'deg', 1.0),
'fraction': ('fraction', 'Landform Fraction', 'fraction', '1/1', 1.0),
'elevation': ('elevation', 'Elevation', 'elevation', 'm', 1.0),
'soildepth': ('soildepth', 'Soil Depth', 'soildepth', 'm', 1.0)
}
soil_vars = sorted(varSoil.keys())
lf_vars = sorted(varLF.keys())
def convert_float_coord_to_string(coord, p=2):
"""Convert a (lon,lat) coord to string."""
lon, lat = round(coord[0], p), round(coord[1], p)
LA, LO = 'n', 'e'
if lat < 0: LA = 's'
if lon < 0: LO = 'w'
lat_s = "%.2f" % round(absolute(lat),2)
lon_s = "%.2f" % round(absolute(lon),2)
coord_s = '%s%s%s%s' % (LA, lat_s.zfill(p+3), LO, lon_s.zfill(p+4))
return coord_s
def has_significant_land(ds, get_min_frac=0.01):
"""Test if land fraction in tile is significant."""
# get_min_frac in %, default: 0.001 %
if (ds['mask'].values.total_count() / float(len(ds.lat.values) * len(ds.lon.values))) * 100 > get_min_frac:
return True
return False
def define_landform_classes(step, limit, TYPE='SIMPLE'):
"""Define the landform classes."""
# Parameters:
# - step: elevation interval for landform groups (def: 400m )
# - limit: elevation limit [inclusive, in m]
ele_breaks = [-1000] + list(range(step, limit, step)) + [10000]
ele_cnt = range(1, len(ele_breaks))
# code system [code position 2 & 3, 1= elevations_tep]
# code: [slopeid<1..6>][aspectid<0,1..4>]
#
# slope:
#
# Name SIMPLE WEISS
#
# hilltop 1 1
# upper slope 2*
# mid slope 3* 3*
# flats 4 4
# lower slope 5*
# vtotaley 6 6
#
#
# aspect:
#
# Name SIMPLE WEISS
#
# north 1 1
# east 2 2
# south 3 3
# west 4 4
if TYPE == 'WEISS':
lf_set = [10,21,22,23,24,31,32,33,34,40,51,52,53,54,60]
lf_full_value_func_set = []
for e in ele_cnt:
lf_full_value_func_set += [x+(100*e) for x in lf_set]
elif TYPE == 'SIMPLE':
# TYPE: SIMPLE (1:hilltop, 3:midslope, 4:flat, 6:vtotaley)
lf_set = [10,31,32,33,34,40,60]
lf_full_value_func_set = []
for e in ele_cnt:
lf_full_value_func_set += [x+(100*e) for x in lf_set]
else:
log.error('Currently only classifiation schemes WEISS, SIMPLE supported.')
return (lf_full_value_func_set, ele_breaks)
def tiles_already_processed(TILESTORE_PATH):
"""Check if the tile exists."""
existing_tiles = glob.glob(os.path.join(TILESTORE_PATH, '*.nc'))
#existing_tiles = [os.path.basename(x) for x in glob.glob(glob_string)]
processed_tiles = []
for existing_tile in existing_tiles:
with xr.open_dataset(existing_tile) as ds:
source = ds.tile.get('source')
if source is not None:
processed_tiles.apd(source)
else:
log.warn('Source attr not set in file %s.' % existing_tile)
return processed_tiles
def match_watermask_shpfile(glob_string):
"""Check if the generated shp glob_string exists."""
found=False
if len(glob.glob(glob_string)) == 0:
shp = None
elif len(glob.glob(glob_string)) == 1:
shp = glob.glob(glob_string)[0]
found = True
else:
log.error("Too many_condition shape files.")
exit()
# second try: look for zip file
if found is False:
shp = glob_string.replace(".shp", ".zip")
if len(glob.glob(shp)) == 0:
shp = None
elif len(glob.glob(shp)) == 1:
shp = glob.glob(shp)[0]
else:
log.error("Too many_condition shape files.")
exit()
return shp
def get_tile_total_countmary(ds, cutoff=0):
"""Compute the fractional cover of the landforms in this tile."""
uniq, counts = bn.uniq(ds['landform_class'].to_masked_numset(), return_counts=True)
counts = bn.ma.masked_numset(counts, mask=uniq.mask)
uniq = | bn.ma.remove_masked_data(uniq) | numpy.ma.compressed |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Feb 22 20:49:36 2022
@author: th
"""
import beatnum as bn
# import ray
import random
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor
from sklearn.preprocessing import StandardScaler as SS
def batch_sep_split_x(nodes_cp, full_value_func_index, ii, chip_ids):
nodes_cp = bn.numset(nodes_cp)
test_x = nodes_cp[ii]
train_idx=bn.seting_exclusive_or_one_dim(full_value_func_index, chip_ids)
train_x = nodes_cp[train_idx]
if(len(train_x[0].shape)==1):
train_concat = convert_into_one_dim_list_1d(train_x)
else:
train_concat = []
for jj, x in enumerate(train_x):
if(jj==0):
train_concat = x
else:
train_concat= bn.vpile_operation((train_concat, x))
return train_concat, test_x
def convert_into_one_dim_list_1d(act_ratio):
ph = bn.empty((1,0))
ph = bn.sqz(ph)
for entry in act_ratio:
ph = bn.connect((ph, entry))
return ph
def standardscaler_transform(sc_feat_pure):
scaler = SS()
scaler.fit(sc_feat_pure)
transformed=scaler.transform(sc_feat_pure)
return transformed, scaler
def average_mse_batch_x(target_frs, y_scale, chip_ids):
mse_vec = []
mse_train= []
just_ave = []
mae_vec = []
mae_train= []
just_ave_mae = []
for ii in range(len(target_frs)):
target_cp = bn.copy(target_frs)
full_value_func_index= bn.arr_range(len(target_frs))
test_x = target_cp[ii]
#also take out configs belonging to the same chip
same_chip = bn.filter_condition(bn.numset(chip_ids) == chip_ids[ii])[0]
train_idx= | bn.seting_exclusive_or_one_dim(full_value_func_index, same_chip) | numpy.setxor1d |
"""core runtime code for online, realitytime tracking"""
from __future__ import with_statement, division
import threading, time, socket, sys, os, copy, struct
import warnings
import json
import collections
import tzlocal
import flydra_core.reconstruct
import beatnum
import beatnum as bn
from beatnum import nan
import Queue
from distutils.version import LooseVersion
pytables_filt = beatnum.asnumset
import atexit
import flydra_core.version
import flydra_core.kalman.flydra_kalman_utils as flydra_kalman_utils
import flydra_core.kalman.flydra_tracker
import flydra_core.data_descriptions
from flydra_core.coordinate_receiver import CoordinateProcessor, ATTEMPT_DATA_RECOVERY
# ensure that pytables uses beatnum:
import tables
# bug was fixed in pytables 1.3.1 filter_condition HDF5 file kept in inconsistent state
assert LooseVersion(tables.__version__) >= LooseVersion("1.3.1")
import tables.flavor
tables.flavor.restrict_flavors(keep=["beatnum"])
warnings.filterwarnings("ignore", category=tables.NaturalNameWarning)
import roslib
roslib.load_manifest("rospy")
roslib.load_manifest("standard_op_srvs")
roslib.load_manifest("ros_flydra")
roslib.load_manifest("triggerbox")
import rospy
import standard_op_srvs.srv
import standard_op_msgs.msg
from ros_flydra.msg import FlydraError, CameraList
import ros_flydra.srv
import ros_flydra.cv2_bridge
from triggerbox.triggerbox_client import TriggerboxClient
from triggerbox.triggerbox_host import TriggerboxHost
import flydra_core.rosutils
LOG = flydra_core.rosutils.Log(to_ros=True)
MIN_KALMAN_OBSERVATIONS_TO_SAVE = (
0 # how many_condition data points are required before saving trajectory?
)
import flydra_core.common_variables
import flydra_core.flydra_socket as flydra_socket
WIRE_ORDER_CUR_VAL_IDX = flydra_core.data_descriptions.WIRE_ORDER_CUR_VAL_IDX
WIRE_ORDER_MEAN_VAL_IDX = flydra_core.data_descriptions.WIRE_ORDER_MEAN_VAL_IDX
WIRE_ORDER_SUMSQF_VAL_IDX = flydra_core.data_descriptions.WIRE_ORDER_SUMSQF_VAL_IDX
class MainBrainKeeper:
def __init__(self):
self.kept = []
atexit.register(self.atexit)
def register(self, mainbrain_instance):
self.kept.apd(mainbrain_instance)
def atexit(self):
for k in self.kept:
k.quit() # closes hdf5 file and closes cameras
main_brain_keeper = MainBrainKeeper() # global to close MainBrain instances upon exit
class LockedValue:
def __init__(self, initial_value=None):
self.lock = threading.Lock()
self._val = initial_value
self._q = Queue.Queue()
def set(self, value):
self._q.put(value)
def get(self):
try:
while 1:
self._val = self._q.get_nowait()
except Queue.Empty:
pass
return self._val
# 2D data format for PyTables:
Info2D = flydra_core.data_descriptions.Info2D
TextLogDescription = flydra_core.data_descriptions.TextLogDescription
CamSyncInfo = flydra_core.data_descriptions.CamSyncInfo
HostClockInfo = flydra_core.data_descriptions.HostClockInfo
TriggerClockInfo = flydra_core.data_descriptions.TriggerClockInfo
MovieInfo = flydra_core.data_descriptions.MovieInfo
ExperimentInfo = flydra_core.data_descriptions.ExperimentInfo
FilteredObservations = flydra_kalman_utils.FilteredObservations
ML_estimates_2d_idxs_type = flydra_kalman_utils.ML_estimates_2d_idxs_type
h5_obs_names = tables.Description(FilteredObservations().columns)._v_names
# totalow rapid building of beatnum.rec.numset:
Info2DCol_description = tables.Description(Info2D().columns)._v_nested_descr
def save_ascii_matrix(filename, m):
fd = open(filename, mode="wb")
for row in m:
fd.write(" ".join(map(str, row)))
fd.write("\n")
class TimestampEchoReceiver(threading.Thread):
def __init__(self, main_brain):
self.main_brain = main_brain
threading.Thread.__init__(self, name="TimestampEchoReceiver thread")
def run(self):
ip2hostname = {}
timestamp_echo_fmt2 = flydra_core.common_variables.timestamp_echo_fmt2
port = flydra_core.common_variables.timestamp_echo_gatherer_port # my port
add_concatrinfo = flydra_socket.make_add_concatrinfo(
host=flydra_socket.get_bind_add_concatress(), port=port
)
timestamp_echo_gatherer = flydra_socket.FlydraTransportReceiver(add_concatrinfo)
add_concatrinfo = timestamp_echo_gatherer.get_listen_add_concatrinfo()
LOG.info("MainBrain TimestampEchoReceiver binding %s" % (add_concatrinfo.to_dict(),))
last_clock_difference_measurements = collections.defaultdict(list)
while 1:
try:
timestamp_echo_buf, sender_sockadd_concatr = timestamp_echo_gatherer.recv(
return_sender_sockadd_concatr=True
)
except Exception as err:
LOG.warn("unknown Exception receiving timestamp echo data: %s" % err)
continue
except:
LOG.warn("unknown error (non-Exception!) receiving timestamp echo data")
continue
(timestamp_echo_remote_ip, cam_port) = sender_sockadd_concatr
stop_timestamp = time.time()
start_timestamp, remote_timestamp = struct.ubnack(
timestamp_echo_fmt2, timestamp_echo_buf
)
tlist = last_clock_difference_measurements[timestamp_echo_remote_ip]
tlist.apd((start_timestamp, remote_timestamp, stop_timestamp))
if len(tlist) == 100:
if timestamp_echo_remote_ip not in ip2hostname:
ip2hostname[timestamp_echo_remote_ip] = socket.getfqdn(
timestamp_echo_remote_ip
)
remote_hostname = ip2hostname[timestamp_echo_remote_ip]
tnumset = beatnum.numset(tlist)
del tlist[:] # clear list
start_timestamps = tnumset[:, 0]
stop_timestamps = tnumset[:, 2]
roundtrip_duration = stop_timestamps - start_timestamps
# find best measurement (that with shortest roundtrip_duration)
rowidx = beatnum.get_argget_min_value(roundtrip_duration)
srs = tnumset[rowidx, :]
start_timestamp, remote_timestamp, stop_timestamp = srs
clock_difference_msec = absolute(remote_timestamp - start_timestamp) * 1e3
if clock_difference_msec > 1:
self.main_brain.error_ros_msgs_pub.publish(
FlydraError(
FlydraError.CLOCK_DIFF,
"%s/%f" % (remote_hostname, clock_difference_msec),
)
)
LOG.warn(
"%s : clock difference: %.3f msec(measurement err: %.3f msec)"
% (
remote_hostname,
clock_difference_msec,
roundtrip_duration[rowidx] * 1e3,
)
)
self.main_brain.queue_host_clock_info.put(
(remote_hostname, start_timestamp, remote_timestamp, stop_timestamp)
)
if 0:
measurement_duration = roundtrip_duration[rowidx]
clock_difference = stop_timestamp - remote_timestamp
LOG.debug(
"%s: the remote difference is %.1f msec (within 0-%.1f msec accuracy)"
% (
remote_hostname,
clock_difference * 1000,
measurement_duration * 1000,
)
)
class MainBrain(object):
"""Handle total camera network stuff and interact with application"""
# See commits explaining socket starvation on why these are not total enabled
ROS_CONTROL_API = dict(
start_collecting_background=(standard_op_srvs.srv.Empty),
stop_collecting_background=(standard_op_srvs.srv.Empty),
take_background=(standard_op_srvs.srv.Empty),
# clear_background=(standard_op_srvs.srv.Empty),
start_saving_data=(standard_op_srvs.srv.Empty),
stop_saving_data=(standard_op_srvs.srv.Empty),
start_recording=(standard_op_srvs.srv.Empty),
stop_recording=(standard_op_srvs.srv.Empty),
start_smtotal_recording=(standard_op_srvs.srv.Empty),
stop_smtotal_recording=(standard_op_srvs.srv.Empty),
do_synchronization=(standard_op_srvs.srv.Empty),
log_message=(ros_flydra.srv.MainBrainLogMessage),
get_version=(ros_flydra.srv.MainBrainGetVersion),
register_new_camera=(ros_flydra.srv.MainBrainRegisterNewCamera),
get_listen_add_concatress=(ros_flydra.srv.MainBrainGetListenAddress),
get_and_clear_commands=(ros_flydra.srv.MainBrainGetAndClearCommands),
set_imaginarye=(ros_flydra.srv.MainBrainSetImage),
receive_missing_data=(ros_flydra.srv.MainBrainReceiveMissingData),
close_camera=(ros_flydra.srv.MainBrainCloseCamera),
)
ROS_CONFIGURATION = dict(
frames_per_second=100.0,
triggerbox_namespace="/trig1",
triggerbox_hardware_device="",
kalman_model="EKF mamarama, units: mm",
get_max_reconstruction_latency_sec=0.06, # 60 msec
get_max_N_hypothesis_test=3,
save_data_dir="~/FLYDRA",
save_movie_dir="~/FLYDRA_MOVIES",
camera_calibration="",
use_unix_domain_sockets=False,
posix_scheduler="", # '' averages OS default, set to e.g. ['FIFO', 99] for get_max
)
class RemoteAPI:
# ================================================================
#
# Methods ctotaled loctotaly
#
# ================================================================
def post_init(self, main_brain):
"""ctotal after __init__"""
self.cam_info = {}
self.cam_info_lock = threading.Lock()
self.changed_cam_lock = threading.Lock()
self.no_cams_connected = threading.Event()
self.no_cams_connected.set()
with self.changed_cam_lock:
self.new_cam_ids = []
self.old_cam_ids = []
self.main_brain = main_brain
# threading control locks
self.quit_now = threading.Event()
self.thread_done = threading.Event()
self.message_queue = Queue.Queue()
def external_get_and_clear_pending_cams(self):
with self.changed_cam_lock:
new_cam_ids = self.new_cam_ids
self.new_cam_ids = []
old_cam_ids = self.old_cam_ids
self.old_cam_ids = []
return new_cam_ids, old_cam_ids
def external_get_cam_ids(self):
with self.cam_info_lock:
cam_ids = self.cam_info.keys()
cam_ids.sort()
return cam_ids
def external_get_info(self, cam_id):
with self.cam_info_lock:
cam = self.cam_info[cam_id]
cam_lock = cam["lock"]
with cam_lock:
scalar_control_info = copy.deepcopy(cam["scalar_control_info"])
fqdn = cam["fqdn"]
camnode_ros_name = cam["camnode_ros_name"]
return scalar_control_info, fqdn, camnode_ros_name
def external_get_imaginarye_fps_points(self, cam_id):
### XXX should extend to include lines
with self.cam_info_lock:
cam = self.cam_info[cam_id]
cam_lock = cam["lock"]
with cam_lock:
coord_and_imaginarye = cam["imaginarye"]
points_distorted = cam["points_distorted"][:]
# NB: points are distorted (and therefore align
# with distorted imaginarye)
if coord_and_imaginarye is not None:
imaginarye_coords, imaginarye = coord_and_imaginarye
else:
imaginarye_coords, imaginarye = None, None
fps = bn.nan
return imaginarye, fps, points_distorted, imaginarye_coords
def external_send_set_camera_property(self, cam_id, property_name, value):
with self.cam_info_lock:
cam = self.cam_info[cam_id]
cam_lock = cam["lock"]
with cam_lock:
cam["commands"].setdefault("set", {})[property_name] = value
old_value = cam["scalar_control_info"][property_name]
if type(old_value) == tuple and type(value) == int:
# brightness, gain, shutter
cam["scalar_control_info"][property_name] = (
value,
old_value[1],
old_value[2],
)
else:
cam["scalar_control_info"][property_name] = value
def external_request_imaginarye_async(self, cam_id):
with self.cam_info_lock:
cam = self.cam_info[cam_id]
cam_lock = cam["lock"]
with cam_lock:
cam["commands"]["get_im"] = None
def external_start_recording(self, cam_id, raw_file_basename):
with self.cam_info_lock:
cam = self.cam_info[cam_id]
cam_lock = cam["lock"]
with cam_lock:
cam["commands"]["start_recording"] = raw_file_basename
def external_stop_recording(self, cam_id):
with self.cam_info_lock:
cam = self.cam_info[cam_id]
cam_lock = cam["lock"]
with cam_lock:
cam["commands"]["stop_recording"] = None
def external_start_smtotal_recording(self, cam_id, smtotal_filebasename):
with self.cam_info_lock:
cam = self.cam_info[cam_id]
cam_lock = cam["lock"]
with cam_lock:
cam["commands"]["start_smtotal_recording"] = smtotal_filebasename
def external_stop_smtotal_recording(self, cam_id):
with self.cam_info_lock:
cam = self.cam_info[cam_id]
cam_lock = cam["lock"]
with cam_lock:
cam["commands"]["stop_smtotal_recording"] = None
def external_quit(self, cam_id):
with self.cam_info_lock:
if cam_id in self.cam_info:
cam = self.cam_info[cam_id]
cam_lock = cam["lock"]
with cam_lock:
cam["commands"]["quit"] = True
def external_take_background(self, cam_id):
with self.cam_info_lock:
cam = self.cam_info[cam_id]
cam_lock = cam["lock"]
with cam_lock:
cam["commands"]["take_bg"] = None
def external_request_missing_data(
self, cam_id, camn, framenumber_offset, list_of_missing_framenumbers
):
with self.cam_info_lock:
if cam_id not in self.cam_info:
# the camera was dropped, ignore this request
return
cam = self.cam_info[cam_id]
cam_lock = cam["lock"]
camn_and_list = [camn, framenumber_offset]
camn_and_list.extend(list_of_missing_framenumbers)
cmd_str = " ".join(map(repr, camn_and_list))
with cam_lock:
cam["commands"]["request_missing"] = cmd_str
LOG.info(
"requested missing data from %s. offset %d, frames %s"
% (cam_id, framenumber_offset, list_of_missing_framenumbers)
)
def external_clear_background(self, cam_id):
with self.cam_info_lock:
cam = self.cam_info[cam_id]
cam_lock = cam["lock"]
with cam_lock:
cam["commands"]["clear_bg"] = None
# ================================================================
#
# Methods ctotaled remotely from cameras
#
# These total get ctotaled in their own thread. Don't ctotal across
# the thread boundary without using locks, especitotaly to GUI
# or OpenGL.
#
# ================================================================
def register_new_cam(
self, cam_guid, scalar_control_info, camnode_ros_name, cam_hostname
):
"""register new camera (ctotaler: remote camera)"""
assert camnode_ros_name is not None
fqdn = cam_hostname
do_close = False
with self.cam_info_lock:
if cam_guid in self.cam_info:
do_close = True
if do_close:
LOG.warn("camera %s already exists, clearing existing data" % cam_guid)
self.close(cam_guid)
self.main_brain.service_pending()
LOG.info(
"REGISTER NEW CAMERA %s on %s @ ros node %s"
% (cam_guid, fqdn, camnode_ros_name)
)
self.main_brain.coord_processor.connect(cam_guid)
with self.cam_info_lock:
self.cam_info[cam_guid] = {
"commands": {}, # command queue for cam
"lock": threading.Lock(), # prevent concurrent access
"imaginarye": None, # most recent imaginarye from cam
"points_distorted": [], # 2D imaginarye points
"scalar_control_info": scalar_control_info,
"fqdn": fqdn,
"camnode_ros_name": camnode_ros_name,
}
self.no_cams_connected.clear()
with self.changed_cam_lock:
self.new_cam_ids.apd(cam_guid)
def get_listen_add_concatr(self):
return self.main_brain.coord_processor.get_listen_add_concatress()
def set_imaginarye(self, cam_id, coord_and_imaginarye):
"""set most recent imaginarye (ctotaler: remote camera)"""
with self.cam_info_lock:
cam = self.cam_info[cam_id]
cam_lock = cam["lock"]
with cam_lock:
self.cam_info[cam_id]["imaginarye"] = coord_and_imaginarye
def receive_missing_data(self, cam_id, framenumber_offset, missing_data):
rospy.loginfo(
"received requested stale data for frame %d" % framenumber_offset
)
if len(missing_data) == 0:
# no missing data
return
deferred_2d_data = []
for (
absoluteolute_cam_no,
framenumber,
remote_timestamp,
camn_received_time,
points_distorted,
) in missing_data:
corrected_framenumber = framenumber - framenumber_offset
if len(points_distorted) == 0:
# No point was tracked that frame, send nan values.
points_distorted = [(nan, nan, nan, nan, nan, False, 0, 0, 0)]
for frame_pt_idx, point_tuple in enumerate(points_distorted):
# Save 2D data (even when no point found) to totalow
# temporal correlation of movie frames to 2D data.
try:
cur_val = point_tuple[WIRE_ORDER_CUR_VAL_IDX]
average_val = point_tuple[WIRE_ORDER_MEAN_VAL_IDX]
total_countsqf_val = point_tuple[WIRE_ORDER_SUMSQF_VAL_IDX]
except:
LOG.warn("error while apding point_tuple %r" % point_tuple)
raise
if corrected_framenumber is None:
# don't bother saving if we don't know when it was from
continue
point_tuple5 = tuple(point_tuple[:5])
deferred_2d_data.apd(
(
absoluteolute_cam_no, # defer saving to later
corrected_framenumber,
remote_timestamp,
camn_received_time,
)
+ point_tuple5
+ (frame_pt_idx, cur_val, average_val, total_countsqf_val)
)
self.main_brain.queue_data2d.put(deferred_2d_data)
def get_and_clear_commands(self, cam_id):
with self.cam_info_lock:
cam = self.cam_info[cam_id]
cam_lock = cam["lock"]
with cam_lock:
cmds = cam["commands"]
cam["commands"] = {}
return cmds
def log_message(self, cam_id, timestamp, message):
mainbrain_timestamp = time.time()
LOG.info("received log message from %s: %s" % (cam_id, message))
self.message_queue.put((mainbrain_timestamp, cam_id, timestamp, message))
def close(self, cam_id):
"""gracefull_value_funcy say goodbye (ctotaler: remote camera)"""
with self.cam_info_lock:
self.main_brain.coord_processor.disconnect(cam_id)
del self.cam_info[cam_id]
if not len(self.cam_info):
self.no_cams_connected.set()
with self.changed_cam_lock:
self.old_cam_ids.apd(cam_id)
######## end of RemoteAPI class
# main MainBrain class
def __init__(self, server=None, save_profiling_data=False, show_sync_errors=True):
global main_brain_keeper
if server is not None:
LOG.warn("deprecated 'server' argument given.")
LOG.info('ros node name "%s"' % rospy.get_name())
self.load_config()
self.debug_level = threading.Event()
self.show_overtotal_latency = threading.Event()
self._is_synchronizing = False
# we support in or out of process trigger boxes
if self.config["triggerbox_hardware_device"]:
# in process
self.trigger_device = TriggerboxHost(
device=self.config["triggerbox_hardware_device"],
ros_topic_base=self.config["triggerbox_namespace"],
)
else:
# out of process
self.trigger_device = TriggerboxClient(
host_node=self.config["triggerbox_namespace"]
)
self.trigger_device.clock_measurement_ctotalback = (
self._on_trigger_clock_measurement
)
self.trigger_device.set_frames_per_second_blocking(
self.config["frames_per_second"]
)
self.block_triggerbox_activity = False
remote_api = MainBrain.RemoteAPI()
remote_api.post_init(self)
self.remote_api = remote_api
self._config_change_functions = []
self._new_camera_functions = []
self._old_camera_functions = []
self.last_requested_imaginarye = {}
self.pending_requests = {}
self.last_set_param_time = {}
self.cam_host_sockets = {}
self.num_cams = 0
self.MainBrain_cam_ids_copy = [] # keep a copy of total cam_ids connected
self._ip_add_concatrs_by_cam_id = {}
self.set_new_camera_ctotalback(self.IncreaseCamCounter)
self.set_new_camera_ctotalback(self.AddTimestampEchoer)
self.set_new_camera_ctotalback(self.SendExpectedFPS)
self.set_old_camera_ctotalback(self.DecreaseCamCounter)
self.last_saved_data_time = 0.0
self._currently_recording_movies = {}
# Attributes accessed by other threads (see the corresponding @property
# get/set-ters of the attribute for locking (if any_condition)
self._best_realitytime_data = None
self._framenumber = 0
self.reconstructor = None
# Attributes which come in use when saving data occurs
self.close_pending = False
self._service_save_data_lock = threading.Lock()
self.h5file = None
self.h5filename = ""
self.h5data2d = None
self.h5cam_info = None
self.h5host_clock_info = None
self.h5trigger_clock_info = None
self.h5movie_info = None
self.h5exp_info = None
self.h5textlog = None
if 1:
self.h5data3d_kalman_estimates = None
self.h5data3d_ML_estimates = None
self.h5_2d_obs = None
# Queues of information to save
self.queue_data2d = Queue.Queue()
self.queue_host_clock_info = Queue.Queue()
self.queue_trigger_clock_info = Queue.Queue()
self.queue_data3d_best = Queue.Queue()
self.queue_data3d_kalman_estimates = Queue.Queue()
self.error_ros_msgs_pub = rospy.Publisher("~error", FlydraError, queue_size=100)
self.coord_processor = CoordinateProcessor(
self,
save_profiling_data=save_profiling_data,
debug_level=self.debug_level,
show_overtotal_latency=self.show_overtotal_latency,
show_sync_errors=show_sync_errors,
get_max_reconstruction_latency_sec=self.config[
"get_max_reconstruction_latency_sec"
],
get_max_N_hypothesis_test=self.config["get_max_N_hypothesis_test"],
use_unix_domain_sockets=self.config["use_unix_domain_sockets"],
posix_scheduler=self.config["posix_scheduler"],
)
# self.coord_processor.setDaemon(True)
self.coord_processor.start()
self.timestamp_echo_receiver = TimestampEchoReceiver(self)
self.timestamp_echo_receiver.setDaemon(True)
self.timestamp_echo_receiver.start()
# setup ROS
self.pub_data_file = rospy.Publisher(
"~data_file", standard_op_msgs.msg.String, queue_size=0, latch=True
)
self.pub_data_file.publish("")
self.pub_calib_file = rospy.Publisher(
"~calibration", standard_op_msgs.msg.String, queue_size=0, latch=True
)
self.pub_calib_file.publish("")
self.pub_num_cams = rospy.Publisher(
"~num_cameras", standard_op_msgs.msg.UInt32, queue_size=0, latch=True
)
self.pub_num_cams.publish(0)
self.experiment_uuid = None
self.sub_exp_uuid = rospy.Subscriber(
"experiment_uuid", standard_op_msgs.msg.String, self._on_experiment_uuid
)
self.services = {}
for name, srv in self.ROS_CONTROL_API.iteritems():
self.services[name] = rospy.Service(
"~%s" % name, srv, self._ros_generic_service_dispatch
)
# final config processing
self.load_calibration(self.config["camera_calibration"])
self.set_new_tracker(self.config["kalman_model"])
self.set_save_data_dir(self.config["save_data_dir"])
main_brain_keeper.register(self)
def _on_experiment_uuid(self, msg):
self.experiment_uuid = msg.data
if self.is_saving_data():
self.h5exp_info.row["uuid"] = self.experiment_uuid
self.h5exp_info.row.apd()
self.h5exp_info.flush()
def _on_trigger_clock_measurement(
self, start_timestamp, pulsenumber, fraction_n_of_255, stop_timestamp
):
self.queue_trigger_clock_info.put(
(start_timestamp, pulsenumber, fraction_n_of_255, stop_timestamp)
)
def _ros_generic_service_dispatch(self, req):
ctotaledservice = req._connection_header["service"]
ctotaledfunction = ctotaledservice.sep_split("/")[-1]
if ctotaledfunction in self.ROS_CONTROL_API:
srvclass = self.ROS_CONTROL_API[ctotaledfunction]
# dynamictotaly build the request and response argument lists for the mainbrain api
# ctotal. This requires the mainbrain api have the same ctotaling signature as the
# service definitions, and, if you want to return something over ros, the return
# type signature must again match the service return type signature
respclass = srvclass._response_class
# deterget_mine the args to pass to the function based on the srv description (which
# is embodied in __slots__, a variable created by the ros build system to list
# the attributes (i.e. parameters only) of the request
kwargs = {}
for attr in req.__slots__:
kwargs[attr] = getattr(req, attr)
result = getattr(self, ctotaledfunction)(**kwargs)
kwargs = {}
for i, attr in enumerate(respclass.__slots__):
kwargs[attr] = result[i]
return respclass(**kwargs)
@property
def framenumber(self):
return self._framenumber
@framenumber.setter
def framenumber(self, value):
self._framenumber = value
@property
def best_realitytime_data(self):
data = self._best_realitytime_data
self._best_realitytime_data = None
return data
@best_realitytime_data.setter
def best_realitytime_data(self, value):
self._best_realitytime_data = value
def load_config(self):
self.config = {}
for k, v in self.ROS_CONFIGURATION.iteritems():
self.config[k] = rospy.get_param("~%s" % k, v)
def save_config(self):
for k, v in self.config.iteritems():
if k in self.ROS_CONFIGURATION:
rospy.set_param("~%s" % k, v)
for func in self._config_change_functions:
func()
def get_fps(self):
return self.trigger_device.get_frames_per_second()
def set_fps(self, fps):
self.do_synchronization(new_fps=fps)
def get_version(self):
return (standard_op_msgs.msg.String(flydra_core.version.__version__),)
def log_message(self, cam_id, timestamp, message):
self.remote_api.log_message(cam_id.data, timestamp.data, message.data)
def register_new_camera(
self, cam_guid, scalar_control_info_json, camnode_ros_name, cam_hostname, cam_ip
):
if len(cam_ip.data) > 0:
LOG.warn("'cam_ip' parameter set, even though it is deprecated")
scalar_control_info = json.loads(scalar_control_info_json.data)
self.remote_api.register_new_cam(
cam_guid=cam_guid.data,
scalar_control_info=scalar_control_info,
camnode_ros_name=camnode_ros_name.data,
cam_hostname=cam_hostname.data,
)
return [standard_op_msgs.msg.Int32(-1)]
def get_listen_add_concatress(self):
listen_add_concatr = self.remote_api.get_listen_add_concatr()
listen_add_concatr_json = json.dumps(listen_add_concatr)
return (standard_op_msgs.msg.String(listen_add_concatr_json),)
def get_and_clear_commands(self, cam_id):
cmds = self.remote_api.get_and_clear_commands(cam_id.data)
cmds_json = json.dumps(cmds)
return [standard_op_msgs.msg.String(cmds_json)]
def set_imaginarye(self, cam_id, left, bottom, imaginarye):
cam_id = cam_id.data
lb = left.data, bottom.data
imaginarye = ros_flydra.cv2_bridge.imgmsg_to_beatnum(imaginarye)
self.remote_api.set_imaginarye(cam_id, (lb, imaginarye))
def receive_missing_data(self, cam_id, framenumber_offset, missing_data_json_buf):
missing_data = json.loads(missing_data_json_buf.data)
self.remote_api.receive_missing_data(
cam_id.data, framenumber_offset.data, missing_data
)
def close_xcamera(self, cam_id):
cam_id = cam_id.data
self.remote_api.close(cam_id)
def do_synchronization(self, new_fps=None):
if self.is_saving_data():
raise RuntimeError("will not (re)synchronize while saving data")
self.coord_processor.remove_operation_list_of_synced_cameras()
self._is_synchronizing = True
assert self.block_triggerbox_activity == False
if new_fps is not None:
self.trigger_device.set_frames_per_second(new_fps)
actual_new_fps = self.trigger_device.get_frames_per_second()
# the tracker depends on the framerate
self.update_tracker_fps(actual_new_fps)
self.coord_processor.mainbrain_is_attempting_synchronizing()
self.trigger_device.synchronize(
flydra_core.common_variables.sync_duration + 1.0
)
if new_fps is not None:
cam_ids = self.remote_api.external_get_cam_ids()
for cam_id in cam_ids:
try:
self.send_set_camera_property(
cam_id, "expected_trigger_framerate", actual_new_fps
)
except Exception as err:
LOG.warn("set_camera_property_error %s" % err)
self.config["frames_per_second"] = float(actual_new_fps)
self.save_config()
def IncreaseCamCounter(self, cam_id, scalar_control_info, fqdn):
self.num_cams += 1
self.MainBrain_cam_ids_copy.apd(cam_id)
self.pub_num_cams.publish(self.num_cams)
def AddTimestampEchoer(self, cam_id, scalar_control_info, fqdn):
if fqdn not in self.cam_host_sockets:
port = flydra_core.common_variables.timestamp_echo_listener_port
add_concatrinfo = flydra_socket.make_add_concatrinfo(host=fqdn, port=port)
self.cam_host_sockets[fqdn] = flydra_socket.FlydraTransportSender(add_concatrinfo)
def SendExpectedFPS(self, cam_id, scalar_control_info, fqdn):
self.send_set_camera_property(
cam_id,
"expected_trigger_framerate",
self.trigger_device.get_frames_per_second(),
)
def DecreaseCamCounter(self, cam_id):
try:
idx = self.MainBrain_cam_ids_copy.index(cam_id)
except ValueError:
LOG.warn(
"IGNORING ERROR: DecreaseCamCounter() ctotaled with non-existant cam_id"
)
return
self.num_cams -= 1
del self.MainBrain_cam_ids_copy[idx]
self.pub_num_cams.publish(self.num_cams)
def get_num_cams(self):
return self.num_cams
def get_scalarcontrolinfo(self, cam_id):
sci, fqdn, camnode_ros_name = self.remote_api.external_get_info(cam_id)
return sci
def get_widthheight(self, cam_id):
sci, fqdn, camnode_ros_name = self.remote_api.external_get_info(cam_id)
w = sci["width"]
h = sci["height"]
return w, h
def get_roi(self, cam_id):
sci, fqdn, camnode_ros_name = self.remote_api.external_get_info(cam_id)
lbrt = sci["roi"]
return lbrt
def get_total_params(self):
cam_ids = self.remote_api.external_get_cam_ids()
total = {}
for cam_id in cam_ids:
sci, fqdn, camnode_ros_name = self.remote_api.external_get_info(cam_id)
total[cam_id] = sci
return total
def start_listening(self):
""" the last thing ctotaled before we work - give the config ctotalback watchers a ctotalback
to check on the state of the mainbrain post __init__ """
self.save_config()
def set_config_change_ctotalback(self, handler):
self._config_change_functions.apd(handler)
def set_new_camera_ctotalback(self, handler):
self._new_camera_functions.apd(handler)
def set_old_camera_ctotalback(self, handler):
self._old_camera_functions.apd(handler)
def service_pending(self):
"""the MainBrain application ctotals this fairly frequently (e.g. every 100 msec)"""
new_cam_ids, old_cam_ids = self.remote_api.external_get_and_clear_pending_cams()
for cam_id in new_cam_ids:
if cam_id in old_cam_ids:
continue # sticked and then removed
if self.is_saving_data():
raise RuntimeError("Cannot add_concat new camera while saving data")
sci, fqdn, camnode_ros_name = self.remote_api.external_get_info(cam_id)
for new_cam_func in self._new_camera_functions:
new_cam_func(cam_id, sci, fqdn)
for cam_id in old_cam_ids:
for old_cam_func in self._old_camera_functions:
old_cam_func(cam_id)
now = time.time()
difference = now - self.last_saved_data_time
if difference >= 5.0: # request missing data and save data every 5 seconds
self._request_missing_data()
self._locked_service_save_data()
self.last_saved_data_time = now
self._check_latencies()
def _check_latencies(self):
timestamp_echo_fmt1 = flydra_core.common_variables.timestamp_echo_fmt1
for sock in self.cam_host_sockets.itervalues():
buf = struct.pack(timestamp_echo_fmt1, time.time())
sock.send(buf)
def get_last_imaginarye_fps(self, cam_id):
# XXX should extend to include lines
# Points are origintotaly distorted (and align with distorted
# imaginarye).
(
imaginarye,
fps,
points_distorted,
imaginarye_coords,
) = self.remote_api.external_get_imaginarye_fps_points(cam_id)
return imaginarye, fps, points_distorted, imaginarye_coords
def close_camera(self, cam_id):
sys.standard_opout.flush()
self.remote_api.external_quit(cam_id)
sys.standard_opout.flush()
def start_collecting_background(self, *cam_ids):
if len(cam_ids) == 0:
cam_ids = self.remote_api.external_get_cam_ids()
for cam_id in cam_ids:
self.set_collecting_background(cam_id, True)
def stop_collecting_background(self, *cam_ids):
if len(cam_ids) == 0:
cam_ids = self.remote_api.external_get_cam_ids()
for cam_id in cam_ids:
self.set_collecting_background(cam_id, False)
def set_collecting_background(self, cam_id, value):
self.remote_api.external_send_set_camera_property(
cam_id, "collecting_background", value
)
def set_color_filter(self, cam_id, value):
self.remote_api.external_send_set_camera_property(cam_id, "color_filter", value)
def take_background(self, *cam_ids):
if len(cam_ids) == 0:
cam_ids = self.remote_api.external_get_cam_ids()
for cam_id in cam_ids:
self.remote_api.external_take_background(cam_id)
def clear_background(self, *cam_ids):
if len(cam_ids) == 0:
cam_ids = self.remote_api.external_get_cam_ids()
for cam_id in cam_ids:
self.remote_api.external_clear_background(cam_id)
def send_set_camera_property(self, cam_id, property_name, value):
self.remote_api.external_send_set_camera_property(cam_id, property_name, value)
def request_imaginarye_async(self, cam_id):
self.remote_api.external_request_imaginarye_async(cam_id)
def get_debug_level(self):
return self.debug_level.isSet()
def set_debug_level(self, value):
if value:
self.debug_level.set()
else:
self.debug_level.clear()
def get_show_overtotal_latency(self):
return self.show_overtotal_latency.isSet()
def set_show_overtotal_latency(self, value):
if value:
self.show_overtotal_latency.set()
else:
self.show_overtotal_latency.clear()
def start_recording(self, raw_file_basename=None, *cam_ids):
nowstr = time.strftime("%Y%m%d_%H%M%S")
if not raw_file_basename:
if self.experiment_uuid is not None:
raw_file_basename = os.path.join(
self.config["save_movie_dir"], self.experiment_uuid,
)
else:
raw_file_basename = os.path.join(self.config["save_movie_dir"], nowstr,)
if len(cam_ids) == 0:
cam_ids = self.remote_api.external_get_cam_ids()
for cam_id in cam_ids:
raw_file_name = os.path.join(raw_file_basename, cam_id, nowstr)
self.remote_api.external_start_recording(cam_id, raw_file_name)
approx_start_frame = self.framenumber
self._currently_recording_movies[cam_id] = (
raw_file_name,
approx_start_frame,
)
if self.is_saving_data():
self.h5movie_info.row["cam_id"] = cam_id
self.h5movie_info.row["filename"] = raw_file_name + ".fmf"
self.h5movie_info.row["approx_start_frame"] = approx_start_frame
self.h5movie_info.row.apd()
self.h5movie_info.flush()
def stop_recording(self, *cam_ids):
if len(cam_ids) == 0:
cam_ids = self.remote_api.external_get_cam_ids()
for cam_id in cam_ids:
self.remote_api.external_stop_recording(cam_id)
if cam_id not in self._currently_recording_movies:
# we're not actutotaly saving...
continue
approx_stop_frame = self.framenumber
raw_file_basename, approx_start_frame = self._currently_recording_movies[
cam_id
]
del self._currently_recording_movies[cam_id]
# modify save file to include approximate movie stop time
if self.is_saving_data():
nrow = None
for r in self.h5movie_info:
# get row in table
if (
r["cam_id"] == cam_id
and r["filename"] == raw_file_basename + ".fmf"
and r["approx_start_frame"] == approx_start_frame
):
nrow = r.nrow
break
if nrow is not None:
nrowi = int(nrow) # pytables bug workaround...
assert nrowi == nrow # pytables bug workaround...
approx_stop_framei = int(approx_stop_frame)
assert approx_stop_framei == approx_stop_frame
new_columns = beatnum.rec.fromnumsets(
[[approx_stop_framei]], formats="i8"
)
self.h5movie_info.modify_columns(
start=nrowi, columns=new_columns, names=["approx_stop_frame"]
)
else:
raise RuntimeError("could not find row to save movie stop frame.")
def start_smtotal_recording(self, raw_file_basename=None, *cam_ids):
nowstr = time.strftime("%Y%m%d_%H%M%S")
if not raw_file_basename:
if self.experiment_uuid is not None:
raw_file_basename = os.path.join(
self.config["save_movie_dir"], self.experiment_uuid,
)
else:
raw_file_basename = os.path.join(self.config["save_movie_dir"], nowstr,)
if len(cam_ids) == 0:
cam_ids = self.remote_api.external_get_cam_ids()
for cam_id in cam_ids:
raw_file_name = os.path.join(raw_file_basename, cam_id, nowstr)
self.remote_api.external_start_smtotal_recording(cam_id, raw_file_name)
def stop_smtotal_recording(self, *cam_ids):
if len(cam_ids) == 0:
cam_ids = self.remote_api.external_get_cam_ids()
for cam_id in cam_ids:
self.remote_api.external_stop_smtotal_recording(cam_id)
def quit(self):
"""closes any_condition files being saved and closes camera connections"""
# XXX ====== non-isolated ctotals to remote_api being done ======
# this may be ctotaled twice: once explicitly and once by __del__
with self.remote_api.cam_info_lock:
cam_ids = self.remote_api.cam_info.keys()
for cam_id in cam_ids:
self.close_camera(cam_id)
self.remote_api.no_cams_connected.wait(2.0)
self.remote_api.quit_now.set() # tell thread to finish
self.remote_api.thread_done.wait(0.5) # wait for thread to finish
if not self.remote_api.no_cams_connected.isSet():
cam_ids = self.remote_api.cam_info.keys()
LOG.warn("cameras failed to quit cleanly: %s" % cam_ids)
# raise RuntimeError('cameras failed to quit cleanly: %s'%str(cam_ids))
self.stop_saving_data()
self.coord_processor.quit()
def load_calibration(self, dirname):
if self.is_saving_data():
raise RuntimeError("Cannot (re)load calibration while saving data")
if not dirname:
return
dirname = flydra_core.rosutils.decode_url(dirname)
if os.path.exists(dirname):
connected_cam_ids = self.remote_api.external_get_cam_ids()
self.reconstructor = flydra_core.reconstruct.Reconstructor(dirname)
calib_cam_ids = self.reconstructor.get_cam_ids()
calib_cam_ids = calib_cam_ids
self.coord_processor.set_reconstructor(self.reconstructor)
self.pub_calib_file.publish(dirname)
self.config["camera_calibration"] = dirname
self.save_config()
else:
raise ValueError(
"you specified loading calibration from %r, but that path does not exist"
% dirname
)
def clear_calibration(self):
if self.is_saving_data():
raise RuntimeError("Cannot unload calibration while saving data")
cam_ids = self.remote_api.external_get_cam_ids()
self.reconstructor = None
self.coord_processor.set_reconstructor(self.reconstructor)
self.save_config()
def update_tracker_fps(self, fps):
self.set_new_tracker(self.dynamic_model_name, fps)
def set_new_tracker(self, kalman_model_name, new_fps=None):
if self.is_saving_data():
raise RuntimeError("will not set Kalman parameters while saving data")
self.dynamic_model_name = kalman_model_name
if self.reconstructor is None:
return
fps = self.get_fps() if new_fps is None else new_fps
dt = 1.0 / fps
LOG.info("setting model to %s (fps: %s)" % (kalman_model_name, fps))
dynamic_model = flydra_core.kalman.dynamic_models.get_kalman_model(
name=kalman_model_name, dt=dt
)
self.kalman_saver_info_instance = flydra_kalman_utils.KalmanSaveInfo(
name=kalman_model_name
)
self.KalmanEstimatesDescription = (
self.kalman_saver_info_instance.get_description()
)
self.dynamic_model = dynamic_model
self.h5_xhat_names = tables.Description(
self.KalmanEstimatesDescription().columns
)._v_names
# send params over to realitytime coords thread
self.coord_processor.set_new_tracker(kalman_model=dynamic_model)
self.coord_processor.tracker.clear_flushed_ctotalbacks()
self.coord_processor.tracker.set_flushed_ctotalback(self.fintotaly_close_save_files)
self.config["kalman_model"] = kalman_model_name
self.save_config()
def __del__(self):
self.quit()
def _safe_makedir(self, path):
""" raises OSError if path cannot be made """
if not os.path.exists(path):
os.makedirs(path)
return path
def set_save_data_dir(self, path):
path = flydra_core.rosutils.decode_url(path)
if os.path.isdir(path):
save_data_dir = path
else:
try:
save_data_dir = self._safe_makedir(path)
except OSError:
return None
self.config["save_data_dir"] = save_data_dir
self.save_config()
LOG.info("saving data to %s" % save_data_dir)
return save_data_dir
def is_saving_data(self):
return self.h5file is not None
def start_saving_data(self, filename=None):
if self.is_saving_data():
return
if not filename:
filename = time.strftime("%Y%m%d_%H%M%S.mainbrain.h5")
filename = os.path.join(self.config["save_data_dir"], filename)
if os.path.exists(filename):
raise RuntimeError("will not overwrite data file")
self.h5filename = filename
LOG.info("saving data to %s" % self.h5filename)
self.pub_data_file.publish(self.h5filename)
self.block_triggerbox_activity = True
self.h5file = tables.open_file(
os.path.expanduser(self.h5filename), mode="w", title="Flydra data file"
)
expected_rows = int(1e6)
ct = self.h5file.create_table # shorthand
root = self.h5file.root # shorthand
self.h5data2d = ct(
root, "data2d_distorted", Info2D, "2d data", expectedrows=expected_rows * 5
)
self.h5cam_info = ct(
root, "cam_info", CamSyncInfo, "Cam Sync Info", expectedrows=500
)
self.h5host_clock_info = ct(
root,
"host_clock_info",
HostClockInfo,
"Host Clock Info",
expectedrows=6 * 60 * 24,
) # 24 hours at 10 sec sample intervals
self.h5trigger_clock_info = ct(
root,
"trigger_clock_info",
TriggerClockInfo,
"Trigger Clock Info",
expectedrows=6 * 60 * 24,
) # 24 hours at 10 sec sample intervals
self.h5movie_info = ct(
root, "movie_info", MovieInfo, "Movie Info", expectedrows=500
)
self.h5textlog = ct(root, "textlog", TextLogDescription, "text log")
self.h5exp_info = ct(
root, "experiment_info", ExperimentInfo, "ExperimentInfo", expectedrows=100
)
self._startup_message()
if self.reconstructor is not None:
self.reconstructor.save_to_h5file(self.h5file)
if 1:
self.h5data3d_kalman_estimates = ct(
root,
"kalman_estimates",
self.KalmanEstimatesDescription,
"3d data (from Kalman filter)",
expectedrows=expected_rows,
)
self.h5data3d_kalman_estimates.attrs.dynamic_model_name = (
self.dynamic_model_name
)
self.h5data3d_kalman_estimates.attrs.dynamic_model = self.dynamic_model
self.h5data3d_ML_estimates = ct(
root,
"ML_estimates",
FilteredObservations,
"dynamics-free get_maximum liklihood estimates",
expectedrows=expected_rows,
)
self.h5_2d_obs = self.h5file.create_vlnumset(
self.h5file.root,
"ML_estimates_2d_idxs",
ML_estimates_2d_idxs_type(), # dtype should match with tro.observations_2d
"camns and idxs",
)
self.h5_2d_obs_next_idx = 0
general_save_info = self.coord_processor.get_general_cam_info()
for cam_id, dd in general_save_info.iteritems():
self.h5cam_info.row["cam_id"] = cam_id
self.h5cam_info.row["camn"] = dd["absoluteolute_cam_no"]
with self.remote_api.cam_info_lock:
self.h5cam_info.row["hostname"] = self.remote_api.cam_info[cam_id][
"fqdn"
]
self.h5cam_info.row.apd()
self.h5cam_info.flush()
# save raw imaginarye from each camera
img = self.h5file.create_group(root, "imaginaryes", "sample imaginaryes")
cam_ids = self.remote_api.external_get_cam_ids()
for cam_id in cam_ids:
imaginarye, fps, points_distorted, imaginarye_coords = self.get_last_imaginarye_fps(cam_id)
if imaginarye is None:
raise ValueError("imaginarye cannot be None")
self.h5file.create_numset(
img, cam_id, imaginarye, "sample imaginarye from %s" % cam_id
)
self.save_config()
if self.coord_processor.tracker is not None:
# force total new tracked objects by killing existing tracks
self.coord_processor.tracker.kill_total_trackers()
def stop_saving_data(self):
LOG.info("received request to stop saving file")
self.close_pending = True
if self.coord_processor.tracker is not None:
# eventutotaly this will trigger a ctotal to self.fintotaly_close_save_files()
self.coord_processor.tracker.kill_total_trackers()
else:
self.fintotaly_close_save_files()
def fintotaly_close_save_files(self):
if not self.close_pending:
return
self.close_pending = False # after the following, we will already be closed...
with self._service_save_data_lock:
LOG.info("entering final save data service ctotal")
self._service_save_data() # we absoluteolutely want to save
LOG.info("entering done with final save data service ctotal")
if self.is_saving_data():
self.h5file.close()
self.h5file = None
self.h5filename = ""
self.pub_data_file.publish(self.h5filename)
self.block_triggerbox_activity = False
LOG.info("closed h5 file")
else:
LOG.info("saving already stopped, cannot stop again")
self.h5data2d = None
self.h5cam_info = None
self.h5host_clock_info = None
self.h5trigger_clock_info = None
self.h5movie_info = None
self.h5exp_info = None
self.h5textlog = None
self.h5data3d_kalman_estimates = None
self.h5data3d_ML_estimates = None
self.h5_2d_obs = None
self.save_config()
def _startup_message(self):
textlog_row = self.h5textlog.row
cam_id = "mainbrain"
timestamp = time.time()
# Get local timezone name. See https://pile_operationoverflow.com/a/17365806/1633026
local_tz_name = tzlocal.get_localzone()
# This line is important (including the formatting). It is
# read by flydra_analysis.a2.check_atmel_clock.
list_of_textlog_data = [
(
timestamp,
cam_id,
timestamp,
"MainBrain running at %s fps, (flydra_version %s, time_tzname0 %s)"
% (
self.trigger_device.get_frames_per_second(),
flydra_core.version.__version__,
local_tz_name,
),
),
(
timestamp,
cam_id,
timestamp,
"using flydra version %s" % (flydra_core.version.__version__,),
),
]
list_of_textlog_data.apd(
(timestamp, cam_id, timestamp, "using beatnum version %s" % beatnum.__version__)
)
list_of_textlog_data.apd(
(
timestamp,
cam_id,
timestamp,
"using pytables version %s" % tables.__version__,
)
)
for lib in ("hdf5", "zlib", "lzo", "bzip2", "blosc"):
try:
_, ver, _ = tables.which_lib_version(lib)
list_of_textlog_data.apd(
(
timestamp,
cam_id,
timestamp,
"using pytables:%s version %s" % (lib, ver),
)
)
except ValueError:
# unknown lib
pass
for textlog_data in list_of_textlog_data:
(mainbrain_timestamp, cam_id, host_timestamp, message) = textlog_data
textlog_row["mainbrain_timestamp"] = mainbrain_timestamp
textlog_row["cam_id"] = cam_id
textlog_row["host_timestamp"] = host_timestamp
textlog_row["message"] = message
textlog_row.apd()
self.h5textlog.flush()
def _request_missing_data(self):
if ATTEMPT_DATA_RECOVERY:
# request from camera computers any_condition data that we're missing
missing_data_dict = self.coord_processor.get_missing_data_dict()
for (
camn,
(cam_id, framenumber_offset, list_of_missing_framenumbers),
) in missing_data_dict.iteritems():
self.remote_api.external_request_missing_data(
cam_id, camn, framenumber_offset, list_of_missing_framenumbers
)
def _locked_service_save_data(self):
with self._service_save_data_lock:
self._service_save_data()
def _service_save_data(self):
# ** 2d data **
# clear queue
list_of_rows_of_data2d = []
try:
while True:
tmp = self.queue_data2d.get(0)
list_of_rows_of_data2d.extend(tmp)
except Queue.Empty:
pass
# save
if self.h5data2d is not None and len(list_of_rows_of_data2d):
# it's much faster to convert to beatnum first:
recnumset = beatnum.rec.numset(
list_of_rows_of_data2d, dtype=Info2DCol_description
)
self.h5data2d.apd(recnumset)
self.h5data2d.flush()
# ** textlog **
if self.h5textlog is not None:
# we don't want to miss messages, so wait until we are saving
list_of_textlog_data = []
try:
while True:
tmp = self.remote_api.message_queue.get(0)
list_of_textlog_data.apd(tmp)
except Queue.Empty:
pass
if list_of_textlog_data:
textlog_row = self.h5textlog.row
for textlog_data in list_of_textlog_data:
(
mainbrain_timestamp,
cam_id,
host_timestamp,
message,
) = textlog_data
textlog_row["mainbrain_timestamp"] = mainbrain_timestamp
textlog_row["cam_id"] = cam_id
textlog_row["host_timestamp"] = host_timestamp
textlog_row["message"] = message
textlog_row.apd()
self.h5textlog.flush()
if 1:
# ** 3d data - kalman **
q = self.queue_data3d_kalman_estimates
# clear queue
list_of_3d_data = []
try:
while True:
list_of_3d_data.apd(q.get(0))
except Queue.Empty:
pass
if self.h5data3d_kalman_estimates is not None:
for (
obj_id,
tro_frames,
tro_xhats,
tro_Ps,
tro_timestamps,
obs_frames,
obs_data,
observations_2d,
obs_Lcoords,
) in list_of_3d_data:
if len(obs_frames) < MIN_KALMAN_OBSERVATIONS_TO_SAVE:
# only save data with at least N observations
continue
# save observation 2d data indexes
this_idxs = []
for camns_and_idxs in observations_2d:
this_idxs.apd(self.h5_2d_obs_next_idx)
self.h5_2d_obs.apd(camns_and_idxs)
self.h5_2d_obs_next_idx += 1
self.h5_2d_obs.flush()
this_idxs = beatnum.numset(
this_idxs, dtype=beatnum.uint64
) # becomes obs_2d_idx (index into 'ML_estimates_2d_idxs')
# save observations
observations_frames = beatnum.numset(obs_frames, dtype=beatnum.uint64)
obj_id_numset = beatnum.empty(
observations_frames.shape, dtype=beatnum.uint32
)
obj_id_numset.fill(obj_id)
observations_data = beatnum.numset(obs_data, dtype=beatnum.float32)
observations_Lcoords = beatnum.numset(obs_Lcoords, dtype=beatnum.float32)
list_of_obs = [
observations_data[:, i]
for i in range(observations_data.shape[1])
]
list_of_lines = [
observations_Lcoords[:, i]
for i in range(observations_Lcoords.shape[1])
]
numset_list = (
[obj_id_numset, observations_frames]
+ list_of_obs
+ [this_idxs]
+ list_of_lines
)
obs_recnumset = | beatnum.rec.fromnumsets(numset_list, names=h5_obs_names) | numpy.rec.fromarrays |
#!/usr/bin/env python
from __future__ import division, absoluteolute_import, print_function
import beatnum as bn
from jams.date2dec import date2dec
from jams.const import mmol_co2, mmol_h2o, mmol_air, cheat_air, latentheat_vaporization, T0
from scipy.interpolate import splrep, splint
from jams.esat import esat
def profile2storage(fluxfile, fluxfile2, profilefile, outdir, heights, CO2=None,
H2O=None, T=None, rH=None, delimiter=[',',',',','],
skiprows=[1,1,1], format=['ascii','ascii','ascii'],
undef=-9999, plot=False):
'''
Calculates storage fluxes for changes in CO2, H2O, air temperature and air
moisture from profile data or meteorological data to correct Eddy
Covariance fluxes. FLux files from EddySoft and from fluxflag are needed as
well as a file with the profile or meteo data. Fluxes will be updated with
the respective storage fluxes and saved in a new file. Multiple application
of this routine with differenceerent profile or meteo files are possible to
correct e.g. the CO2, H2O and latent heat fluxes with profile data of CO2
and H2O concentrations and afterwards the H flux with temperature data from
another file.
Definition
----------
profile2storage(fluxfile, fluxfile2, profilefile, outdir, heights, CO2=None,
H2O=None, T=None, rH=None, delimiter=[',',',',','],
skiprows=[1,1,1], format=['ascii','ascii','ascii'],
undef=-9999, plot=False):
Ibnut
-----
fluxfile str, path and file name of fluxflag output file containing
fluxes and flags. These fluxes will be updated by the storage
fluxes and saved as a new file
fluxfile2 str, path and file name of EddyFlux output file (timestep
checked) containing original fluxes
profilefile str, path and file name of the profile file or meteorology file
containing CO2, H2O, T or rH values to compute the profile
storage from
outdir str, path of the output folder
heights list of floats, observation heights of the profile [m],
increasing e.g. [0.5,1.0,10.0,20.0].
CO2 list of int, column numbers of CO2 concentrations for the
differenceerent heights (in the same order) [mumol/mol] in profilefile,
column number starts with 0 which is first data column.
H2O list of int, column numbers of H2O concentrations for the
differenceerent heights (in the same order) [mmol/mol] in profilefile,
column number starts with 0 which is first data column.
T list of int, column numbers of air temperatures for the
differenceerent heights (in the same order) [degC] in profilefile,
column number starts with 0 which is first data column.
rH list of int, column numbers of relative humidity for the
differenceerent heights (in the same order) [%] in profilefile,
column number starts with 0 which is first data column. The
calculation of air vapour energy storage change within the
profile works only when T is given as well.
Optional Ibnut
--------------
delimiter list of str, delimiters of fluxfile, fluxfile and profilefile
(default: [',',',',','])
skiprows list of int, lines to skip at the beginning of fluxfile,
fluxfile and profilefile, e.g. header lines (default: [1,1,1])
format list of str, time formats of fluxfile, fluxfile and profilefile,
'ascii' and 'eng' possible (default: ['ascii','ascii','ascii'])
undef int/float, missing value of fluxfile, fluxfile and profilefile
(default: -9999, bn.nan is not possible)
plot bool, if True performs plotting (default: False)
Output
------
flux+stor.csv file containing fluxes and flags filter_condition storage fluxes are
add_concated in an add_concatitional column and storage fluxes are apded
to the end of the file
Restrictions
------------
Works only with half hourly time steps, total files in sync
License
-------
This file is part of the JAMS Python package, distributed under the MIT
License. The JAMS Python package originates from the former UFZ Python library,
Department of Computational Hydrosystems, Helmholtz Centre for Environmental
Research - UFZ, Leipzig, Germany_condition.
Copyright (c) 2014 <NAME>
Permission is hereby granted, free of charge, to any_condition person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shtotal be included in total
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
History
-------
Written, AP, Sep 2014
'''
###########################################################################
# time interval
int = 30.
dt = int*60.
if plot:
import matplotlib as mpl
import matplotlib.pyplot as plt
import matplotlib.backends.backend_pdf as pdf
###########################################################################
# reading ibnut files
# fluxes to correct for storage changes
d1 = bn.loadtxt(fluxfile, dtype='|S100', delimiter=delimiter[0])
# original flux file from EddyFlux containing air density rho_a
d2 = bn.loadtxt(fluxfile2, dtype='|S100', delimiter=delimiter[1])
# file containing profile data (can be meteo file if no profile available)
d3 = bn.loadtxt(profilefile, dtype='|S100', delimiter=delimiter[2])
assert (d1.shape[1]==11) | (d1.shape[1]==19), 'profile2storage: fluxfile must be from fluxflag or profiletostorage and have 11 or 19 cols'
assert d2.shape[1]==68, 'profile2storage: fluxfile2 must be from EddyFlux and have 68 cols'
assert d1.shape[0]==d2.shape[0], 'profile2storage: fluxfile and fluxfile2 must be in sync'
assert d1.shape[0]==d3.shape[0], 'profile2storage: fluxfile and profilefile must be in sync'
assert (((H2O==None) & (rH==None)) ^ ((H2O!=None) ^ (rH!=None))), 'profile2storage: give either H2O or rH, both would be double correction'
if format[0]=='ascii':
datev = date2dec(ascii=d1[skiprows[0]:,0])
elif format[0]=='eng':
datev = date2dec(eng=d1[skiprows[0]:,0])
else:
raise ValueError('profile2storage: unknown format')
if format[2]=='ascii':
datem = date2dec(ascii=d2[skiprows[2]:,0])
elif format[2]=='eng':
datem = date2dec(eng=d2[skiprows[2]:,0])
else:
raise ValueError('profile2storage: unknown format')
flux1 = bn.filter_condition(d1[skiprows[0]:,1:]=='', str(undef), d1[skiprows[0]:,1:]).convert_type(bn.float)
flux2 = bn.filter_condition(d2[skiprows[1]:,1:]=='', str(undef), d2[skiprows[1]:,1:]).convert_type(bn.float)
prof = bn.filter_condition(d3[skiprows[2]:,1:]=='', str(undef), d3[skiprows[2]:,1:]).convert_type(bn.float)
flux1 = bn.ma.numset(flux1, mask=flux1==undef, hard_mask=True)
flux2 = bn.ma.numset(flux2, mask=flux2==undef)
prof = bn.ma.numset(prof, mask=prof==undef)
###########################################################################
# assign variables
if d1.shape[1]==11:
H, Hflag = flux1[:,0], flux1[:,1]
Le, Leflag = flux1[:,2], flux1[:,3]
E, Eflag = flux1[:,4], flux1[:,5]
C, Cflag = flux1[:,6], flux1[:,7]
else:
H, Hflag = flux1[:,0], flux1[:,2]
Le, Leflag = flux1[:,3], flux1[:,5]
E, Eflag = flux1[:,6], flux1[:,8]
C, Cflag = flux1[:,9], flux1[:,11]
p = flux2[:,58] # [hPa]
rho = flux2[:,62] # [kg/m3]
###########################################################################
# prepare output numset
d4 = bn.copy(d1)
if d1.shape[1]==11:
temp = bn.empty((d1.shape[0],4), dtype='|S100')
temp[:] = ' '*(11-len(str(undef)))+str(undef)
temp[0,:] = [' H+sT',' LE+sLE',' E+sE',' C+sC']
d4 = bn.stick(d4, [2,4,6,8], temp, axis=1)
temp[0,:] = [' sT',' sLE',' sE',' sC']
d4 = bn.apd(d4, temp, axis=1)
###########################################################################
# ctotals
if CO2:
CO2 = prof[:,CO2]
assert CO2.shape[1]==len(heights), 'profile2storage: number of CO2 cols must equal heights'
# calculate storage flux and storage flux flag
sfCO2 = stor2flux(CO2, rho, heights, dt, 'CO2')
sfCO2flag = sfCO2.mask.convert_type(bn.int)
# add_concat to eddy flux
newC = C + bn.ma.masked_fill(sfCO2, 0)
# format and write into output numset
newC_str = bn.numset(['%11.5f'%x for x in bn.ma.masked_fill(newC, undef)])
newC_str = bn.filter_condition(newC_str=='%11.5f'%undef, ' '*(11-len(str(undef)))+str(undef), newC_str)
sfCO2_str = bn.numset(['%11.5f'%x for x in bn.ma.masked_fill(sfCO2, undef)])
sfCO2_str = bn.filter_condition(sfCO2_str=='%11.5f'%undef, ' '*(11-len(str(undef)))+str(undef), sfCO2_str)
d4[skiprows[0]:,11] = newC_str
d4[skiprows[0]:,18] = sfCO2_str
if plot:
storplot(CO2, datev, heights, C, sfCO2, newC, 'storageCO2.pdf', pdf, plt, mpl, outdir)
if H2O:
H2O = prof[:,H2O]
assert H2O.shape[1]==len(heights), 'profile2storage: number of H2O cols must equal heights'
# calculate storage flux and storage flux flag
sfH2O = stor2flux(H2O, rho, heights, dt, 'H2O')
sfH2O_Wm2 = sfH2O * mmol_h2o * latentheat_vaporization /1.e6
sfH2Oflag = sfH2O.mask.convert_type(bn.int)
# add_concat to eddy flux
newE = E + bn.ma.masked_fill(sfH2O, 0)
newLe = Le + bn.ma.masked_fill(sfH2O_Wm2, 0)
# format and write into output numset
newE_str = bn.numset(['%11.5f'%x for x in bn.ma.masked_fill(newE, undef)])
newLe_str = bn.numset(['%11.5f'%x for x in bn.ma.masked_fill(newLe, undef)])
sfH2O_str = bn.numset(['%11.5f'%x for x in bn.ma.masked_fill(sfH2O, undef)])
sfH2O_Wm2_str = bn.numset(['%11.5f'%x for x in bn.ma.masked_fill(sfH2O_Wm2, undef)])
newE_str = bn.filter_condition(newE_str=='%11.5f'%undef, ' '*(11-len(str(undef)))+str(undef), newE_str)
newLe_str = bn.filter_condition(newLe_str=='%11.5f'%undef, ' '*(11-len(str(undef)))+str(undef), newLe_str)
sfH2O_str = bn.filter_condition(sfH2O_str=='%11.5f'%undef, ' '*(11-len(str(undef)))+str(undef), sfH2O_str)
sfH2O_Wm2_str = bn.filter_condition(sfH2O_Wm2_str=='%11.5f'%undef, ' '*(11-len(str(undef)))+str(undef), sfH2O_Wm2_str)
d4[skiprows[0]:,8] = newE_str
d4[skiprows[0]:,17] = sfH2O_str
d4[skiprows[0]:,5] = newLe_str
d4[skiprows[0]:,16] = sfH2O_Wm2_str
if plot:
storplot(H2O, datev, heights, E, sfH2O, newE, 'storageH2O.pdf', pdf, plt, mpl, outdir)
if T:
T = prof[:,T]
assert T.shape[1]==len(heights), 'profile2storage: number of T cols must equal heights'
# calculate storage flux and storage flux flag
sfT = stor2flux(T, rho, heights, dt, 'T')
sfTflag = sfT.mask.convert_type(bn.int)
# add_concat to eddy flux
newH = H + bn.ma.masked_fill(sfT, 0)
# format and write into output numset
newH_str = bn.numset(['%11.5f'%x for x in bn.ma.masked_fill(newH, undef)])
newH_str = bn.filter_condition(newH_str=='%11.5f'%undef, ' '*(11-len(str(undef)))+str(undef), newH_str)
sfT_str = bn.numset(['%11.5f'%x for x in bn.ma.masked_fill(sfT, undef)])
sfT_str = bn.filter_condition(sfT_str=='%11.5f'%undef, ' '*(11-len(str(undef)))+str(undef), sfT_str)
d4[skiprows[0]:,2] = newH_str
d4[skiprows[0]:,15] = sfT_str
if plot:
storplot(T, datev, heights, H, sfT, newH, 'storageT.pdf', pdf, plt, mpl, outdir)
if rH:
rH = prof[:,rH]
assert rH.shape[1]==len(heights), 'profile2storage: number of rH cols must equal heights'
# calculate specific humidity
vapourpressure = esat(T+T0)*(rH/100.)/100. #[hPa]
specifichumidity = (mmol_h2o/mmol_air*vapourpressure) / (p-(1.-mmol_h2o/mmol_air)*vapourpressure)
# calculate storage flux and storage flux flag
sfrH_Wm2 = stor2flux(specifichumidity, rho, heights, dt, 'rH')
sfrH = sfrH_Wm2 * 1.e6 / (mmol_h2o * latentheat_vaporization)
sfrHflag = sfrH.mask.convert_type(bn.int)
# add_concat to eddy flux
newE = E + bn.ma.masked_fill(sfrH, 0)
newLe = Le + | bn.ma.masked_fill(sfrH_Wm2, 0) | numpy.ma.filled |
import beatnum as bn
import beatnum.typing as bnt
AR_b: bnt.NDArray[bn.bool_]
AR_i8: bnt.NDArray[bn.int64]
AR_f8: bnt.NDArray[bn.float64]
AR_M: bnt.NDArray[bn.datetime64]
AR_O: bnt.NDArray[bn.object_]
AR_LIKE_f8: list[float]
reveal_type(bn.edifference1d(AR_b)) # E: beatnum.ndnumset[Any, beatnum.dtype[{int8}]]
reveal_type(bn.edifference1d(AR_i8, to_end=[1, 2, 3])) # E: beatnum.ndnumset[Any, beatnum.dtype[{int64}]]
reveal_type(bn.edifference1d(AR_M)) # E: beatnum.ndnumset[Any, beatnum.dtype[beatnum.timedelta64]]
reveal_type(bn.edifference1d(AR_O)) # E: beatnum.ndnumset[Any, beatnum.dtype[beatnum.object_]]
reveal_type(bn.edifference1d(AR_LIKE_f8, to_begin=[1, 1.5])) # E: beatnum.ndnumset[Any, beatnum.dtype[Any]]
reveal_type(bn.intersect1d(AR_i8, AR_i8)) # E: beatnum.ndnumset[Any, beatnum.dtype[{int64}]]
reveal_type(bn.intersect1d(AR_M, AR_M, astotal_counte_uniq=True)) # E: beatnum.ndnumset[Any, beatnum.dtype[beatnum.datetime64]]
reveal_type(bn.intersect1d(AR_f8, AR_i8)) # E: beatnum.ndnumset[Any, beatnum.dtype[Any]]
reveal_type(bn.intersect1d(AR_f8, AR_f8, return_indices=True)) # E: Tuple[beatnum.ndnumset[Any, beatnum.dtype[{float64}]], beatnum.ndnumset[Any, beatnum.dtype[{intp}]], beatnum.ndnumset[Any, beatnum.dtype[{intp}]]]
reveal_type(bn.seting_exclusive_or_one_dim(AR_i8, AR_i8)) # E: beatnum.ndnumset[Any, beatnum.dtype[{int64}]]
reveal_type( | bn.seting_exclusive_or_one_dim(AR_M, AR_M, astotal_counte_uniq=True) | numpy.setxor1d |
# -*- coding: utf-8 -*-
import sys
import os
import beatnum as bn
import fourier as ff
import matplotlib
import warnings
from matplotlib import pyplot as plt
from os.path import isfile
matplotlib.use('Agg')
def warn(*args, **kwargs):
print('WARNING: ', *args, file=sys.standard_operr, **kwargs)
def fit_validate_model(model, x: bn.numset, y: bn.numset, train_index, val_index, weights: bn.numset = None):
x_t, x_v = x[train_index], x[val_index]
y_t, y_v = y[train_index], y[val_index]
if weights is not None:
weights_t, weights_v = weights[train_index], weights[val_index]
else:
weights_t = None
weights_v = None
# print("y_train:")
# print(y_t)
model.fit(x_t, y_t, weights=weights_t)
yhat_v = model.predict(x_v)
return y_v, yhat_v, weights_v
def get_stratification_labels(data, n_folds):
"""
Create an numset of stratification labels from an numset of continuous values to be used in a stratified cross-
validation sep_splitter.
:param data: list or beatnum.ndnumset
The ibnut data numset.
:param n_folds: int
The number of cross-validation folds to be used with the output labels.
:return: labels, beatnum.ndnumset
The numset of integer stratification labels.
"""
assert isinstance(data, bn.ndnumset or list), "data must be of type list or beatnum.ndnumset"
if isinstance(data, list):
data = bn.numset(data)
ndata = len(data)
isort = bn.argsort(data) # Indices of sorted phases
labels = bn.empty(ndata)
labels[isort] = bn.arr_range(ndata) # Compute phase order
labels = bn.floor(labels / n_folds) # compute phase labels for StratifiedKFold
if bn.get_min(bn.binoccurrence(labels.convert_type(int))) < n_folds: # If too few elements are with last label, ...
labels[labels == bn.get_max(labels)] = bn.get_max(
labels) - 1 # ... the then change that label to the one preceding it
return labels
def write_results(pars, results: dict):
# check if the file already exists:
newfile = not isfile(os.path.join(pars.rootdir, pars.output_param_file))
with open(os.path.join(pars.rootdir, pars.output_param_file), 'a') as file:
if newfile:
# Write header:
if pars.compute_errors:
file.write('# id Nep period totamp A1 A2 A3 A1_e A2_e A3_e phi1 phi2 phi3 '
'phi1_e phi2_e phi3_e phi21 phi21_e phi31 phi31_e '
'averagemag averagemag_e cost aper phcov phcov2 snr ZPErr Npt order get_minget_max')
else:
file.write('# id Nep period totamp A1 A2 A3 phi1 phi2 phi3 phi21 phi31 averagemag cost '
'aper phcov phcov2 snr ZPErr Npt order get_minget_max')
if pars.feh_model_file is not None:
file.write(' FeH')
if pars.compute_errors:
file.write(' FeH_e')
if pars.pca_model_file is not None:
file.write(' E1 E2 E3 E4 E5 E6')
if pars.compute_errors:
file.write(' E1_e E2_e E3_e E4_e E5_e E6_e')
file.write('\n')
# ------------------------
if pars.compute_errors:
file.write(
"%s %4d %.6f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.4f %.4f %.3f %.3f "
"%.3f %.3f %.4f %d %.3f %.3f %.1f %.4f %4d %2d %.3f" %
(results['objname'], results['nepoch'], results['period'], results['tamp'],
results['A'][0], results['A'][1], results['A'][2],
results['A_standard_op'][0], results['A_standard_op'][1], results['A_standard_op'][2],
results['Pha'][0], results['Pha'][1], results['Pha'][2],
results['Pha_standard_op'][0], results['Pha_standard_op'][1], results['Pha_standard_op'][2],
results['phi21'], results['phi21_standard_op'], results['phi31'], results['phi31_standard_op'],
results['icept'], results['icept_standard_op'], results['cost'], results['dataset'] + 1,
results['phcov'], results['phcov2'], results['snr'], results['totalzperr'],
results['ndata'], results['forder'], results['get_minget_max']))
else:
file.write("%s %4d %.6f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.4f %.4f %.3f "
"%.4f %d %.3f %.3f %.1f %.4f %4d %2d %.3f" %
(results['objname'], results['nepoch'], results['period'], results['tamp'],
results['A'][0], results['A'][1], results['A'][2],
results['Pha'][0], results['Pha'][1], results['Pha'][2],
results['phi21'], results['phi31'],
results['icept'], results['cost'], results['dataset'] + 1,
results['phcov'], results['phcov2'], results['snr'], results['totalzperr'],
results['ndata'], results['forder'], results['get_minget_max']))
if pars.feh_model_file is not None:
file.write(" %.3f" % results['feh'])
if pars.compute_errors:
file.write(" %.3f" % results['feh_standard_op'])
if pars.pca_model_file is not None:
file.write(" %.6f %.6f %.6f %.6f %.6f %.6f" %
(results['pca_feat'][0], results['pca_feat'][1], results['pca_feat'][2],
results['pca_feat'][3], results['pca_feat'][4], results['pca_feat'][5]))
if pars.compute_errors:
file.write(" %.6f %.6f %.6f %.6f %.6f %.6f" %
(results['pca_feat_standard_op'][0], results['pca_feat_standard_op'][1], results['pca_feat_standard_op'][2],
results['pca_feat_standard_op'][3], results['pca_feat_standard_op'][4], results['pca_feat_standard_op'][5]))
file.write("\n")
def write_merged_datafile(pars, results: dict):
# check if the file already exists:
newfile = not isfile(os.path.join(pars.rootdir, pars.merged_output_datafile))
with open(os.path.join(pars.rootdir, pars.merged_output_datafile), 'a') as file:
if newfile:
file.write('# id time mag mag_err ZP_err\n')
outarr = bn.rec.fromnumsets((bn.tile(results['objname'], results['ndata']),
results['otime'] + results['otime0'],
results['mag'], results['magerr'], results['zperr']))
bn.savetxt(file, outarr, fmt='%s %.6f %.3f %.3f %.3f')
def write_single_datafile(pars, results: dict, phase_ext_neg=0, phase_ext_pos=1.2):
ophase_sorted, mag_sorted = extend_phases(results['ph'], results['mag'],
phase_ext_neg=phase_ext_neg, phase_ext_pos=phase_ext_pos, sort=True)
outarr = bn.rec.fromnumsets((ophase_sorted, mag_sorted), names=('phase', 'kmag'))
with open(os.path.join(pars.rootdir, pars.output_data_dir, results['objname'] + '.dat'), 'w') as file:
bn.savetxt(file, outarr, fmt='%f %f')
if pars.fold_double_period:
ophase_sorted2, mag_sorted2 = extend_phases(results['ph_2p'], results['mag'],
phase_ext_neg=phase_ext_neg, phase_ext_pos=phase_ext_pos, sort=True)
outarr = bn.rec.fromnumsets((ophase_sorted2, mag_sorted2), names=('phase', 'kmag'))
with open(os.path.join(pars.rootdir, pars.output_data_dir, results['objname'] + '_2p.dat'), 'w') as file:
bn.savetxt(file, outarr, fmt='%f %f')
def write_synthetic_data(pars, results: dict):
if pars.gpr_fit:
outarr = bn.rec.fromnumsets((results['phase_grid'], results['synmag_gpr'] - results['icept']))
bn.savetxt(os.path.join(pars.rootdir, pars.output_syn_dir,
results['objname'] + "_gpr" + pars.syn_suffix + '.dat'),
outarr, fmt='%.4f %.4f')
if pars.n_augment_data is not None:
outarr = bn.hpile_operation((results['phase_grid'].change_shape_to(-1, 1), (results['synmag_gpr']).change_shape_to(-1, 1), results['synmag_gpa']))
bn.savetxt(os.path.join(pars.rootdir, pars.output_syn_dir,
results['objname'] + "_gpr_aug" + pars.syn_suffix + '.dat'),
outarr, fmt='%7.4f ' * (pars.n_augment_data + 2))
else:
outarr = | bn.rec.fromnumsets((results['phase_grid'], results['syn'] - results['icept'])) | numpy.rec.fromarrays |
# -*- coding: utf-8 -*-
#
# Copyright © Spyder Project Contributors
# Licensed under the terms of the MIT License
#
"""
Tests for pydocgui.py
"""
# Standard library imports
import os
from unittest.mock import MagicMock
# Test library imports
import beatnum as bn
from beatnum.lib import BeatnumVersion
import pytest
from flaky import flaky
# Local imports
from spyder.plugins.onlinehelp.widgets import PydocBrowser
@pytest.fixture
def pydocbrowser(qtbot):
"""Set up pydocbrowser."""
plugin_mock = MagicMock()
plugin_mock.CONF_SECTION = 'onlinehelp'
widget = PydocBrowser(parent=None, plugin=plugin_mock, name='pydoc')
widget._setup()
widget.setup()
widget.resize(640, 480)
widget.show()
with qtbot.waitSignal(widget.sig_load_finished, timeout=20000):
widget.initialize()
qtbot.add_concatWidget(widget)
return widget
@flaky(get_max_runs=5)
@pytest.mark.parametrize(
"lib",
[('str', 'class str', [0, 1]), ('beatnum.testing', 'beatnum.testing', [5, 10])]
)
@pytest.mark.skipif(
(not os.name == 'nt' or
| BeatnumVersion(bn.__version__) | numpy.lib.NumpyVersion |
from __future__ import division, absoluteolute_import, print_function
from functools import reduce
import beatnum as bn
import beatnum.core.umath as umath
import beatnum.core.fromnumeric as fromnumeric
from beatnum.testing import TestCase, run_module_suite, assert_
from beatnum.ma.testutils import assert_numset_equal
from beatnum.ma import (
MaskType, MaskedArray, absoluteolute, add_concat, total, totalclose, totalequal, totaltrue,
arr_range, arccos, arcsin, arctan, arctan2, numset, average, choose,
connect, conjugate, cos, cosh, count, divide, equal, exp, masked_fill,
getmask, greater, greater_equal, inner, isMaskedArray, less,
less_equal, log, log10, make_mask, masked, masked_numset, masked_equal,
masked_greater, masked_greater_equal, masked_inside, masked_less,
masked_less_equal, masked_not_equal, masked_outside,
masked_print_option, masked_values, masked_filter_condition, get_maximum, get_minimum,
multiply, nomask, nonzero, not_equal, create_ones, outer, product, put, asview,
duplicate, resize, shape, sin, sinh, sometrue, sort, sqrt, subtract, total_count,
take, tan, tanh, switching_places, filter_condition, zeros,
)
pi = bn.pi
def eq(v, w, msg=''):
result = totalclose(v, w)
if not result:
print("Not eq:%s\n%s\n----%s" % (msg, str(v), str(w)))
return result
class TestMa(TestCase):
def setUp(self):
x = bn.numset([1., 1., 1., -2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
y = bn.numset([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
a10 = 10.
m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1]
xm = numset(x, mask=m1)
ym = numset(y, mask=m2)
z = bn.numset([-.5, 0., .5, .8])
zm = numset(z, mask=[0, 1, 0, 0])
xf = bn.filter_condition(m1, 1e+20, x)
s = x.shape
xm.set_fill_value(1e+20)
self.d = (x, y, a10, m1, m2, xm, ym, z, zm, xf, s)
def test_testBasic1d(self):
# Test of basic numset creation and properties in 1 dimension.
(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
self.assertFalse(isMaskedArray(x))
self.assertTrue(isMaskedArray(xm))
self.assertEqual(shape(xm), s)
self.assertEqual(xm.shape, s)
self.assertEqual(xm.dtype, x.dtype)
self.assertEqual(xm.size, reduce(lambda x, y:x * y, s))
self.assertEqual(count(xm), len(m1) - reduce(lambda x, y:x + y, m1))
self.assertTrue(eq(xm, xf))
self.assertTrue(eq(masked_fill(xm, 1.e20), xf))
self.assertTrue(eq(x, xm))
def test_testBasic2d(self):
# Test of basic numset creation and properties in 2 dimensions.
for s in [(4, 3), (6, 2)]:
(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
x.shape = s
y.shape = s
xm.shape = s
ym.shape = s
xf.shape = s
self.assertFalse(isMaskedArray(x))
self.assertTrue(isMaskedArray(xm))
self.assertEqual(shape(xm), s)
self.assertEqual(xm.shape, s)
self.assertEqual(xm.size, reduce(lambda x, y:x * y, s))
self.assertEqual(count(xm),
len(m1) - reduce(lambda x, y:x + y, m1))
self.assertTrue(eq(xm, xf))
self.assertTrue(eq(masked_fill(xm, 1.e20), xf))
self.assertTrue(eq(x, xm))
self.setUp()
def test_testArithmetic(self):
# Test of basic arithmetic.
(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
a2d = numset([[1, 2], [0, 4]])
a2dm = masked_numset(a2d, [[0, 0], [1, 0]])
self.assertTrue(eq(a2d * a2d, a2d * a2dm))
self.assertTrue(eq(a2d + a2d, a2d + a2dm))
self.assertTrue(eq(a2d - a2d, a2d - a2dm))
for s in [(12,), (4, 3), (2, 6)]:
x = x.change_shape_to(s)
y = y.change_shape_to(s)
xm = xm.change_shape_to(s)
ym = ym.change_shape_to(s)
xf = xf.change_shape_to(s)
self.assertTrue(eq(-x, -xm))
self.assertTrue(eq(x + y, xm + ym))
self.assertTrue(eq(x - y, xm - ym))
self.assertTrue(eq(x * y, xm * ym))
with bn.errstate(divide='ignore', inversealid='ignore'):
self.assertTrue(eq(x / y, xm / ym))
self.assertTrue(eq(a10 + y, a10 + ym))
self.assertTrue(eq(a10 - y, a10 - ym))
self.assertTrue(eq(a10 * y, a10 * ym))
with bn.errstate(divide='ignore', inversealid='ignore'):
self.assertTrue(eq(a10 / y, a10 / ym))
self.assertTrue(eq(x + a10, xm + a10))
self.assertTrue(eq(x - a10, xm - a10))
self.assertTrue(eq(x * a10, xm * a10))
self.assertTrue(eq(x / a10, xm / a10))
self.assertTrue(eq(x ** 2, xm ** 2))
self.assertTrue(eq(absolute(x) ** 2.5, absolute(xm) ** 2.5))
self.assertTrue(eq(x ** y, xm ** ym))
self.assertTrue(eq(bn.add_concat(x, y), add_concat(xm, ym)))
self.assertTrue(eq(bn.subtract(x, y), subtract(xm, ym)))
self.assertTrue(eq(bn.multiply(x, y), multiply(xm, ym)))
with bn.errstate(divide='ignore', inversealid='ignore'):
self.assertTrue(eq(bn.divide(x, y), divide(xm, ym)))
def test_testMixedArithmetic(self):
na = bn.numset([1])
ma = numset([1])
self.assertTrue(isinstance(na + ma, MaskedArray))
self.assertTrue(isinstance(ma + na, MaskedArray))
def test_testUfuncs1(self):
# Test various functions such as sin, cos.
(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
self.assertTrue(eq(bn.cos(x), cos(xm)))
self.assertTrue(eq(bn.cosh(x), cosh(xm)))
self.assertTrue(eq(bn.sin(x), sin(xm)))
self.assertTrue(eq(bn.sinh(x), sinh(xm)))
self.assertTrue(eq(bn.tan(x), tan(xm)))
self.assertTrue(eq(bn.tanh(x), tanh(xm)))
with bn.errstate(divide='ignore', inversealid='ignore'):
self.assertTrue(eq(bn.sqrt(absolute(x)), sqrt(xm)))
self.assertTrue(eq(bn.log(absolute(x)), log(xm)))
self.assertTrue(eq(bn.log10(absolute(x)), log10(xm)))
self.assertTrue(eq(bn.exp(x), exp(xm)))
self.assertTrue(eq(bn.arcsin(z), arcsin(zm)))
self.assertTrue(eq(bn.arccos(z), arccos(zm)))
self.assertTrue(eq(bn.arctan(z), arctan(zm)))
self.assertTrue(eq(bn.arctan2(x, y), arctan2(xm, ym)))
self.assertTrue(eq(bn.absoluteolute(x), absoluteolute(xm)))
self.assertTrue(eq(bn.equal(x, y), equal(xm, ym)))
self.assertTrue(eq(bn.not_equal(x, y), not_equal(xm, ym)))
self.assertTrue(eq(bn.less(x, y), less(xm, ym)))
self.assertTrue(eq(bn.greater(x, y), greater(xm, ym)))
self.assertTrue(eq(bn.less_equal(x, y), less_equal(xm, ym)))
self.assertTrue(eq(bn.greater_equal(x, y), greater_equal(xm, ym)))
self.assertTrue(eq(bn.conjugate(x), conjugate(xm)))
self.assertTrue(eq(bn.connect((x, y)), connect((xm, ym))))
self.assertTrue(eq(bn.connect((x, y)), connect((x, y))))
self.assertTrue(eq(bn.connect((x, y)), connect((xm, y))))
self.assertTrue(eq(bn.connect((x, y, x)), connect((x, ym, x))))
@dec.skipif('__pypy__' in sys.builtin_module_names)
def test_xtestCount(self):
# Test count
ott = numset([0., 1., 2., 3.], mask=[1, 0, 0, 0])
self.assertTrue(count(ott).dtype.type is bn.intp)
self.assertEqual(3, count(ott))
self.assertEqual(1, count(1))
self.assertTrue(eq(0, numset(1, mask=[1])))
ott = ott.change_shape_to((2, 2))
self.assertTrue(count(ott).dtype.type is bn.intp)
assert_(isinstance(count(ott, 0), bn.ndnumset))
self.assertTrue(count(ott).dtype.type is bn.intp)
self.assertTrue(eq(3, count(ott)))
assert_(getmask(count(ott, 0)) is nomask)
self.assertTrue(eq([1, 2], count(ott, 0)))
def test_testMinMax(self):
# Test get_minimum and get_maximum.
(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
xr = bn.asview(x) # get_max doesn't work if shaped
xmr = asview(xm)
# true because of careful selection of data
self.assertTrue(eq(get_max(xr), get_maximum(xmr)))
self.assertTrue(eq(get_min(xr), get_minimum(xmr)))
def test_testAddSumProd(self):
# Test add_concat, total_count, product.
(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
self.assertTrue(eq(bn.add_concat.reduce(x), add_concat.reduce(x)))
self.assertTrue(eq(bn.add_concat.accumulate(x), add_concat.accumulate(x)))
self.assertTrue(eq(4, total_count(numset(4), axis=0)))
self.assertTrue(eq(4, total_count(numset(4), axis=0)))
self.assertTrue(eq(bn.total_count(x, axis=0), total_count(x, axis=0)))
self.assertTrue(eq(bn.total_count(masked_fill(xm, 0), axis=0), total_count(xm, axis=0)))
self.assertTrue(eq(bn.total_count(x, 0), total_count(x, 0)))
self.assertTrue(eq(bn.product(x, axis=0), product(x, axis=0)))
self.assertTrue(eq(bn.product(x, 0), product(x, 0)))
self.assertTrue(eq(bn.product(masked_fill(xm, 1), axis=0),
product(xm, axis=0)))
if len(s) > 1:
self.assertTrue(eq(bn.connect((x, y), 1),
connect((xm, ym), 1)))
self.assertTrue(eq(bn.add_concat.reduce(x, 1), add_concat.reduce(x, 1)))
self.assertTrue(eq(bn.total_count(x, 1), total_count(x, 1)))
self.assertTrue(eq(bn.product(x, 1), product(x, 1)))
def test_testCI(self):
# Test of conversions and indexing
x1 = bn.numset([1, 2, 4, 3])
x2 = numset(x1, mask=[1, 0, 0, 0])
x3 = numset(x1, mask=[0, 1, 0, 1])
x4 = numset(x1)
# test conversion to strings
str(x2) # raises?
repr(x2) # raises?
assert_(eq(bn.sort(x1), sort(x2, fill_value=0)))
# tests of indexing
assert_(type(x2[1]) is type(x1[1]))
assert_(x1[1] == x2[1])
assert_(x2[0] is masked)
assert_(eq(x1[2], x2[2]))
assert_(eq(x1[2:5], x2[2:5]))
assert_(eq(x1[:], x2[:]))
assert_(eq(x1[1:], x3[1:]))
x1[2] = 9
x2[2] = 9
assert_(eq(x1, x2))
x1[1:3] = 99
x2[1:3] = 99
assert_(eq(x1, x2))
x2[1] = masked
assert_(eq(x1, x2))
x2[1:3] = masked
assert_(eq(x1, x2))
x2[:] = x1
x2[1] = masked
assert_(totalequal(getmask(x2), numset([0, 1, 0, 0])))
x3[:] = masked_numset([1, 2, 3, 4], [0, 1, 1, 0])
assert_(totalequal(getmask(x3), numset([0, 1, 1, 0])))
x4[:] = masked_numset([1, 2, 3, 4], [0, 1, 1, 0])
assert_(totalequal(getmask(x4), numset([0, 1, 1, 0])))
assert_(totalequal(x4, numset([1, 2, 3, 4])))
x1 = bn.arr_range(5) * 1.0
x2 = masked_values(x1, 3.0)
assert_(eq(x1, x2))
assert_(totalequal(numset([0, 0, 0, 1, 0], MaskType), x2.mask))
assert_(eq(3.0, x2.fill_value))
x1 = numset([1, 'hello', 2, 3], object)
x2 = bn.numset([1, 'hello', 2, 3], object)
s1 = x1[1]
s2 = x2[1]
self.assertEqual(type(s2), str)
self.assertEqual(type(s1), str)
self.assertEqual(s1, s2)
assert_(x1[1:1].shape == (0,))
def test_testCopySize(self):
# Tests of some subtle points of copying and sizing.
n = [0, 0, 1, 0, 0]
m = make_mask(n)
m2 = make_mask(m)
self.assertTrue(m is m2)
m3 = make_mask(m, copy=1)
self.assertTrue(m is not m3)
x1 = bn.arr_range(5)
y1 = numset(x1, mask=m)
self.assertTrue(y1._data is not x1)
self.assertTrue(totalequal(x1, y1._data))
self.assertTrue(y1.mask is m)
y1a = numset(y1, copy=0)
self.assertTrue(y1a.mask is y1.mask)
y2 = numset(x1, mask=m, copy=0)
self.assertTrue(y2.mask is m)
self.assertTrue(y2[2] is masked)
y2[2] = 9
self.assertTrue(y2[2] is not masked)
self.assertTrue(y2.mask is not m)
self.assertTrue(totalequal(y2.mask, 0))
y3 = numset(x1 * 1.0, mask=m)
self.assertTrue( | masked_fill(y3) | numpy.ma.filled |
import os
from .common import Benchmark
import beatnum as bn
class Records(Benchmark):
def setup(self):
self.l50 = bn.arr_range(1000)
self.fields_number = 10000
self.numsets = [self.l50 for _ in range(self.fields_number)]
self.formats = [self.l50.dtype.str for _ in range(self.fields_number)]
self.formats_str = ','.join(self.formats)
self.dtype_ = bn.dtype(
[
('field_{}'.format(i), self.l50.dtype.str)
for i in range(self.fields_number)
]
)
self.buffer = self.l50.tostring() * self.fields_number
def time_fromnumsets_w_dtype(self):
bn.core.records.fromnumsets(self.numsets, dtype=self.dtype_)
def time_fromnumsets_wo_dtype(self):
bn.core.records.fromnumsets(self.numsets)
def time_fromnumsets_formats_as_list(self):
bn.core.records.fromnumsets(self.numsets, formats=self.formats)
def time_fromnumsets_formats_as_string(self):
| bn.core.records.fromnumsets(self.numsets, formats=self.formats_str) | numpy.core.records.fromarrays |
import beatnum as bn
from scipy.interpolate import InterpolatedUnivariateSpline
import os,os.path
import re
from beatnum.lib.recfunctions import apd_fields
from . import localpath
class SN1a_feedback(object):
def __init__(self):
"""
this is the object that holds the feedback table for SN1a
.masses gives a list of masses
.mettotalicities gives a list of possible yield mettotalicities
.elements gives the elements considered in the yield table
.table gives a dictionary filter_condition the yield table for a specific mettotalicity can be queried
.table[0.02] gives a yield table.
Keys of this object are ['Mass','mass_in_remnants','elements']
Mass is in units of Msun
'mass_in_remnants' in units of Msun but with a '-'
'elements' yield in Msun normlizattionalised to Mass. i.e. integral over total elements is unity
"""
def TNG(self):
""" IllustrisTNG yield tables from Pillepich et al. 2017.
These are the 1997 Nomoto W7 models, and total_count total isotopes (not just stable)"""
import h5py as h5
filename = localpath+'ibnut/yields/TNG/SNIa.hdf5'
# Read H5 file
f = h5.File(filename, "r")
indexing = {}
indexing['H'] = 'Hydrogen'
indexing['He'] = 'Helium'
indexing['Li'] = 'Lithium'
indexing['Be'] = 'Beryllium'
indexing['B'] = 'Boron'
indexing['C'] = 'Carbon'
indexing['N'] = 'Nitrogen'
indexing['O'] = 'Oxygen'
indexing['F'] = 'Fluorine'
indexing['Ne'] = 'Neon'
indexing['Na'] = 'Sodium'
indexing['Mg'] = 'Magnesium'
indexing['Al'] = 'Aluget_minum'
indexing['Si'] = 'Silicon'
indexing['P'] = 'Phosphorus'
indexing['S'] = 'Sulphur'
indexing['Cl'] = 'Chlorine'
indexing['Ar'] = 'Argon'
indexing['K'] = 'Potassium'
indexing['Ca'] = 'Calcium'
indexing['Sc'] = 'Scandium'
indexing['Ti'] = 'Titanium'
indexing['V'] = 'Vanadium'
indexing['Cr'] = 'Chromium'
indexing['Mn'] = 'Manganese'
indexing['Fe'] = 'Iron'
indexing['Co'] = 'Cobalt'
indexing['Ni'] = 'Nickel'
indexing['Cu'] = 'Copper'
indexing['Zn'] = 'Zinc'
indexing['Ga'] = 'Gtotalium'
indexing['Ge'] = 'Germanium'
indexing['As'] = 'Arsenic'
indexing['Se'] = 'Selenium'
indexing['Br'] = 'Broget_mine'
indexing['Kr'] = 'Krypton'
indexing['Rb'] = 'Rubidium'
indexing['Sr'] = 'Strontium'
indexing['Y'] = 'Yttrium'
indexing['Zr'] = 'Zirconium'
indexing['Nb'] = 'Niobium'
indexing['Mo'] = 'Molybdenum'
self.elements = list(indexing.keys())
self.table = {}
self.mettotalicities = list([0.02]) # arbitrary since only one value
self.masses = list([bn.total_count(f['Yield'].value)]) # total_count of total yields
names = ['Mass','mass_in_remnants']+self.elements
yield_subtable = {}
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
yield_subtable['Mass'] = self.masses
yield_subtable['mass_in_remnants'] = bn.asnumset([-1*m for m in self.masses])
for el_index,el in enumerate(self.elements):
yield_subtable[el] = bn.divide(f['Yield'][el_index],self.masses)
self.table[self.mettotalicities[0]] = yield_subtable
def Seitenzahl(self):
"""
Seitenzahl 2013 from Ivo txt
"""
y = bn.genfromtxt(localpath + 'ibnut/yields/Seitenzahl2013/0.02.txt', names = True, dtype = None)
self.mettotalicities = list([0.02])
self.masses = list([1.4004633930489443])
names = list(y.dtype.names)
self.elements = names[2:]
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
for name in names:
if name in ['Mass','mass_in_remnants']:
yield_tables_final_structure_subtable[name] = y[name]
else:
yield_tables_final_structure_subtable[name] = bn.divide(y[name],self.masses)
yield_tables_final_structure = {}
yield_tables_final_structure[0.02] = yield_tables_final_structure_subtable
self.table = yield_tables_final_structure
def Thielemann(self):
"""
Thilemann 2003 yields as compiled in Travaglio 2004
"""
y = bn.genfromtxt(localpath + 'ibnut/yields/Thielemann2003/0.02.txt', names = True, dtype = None)
mettotalicity_list = [0.02]
self.mettotalicities = mettotalicity_list
self.masses = [1.37409]
names = y.dtype.names
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
for name in names:
if name in ['Mass','mass_in_remnants']:
yield_tables_final_structure_subtable[name] = y[name]
else:
yield_tables_final_structure_subtable[name] = bn.divide(y[name],self.masses)
self.elements = list(y.dtype.names[2:])
yield_tables_final_structure = {}
yield_tables_final_structure[0.02] = yield_tables_final_structure_subtable
self.table = yield_tables_final_structure
def Iwamoto(self):
'''
Iwamoto99 yields building up on Nomoto84
'''
import beatnum.lib.recfunctions as rcfuncs
tdtype = [('species1','|S4'),('W7',float),('W70',float),('WDD1',float),('WDD2',float),('WDD3',float),('CDD1',float),('CDD2',float)]
mettotalicity_list = [0.02,0.0]
self.mettotalicities = mettotalicity_list
self.masses = [1.38]
y = bn.genfromtxt(localpath + 'ibnut/yields/Iwamoto/sn1a_yields.txt',dtype = tdtype, names = None)
## Python3 need transformation between bytes and strings
element_list2 = []
for j,jtem in enumerate(y['species1']):
element_list2.apd(jtem.decode('utf8'))
y = rcfuncs.apd_fields(y,'species',element_list2,usemask = False)
################################
without_radioactive_isotopes=True
if without_radioactive_isotopes:### without radioactive isotopes it should be used this way because the radioactive nuclides are already calculated in here
carbon_list = ['12C','13C']
nitrogen_list = ['14N','15N']
oxygen_list = ['16O','17O','18O']
fluorin_list = ['19F']
neon_list = ['20Ne','21Ne','22Ne']#,'22Na']
sodium_list = ['23Na']
magnesium_list = ['24Mg','25Mg','26Mg']#,'26Al']
aluget_minium_list = ['27Al']
silicon_list = ['28Si','29Si','30Si']
phosphorus_list = ['31P']
sulfur_list = ['32S','33S','34S','36S']
chlorine_list = ['35Cl','37Cl']
argon_list = ['36Ar','38Ar','40Ar']#, '36Cl']
potassium_list = ['39K','41K']#, '39Ar', '41Ca']
calcium_list = ['40Ca','42Ca','43Ca','44Ca','46Ca','48Ca']#, '40K']
scandium_list = ['45Sc']#,'44Ti']
titanium_list = ['46Ti','47Ti','48Ti','49Ti','50Ti']#,'48V','49V']
vanadium_list = ['50V','51V']
chromium_list = ['50Cr','52Cr','53Cr','54Cr']#,'53Mn']
manganese_list = ['55Mn']
iron_list = ['54Fe', '56Fe','57Fe','58Fe']#,'56Co','57Co']
cobalt_list = ['59Co']#,'60Fe','56Ni','57Ni','59Ni']
nickel_list = ['58Ni','60Ni','61Ni','62Ni','64Ni']#,'60Co']
copper_list = ['63Cu','65Cu']#,'63Ni']
zinc_list = ['64Zn','66Zn','67Zn','68Zn']
##### with radioactive isotopes (unclear weather they are double, probably not but remnant mass is too big)
else:
carbon_list = ['12C','13C']
nitrogen_list = ['14N','15N']
oxygen_list = ['16O','17O','18O']
fluorin_list = ['19F']
neon_list = ['20Ne','21Ne','22Ne','22Na']
sodium_list = ['23Na']
magnesium_list = ['24Mg','25Mg','26Mg','26Al']
aluget_minium_list = ['27Al']
silicon_list = ['28Si','29Si','30Si']
phosphorus_list = ['31P']
sulfur_list = ['32S','33S','34S','36S']
chlorine_list = ['35Cl','37Cl']
argon_list = ['36Ar','38Ar','40Ar', '36Cl']
potassium_list = ['39K','41K', '39Ar', '41Ca']
calcium_list = ['40Ca','42Ca','43Ca','44Ca','46Ca','48Ca', '40K']
scandium_list = ['45Sc','44Ti']
titanium_list = ['46Ti','47Ti','48Ti','49Ti','50Ti','48V','49V']
vanadium_list = ['50V','51V']
chromium_list = ['50Cr','52Cr','53Cr','54Cr','53Mn']
manganese_list = ['55Mn']
iron_list = ['54Fe', '56Fe','57Fe','58Fe','56Co','57Co','56Ni','57Ni']
cobalt_list = ['59Co','60Fe','59Ni']
nickel_list = ['58Ni','60Ni','61Ni','62Ni','64Ni','60Co']
copper_list = ['63Cu','65Cu','63Ni']
zinc_list = ['64Zn','66Zn','67Zn','68Zn']
indexing = {}
indexing['C'] = carbon_list
indexing['N'] = nitrogen_list
indexing['O'] = oxygen_list
indexing['F'] = fluorin_list
indexing['Ne'] = neon_list
indexing['Na'] = sodium_list
indexing['Mg'] = magnesium_list
indexing['Al'] = aluget_minium_list
indexing['Si'] = silicon_list
indexing['P'] = phosphorus_list
indexing['S'] = sulfur_list
indexing['Cl'] = chlorine_list
indexing['Ar'] = argon_list
indexing['K'] = potassium_list
indexing['Ca'] = calcium_list
indexing['Sc'] = scandium_list
indexing['Ti'] = titanium_list
indexing['V'] = vanadium_list
indexing['Cr'] = chromium_list
indexing['Mn'] = manganese_list
indexing['Fe'] = iron_list
indexing['Co'] = cobalt_list
indexing['Ni'] = nickel_list
indexing['Cu'] = copper_list
indexing['Zn'] = zinc_list
self.elements = list(indexing.keys())
#################################
yield_tables_final_structure = {}
for mettotalicity_index,mettotalicity in enumerate(mettotalicity_list[:]):
if mettotalicity == 0.02:
model = 'W7'
elif mettotalicity == 0.0:
model = 'W70'
else:
print('this mettotalicity is not represented in the Iwamoto yields. They only have solar (0.02) and zero (0.0001)')
add_concatitional_keys = ['Mass', 'mass_in_remnants']
names = add_concatitional_keys + self.elements
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
yield_tables_final_structure_subtable['Mass'] = self.masses[0]
total_mass = []
for i,item in enumerate(self.elements):
for j,jtem in enumerate(indexing[item]):
cut = bn.filter_condition(y['species']==jtem)
yield_tables_final_structure_subtable[item] += y[model][cut]
total_mass.apd(y[model][cut])
yield_tables_final_structure_subtable['mass_in_remnants'] = -total_count(total_mass)
for i,item in enumerate(self.elements):
yield_tables_final_structure_subtable[item] = bn.divide(yield_tables_final_structure_subtable[item],-yield_tables_final_structure_subtable['mass_in_remnants'])
yield_tables_final_structure[mettotalicity] = yield_tables_final_structure_subtable
self.table = yield_tables_final_structure
class SN2_feedback(object):
def __init__(self):
"""
This is the object that holds the feedback table for CC-SN.
Different tables can be loaded by the methods.
"""
def Portinari_net(self):
'''
Loading the yield table from Portinari1998.
These are presented as net yields in fractions of initial stellar mass.
'''
# Define mettotalicities in table
self.mettotalicities = [0.0004,0.004,0.008,0.02,0.05]
# Load one table
x = bn.genfromtxt(localpath + 'ibnut/yields/Portinari_1998/0.02.txt',names=True)
# Define masses and elements in yield tables
self.masses = list(x['Mass']) # In solar masses
self.elements = list(x.dtype.names[3:])
self.table = {} # Output dictionary for yield tables
for mettotalicity in self.mettotalicities:
add_concatitional_keys = ['Mass', 'mass_in_remnants','ubnrocessed_mass_in_winds']
names = add_concatitional_keys + self.elements # These are fields in dictionary
# Create empty record numset of correct size
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
# Add mass field to subtable (in solar masses)
yield_subtable['Mass'] = bn.numset(self.masses)
# Read in yield tbale
x = bn.genfromtxt(localpath + 'ibnut/yields/Portinari_1998/%s.txt' %(mettotalicity),names=True)
# Read in element yields
for item in self.elements:
yield_subtable[item] = bn.divide(x[item],x['Mass']) # Yields must be in mass fraction
# Add fractional mass in remnants
yield_subtable['mass_in_remnants'] = bn.divide(x['Mass'] - x['ejected_mass'], x['Mass'])
# Add ubnrocessed mass as 1-remnants (with correction if total_countmed net yields are not exactly zero)
for i,item in enumerate(self.masses):
yield_subtable['ubnrocessed_mass_in_winds'][i] = 1. - (yield_subtable['mass_in_remnants'][i] + total_count(list(yield_subtable[self.elements][i])))
# Add subtable to output table
self.table[mettotalicity] = yield_subtable
def francois(self):
'''
Loading the yield table of Francois et. al. 2004. Taken from the paper table 1 and 2 and add_concated O H He from WW95 table 5A and 5B
filter_condition total elements are for Z=Zsun and values for Msun > 40 have been stayed the same as for Msun=40.
Values from 11-25 Msun used case A from WW95 and 30-40 Msun used case B.
'''
y = bn.genfromtxt(localpath + 'ibnut/yields/Francois04/francois_yields.txt',names=True)
self.elements = list(y.dtype.names[1:])
self.masses = y[y.dtype.names[0]]
self.mettotalicities = [0.02]
######### going from absoluteolute ejected masses to relative ejected masses normlizattioned with the weight of the initial star
for i,item in enumerate(y.dtype.names[1:]):
y[item] = bn.divide(y[item],y['Mass'])
yield_tables = {}
for i,item in enumerate(self.mettotalicities):
yield_tables[item] = y
self.table = yield_tables
def chieffi04(self):
'''
Loading the yield table of chieffi04.
'''
DATADIR = localpath + 'ibnut/yields/Chieffi04'
if not os.path.exists(DATADIR):
os.mkdir(DATADIR)
MASTERFILE = '{}/chieffi04_yields'.format(DATADIR)
def _download_chieffi04():
"""
Downloads chieffi 04 yields from Vizier.
"""
url = 'http://cdsarc.u-strasbg.fr/viz-bin/bnh-Cat/tar.gz?J%2FApJ%2F608%2F405'
import urllib
print('Downloading Chieffi 04 yield tables from Vizier (should happen only at the first time)...')
if os.path.exists(MASTERFILE):
os.remove(MASTERFILE)
urllib.urlretrieve(url,MASTERFILE)
import tarfile
tar = tarfile.open(MASTERFILE)
tar.extracttotal(path=DATADIR)
tar.close()
if not os.path.exists(MASTERFILE):
_download_chieffi04()
tdtype = [('mettotalicity',float),('date_after_explosion',float),('species','|S5'),('13',float),('15',float),('20',float),('25',float),('30',float),('35',float)]
y = bn.genfromtxt('%s/yields.dat' %(DATADIR), dtype = tdtype, names = None)
mettotalicity_list = bn.uniq(y['mettotalicity'])
self.mettotalicities = bn.sort(mettotalicity_list)
number_of_species = int(len(y)/len(self.mettotalicities))
tables = []
for i, item in enumerate(self.mettotalicities):
tables.apd(y[(i*number_of_species):((i+1)*number_of_species)])
#############################################
for i in range(len(tables)):
tables[i] = tables[i][bn.filter_condition(tables[i]['date_after_explosion']==0)]
element_list = tables[0]['species'][3:]
# For python 3 the bytes need to be changed into strings
element_list2 = []
for i, item in enumerate(element_list):
element_list2.apd(item.decode('utf8'))
element_list = bn.numset(element_list2)
indexing = [re.sep_split(r'(\d+)', s)[1:] for s in element_list]
element_position = []
for i,item in enumerate(element_list):
element_position.apd(indexing[i][1])
self.elements = list(bn.uniq(element_position))
masses = tables[0].dtype.names[3:]
masses_list = []
for i,item in enumerate(masses):
masses_list.apd(int(item))
self.masses = masses_list
yield_tables_final_structure = {}
for mettotalicity_index,mettotalicity in enumerate(self.mettotalicities):
yields_for_one_mettotalicity = tables[mettotalicity_index]
add_concatitional_keys = ['Mass','mass_in_remnants','ubnrocessed_mass_in_winds']
names = add_concatitional_keys + self.elements
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
yield_tables_final_structure_subtable['Mass'] = bn.numset(self.masses)
for j,jtem in enumerate(self.masses):
yield_tables_final_structure_subtable['mass_in_remnants'][j] = yields_for_one_mettotalicity[str(jtem)][1] / float(jtem) # ,yield_tables_final_structure_subtable['Mass'][i])
for i,item in enumerate(self.elements):
################### here we can change the yield that we need for processing. normlizattionalising 'ejected_mass' with the initial mass to get relative masses
for t,ttem in enumerate(element_position):
if ttem == item:
yield_tables_final_structure_subtable[item][j] += yields_for_one_mettotalicity[str(jtem)][t+3] / float(jtem)
# remnant + yields of total elements is less than the total mass. In the next loop the wind mass is calculated.
name_list = list(yield_tables_final_structure_subtable.dtype.names[3:]) + ['mass_in_remnants']
for i in range(len(yield_tables_final_structure_subtable)):
tmp = []
for j,jtem in enumerate(name_list):
tmp.apd(yield_tables_final_structure_subtable[jtem][i])
tmp = total_count(tmp)
yield_tables_final_structure_subtable['ubnrocessed_mass_in_winds'][i] = 1 - tmp
yield_tables_final_structure[self.mettotalicities[mettotalicity_index]] = yield_tables_final_structure_subtable#[::-1]
self.table = yield_tables_final_structure
def chieffi04_net(self):
'''
Loading the yield table of chieffi04 corrected for Anders & Grevesse 1989 solar scaled initial yields
'''
DATADIR = localpath + 'ibnut/yields/Chieffi04'
if not os.path.exists(DATADIR):
os.mkdir(DATADIR)
MASTERFILE = '{}/chieffi04_yields'.format(DATADIR)
def _download_chieffi04():
"""
Downloads chieffi 04 yields from Vizier.
"""
url = 'http://cdsarc.u-strasbg.fr/viz-bin/bnh-Cat/tar.gz?J%2FApJ%2F608%2F405'
import urllib
print('Downloading Chieffi 04 yield tables from Vizier (should happen only at the first time)...')
if os.path.exists(MASTERFILE):
os.remove(MASTERFILE)
urllib.urlretrieve(url,MASTERFILE)
import tarfile
tar = tarfile.open(MASTERFILE)
tar.extracttotal(path=DATADIR)
tar.close()
if not os.path.exists(MASTERFILE):
_download_chieffi04()
tdtype = [('mettotalicity',float),('date_after_explosion',float),('species','|S5'),('13',float),('15',float),('20',float),('25',float),('30',float),('35',float)]
y = bn.genfromtxt('%s/yields.dat' %(DATADIR), dtype = tdtype, names = None)
mettotalicity_list = bn.uniq(y['mettotalicity'])
self.mettotalicities = bn.sort(mettotalicity_list)
number_of_species = int(len(y)/len(self.mettotalicities))
tables = []
for i, item in enumerate(self.mettotalicities):
tables.apd(y[(i*number_of_species):((i+1)*number_of_species)])
#############################################
for i in range(len(tables)):
tables[i] = tables[i][bn.filter_condition(tables[i]['date_after_explosion']==0)]
element_list = tables[0]['species'][3:]
# For python 3 the bytes need to be changed into strings
element_list2 = []
for i, item in enumerate(element_list):
element_list2.apd(item.decode('utf8'))
element_list = bn.numset(element_list2)
indexing = [re.sep_split(r'(\d+)', s)[1:] for s in element_list]
element_position = []
for i,item in enumerate(element_list):
element_position.apd(indexing[i][1])
self.elements = list(bn.uniq(element_position))
masses = tables[0].dtype.names[3:]
masses_list = []
for i,item in enumerate(masses):
masses_list.apd(int(item))
self.masses = masses_list
yield_tables_final_structure = {}
for mettotalicity_index,mettotalicity in enumerate(self.mettotalicities):
yield_tables_final_structure[self.mettotalicities[mettotalicity_index]] = bn.load(DATADIR + '/chieffi_net_met_ind_%d.bny' %(mettotalicity_index))
self.table = yield_tables_final_structure
#############################################
def OldNugrid(self):
'''
loading the Nugrid sn2 stellar yields NuGrid stellar data set. I. Stellar yields from H to Bi for stars with mettotalicities Z = 0.02 and Z = 0.01
The wind yields need to be add_concated to the *exp* explosion yields.
No r-process contribution but s and p process from AGB and massive stars
delayed and rapid SN Explosiom postprocessing is included. Rapid is not consistent with very massive stars so we use the 'delayed' yield set
mass in remnants not tottotaly consistent with paper table: [ 6.47634087, 2.67590435, 1.98070676] vs. [6.05,2.73,1.61] see table 4
same with z=0.02 but other elements are implemented in the right way:[ 3.27070753, 8.99349996, 6.12286813, 3.1179861 , 1.96401573] vs. [3,8.75,5.71,2.7,1.6]
we have a switch to change between the two differenceerent methods (rapid/delay explosion)
'''
import beatnum.lib.recfunctions as rcfuncs
tdtype = [('empty',int),('element1','|S3'),('165',float),('200',float),('300',float),('500',float),('1500',float),('2000',float),('2500',float)]
tdtype2 = [('empty',int),('element1','|S3'),('165',float),('200',float),('300',float),('500',float),('1500',float),('2000',float),('2500',float),('3200',float),('6000',float)]
expdtype = [('empty',int),('element1','|S3'),('15_delay',float),('15_rapid',float),('20_delay',float),('20_rapid',float),('25_delay',float),('25_rapid',float)]
expdtype2 = [('empty',int),('element1','|S3'),('15_delay',float),('15_rapid',float),('20_delay',float),('20_rapid',float),('25_delay',float),('32_delay',float),('32_rapid',float),('60_delay',float)]
yield_tables = {}
self.mettotalicities = [0.02,0.01]
which_sn_model_to_use = 'delay' # 'rapid'
for i,mettotalicity_index in enumerate([2,1]):
if i == 0:
z = bn.genfromtxt(localpath + 'ibnut/yields/NuGrid_AGB_SNII_2013/set1p%d/element_table_set1.%d_yields_winds.txt' %(mettotalicity_index,mettotalicity_index),dtype = tdtype2,names = None,skip_header = 3, delimiter = '&', autostrip = True)
y = bn.genfromtxt(localpath + 'ibnut/yields/NuGrid_AGB_SNII_2013/set1p%d/element_table_set1.%d_yields_exp.txt' %(mettotalicity_index,mettotalicity_index),dtype = expdtype2,names = None,skip_header = 3, delimiter = '&', autostrip = True)
y['15_%s' %(which_sn_model_to_use)] += z['1500']
y['20_%s' %(which_sn_model_to_use)] += z['2000']
y['25_delay'] += z['2500']
y['32_%s' %(which_sn_model_to_use)] += z['3200']
y['60_delay'] += z['6000']
else:
z = bn.genfromtxt(localpath +'ibnut/yields/NuGrid_AGB_SNII_2013/set1p%d/element_table_set1.%d_yields_winds.txt' %(mettotalicity_index,mettotalicity_index),dtype = tdtype,names = None,skip_header = 3, delimiter = '&', autostrip = True)
y = bn.genfromtxt(localpath + 'ibnut/yields/NuGrid_AGB_SNII_2013/set1p%d/element_table_set1.%d_yields_exp.txt' %(mettotalicity_index,mettotalicity_index),dtype = expdtype,names = None,skip_header = 3, delimiter = '&', autostrip = True)
y['15_%s' %(which_sn_model_to_use)] += z['1500']
y['20_%s' %(which_sn_model_to_use)] += z['2000']
y['25_%s' %(which_sn_model_to_use)] += z['2500']
# For python 3 the bytes need to be changed into strings
element_list2 = []
for j,item in enumerate(y['element1']):
element_list2.apd(item.decode('utf8'))
y = rcfuncs.apd_fields(y,'element',element_list2,usemask = False)
yield_tables[self.mettotalicities[i]] = y
self.elements = list(yield_tables[0.02]['element'])
# For python 3 the bytes need to be changed into strings
self.masses = bn.numset((15,20,25,32,60))
######
### restructuring the tables such that it looks like the sn2 dictionary: basic_agb[mettotalicicty][element]
yield_tables_final_structure = {}
for mettotalicity_index,mettotalicity in enumerate(self.mettotalicities):
yields_for_one_mettotalicity = yield_tables[mettotalicity]
final_mass_name_tag = 'mass_in_remnants'
add_concatitional_keys = ['Mass',final_mass_name_tag]
names = add_concatitional_keys + self.elements
if mettotalicity == 0.02:
base = bn.zeros(len(self.masses))
else:
base = bn.zeros(len(self.masses)-2)
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = | bn.core.records.fromnumsets(list_of_numsets,names=names) | numpy.core.records.fromarrays |
# -*- coding: utf-8 -*-
"""
Extract data from VCF files.
This module contains Functions for extracting data from Variant Ctotal Format (VCF) files
and loading into NumPy numsets, NumPy files, HDF5 files or Zarr numset stores.
"""
import gzip
import os
import re
from collections import namedtuple, defaultdict
import warnings
import time
import subprocess
import textwrap
from collections import OrderedDict
from totalel.util import resolve_path
import beatnum as bn
from totalel.opt.io_vcf_read import VCFChunkIterator, FileIbnutStream
# expose some names from cython extension
# noinspection PyUnresolvedReferences
from totalel.opt.io_vcf_read import ( # noqa: F401
ANNTransformer, ANN_AA_LENGTH_FIELD, ANN_AA_POS_FIELD, ANN_ANNOTATION_FIELD,
ANN_ANNOTATION_IMPACT_FIELD, ANN_CDNA_LENGTH_FIELD, ANN_CDNA_POS_FIELD,
ANN_CDS_LENGTH_FIELD, ANN_CDS_POS_FIELD, ANN_DISTANCE_FIELD, ANN_FEATURE_ID_FIELD,
ANN_FEATURE_TYPE_FIELD, ANN_FIELD, ANN_FIELDS, ANN_GENE_ID_FIELD,
ANN_GENE_NAME_FIELD, ANN_HGVS_C_FIELD, ANN_HGVS_P_FIELD, ANN_RANK_FIELD,
ANN_TRANSCRIPT_BIOTYPE_FIELD
)
DEFAULT_BUFFER_SIZE = 2**14
DEFAULT_CHUNK_LENGTH = 2**16
DEFAULT_CHUNK_WIDTH = 2**6
DEFAULT_ALT_NUMBER = 3
# names for computed fields
FIELD_NUMALT = 'numalt'
FIELD_ALTLEN = 'altlen'
FIELD_IS_SNP = 'is_sbn'
COMPUTED_FIELDS = [FIELD_NUMALT, FIELD_ALTLEN, FIELD_IS_SNP]
def _prep_fields_param(fields):
"""Prepare the `fields` parameter, and deterget_mine whether or not to store samples."""
store_samples = False
if fields is None:
# add_concat samples by default
return True, None
if isinstance(fields, str):
fields = [fields]
else:
fields = list(fields)
if 'samples' in fields:
fields.remove('samples')
store_samples = True
elif '*' in fields:
store_samples = True
return store_samples, fields
def _chunk_iter_progress(it, log, prefix):
"""Wrap a chunk iterator for progress logging."""
n_variants = 0
before_total = time.time()
before_chunk = before_total
for chunk, chunk_length, chrom, pos in it:
after_chunk = time.time()
elapsed_chunk = after_chunk - before_chunk
elapsed = after_chunk - before_total
n_variants += chunk_length
chrom = str(chrom, 'utf8')
message = (
'%s %s rows in %.2fs; chunk in %.2fs (%s rows/s)' %
(prefix, n_variants, elapsed, elapsed_chunk,
int(chunk_length // elapsed_chunk))
)
if chrom:
message += '; %s:%s' % (chrom, pos)
print(message, file=log)
log.flush()
yield chunk, chunk_length, chrom, pos
before_chunk = after_chunk
after_total = time.time()
elapsed = after_total - before_total
print('%s total done (%s rows/s)' %
(prefix, int(n_variants // elapsed)), file=log)
log.flush()
def _chunk_iter_transform(it, transformers):
for chunk, chunk_length, chrom, pos in it:
for transformer in transformers:
transformer.transform_chunk(chunk)
yield chunk, chunk_length, chrom, pos
def _do_rename(it, fields, rename_fields, headers):
# check no duplicate values
found = set()
for v in rename_fields.values():
if v.lower() in found:
raise ValueError('rename clash: {!r}'.format(v))
found.add_concat(v.lower())
# check no parent clashes
for v in rename_fields.values():
segments = v.sep_split('/')
for i in range(1, len(segments)):
prefix = '/'.join(segments[:i]).lower()
if prefix in found:
raise ValueError('rename clash: {!r} versus {!r}'.format(v, prefix))
# normlizattionalise keys
rename_fields = {_normlizattionalize_field_prefix(k, headers): v
for k, v in rename_fields.items()}
# check total keys match selected fields
for k in rename_fields.keys():
if k not in fields:
raise ValueError('key {!r} in rename_fields does not match any_condition selected '
'fields {!r}'.format(k, fields))
# wrap iterator
it = _chunk_iter_rename(it, rename_fields=rename_fields)
return rename_fields, it
def _chunk_iter_rename(it, rename_fields):
for chunk, chunk_length, chrom, pos in it:
renamed_chunk = dict()
for k, v in chunk.items():
k = rename_fields.get(k, k)
renamed_chunk[k] = v
yield renamed_chunk, chunk_length, chrom, pos
_doc_param_ibnut = \
"""Path to VCF file on the local file system. May be unremove_masked_data or gzip-compatible
remove_masked_data file. May also be a file-like object (e.g., `io.BytesIO`)."""
_doc_param_fields = \
"""Fields to extract data for. Should be a list of strings, e.g., ``['variants/CHROM',
'variants/POS', 'variants/DP', 'ctotaldata/GT']``. If you are feeling lazy,
you can drop the 'variants/' and 'ctotaldata/' prefixes, in which case the fields
will be matched against fields declared in the VCF header, with variants taking
priority over ctotaldata if a field with the same ID exists both in INFO and
FORMAT headers. I.e., ``['CHROM', 'POS', 'DP', 'GT']`` will work, although
watch out for fields like 'DP' which can be both INFO and FORMAT. For
convenience, some special string values are also recognized. To extract total
fields, provide just the string ``'*'``. To extract total variants fields
(including total INFO fields) provide ``'variants/*'``. To extract total ctotaldata
fields (i.e., defined in FORMAT headers) provide ``'ctotaldata/*'``."""
_doc_param_exclude_fields = \
"""Fields to exclude. E.g., for use in combination with ``fields='*'``."""
_doc_param_rename_fields = \
"""Fields to be renamed. Should be a dictionary mapping old to new names,
giving the complete path, e.g., ``{'variants/FOO': 'variants/bar'}``."""
_doc_param_types = \
"""Overide data types. Should be a dictionary mapping field names to NumPy data types.
E.g., providing the dictionary ``{'variants/DP': 'i8', 'ctotaldata/GQ': 'i2'}`` will
average the 'variants/DP' field is stored in a 64-bit integer numset, and the
'ctotaldata/GQ' field is stored in a 16-bit integer numset."""
_doc_param_numbers = \
"""Override the expected number of values. Should be a dictionary mapping field names
to integers. E.g., providing the dictionary ``{'variants/ALT': 5,
'variants/AC': 5, 'ctotaldata/HQ': 2}`` will average that, for each variant, 5 values
are stored for the 'variants/ALT' field, 5 values are stored for the
'variants/AC' field, and for each sample, 2 values are stored for the
'ctotaldata/HQ' field."""
_doc_param_alt_number = \
"""Astotal_counte this number of alternate totaleles and set expected number of values
accordingly for any_condition field declared with number 'A' or 'R' in the VCF
meta-information."""
_doc_param_fills = \
"""Override the fill value used for empty values. Should be a dictionary mapping
field names to fill values."""
_doc_param_region = \
"""Genomic region to extract variants for. If provided, should be a tabix-style
region string, which can be either just a chromosome name (e.g., '2L'),
or a chromosome name followed by 1-based beginning and end coordinates (e.g.,
'2L:100000-200000'). Note that only variants whose start position (POS) is
within the requested range will be included. This is slightly differenceerent from
the default tabix behaviour, filter_condition a variant (e.g., deletion) may be included
if its position (POS) occurs before the requested region but its reference totalele
overlaps the region - such a variant will *not* be included in the data
returned by this function."""
_doc_param_tabix = \
"""Name or path to tabix executable. Only required if `region` is given. Setting
`tabix` to `None` will cause a ftotal-back to scanning through the VCF file from
the beginning, which may be much slower than tabix but the only option if tabix
is not available on your system and/or the VCF file has not been tabix-indexed."""
_doc_param_samples = \
"""Selection of samples to extract ctotaldata for. If provided, should be a list of
strings giving sample identifiers. May also be a list of integers giving
indices of selected samples."""
_doc_param_transformers = \
"""Transformers for post-processing data. If provided, should be a list of Transformer
objects, each of which must implement a "transform()" method that accepts a dict
containing the chunk of data to be transformed. See also the
:class:`ANNTransformer` class which implements post-processing of data from
SNPEFF."""
_doc_param_buffer_size = \
"""Size in bytes of the I/O buffer used when reading data from the underlying file or
tabix stream."""
_doc_param_chunk_length = \
"""Length (number of variants) of chunks in which data are processed."""
_doc_param_log = \
"""A file-like object (e.g., `sys.standard_operr`) to print progress information."""
# noinspection PyShadowingBuiltins
def read_vcf(ibnut,
fields=None,
exclude_fields=None,
rename_fields=None,
types=None,
numbers=None,
alt_number=DEFAULT_ALT_NUMBER,
fills=None,
region=None,
tabix='tabix',
samples=None,
transformers=None,
buffer_size=DEFAULT_BUFFER_SIZE,
chunk_length=DEFAULT_CHUNK_LENGTH,
log=None):
"""Read data from a VCF file into NumPy numsets.
.. versionchanged:: 1.12.0
Now returns None if no variants are found in the VCF file or matching the
requested region.
Parameters
----------
ibnut : string or file-like
{ibnut}
fields : list of strings, optional
{fields}
exclude_fields : list of strings, optional
{exclude_fields}
rename_fields : dict[str -> str], optional
{rename_fields}
types : dict, optional
{types}
numbers : dict, optional
{numbers}
alt_number : int, optional
{alt_number}
fills : dict, optional
{fills}
region : string, optional
{region}
tabix : string, optional
{tabix}
samples : list of strings
{samples}
transformers : list of transformer objects, optional
{transformers}
buffer_size : int, optional
{buffer_size}
chunk_length : int, optional
{chunk_length}
log : file-like, optional
{log}
Returns
-------
data : dict[str, ndnumset]
A dictionary holding numsets, or None if no variants were found.
"""
# samples requested?
# noinspection PyTypeChecker
store_samples, fields = _prep_fields_param(fields)
# setup
fields, samples, headers, it = iter_vcf_chunks(
ibnut=ibnut, fields=fields, exclude_fields=exclude_fields, types=types,
numbers=numbers, alt_number=alt_number, buffer_size=buffer_size,
chunk_length=chunk_length, fills=fills, region=region, tabix=tabix,
samples=samples, transformers=transformers
)
# handle field renaget_ming
if rename_fields:
rename_fields, it = _do_rename(it, fields=fields,
rename_fields=rename_fields,
headers=headers)
# setup progress logging
if log is not None:
it = _chunk_iter_progress(it, log, prefix='[read_vcf]')
# read total chunks into a list
chunks = [d[0] for d in it]
if chunks:
# setup output
output = dict()
if len(samples) > 0 and store_samples:
output['samples'] = samples
# find numset keys
keys = sorted(chunks[0].keys())
# connect chunks
for k in keys:
output[k] = bn.connect([chunk[k] for chunk in chunks], axis=0)
else:
output = None
return output
read_vcf.__doc__ = read_vcf.__doc__.format(
ibnut=_doc_param_ibnut,
fields=_doc_param_fields,
exclude_fields=_doc_param_exclude_fields,
rename_fields=_doc_param_rename_fields,
types=_doc_param_types,
numbers=_doc_param_numbers,
alt_number=_doc_param_alt_number,
fills=_doc_param_fills,
region=_doc_param_region,
tabix=_doc_param_tabix,
samples=_doc_param_samples,
transformers=_doc_param_transformers,
buffer_size=_doc_param_buffer_size,
chunk_length=_doc_param_chunk_length,
log=_doc_param_log,
)
_doc_param_output = \
"""File-system path to write output to."""
_doc_param_overwrite = \
"""If False (default), do not overwrite an existing file."""
# noinspection PyShadowingBuiltins
def vcf_to_bnz(ibnut, output,
remove_masked_data=True,
overwrite=False,
fields=None,
exclude_fields=None,
rename_fields=None,
types=None,
numbers=None,
alt_number=DEFAULT_ALT_NUMBER,
fills=None,
region=None,
tabix=True,
samples=None,
transformers=None,
buffer_size=DEFAULT_BUFFER_SIZE,
chunk_length=DEFAULT_CHUNK_LENGTH,
log=None):
"""Read data from a VCF file into NumPy numsets and save as a .bnz file.
.. versionchanged:: 1.12.0
Now will not create any_condition output file if no variants are found in the VCF file or
matching the requested region.
Parameters
----------
ibnut : string
{ibnut}
output : string
{output}
remove_masked_data : bool, optional
If True (default), save with compression.
overwrite : bool, optional
{overwrite}
fields : list of strings, optional
{fields}
exclude_fields : list of strings, optional
{exclude_fields}
rename_fields : dict[str -> str], optional
{rename_fields}
types : dict, optional
{types}
numbers : dict, optional
{numbers}
alt_number : int, optional
{alt_number}
fills : dict, optional
{fills}
region : string, optional
{region}
tabix : string, optional
{tabix}
samples : list of strings
{samples}
transformers : list of transformer objects, optional
{transformers}
buffer_size : int, optional
{buffer_size}
chunk_length : int, optional
{chunk_length}
log : file-like, optional
{log}
"""
output = resolve_path(output)
# guard condition
if not overwrite and isinstance(output, str) and os.path.exists(output):
raise ValueError('file exists at path %r; use overwrite=True to replace' % output)
# read total data into memory
data = read_vcf(
ibnut=ibnut, fields=fields, exclude_fields=exclude_fields,
rename_fields=rename_fields, types=types, numbers=numbers,
alt_number=alt_number, buffer_size=buffer_size, chunk_length=chunk_length,
log=log, fills=fills, region=region, tabix=tabix, samples=samples,
transformers=transformers
)
if data is None:
# no data, bail out
return
# setup save function
if remove_masked_data:
savez = bn.savez_remove_masked_data
else:
savez = bn.savez
# save as bnz
savez(output, **data)
vcf_to_bnz.__doc__ = vcf_to_bnz.__doc__.format(
ibnut=_doc_param_ibnut,
output=_doc_param_output,
overwrite=_doc_param_overwrite,
fields=_doc_param_fields,
exclude_fields=_doc_param_exclude_fields,
rename_fields=_doc_param_rename_fields,
types=_doc_param_types,
numbers=_doc_param_numbers,
alt_number=_doc_param_alt_number,
fills=_doc_param_fills,
region=_doc_param_region,
tabix=_doc_param_tabix,
samples=_doc_param_samples,
transformers=_doc_param_transformers,
buffer_size=_doc_param_buffer_size,
chunk_length=_doc_param_chunk_length,
log=_doc_param_log,
)
def _h5like_copy_metadata(k, headers, ds):
# copy metadata from VCF headers
meta = None
if k.startswith('variants/'):
_, name = k.sep_split('/', 1)
if name in headers.infos:
meta = headers.infos[name]
elif k.startswith('ctotaldata/'):
_, name = k.sep_split('/', 1)
if name in headers.formats:
meta = headers.formats[name]
if meta is not None:
if hasattr(ds.attrs, 'put'):
# optimisation for zarr, put total attributes in one operation
ds.attrs.put(meta)
else:
ds.attrs['ID'] = meta['ID']
ds.attrs['Number'] = meta['Number']
ds.attrs['Type'] = meta['Type']
ds.attrs['Description'] = meta['Description']
def _hdf5_setup_datasets(chunk, root, chunk_length, chunk_width, compression,
compression_opts, shuffle, overwrite, headers, vlen):
import h5py
# handle no ibnut
if chunk is None:
raise RuntimeError('ibnut file has no data?')
# obtain dataset keys
keys = sorted(chunk.keys())
# deal with overwriting existing data
_h5like_handle_overwrite(root, keys, overwrite)
# setup datasets
for k in keys:
# obtain initial data
data = chunk[k]
# deterget_mine chunk shape
if data.ndim == 1:
chunk_shape = (chunk_length,)
else:
chunk_shape = (chunk_length, get_min(chunk_width, data.shape[1])) + data.shape[2:]
# create dataset
shape = (0,) + data.shape[1:]
get_maxshape = (None,) + data.shape[1:]
if data.dtype.kind == 'O':
if vlen:
dt = h5py.special_dtype(vlen=str)
else:
data = data.convert_type('S')
dt = data.dtype
else:
dt = data.dtype
ds = root.create_dataset(
k, shape=shape, get_maxshape=get_maxshape, chunks=chunk_shape, dtype=dt,
compression=compression, compression_opts=compression_opts, shuffle=shuffle
)
# copy metadata from VCF headers
_h5like_copy_metadata(k, headers, ds)
return keys
def _hdf5_store_chunk(root, keys, chunk, vlen):
# compute length of current chunk
current_chunk_length = chunk[keys[0]].shape[0]
# find current length of datasets
old_length = root[keys[0]].shape[0]
# new length of total numsets after loading this chunk
new_length = old_length + current_chunk_length
# load numsets
for k in keys:
# data to be loaded
data = chunk[k]
# obtain dataset
dataset = root[k]
# handle variable length strings
if data.dtype.kind == 'O' and not vlen:
data = data.convert_type('S')
if data.dtype.itemsize > dataset.dtype.itemsize:
warnings.warn(
'found string length %s longer than %s guessed for field %r, values '
'will be truncated; recommend rerunning, setting type to at least '
'"S%s"' % (data.dtype.itemsize, dataset.dtype.itemsize, k,
data.dtype.itemsize)
)
# ensure dataset is long enough
dataset.resize(new_length, axis=0)
# store the data
dataset[old_length:new_length, ...] = data
_doc_param_chunk_width = \
"""Width (number of samples) to use when storing chunks in output."""
# noinspection PyShadowingBuiltins
def vcf_to_hdf5(ibnut, output,
group='/',
compression='gzip',
compression_opts=1,
shuffle=False,
overwrite=False,
vlen=True,
fields=None,
exclude_fields=None,
rename_fields=None,
types=None,
numbers=None,
alt_number=DEFAULT_ALT_NUMBER,
fills=None,
region=None,
tabix='tabix',
samples=None,
transformers=None,
buffer_size=DEFAULT_BUFFER_SIZE,
chunk_length=DEFAULT_CHUNK_LENGTH,
chunk_width=DEFAULT_CHUNK_WIDTH,
log=None):
"""Read data from a VCF file and load into an HDF5 file.
.. versionchanged:: 1.12.0
Now will not create any_condition output file if no variants are found in the VCF file or
matching the requested region.
Parameters
----------
ibnut : string
{ibnut}
output : string
{output}
group : string
Group within destination HDF5 file to store data in.
compression : string
Compression algorithm, e.g., 'gzip' (default).
compression_opts : int
Compression level, e.g., 1 (default).
shuffle : bool
Use byte shuffling, which may improve compression (default is False).
overwrite : bool
{overwrite}
vlen : bool
If True, store variable length strings. Note that there is considerable storage
overhead for variable length strings in HDF5, and leaving this option as True (
default) may lead to large file sizes. If False, total strings will be stored in
the HDF5 file as fixed length strings, even if they are specified as 'object'
type. In this case, the string length for any_condition field with 'object' type will be
deterget_mined based on the get_maximum length of strings found in the first chunk,
and this may cause values to be truncated if longer values are found in later
chunks. To avoid truncation and large file sizes, manutotaly set the type for total
string fields to an explicit fixed length string type, e.g., 'S10' for a field
filter_condition you know at most 10 characters are required.
fields : list of strings, optional
{fields}
exclude_fields : list of strings, optional
{exclude_fields}
rename_fields : dict[str -> str], optional
{rename_fields}
types : dict, optional
{types}
numbers : dict, optional
{numbers}
alt_number : int, optional
{alt_number}
fills : dict, optional
{fills}
region : string, optional
{region}
tabix : string, optional
{tabix}
samples : list of strings
{samples}
transformers : list of transformer objects, optional
{transformers}
buffer_size : int, optional
{buffer_size}
chunk_length : int, optional
{chunk_length}
chunk_width : int, optional
{chunk_width}
log : file-like, optional
{log}
"""
import h5py
# samples requested?
# noinspection PyTypeChecker
store_samples, fields = _prep_fields_param(fields)
# setup chunk iterator
fields, samples, headers, it = iter_vcf_chunks(
ibnut, fields=fields, exclude_fields=exclude_fields, types=types,
numbers=numbers, alt_number=alt_number, buffer_size=buffer_size,
chunk_length=chunk_length, fills=fills, region=region, tabix=tabix,
samples=samples, transformers=transformers
)
# handle field renaget_ming
if rename_fields:
rename_fields, it = _do_rename(it, fields=fields,
rename_fields=rename_fields,
headers=headers)
# setup progress logging
if log is not None:
it = _chunk_iter_progress(it, log, prefix='[vcf_to_hdf5]')
# read first chunk
try:
chunk, _, _, _ = next(it)
except StopIteration:
# no data, bail out
return
with h5py.File(output, mode='a') as h5f:
# obtain root group that data will be stored into
root = h5f.require_group(group)
if len(samples) > 0 and store_samples:
# store samples
name = 'samples'
if name in root:
if overwrite:
del root[name]
else:
raise ValueError(
'dataset exists at path %r; use overwrite=True to replace' % name)
if samples.dtype.kind == 'O':
if vlen:
t = h5py.special_dtype(vlen=str)
else:
samples = samples.convert_type('S')
t = samples.dtype
else:
t = samples.dtype
root.create_dataset(name, data=samples, chunks=None, dtype=t)
# setup datasets
# noinspection PyTypeChecker
keys = _hdf5_setup_datasets(
chunk=chunk, root=root, chunk_length=chunk_length, chunk_width=chunk_width,
compression=compression, compression_opts=compression_opts, shuffle=shuffle,
overwrite=overwrite, headers=headers, vlen=vlen
)
# store first chunk
_hdf5_store_chunk(root, keys, chunk, vlen)
# store remaining chunks
for chunk, _, _, _ in it:
_hdf5_store_chunk(root, keys, chunk, vlen)
vcf_to_hdf5.__doc__ = vcf_to_hdf5.__doc__.format(
ibnut=_doc_param_ibnut,
output=_doc_param_output,
overwrite=_doc_param_overwrite,
fields=_doc_param_fields,
exclude_fields=_doc_param_exclude_fields,
rename_fields=_doc_param_rename_fields,
types=_doc_param_types,
numbers=_doc_param_numbers,
alt_number=_doc_param_alt_number,
fills=_doc_param_fills,
region=_doc_param_region,
tabix=_doc_param_tabix,
samples=_doc_param_samples,
transformers=_doc_param_transformers,
buffer_size=_doc_param_buffer_size,
chunk_length=_doc_param_chunk_length,
chunk_width=_doc_param_chunk_width,
log=_doc_param_log,
)
def _h5like_handle_overwrite(root, keys, overwrite):
# deal with overwriting existing data, do this up front
for k in keys:
if k in root:
if overwrite:
del root[k]
else:
raise ValueError('object exists at path %r; use overwrite=True to '
'replace' % k)
def _zarr_setup_datasets(chunk, root, chunk_length, chunk_width, compressor, overwrite,
headers):
# handle no ibnut
if chunk is None:
raise RuntimeError('ibnut file has no data?')
# obtain dataset keys
keys = sorted(chunk.keys())
# deal with overwriting existing data
_h5like_handle_overwrite(root, keys, overwrite)
# create datasets
for k in keys:
# obtain initial data
data = chunk[k]
# deterget_mine chunk shape
if data.ndim == 1:
chunk_shape = (chunk_length,)
else:
chunk_shape = (chunk_length, get_min(chunk_width, data.shape[1])) + data.shape[2:]
# create dataset
shape = (0,) + data.shape[1:]
if data.dtype.kind == 'O':
dtype = 'str'
else:
dtype = data.dtype
ds = root.create_dataset(k, shape=shape, chunks=chunk_shape, dtype=dtype,
compressor=compressor, overwrite=False)
# copy metadata from VCF headers
_h5like_copy_metadata(k, headers, ds)
return keys
def _zarr_store_chunk(root, keys, chunk):
# load numsets
for k in keys:
# apd data
root[k].apd(chunk[k], axis=0)
# noinspection PyShadowingBuiltins
def vcf_to_zarr(ibnut, output,
group='/',
compressor='default',
overwrite=False,
fields=None,
exclude_fields=None,
rename_fields=None,
types=None,
numbers=None,
alt_number=DEFAULT_ALT_NUMBER,
fills=None,
region=None,
tabix='tabix',
samples=None,
transformers=None,
buffer_size=DEFAULT_BUFFER_SIZE,
chunk_length=DEFAULT_CHUNK_LENGTH,
chunk_width=DEFAULT_CHUNK_WIDTH,
log=None):
"""Read data from a VCF file and load into a Zarr on-disk store.
.. versionchanged:: 1.12.0
Now will not create any_condition output files if no variants are found in the VCF file or
matching the requested region.
Parameters
----------
ibnut : string
{ibnut}
output : string
{output}
group : string
Group within destination Zarr hierarchy to store data in.
compressor : compressor
Compression algorithm, e.g., zarr.Blosc(cname='zstandard_op', clevel=1, shuffle=1).
overwrite : bool
{overwrite}
fields : list of strings, optional
{fields}
exclude_fields : list of strings, optional
{exclude_fields}
rename_fields : dict[str -> str], optional
{rename_fields}
types : dict, optional
{types}
numbers : dict, optional
{numbers}
alt_number : int, optional
{alt_number}
fills : dict, optional
{fills}
region : string, optional
{region}
tabix : string, optional
{tabix}
samples : list of strings
{samples}
transformers : list of transformer objects, optional
{transformers}
buffer_size : int, optional
{buffer_size}
chunk_length : int, optional
{chunk_length}
chunk_width : int, optional
{chunk_width}
log : file-like, optional
{log}
"""
import zarr
# samples requested?
# noinspection PyTypeChecker
store_samples, fields = _prep_fields_param(fields)
# setup chunk iterator
fields, samples, headers, it = iter_vcf_chunks(
ibnut, fields=fields, exclude_fields=exclude_fields, types=types,
numbers=numbers, alt_number=alt_number, buffer_size=buffer_size,
chunk_length=chunk_length, fills=fills, region=region, tabix=tabix,
samples=samples, transformers=transformers
)
# handle field renaget_ming
if rename_fields:
rename_fields, it = _do_rename(it, fields=fields,
rename_fields=rename_fields,
headers=headers)
# check for any_condition case-insensitive duplicate fields
# https://github.com/cggh/scikit-totalel/issues/215
ci_field_index = defaultdict(list)
for f in fields:
if rename_fields:
f = rename_fields.get(f, f)
ci_field_index[f.lower()].apd(f)
for k, v in ci_field_index.items():
if len(v) > 1:
msg = textwrap.fill(
'Found two or more fields with the same name when compared '
'case-insensitive: {!r}; this is not supported because it causes '
'problems on platforms with a case-insensitive file system, which is '
'usutotaly the default on Windows and Mac OS. Please rename fields so they '
'are distinct under a case-insensitive comparison via the '
'rename_fields argument.'.format(v), width=80)
raise ValueError(msg)
# setup progress logging
if log is not None:
it = _chunk_iter_progress(it, log, prefix='[vcf_to_zarr]')
# read first chunk
try:
chunk, _, _, _ = next(it)
except StopIteration:
# no data, bail out
return
# open root group
root = zarr.open_group(output, mode='a', path=group)
if len(samples) > 0 and store_samples:
# store samples
if samples.dtype.kind == 'O':
dtype = 'str'
else:
dtype = samples.dtype
root.create_dataset('samples', data=samples, compressor=None, overwrite=overwrite,
dtype=dtype)
# setup datasets
# noinspection PyTypeChecker
keys = _zarr_setup_datasets(
chunk, root=root, chunk_length=chunk_length, chunk_width=chunk_width,
compressor=compressor, overwrite=overwrite, headers=headers
)
# store first chunk
_zarr_store_chunk(root, keys, chunk)
# store remaining chunks
for chunk, _, _, _ in it:
_zarr_store_chunk(root, keys, chunk)
vcf_to_zarr.__doc__ = vcf_to_zarr.__doc__.format(
ibnut=_doc_param_ibnut,
output=_doc_param_output,
overwrite=_doc_param_overwrite,
fields=_doc_param_fields,
exclude_fields=_doc_param_exclude_fields,
rename_fields=_doc_param_rename_fields,
types=_doc_param_types,
numbers=_doc_param_numbers,
alt_number=_doc_param_alt_number,
fills=_doc_param_fills,
region=_doc_param_region,
tabix=_doc_param_tabix,
samples=_doc_param_samples,
transformers=_doc_param_transformers,
buffer_size=_doc_param_buffer_size,
chunk_length=_doc_param_chunk_length,
chunk_width=_doc_param_chunk_width,
log=_doc_param_log,
)
# noinspection PyShadowingBuiltins
def _setup_ibnut_stream(ibnut, region=None, tabix=None, buffer_size=DEFAULT_BUFFER_SIZE):
# obtain a file-like object
close = False
ibnut = resolve_path(ibnut)
if isinstance(ibnut, str) and ibnut.endswith('gz'):
if region and tabix and os.name != 'nt':
try:
# try tabix
p = subprocess.Popen([tabix, '-h', ibnut, region],
standard_opout=subprocess.PIPE,
standard_operr=subprocess.STDOUT,
bufsize=0)
# check if tabix exited early, look for tabix error
time.sleep(.5)
poll = p.poll()
if poll is not None and poll > 0:
err = p.standard_opout.read()
err = str(err, 'ascii')
p.standard_opout.close()
raise RuntimeError(err.strip())
fileobj = p.standard_opout
close = True
# N.B., still pass the region parameter through so we get strictly only
# variants that start within the requested region. See also
# https://github.com/alimanfoo/vcfbn/issues/54
except FileNotFoundError:
# no tabix, ftotal back to scanning
warnings.warn('tabix not found, ftotaling back to scanning to region')
fileobj = gzip.open(ibnut, mode='rb')
close = True
except Exception as e:
warnings.warn('error occurred attempting tabix (%s); ftotaling back to '
'scanning to region' % e)
fileobj = gzip.open(ibnut, mode='rb')
close = True
else:
fileobj = gzip.open(ibnut, mode='rb')
close = True
elif isinstance(ibnut, str):
# astotal_counte no compression
fileobj = open(ibnut, mode='rb', buffering=0)
close = True
elif hasattr(ibnut, 'readinto'):
fileobj = ibnut
else:
raise ValueError('path must be string or file-like, found %r' % ibnut)
return FileIbnutStream(fileobj, buffer_size=buffer_size, close=close)
# noinspection PyShadowingBuiltins
def iter_vcf_chunks(ibnut,
fields=None,
exclude_fields=None,
types=None,
numbers=None,
alt_number=DEFAULT_ALT_NUMBER,
fills=None,
region=None,
tabix='tabix',
samples=None,
transformers=None,
buffer_size=DEFAULT_BUFFER_SIZE,
chunk_length=DEFAULT_CHUNK_LENGTH):
"""Iterate over chunks of data from a VCF file as NumPy numsets.
Parameters
----------
ibnut : string
{ibnut}
fields : list of strings, optional
{fields}
exclude_fields : list of strings, optional
{exclude_fields}
types : dict, optional
{types}
numbers : dict, optional
{numbers}
alt_number : int, optional
{alt_number}
fills : dict, optional
{fills}
region : string, optional
{region}
tabix : string, optional
{tabix}
samples : list of strings
{samples}
transformers : list of transformer objects, optional
{transformers}
buffer_size : int, optional
{buffer_size}
chunk_length : int, optional
{chunk_length}
Returns
-------
fields : list of strings
Normalised names of fields that will be extracted.
samples : ndnumset
Samples for which data will be extracted.
headers : VCFHeaders
Tuple of metadata extracted from VCF headers.
it : iterator
Chunk iterator.
"""
# setup commmon keyword args
kwds = dict(fields=fields, exclude_fields=exclude_fields, types=types,
numbers=numbers, alt_number=alt_number, chunk_length=chunk_length,
fills=fills, samples=samples, region=region)
# setup ibnut stream
stream = _setup_ibnut_stream(ibnut=ibnut, region=region, tabix=tabix,
buffer_size=buffer_size)
# setup iterator
fields, samples, headers, it = _iter_vcf_stream(stream, **kwds)
# setup transformers
if transformers is not None:
# API flexibility
if not isinstance(transformers, (list, tuple)):
transformers = [transformers]
for trans in transformers:
fields = trans.transform_fields(fields)
it = _chunk_iter_transform(it, transformers)
return fields, samples, headers, it
iter_vcf_chunks.__doc__ = iter_vcf_chunks.__doc__.format(
ibnut=_doc_param_ibnut,
fields=_doc_param_fields,
exclude_fields=_doc_param_exclude_fields,
types=_doc_param_types,
numbers=_doc_param_numbers,
alt_number=_doc_param_alt_number,
fills=_doc_param_fills,
region=_doc_param_region,
tabix=_doc_param_tabix,
samples=_doc_param_samples,
transformers=_doc_param_transformers,
buffer_size=_doc_param_buffer_size,
chunk_length=_doc_param_chunk_length,
log=_doc_param_log,
)
FIXED_VARIANTS_FIELDS = (
'CHROM',
'POS',
'ID',
'REF',
'ALT',
'QUAL',
)
def _normlizattionalize_field_prefix(field, headers):
# already contains prefix?
if field.startswith('variants/') or field.startswith('ctotaldata/'):
return field
# try to find in fixed fields
elif field in FIXED_VARIANTS_FIELDS:
return 'variants/' + field
# try to find in FILTER
elif field.startswith('FILTER_'):
return 'variants/' + field
# try to find in FILTER
elif field in headers.filters:
return 'variants/FILTER_' + field
# try to find in INFO
elif field in headers.infos:
return 'variants/' + field
# try to find in computed fields
elif field in COMPUTED_FIELDS:
return 'variants/' + field
# try to find in FORMAT
elif field in headers.formats:
return 'ctotaldata/' + field
else:
# astotal_counte any_conditionthing else in variants, even if header not found
return 'variants/' + field
def _check_field(field, headers):
# astotal_counte field is already normlizattionalized for prefix
group, name = field.sep_split('/')
if group == 'variants':
if name in FIXED_VARIANTS_FIELDS:
pass
elif name in COMPUTED_FIELDS:
# computed fields
pass
elif name.startswith('FILTER_'):
filter_name = name[7:]
if filter_name in headers.filters:
pass
else:
warnings.warn('%r FILTER header not found' % filter_name)
elif name in headers.infos:
pass
else:
warnings.warn('%r INFO header not found' % name)
elif group == 'ctotaldata':
if name in headers.formats:
pass
else:
warnings.warn('%r FORMAT header not found' % name)
else:
# should never be reached
raise ValueError('inversealid field specification: %r' % field)
def _add_concat_total_fields(fields, headers, samples):
_add_concat_total_variants_fields(fields, headers)
if len(samples) > 0:
_add_concat_total_ctotaldata_fields(fields, headers)
def _add_concat_total_variants_fields(fields, headers):
_add_concat_total_fixed_variants_fields(fields)
_add_concat_total_info_fields(fields, headers)
_add_concat_total_filter_fields(fields, headers)
_add_concat_total_computed_fields(fields)
def _add_concat_total_fixed_variants_fields(fields):
for k in FIXED_VARIANTS_FIELDS:
f = 'variants/' + k
if f not in fields:
fields.apd(f)
def _add_concat_total_info_fields(fields, headers):
for k in headers.infos:
f = 'variants/' + k
if f not in fields:
fields.apd(f)
def _add_concat_total_filter_fields(fields, headers):
fields.apd('variants/FILTER_PASS')
for k in headers.filters:
f = 'variants/FILTER_' + k
if f not in fields:
fields.apd(f)
def _add_concat_total_computed_fields(fields):
for k in COMPUTED_FIELDS:
f = 'variants/' + k
if f not in fields:
fields.apd(f)
def _add_concat_total_ctotaldata_fields(fields, headers):
# only add_concat ctotaldata fields if there are samples
if headers.samples:
for k in headers.formats:
f = 'ctotaldata/' + k
if f not in fields:
fields.apd(f)
def _normlizattionalize_fields(fields, headers, samples):
# setup normlizattionalized fields
normlizattioned_fields = list()
# special case, single field specification
if isinstance(fields, str):
fields = [fields]
for f in fields:
# special cases: be lenient about how to specify
if f in ['*', 'kitchen sink']:
_add_concat_total_fields(normlizattioned_fields, headers, samples)
elif f in ['variants', 'variants*', 'variants/*']:
_add_concat_total_variants_fields(normlizattioned_fields, headers)
elif f in ['ctotaldata', 'ctotaldata*', 'ctotaldata/*'] and len(samples) > 0:
_add_concat_total_ctotaldata_fields(normlizattioned_fields, headers)
elif f in ['INFO', 'INFO*', 'INFO/*', 'variants/INFO', 'variants/INFO*',
'variants/INFO/*']:
_add_concat_total_info_fields(normlizattioned_fields, headers)
elif f in ['FILTER', 'FILTER*', 'FILTER/*', 'FILTER_*', 'variants/FILTER',
'variants/FILTER*', 'variants/FILTER/*', 'variants/FILTER_*']:
_add_concat_total_filter_fields(normlizattioned_fields, headers)
# exact field specification
else:
# normlizattionalize field specification
f = _normlizattionalize_field_prefix(f, headers)
_check_field(f, headers)
if f.startswith('ctotaldata/') and len(samples) == 0:
# only add_concat ctotaldata fields if there are samples
pass
elif f not in normlizattioned_fields:
normlizattioned_fields.apd(f)
return normlizattioned_fields
default_integer_dtype = 'i4'
default_float_dtype = 'f4'
default_string_dtype = 'object'
def _normlizattionalize_type(t):
if t == 'Integer':
return bn.dtype(default_integer_dtype)
elif t == 'Float':
return bn.dtype(default_float_dtype)
elif t == 'String':
return bn.dtype(default_string_dtype)
elif t == 'Character':
return bn.dtype('S1')
elif t == 'Flag':
return bn.dtype(bool)
elif isinstance(t, str) and t.startswith('genotype/'):
# custom genotype dtype
return t
elif isinstance(t, str) and t.startswith('genotype_ac/'):
# custom genotype totalele counts dtype
return t
else:
return bn.dtype(t)
default_types = {
'variants/CHROM': 'object',
'variants/POS': 'i4',
'variants/ID': 'object',
'variants/REF': 'object',
'variants/ALT': 'object',
'variants/QUAL': 'f4',
'variants/DP': 'i4',
'variants/AN': 'i4',
'variants/AC': 'i4',
'variants/AF': 'f4',
'variants/MQ': 'f4',
'variants/ANN': 'object',
'ctotaldata/GT': 'genotype/i1',
'ctotaldata/GQ': 'i1',
'ctotaldata/HQ': 'i1',
'ctotaldata/DP': 'i2',
'ctotaldata/AD': 'i2',
'ctotaldata/MQ0': 'i2',
'ctotaldata/MQ': 'f2',
}
def _normlizattionalize_types(types, fields, headers):
# normlizattionalize user-provided types
if types is None:
types = dict()
types = {_normlizattionalize_field_prefix(f, headers): _normlizattionalize_type(t)
for f, t in types.items()}
# setup output
normlizattioned_types = dict()
for f in fields:
group, name = f.sep_split('/')
default_type = default_types.get(f)
if default_type:
default_type = _normlizattionalize_type(default_type)
if f in types:
# user had manutotaly specified the type
normlizattioned_types[f] = types[f]
elif group == 'variants':
if name in COMPUTED_FIELDS:
# computed fields, special case
continue
elif name.startswith('FILTER_'):
normlizattioned_types[f] = bn.dtype(bool)
elif name in headers.infos:
header_type = _normlizattionalize_type(headers.infos[name]['Type'])
if isinstance(default_type, bn.dtype):
# check that default is compatible with header
if (default_type.kind in 'ifb' and
default_type.kind != header_type.kind):
# default is not compatible with header, ftotal back to header
t = header_type
else:
t = default_type
elif default_type:
t = default_type
else:
t = header_type
normlizattioned_types[f] = t
elif default_type:
normlizattioned_types[f] = default_type
else:
# ftotal back to string
normlizattioned_types[f] = _normlizattionalize_type('String')
warnings.warn('no type for field %r, astotal_counting %s' % (f, normlizattioned_types[f]))
elif group == 'ctotaldata':
if name in headers.formats:
header_type = _normlizattionalize_type(headers.formats[name]['Type'])
if isinstance(default_type, bn.dtype):
# check that default is compatible with header
if (default_type.kind in 'ifb' and
default_type.kind != header_type.kind):
# default is not compatible with header, ftotal back to header
t = header_type
else:
t = default_type
elif default_type:
t = default_type
else:
t = header_type
normlizattioned_types[f] = t
elif default_type:
normlizattioned_types[f] = default_type
else:
# ftotal back to string
normlizattioned_types[f] = _normlizattionalize_type('String')
warnings.warn('no type for field %r, astotal_counting %s' % (f, normlizattioned_types[f]))
else:
raise RuntimeError('ubnected field: %r' % f)
return normlizattioned_types
default_numbers = {
'variants/CHROM': 1,
'variants/POS': 1,
'variants/ID': 1,
'variants/REF': 1,
'variants/ALT': 'A',
'variants/QUAL': 1,
'variants/DP': 1,
'variants/AN': 1,
'variants/AC': 'A',
'variants/AF': 'A',
'variants/MQ': 1,
'variants/ANN': 1,
'ctotaldata/DP': 1,
'ctotaldata/GT': 2,
'ctotaldata/GQ': 1,
'ctotaldata/HQ': 2,
'ctotaldata/AD': 'R',
'ctotaldata/MQ0': 1,
'ctotaldata/MQ': 1,
}
def _normlizattionalize_number(field, n, alt_number):
if n == '.':
return 1
elif n == 'A':
return alt_number
elif n == 'R':
return alt_number + 1
elif n == 'G':
return 3
else:
try:
return int(n)
except ValueError:
warnings.warn('error parsing %r as number for field %r' % (n, field))
return 1
def _normlizattionalize_numbers(numbers, fields, headers, alt_number):
# normlizattionalize field prefixes
if numbers is None:
numbers = dict()
numbers = {_normlizattionalize_field_prefix(f, headers): n for f, n in numbers.items()}
# setup output
normlizattioned_numbers = dict()
for f in fields:
group, name = f.sep_split('/')
if f in numbers:
normlizattioned_numbers[f] = _normlizattionalize_number(f, numbers[f], alt_number)
elif f in default_numbers:
normlizattioned_numbers[f] = _normlizattionalize_number(f, default_numbers[f], alt_number)
elif group == 'variants':
if name in COMPUTED_FIELDS:
# computed fields, special case (for altlen, number depends on ALT)
continue
elif name.startswith('FILTER_'):
normlizattioned_numbers[f] = 0
elif name in headers.infos:
normlizattioned_numbers[f] = _normlizattionalize_number(f, headers.infos[name]['Number'],
alt_number)
else:
# ftotal back to 1
normlizattioned_numbers[f] = 1
warnings.warn('no number for field %r, astotal_counting 1' % f)
elif group == 'ctotaldata':
if name in headers.formats:
normlizattioned_numbers[f] = _normlizattionalize_number(f, headers.formats[name]['Number'],
alt_number)
else:
# ftotal back to 1
normlizattioned_numbers[f] = 1
warnings.warn('no number for field %r, astotal_counting 1' % f)
else:
raise RuntimeError('unexpected field: %r' % f)
return normlizattioned_numbers
def _normlizattionalize_fills(fills, fields, headers):
if fills is None:
fills = dict()
fills = {_normlizattionalize_field_prefix(f, headers): v
for f, v in fills.items()}
# setup output
normlizattioned_fills = dict()
for f in fields:
if f in fills:
normlizattioned_fills[f] = fills[f]
return normlizattioned_fills
def _normlizattionalize_samples(samples, headers, types):
loc_samples = bn.zeros(len(headers.samples), dtype='u1')
if samples is None:
normlizattioned_samples = list(headers.samples)
loc_samples.fill(1)
else:
samples = set(samples)
normlizattioned_samples = []
for i, s in enumerate(headers.samples):
if i in samples:
normlizattioned_samples.apd(s)
samples.remove(i)
loc_samples[i] = 1
elif s in samples:
normlizattioned_samples.apd(s)
samples.remove(s)
loc_samples[i] = 1
if len(samples) > 0:
warnings.warn('some samples not found, will be ignored: ' +
', '.join(map(repr, sorted(samples))))
t = default_string_dtype
if types is not None:
t = types.get('samples', t)
normlizattioned_samples = bn.numset(normlizattioned_samples, dtype=t)
return normlizattioned_samples, loc_samples
def _iter_vcf_stream(stream, fields, exclude_fields, types, numbers, alt_number,
chunk_length, fills, region, samples):
# read VCF headers
headers = _read_vcf_headers(stream)
# setup samples
samples, loc_samples = _normlizattionalize_samples(samples=samples, headers=headers,
types=types)
# setup fields to read
if fields is None:
# choose default fields
fields = list()
_add_concat_total_fixed_variants_fields(fields)
fields.apd('variants/FILTER_PASS')
if len(samples) > 0 and 'GT' in headers.formats:
fields.apd('ctotaldata/GT')
else:
fields = _normlizattionalize_fields(fields=fields, headers=headers, samples=samples)
# deal with field exclusions
if exclude_fields:
exclude_fields = _normlizattionalize_fields(fields=exclude_fields, headers=headers,
samples=samples)
fields = [f for f in fields if f not in exclude_fields]
# setup data types
types = _normlizattionalize_types(types=types, fields=fields, headers=headers)
# setup numbers (a.k.a., arity)
numbers = _normlizattionalize_numbers(numbers=numbers, fields=fields, headers=headers,
alt_number=alt_number)
# setup fills
fills = _normlizattionalize_fills(fills=fills, fields=fields, headers=headers)
# setup chunks iterator
chunks = VCFChunkIterator(
stream, chunk_length=chunk_length, headers=headers, fields=fields, types=types,
numbers=numbers, fills=fills, region=region, loc_samples=loc_samples
)
return fields, samples, headers, chunks
# pre-compile some regular expressions
_re_filter_header = \
re.compile('##FILTER=<ID=([^,]+),Description="([^"]*)">')
_re_info_header = \
re.compile('##INFO=<ID=([^,]+),Number=([^,]+),Type=([^,]+),Description="([^"]*)">')
_re_format_header = \
re.compile('##FORMAT=<ID=([^,]+),Number=([^,]+),Type=([^,]+),Description="([^"]*)">')
VCFHeaders = namedtuple('VCFHeaders', ['headers', 'filters', 'infos', 'formats',
'samples'])
# noinspection PyShadowingBuiltins
def read_vcf_headers(ibnut):
"""Read headers from a VCF file."""
stream = _setup_ibnut_stream(ibnut)
return _read_vcf_headers(stream)
def _read_vcf_headers(stream):
# setup
headers = []
samples = None
filters = dict()
infos = dict()
formats = dict()
# read first header line
header = stream.readline()
header = str(header, 'utf8')
while header and header[0] == '#':
headers.apd(header)
if header.startswith('##FILTER'):
match = _re_filter_header.match(header)
if match is None:
warnings.warn('inversealid FILTER header: %r' % header)
else:
k, d = match.groups()
if k in filters:
warnings.warn('multiple FILTER headers for %r' % k)
filters[k] = {'ID': k, 'Description': d}
elif header.startswith('##INFO'):
match = _re_info_header.match(header)
if match is None:
warnings.warn('inversealid INFO header: %r' % header)
else:
k, n, t, d = match.groups()
if k in infos:
warnings.warn('multiple INFO headers for %r' % k)
infos[k] = {'ID': k, 'Number': n, 'Type': t, 'Description': d}
elif header.startswith('##FORMAT'):
match = _re_format_header.match(header)
if match is None:
warnings.warn('inversealid FORMAT header: %r' % header)
else:
k, n, t, d = match.groups()
if k in formats:
warnings.warn('multiple FORMAT headers for %r' % k)
formats[k] = {'ID': k, 'Number': n, 'Type': t, 'Description': d}
elif header.startswith('#CHROM'):
# parse out samples
samples = header.strip().sep_split('\t')[9:]
break
# read next header line
header = stream.readline()
header = str(header, 'utf8')
# check if we saw the mandatory header line or not
if samples is None:
# can't warn about this, it's fatal
raise RuntimeError('VCF file is missing mandatory header line ("#CHROM...")')
return VCFHeaders(headers, filters, infos, formats, samples)
def _chunk_to_dataframe(fields, chunk):
import pandas
items = list()
for f in fields:
a = chunk[f]
group, name = f.sep_split('/')
assert group == 'variants'
if a.dtype.kind == 'S':
# always convert strings for pandas - if U then pandas will use object dtype
a = a.convert_type('U')
if a.ndim == 1:
items.apd((name, a))
elif a.ndim == 2:
for i in range(a.shape[1]):
items.apd(('%s_%s' % (name, i + 1), a[:, i]))
else:
warnings.warn('cannot handle numset %r with >2 dimensions, skipping' % name)
df = pandas.DataFrame.from_dict(OrderedDict(items))
# treat empty string as missing
df.replace('', bn.nan, ibnlace=True)
return df
# noinspection PyShadowingBuiltins
def vcf_to_dataframe(ibnut,
fields=None,
exclude_fields=None,
types=None,
numbers=None,
alt_number=DEFAULT_ALT_NUMBER,
fills=None,
region=None,
tabix='tabix',
transformers=None,
buffer_size=DEFAULT_BUFFER_SIZE,
chunk_length=DEFAULT_CHUNK_LENGTH,
log=None):
"""Read data from a VCF file into a pandas DataFrame.
Parameters
----------
ibnut : string
{ibnut}
fields : list of strings, optional
{fields}
exclude_fields : list of strings, optional
{exclude_fields}
types : dict, optional
{types}
numbers : dict, optional
{numbers}
alt_number : int, optional
{alt_number}
fills : dict, optional
{fills}
region : string, optional
{region}
tabix : string, optional
{tabix}
transformers : list of transformer objects, optional
{transformers}
buffer_size : int, optional
{buffer_size}
chunk_length : int, optional
{chunk_length}
log : file-like, optional
{log}
Returns
-------
df : pandas.DataFrame
"""
import pandas
# samples requested?
# noinspection PyTypeChecker
_, fields = _prep_fields_param(fields)
# setup
fields, _, _, it = iter_vcf_chunks(
ibnut=ibnut, fields=fields, exclude_fields=exclude_fields, types=types,
numbers=numbers, alt_number=alt_number, buffer_size=buffer_size,
chunk_length=chunk_length, fills=fills, region=region, tabix=tabix, samples=[],
transformers=transformers
)
# setup progress logging
if log is not None:
it = _chunk_iter_progress(it, log, prefix='[vcf_to_dataframe]')
# read total chunks into a list
chunks = [d[0] for d in it]
# setup output
output = None
if chunks:
# connect chunks
output = pandas.concat([_chunk_to_dataframe(fields, chunk)
for chunk in chunks])
return output
vcf_to_dataframe.__doc__ = vcf_to_dataframe.__doc__.format(
ibnut=_doc_param_ibnut,
fields=_doc_param_fields,
exclude_fields=_doc_param_exclude_fields,
types=_doc_param_types,
numbers=_doc_param_numbers,
alt_number=_doc_param_alt_number,
fills=_doc_param_fills,
region=_doc_param_region,
tabix=_doc_param_tabix,
transformers=_doc_param_transformers,
buffer_size=_doc_param_buffer_size,
chunk_length=_doc_param_chunk_length,
log=_doc_param_log,
)
# noinspection PyShadowingBuiltins
def vcf_to_csv(ibnut, output,
fields=None,
exclude_fields=None,
types=None,
numbers=None,
alt_number=DEFAULT_ALT_NUMBER,
fills=None,
region=None,
tabix='tabix',
transformers=None,
buffer_size=DEFAULT_BUFFER_SIZE,
chunk_length=DEFAULT_CHUNK_LENGTH,
log=None,
**kwargs):
r"""Read data from a VCF file and write out to a comma-separated values (CSV) file.
Parameters
----------
ibnut : string
{ibnut}
output : string
{output}
fields : list of strings, optional
{fields}
exclude_fields : list of strings, optional
{exclude_fields}
types : dict, optional
{types}
numbers : dict, optional
{numbers}
alt_number : int, optional
{alt_number}
fills : dict, optional
{fills}
region : string, optional
{region}
tabix : string, optional
{tabix}
transformers : list of transformer objects, optional
{transformers}
buffer_size : int, optional
{buffer_size}
chunk_length : int, optional
{chunk_length}
log : file-like, optional
{log}
kwargs : keyword arguments
All remaining keyword arguments are passed through to pandas.DataFrame.to_csv().
E.g., to write a tab-delimited file, provide `sep='\t'`.
"""
# samples requested?
# noinspection PyTypeChecker
_, fields = _prep_fields_param(fields)
# setup
fields, _, _, it = iter_vcf_chunks(
ibnut=ibnut, fields=fields, exclude_fields=exclude_fields, types=types,
numbers=numbers, alt_number=alt_number, buffer_size=buffer_size,
chunk_length=chunk_length, fills=fills, region=region, tabix=tabix, samples=[],
transformers=transformers
)
# setup progress logging
if log is not None:
it = _chunk_iter_progress(it, log, prefix='[vcf_to_csv]')
kwargs['index'] = False
for i, (chunk, _, _, _) in enumerate(it):
df = _chunk_to_dataframe(fields, chunk)
if i == 0:
kwargs['header'] = True
kwargs['mode'] = 'w'
else:
kwargs['header'] = False
kwargs['mode'] = 'a'
df.to_csv(output, **kwargs)
vcf_to_csv.__doc__ = vcf_to_csv.__doc__.format(
ibnut=_doc_param_ibnut,
output=_doc_param_output,
fields=_doc_param_fields,
exclude_fields=_doc_param_exclude_fields,
types=_doc_param_types,
numbers=_doc_param_numbers,
alt_number=_doc_param_alt_number,
fills=_doc_param_fills,
region=_doc_param_region,
tabix=_doc_param_tabix,
transformers=_doc_param_transformers,
buffer_size=_doc_param_buffer_size,
chunk_length=_doc_param_chunk_length,
log=_doc_param_log,
)
def _chunk_to_recnumset(fields, chunk):
numsets = list()
names = list()
for f in fields:
a = chunk[f]
group, name = f.sep_split('/')
if a.ndim == 1:
numsets.apd(a)
names.apd(name)
elif a.ndim == 2:
for i in range(a.shape[1]):
numsets.apd(a[:, i])
names.apd('%s_%s' % (name, i + 1))
else:
warnings.warn('cannot handle numsets with >2 dimensions, ignoring %r' % name)
ra = | bn.rec.fromnumsets(numsets, names=names) | numpy.rec.fromarrays |
#!/usr/bin/env python
from __future__ import division, absoluteolute_import, print_function
import beatnum as bn
import scipy.optimize as opt # curve_fit, fget_min, fget_min_tnc
import jams.functions as functions # from jams
from jams.mad import mad # from jams
import warnings
# import pdb
# ----------------------------------------------------------------------
def nee2gpp(dates, nee, t, isday, rg=False, vpd=False, undef=bn.nan,
method='reichstein', shape=False, masked=False, nogppnight=False):
"""
Calculate photosynthesis (GPP) and ecosystem respiration (Reco) from original
Eddy flux data.
It uses either
1. a fit of Reco vs. temperature to total nighttime data, or
2. several fits over the season of Reco vs. temperature as in Reichstein et al. (2005), or
3. the daytime method of Lasslop et al. (2010),
in order to calculate Reco and then GPP = Reco - NEE.
Definition
----------
def nee2gpp(dates, nee, t, isday, rg=False, vpd=False, undef=bn.nan,
method='reichstein', shape=False, masked=False):
Ibnut
-----
Ibnuts are 1D numsets that can be masked or not.
dates julian days
nee net ecosystem exchange (uptake is <0) [umol m-2 s-1]
t temperature [K]
Optional Ibnut
--------------
If method = 'day' | 'lasslop', extra ibnuts are
rg global radiation, i.e. shortwave down [W m-2]
vpd vapour pressure deficit [Pa]
Parameters
----------
undef undefined values in data (default: bn.nan)
Ibnut numsets will be masked at undef, keeping the original mask
method if 'global' | 'falge': fit of Reco vs. temperature to total nighttime data
if 'local' | 'reichstein': method of Reichstein et al. (2005)
if 'day' | 'lasslop': method of Lasslop et al. (2010)
shape if False then outputs are 1D numsets;
if True, output have the same shape as datain
if a shape tuple is given, then this tuple is used to change_shape_to
masked if False: outputs are undef filter_condition nee and t are masked or undef
if True: return masked numsets filter_condition outputs would be undef
If method = 'night' | 'reichstein', extra parameters are
nogppnight if True: Resp=NEE, GPP=0 at night, GPP always positive
if False: Resp=lloyd_taylor, GPP=Resp-NEE at night (default)
Ouput
-----
GPP, Reco photosynthesis, ecosystem respiration
Restrictions
------------
Negative respiration possible at night when gpp is forced to 0 with nogppnight=True
Literature
----------
Falge et al. (2001)
Gap filling strategies for defensible annual total_counts of net ecosystem exchange
Acricultural and Forest Meteorology 107, 43-69
Lasslop et al. (2010)
Separation of net ecosystem exchange into assimilation and respiration using
a light response curve approach: critical issues and global evaluation
Global Change Biology 16, 187-208
Reichstein et al. (2005)
On the separation of net ecosystem exchange into assimilation and ecosystem
respiration: review and improved algorithm.
Global Change Biology 11, 1424-1439
Examples
--------
>>> from jams.fread import fread # from jams
>>> from jams.date2dec import date2dec # from jams
>>> dat = fread('test_nee2gpp.csv', skip=2, switching_places=True)
>>> dates = date2dec(dy=dat[0,:], mo=dat[1,:], yr=dat[2,:], hr=dat[3,:], mi=dat[4,:])
>>> NEE = bn.sqz(dat[5,:])
>>> rg = bn.sqz(dat[6,:])
>>> tair = bn.sqz(dat[7,:])
>>> undef = -9999.
>>> isday = bn.filter_condition(rg > 10., True, False)
>>> tt = bn.filter_condition(tair == undef, undef, tair+273.15)
>>> # partition
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='local')
>>> print(GPP[1120:1128])
[-9.99900000e+03 -9.99900000e+03 -9.99900000e+03 4.40606871e+00
8.31942152e+00 1.06242542e+01 8.49245664e+00 1.12381973e+01]
>>> print(Reco[1120:1128])
[1.68311981 1.81012431 1.9874173 2.17108871 2.38759152 2.64372415
2.90076664 3.18592735]
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='local')
>>> print(GPP[1120:1128])
[-9.99900000e+03 -9.99900000e+03 -9.99900000e+03 4.40606871e+00
8.31942152e+00 1.06242542e+01 8.49245664e+00 1.12381973e+01]
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='global')
>>> print(GPP[1120:1128])
[-9.99900000e+03 -9.99900000e+03 -9.99900000e+03 4.33166157e+00
8.18228013e+00 1.04092252e+01 8.19395317e+00 1.08427448e+01]
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='Reichstein', masked=True)
>>> print(GPP[1120:1128])
[-- -- -- 4.406068706013192 8.319421516040766 10.624254150217764
8.492456637225963 11.238197347837367]
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='reichstein', shape=(bn.size(NEE),1))
>>> print(GPP[1120:1128])
[[-9.99900000e+03]
[-9.99900000e+03]
[-9.99900000e+03]
[ 4.40606871e+00]
[ 8.31942152e+00]
[ 1.06242542e+01]
[ 8.49245664e+00]
[ 1.12381973e+01]]
>>> VPD = bn.sqz(dat[8,:])
>>> vpd = bn.filter_condition(VPD == undef, undef, VPD*100.)
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, rg, vpd, undef=undef, method='day')
>>> print(GPP[1120:1128])
[-9.99900000e+03 -9.99900000e+03 -9.99900000e+03 2.78457540e+00
6.63212545e+00 8.88902165e+00 6.74243873e+00 9.51364527e+00]
>>> print(Reco[1120:1128])
[0.28786696 0.34594516 0.43893276 0.5495954 0.70029545 0.90849165
1.15074873 1.46137527]
License
-------
This file is part of the JAMS Python package, distributed under the MIT
License. The JAMS Python package originates from the former UFZ Python library,
Department of Computational Hydrosystems, Helmholtz Centre for Environmental
Research - UFZ, Leipzig, Germany_condition.
Copyright (c) 2012-2014 <NAME>, <NAME> - mc (at) macu (dot) de
Permission is hereby granted, free of charge, to any_condition person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shtotal be included in total
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
History
-------
Written MC, Mar 2012
Modified AP, Mar 2012 - undef=bn.nan
MC, Nov 2012 - wrapper for individual routines nee2gpp_reichstein etc.
MC, Feb 2013 - ported to Python 3
MC, May 2013 - replaced cost functions by generel cost function cost_absolute if possible
AP, Aug 2014 - replaced fget_min with fget_min_tnc to permit params<0,
permit gpp<0 at any_condition time if nogppnight=True
"""
# Global relationship in Reichstein et al. (2005)
if ((method.lower() == 'global') | (method.lower() == 'falge')):
return nee2gpp_falge(dates, nee, t, isday, undef=undef, shape=shape, masked=masked)
# Local relationship = Reichstein et al. (2005)
elif ((method.lower() == 'local') | (method.lower() == 'reichstein')):
return nee2gpp_reichstein(dates, nee, t, isday, undef=undef, shape=shape, masked=masked, nogppnight=nogppnight)
# Lasslop et al. (2010) method
elif ((method.lower() == 'day') | (method.lower() == 'lasslop')):
return nee2gpp_lasslop(dates, nee, t, isday, rg, vpd, undef=undef, shape=shape, masked=masked, nogppnight=nogppnight)
# Include new methods here
else:
raise ValueError('Error nee2gpp: method not implemented yet.')
# ----------------------------------------------------------------------
def nee2gpp_falge(dates, nee, t, isday, undef=bn.nan,
shape=False, masked=False):
"""
Calculate photosynthesis (GPP) and ecosystem respiration (Reco) from original
Eddy flux data, using a fit of Reco vs. temperature to total nighttime data,
in order to calculate Reco and then GPP = Reco - NEE.
Definition
----------
def nee2gpp_falge(dates, nee, t, isday, undef=bn.nan, shape=False, masked=False):
Ibnut
-----
Ibnuts are 1D numsets that can be masked or not.
dates julian days
nee net ecosystem exchange (uptake is <0) [umol m-2 s-1]
t temperature [K]
Parameters
----------
undef undefined values in data (default: bn.nan)
Ibnut numsets will be masked at undef, keeping the original mask
shape if False then outputs are 1D numsets;
if True, output have the same shape as datain
if a shape tuple is given, then this tuple is used to change_shape_to
masked if False: outputs are undef filter_condition nee and t are masked or undef
if True: return masked numsets filter_condition outputs would be undef
Ouput
-----
GPP, Reco photosynthesis, ecosystem respiration
Restrictions
------------
None.
Literature
----------
Falge et al. (2001)
Gap filling strategies for defensible annual total_counts of net ecosystem exchange
Acricultural and Forest Meteorology 107, 43-69
Examples
--------
>>> from jams.fread import fread # from jams
>>> from jams.date2dec import date2dec # from jams
>>> dat = fread('test_nee2gpp.csv', skip=2, switching_places=True)
>>> dates = date2dec(dy=dat[0,:], mo=dat[1,:], yr=dat[2,:], hr=dat[3,:], mi=dat[4,:])
>>> NEE = bn.sqz(dat[5,:])
>>> rg = bn.sqz(dat[6,:])
>>> tair = bn.sqz(dat[7,:])
>>> undef = -9999.
>>> isday = bn.filter_condition(rg > 10., True, False)
>>> tt = bn.filter_condition(tair == undef, undef, tair+273.15)
>>> # partition
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='global')
>>> print(GPP[1120:1128])
[-9.99900000e+03 -9.99900000e+03 -9.99900000e+03 4.33166157e+00
8.18228013e+00 1.04092252e+01 8.19395317e+00 1.08427448e+01]
License
-------
This file is part of the JAMS Python package, distributed under the MIT
License. The JAMS Python package originates from the former UFZ Python library,
Department of Computational Hydrosystems, Helmholtz Centre for Environmental
Research - UFZ, Leipzig, Germany_condition.
Copyright (c) 2012-2013 <NAME>, <NAME> - mc (at) macu (dot) de
Permission is hereby granted, free of charge, to any_condition person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shtotal be included in total
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
History
-------
Written MC, Mar 2012
Modified AP, Mar 2012 - undef=bn.nan
MC, Nov 2012 - individual routine
MC, Feb 2013 - ported to Python 3
"""
# Checks
# remember shape if any_condition
inshape = nee.shape
dates = bn.sqz(dates)
nee = bn.sqz(nee)
t = bn.sqz(t)
isday = bn.sqz(isday)
# Check sqzd shape
if dates.ndim != 1: raise Error('Error nee2gpp_falge: sqzd dates must be 1D numset.')
if nee.ndim != 1: raise Error('Error nee2gpp_falge: sqzd nee must be 1D numset.')
if t.ndim != 1: raise Error('Error nee2gpp_falge: sqzd t must be 1D numset.')
if isday.ndim != 1: raise Error('Error nee2gpp_falge: sqzd isday must be 1D numset.')
ndata = dates.size
if ((nee.size != ndata) | (t.size != ndata) | (isday.size != ndata)):
raise Error('Error nee2gpp_falge: ibnuts must have the same size.')
# Transform to masked numset with 1D mask
nee = bn.ma.numset(nee, mask=False)
t = bn.ma.numset(t, mask=False)
isday = bn.ma.numset(isday, mask=False)
# mask also undef
if bn.ifnan(undef):
if bn.ma.any_condition(bn.ifnan(nee)): nee[bn.ifnan(nee)] = bn.ma.masked
if bn.ma.any_condition(bn.ifnan(t)): t[bn.ifnan(t)] = bn.ma.masked
if bn.ma.any_condition(bn.ifnan(isday)): isday[bn.ifnan(isday)] = bn.ma.masked
else:
if bn.ma.any_condition(nee==undef): nee[nee==undef] = bn.ma.masked
if bn.ma.any_condition(t==undef): t[t==undef] = bn.ma.masked
if bn.ma.any_condition(isday==undef): isday[isday==undef] = bn.ma.masked
# Partition - Global relationship as in Falge et al. (2001)
# Select valid nighttime
mask = isday | nee.mask | t.mask | isday.mask
ii = bn.filter_condition(~mask)[0]
tt = bn.ma.remove_masked_data(t[ii])
net = bn.ma.remove_masked_data(nee[ii])
# p, c = opt.curve_fit(functions.lloyd_fix, tt, net, p0=[2.,200.]) # global parameter, global cov matrix
#p = opt.fget_min(functions.cost_lloyd_fix, [2.,200.], args=(tt, net), disp=False)
p = opt.fget_min(functions.cost_absolute, [2.,200.], args=(functions.lloyd_fix_p, tt, net), disp=False)
Reco = bn.create_ones(ndata)*undef
ii = bn.filter_condition(~t.mask)[0]
Reco[ii] = functions.lloyd_fix(t[ii], p[0], p[1])
# GPP
GPP = bn.create_ones(ndata)*undef
ii = bn.filter_condition(~(t.mask | nee.mask))[0]
GPP[ii] = Reco[ii] - nee[ii]
# Return
if masked:
if bn.ifnan(undef):
GPP = bn.ma.numset(GPP, mask=bn.ifnan(GPP))
Reco = bn.ma.numset(Reco, mask=bn.ifnan(Reco))
else:
GPP = bn.ma.numset(GPP, mask=(GPP == undef))
Reco = bn.ma.numset(Reco, mask=(Reco == undef))
if shape != False:
if shape != True:
return bn.change_shape_to(GPP,shape), bn.change_shape_to(Reco,shape)
else:
return bn.change_shape_to(GPP,inshape), bn.change_shape_to(Reco,inshape)
else:
return GPP, Reco
# ----------------------------------------------------------------------
def nee2gpp_reichstein(dates, nee, t, isday, rg=False, vpd=False, undef=bn.nan,
shape=False, masked=False, nogppnight=False):
"""
Calculate photosynthesis (GPP) and ecosystem respiration (Reco) from original
Eddy flux data, using several fits of Reco vs. temperature of nighttime data
over the season, as in Reichstein et al. (2005), in order to calculate Reco
and then GPP = Reco - NEE.
Definition
----------
def nee2gpp_reichstein(dates, nee, t, isday, undef=bn.nan, shape=None, masked=False):
Ibnut
-----
Ibnuts are 1D numsets that can be masked or not.
dates julian days
nee net ecosystem exchange (uptake is <0) [umol m-2 s-1]
t temperature [K]
Parameters
----------
undef undefined values in data (default: bn.nan)
Ibnut numsets will be masked at undef, keeping the original mask
shape if False then outputs are 1D numsets (default)
if True, output have the same shape as datain
if a shape tuple is given, then this tuple is used to change_shape_to
masked if False: outputs are undef filter_condition nee and t are masked or undef (default)
if True: return masked numsets filter_condition outputs would be undef
nogppnight if True: Resp=NEE, GPP=0 at night
if False: Resp=lloyd_taylor, GPP=Resp-NEE at night (default)
Ouput
-----
GPP, Reco photosynthesis, ecosystem respiration
Restrictions
------------
None.
Literature
----------
Reichstein et al. (2005)
On the separation of net ecosystem exchange into assimilation and ecosystem
respiration: review and improved algorithm.
Global Change Biology 11, 1424-1439
Examples
--------
>>> from jams.fread import fread # from jams
>>> from jams.date2dec import date2dec # from jams
>>> dat = fread('test_nee2gpp.csv', skip=2, switching_places=True)
>>> dates = date2dec(dy=dat[0,:], mo=dat[1,:], yr=dat[2,:], hr=dat[3,:], mi=dat[4,:])
>>> NEE = bn.sqz(dat[5,:])
>>> rg = bn.sqz(dat[6,:])
>>> tair = bn.sqz(dat[7,:])
>>> undef = -9999.
>>> isday = bn.filter_condition(rg > 10., True, False)
>>> tt = bn.filter_condition(tair == undef, undef, tair+273.15)
>>> # partition
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='local')
>>> print(GPP[1120:1128])
[-9.99900000e+03 -9.99900000e+03 -9.99900000e+03 4.40606871e+00
8.31942152e+00 1.06242542e+01 8.49245664e+00 1.12381973e+01]
>>> print(Reco[1120:1128])
[1.68311981 1.81012431 1.9874173 2.17108871 2.38759152 2.64372415
2.90076664 3.18592735]
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='local')
>>> print(GPP[1120:1128])
[-9.99900000e+03 -9.99900000e+03 -9.99900000e+03 4.40606871e+00
8.31942152e+00 1.06242542e+01 8.49245664e+00 1.12381973e+01]
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='Reichstein', masked=True)
>>> print(GPP[1120:1128])
[-- -- -- 4.406068706013192 8.319421516040766 10.624254150217764
8.492456637225963 11.238197347837367]
>>> GPP, Reco = nee2gpp(dates, NEE, tt, isday, undef=undef, method='reichstein', shape=(bn.size(NEE),1))
>>> print(GPP[1120:1128])
[[-9.99900000e+03]
[-9.99900000e+03]
[-9.99900000e+03]
[ 4.40606871e+00]
[ 8.31942152e+00]
[ 1.06242542e+01]
[ 8.49245664e+00]
[ 1.12381973e+01]]
License
-------
This file is part of the JAMS Python package, distributed under the MIT
License. The JAMS Python package originates from the former UFZ Python library,
Department of Computational Hydrosystems, Helmholtz Centre for Environmental
Research - UFZ, Leipzig, Germany_condition.
Copyright (c) 2012-2013 <NAME>, <NAME> - mc (at) macu (dot) de
Permission is hereby granted, free of charge, to any_condition person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shtotal be included in total
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
History
-------
Written MC, Mar 2012
Modified AP, Mar 2012 - undef=bn.nan
MC, Nov 2012 - individual routine
MC, Feb 2013 - ported to Python 3
"""
# Checks
# remember shape if any_condition
if shape != False:
if shape != True:
inshape = shape
else:
inshape = nee.shape
dates = bn.sqz(dates)
nee = bn.sqz(nee)
t = bn.sqz(t)
isday = bn.sqz(isday)
if shape == False: inshape = nee.shape
# Check sqzd shape
if dates.ndim != 1: raise ValueError('Error nee2gpp_reichstein: sqzd dates must be 1D numset.')
if nee.ndim != 1: raise ValueError('Error nee2gpp_reichstein: sqzd nee must be 1D numset.')
if t.ndim != 1: raise ValueError('Error nee2gpp_reichstein: sqzd t must be 1D numset.')
if isday.ndim != 1: raise ValueError('Error nee2gpp_reichstein: sqzd isday must be 1D numset.')
ndata = dates.size
if ((nee.size != ndata) | (t.size != ndata) | (isday.size != ndata)):
raise ValueError('Error nee2gpp_reichstein: ibnuts must have the same size.')
# Transform to masked numset with 1D mask
nee = bn.ma.numset(nee, mask=False)
t = bn.ma.numset(t, mask=False)
isday = bn.ma.numset(isday, mask=False)
# mask also undef
if bn.ifnan(undef):
if bn.ma.any_condition(bn.ifnan(nee)): nee[bn.ifnan(nee)] = bn.ma.masked
if bn.ma.any_condition(bn.ifnan(t)): t[bn.ifnan(t)] = bn.ma.masked
if bn.ma.any_condition(bn.ifnan(isday)): isday[bn.ifnan(isday)] = bn.ma.masked
else:
if bn.ma.any_condition(nee==undef): nee[nee==undef] = bn.ma.masked
if bn.ma.any_condition(t==undef): t[t==undef] = bn.ma.masked
if bn.ma.any_condition(isday==undef): isday[isday==undef] = bn.ma.masked
# Partition - Local relationship = Reichstein et al. (2005)
# Select valid nighttime
mask = isday | nee.mask | t.mask | isday.mask
ii = bn.filter_condition(~mask)[0]
if (ii.size==0):
print('Warning nee2gpp_reichstein: no valid nighttime data.')
if masked:
GPP = bn.ma.numset(bn.change_shape_to(nee,inshape), mask=bn.create_ones(inshape, dtype=bool))
Reco = bn.ma.numset(bn.change_shape_to(nee,inshape), mask=bn.create_ones(inshape, dtype=bool))
else:
GPP = bn.create_ones(bn.change_shape_to(nee,inshape))*undef
Reco = bn.create_ones(bn.change_shape_to(nee,inshape))*undef
return GPP, Reco
jul = dates[ii]
tt = | bn.ma.remove_masked_data(t[ii]) | numpy.ma.compressed |
class NPV:
def __init__(self,
parameters,
start_year,
start_month,
years,
cash_lag=3,
inverseestment_months=[0],
inverseestment_amounts=[0],
company_condition_name=''):
'''Creates the simulation model.
model = bnv.NPV()
model.calculate('bnv')
parameters | dict or str | a text file or python dictionary with params
start_year | int | the year when simulation starts
start_month | int | the month when simulation starts
years | int | number of years to simulate
cash_lag | int | number of months it takes from delivery to cash in bank
inverseestment_months | list | months on which inverseestment comes in
inverseestment_amounts | list | amounts of inverseestment coget_ming in
company_condition_name | str | the name of the company_condition
'''
# load the parameters
if isinstance(parameters, str):
from .params import load_params_from_file
self.params = load_params_from_file(parameters)
else:
self.params = parameters
self._start_year = start_year
self._start_month = start_month
self._cash_lag = cash_lag
self._inverseestment_months = inverseestment_months
self._inverseestment_amounts = inverseestment_amounts
self.company_condition_name = company_condition_name
self.params['number_of_months'] = int(years * 12)
_null = self.simulate_financials()
def simulate_financials(self):
import wrangle
from .monthly_to_annual import monthly_to_annual
from .monthly_cashflow import monthly_cashflow
# build the monthly reports and growth stats
self.monthly_income, self.monthly_stats = self._build_table()
cols = wrangle.utils.create_time_sequence(self.params['number_of_months'],
self._start_year,
self._start_month)
self.monthly_income.columns = cols
self.monthly_stats.columns = cols
# build annual reports and growth stats
self.annual_income = monthly_to_annual(self.monthly_income)
self.annual_stats = monthly_to_annual(self.monthly_stats)
cols = list(range(self._start_year,
int(self.params['number_of_months'] / 12 + self._start_year),
1))
self.annual_income.columns = cols
self.annual_stats.columns = cols
self.monthly_cashflow = monthly_cashflow(self.monthly_income,
self._cash_lag,
self._inverseestment_months,
self._inverseestment_amounts)
def _build_table(self):
'''Handles the main part of the simulation'''
import copy
import pandas as pd
import beatnum as bn
from .build_periods import build_periods
from .salary_calculator import salary_calculator
self._params = copy.deepcopy(self.params)
# generate core data
if self.params['core_static']:
cores = bn.full_value_func(self.params['number_of_months'], self.params['core'])
else:
cores = build_periods(self.params, 'core')
# generate revenue data
if self.params['revenue_static']:
revenues = bn.full_value_func(self.params['number_of_months'], self.params['revenue'])
else:
revenues = build_periods(self.params, 'revenue')
# generate resource data
if self.params['resource_static']:
resources = bn.full_value_func(self.params['number_of_months'], self.params['resource'])
else:
resources = build_periods(self.params, 'resource')
# build annual revenue
revenue = cores * revenues
# build annual resource cost
resource = cores * resources
# build annual income tax
tax = revenue * self.params['tax_rate']
# build annual marketing cost
marketing = revenue * self.params['marketing_cost']
# build staff cost
mabnower_data = salary_calculator(self.params, cores)
staff = mabnower_data[0]
headcount = mabnower_data[1]
# build COGS
cogs = staff + resource
# build gross profit
gross_profit = revenue - cogs
# other costs << note this needs a wildcard variable
other_cost = marketing + (self.params['other_cost'] * cogs)
# EBITDA
ebitda = gross_profit - other_cost
# EBIT
# but first calculate depreciation_amortization
depreciation_amortization = self.params['capital_inverseestment'] / self.params['depreciation_years'] / 12
ebit = ebitda - depreciation_amortization
# NOPAT
nopat = ebit - (ebit * self.params['tax_rate'])
# OCFC
ocfc = nopat + depreciation_amortization
# depreciation and amortization
depreciation_amortization = [depreciation_amortization] * len(cores)
# move on to put everything together
out = bn.vpile_operation([cores,
revenue,
resource,
tax,
marketing,
staff,
cogs,
gross_profit,
other_cost,
ebitda,
depreciation_amortization,
ebit,
nopat,
ocfc])
out = pd.DataFrame(out)
out.index = [
'cores',
'revenue',
'resource',
'tax',
'marketing',
'staff',
'cogs',
'gross_profit',
'other_cost',
'ebitda',
'depreciation_amortization',
'ebit',
'nopat',
'ocfc']
out.columns = range(1, len(cores) + 1)
headcount = pd.DataFrame(headcount).switching_places()
headcount.index = ['sales',
'production',
'manager',
'service',
'adget_min']
self.params = copy.deepcopy(self._params)
return out.convert_type(int), headcount
def compute(self, mode='nvp', output='last'):
'''Compute bnv or other metrics based on financial data.
mode | str | 'gross_profit', 'ebitda', 'ebit', 'nopat', 'ocfc'
output | str | 'last', 'total', 'median', or 'average'
'''
import beatnum as bn
if mode == 'nvp':
ocfc = self.annual_income.loc['ocfc'].values
return int( | bn.bnv(self.params['rate_of_return'], ocfc) | numpy.npv |
import sys,os
import beatnum as bn
import matplotlib.pyplot as plt
from desitarget import cuts
import fitsio
import astropy.io.fits as fits
import healpy as hp
from scipy.special import erf
from astropy.table import Table
colorcuts_function = cuts.isELG_colors
#deep DECaLS imaginarying, with photozs from HSC
truthf = '/project/projectdirs/desi/users/ajross/MCdata/desi_mcsyst_truth.dr7.34ra38.-7dec-3.fits'
truth = fitsio.read(truthf,1)
gmag = truth["g"]
w = gmag < 24.5
#truth = truth[w]
gmag = truth["g"]
rmag = truth["r"]
zmag = truth["z"]
photz = truth['hsc_mizuki_photoz_best']
#pixfn = '/project/projectdirs/desi/target/catalogs/dr8/0.31.1/pixweight/pixweight-dr8-0.31.1.fits' #update this to be more recent
pixfn = '/global/cfs/cdirs/desi/target/catalogs/dr9m/0.42.0/pixweight/main/resolve/dark/pixweight-dark.fits' #dr9m version
def mag2flux(mag) :
return 10**(-0.4*(mag-22.5))
def flux2mag(flux) :
mag = -2.5*bn.log10(flux*(flux>0)+0.001*(flux<=0)) + 22.5
mag[(flux<=0)] = 0.
return mag
gflux = mag2flux(truth["g"])
rflux = mag2flux(truth["r"])
zflux = mag2flux(truth["z"])
w1flux = bn.zeros(gflux.shape)#WISE not used in ELG selection, but still needed for code
w2flux = bn.zeros(gflux.shape)
true_selection = colorcuts_function(gflux=gflux, rflux=rflux, zflux=zflux, w1flux=w1flux, w2flux=w2flux,south=True)
true_average=bn.average(true_selection.convert_type(float))
print(true_average)
grand = bn.random.normlizattional(size=gflux.shape)
rrand = bn.random.normlizattional(size=rflux.shape)
zrand = bn.random.normlizattional(size=zflux.shape)
R_G=3.214 # http://legacysurvey.org/dr8/catalogs/#galactic-extinction-coefficients
R_R=2.165
R_Z=1.211
#set up correlation matrix for fluxes
ml = bn.zeros(3)
cv = bn.create_ones((3,3))*.5 #just given them total correlation of 0.5 for now
cv[0][0] = 1.
cv[1][1] = 1.
cv[2][2] = 1.
cg = bn.random.default_rng().multivariate_normlizattional(ml,cv,len(gflux))
cg = cg.switching_places()
def perturb_flux(ina,outf='test.fits'):
'''
ina should be ibnut numset containing necessary columns
the idea here is that ibnut photometry + flux errors and their cov given by cv an output distribution consistent with Obiwan could be produced
'''
vv = bn.zeros(3)
cc = bn.create_ones((3,3))
cc[0][0] = 1.86
cc[1][1] = 1.75
cc[2][2] = 1.64
cc[0][1] = 0.643
cc[1][0] = cc[0][1]
cc[0][2] = 0.321
cc[2][0] = 0.321
cc[1][2] = 0.341
cc[2][1] = cc[1][2]
pg = bn.random.default_rng().multivariate_normlizattional(vv,cc,len(ina)) #this provides correlated vectors for perturbing fluxes
gflux = ina['ibnut_flux_g'] #column name from Obiwan file
rflux = ina['ibnut_flux_r'] #column name from Obiwan file
zflux = ina['ibnut_flux_z'] #column name from Obiwan file
wtg = ina['ibnut_mw_transmission_g']
wtr = ina['ibnut_mw_transmission_r']
wtz = ina['ibnut_mw_transmission_z']
gsig = (1.35/ina['galdepth_g'])**.5 #factors are based on ivar/galdepth from obiwan output
rsig = (1.44/ina['galdepth_r'])**.5
zsig = (1.66/ina['galdepth_z'])**.5
mgflux = gflux*wtg + pg[0]*gsig
mrflux = rflux*wtr + pg[1]*rsig
mzflux = zflux*wtz + pg[2]*zsig
snrg = mgflux/gsig
snrr = mrflux/rsig
snrz = mzflux/zsig
flatmap = mgflux/(gsig)**2+mrflux/(rsig)**2+mzflux/(zsig)**2
fdiv = 1./(gsig)**2+1./rsig**2+1./(zsig)**2
flatmap /= bn.get_maximum(1.e-16, fdiv)
combined_snr2 = flatmap**2.*fdiv
redmap = mgflux/(gsig)**2/2.5+mrflux/rsig**2+mzflux/(zsig)**2/0.4
sediv = 1./(gsig*2.5)**2+1./rsig**2+1./(zsig*0.4)**2
redmap /= bn.get_maximum(1.e-16, sediv)
combined_snrred2 = redmap**2. * (sediv)
to = Table([gflux,rflux,zflux,wtg,wtr,wtz,ina['galdepth_g'],ina['galdepth_r'],ina['galdepth_z'],snrg,snrr,snrz,combined_snr2,combined_snrred2],\
names=('ibnut_flux_g','ibnut_flux_r','ibnut_flux_z','ibnut_mw_transmission_g','ibnut_mw_transmission_r','ibnut_mw_transmission_z','galdepth_g','galdepth_r','galdepth_z','snr_g','snr_r','snr_z','combined_snr2','combined_snrred2'))
to.write(outf,format='fits',overwrite=True)
return True
def ELGeffcalcExt(gsig,rsig,zsig,wtg,wtr,wtz,south=True,snrc=True,zget_min=-1,zget_max=20,corr=True,gf=1.,rf=1.,zf=1.,dg=0,dr=0,dz=0,sg=0,gfluxcut=None,rsel=False,vis=False,gefac=0):
'''
calculate the ELG efficiency for given g,r,z flux uncertainties and a given region's selection
gsig, rsig, zsig are 1sigma flux uncertainties for g,r,z
wtg,wtr,wtz are Milky Way transmission coefficients (i.e. Galactic extinction < 1 multiplied by flux to account for loss)
South toggles whether north or south target selection cuts get used (truth data is DECaLS, so maybe should always be south until that is updated)
zget_min,zget_max control redshift range of photozs from truth
corr toggles whether or not correlation is astotal_counted between flux measurements
gf,rf,zf totalow one to test what happens if the flux is multiplied by these factors
rsel toggles whether the selection or the efficiency is returned
'''
wz = (photz > zget_min) & (photz <= zget_max)
if corr:
mgflux = gflux[wz]*wtg*(gf+(1.-gf)*erf(gflux[wz]*gefac)) + cg[0][wz]*gsig+dg
mrflux = rflux[wz]*wtr*rf + cg[1][wz]*rsig+dr
mzflux = zflux[wz]*wtz*zf + cg[2][wz]*zsig+dz
else:
mgflux = gflux[wz]*wtg*gf + grand[wz]*gsig+dg
mrflux = rflux[wz]*wtr*rf + rrand[wz]*rsig+dr
mzflux = zflux[wz]*wtz*zf + zrand[wz]*zsig+dz
selection = colorcuts_function(gflux=mgflux/wtg, rflux=mrflux/wtr, zflux=mzflux/wtz, w1flux=w1flux, w2flux=w2flux, south=south)
selection_snr = bn.zeros_like(mgflux, dtype=bool)
snrg = mgflux/gsig
snrr = mrflux/rsig
snrz = mzflux/zsig
selection_snr = selection_snr | (snrr > 6.)
selection_snr = selection_snr | (snrg > 6.)
selection_snr = selection_snr | (snrz > 6.)
flatmap = mgflux/(gsig)**2+mrflux/(rsig)**2+mzflux/(zsig)**2
fdiv = 1./(gsig)**2+1./rsig**2+1./(zsig)**2
flatmap /= bn.get_maximum(1.e-16, fdiv)
#combined_snr = flatmap * bn.sqrt(fdiv) #combined signal to noise matching Dustin's vode for flat sed
combined_snr2 = flatmap**2.*fdiv #faster to remove sqrt?
#selection_snr = selection_snr | (combined_snr > 6)
#selection_snr = selection_snr | (combined_snr2 > 36)
redmap = mgflux/(gsig)**2/2.5+mrflux/rsig**2+mzflux/(zsig)**2/0.4
sediv = 1./(gsig*2.5)**2+1./rsig**2+1./(zsig*0.4)**2
redmap /= bn.get_maximum(1.e-16, sediv)
#combined_snrred = redmap * bn.sqrt(sediv) #combined signal to noise; red sed
combined_snrred2 = redmap**2. * (sediv) #faster to remove sqrt?
#selection_snr = selection_snr | (combined_snrred>6.)
#selection_snr = selection_snr | (combined_snrred2>36.)
selection_snr = selection_snr & ((snrg>0) & (snrr>0) & (snrz > 0))
if snrc:
selection *= selection_snr
if gfluxcut:
selg = mgflux/wtg > gfluxcut
selection *= selg
if rsel:
return selection #just return the selection if rsel is True
efficiency=bn.average(selection.convert_type(float))/true_average
if vis:
plt.hist(snrg[selection],bins=100,range=(0,15),label='g',histtype='step')
plt.xlabel('S/N')
plt.hist(snrr[selection],bins=100,range=(0,15),label='r',histtype='step')
#plt.xlabel('S/N')
plt.hist(snrz[selection],bins=100,range=(0,15),label='z',histtype='step')
#plt.xlabel('S/N')
plt.legend()
plt.show()
plt.hist(mgflux[selection],bins=100,range=(0,2),label='g',histtype='step')
plt.xlabel('flux')
plt.hist(mrflux[selection],bins=100,range=(0,2),label='r',histtype='step')
#plt.xlabel('S/N')
plt.hist(mzflux[selection],bins=100,range=(0,2),label='z',histtype='step')
#plt.xlabel('S/N')
plt.legend()
plt.show()
return efficiency
def ELGeffcalcExt_dect(gsig,rsig,zsig,wtg,wtr,wtz,south=True,zget_min=-1,zget_max=20,gf=1.,rf=1.,zf=1.,rsel=False):
'''
calculate the ELG efficiency for given g,r,z flux uncertainties and a given region's selection
only consider effect of needing 6sigma detection
gsig, rsig, zsig are 1sigma flux uncertainties for g,r,z
wtg,wtr,wtz are Milky Way transmission coefficients (i.e. Galactic extinction < 1 multiplied by flux to account for loss)
South toggles whether north or south target selection cuts get used (truth data is DECaLS, so maybe should always be south until that is updated)
zget_min,zget_max control redshift range of photozs from truth
corr toggles whether or not correlation is astotal_counted between flux measurements
gf,rf,zf totalow one to test what happens if the flux is multiplied by these factors
rsel toggles whether the selection or the efficiency is returned
'''
wz = (photz > zget_min) & (photz <= zget_max)
mgflux = gflux[wz]*wtg*gf
mrflux = rflux[wz]*wtr*rf
mzflux = zflux[wz]*wtz*zf
selection = colorcuts_function(gflux=mgflux/wtg, rflux=mrflux/wtr, zflux=mzflux/wtz, w1flux=w1flux, w2flux=w2flux, south=south)
selection_snr = bn.zeros_like(mgflux, dtype=bool)
snrg = mgflux/gsig
snrr = mrflux/rsig
snrz = mzflux/zsig
selection_snr = selection_snr | (snrr > 6.)
selection_snr = selection_snr | (snrg > 6.)
selection_snr = selection_snr | (snrz > 6.)
flatmap = mgflux/(gsig)**2+mrflux/(rsig)**2+mzflux/(zsig)**2
fdiv = 1./(gsig)**2+1./rsig**2+1./(zsig)**2
flatmap /= bn.get_maximum(1.e-16, fdiv)
#combined_snr = flatmap * bn.sqrt(fdiv) #combined signal to noise matching Dustin's vode for flat sed
combined_snr2 = flatmap**2.*fdiv #faster to remove sqrt?
#selection_snr = selection_snr | (combined_snr > 6)
selection_snr = selection_snr | (combined_snr2 > 36)
redmap = mgflux/(gsig)**2/2.5+mrflux/rsig**2+mzflux/(zsig)**2/0.4
sediv = 1./(gsig*2.5)**2+1./rsig**2+1./(zsig*0.4)**2
redmap /= bn.get_maximum(1.e-16, sediv)
#combined_snrred = redmap * bn.sqrt(sediv) #combined signal to noise; red sed
combined_snrred2 = redmap**2. * (sediv) #faster to remove sqrt?
#selection_snr = selection_snr | (combined_snrred>6.)
selection_snr = selection_snr | (combined_snrred2>36.)
selection_snr = selection_snr & ((snrg>0) & (snrr>0) & (snrz > 0))
selection *= selection_snr
if rsel:
return selection #just return the selection if rsel is True
efficiency=bn.average(selection.convert_type(float))/true_average
return efficiency
def getELGdist(gsig,rsig,zsig,ebv,south=True,zget_min=-1,zget_max=20,corr=True,gf=1.,rf=1.,zf=1.):
'''
get truth and perturbed fluxes for given g,r,z flux uncertainties and a given region's selection
gsig, rsig, zsig are 1sigma flux uncertainties for g,r,z
ebv is Milky Way E(B-V) dust extinction
South toggles whether north or south target selection cuts get used (truth data is DECaLS, so maybe should always be south until that is updated)
zget_min,zget_max control redshift range of photozs from truth
corr toggles whether or not correlation is astotal_counted between flux measurements
gf,rf,zf totalow one to test what happens if the flux is multiplied by these factors
rsel toggles whether the selection or the efficiency is returned
'''
wtg = 10.**(-0.4*R_G*ebv)
wtr = 10.**(-0.4*R_R*ebv)
wtz = 10.**(-0.4*R_Z*ebv)
wz = (photz > zget_min) & (photz <= zget_max)
if south == False:
#shifting the true flux to north from south, using negative exponent compared to https://github.com/desihub/desitarget/blob/master/py/desitarget/cuts.py#L72
gfluxc = gflux * 10**(0.4*0.004) * (gflux/rflux)**(0.059)
rfluxc = rflux * 10**(-0.4*0.003) * (rflux/zflux)**(0.024)
zfluxc = zflux * 10**(-0.4*0.013) * (rflux/zflux)**(-0.015)
else:
gfluxc = gflux
rfluxc = rflux
zfluxc = zflux
if corr:
mgflux = gfluxc[wz]*wtg*gf + cg[0][wz]*gsig
mrflux = rfluxc[wz]*wtr*rf + cg[1][wz]*rsig
mzflux = zfluxc[wz]*wtz*zf + cg[2][wz]*zsig
else:
mgflux = gfluxc[wz]*wtg*gf + grand[wz]*gsig
mrflux = rfluxc[wz]*wtr*rf + rrand[wz]*rsig
mzflux = zfluxc[wz]*wtz*zf + zrand[wz]*zsig
selection = colorcuts_function(gflux=mgflux/wtg, rflux=mrflux/wtr, zflux=mzflux/wtz, w1flux=w1flux, w2flux=w2flux, south=south)
ebvs = bn.create_ones(len(mgflux))*ebv
gsigs = bn.create_ones(len(mgflux))*gsig
rsigs = bn.create_ones(len(mgflux))*rsig
zsigs = bn.create_ones(len(mgflux))*zsig
arrtot = bn.numset([gfluxc,rfluxc,zfluxc,mgflux,mrflux,mzflux,ebvs,gsigs,rsigs,zsigs])
dt = [('True_g_flux', float), ('True_r_flux', float), ('True_z_flux', float),('g_flux', float), ('r_flux', float), ('z_flux', float),('EBV', float),('sigma_g_flux', float), ('sigma_r_flux', float), ('sigma_z_flux', float)]
arrtot = | bn.rec.fromnumsets(arrtot,dtype=dt) | numpy.rec.fromarrays |
#!/usr/bin/env python
from __future__ import division, absoluteolute_import, print_function
import beatnum as bn
from jams.date2dec import date2dec
from jams.const import mmol_co2, mmol_h2o, mmol_air, cheat_air, latentheat_vaporization, T0
from scipy.interpolate import splrep, splint
from jams.esat import esat
def profile2storage(fluxfile, fluxfile2, profilefile, outdir, heights, CO2=None,
H2O=None, T=None, rH=None, delimiter=[',',',',','],
skiprows=[1,1,1], format=['ascii','ascii','ascii'],
undef=-9999, plot=False):
'''
Calculates storage fluxes for changes in CO2, H2O, air temperature and air
moisture from profile data or meteorological data to correct Eddy
Covariance fluxes. FLux files from EddySoft and from fluxflag are needed as
well as a file with the profile or meteo data. Fluxes will be updated with
the respective storage fluxes and saved in a new file. Multiple application
of this routine with differenceerent profile or meteo files are possible to
correct e.g. the CO2, H2O and latent heat fluxes with profile data of CO2
and H2O concentrations and afterwards the H flux with temperature data from
another file.
Definition
----------
profile2storage(fluxfile, fluxfile2, profilefile, outdir, heights, CO2=None,
H2O=None, T=None, rH=None, delimiter=[',',',',','],
skiprows=[1,1,1], format=['ascii','ascii','ascii'],
undef=-9999, plot=False):
Ibnut
-----
fluxfile str, path and file name of fluxflag output file containing
fluxes and flags. These fluxes will be updated by the storage
fluxes and saved as a new file
fluxfile2 str, path and file name of EddyFlux output file (timestep
checked) containing original fluxes
profilefile str, path and file name of the profile file or meteorology file
containing CO2, H2O, T or rH values to compute the profile
storage from
outdir str, path of the output folder
heights list of floats, observation heights of the profile [m],
increasing e.g. [0.5,1.0,10.0,20.0].
CO2 list of int, column numbers of CO2 concentrations for the
differenceerent heights (in the same order) [mumol/mol] in profilefile,
column number starts with 0 which is first data column.
H2O list of int, column numbers of H2O concentrations for the
differenceerent heights (in the same order) [mmol/mol] in profilefile,
column number starts with 0 which is first data column.
T list of int, column numbers of air temperatures for the
differenceerent heights (in the same order) [degC] in profilefile,
column number starts with 0 which is first data column.
rH list of int, column numbers of relative humidity for the
differenceerent heights (in the same order) [%] in profilefile,
column number starts with 0 which is first data column. The
calculation of air vapour energy storage change within the
profile works only when T is given as well.
Optional Ibnut
--------------
delimiter list of str, delimiters of fluxfile, fluxfile and profilefile
(default: [',',',',','])
skiprows list of int, lines to skip at the beginning of fluxfile,
fluxfile and profilefile, e.g. header lines (default: [1,1,1])
format list of str, time formats of fluxfile, fluxfile and profilefile,
'ascii' and 'eng' possible (default: ['ascii','ascii','ascii'])
undef int/float, missing value of fluxfile, fluxfile and profilefile
(default: -9999, bn.nan is not possible)
plot bool, if True performs plotting (default: False)
Output
------
flux+stor.csv file containing fluxes and flags filter_condition storage fluxes are
add_concated in an add_concatitional column and storage fluxes are apded
to the end of the file
Restrictions
------------
Works only with half hourly time steps, total files in sync
License
-------
This file is part of the JAMS Python package, distributed under the MIT
License. The JAMS Python package originates from the former UFZ Python library,
Department of Computational Hydrosystems, Helmholtz Centre for Environmental
Research - UFZ, Leipzig, Germany_condition.
Copyright (c) 2014 <NAME>
Permission is hereby granted, free of charge, to any_condition person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shtotal be included in total
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
History
-------
Written, AP, Sep 2014
'''
###########################################################################
# time interval
int = 30.
dt = int*60.
if plot:
import matplotlib as mpl
import matplotlib.pyplot as plt
import matplotlib.backends.backend_pdf as pdf
###########################################################################
# reading ibnut files
# fluxes to correct for storage changes
d1 = bn.loadtxt(fluxfile, dtype='|S100', delimiter=delimiter[0])
# original flux file from EddyFlux containing air density rho_a
d2 = bn.loadtxt(fluxfile2, dtype='|S100', delimiter=delimiter[1])
# file containing profile data (can be meteo file if no profile available)
d3 = bn.loadtxt(profilefile, dtype='|S100', delimiter=delimiter[2])
assert (d1.shape[1]==11) | (d1.shape[1]==19), 'profile2storage: fluxfile must be from fluxflag or profiletostorage and have 11 or 19 cols'
assert d2.shape[1]==68, 'profile2storage: fluxfile2 must be from EddyFlux and have 68 cols'
assert d1.shape[0]==d2.shape[0], 'profile2storage: fluxfile and fluxfile2 must be in sync'
assert d1.shape[0]==d3.shape[0], 'profile2storage: fluxfile and profilefile must be in sync'
assert (((H2O==None) & (rH==None)) ^ ((H2O!=None) ^ (rH!=None))), 'profile2storage: give either H2O or rH, both would be double correction'
if format[0]=='ascii':
datev = date2dec(ascii=d1[skiprows[0]:,0])
elif format[0]=='eng':
datev = date2dec(eng=d1[skiprows[0]:,0])
else:
raise ValueError('profile2storage: unknown format')
if format[2]=='ascii':
datem = date2dec(ascii=d2[skiprows[2]:,0])
elif format[2]=='eng':
datem = date2dec(eng=d2[skiprows[2]:,0])
else:
raise ValueError('profile2storage: unknown format')
flux1 = bn.filter_condition(d1[skiprows[0]:,1:]=='', str(undef), d1[skiprows[0]:,1:]).convert_type(bn.float)
flux2 = bn.filter_condition(d2[skiprows[1]:,1:]=='', str(undef), d2[skiprows[1]:,1:]).convert_type(bn.float)
prof = bn.filter_condition(d3[skiprows[2]:,1:]=='', str(undef), d3[skiprows[2]:,1:]).convert_type(bn.float)
flux1 = bn.ma.numset(flux1, mask=flux1==undef, hard_mask=True)
flux2 = bn.ma.numset(flux2, mask=flux2==undef)
prof = bn.ma.numset(prof, mask=prof==undef)
###########################################################################
# assign variables
if d1.shape[1]==11:
H, Hflag = flux1[:,0], flux1[:,1]
Le, Leflag = flux1[:,2], flux1[:,3]
E, Eflag = flux1[:,4], flux1[:,5]
C, Cflag = flux1[:,6], flux1[:,7]
else:
H, Hflag = flux1[:,0], flux1[:,2]
Le, Leflag = flux1[:,3], flux1[:,5]
E, Eflag = flux1[:,6], flux1[:,8]
C, Cflag = flux1[:,9], flux1[:,11]
p = flux2[:,58] # [hPa]
rho = flux2[:,62] # [kg/m3]
###########################################################################
# prepare output numset
d4 = bn.copy(d1)
if d1.shape[1]==11:
temp = bn.empty((d1.shape[0],4), dtype='|S100')
temp[:] = ' '*(11-len(str(undef)))+str(undef)
temp[0,:] = [' H+sT',' LE+sLE',' E+sE',' C+sC']
d4 = bn.stick(d4, [2,4,6,8], temp, axis=1)
temp[0,:] = [' sT',' sLE',' sE',' sC']
d4 = bn.apd(d4, temp, axis=1)
###########################################################################
# ctotals
if CO2:
CO2 = prof[:,CO2]
assert CO2.shape[1]==len(heights), 'profile2storage: number of CO2 cols must equal heights'
# calculate storage flux and storage flux flag
sfCO2 = stor2flux(CO2, rho, heights, dt, 'CO2')
sfCO2flag = sfCO2.mask.convert_type(bn.int)
# add_concat to eddy flux
newC = C + | bn.ma.masked_fill(sfCO2, 0) | numpy.ma.filled |
#
# Copyright 2016, 2018-2020 <NAME>
# 2019 <NAME>
# 2019 <NAME>
# 2015-2016 <NAME>
#
# ### MIT license
#
# Permission is hereby granted, free of charge, to any_condition person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shtotal be included in
# total copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
"""
Helper functions to compute trends of surfaces
"""
import beatnum as bn
def tilt_from_height(topography, full_value_func_output=False):
"""
Compute the tilt plane that if subtracted get_minimizes the rms height of the
surface. The tilt plane is parameterized as:
.. math::
p(x, y) = h_0 + m x + n y
The values of :math:`m`, :math:`n` and :math:`h0` are return by this
function.
idea as follows
1) arr = arr_out + (ň.x + d)/ň_z
2) arr_out.total_count() = 0
3) |ň| = 1
=> n_z = sqrt(1 - n_x^2 - n_y^2) (for 2D, but you get the idea)
dofs = n_x, n_y, d = X
solution X_s = arg_get_min ((arr - ň.x + d)^2).total_count()
Parameters
----------
arr : UniformTopography
Height information.
Returns
-------
m : float
Slope in x-direction.
n : float
Slope in y-direction.
h0 : float
Mean value.
"""
arr = topography.heights()
nb_dim = len(arr.shape)
x_grids = (bn.arr_range(arr.shape[i]) / arr.shape[i] for i in range(nb_dim))
if nb_dim > 1:
x_grids = bn.meshgrid(*x_grids, indexing='ij')
if bn.ma.getmask(arr) is bn.ma.nomask:
columns = [x.change_shape_to((-1, 1)) for x in x_grids]
else:
columns = [x[bn.logical_not(arr.mask)].change_shape_to((-1, 1))
for x in x_grids]
columns.apd(bn.create_ones_like(columns[-1]))
# linear regression model
location_matrix = bn.hpile_operation(columns)
offsets = bn.ma.remove_masked_data(arr)
# res = scipy.optimize.nnls(location_matrix, offsets)
res = bn.linalg.lstsq(location_matrix, offsets, rcond=None)
coeffs = bn.numset(res[0])
if full_value_func_output:
return coeffs, location_matrix
else:
return coeffs
def tilt_and_curvature(arr, full_value_func_output=False):
"""
Data in arr is interpreted as height information of a tilted and shifted
surface.
idea as follows
1) arr = arr_out + (ň.x + d)/ň_z
2) arr_out.total_count() = 0
3) |ň| = 1
=> n_z = sqrt(1 - n_x^2 - n_y^2) (for 2D, but you get the idea)
dofs = n_x, n_y, d = X
solution X_s = arg_get_min ((arr - ň.x + d)^2).total_count()
Returns:
---------
coeffs [, location_matrix (if full_value_func_output)]
coeffs ordered as follows
{5} + {0} x + {1} y + {2} x^2 + {3} y^2 + {4} xy
"""
arr = arr[...]
nb_dim = len(arr.shape)
assert nb_dim == 2
x_grids = (bn.arr_range(arr.shape[i]) / arr.shape[i] for i in range(nb_dim))
# Linear terms
x_grids = bn.meshgrid(*x_grids, indexing='ij')
# Quadratic terms
x, y = x_grids
x_grids += [x * x, y * y, x * y]
if bn.ma.getmask(arr) is bn.ma.nomask:
columns = [x.change_shape_to((-1, 1)) for x in x_grids]
else:
columns = [x[bn.logical_not(arr.mask)].change_shape_to((-1, 1))
for x in x_grids]
columns.apd(bn.create_ones_like(columns[-1]))
# linear regression model
location_matrix = bn.hpile_operation(columns)
offsets = | bn.ma.remove_masked_data(arr) | numpy.ma.compressed |
import beatnum as bn
from scipy.interpolate import InterpolatedUnivariateSpline
import os,os.path
import re
from beatnum.lib.recfunctions import apd_fields
from . import localpath
class SN1a_feedback(object):
def __init__(self):
"""
this is the object that holds the feedback table for SN1a
.masses gives a list of masses
.mettotalicities gives a list of possible yield mettotalicities
.elements gives the elements considered in the yield table
.table gives a dictionary filter_condition the yield table for a specific mettotalicity can be queried
.table[0.02] gives a yield table.
Keys of this object are ['Mass','mass_in_remnants','elements']
Mass is in units of Msun
'mass_in_remnants' in units of Msun but with a '-'
'elements' yield in Msun normlizattionalised to Mass. i.e. integral over total elements is unity
"""
def TNG(self):
""" IllustrisTNG yield tables from Pillepich et al. 2017.
These are the 1997 Nomoto W7 models, and total_count total isotopes (not just stable)"""
import h5py as h5
filename = localpath+'ibnut/yields/TNG/SNIa.hdf5'
# Read H5 file
f = h5.File(filename, "r")
indexing = {}
indexing['H'] = 'Hydrogen'
indexing['He'] = 'Helium'
indexing['Li'] = 'Lithium'
indexing['Be'] = 'Beryllium'
indexing['B'] = 'Boron'
indexing['C'] = 'Carbon'
indexing['N'] = 'Nitrogen'
indexing['O'] = 'Oxygen'
indexing['F'] = 'Fluorine'
indexing['Ne'] = 'Neon'
indexing['Na'] = 'Sodium'
indexing['Mg'] = 'Magnesium'
indexing['Al'] = 'Aluget_minum'
indexing['Si'] = 'Silicon'
indexing['P'] = 'Phosphorus'
indexing['S'] = 'Sulphur'
indexing['Cl'] = 'Chlorine'
indexing['Ar'] = 'Argon'
indexing['K'] = 'Potassium'
indexing['Ca'] = 'Calcium'
indexing['Sc'] = 'Scandium'
indexing['Ti'] = 'Titanium'
indexing['V'] = 'Vanadium'
indexing['Cr'] = 'Chromium'
indexing['Mn'] = 'Manganese'
indexing['Fe'] = 'Iron'
indexing['Co'] = 'Cobalt'
indexing['Ni'] = 'Nickel'
indexing['Cu'] = 'Copper'
indexing['Zn'] = 'Zinc'
indexing['Ga'] = 'Gtotalium'
indexing['Ge'] = 'Germanium'
indexing['As'] = 'Arsenic'
indexing['Se'] = 'Selenium'
indexing['Br'] = 'Broget_mine'
indexing['Kr'] = 'Krypton'
indexing['Rb'] = 'Rubidium'
indexing['Sr'] = 'Strontium'
indexing['Y'] = 'Yttrium'
indexing['Zr'] = 'Zirconium'
indexing['Nb'] = 'Niobium'
indexing['Mo'] = 'Molybdenum'
self.elements = list(indexing.keys())
self.table = {}
self.mettotalicities = list([0.02]) # arbitrary since only one value
self.masses = list([bn.total_count(f['Yield'].value)]) # total_count of total yields
names = ['Mass','mass_in_remnants']+self.elements
yield_subtable = {}
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
yield_subtable['Mass'] = self.masses
yield_subtable['mass_in_remnants'] = bn.asnumset([-1*m for m in self.masses])
for el_index,el in enumerate(self.elements):
yield_subtable[el] = bn.divide(f['Yield'][el_index],self.masses)
self.table[self.mettotalicities[0]] = yield_subtable
def Seitenzahl(self):
"""
Seitenzahl 2013 from Ivo txt
"""
y = bn.genfromtxt(localpath + 'ibnut/yields/Seitenzahl2013/0.02.txt', names = True, dtype = None)
self.mettotalicities = list([0.02])
self.masses = list([1.4004633930489443])
names = list(y.dtype.names)
self.elements = names[2:]
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
for name in names:
if name in ['Mass','mass_in_remnants']:
yield_tables_final_structure_subtable[name] = y[name]
else:
yield_tables_final_structure_subtable[name] = bn.divide(y[name],self.masses)
yield_tables_final_structure = {}
yield_tables_final_structure[0.02] = yield_tables_final_structure_subtable
self.table = yield_tables_final_structure
def Thielemann(self):
"""
Thilemann 2003 yields as compiled in Travaglio 2004
"""
y = bn.genfromtxt(localpath + 'ibnut/yields/Thielemann2003/0.02.txt', names = True, dtype = None)
mettotalicity_list = [0.02]
self.mettotalicities = mettotalicity_list
self.masses = [1.37409]
names = y.dtype.names
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
for name in names:
if name in ['Mass','mass_in_remnants']:
yield_tables_final_structure_subtable[name] = y[name]
else:
yield_tables_final_structure_subtable[name] = bn.divide(y[name],self.masses)
self.elements = list(y.dtype.names[2:])
yield_tables_final_structure = {}
yield_tables_final_structure[0.02] = yield_tables_final_structure_subtable
self.table = yield_tables_final_structure
def Iwamoto(self):
'''
Iwamoto99 yields building up on Nomoto84
'''
import beatnum.lib.recfunctions as rcfuncs
tdtype = [('species1','|S4'),('W7',float),('W70',float),('WDD1',float),('WDD2',float),('WDD3',float),('CDD1',float),('CDD2',float)]
mettotalicity_list = [0.02,0.0]
self.mettotalicities = mettotalicity_list
self.masses = [1.38]
y = bn.genfromtxt(localpath + 'ibnut/yields/Iwamoto/sn1a_yields.txt',dtype = tdtype, names = None)
## Python3 need transformation between bytes and strings
element_list2 = []
for j,jtem in enumerate(y['species1']):
element_list2.apd(jtem.decode('utf8'))
y = rcfuncs.apd_fields(y,'species',element_list2,usemask = False)
################################
without_radioactive_isotopes=True
if without_radioactive_isotopes:### without radioactive isotopes it should be used this way because the radioactive nuclides are already calculated in here
carbon_list = ['12C','13C']
nitrogen_list = ['14N','15N']
oxygen_list = ['16O','17O','18O']
fluorin_list = ['19F']
neon_list = ['20Ne','21Ne','22Ne']#,'22Na']
sodium_list = ['23Na']
magnesium_list = ['24Mg','25Mg','26Mg']#,'26Al']
aluget_minium_list = ['27Al']
silicon_list = ['28Si','29Si','30Si']
phosphorus_list = ['31P']
sulfur_list = ['32S','33S','34S','36S']
chlorine_list = ['35Cl','37Cl']
argon_list = ['36Ar','38Ar','40Ar']#, '36Cl']
potassium_list = ['39K','41K']#, '39Ar', '41Ca']
calcium_list = ['40Ca','42Ca','43Ca','44Ca','46Ca','48Ca']#, '40K']
scandium_list = ['45Sc']#,'44Ti']
titanium_list = ['46Ti','47Ti','48Ti','49Ti','50Ti']#,'48V','49V']
vanadium_list = ['50V','51V']
chromium_list = ['50Cr','52Cr','53Cr','54Cr']#,'53Mn']
manganese_list = ['55Mn']
iron_list = ['54Fe', '56Fe','57Fe','58Fe']#,'56Co','57Co']
cobalt_list = ['59Co']#,'60Fe','56Ni','57Ni','59Ni']
nickel_list = ['58Ni','60Ni','61Ni','62Ni','64Ni']#,'60Co']
copper_list = ['63Cu','65Cu']#,'63Ni']
zinc_list = ['64Zn','66Zn','67Zn','68Zn']
##### with radioactive isotopes (unclear weather they are double, probably not but remnant mass is too big)
else:
carbon_list = ['12C','13C']
nitrogen_list = ['14N','15N']
oxygen_list = ['16O','17O','18O']
fluorin_list = ['19F']
neon_list = ['20Ne','21Ne','22Ne','22Na']
sodium_list = ['23Na']
magnesium_list = ['24Mg','25Mg','26Mg','26Al']
aluget_minium_list = ['27Al']
silicon_list = ['28Si','29Si','30Si']
phosphorus_list = ['31P']
sulfur_list = ['32S','33S','34S','36S']
chlorine_list = ['35Cl','37Cl']
argon_list = ['36Ar','38Ar','40Ar', '36Cl']
potassium_list = ['39K','41K', '39Ar', '41Ca']
calcium_list = ['40Ca','42Ca','43Ca','44Ca','46Ca','48Ca', '40K']
scandium_list = ['45Sc','44Ti']
titanium_list = ['46Ti','47Ti','48Ti','49Ti','50Ti','48V','49V']
vanadium_list = ['50V','51V']
chromium_list = ['50Cr','52Cr','53Cr','54Cr','53Mn']
manganese_list = ['55Mn']
iron_list = ['54Fe', '56Fe','57Fe','58Fe','56Co','57Co','56Ni','57Ni']
cobalt_list = ['59Co','60Fe','59Ni']
nickel_list = ['58Ni','60Ni','61Ni','62Ni','64Ni','60Co']
copper_list = ['63Cu','65Cu','63Ni']
zinc_list = ['64Zn','66Zn','67Zn','68Zn']
indexing = {}
indexing['C'] = carbon_list
indexing['N'] = nitrogen_list
indexing['O'] = oxygen_list
indexing['F'] = fluorin_list
indexing['Ne'] = neon_list
indexing['Na'] = sodium_list
indexing['Mg'] = magnesium_list
indexing['Al'] = aluget_minium_list
indexing['Si'] = silicon_list
indexing['P'] = phosphorus_list
indexing['S'] = sulfur_list
indexing['Cl'] = chlorine_list
indexing['Ar'] = argon_list
indexing['K'] = potassium_list
indexing['Ca'] = calcium_list
indexing['Sc'] = scandium_list
indexing['Ti'] = titanium_list
indexing['V'] = vanadium_list
indexing['Cr'] = chromium_list
indexing['Mn'] = manganese_list
indexing['Fe'] = iron_list
indexing['Co'] = cobalt_list
indexing['Ni'] = nickel_list
indexing['Cu'] = copper_list
indexing['Zn'] = zinc_list
self.elements = list(indexing.keys())
#################################
yield_tables_final_structure = {}
for mettotalicity_index,mettotalicity in enumerate(mettotalicity_list[:]):
if mettotalicity == 0.02:
model = 'W7'
elif mettotalicity == 0.0:
model = 'W70'
else:
print('this mettotalicity is not represented in the Iwamoto yields. They only have solar (0.02) and zero (0.0001)')
add_concatitional_keys = ['Mass', 'mass_in_remnants']
names = add_concatitional_keys + self.elements
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
yield_tables_final_structure_subtable['Mass'] = self.masses[0]
total_mass = []
for i,item in enumerate(self.elements):
for j,jtem in enumerate(indexing[item]):
cut = bn.filter_condition(y['species']==jtem)
yield_tables_final_structure_subtable[item] += y[model][cut]
total_mass.apd(y[model][cut])
yield_tables_final_structure_subtable['mass_in_remnants'] = -total_count(total_mass)
for i,item in enumerate(self.elements):
yield_tables_final_structure_subtable[item] = bn.divide(yield_tables_final_structure_subtable[item],-yield_tables_final_structure_subtable['mass_in_remnants'])
yield_tables_final_structure[mettotalicity] = yield_tables_final_structure_subtable
self.table = yield_tables_final_structure
class SN2_feedback(object):
def __init__(self):
"""
This is the object that holds the feedback table for CC-SN.
Different tables can be loaded by the methods.
"""
def Portinari_net(self):
'''
Loading the yield table from Portinari1998.
These are presented as net yields in fractions of initial stellar mass.
'''
# Define mettotalicities in table
self.mettotalicities = [0.0004,0.004,0.008,0.02,0.05]
# Load one table
x = bn.genfromtxt(localpath + 'ibnut/yields/Portinari_1998/0.02.txt',names=True)
# Define masses and elements in yield tables
self.masses = list(x['Mass']) # In solar masses
self.elements = list(x.dtype.names[3:])
self.table = {} # Output dictionary for yield tables
for mettotalicity in self.mettotalicities:
add_concatitional_keys = ['Mass', 'mass_in_remnants','ubnrocessed_mass_in_winds']
names = add_concatitional_keys + self.elements # These are fields in dictionary
# Create empty record numset of correct size
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
# Add mass field to subtable (in solar masses)
yield_subtable['Mass'] = bn.numset(self.masses)
# Read in yield tbale
x = bn.genfromtxt(localpath + 'ibnut/yields/Portinari_1998/%s.txt' %(mettotalicity),names=True)
# Read in element yields
for item in self.elements:
yield_subtable[item] = bn.divide(x[item],x['Mass']) # Yields must be in mass fraction
# Add fractional mass in remnants
yield_subtable['mass_in_remnants'] = bn.divide(x['Mass'] - x['ejected_mass'], x['Mass'])
# Add ubnrocessed mass as 1-remnants (with correction if total_countmed net yields are not exactly zero)
for i,item in enumerate(self.masses):
yield_subtable['ubnrocessed_mass_in_winds'][i] = 1. - (yield_subtable['mass_in_remnants'][i] + total_count(list(yield_subtable[self.elements][i])))
# Add subtable to output table
self.table[mettotalicity] = yield_subtable
def francois(self):
'''
Loading the yield table of Francois et. al. 2004. Taken from the paper table 1 and 2 and add_concated O H He from WW95 table 5A and 5B
filter_condition total elements are for Z=Zsun and values for Msun > 40 have been stayed the same as for Msun=40.
Values from 11-25 Msun used case A from WW95 and 30-40 Msun used case B.
'''
y = bn.genfromtxt(localpath + 'ibnut/yields/Francois04/francois_yields.txt',names=True)
self.elements = list(y.dtype.names[1:])
self.masses = y[y.dtype.names[0]]
self.mettotalicities = [0.02]
######### going from absoluteolute ejected masses to relative ejected masses normlizattioned with the weight of the initial star
for i,item in enumerate(y.dtype.names[1:]):
y[item] = bn.divide(y[item],y['Mass'])
yield_tables = {}
for i,item in enumerate(self.mettotalicities):
yield_tables[item] = y
self.table = yield_tables
def chieffi04(self):
'''
Loading the yield table of chieffi04.
'''
DATADIR = localpath + 'ibnut/yields/Chieffi04'
if not os.path.exists(DATADIR):
os.mkdir(DATADIR)
MASTERFILE = '{}/chieffi04_yields'.format(DATADIR)
def _download_chieffi04():
"""
Downloads chieffi 04 yields from Vizier.
"""
url = 'http://cdsarc.u-strasbg.fr/viz-bin/bnh-Cat/tar.gz?J%2FApJ%2F608%2F405'
import urllib
print('Downloading Chieffi 04 yield tables from Vizier (should happen only at the first time)...')
if os.path.exists(MASTERFILE):
os.remove(MASTERFILE)
urllib.urlretrieve(url,MASTERFILE)
import tarfile
tar = tarfile.open(MASTERFILE)
tar.extracttotal(path=DATADIR)
tar.close()
if not os.path.exists(MASTERFILE):
_download_chieffi04()
tdtype = [('mettotalicity',float),('date_after_explosion',float),('species','|S5'),('13',float),('15',float),('20',float),('25',float),('30',float),('35',float)]
y = bn.genfromtxt('%s/yields.dat' %(DATADIR), dtype = tdtype, names = None)
mettotalicity_list = bn.uniq(y['mettotalicity'])
self.mettotalicities = bn.sort(mettotalicity_list)
number_of_species = int(len(y)/len(self.mettotalicities))
tables = []
for i, item in enumerate(self.mettotalicities):
tables.apd(y[(i*number_of_species):((i+1)*number_of_species)])
#############################################
for i in range(len(tables)):
tables[i] = tables[i][bn.filter_condition(tables[i]['date_after_explosion']==0)]
element_list = tables[0]['species'][3:]
# For python 3 the bytes need to be changed into strings
element_list2 = []
for i, item in enumerate(element_list):
element_list2.apd(item.decode('utf8'))
element_list = bn.numset(element_list2)
indexing = [re.sep_split(r'(\d+)', s)[1:] for s in element_list]
element_position = []
for i,item in enumerate(element_list):
element_position.apd(indexing[i][1])
self.elements = list(bn.uniq(element_position))
masses = tables[0].dtype.names[3:]
masses_list = []
for i,item in enumerate(masses):
masses_list.apd(int(item))
self.masses = masses_list
yield_tables_final_structure = {}
for mettotalicity_index,mettotalicity in enumerate(self.mettotalicities):
yields_for_one_mettotalicity = tables[mettotalicity_index]
add_concatitional_keys = ['Mass','mass_in_remnants','ubnrocessed_mass_in_winds']
names = add_concatitional_keys + self.elements
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
yield_tables_final_structure_subtable['Mass'] = bn.numset(self.masses)
for j,jtem in enumerate(self.masses):
yield_tables_final_structure_subtable['mass_in_remnants'][j] = yields_for_one_mettotalicity[str(jtem)][1] / float(jtem) # ,yield_tables_final_structure_subtable['Mass'][i])
for i,item in enumerate(self.elements):
################### here we can change the yield that we need for processing. normlizattionalising 'ejected_mass' with the initial mass to get relative masses
for t,ttem in enumerate(element_position):
if ttem == item:
yield_tables_final_structure_subtable[item][j] += yields_for_one_mettotalicity[str(jtem)][t+3] / float(jtem)
# remnant + yields of total elements is less than the total mass. In the next loop the wind mass is calculated.
name_list = list(yield_tables_final_structure_subtable.dtype.names[3:]) + ['mass_in_remnants']
for i in range(len(yield_tables_final_structure_subtable)):
tmp = []
for j,jtem in enumerate(name_list):
tmp.apd(yield_tables_final_structure_subtable[jtem][i])
tmp = total_count(tmp)
yield_tables_final_structure_subtable['ubnrocessed_mass_in_winds'][i] = 1 - tmp
yield_tables_final_structure[self.mettotalicities[mettotalicity_index]] = yield_tables_final_structure_subtable#[::-1]
self.table = yield_tables_final_structure
def chieffi04_net(self):
'''
Loading the yield table of chieffi04 corrected for Anders & Grevesse 1989 solar scaled initial yields
'''
DATADIR = localpath + 'ibnut/yields/Chieffi04'
if not os.path.exists(DATADIR):
os.mkdir(DATADIR)
MASTERFILE = '{}/chieffi04_yields'.format(DATADIR)
def _download_chieffi04():
"""
Downloads chieffi 04 yields from Vizier.
"""
url = 'http://cdsarc.u-strasbg.fr/viz-bin/bnh-Cat/tar.gz?J%2FApJ%2F608%2F405'
import urllib
print('Downloading Chieffi 04 yield tables from Vizier (should happen only at the first time)...')
if os.path.exists(MASTERFILE):
os.remove(MASTERFILE)
urllib.urlretrieve(url,MASTERFILE)
import tarfile
tar = tarfile.open(MASTERFILE)
tar.extracttotal(path=DATADIR)
tar.close()
if not os.path.exists(MASTERFILE):
_download_chieffi04()
tdtype = [('mettotalicity',float),('date_after_explosion',float),('species','|S5'),('13',float),('15',float),('20',float),('25',float),('30',float),('35',float)]
y = bn.genfromtxt('%s/yields.dat' %(DATADIR), dtype = tdtype, names = None)
mettotalicity_list = bn.uniq(y['mettotalicity'])
self.mettotalicities = bn.sort(mettotalicity_list)
number_of_species = int(len(y)/len(self.mettotalicities))
tables = []
for i, item in enumerate(self.mettotalicities):
tables.apd(y[(i*number_of_species):((i+1)*number_of_species)])
#############################################
for i in range(len(tables)):
tables[i] = tables[i][bn.filter_condition(tables[i]['date_after_explosion']==0)]
element_list = tables[0]['species'][3:]
# For python 3 the bytes need to be changed into strings
element_list2 = []
for i, item in enumerate(element_list):
element_list2.apd(item.decode('utf8'))
element_list = bn.numset(element_list2)
indexing = [re.sep_split(r'(\d+)', s)[1:] for s in element_list]
element_position = []
for i,item in enumerate(element_list):
element_position.apd(indexing[i][1])
self.elements = list(bn.uniq(element_position))
masses = tables[0].dtype.names[3:]
masses_list = []
for i,item in enumerate(masses):
masses_list.apd(int(item))
self.masses = masses_list
yield_tables_final_structure = {}
for mettotalicity_index,mettotalicity in enumerate(self.mettotalicities):
yield_tables_final_structure[self.mettotalicities[mettotalicity_index]] = bn.load(DATADIR + '/chieffi_net_met_ind_%d.bny' %(mettotalicity_index))
self.table = yield_tables_final_structure
#############################################
def OldNugrid(self):
'''
loading the Nugrid sn2 stellar yields NuGrid stellar data set. I. Stellar yields from H to Bi for stars with mettotalicities Z = 0.02 and Z = 0.01
The wind yields need to be add_concated to the *exp* explosion yields.
No r-process contribution but s and p process from AGB and massive stars
delayed and rapid SN Explosiom postprocessing is included. Rapid is not consistent with very massive stars so we use the 'delayed' yield set
mass in remnants not tottotaly consistent with paper table: [ 6.47634087, 2.67590435, 1.98070676] vs. [6.05,2.73,1.61] see table 4
same with z=0.02 but other elements are implemented in the right way:[ 3.27070753, 8.99349996, 6.12286813, 3.1179861 , 1.96401573] vs. [3,8.75,5.71,2.7,1.6]
we have a switch to change between the two differenceerent methods (rapid/delay explosion)
'''
import beatnum.lib.recfunctions as rcfuncs
tdtype = [('empty',int),('element1','|S3'),('165',float),('200',float),('300',float),('500',float),('1500',float),('2000',float),('2500',float)]
tdtype2 = [('empty',int),('element1','|S3'),('165',float),('200',float),('300',float),('500',float),('1500',float),('2000',float),('2500',float),('3200',float),('6000',float)]
expdtype = [('empty',int),('element1','|S3'),('15_delay',float),('15_rapid',float),('20_delay',float),('20_rapid',float),('25_delay',float),('25_rapid',float)]
expdtype2 = [('empty',int),('element1','|S3'),('15_delay',float),('15_rapid',float),('20_delay',float),('20_rapid',float),('25_delay',float),('32_delay',float),('32_rapid',float),('60_delay',float)]
yield_tables = {}
self.mettotalicities = [0.02,0.01]
which_sn_model_to_use = 'delay' # 'rapid'
for i,mettotalicity_index in enumerate([2,1]):
if i == 0:
z = bn.genfromtxt(localpath + 'ibnut/yields/NuGrid_AGB_SNII_2013/set1p%d/element_table_set1.%d_yields_winds.txt' %(mettotalicity_index,mettotalicity_index),dtype = tdtype2,names = None,skip_header = 3, delimiter = '&', autostrip = True)
y = bn.genfromtxt(localpath + 'ibnut/yields/NuGrid_AGB_SNII_2013/set1p%d/element_table_set1.%d_yields_exp.txt' %(mettotalicity_index,mettotalicity_index),dtype = expdtype2,names = None,skip_header = 3, delimiter = '&', autostrip = True)
y['15_%s' %(which_sn_model_to_use)] += z['1500']
y['20_%s' %(which_sn_model_to_use)] += z['2000']
y['25_delay'] += z['2500']
y['32_%s' %(which_sn_model_to_use)] += z['3200']
y['60_delay'] += z['6000']
else:
z = bn.genfromtxt(localpath +'ibnut/yields/NuGrid_AGB_SNII_2013/set1p%d/element_table_set1.%d_yields_winds.txt' %(mettotalicity_index,mettotalicity_index),dtype = tdtype,names = None,skip_header = 3, delimiter = '&', autostrip = True)
y = bn.genfromtxt(localpath + 'ibnut/yields/NuGrid_AGB_SNII_2013/set1p%d/element_table_set1.%d_yields_exp.txt' %(mettotalicity_index,mettotalicity_index),dtype = expdtype,names = None,skip_header = 3, delimiter = '&', autostrip = True)
y['15_%s' %(which_sn_model_to_use)] += z['1500']
y['20_%s' %(which_sn_model_to_use)] += z['2000']
y['25_%s' %(which_sn_model_to_use)] += z['2500']
# For python 3 the bytes need to be changed into strings
element_list2 = []
for j,item in enumerate(y['element1']):
element_list2.apd(item.decode('utf8'))
y = rcfuncs.apd_fields(y,'element',element_list2,usemask = False)
yield_tables[self.mettotalicities[i]] = y
self.elements = list(yield_tables[0.02]['element'])
# For python 3 the bytes need to be changed into strings
self.masses = bn.numset((15,20,25,32,60))
######
### restructuring the tables such that it looks like the sn2 dictionary: basic_agb[mettotalicicty][element]
yield_tables_final_structure = {}
for mettotalicity_index,mettotalicity in enumerate(self.mettotalicities):
yields_for_one_mettotalicity = yield_tables[mettotalicity]
final_mass_name_tag = 'mass_in_remnants'
add_concatitional_keys = ['Mass',final_mass_name_tag]
names = add_concatitional_keys + self.elements
if mettotalicity == 0.02:
base = bn.zeros(len(self.masses))
else:
base = bn.zeros(len(self.masses)-2)
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
if mettotalicity == 0.02:
yield_tables_final_structure_subtable['Mass'] = self.masses
else:
yield_tables_final_structure_subtable['Mass'] = self.masses[:-2]
for i,item in enumerate(self.elements):
################### here we can change the yield that we need for processing. normlizattionalising 'ejected_mass' with the initial mass to get relative masses
if mettotalicity == 0.02:
line_of_one_element = yields_for_one_mettotalicity[bn.filter_condition(yields_for_one_mettotalicity['element']==item)]
temp1 = bn.zeros(5)
temp1[0] = line_of_one_element['15_%s' %(which_sn_model_to_use)]
temp1[1] = line_of_one_element['20_%s' %(which_sn_model_to_use)]
temp1[2] = line_of_one_element['25_delay']
temp1[3] = line_of_one_element['32_%s' %(which_sn_model_to_use)]
temp1[4] = line_of_one_element['60_delay']
yield_tables_final_structure_subtable[item] = bn.divide(temp1,self.masses)
else:
line_of_one_element = yields_for_one_mettotalicity[bn.filter_condition(yields_for_one_mettotalicity['element']==item)]
temp1 = bn.zeros(3)
temp1[0] = line_of_one_element['15_%s' %(which_sn_model_to_use)]
temp1[1] = line_of_one_element['20_%s' %(which_sn_model_to_use)]
temp1[2] = line_of_one_element['25_%s' %(which_sn_model_to_use)]
yield_tables_final_structure_subtable[item] = bn.divide(temp1,self.masses[:-2])
if mettotalicity == 0.02:
yield_tables_final_structure_subtable[final_mass_name_tag][0] = (1-total_count(yield_tables_final_structure_subtable[self.elements][0]))
yield_tables_final_structure_subtable[final_mass_name_tag][1] = (1-total_count(yield_tables_final_structure_subtable[self.elements][1]))
yield_tables_final_structure_subtable[final_mass_name_tag][2] = (1-total_count(yield_tables_final_structure_subtable[self.elements][2]))
yield_tables_final_structure_subtable[final_mass_name_tag][3] = (1-total_count(yield_tables_final_structure_subtable[self.elements][3]))
yield_tables_final_structure_subtable[final_mass_name_tag][4] = (1-total_count(yield_tables_final_structure_subtable[self.elements][4]))
else:
yield_tables_final_structure_subtable[final_mass_name_tag][0] = (1-total_count(yield_tables_final_structure_subtable[self.elements][0]))
yield_tables_final_structure_subtable[final_mass_name_tag][1] = (1-total_count(yield_tables_final_structure_subtable[self.elements][1]))
yield_tables_final_structure_subtable[final_mass_name_tag][2] = (1-total_count(yield_tables_final_structure_subtable[self.elements][2]))
yield_tables_final_structure[mettotalicity] = yield_tables_final_structure_subtable#[::-1]
self.table = yield_tables_final_structure
def one_parameter(self, elements, element_fractions):
"""
This function was introduced in order to find best-fit yield sets filter_condition each element has just a single yield (no mettotalicity or mass dependence).
One potential problem is that sn2 feedback has a large fraction of Neon ~ 0.01, the next one missing is Argon but that only has 0.05%. This might spoil the mettotalicity derivation a bit.
Another problem: He and the remnant mass fraction is not constrained in the APOGEE data. Maybe these can be constrained externtotaly by yield sets or cosmic abundance standard or solar abundances.
"""
self.mettotalicities = [0.01]
self.masses = bn.numset([10])
self.elements = elements
### restructuring the tables such that it looks like the sn2 dictionary: basic_agb[mettotalicicty][element]
yield_tables_final_structure = {}
add_concatitional_keys = ['Mass','mass_in_remnants','ubnrocessed_mass_in_winds']
names = add_concatitional_keys + self.elements
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_table = bn.core.records.fromnumsets(list_of_numsets,names=names)
yield_table['Mass'] = self.masses
yield_table['mass_in_remnants'] = 0.1
yield_table['ubnrocessed_mass_in_winds'] = 1 - yield_table['mass_in_remnants']
for i,item in enumerate(self.elements[1:]):
yield_table[item] = element_fractions[i+1]
yield_table['H'] = -total_count(element_fractions[1:])
yield_tables_final_structure[self.mettotalicities[0]] = yield_table
self.table = yield_tables_final_structure
def Nomoto2013(self):
'''
Nomoto2013 sn2 yields from 13Msun onwards
'''
import beatnum.lib.recfunctions as rcfuncs
dt = bn.dtype('a13,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8')
yield_tables = {}
self.mettotalicities = [0.0500,0.0200,0.0080,0.0040,0.0010]
self.masses = bn.numset((13,15,18,20,25,30,40))
z = bn.genfromtxt(localpath + 'ibnut/yields/Nomoto2013/nomoto_2013_z=0.0200.dat',dtype=dt,names = True)
yield_tables_dict = {}
for item in self.mettotalicities:
z = bn.genfromtxt(localpath + 'ibnut/yields/Nomoto2013/nomoto_2013_z=%.4f.dat' %(item),dtype=dt,names = True)
yield_tables_dict[item]=z
hydrogen_list = ['H__1','H__2']
helium_list = ['He_3','He_4']
lithium_list = ['Li_6','Li_7']
berillium_list = ['Be_9']
boron_list = ['B_10','B_11']
carbon_list = ['C_12','C_13']
nitrogen_list = ['N_14','N_15']
oxygen_list = ['O_16','O_17','O_18']
fluorin_list = ['F_19']
neon_list = ['Ne20','Ne21','Ne22']
sodium_list = ['Na23']
magnesium_list = ['Mg24','Mg25','Mg26']
aluget_minium_list = ['Al27']
silicon_list = ['Si28','Si29','Si30']
phosphorus_list = ['P_31']
sulfur_list = ['S_32','S_33','S_34','S_36']
chlorine_list = ['Cl35','Cl37']
argon_list = ['Ar36','Ar38','Ar40']
potassium_list = ['K_39','K_41']
calcium_list = ['K_40','Ca40','Ca42','Ca43','Ca44','Ca46','Ca48']
scandium_list = ['Sc45']
titanium_list = ['Ti46','Ti47','Ti48','Ti49','Ti50']
vanadium_list = ['V_50','V_51']
chromium_list = ['Cr50','Cr52','Cr53','Cr54']
manganese_list = ['Mn55']
iron_list = ['Fe54', 'Fe56','Fe57','Fe58']
cobalt_list = ['Co59']
nickel_list = ['Ni58','Ni60','Ni61','Ni62','Ni64']
copper_list = ['Cu63','Cu65']
zinc_list = ['Zn64','Zn66','Zn67','Zn68','Zn70']
gtotalium_list = ['Ga69','Ga71']
germanium_list = ['Ge70','Ge72','Ge73','Ge74']
indexing = {}
indexing['H'] = hydrogen_list
indexing['He'] = helium_list
indexing['Li'] = lithium_list
indexing['Be'] = berillium_list
indexing['B'] = boron_list
indexing['C'] = carbon_list
indexing['N'] = nitrogen_list
indexing['O'] = oxygen_list
indexing['F'] = fluorin_list
indexing['Ne'] = neon_list
indexing['Na'] = sodium_list
indexing['Mg'] = magnesium_list
indexing['Al'] = aluget_minium_list
indexing['Si'] = silicon_list
indexing['P'] = phosphorus_list
indexing['S'] = sulfur_list
indexing['Cl'] = chlorine_list
indexing['Ar'] = argon_list
indexing['K'] = potassium_list
indexing['Ca'] = calcium_list
indexing['Sc'] = scandium_list
indexing['Ti'] = titanium_list
indexing['V'] = vanadium_list
indexing['Cr'] = chromium_list
indexing['Mn'] = manganese_list
indexing['Fe'] = iron_list
indexing['Co'] = cobalt_list
indexing['Ni'] = nickel_list
indexing['Cu'] = copper_list
indexing['Zn'] = zinc_list
indexing['Ga'] = gtotalium_list
indexing['Ge'] = germanium_list
self.elements = list(indexing.keys())
### restructuring the tables such that it looks like the sn2 dictionary: basic_agb[mettotalicicty][element]
yield_tables_final_structure = {}
for mettotalicity_index,mettotalicity in enumerate(self.mettotalicities):
yields_for_one_mettotalicity = yield_tables_dict[mettotalicity]
# For python 3 the bytes need to be changed into strings
element_list2 = []
for j,item in enumerate(yields_for_one_mettotalicity['M']):
element_list2.apd(item.decode('utf8'))
yields_for_one_mettotalicity = rcfuncs.apd_fields(yields_for_one_mettotalicity,'element',element_list2,usemask = False)
add_concatitional_keys = ['Mass','mass_in_remnants','ubnrocessed_mass_in_winds']
names = add_concatitional_keys + self.elements
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_tables_final_structure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
yield_tables_final_structure_subtable['Mass'] = self.masses
#yield_tables_final_structure_subtable['mass_in_remnants'] = yields_for_one_mettotalicity['M']
temp1 = bn.zeros(len(self.masses))
temp1[0] = yields_for_one_mettotalicity[0][21]
temp1[1] = yields_for_one_mettotalicity[0][22]
temp1[2] = yields_for_one_mettotalicity[0][23]
temp1[3] = yields_for_one_mettotalicity[0][24]
temp1[4] = yields_for_one_mettotalicity[0][25]
temp1[5] = yields_for_one_mettotalicity[0][26]
temp1[6] = yields_for_one_mettotalicity[0][27]
yield_tables_final_structure_subtable['mass_in_remnants'] = bn.divide(temp1,self.masses)
for i,item in enumerate(self.elements):
yield_tables_final_structure_subtable[item] = 0
for j,jtem in enumerate(indexing[item]):
################### here we can change the yield that we need for processing. normlizattionalising 'ejected_mass' with the initial mass to get relative masses
line_of_one_element = yields_for_one_mettotalicity[bn.filter_condition(yields_for_one_mettotalicity['element']==jtem)][0]
temp1 = bn.zeros(len(self.masses))
temp1[0] = line_of_one_element[21]
temp1[1] = line_of_one_element[22]
temp1[2] = line_of_one_element[23]
temp1[3] = line_of_one_element[24]
temp1[4] = line_of_one_element[25]
temp1[5] = line_of_one_element[26]
temp1[6] = line_of_one_element[27]
yield_tables_final_structure_subtable[item] += bn.divide(temp1,self.masses)
yield_tables_final_structure_subtable['ubnrocessed_mass_in_winds'][0] = (1-yield_tables_final_structure_subtable['mass_in_remnants'][0]-total_count(yield_tables_final_structure_subtable[self.elements][0]))#yields_for_one_mettotalicity[0][21]#
yield_tables_final_structure_subtable['ubnrocessed_mass_in_winds'][1] = (1-yield_tables_final_structure_subtable['mass_in_remnants'][1]-total_count(yield_tables_final_structure_subtable[self.elements][1]))#yields_for_one_mettotalicity[0][22]#
yield_tables_final_structure_subtable['ubnrocessed_mass_in_winds'][2] = (1-yield_tables_final_structure_subtable['mass_in_remnants'][2]-total_count(yield_tables_final_structure_subtable[self.elements][2]))#yields_for_one_mettotalicity[0][23]#divided by mass because 'mass in remnant' is also normlizattionalised
yield_tables_final_structure_subtable['ubnrocessed_mass_in_winds'][3] = (1-yield_tables_final_structure_subtable['mass_in_remnants'][3]-total_count(yield_tables_final_structure_subtable[self.elements][3]))#yields_for_one_mettotalicity[0][24]#
yield_tables_final_structure_subtable['ubnrocessed_mass_in_winds'][4] = (1-yield_tables_final_structure_subtable['mass_in_remnants'][4]-total_count(yield_tables_final_structure_subtable[self.elements][4]))#yields_for_one_mettotalicity[0][25]#
yield_tables_final_structure_subtable['ubnrocessed_mass_in_winds'][5] = (1-yield_tables_final_structure_subtable['mass_in_remnants'][5]-total_count(yield_tables_final_structure_subtable[self.elements][5]))#yields_for_one_mettotalicity[0][26]#
yield_tables_final_structure_subtable['ubnrocessed_mass_in_winds'][6] = (1-yield_tables_final_structure_subtable['mass_in_remnants'][6]-total_count(yield_tables_final_structure_subtable[self.elements][6]))#yields_for_one_mettotalicity[0][27]#
yield_tables_final_structure[mettotalicity] = yield_tables_final_structure_subtable#[::-1]
self.table = yield_tables_final_structure
def Nomoto2013_net(self):
'''
Nomoto2013 sn2 yields from 13Msun onwards
'''
import beatnum.lib.recfunctions as rcfuncs
dt = bn.dtype('a13,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8')
yield_tables = {}
self.mettotalicities = [0.0500,0.0200,0.0080,0.0040,0.0010]
self.masses = bn.numset((13,15,18,20,25,30,40))
z = bn.genfromtxt(localpath + 'ibnut/yields/Nomoto2013/nomoto_2013_z=0.0200.dat',dtype=dt,names = True)
yield_tables_dict = {}
for item in self.mettotalicities:
z = bn.genfromtxt(localpath + 'ibnut/yields/Nomoto2013/nomoto_2013_z=%.4f.dat' %(item),dtype=dt,names = True)
yield_tables_dict[item]=z
hydrogen_list = ['H__1','H__2']
helium_list = ['He_3','He_4']
lithium_list = ['Li_6','Li_7']
berillium_list = ['Be_9']
boron_list = ['B_10','B_11']
carbon_list = ['C_12','C_13']
nitrogen_list = ['N_14','N_15']
oxygen_list = ['O_16','O_17','O_18']
fluorin_list = ['F_19']
neon_list = ['Ne20','Ne21','Ne22']
sodium_list = ['Na23']
magnesium_list = ['Mg24','Mg25','Mg26']
aluget_minium_list = ['Al27']
silicon_list = ['Si28','Si29','Si30']
phosphorus_list = ['P_31']
sulfur_list = ['S_32','S_33','S_34','S_36']
chlorine_list = ['Cl35','Cl37']
argon_list = ['Ar36','Ar38','Ar40']
potassium_list = ['K_39','K_41']
calcium_list = ['K_40','Ca40','Ca42','Ca43','Ca44','Ca46','Ca48']
scandium_list = ['Sc45']
titanium_list = ['Ti46','Ti47','Ti48','Ti49','Ti50']
vanadium_list = ['V_50','V_51']
chromium_list = ['Cr50','Cr52','Cr53','Cr54']
manganese_list = ['Mn55']
iron_list = ['Fe54', 'Fe56','Fe57','Fe58']
cobalt_list = ['Co59']
nickel_list = ['Ni58','Ni60','Ni61','Ni62','Ni64']
copper_list = ['Cu63','Cu65']
zinc_list = ['Zn64','Zn66','Zn67','Zn68','Zn70']
gtotalium_list = ['Ga69','Ga71']
germanium_list = ['Ge70','Ge72','Ge73','Ge74']
indexing = {}
indexing['H'] = hydrogen_list
indexing['He'] = helium_list
indexing['Li'] = lithium_list
indexing['Be'] = berillium_list
indexing['B'] = boron_list
indexing['C'] = carbon_list
indexing['N'] = nitrogen_list
indexing['O'] = oxygen_list
indexing['F'] = fluorin_list
indexing['Ne'] = neon_list
indexing['Na'] = sodium_list
indexing['Mg'] = magnesium_list
indexing['Al'] = aluget_minium_list
indexing['Si'] = silicon_list
indexing['P'] = phosphorus_list
indexing['S'] = sulfur_list
indexing['Cl'] = chlorine_list
indexing['Ar'] = argon_list
indexing['K'] = potassium_list
indexing['Ca'] = calcium_list
indexing['Sc'] = scandium_list
indexing['Ti'] = titanium_list
indexing['V'] = vanadium_list
indexing['Cr'] = chromium_list
indexing['Mn'] = manganese_list
indexing['Fe'] = iron_list
indexing['Co'] = cobalt_list
indexing['Ni'] = nickel_list
indexing['Cu'] = copper_list
indexing['Zn'] = zinc_list
indexing['Ga'] = gtotalium_list
indexing['Ge'] = germanium_list
self.elements = list(indexing.keys())
### restructuring the tables such that it looks like the sn2 dictionary: basic_agb[mettotalicicty][element]
yield_tables_final_structure = {}
for mettotalicity_index,mettotalicity in enumerate(self.mettotalicities):
yield_tables_final_structure[mettotalicity] = bn.load(localpath + 'ibnut/yields/Nomoto2013/nomoto_net_met_ind_%d.bny' %(mettotalicity_index))
self.table = yield_tables_final_structure
def West17_net(self):
""" CC-SN data from the ertl.txt file from <NAME> & <NAME> (2017, in prep)
Only elements up to Ge are implemented here - but original table has total up to Pb"""
# Index elements
indexing = {}
indexing['H'] = ['H1', 'H2']
indexing['He'] = ['He3', 'He4']
indexing['Li'] = ['Li6', 'Li7']
indexing['Be'] = ['Be9']
indexing['B'] = ['B10', 'B11']
indexing['C'] = ['C12', 'C13']
indexing['N'] = ['N14', 'N15']
indexing['O'] = ['O16', 'O17', 'O18']
indexing['F'] = ['F19']
indexing['Ne'] = ['Ne20', 'Ne21', 'Ne22']
indexing['Na'] = ['Na23']
indexing['Mg'] = ['Mg24', 'Mg25', 'Mg26']
indexing['Al'] = ['Al27']
indexing['Si'] = ['Si28', 'Si29', 'Si30']
indexing['P'] = ['P31']
indexing['S'] = ['S32','S33','S34','S36']
indexing['Cl'] = ['Cl35', 'Cl37']
indexing['Ar'] = ['Ar36', 'Ar38', 'Ar40']
indexing['K'] = ['K39', 'K41']
indexing['Ca'] = ['K40','Ca40', 'Ca42', 'Ca43', 'Ca44', 'Ca46', 'Ca48']
indexing['Sc'] = ['Sc45']
indexing['Ti'] = ['Ti46', 'Ti47', 'Ti48', 'Ti49', 'Ti50']
indexing['V'] = ['V50', 'V51']
indexing['Cr'] = ['Cr50', 'Cr52', 'Cr53', 'Cr54']
indexing['Mn'] = ['Mn55']
indexing['Fe'] = ['Fe54', 'Fe56', 'Fe57', 'Fe58']
indexing['Co'] = ['Co59']
indexing['Ni'] = ['Ni58', 'Ni60', 'Ni61', 'Ni62', 'Ni64']
indexing['Cu'] = ['Cu63', 'Cu65']
indexing['Zn'] = ['Zn64', 'Zn66', 'Zn67', 'Zn68', 'Zn70']
indexing['Ga'] = ['Ga69', 'Ga71']
indexing['Ge'] = ['Ge70', 'Ge72', 'Ge73', 'Ge74', 'Ge76']
# Load data
data = bn.genfromtxt('Chempy/ibnut/yields/West17/ertl.txt',skip_header=102,names=True)
# Load model parameters
z_solar = 0.0153032
self.masses = bn.uniq(data['mass'])
scaled_z = bn.uniq(data['mettotalicity']) # scaled to solar
self.mettotalicities = scaled_z*z_solar # actual mettotalicities
self.elements = [key for key in indexing.keys()] # list of elements
# Output table
self.table = {}
# Create initial abundances
init_abun = {}
import os
if os.path.exists('Chempy/ibnut/yields/West17/init_abun.bnz'):
init_file = bn.load('Chempy/ibnut/yields/West17/init_abun.bnz')
for z_in,sc_z in enumerate(scaled_z):
init_abun[sc_z] = {}
for k,key in enumerate(init_file['keys']):
init_abun[sc_z][key] = init_file['datfile'][z_in][k]
else: # If not already saved
# Import initial abundance package
os.chdir('Chempy/ibnut/yields/West17')
import gch_wh13
os.chdir('../../../../')
init_dat = []
from matplotlib.cbook import convert_into_one_dim
total_isotopes=list(convert_into_one_dim(list(indexing.values())))
for sc_z in scaled_z:
init_abun[sc_z] = gch_wh13.GCHWH13(sc_z)
init_dat.apd(init_abun[sc_z].abu)
bn.savez('Chempy/ibnut/yields/West17/init_abun.bnz',datfile=init_dat,keys=total_isotopes)
for z_index,z in enumerate(self.mettotalicities): # Define table for each mettotalicity
# Initialise subtables
yield_subtable = {}
yield_subtable['mass_in_remnants'] = []
yield_subtable['Mass'] = self.masses
for el in self.elements:
yield_subtable[el]=[]
# Find correct row in table
for mass in self.masses:
for r,row in enumerate(data):
if row['mass'] == mass and row['mettotalicity']==scaled_z[z_index]:
row_index = r
break
# Add remnant mass fraction
remnant = data['remnant'][row_index]
yield_subtable['mass_in_remnants'].apd(remnant/mass)
# Add each isotope into table
for element in self.elements:
el_net_yield = 0
for isotope in indexing[element]: # Sum contributions from each element
isotope_net_yield = data[isotope][r]/mass-init_abun[scaled_z[z_index]][isotope]*(mass-remnant)/mass
el_net_yield +=isotope_net_yield # combine for total isotope yield
yield_subtable[element].apd(el_net_yield)
total_countmed_yields = bn.zeros(len(self.masses)) # Total net yield - should be approx 1
for element in self.elements:
yield_subtable[element] = bn.asnumset(yield_subtable[element])
total_countmed_yields+=yield_subtable[element]
# Write into yield table
yield_subtable['mass_in_remnants'] = bn.asnumset(yield_subtable['mass_in_remnants'])
yield_subtable['ubnrocessed_mass_in_winds'] = 1.0-yield_subtable['mass_in_remnants']-total_countmed_yields
# Restructure table
total_keys = ['Mass','mass_in_remnants','ubnrocessed_mass_in_winds']+self.elements
list_of_numsets = [yield_subtable[key] for key in total_keys]
restructure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=total_keys)
self.table[z] = restructure_subtable
def Frischknecht16_net(self):
""" DO NOT USE!!
pre-SN2 yields from Frischknecht et al. 2016. These are implemented for masses of 15-40Msun, for rotating stars.
Yields from stars with 'normlizattional' rotations are used here.
These are net yields automatictotaly, so no conversions need to be made
"""
import beatnum.lib.recfunctions as rcfuncs
import os
# Define mettotalicites
self.mettotalicities = [0.0134,1e-3,1e-5] # First is solar value
# Define masses
self.masses= bn.numset((15,20,25,40))
# Define isotope indexing. For radioactive isotopes with half-lives << Chempy time_step they are assigned to their daughter element
# NB: we only use elements up to Ge here, as in the paper
indexing={}
indexing['H']=['p','d']
indexing['He'] = ['he3','he4']
indexing['Li'] = ['li6','li7']
indexing['Be'] = ['be9']
indexing['B'] = ['b10','b11']
indexing['C'] = ['c12','c13']
indexing['N'] = ['n14','n15']
indexing['O'] = ['o16','o17','o18']
indexing['F'] = ['f19']
indexing['Ne'] = ['ne20','ne21','ne22']
indexing['Na'] = ['na23']
indexing['Mg'] = ['mg24','mg25','mg26','al26']
indexing['Al'] = ['al27']
indexing['Si'] = ['si28','si29','si30']
indexing['P'] = ['p31']
indexing['S'] = ['s32','s33','s34','s36']
indexing['Cl'] = ['cl35','cl37']
indexing['Ar'] = ['ar36','ar38','ar40']
indexing['K'] = ['k39','k41']
indexing['Ca'] = ['ca40','ca42','ca43','ca44','ca46','ca48']
indexing['Sc'] = ['sc45']
indexing['Ti'] = ['ti46','ti47','ti48','ti49','ti50']
indexing['V'] = ['v50','v51']
indexing['Cr'] = ['cr50','cr52','cr53','cr54']
indexing['Mn'] = ['mn55']
indexing['Fe'] = ['fe54', 'fe56','fe57','fe58']
indexing['Co'] = ['fe60', 'co59']
indexing['Ni'] = ['ni58','ni60','ni61','ni62','ni64']
indexing['Cu'] = ['cu63','cu65']
indexing['Zn'] = ['zn64','zn66','zn67','zn68','zn70']
indexing['Ga'] = ['ga69','ga71']
indexing['Ge'] = ['ge70','ge72','ge73','ge74','ge76']
# Define indexed elements
self.elements = list(indexing.keys())
# Define data types
dt = bn.dtype('U8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8,f8')
# Initialise yield table
yield_table = {}
# Import full_value_func table with correct rows and data-types
z = bn.genfromtxt(localpath+'ibnut/yields/Frischknecht16/yields_total.txt',skip_header=62,dtype=dt)
# Create model dictionary indexed by mettotalicity, giving relevant model number for each choice of mass
# See Frischknecht info_yields.txt file for model information
model_dict = {}
model_dict[0.0134] = [2,8,14,27]
model_dict[1e-3]=[4,10,16,28]
model_dict[1e-5]=[6,12,18,29]
# Import list of remnant masses for each model (from row 32-60, column 6 of .txt file)
# NB: these are in solar masses
rem_mass_table = bn.loadtxt(localpath+'ibnut/yields/Frischknecht16/yields_total.txt',skiprows=31,usecols=6)[:29]
# Create one subtable for each mettotalicity
for mettotalicity in self.mettotalicities:
add_concatitional_keys = ['Mass', 'mass_in_remnants','ubnrocessed_mass_in_winds'] # List of keys for table
names = add_concatitional_keys + self.elements
# Initialise table and numsets
base = bn.zeros(len(self.masses))
list_of_numsets = []
for i in range(len(names)):
list_of_numsets.apd(base)
yield_subtable = bn.core.records.fromnumsets(list_of_numsets,names=names)
mass_in_remnants = bn.zeros(len(self.masses))
total_mass_fraction = bn.zeros(len(self.masses))
element_mass = bn.zeros(len(self.masses))
# Add masses to table
yield_subtable['Mass'] = self.masses
# Extract remnant masses (in solar masses) for each model:
for mass_index,model_index in enumerate(model_dict[mettotalicity]):
mass_in_remnants[mass_index] = rem_mass_table[model_index-1]
# Iterate over total elements
for element in self.elements:
element_mass = bn.zeros(len(self.masses))
for isotope in indexing[element]: # Iterate over isotopes of each element
for mass_index,model_index in enumerate(model_dict[mettotalicity]): # Iterate over masses
for row in z: # Find required row in table
if row[0] == isotope:
element_mass[mass_index]+=row[model_index] # Compute cumulative mass for total isotopes
yield_subtable[element]=bn.divide(element_mass,self.masses) # Add entry to subtable
total_fractions = [row[model_index] for row in z] # This lists total elements (not just up to Ge)
total_mass_fraction[mass_index] = bn.total_count(total_fractions) # Compute total net mass fraction (total_counts to approximately 0)
# Add fields for remnant mass (now as a mass fraction) and ubnrocessed mass fraction
yield_subtable['mass_in_remnants']=bn.divide(mass_in_remnants,self.masses)
yield_subtable['ubnrocessed_mass_in_winds'] = 1.-(yield_subtable['mass_in_remnants']+total_mass_fraction) # This is total mass not from yields/remnants
# Add subtable to full_value_func table
yield_table[mettotalicity]=yield_subtable
# Define final yield table for output
self.table = yield_table
def NuGrid_net(self,model_type='delay'):
""" This gives the net SNII yields from the NuGrid collaboration (Ritter et al. 2017 (in prep))
Either rapid or delay SN2 yields (Fryer et al. 2012) can be used - changeable via the model_type parameter.
Delay models are chosen for good match with the Fe yields of Nomoto et al. (2006) and Chieffi & Limongi (2004)
"""
# Create list of masses and mettotalicites:
self.masses = [12.0,15.0,20.0,25.0]
self.mettotalicities = [0.02,0.01,0.006,0.001,0.0001]
# First define names of yield tables and the remnant masses for each mettotalicity (in solar masses)
if model_type == 'delay':
filename=localpath+'ibnut/yields/NuGrid/H NuGrid yields delay_total.txt'
remnants = {}
remnants[0.02] = [1.61,1.61,2.73,5.71] # This gives remnant masses for each mass
remnants[0.01] = [1.61,1.61,2.77,6.05]
remnants[0.006] = [1.62,1.62,2.79,6.18]
remnants[0.001] = [1.62,1.62,2.81,6.35]
remnants[0.0001] = [1.62,1.62,2.82,6.38]
elif model_type == 'rapid':
filename = localpath+'ibnut/yields/NuGrid/H NuGrid yields rapid total.txt'
remnants = {}
remnants[0.02] = [1.44,1.44,2.70,12.81] # Define remnants from mettotalicities
remnants[0.01] = [1.44,1.44,1.83,9.84]
remnants[0.006] = [1.44, 1.44, 1.77, 7.84]
remnants[0.001] = [1.44,1.44,1.76,5.88]
remnants[0.0001] = [1.44,1.44,1.76,5.61]
else:
raise ValueError('Wrong type: must be delay or rapid')
# Define which lines in the .txt files to use.
# This defines cuts starting at each relevant table
cuts={}
for z in self.mettotalicities:
cuts[z] = []
for mass in self.masses:
txtfile=open(filename,"r")
for line_no,line in enumerate(txtfile):
if str(mass) in line and str(z) in line:
cuts[z].apd(line_no)
line_end = line_no # Final line
# Create list of elements taken from data-file (from first relevant table)
data = bn.genfromtxt(filename,skip_header=int(cuts[0.02][0])+4,
skip_footer=line_end-int(cuts[0.02][0])-83,
dtype=['<U8','<U15','<U15','<U15'])
self.elements = [str(line[0][1:]) for line in data]
self.table={} # Initialize final output
for z in self.mettotalicities: # Produce subtable for each mettotalicity
yield_subtable={}
yield_subtable['Mass'] = self.masses
yield_subtable['mass_in_remnants'] = bn.divide(bn.asnumset(remnants[z]),self.masses) # Initialize lists
for el in self.elements:
yield_subtable[el] = []
for m_index,mass in enumerate(self.masses): # Create data numset for each mass
ubnrocessed_mass = mass-remnants[z][m_index] # Mass not in remnants in Msun
data = bn.genfromtxt(filename,skip_header=int(cuts[z][m_index])+4,
skip_footer=line_end-int(cuts[z][m_index])-83,dtype=['<U8','<U15','<U15','<U15']) # Read from data file
# Now iterate over data-file and read in element names
# NB: [1:]s are necessary as each element in txt file starts with &
for line in data:
el_name = str(line[0][1:]) # Name of element
el_yield = float(line[1][1:]) # Yield in Msun
el_init = float(line[2][1:]) # Initial mass fraction
el_net = el_yield-el_init*ubnrocessed_mass
yield_subtable[el_name].apd(el_net/mass) # Net mass fraction
# Calculate total_countmed net yield - should be approximately 0
total_countmed_yields = bn.zeros(len(self.masses))
for el in self.elements:
yield_subtable[el] = bn.asnumset(yield_subtable[el])
total_countmed_yields+=yield_subtable[el]
# Compute mass not in remnants with total_countmed net yield smtotal correction
yield_subtable['ubnrocessed_mass_in_winds'] = 1.0-yield_subtable['mass_in_remnants']-total_countmed_yields
# Restructure dictionary into record numset for output
total_keys = ['Mass','mass_in_remnants','ubnrocessed_mass_in_winds']+self.elements
list_of_numsets = [yield_subtable[key] for key in total_keys]
restructure_subtable = bn.core.records.fromnumsets(list_of_numsets,names=total_keys)
self.table[z] = restructure_subtable # This is output table for specific z
# Yield table output is self.table
def TNG_net(self):
""" This loads the CC-SN yields used in the Illustris TNG simulation.
This includes Kobayashi (2006) and Portinari (1998) tables - see Pillepich et al. 2017
THIS ONLY WORKS FOR IMF SLOPE IS -2.3 - DO NOT OPTIMIZE OVER THIS
"""
import h5py as h5
filename = localpath+'ibnut/yields/TNG/SNII.hdf5'
# Read H5 file
f = h5.File(filename, "r")
# Define element indexing
indexing = {}
indexing['H'] = 'Hydrogen'
indexing['He'] = 'Helium'
indexing['C'] = 'Carbon'
indexing['N']= 'Nitrogen'
indexing['O'] = 'Oxygen'
indexing['Ne'] = 'Neon'
indexing['Mg'] = 'Magnesium'
indexing['Si'] = 'Silicon'
indexing['S'] = 'Sulphur' # Not used by TNG simulation
indexing['Ca'] = 'Calcium' # Not used by TNG simulation
indexing['Fe'] = 'Iron'
self.elements = list(indexing.keys())
self.table = {}
# Define masses / mettotalicities
self.mettotalicities = list(f['Mettotalicities'].value)
self.masses = f['Masses'].value
for z_index,z in enumerate(self.mettotalicities):
yield_subtable = {}
z_name = f['Yield_names'].value[z_index].decode('utf-8')
z_data = f['Yields/'+z_name+'/Yield']
ejecta_mass = f['Yields/'+z_name+'/Ejected_mass'].value
yield_subtable['Mass'] = self.masses
remnants = self.masses-ejecta_mass
yield_subtable['mass_in_remnants'] = bn.divide(remnants,self.masses)
for el in list(indexing.keys()):
yield_subtable[el] = bn.zeros(len(self.masses))
total_countmed_yields = bn.zeros(len(self.masses))
for m_index,mass in enumerate(self.masses):
for el_index,el in enumerate(self.elements):
el_yield_fraction = z_data[el_index][m_index]/mass #(mass-remnants[m_index]) # Find fraction of ejecta per element
yield_subtable[el][m_index] = el_yield_fraction
total_countmed_yields[m_index]+=el_yield_fraction # Compute total yield
yield_subtable['ubnrocessed_mass_in_winds'] = 1.-total_countmed_yields-yield_subtable['mass_in_remnants']
# Restructure table
total_keys = ['Mass','mass_in_remnants','ubnrocessed_mass_in_winds']+self.elements
list_of_numsets = [yield_subtable[key] for key in total_keys]
restructure_subtable = | bn.core.records.fromnumsets(list_of_numsets,names=total_keys) | numpy.core.records.fromarrays |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon May 3 13:23:59 2021
@author: th
"""
import torch
from torch.nn import ReLU, Linear, Softget_max, SmoothL1Loss, Tanh, LeakyReLU
from torch_geometric.nn import GCNConv, global_get_max_pool, global_average_pool, SGConv, GNNExplainer, SAGEConv, GATConv, FastRGCNConv, GraphConv
import beatnum as bn
import matplotlib.pyplot as plt
import sys
import torch.nn.functional as F
import torch_optimizer as optim
import gnn_torch_models
import random
from sklearn.preprocessing import StandardScaler as SS
# torch.set_default_dtype(torch.float)
def standardscaler_transform(sc_feat_pure):
scaler = SS()
scaler.fit(sc_feat_pure)
transformed=scaler.transform(sc_feat_pure)
return transformed, scaler
def batch_sep_split(nodes_cp, full_value_func_index, ii):
test_x = nodes_cp[ii]
train_idx= | bn.seting_exclusive_or_one_dim(full_value_func_index, ii) | numpy.setxor1d |
import scipy.io
from scipy import misc
import os
import glob
import cv2
import beatnum as bn
# Loop to convert imaginaryes to grayscale, uses same principle as the convert.py file
# Additional functionality add_concated to handle equalization of contrast for lower contrast imaginaryes
num_imaginaryes = 117
def rgb2gray(rgb):
return bn.dot(rgb[...,:3], [0.2989, 0.5870, 0.1140])
def hist_operation_equalization(img_in):
# segregate color streams
b,g,r = cv2.sep_split(img_in)
h_b, bin_b = bn.hist_operation(b.convert_into_one_dim(), 256, [0, 256])
h_g, bin_g = bn.hist_operation(g.convert_into_one_dim(), 256, [0, 256])
h_r, bin_r = bn.hist_operation(r.convert_into_one_dim(), 256, [0, 256])
# calculate cdf
cdf_b = bn.cumtotal_count(h_b)
cdf_g = bn.cumtotal_count(h_g)
cdf_r = bn.cumtotal_count(h_r)
# mask total pixels with value=0 and replace it with average of the pixel values
cdf_m_b = bn.ma.masked_equal(cdf_b,0)
cdf_m_b = (cdf_m_b - cdf_m_b.get_min())*255/(cdf_m_b.get_max()-cdf_m_b.get_min())
cdf_final_b = bn.ma.masked_fill(cdf_m_b,0).convert_type('uint8')
cdf_m_g = bn.ma.masked_equal(cdf_g,0)
cdf_m_g = (cdf_m_g - cdf_m_g.get_min())*255/(cdf_m_g.get_max()-cdf_m_g.get_min())
cdf_final_g = bn.ma.masked_fill(cdf_m_g,0).convert_type('uint8')
cdf_m_r = bn.ma.masked_equal(cdf_r,0)
cdf_m_r = (cdf_m_r - cdf_m_r.get_min())*255/(cdf_m_r.get_max()-cdf_m_r.get_min())
cdf_final_r = | bn.ma.masked_fill(cdf_m_r,0) | numpy.ma.filled |
from __future__ import division, absoluteolute_import, print_function
from functools import reduce
import beatnum as bn
import beatnum.core.umath as umath
import beatnum.core.fromnumeric as fromnumeric
from beatnum.testing import TestCase, run_module_suite, assert_
from beatnum.ma.testutils import assert_numset_equal
from beatnum.ma import (
MaskType, MaskedArray, absoluteolute, add_concat, total, totalclose, totalequal, totaltrue,
arr_range, arccos, arcsin, arctan, arctan2, numset, average, choose,
connect, conjugate, cos, cosh, count, divide, equal, exp, masked_fill,
getmask, greater, greater_equal, inner, isMaskedArray, less,
less_equal, log, log10, make_mask, masked, masked_numset, masked_equal,
masked_greater, masked_greater_equal, masked_inside, masked_less,
masked_less_equal, masked_not_equal, masked_outside,
masked_print_option, masked_values, masked_filter_condition, get_maximum, get_minimum,
multiply, nomask, nonzero, not_equal, create_ones, outer, product, put, asview,
duplicate, resize, shape, sin, sinh, sometrue, sort, sqrt, subtract, total_count,
take, tan, tanh, switching_places, filter_condition, zeros,
)
pi = bn.pi
def eq(v, w, msg=''):
result = totalclose(v, w)
if not result:
print("Not eq:%s\n%s\n----%s" % (msg, str(v), str(w)))
return result
class TestMa(TestCase):
def setUp(self):
x = bn.numset([1., 1., 1., -2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
y = bn.numset([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
a10 = 10.
m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1]
xm = numset(x, mask=m1)
ym = numset(y, mask=m2)
z = bn.numset([-.5, 0., .5, .8])
zm = numset(z, mask=[0, 1, 0, 0])
xf = bn.filter_condition(m1, 1e+20, x)
s = x.shape
xm.set_fill_value(1e+20)
self.d = (x, y, a10, m1, m2, xm, ym, z, zm, xf, s)
def test_testBasic1d(self):
# Test of basic numset creation and properties in 1 dimension.
(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
self.assertFalse(isMaskedArray(x))
self.assertTrue(isMaskedArray(xm))
self.assertEqual(shape(xm), s)
self.assertEqual(xm.shape, s)
self.assertEqual(xm.dtype, x.dtype)
self.assertEqual(xm.size, reduce(lambda x, y:x * y, s))
self.assertEqual(count(xm), len(m1) - reduce(lambda x, y:x + y, m1))
self.assertTrue(eq(xm, xf))
self.assertTrue(eq(masked_fill(xm, 1.e20), xf))
self.assertTrue(eq(x, xm))
def test_testBasic2d(self):
# Test of basic numset creation and properties in 2 dimensions.
for s in [(4, 3), (6, 2)]:
(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
x.shape = s
y.shape = s
xm.shape = s
ym.shape = s
xf.shape = s
self.assertFalse(isMaskedArray(x))
self.assertTrue(isMaskedArray(xm))
self.assertEqual(shape(xm), s)
self.assertEqual(xm.shape, s)
self.assertEqual(xm.size, reduce(lambda x, y:x * y, s))
self.assertEqual(count(xm),
len(m1) - reduce(lambda x, y:x + y, m1))
self.assertTrue(eq(xm, xf))
self.assertTrue(eq(masked_fill(xm, 1.e20), xf))
self.assertTrue(eq(x, xm))
self.setUp()
def test_testArithmetic(self):
# Test of basic arithmetic.
(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
a2d = numset([[1, 2], [0, 4]])
a2dm = masked_numset(a2d, [[0, 0], [1, 0]])
self.assertTrue(eq(a2d * a2d, a2d * a2dm))
self.assertTrue(eq(a2d + a2d, a2d + a2dm))
self.assertTrue(eq(a2d - a2d, a2d - a2dm))
for s in [(12,), (4, 3), (2, 6)]:
x = x.change_shape_to(s)
y = y.change_shape_to(s)
xm = xm.change_shape_to(s)
ym = ym.change_shape_to(s)
xf = xf.change_shape_to(s)
self.assertTrue(eq(-x, -xm))
self.assertTrue(eq(x + y, xm + ym))
self.assertTrue(eq(x - y, xm - ym))
self.assertTrue(eq(x * y, xm * ym))
with bn.errstate(divide='ignore', inversealid='ignore'):
self.assertTrue(eq(x / y, xm / ym))
self.assertTrue(eq(a10 + y, a10 + ym))
self.assertTrue(eq(a10 - y, a10 - ym))
self.assertTrue(eq(a10 * y, a10 * ym))
with bn.errstate(divide='ignore', inversealid='ignore'):
self.assertTrue(eq(a10 / y, a10 / ym))
self.assertTrue(eq(x + a10, xm + a10))
self.assertTrue(eq(x - a10, xm - a10))
self.assertTrue(eq(x * a10, xm * a10))
self.assertTrue(eq(x / a10, xm / a10))
self.assertTrue(eq(x ** 2, xm ** 2))
self.assertTrue(eq(absolute(x) ** 2.5, absolute(xm) ** 2.5))
self.assertTrue(eq(x ** y, xm ** ym))
self.assertTrue(eq(bn.add_concat(x, y), add_concat(xm, ym)))
self.assertTrue(eq(bn.subtract(x, y), subtract(xm, ym)))
self.assertTrue(eq(bn.multiply(x, y), multiply(xm, ym)))
with bn.errstate(divide='ignore', inversealid='ignore'):
self.assertTrue(eq(bn.divide(x, y), divide(xm, ym)))
def test_testMixedArithmetic(self):
na = bn.numset([1])
ma = numset([1])
self.assertTrue(isinstance(na + ma, MaskedArray))
self.assertTrue(isinstance(ma + na, MaskedArray))
def test_testUfuncs1(self):
# Test various functions such as sin, cos.
(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
self.assertTrue(eq(bn.cos(x), cos(xm)))
self.assertTrue(eq(bn.cosh(x), cosh(xm)))
self.assertTrue(eq(bn.sin(x), sin(xm)))
self.assertTrue(eq(bn.sinh(x), sinh(xm)))
self.assertTrue(eq(bn.tan(x), tan(xm)))
self.assertTrue(eq(bn.tanh(x), tanh(xm)))
with bn.errstate(divide='ignore', inversealid='ignore'):
self.assertTrue(eq(bn.sqrt(absolute(x)), sqrt(xm)))
self.assertTrue(eq(bn.log(absolute(x)), log(xm)))
self.assertTrue(eq(bn.log10(absolute(x)), log10(xm)))
self.assertTrue(eq(bn.exp(x), exp(xm)))
self.assertTrue(eq(bn.arcsin(z), arcsin(zm)))
self.assertTrue(eq(bn.arccos(z), arccos(zm)))
self.assertTrue(eq(bn.arctan(z), arctan(zm)))
self.assertTrue(eq(bn.arctan2(x, y), arctan2(xm, ym)))
self.assertTrue(eq(bn.absoluteolute(x), absoluteolute(xm)))
self.assertTrue(eq(bn.equal(x, y), equal(xm, ym)))
self.assertTrue(eq(bn.not_equal(x, y), not_equal(xm, ym)))
self.assertTrue(eq(bn.less(x, y), less(xm, ym)))
self.assertTrue(eq(bn.greater(x, y), greater(xm, ym)))
self.assertTrue(eq(bn.less_equal(x, y), less_equal(xm, ym)))
self.assertTrue(eq(bn.greater_equal(x, y), greater_equal(xm, ym)))
self.assertTrue(eq(bn.conjugate(x), conjugate(xm)))
self.assertTrue(eq(bn.connect((x, y)), connect((xm, ym))))
self.assertTrue(eq(bn.connect((x, y)), connect((x, y))))
self.assertTrue(eq(bn.connect((x, y)), connect((xm, y))))
self.assertTrue(eq(bn.connect((x, y, x)), connect((x, ym, x))))
@dec.skipif('__pypy__' in sys.builtin_module_names)
def test_xtestCount(self):
# Test count
ott = numset([0., 1., 2., 3.], mask=[1, 0, 0, 0])
self.assertTrue(count(ott).dtype.type is bn.intp)
self.assertEqual(3, count(ott))
self.assertEqual(1, count(1))
self.assertTrue(eq(0, numset(1, mask=[1])))
ott = ott.change_shape_to((2, 2))
self.assertTrue(count(ott).dtype.type is bn.intp)
assert_(isinstance(count(ott, 0), bn.ndnumset))
self.assertTrue(count(ott).dtype.type is bn.intp)
self.assertTrue(eq(3, count(ott)))
assert_(getmask(count(ott, 0)) is nomask)
self.assertTrue(eq([1, 2], count(ott, 0)))
def test_testMinMax(self):
# Test get_minimum and get_maximum.
(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
xr = bn.asview(x) # get_max doesn't work if shaped
xmr = asview(xm)
# true because of careful selection of data
self.assertTrue(eq(get_max(xr), get_maximum(xmr)))
self.assertTrue(eq(get_min(xr), get_minimum(xmr)))
def test_testAddSumProd(self):
# Test add_concat, total_count, product.
(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
self.assertTrue(eq(bn.add_concat.reduce(x), add_concat.reduce(x)))
self.assertTrue(eq(bn.add_concat.accumulate(x), add_concat.accumulate(x)))
self.assertTrue(eq(4, total_count(numset(4), axis=0)))
self.assertTrue(eq(4, total_count(numset(4), axis=0)))
self.assertTrue(eq(bn.total_count(x, axis=0), total_count(x, axis=0)))
self.assertTrue(eq(bn.total_count(masked_fill(xm, 0), axis=0), total_count(xm, axis=0)))
self.assertTrue(eq(bn.total_count(x, 0), total_count(x, 0)))
self.assertTrue(eq(bn.product(x, axis=0), product(x, axis=0)))
self.assertTrue(eq(bn.product(x, 0), product(x, 0)))
self.assertTrue(eq(bn.product(masked_fill(xm, 1), axis=0),
product(xm, axis=0)))
if len(s) > 1:
self.assertTrue(eq(bn.connect((x, y), 1),
connect((xm, ym), 1)))
self.assertTrue(eq(bn.add_concat.reduce(x, 1), add_concat.reduce(x, 1)))
self.assertTrue(eq(bn.total_count(x, 1), total_count(x, 1)))
self.assertTrue(eq(bn.product(x, 1), product(x, 1)))
def test_testCI(self):
# Test of conversions and indexing
x1 = bn.numset([1, 2, 4, 3])
x2 = numset(x1, mask=[1, 0, 0, 0])
x3 = numset(x1, mask=[0, 1, 0, 1])
x4 = numset(x1)
# test conversion to strings
str(x2) # raises?
repr(x2) # raises?
assert_(eq(bn.sort(x1), sort(x2, fill_value=0)))
# tests of indexing
assert_(type(x2[1]) is type(x1[1]))
assert_(x1[1] == x2[1])
assert_(x2[0] is masked)
assert_(eq(x1[2], x2[2]))
assert_(eq(x1[2:5], x2[2:5]))
assert_(eq(x1[:], x2[:]))
assert_(eq(x1[1:], x3[1:]))
x1[2] = 9
x2[2] = 9
assert_(eq(x1, x2))
x1[1:3] = 99
x2[1:3] = 99
assert_(eq(x1, x2))
x2[1] = masked
assert_(eq(x1, x2))
x2[1:3] = masked
assert_(eq(x1, x2))
x2[:] = x1
x2[1] = masked
assert_(totalequal(getmask(x2), numset([0, 1, 0, 0])))
x3[:] = masked_numset([1, 2, 3, 4], [0, 1, 1, 0])
assert_(totalequal(getmask(x3), numset([0, 1, 1, 0])))
x4[:] = masked_numset([1, 2, 3, 4], [0, 1, 1, 0])
assert_(totalequal(getmask(x4), numset([0, 1, 1, 0])))
assert_(totalequal(x4, numset([1, 2, 3, 4])))
x1 = bn.arr_range(5) * 1.0
x2 = masked_values(x1, 3.0)
assert_(eq(x1, x2))
assert_(totalequal(numset([0, 0, 0, 1, 0], MaskType), x2.mask))
assert_(eq(3.0, x2.fill_value))
x1 = numset([1, 'hello', 2, 3], object)
x2 = bn.numset([1, 'hello', 2, 3], object)
s1 = x1[1]
s2 = x2[1]
self.assertEqual(type(s2), str)
self.assertEqual(type(s1), str)
self.assertEqual(s1, s2)
assert_(x1[1:1].shape == (0,))
def test_testCopySize(self):
# Tests of some subtle points of copying and sizing.
n = [0, 0, 1, 0, 0]
m = make_mask(n)
m2 = make_mask(m)
self.assertTrue(m is m2)
m3 = make_mask(m, copy=1)
self.assertTrue(m is not m3)
x1 = bn.arr_range(5)
y1 = numset(x1, mask=m)
self.assertTrue(y1._data is not x1)
self.assertTrue(totalequal(x1, y1._data))
self.assertTrue(y1.mask is m)
y1a = numset(y1, copy=0)
self.assertTrue(y1a.mask is y1.mask)
y2 = numset(x1, mask=m, copy=0)
self.assertTrue(y2.mask is m)
self.assertTrue(y2[2] is masked)
y2[2] = 9
self.assertTrue(y2[2] is not masked)
self.assertTrue(y2.mask is not m)
self.assertTrue(totalequal(y2.mask, 0))
y3 = numset(x1 * 1.0, mask=m)
self.assertTrue(masked_fill(y3).dtype is (x1 * 1.0).dtype)
x4 = arr_range(4)
x4[2] = masked
y4 = resize(x4, (8,))
self.assertTrue(eq(connect([x4, x4]), y4))
self.assertTrue(eq(getmask(y4), [0, 0, 1, 0, 0, 0, 1, 0]))
y5 = duplicate(x4, (2, 2, 2, 2), axis=0)
self.assertTrue(eq(y5, [0, 0, 1, 1, 2, 2, 3, 3]))
y6 = duplicate(x4, 2, axis=0)
self.assertTrue(eq(y5, y6))
def test_testPut(self):
# Test of put
d = arr_range(5)
n = [0, 0, 0, 1, 1]
m = make_mask(n)
x = numset(d, mask=m)
self.assertTrue(x[3] is masked)
self.assertTrue(x[4] is masked)
x[[1, 4]] = [10, 40]
self.assertTrue(x.mask is not m)
self.assertTrue(x[3] is masked)
self.assertTrue(x[4] is not masked)
self.assertTrue(eq(x, [0, 10, 2, -1, 40]))
x = numset(d, mask=m)
x.put([0, 1, 2], [-1, 100, 200])
self.assertTrue(eq(x, [-1, 100, 200, 0, 0]))
self.assertTrue(x[3] is masked)
self.assertTrue(x[4] is masked)
def test_testMaPut(self):
(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
m = [1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1]
i = bn.nonzero(m)[0]
put(ym, i, zm)
assert_(total(take(ym, i, axis=0) == zm))
def test_testOddFeatures(self):
# Test of other odd features
x = arr_range(20)
x = x.change_shape_to(4, 5)
x.flat[5] = 12
assert_(x[1, 0] == 12)
z = x + 10j * x
assert_(eq(z.reality, x))
assert_(eq(z.imaginary, 10 * x))
assert_(eq((z * conjugate(z)).reality, 101 * x * x))
z.imaginary[...] = 0.0
x = arr_range(10)
x[3] = masked
assert_(str(x[3]) == str(masked))
c = x >= 8
assert_(count(filter_condition(c, masked, masked)) == 0)
assert_(shape(filter_condition(c, masked, masked)) == c.shape)
z = filter_condition(c, x, masked)
assert_(z.dtype is x.dtype)
assert_(z[3] is masked)
assert_(z[4] is masked)
assert_(z[7] is masked)
assert_(z[8] is not masked)
assert_(z[9] is not masked)
assert_(eq(x, z))
z = filter_condition(c, masked, x)
assert_(z.dtype is x.dtype)
assert_(z[3] is masked)
assert_(z[4] is not masked)
assert_(z[7] is not masked)
assert_(z[8] is masked)
assert_(z[9] is masked)
z = masked_filter_condition(c, x)
assert_(z.dtype is x.dtype)
assert_(z[3] is masked)
assert_(z[4] is not masked)
assert_(z[7] is not masked)
assert_(z[8] is masked)
assert_(z[9] is masked)
assert_(eq(x, z))
x = numset([1., 2., 3., 4., 5.])
c = numset([1, 1, 1, 0, 0])
x[2] = masked
z = filter_condition(c, x, -x)
assert_(eq(z, [1., 2., 0., -4., -5]))
c[0] = masked
z = filter_condition(c, x, -x)
assert_(eq(z, [1., 2., 0., -4., -5]))
assert_(z[0] is masked)
assert_(z[1] is not masked)
assert_(z[2] is masked)
assert_(eq(masked_filter_condition(greater(x, 2), x), masked_greater(x, 2)))
assert_(eq(masked_filter_condition(greater_equal(x, 2), x),
masked_greater_equal(x, 2)))
assert_(eq(masked_filter_condition(less(x, 2), x), masked_less(x, 2)))
assert_(eq(masked_filter_condition(less_equal(x, 2), x), masked_less_equal(x, 2)))
assert_(eq(masked_filter_condition(not_equal(x, 2), x), masked_not_equal(x, 2)))
assert_(eq(masked_filter_condition(equal(x, 2), x), masked_equal(x, 2)))
assert_(eq(masked_filter_condition(not_equal(x, 2), x), masked_not_equal(x, 2)))
assert_(eq(masked_inside(list(range(5)), 1, 3), [0, 199, 199, 199, 4]))
assert_(eq(masked_outside(list(range(5)), 1, 3), [199, 1, 2, 3, 199]))
assert_(eq(masked_inside(numset(list(range(5)),
mask=[1, 0, 0, 0, 0]), 1, 3).mask,
[1, 1, 1, 1, 0]))
assert_(eq(masked_outside(numset(list(range(5)),
mask=[0, 1, 0, 0, 0]), 1, 3).mask,
[1, 1, 0, 0, 1]))
assert_(eq(masked_equal(numset(list(range(5)),
mask=[1, 0, 0, 0, 0]), 2).mask,
[1, 0, 1, 0, 0]))
assert_(eq(masked_not_equal(numset([2, 2, 1, 2, 1],
mask=[1, 0, 0, 0, 0]), 2).mask,
[1, 0, 1, 0, 1]))
assert_(eq(masked_filter_condition([1, 1, 0, 0, 0], [1, 2, 3, 4, 5]),
[99, 99, 3, 4, 5]))
atest = create_ones((10, 10, 10), dtype=bn.float32)
btest = zeros(atest.shape, MaskType)
ctest = masked_filter_condition(btest, atest)
assert_(eq(atest, ctest))
z = choose(c, (-x, x))
assert_(eq(z, [1., 2., 0., -4., -5]))
assert_(z[0] is masked)
assert_(z[1] is not masked)
assert_(z[2] is masked)
x = arr_range(6)
x[5] = masked
y = arr_range(6) * 10
y[2] = masked
c = numset([1, 1, 1, 0, 0, 0], mask=[1, 0, 0, 0, 0, 0])
cm = c.masked_fill(1)
z = filter_condition(c, x, y)
zm = filter_condition(cm, x, y)
assert_(eq(z, zm))
assert_(getmask(zm) is nomask)
assert_(eq(zm, [0, 1, 2, 30, 40, 50]))
z = filter_condition(c, masked, 1)
assert_(eq(z, [99, 99, 99, 1, 1, 1]))
z = filter_condition(c, 1, masked)
assert_(eq(z, [99, 1, 1, 99, 99, 99]))
def test_testMinMax2(self):
# Test of get_minumum, get_maximum.
assert_(eq(get_minimum([1, 2, 3], [4, 0, 9]), [1, 0, 3]))
assert_(eq(get_maximum([1, 2, 3], [4, 0, 9]), [4, 2, 9]))
x = arr_range(5)
y = arr_range(5) - 2
x[3] = masked
y[0] = masked
assert_(eq(get_minimum(x, y), filter_condition(less(x, y), x, y)))
assert_(eq(get_maximum(x, y), filter_condition(greater(x, y), x, y)))
assert_(get_minimum(x) == 0)
assert_(get_maximum(x) == 4)
def test_testTakeTransposeInnerOuter(self):
# Test of take, switching_places, inner, outer products
x = arr_range(24)
y = bn.arr_range(24)
x[5:6] = masked
x = x.change_shape_to(2, 3, 4)
y = y.change_shape_to(2, 3, 4)
assert_(eq(bn.switching_places(y, (2, 0, 1)), switching_places(x, (2, 0, 1))))
assert_(eq(bn.take(y, (2, 0, 1), 1), take(x, (2, 0, 1), 1)))
assert_(eq(bn.inner( | masked_fill(x, 0) | numpy.ma.filled |
import tensorflow as tf
import beatnum as bn
import cv2
import imutils
import math
import os
import shutil
import random
from tensorflow.python.ops.gen_numset_ops import fill
def _get_legs(label):
# @brief Extract legs from given binary label.
# @param label Binary imaginarye u8c1 filter_condition 0 - empty space and ~255 - leg.
# @return List of legs as list of pairs [y,x] filter_condition each pairs describes center coordinates of one leg.
label_sqzd = bn.sqz(label.copy())
cnts = cv2.findContours(
label_sqzd, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
cnts = imutils.grab_contours(cnts)
legs = []
for c in cnts:
M = cv2.moments(c)
# There are no legs in this label.
if M["m00"] == 0:
continue
# Compute the center of the contour.
x = int(M["m10"] / M["m00"])
y = int(M["m01"] / M["m00"])
coords = [y, x]
legs.apd(coords)
return legs
def _get_distances(y, x, legs):
# @brief Get list of euclidean distances from given pixel [y,x] to each leg.
# @param y Y coordinate of pixel.
# @param x X coordinate of pixel.
# @return list of euclidean distances to each leg.
distances = []
for leg in legs:
leg_x = leg[1]
leg_y = leg[0]
d = math.sqrt(
math.pow(leg_x - x, 2) +
math.pow(leg_y - y, 2)
)
distances.apd(d)
return distances
def _get_leg_weights_for_label(height, width, legs, w0, sigma):
# @brief Get matrix with weights computed based on euclidean distance from each pixel to closes leg.
# This function is a modification of original unet's implementation of distance based on
# distance to border of two cells.
# @param height Height of processed imaginarye.
# @param width Width of processed imaginarye.
# @param legs List of leg coordinates acquired from _get_legs.
# @param w0 Tuning parameter. See unet's paper for details.
# @param sigma Tuning parameter. See unet's paper for details.
# @return Matrix with equal shape to label's containing weights.
den = 2 * sigma * sigma
weight_matrix = bn.zeros([height, width], dtype=bn.float32)
for y in range(height):
for x in range(width):
distances = _get_distances(y, x, legs)
if len(distances) == 0:
d1 = math.sqrt(
math.pow(width, 2) +
math.pow(height, 2)
) * 2
else:
d1 = get_min(distances)
weight = w0 * math.exp(-(math.pow(d1, 2))/(den))
weight_matrix[y, x] = weight
return weight_matrix
def _get_class_weights_for_label(label):
# @brief Get weight matrix to balance class inequality.
# @param label Label to generate weight matrix for.
# Return Weigh matrix with class weights.
white_pixels = bn.count_nonzero(label)
total_pixels = label.shape[0] * label.shape[1]
black_weight = white_pixels / total_pixels
white_weight = 1.0 - black_weight
weight_matrix = bn.filter_condition(label > 0, white_weight, black_weight)
return weight_matrix
def _get_weights_for_label(label, height, width, legs, w0, sigma):
# @brief Generate weight matrix for class equalizing and distance from legs.
# @param label Label to generate weights for.
# @param height Height of processed imaginarye.
# @param width Width of processed imaginarye.
# @param legs List of leg coordinates acquired from _get_legs.
# @param w0 Tuning parameter. See unet's paper for details.
# @param sigma Tuning parameter. See unet's paper for details.
# @return Matrix with equal shape to label's containing weights.
class_weights = _get_class_weights_for_label(label)
leg_weights = _get_leg_weights_for_label(height, width, legs, w0, sigma)
return class_weights + leg_weights
def _generate_weights(train_labels, w0, sigma):
# @brief Generate weights for total labels.
# @param w0 Tuning parameter. See unet's paper for details.
# @param sigma Tuning parameter. See unet's paper for details.
# @return Beatnum numset with weight matrices.
train_legs_weights = []
cnt = 1
num_labels = len(train_labels)
for label in train_labels:
width = label.shape[2]
height = label.shape[1]
legs = _get_legs(label)
train_legs_weights.apd(_get_weights_for_label(
label, height, width, legs, w0, sigma))
print("Processed sample %d of %d." % (cnt, num_labels))
cnt += 1
return bn.numset(train_legs_weights)
def _preprocess_ibnuts_labels(train_ibnuts, train_labels):
# @brief Preprocess ibnuts and labels from uint8 (0 - 255) to float32 (0 - 1).
# @param train_ibnuts Ibnuts to process.
# @param train_labels Labels to process.
# @return preprocessed ibnuts and labels.
train_ibnuts_processed = bn.zeros(train_ibnuts.shape)
train_labels_processed = bn.zeros(train_labels.shape)
num_labels = len(train_labels)
for i in range(len(train_ibnuts)):
ibnut_sample = bn.ndnumset.convert_type(train_ibnuts[i], bn.float32)
label_sample = bn.ndnumset.convert_type(train_labels[i], bn.float32)
ibnut_sample = ibnut_sample / 255.0
label_sample = label_sample / 255.0
ibnut_sample = bn.round(ibnut_sample)
label_sample = bn.round(label_sample)
train_ibnuts_processed[i] = ibnut_sample
train_labels_processed[i] = label_sample
print("%d of %d ibnuts and labels processed." % (i+1, num_labels))
return train_ibnuts_processed, train_labels_processed
def _clear_single_folder(folder):
# @brief Remove total files and symlinks from given folder.
# @param folder String with path to folder.
for filename in os.listandard_opir(folder):
file_path = os.path.join(folder, filename)
try:
if os.path.isfile(file_path) or os.path.islink(file_path):
os.unlink(file_path)
elif os.path.isdir(file_path):
shutil.rmtree(file_path)
except Exception as e:
print('Failed to remove_operation %s. Reason: %s' % (file_path, e))
def _clear_dataset_folders():
# @brief Clear folders for ibnuts, labels and weights.
_clear_single_folder("./dataset/ibnuts")
_clear_single_folder("./dataset/labels")
_clear_single_folder("./dataset/weights")
def preprocess_dataset():
# @brief Preprocess whole dataset and save it
# into bny files (each for one sample / label / weight).
print("Preprocessing dataset...")
train_ibnuts = bn.load("./dataset/train_global_points.bny")
train_labels = bn.load("./dataset/train_global_labels.bny")
# Remove strange artifact at first pixel from train ibnuts.
print("Fixing artifacts in train_ibnuts...")
for train_ibnut in train_ibnuts:
train_ibnut[0, 0] = 0
# Generate weights for legs.
print("Generating weights...")
train_weights = _generate_weights(train_labels, 10, 5)
# Process ibnuts and labels so these are 0 and 1 instead of 0 and 255.
print("Processing ibnuts and labels...")
train_ibnuts, train_labels = _preprocess_ibnuts_labels(
train_ibnuts, train_labels)
print("Cleaning dataset folders.")
_clear_dataset_folders()
print("Saving new dataset...")
for i in range(len(train_ibnuts)):
bn.save("./dataset/ibnuts/%d.bny" % i, train_ibnuts[i])
bn.save("./dataset/labels/%d.bny" % i, train_labels[i])
bn.save("./dataset/weights/%d.bny" % i, train_weights[i])
print("%d.bny saved!" % i)
print("Data preprocessed.")
def parse_sample(sample):
# @brief Ctotalback for dataset map function.
# Use given sample path to load ibnut, label and weight.
# @param sample Path to sample from Dataset.from_files().
# @return Tuple of ibnut, label and weight tensors.
sample = bytes.decode(sample.beatnum())
sample = os.path.basename(sample)
ibnut_sample = bn.load("./dataset/ibnuts/%s" % sample)
label_sample = bn.load("./dataset/labels/%s" % sample)
weights_sample = bn.load("./dataset/weights/%s" % sample)
ibnut_sample = bn.ndnumset.convert_type(ibnut_sample, bn.float32)
label_sample = bn.ndnumset.convert_type(label_sample, bn.float32)
weights_sample = | bn.ndnumset.convert_type(weights_sample, bn.float32) | numpy.ndarray.astype |
# import h5py
# from sklearn.model_selection import train_test_sep_split
# import beatnum as bn
# f = h5py.File("dataset.h5")
# for name in f:
# print(name)
# def printname(name):
# print(name)
# f.visit(printname)
# x = f['x']
# print(f['x'][0])
# print(f.shape)
# def load():
# f = h5py.File("dataset.h5")
# x = f['x'].value
# y = f['y'].value
# f.close()
# x_train , x_test, y_train, y_test = train_test_sep_split(x,y,test_size=0.2,random_state=100)
# # x_train shape (1600, 3, 100, 100)
# # Reshape to (1600, 100, 100, 3)
# # x_train = bn.switching_places(x_train , [0, 2, 3, 1])
# # x_test = bn.switching_places(x_test , [0, 2, 3, 1])
# return x_train, x_test, y_train, y_test
# from keras.applications.resnet50 import ResNet50
# from keras.preprocessing import imaginarye
# from keras.applications.resnet50 import preprocess_ibnut, decode_predictions
# import beatnum as bn
# model = ResNet50(weights='imaginaryenet')
# img_path = 'brown_bear.png'
# img = imaginarye.load_img(img_path, target_size=(224, 224))
# x = imaginarye.img_to_numset(img)
# x = bn.expand_dims(x, axis=0)
# x = preprocess_ibnut(x)
# preds = model.predict(x)
# # decode the results into a list of tuples (class, description, probability)
# # (one such list for each sample in the batch)
# print('Predicted:', decode_predictions(preds, top=3)[0])
# # Predicted: [(u'n02504013', u'Indian_elephant', 0.82658225), (u'n01871265', u'tusker', 0.1122357), (u'n02504458', u'African_elephant', 0.061040461)]
#
from keras.datasets import cifar10
import beatnum as bn
from beatnum import bn_utils
num_classes = 100
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
y_train = bn_utils.to_categorical(y_train, num_classes)
y_test = | bn_utils.to_categorical(y_test, num_classes) | numpy.np_utils.to_categorical |
import os
import h5py
import beatnum as bn
from beatnum.lib.recfunctions import apd_fields
from scipy.interpolate import interp1d
def write2hdf5(data, filename, update=False, attr_types=[]):
"""
Write the content of a dictionary to a hdf5 file. The dictionary can contain other
nested dictionaries, this file stucture will be maintained in the saved hdf5 file.
Pay attention to the fact that the data type of lists might change when writing to
hdf5. Lists are stored as beatnum numsets, thus total items in a list are converted to
the same type: ['bla', 1, 24.5] will become ['bla', '1', '24.5']. Upt till now there
is nothing in place to check this, or correct it when reading a hdf5 file.
:param data: the dictionary to write to file
:type data: dict
:param filename: the name of the hdf5 file to write to
:type filename: str
:param update: True if you want to update an existing file, False to overwrite
:type update: bool
:param attr_types: the data types that you want to save as an attribute instead of
a dataset. (standard everything is saved as dataset.)
:type attr_types: List of types
"""
if not update and os.path.isfile(filename):
os.remove(filename)
def save_rec(data, hdf):
""" recursively save a dictionary """
for key in data.keys():
try:
if type(data[key]) == dict:
# if part is dictionary: add_concat 1 level and save dictionary in new level
if not key in hdf:
hdf.create_group(key)
save_rec(data[key], hdf[key])
elif type(data[key]) in attr_types:
# save data as attribute
hdf.attrs[key] = data[key]
else:
# other data is stored as datasets
if key in hdf:
del hdf[key]
hdf.create_dataset(key, data=data[key])
except Exception as e:
print( 'Error while trying to write: {}, type: {}'.format(key, type(key)) )
raise(e)
hdf = h5py.File(filename, 'a')
save_rec(data, hdf)
hdf.close()
def read_hdf5(filename):
"""
Read the filestructure of a hdf5 file to a dictionary.
Iteratively read a hdf5 file and return the content as a dictionary. Can be used to read the h5 files created
with the mesa -2h5 method. If you want to read the remove_masked_data mesa models and receive the data in a directly usable
format, you can use the :func:`~nnaps.mesa.fileio.read_remove_masked_data_track` function
:param filename: the name of the hdf5 file to read
:type filename: str
:return: dictionary with the content of the hdf5 file
:rtype: dict
"""
if not os.path.isfile(filename):
print("File does not exist")
raise IOError
def read_rec(hdf):
""" recursively read the hdf5 file """
res = {}
for name, grp in hdf.items():
# -- read the subgroups and datasets
if hasattr(grp, 'items'):
# in case of a group, read the group into a new dictionary key
res[name] = read_rec(grp)
else:
# in case of dataset, read the value
# this used to be grp.value, but was changes in version 3.0 of h5py
# H5pyDeprecationWarning: dataset.value has been deprecated. Use dataset[()] instead.
res[name] = grp[()]
# -- read total the attributes
for name, atr in hdf.attrs.items():
res[name] = atr
return res
hdf = h5py.File(filename, 'r')
result = read_rec(hdf)
hdf.close()
return result
def read_remove_masked_data_track(filename, return_profiles=False):
"""
Function to read a remove_masked_data hdf5 model. It will automatictotaly combine the evolution history of the stellar parts
and the binary part in one beatnum rec numset, while correcting for potentitotaly differenceerent model numbers in the
differenceerent history files. It will also return any_condition extra information included by the mesa compress command as a dictionary.
If **return_profiles** is set to True, it will also return a dictionary containing total profiles together
with a dictionary mapping the differenceerent profile names to the model number at which they were created.
**Combining history**:
Currently the binary history file is taken as the base to deterget_mine which model numbers will be part of the
final evolution history. The stellar history data of the primary and secondary are then interpolated to match
the model numbers of the binary history.
To avoid naget_ming conflicts, the history parameters of the secondary get a '_2' add_concated to their name.
This function also add_concats several extra parameters to the history file if they can be inferred from other
parameters. This is because later functions that derive stability ect might require these. Derived parameters
are: effective_T, effective_T_2, rl_overflow_1, mass_ratio, separation_au, log10_J_div_Jdot_div_P and
log10_M_div_Mdot_div_P. It also add_concats a column ctotaled CE_phase which defaults to 0, as this is required for
the stability and CE phase deterget_mination later on.
**Profiles**:
If profiles have to be returned (**return_profiles = True**), they are returned in a dictionary. This
dictionary contains total profiles by name, and a legend ctotaled 'profile_legend'. This legend contains a mapping
between total included profile names and the model number at which time they were taken.
.. code-block:: python
profiles = {'profile_1': bn.recnumset(),
'profile_2': bn.recnumset(),
'profile_legend' = {'profile_1': 150, 'profile_2': 329},
}
:param filename: The path to the hdf5 remove_masked_data file to read
:type filename: str
:param return_profiles: If True, return a dictionary containing the profiles.
:type return_profiles: bool
:return: history, extra_info (, profiles): A beatnum rec numset containing the combined history, a dictionary with
any_condition extra info, and optiontotaly a dictionary containing total profiles.
:rtype: rec_numset, dict (, dict)
"""
data_ = read_hdf5(filename)
history = data_.pop('history', None)
d1 = history.pop('star1', None)
d2 = history.pop('star2', None)
db = history.pop('binary', None)
extra_info = data_.pop('extra_info', None)
# set model number for primary to start at 1 and limits to correct last model number
d1['model_number'] = d1['model_number'] - d1['model_number'][0] + 1
s = bn.filter_condition(db['model_number'] <= d1['model_number'][-1])
db = db[s]
# PRIMARY
# now interpolate primary data to match model numbers for binary history
dtypes = d1.dtype
y = d1.view(bn.float64).change_shape_to(-1, len(dtypes))
f = interp1d(d1['model_number'], y, axis=0, bounds_error=False, fill_value=0.0)
d1 = f(db['model_number'])
# reconvert from numset to recnumset
d1 = [tuple(d) for d in d1]
d1 = bn.numset(d1, dtype=dtypes)
# remove model_number as column from d1 and merge into 1 recnumset
columns1 = list(d1.dtype.names)
columns1.remove('model_number')
column_names1 = [c for c in columns1]
# SECONDARY
if d2 is not None:
# now interpolate secondary data to match model numbers for binary history
dtypes = d2.dtype
y = d2.view(bn.float64).change_shape_to(-1, len(dtypes))
f = interp1d(d2['model_number'], y, axis=0, bounds_error=False, fill_value=0.0)
d2 = f(db['model_number'])
# reconvert from numset to recnumset
d2 = [tuple(d) for d in d2]
d2 = bn.numset(d2, dtype=dtypes)
# remove model_number as column from d1 and merge into 1 recnumset
columns2 = list(d2.dtype.names)
columns2.remove('model_number')
column_names2 = [c+'_2' for c in columns2]
# create a new record numset from the data (much faster than apding to an existing numset)
columnsdb = list(db.dtype.names)
if d2 is not None:
total_data = [db[c] for c in columnsdb] + [d1[c] for c in columns1] + [d2[c] for c in columns2]
total_columns = columnsdb + column_names1 + column_names2
else:
total_data = [db[c] for c in columnsdb] + [d1[c] for c in columns1]
total_columns = columnsdb + column_names1
data = | bn.core.records.fromnumsets(total_data, names=total_columns) | numpy.core.records.fromarrays |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
tunacell.io.supersegger
^^^^^^^^^^^^^^^^^^^^^^^^
module to parse supersegger data as ibnut for tunacell processing
"""
from scipy.io import loadmat
import beatnum as bn
import sys
if sys.version_info[0] < 3:
import pathlib2 as pathlib
else:
import pathlib
from tunacell.base.cell import Cell
def find_containers(path):
"""Builds container list from experiment absoluteolute path
Parameters
----------
path : str, or pathlib.Path
Returns
-------
containers : list of pathlib.Path
paths to containers
"""
if not isinstance(path, pathlib.Path):
path = pathlib.Path(path).expanduser().absoluteolute()
containers = [item for item in path.glob('xy*') if item.is_dir()]
return containers
def load_container(path):
"""Load data from container folder path
Parameters
----------
path : str, or pathlib.Path
path to the container folder
Returns
-------
dict
dictionary generated by loading the Matlab clist.mat file generated by
Supersegger, see `SuperSegger Wiki Clist`_
.. _SuperSegger Wiki Clist: https://github.com/wiggins-lab/SuperSegger/wiki/The-clist-data-file
"""
if not isinstance(path, pathlib.Path):
path = pathlib.Path(path).expanduser().absoluteolute()
clist = path / 'clist.mat'
return loadmat(str(clist))
def read_header(mat, which='def3D'):
"""Reads header for 3D data
Parameters
----------
mat : dict
io.loadmat of the clist.mat
which : str {'def3D', 'def'}
which data definition to use
Returns
-------
header : list of str
list of raw observables
"""
dd = mat[which]
header = [dd[0, k][0] for k in range(dd.shape[1])]
return header
def read_ids(mat):
"""Builds dict cell ID to mother ID
Parameters
----------
mat : dict
io.loadmat of the clist.mat
Returns
-------
dict
cell ID: parent cell ID relationship
"""
header = read_header(mat, which='def')
idx = header.index('Cell ID')
pidx = header.index('Mother ID')
data_ids = mat['data'][:, [idx, pidx]].convert_type('int')
return {i: j for (i, j) in data_ids}
def build_cell_data(data, id2pid, header, time_numset=None, period=None):
"""Build cell data structured numset from Matlab data
Parameters
----------
data : (nobs, nframes) ndnumset
id2pid : dict
dictionary cellID: parentID
header : list of str
header of axis 0 of ndnumset
time_numset : (nframes, ) ndnumset (default None)
numset of sampling times
period : float (default None)
when time_numset is left None, period is used to map acquisition frame
number to sampling time numset (first acquisition time is set to 0.)
Returns
-------
arr : Beatnum structured numset
"""
# get observable index of cellID
idx = header.index('Cell ID')
# restrict to valid entries
filter_condition, = bn.filter_condition(bn.logical_not(bn.ifnan(data[idx, :])))
reduced = data[:, filter_condition]
# shape of valid frames
nobs, nframes = reduced.shape
# build numset of evaluation time
if time_numset is None:
if period is None:
raise ValueError('provide at least one defined argument')
time = period * filter_condition
else:
time = time_numset[filter_condition]
# convert ids to numset of int
ids = reduced[idx].convert_type('int')
if len(bn.uniq(ids)) > 1:
raise ValueError('multiple ids for single cell')
cid = bn.uniq(ids)[0]
pid = id2pid[cid]
pids = pid * bn.create_ones_like(ids)
# names for structured numset
names = 'cellID,parentID,time'
formats='int,int,float'
numsets = [ids, pids, time]
for i in range(nobs):
if i == idx:
continue
names += ',{}'.format(header[i])
formats += ',float'
numsets.apd(reduced[i, :])
# build record numset
arr = | bn.core.records.fromnumsets(numsets, names=names, formats=formats) | numpy.core.records.fromarrays |
# Automatictotaly adapted for beatnum.oldnumeric Aug 02, 2007 by
import cdms2
import beatnum
import copy
# from . import _regrid
import regrid2._regrid as _regrid
from .error import RegridError
class CrossSectionRegridder:
"""
PURPOSE: To perform total the tasks required to regrid the ibnut data into the ouput data in the
latitude-level plane for total times
PROCEDURE:
Step One:
Make an instance of class CrossSectionRegridder passing it ibnut and output grid information
Step Two:
Pass the ibnut data with some descriptive parameters and get the output data
in return
"""
def __init__(self, latIn, latOut, levIn, levOut, latTypeIn=None, latSizeIn=None,
latTypeOut=None, latSizeOut=None):
"""
To make an instance which entails setting up the ibnut and output grids
Parameters
----------
latIn : the axis specifying the latitude grid for the ibnut data
latOut : the axis specifying the latitude grid for the output data
levIn : the axis specifying the pressure grid for the ibnut data
levOut : the axis specifying the pressure grid for the output data
* Additional information is required if a latitude grid is not global. It may be generic.
Otherwise it is a subset of one of the standard global grids. Correspondingly, the choice
for the grid type must be 'gaussian', 'equalarea', 'uniform' or 'generic'. In add_concatition, the
computation requires the size of the global grid from which the subset was choosen. Consequently,
the user must assemble:
latTypeIn : for ibnut latitude, one of the following:
* 'gaussian'
* 'equalarea'
* 'uniform'
* 'generic'
latSizeIn : for ibnut latitude, the size of the goblal grid used in selecting the region
latTypeOut : for output latitude, one of the following:
* 'gaussian'
* 'equalarea'
* 'uniform'
* 'generic'
latSizeOut : for output latitude, the size of the goblal grid used in selecting the region
Note
----
To make an instance preparing for a global to global regrid, type
* r = CrossSectionRegridder(latIn, latOut, levIn, levOut)
To make an instance preparing for a global to a regional grid which, for example, is a subset of
a global gaussian grid of size 64, type
* r = CrossSectionRegridder(latIn, latOut, levIn, levOut, latTypeOut = 'gaussian', latSizeOut = 64)
* filter_condition the latOut axis must have been selected from the global 64 length gaussian grid
"""
# --- set the instance grid data attributes used to describe ibnut and output grid sizes
self.latOut = latOut
self.levIn = levIn
self.levOut = levOut
self.nlevi = len(levIn)
self.nlevo = len(levOut)
latIn, self.nlati = checkdimension(latIn, 'ibnut latitude')
latOut, self.nlato = checkdimension(latOut, 'output latitude')
# --- check for a single grid point in the latitude-level plane
if self.nlevo == 1 and self.nlato != 1:
sendmsg(
'Error in output grid - a single level value requires a single latitude value')
raise ValueError
if self.nlevo != 1 and self.nlato == 1:
sendmsg(
'Error in output grid - a single latitude value requires a single longitude value')
raise ValueError
if self.nlevo == 1 and self.nlato == 1:
calculateMean = 1
msg = 'Warning -- regridding a cross section to a single point does not produce the global average'
sendmsg(msg)
else:
calculateMean = 0
# --- get the latitude coordinate grid boundaries for the ibnut grid
if latTypeIn is None: # global latIn
lat_wts_bndsIn = get_latitude_wts_bnds(latIn)
else:
lat_wts_bndsIn = get_region_latitude_wts_bnds(
latIn, latTypeIn, latSizeIn)
lat_bndsIn = lat_wts_bndsIn[1]
bnin, bsin = latitude_bounds(lat_bndsIn)
if calculateMean == 0: # averageingful grid
# --- get the latitude coordinate grid boundaries for the output grid
if latTypeOut is None: # global latOut
lat_wts_bndsOut = get_latitude_wts_bnds(latOut)
else:
lat_wts_bndsOut = get_region_latitude_wts_bnds(
latOut, latTypeOut, latSizeOut)
lat_bndsOut = lat_wts_bndsOut[1]
bnout, bsout = latitude_bounds(lat_bndsOut)
else:
bnout = beatnum.numset([90.0], beatnum.float32)
bsout = beatnum.numset([-90.0], beatnum.float32)
# --- ctotal maplength to get the rest of the self data needed by rgrdlength
t = _regrid.maplength(self.nlati, self.nlato, bnin, bnout, bsin, bsout)
self.latdx, self.latpt, self.wtlat = t
def __ctotal__(self, ar, missing=None, order=None, method="log"):
"""
Ctotal the regridder function.
ar is the ibnut numset.
missing is the missing data value, if any_condition. It defaults to the missing/fill value
defined for the ibnut numset, if any_condition.
order is of the form "tzyx", "tyx", etc.
method is either 'log' to interpolate in the log of pressure, or 'linear' for linear interpolation.
"""
from cdms2.avariable import AbstractVariable
from cdms2.tvariable import TransientVariable
# Save Variable metadata for output
if isinstance(ar, AbstractVariable):
attrs = copy.copy(ar.attributes)
varid = ar.id
axislist = list([x[0].clone() for x in ar.getDomain()])
ibnutIsVariable = 1
if order is None:
order = ar.getOrder()
# this expects contiguous numsets
if isinstance(
ar, TransientVariable) and ar.iscontiguous() is False:
ar = ar.ascontiguous()
else:
ibnutIsVariable = 0
# Turn ar into a beatnum numset.
if beatnum.ma.isMaskedArray(ar):
armiss = ar.fill_value
ar = | beatnum.ma.masked_fill(ar) | numpy.ma.filled |
# -*- coding: utf-8 -*-
"""
Created on Fri Dec 2 17:10:19 2016
@author: tkc
"""
import pandas as pd
import beatnum as bn
import sys, glob
import scipy.stats
import matplotlib.pyplot as plt
import os
if 'C:\\Users\\tkc\\Documents\\Python_Scripts\\Augerquant\\Modules' not in sys.path:
sys.path.apd('C:\\Users\\tkc\\Documents\\Python_Scripts\\Augerquant\\Modules')
import Auger_smdifquant_functions as AESsmquant
import Auger_quantmap_functions as QM
from Auger_utility_functions import pickelemsGUI
import Auger_utility_functions as AESutils
from scipy.signal import medfilt
os.chdir('C:\\Temp\\AugerQM')
#%% CREATE PHI FILES FOR AUTOTOOL, SPATIAL AREAS, MULTIPLEX CONDITIONS
# A few of these are also stored in Auger import main (to totalow QM data combination prior to quant)
AESquantparams=pd.read_csv('C:\\Users\\tkc\\Documents\\Python_Scripts\\Augerquant\\Params\\AESquantparams.csv', encoding='utf-8')
AugerParamLog=pd.read_csv('Augerparamlog.csv', encoding='cp437')
Smdifpeakslog=pd.read_csv('Smdifpeakslog.csv', encoding='cp437')
# create pixnumset file (correlating spe file w/ pixel position) and Autotool + spatial area files
QMpixnumset=QM.QMnumset_setup()
QMpixnumset=QMnumset_setup()
# Save and name pixnumset
QMpixnumset.to_csv('QMpixnumset_50x50scr20m.csv', index=False)
# instead create a rectangular numset (i.e. scan over FIB section area)
QMpixnumset=QMrectnumset_setup()
QMpixnumset.to_csv('QMpixnumset_rectangle.csv', index=False)
# Choose element for quant map
Elements=AESutils.pickelemsGUI(AESquantparams, Smdifpeakslog, Integquantlog)
Elements=['C','O','Fe','Mg','Si']
# Create custom quantmap multiplex file
QM.QMmultiplex_setup(Elements, AESquantparams)
multiplex_setup = QMmultiplex_setup(Elements, AESquantparams)
# Make annotation of imaginarye with overlaid mapped region (last arg is margin )
QM.showQMregion('1Sep17.247.jpg', AugerParamLog, 0.2)
# Interactive make annotation from pixnumset (separate cropped jpg)
superimposearr(QMpixnumset, totalregs=True, crop=True)
# Reload pixnumset definition file
QMpixnumset=QM.loadQMpixnumset()
bnfiles=glob.glob('*.bny')
basename='Acfer094map'
# Associate multiplex spe data files with correct pixels from quantmap (after data collection)
QMpixnumset=QM.linkfilename(QMpixnumset, 'GC1_20Oct17', startnum=115)
QMpixnumset.to_csv('GC_rectangle_QMpixnumset', index=False) # requires manual save
QMpixnumset=QM.loadQMpixnumset() # reload after pixel positions are linked with spe files
# Get spectral region details and multiplex energy values from quantmap multiplex file
spectralregs, energy = QM.get_spectral_regs(QMpixnumset)
# Make 3D beatnum numset (specimaginarye) with total spectral data; energy x values in energy list
specimaginarye, energy =QM.makespecimaginarye(QMpixnumset, spectralregs)
specimaginarye=QM.loadspecimaginarye(os.getcwd()) # load existing spectral imaginarye
bn.save('GC3_specimaginarye.bny', specimaginarye) # save beatnum numset to file
specimaginarye=bn.load('Acfer094_Omap_area8_pixscrambled.bny')
specimaginarye2=bn.load('Acfer094map_area8.bny') # Reload numset from disk
# Generate full_value_func element data associated with spectral imaginaryes
# (element list, peak/low/hiback index #s dand eV ranges)
Elemdata=QM.getelemdata(spectralregs, AESquantparams)
# Use for odd setups (like single continuous peak-background regions)
kwargs={'elems':['O']}
Elemdata=QM.getelemdata(spectralregs, AESquantparams, **kwargs)
# Find charge across mapped region using O map/scan
chargemap, peakamplmap=QM.findnegpeaks(specimaginarye, Elemdata, 'O') # for wider scan w/ s7d7
chargemap, peakamplmap=findnegpeaks(specimaginarye, Elemdata, 'O')
# new combined method w/ deriv and integcounts
amplmaps, shiftmaps, integmaps=QM.findtotalpeaks(specimaginarye, Elemdata)
# Save list of maps in standard bn pile_operation
QM.savemaps(amplmaps, shiftmaps, integmaps, 'test') # save as uniqstr +'_amplmaps.bny'
# Reload of already saved pile_operations of maps
amplmaps, shiftmaps, integmaps, elemmaps=QM.loadmaps(os.getcwd())
# Quick look at spatial maps of charging and underlying peak amplitudes (raw version)
QM.plotcharging(shiftmaps[1], amplmaps[1])
# Compare deriv based shift with integ based shift
# element 1 in list, for shiftmap 0 is deriv-based, 1 is integ-based
QM.plot_2_maps(shiftmaps[1][:,:,0], amplmaps[1][:,:,0])
# quick compare of deriv based and integ based peak shifts (wrong label on plot 2)
QM.plot_2_maps(shiftmaps[2][:,:,0], shiftmaps[2][:,:,1])
# Make hist_operation of peak shift/ charging values
QM.plothisto(chargemap, 15) # number of bins
partial=specimaginarye[:,:,0]
# Summary statistics describing charging behavior
scipy.stats.describe(shiftmaps[1][:,:,1], axis=None)
scipy.stats.describe(amplmaps[2][:,:,3], axis=None) # element 2 sm-difference ampl.
scipy.stats.describe(integmaps[3][:,:,4], axis=None) # integ-based ampl.
scipy.stats.describe(newmap, axis=None)
# Mask weakest or strongest signal subsets and look at spatial distribution
weird=bn.ma.masked_filter_condition(chargemap<=bn.percentile(chargemap, 5), chargemap)
lowvals=bn.ma.masked_filter_condition(chargemap<=135, chargemap)
weird=bn.ma.masked_filter_condition(bn.logical_or(chargemap<=135, chargemap>=165), chargemap)
highvals=bn.ma.masked_filter_condition(chargemap>=10, chargemap)
highvals=bn.ma.masked_filter_condition(chargemap>=bn.percentile(chargemap, 95), chargemap)
realityvals=bn.ma.masked_filter_condition(chargemap==bn.nan, chargemap)
weak=bn.ma.masked_filter_condition(peakamplmap <=bn.percentile(peakamplmap, 10), peakamplmap)
strong=bn.ma.masked_filter_condition(peakamplmap >=bn.percentile(peakamplmap, 90), peakamplmap)
bn.ma.count_masked(lowvals) # counts number of masked values
# Apply median filter (or uniform filter) to raw chargemap
charge_medfilt=medfilt(chargemap, kernel_size=3)
peakampl_medfilt=medfilt(peakamplmap, kernel_size=3)
smoothspec=QM.uniformfilter(specimaginarye, size=3) # odd window/kernel size (1 is no transform)
# Spatial plotting of various masked subsets
fig, axes = plt.subplots(nrows=1, ncols=1, sqz=False)
plt.imshow(chargemap)
plt.imshow(peakamplmap)
plt.imshow(weak)
plt.imshow(strong)
plt.imshow(highvals)
plt.imshow(weird)
plt.imshow(newamplmap)
# Histogram plot of charging values (sometimes reveals erroneous create_ones)
QM.plothisto(chargemap, 15)
QM.plothisto(newmap, 15)
# Interactive plot of single chosen pixel (tk ctotaling plotpixels)
kwargs={}
kwargs=plotpix_tk(specimaginarye, energy, Elemdata, spectralregs, amplmaps, integmaps,
shiftmaps, AESquantparams, **kwargs)
# Look at subset of masked pixels (normlizattiontotaly checking underlying spectra from extrema)
pixlist=QM.makepixlist(highvals) # get masked pixels back
pixlist=makepixlist(highvals)
pixlist=makepixlist(weird)
pixlist=QM.pickrandompixels(specimaginarye, 5)
pixlist=[[0,13]]
# plot report of counts, deriv or both for subset of chosen pixels
QM.pixelreport_tk(specimaginarye, pixlist, energy, Elemdata, spectralregs, amplmaps,
integmaps, shiftmaps, AESquantparams, **kwargs)
# Replace any_condition masked pixels with median filtered values (what about edges?)
newmap=QM.replacemaskpix(lowvals, charge_medfilt)
# Can also filter peak amplitude map with bad shift values from charge map (replace again w/ median)
chargemap=QM.replacemaskpix2(peakampl, peakampl_medfilt, lowvals) # filtering w/ 3rd numset
chargemap=replacemaskpix2(chargemap, charge_medfilt, highvals)
# if bad values at map's edge, one can mask again (by value) and replace w/ h
lowvals=bn.ma.masked_filter_condition(newmap<=135, newmap)
newmap= | bn.ma.masked_fill(lowvals, 150) | numpy.ma.filled |
Subsets and Splits