utils.py

from __future__ import absolute_import
from __future__ import print_function
from __future__ import division

import os
import pickle
import numpy as np
import math
import numbers

import torch
import torch.nn as nn
from torch.nn import functional as F

# from easydict import EasyDict as edict

SMPLX_PART_TO_IDX = {
    "Global": 0,
    "L_Thigh": 1,
    "R_Thigh": 2,
    "Spine": 3,
    "L_Calf": 4,
    "R_Calf": 5,
    "Spine1": 6,
    "L_Foot": 7,
    "R_Foot": 8,
    "Spine2": 9,
    "L_Toes": 10,
    "R_Toes": 11,
    "Neck": 12,
    "L_Shoulder": 13,
    "R_Shoulder": 14,
    "Head": 15,
    "L_UpperArm": 16,
    "R_UpperArm": 17,
    "L_ForeArm": 18,
    "R_ForeArm": 19,
    "L_Hand": 20,
    "R_Hand": 21,
    "Jaw": 22,
    "L_Eye": 23,
    "R_Eye": 24,
    "L_Index1": 25,
    "L_Index2": 26,
    "L_Index3": 27,
    "L_Middle1": 28,
    "L_Middle2": 29,
    "L_Middle3": 30,
    "L_Pinky1": 31,
    "L_Pinky2": 32,
    "L_Pinky3": 33,
    "L_Ring1": 34,
    "L_Ring2": 35,
    "L_Ring3": 36,
    "L_Thumb1": 37,
    "L_Thumb2": 38,
    "L_Thumb3": 39,
    "R_Index1": 40,
    "R_Index2": 41,
    "R_Index3": 42,
    "R_Middle1": 43,
    "R_Middle2": 44,
    "R_Middle3": 45,
    "R_Pinky1": 46,
    "R_Pinky2": 47,
    "R_Pinky3": 48,
    "R_Ring1": 49,
    "R_Ring2": 50,
    "R_Ring3": 51,
    "R_Thumb1": 52,
    "R_Thumb2": 53,
    "R_Thumb3": 54,
}


class GaussianSmoothing(nn.Module):
    """
    Apply gaussian smoothing on a
    1d, 2d or 3d tensor. Filtering is performed seperately for each channel
    in the input using a depthwise convolution.
    Arguments:
        channels (int, sequence): Number of channels of the input tensors. Output will
            have this number of channels as well.
        kernel_size (int, sequence): Size of the gaussian kernel.
        sigma (float, sequence): Standard deviation of the gaussian kernel.
        dim (int, optional): The number of dimensions of the data.
            Default value is 2 (spatial).
    """

    def __init__(self, channels, kernel_size, sigma, dim=2):
        super(GaussianSmoothing, self).__init__()
        if isinstance(kernel_size, numbers.Number):
            kernel_size = [kernel_size] * dim
        if isinstance(sigma, numbers.Number):
            sigma = [sigma] * dim

        # The gaussian kernel is the product of the
        # gaussian function of each dimension.
        kernel = 1
        meshgrids = torch.meshgrid(
            [torch.arange(size, dtype=torch.float32) for size in kernel_size]
        )
        for size, std, mgrid in zip(kernel_size, sigma, meshgrids):
            mean = (size - 1) / 2
            kernel *= (
                1
                / (std * math.sqrt(2 * math.pi))
                * torch.exp(-(((mgrid - mean) / std) ** 2) / 2)
            )

        # Make sure sum of values in gaussian kernel equals 1.
        kernel = kernel / torch.sum(kernel)

        # Reshape to depthwise convolutional weight
        kernel = kernel.view(1, 1, *kernel.size())
        kernel = kernel.repeat(channels, *[1] * (kernel.dim() - 1))

        self.register_buffer("weight", kernel)
        self.groups = channels

        if dim == 1:
            self.conv = F.conv1d
        elif dim == 2:
            self.conv = F.conv2d
        elif dim == 3:
            self.conv = F.conv3d
        else:
            raise RuntimeError(
                "Only 1, 2 and 3 dimensions are supported. Received {}.".format(dim)
            )

    def forward(self, input):
        """
        Apply gaussian filter to input.
        Arguments:
            input (torch.Tensor): Input to apply gaussian filter on.
        Returns:
            filtered (torch.Tensor): Filtered output.
        """
        return self.conv(input, weight=self.weight, groups=self.groups)


def rotation_6d_to_matrix(d6: torch.Tensor) -> torch.Tensor:
    """
    Converts 6D rotation representation by Zhou et al. [1] to rotation matrix
    using Gram--Schmidt orthogonalization per Section B of [1].
    Args:
        d6: 6D rotation representation, of size (*, 6)

    Returns:
        batch of rotation matrices of size (*, 3, 3)

    [1] Zhou, Y., Barnes, C., Lu, J., Yang, J., & Li, H.
    On the Continuity of Rotation Representations in Neural Networks.
    IEEE Conference on Computer Vision and Pattern Recognition, 2019.
    Retrieved from http://arxiv.org/abs/1812.07035
    """
    a1, a2 = d6[..., :3], d6[..., 3:]
    b1 = F.normalize(a1, dim=-1)
    b2 = a2 - (b1 * a2).sum(-1, keepdim=True) * b1
    b2 = F.normalize(b2, dim=-1)
    b3 = torch.cross(b1, b2, dim=-1)
    return torch.stack((b1, b2, b3), dim=-2)


def matrix_to_rotation_6d(matrix: torch.Tensor) -> torch.Tensor:
    """
    Converts rotation matrices to 6D rotation representation by Zhou et al. [1]
    by dropping the last row. Note that 6D representation is not unique.
    Args:
        matrix: batch of rotation matrices of size (*, 3, 3)

    Returns:
        6D rotation representation, of size (*, 6)

    [1] Zhou, Y., Barnes, C., Lu, J., Yang, J., & Li, H.
    On the Continuity of Rotation Representations in Neural Networks.
    IEEE Conference on Computer Vision and Pattern Recognition, 2019.
    Retrieved from http://arxiv.org/abs/1812.07035
    """
    return matrix[..., :2, :].clone().reshape(*matrix.size()[:-2], 6)


def smpl_to_openpose(
    model_type="smpl",
    use_hands=True,
    use_face=True,
    use_face_contour=False,
    openpose_format="coco25",
):
    """Returns the indices of the permutation that maps OpenPose to SMPL
    Parameters
    ----------
    model_type: str, optional
        The type of SMPL-like model that is used. The default mapping
        returned is for the SMPLX model
    use_hands: bool, optional
        Flag for adding to the returned permutation the mapping for the
        hand keypoints. Defaults to True
    use_face: bool, optional
        Flag for adding to the returned permutation the mapping for the
        face keypoints. Defaults to True
    use_face_contour: bool, optional
        Flag for appending the facial contour keypoints. Defaults to False
    openpose_format: bool, optional
        The output format of OpenPose. For now only COCO-25 and COCO-19 is
        supported. Defaults to 'coco25'
    """
    if openpose_format.lower() == "coco25":
        if model_type == "smpl":
            return np.array(
                [
                    24,
                    12,
                    17,
                    19,
                    21,
                    16,
                    18,
                    20,
                    0,
                    2,
                    5,
                    8,
                    1,
                    4,
                    7,
                    25,
                    26,
                    27,
                    28,
                    29,
                    30,
                    31,
                    32,
                    33,
                    34,
                ],
                dtype=np.int32,
            )
        elif model_type == "smplh":
            body_mapping = np.array(
                [
                    52,
                    12,
                    17,
                    19,
                    21,
                    16,
                    18,
                    20,
                    0,
                    2,
                    5,
                    8,
                    1,
                    4,
                    7,
                    53,
                    54,
                    55,
                    56,
                    57,
                    58,
                    59,
                    60,
                    61,
                    62,
                ],
                dtype=np.int32,
            )
            mapping = [body_mapping]
            if use_hands:
                lhand_mapping = np.array(
                    [
                        20,
                        34,
                        35,
                        36,
                        63,
                        22,
                        23,
                        24,
                        64,
                        25,
                        26,
                        27,
                        65,
                        31,
                        32,
                        33,
                        66,
                        28,
                        29,
                        30,
                        67,
                    ],
                    dtype=np.int32,
                )
                rhand_mapping = np.array(
                    [
                        21,
                        49,
                        50,
                        51,
                        68,
                        37,
                        38,
                        39,
                        69,
                        40,
                        41,
                        42,
                        70,
                        46,
                        47,
                        48,
                        71,
                        43,
                        44,
                        45,
                        72,
                    ],
                    dtype=np.int32,
                )
                mapping += [lhand_mapping, rhand_mapping]
            return np.concatenate(mapping)
        # SMPLX
        elif model_type == "smplx":
            body_mapping = np.array(
                [
                    55,
                    12,
                    17,
                    19,
                    21,
                    16,
                    18,
                    20,
                    0,
                    2,
                    5,
                    8,
                    1,
                    4,
                    7,
                    56,
                    57,
                    58,
                    59,
                    60,
                    61,
                    62,
                    63,
                    64,
                    65,
                ],
                dtype=np.int32,
            )
            mapping = [body_mapping]
            if use_hands:
                lhand_mapping = np.array(
                    [
                        20,
                        37,
                        38,
                        39,
                        66,
                        25,
                        26,
                        27,
                        67,
                        28,
                        29,
                        30,
                        68,
                        34,
                        35,
                        36,
                        69,
                        31,
                        32,
                        33,
                        70,
                    ],
                    dtype=np.int32,
                )
                rhand_mapping = np.array(
                    [
                        21,
                        52,
                        53,
                        54,
                        71,
                        40,
                        41,
                        42,
                        72,
                        43,
                        44,
                        45,
                        73,
                        49,
                        50,
                        51,
                        74,
                        46,
                        47,
                        48,
                        75,
                    ],
                    dtype=np.int32,
                )

                mapping += [lhand_mapping, rhand_mapping]
            if use_face:
                #  end_idx = 127 + 17 * use_face_contour
                face_mapping = np.arange(
                    76, 127 + 17 * use_face_contour, dtype=np.int32
                )
                mapping += [face_mapping]

            return np.concatenate(mapping)
        else:
            raise ValueError("Unknown model type: {}".format(model_type))
    elif openpose_format == "coco19":
        if model_type == "smpl":
            return np.array(
                [24, 12, 17, 19, 21, 16, 18, 20, 0, 2, 5, 8, 1, 4, 7, 25, 26, 27, 28],
                dtype=np.int32,
            )
        elif model_type == "smplh":
            body_mapping = np.array(
                [52, 12, 17, 19, 21, 16, 18, 20, 0, 2, 5, 8, 1, 4, 7, 53, 54, 55, 56],
                dtype=np.int32,
            )
            mapping = [body_mapping]
            if use_hands:
                lhand_mapping = np.array(
                    [
                        20,
                        34,
                        35,
                        36,
                        57,
                        22,
                        23,
                        24,
                        58,
                        25,
                        26,
                        27,
                        59,
                        31,
                        32,
                        33,
                        60,
                        28,
                        29,
                        30,
                        61,
                    ],
                    dtype=np.int32,
                )
                rhand_mapping = np.array(
                    [
                        21,
                        49,
                        50,
                        51,
                        62,
                        37,
                        38,
                        39,
                        63,
                        40,
                        41,
                        42,
                        64,
                        46,
                        47,
                        48,
                        65,
                        43,
                        44,
                        45,
                        66,
                    ],
                    dtype=np.int32,
                )
                mapping += [lhand_mapping, rhand_mapping]
            return np.concatenate(mapping)
        # SMPLX
        elif model_type == "smplx":
            body_mapping = np.array(
                [55, 12, 17, 19, 21, 16, 18, 20, 0, 2, 5, 8, 1, 4, 7, 56, 57, 58, 59],
                dtype=np.int32,
            )
            mapping = [body_mapping]
            if use_hands:
                lhand_mapping = np.array(
                    [
                        20,
                        37,
                        38,
                        39,
                        60,
                        25,
                        26,
                        27,
                        61,
                        28,
                        29,
                        30,
                        62,
                        34,
                        35,
                        36,
                        63,
                        31,
                        32,
                        33,
                        64,
                    ],
                    dtype=np.int32,
                )
                rhand_mapping = np.array(
                    [
                        21,
                        52,
                        53,
                        54,
                        65,
                        40,
                        41,
                        42,
                        66,
                        43,
                        44,
                        45,
                        67,
                        49,
                        50,
                        51,
                        68,
                        46,
                        47,
                        48,
                        69,
                    ],
                    dtype=np.int32,
                )

                mapping += [lhand_mapping, rhand_mapping]
            if use_face:
                face_mapping = np.arange(
                    70, 70 + 51 + 17 * use_face_contour, dtype=np.int32
                )
                mapping += [face_mapping]

            return np.concatenate(mapping)
        else:
            raise ValueError("Unknown model type: {}".format(model_type))
    else:
        raise ValueError("Unknown joint format: {}".format(openpose_format))


class JointMapper(nn.Module):
    def __init__(self, joint_maps=None):
        super(JointMapper, self).__init__()
        if joint_maps is None:
            self.joint_maps = joint_maps
        else:
            self.register_buffer(
                "joint_maps", torch.tensor(joint_maps, dtype=torch.long)
            )

    def forward(self, joints, **kwargs):
        if self.joint_maps is None:
            return joints
        else:
            return torch.index_select(joints, 1, self.joint_maps)


class Struct(object):
    def __init__(self, **kwargs):
        for key, val in kwargs.items():
            setattr(self, key, val)


def to_np(array, dtype=np.float32):
    if "scipy.sparse" in str(type(array)):
        array = array.todense()
    return np.array(array, dtype=dtype)


def load_smplx_model(smpl_path):
    # assert use_torch, "do NOT support numpy version yet"
    model = {}
    assert os.path.isfile(smpl_path)
    with open(smpl_path, "rb") as smpl_file:
        data_struct = Struct(**pickle.load(smpl_file, encoding="latin1"))

    model["parents"] = to_np(data_struct.kintree_table[0])
    model["v_template"] = to_np(data_struct.v_template)
    model["shapedirs"] = to_np(data_struct.shapedirs)
    model["J_regressor"] = to_np(data_struct.J_regressor)
    model["parents"][0] = -1
    model["parents"] = torch.tensor(model["parents"]).long() #.to(device)
    model["v_template"] = torch.tensor(model["v_template"]).float()# .to(device)
    model["shapedirs"] = torch.tensor(model["shapedirs"]).float()# .to(device)
    model["J_regressor"] = torch.tensor(model["J_regressor"]).float()# .to(device)
    return model


def vertices2joints(J_regressor, vertices):
    """Calculates the 3D joint locations from the vertices

    Parameters
    ----------
    J_regressor : torch.tensor JxV
        The regressor array that is used to calculate the joints from the
        position of the vertices
    vertices : torch.tensor BxVx3
        The tensor of mesh vertices

    Returns
    -------
    torch.tensor BxJx3
        The location of the joints
    """

    return torch.einsum("bik,ji->bjk", [vertices, J_regressor])


def blend_shapes(betas, shape_disps):
    """Calculates the per vertex displacement due to the blend shapes


    Parameters
    ----------
    betas : torch.tensor Bx(num_betas)
        Blend shape coefficients
    shape_disps: torch.tensor Vx3x(num_betas)
        Blend shapes

    Returns
    -------
    torch.tensor BxVx3
        The per-vertex displacement due to shape deformation
    """

    # Displacement[b, m, k] = sum_{l} betas[b, l] * shape_disps[m, k, l]
    # i.e. Multiply each shape displacement by its corresponding beta and
    # then sum them.
    blend_shape = torch.einsum("bl,mkl->bmk", [betas, shape_disps])
    return blend_shape


def batch_rodrigues(rot_vecs, epsilon=1e-8, dtype=torch.float32):
    """Calculates the rotation matrices for a batch of rotation vectors
    Parameters
    ----------
    rot_vecs: torch.tensor Nx3
        array of N axis-angle vectors
    Returns
    -------
    R: torch.tensor Nx3x3
        The rotation matrices for the given axis-angle parameters
    """

    batch_size = rot_vecs.shape[0]
    device = rot_vecs.device

    angle = torch.norm(rot_vecs + 1e-8, dim=1, keepdim=True)
    rot_dir = rot_vecs / angle

    cos = torch.unsqueeze(torch.cos(angle), dim=1)
    sin = torch.unsqueeze(torch.sin(angle), dim=1)

    # Bx1 arrays
    rx, ry, rz = torch.split(rot_dir, 1, dim=1)
    K = torch.zeros((batch_size, 3, 3), dtype=dtype, device=device)

    zeros = torch.zeros((batch_size, 1), dtype=dtype, device=device)
    K = torch.cat([zeros, -rz, ry, rz, zeros, -rx, -ry, rx, zeros], dim=1).view(
        (batch_size, 3, 3)
    )

    ident = torch.eye(3, dtype=dtype, device=device).unsqueeze(dim=0)
    rot_mat = ident + sin * K + (1 - cos) * torch.bmm(K, K)
    return rot_mat


def transform_mat(R, t):
    """Creates a batch of transformation matrices
    Args:
        - R: Bx3x3 array of a batch of rotation matrices
        - t: Bx3x1 array of a batch of translation vectors
    Returns:
        - T: Bx4x4 Transformation matrix
    """
    # No padding left or right, only add an extra row
    return torch.cat([F.pad(R, [0, 0, 0, 1]), F.pad(t, [0, 0, 0, 1], value=1)], dim=2)


def batch_rigid_transform(rot_mats, joints, parents, dtype=torch.float32):
    """
    Applies a batch of rigid transformations to the joints

    Parameters
    ----------
    rot_mats : torch.tensor BxNx3x3
        Tensor of rotation matrices
    joints : torch.tensor BxNx3
        Locations of joints
    parents : torch.tensor BxN
        The kinematic tree of each object
    dtype : torch.dtype, optional:
        The data type of the created tensors, the default is torch.float32

    Returns
    -------
    posed_joints : torch.tensor BxNx3
        The locations of the joints after applying the pose rotations
    rel_transforms : torch.tensor BxNx4x4
        The relative (with respect to the root joint) rigid transformations
        for all the joints
    """

    joints = torch.unsqueeze(joints, dim=-1)

    rel_joints = joints.clone()
    rel_joints[:, 1:] -= joints[:, parents[1:]]

    transforms_mat = transform_mat(
        rot_mats.reshape(-1, 3, 3), rel_joints.reshape(-1, 3, 1)
    ).reshape(-1, joints.shape[1], 4, 4)

    transform_chain = [transforms_mat[:, 0]]
    for i in range(1, parents.shape[0]):
        # Subtract the joint location at the rest pose
        # No need for rotation, since it's identity when at rest
        curr_res = torch.matmul(transform_chain[parents[i]], transforms_mat[:, i])
        transform_chain.append(curr_res)

    transforms = torch.stack(transform_chain, dim=1)

    # The last column of the transformations contains the posed joints
    posed_joints = transforms[:, :, :3, 3]

    # The last column of the transformations contains the posed joints
    posed_joints = transforms[:, :, :3, 3]

    joints_homogen = F.pad(joints, [0, 0, 0, 1])

    rel_transforms = transforms - F.pad(
        torch.matmul(transforms, joints_homogen), [3, 0, 0, 0, 0, 0, 0, 0]
    )

    return posed_joints, rel_transforms



def so3_relative_angle(m1, m2):
    m1 = m1.reshape(-1, 3, 3)
    m2 = m2.reshape(-1, 3, 3)
    m = torch.bmm(m1, m2.transpose(1, 2))  # batch*3*3
    cos = (m[:, 0, 0] + m[:, 1, 1] + m[:, 2, 2] - 1) / 2
    cos = torch.clamp(cos, min=-1 + 1E-6, max=1-1E-6)
    theta = torch.acos(cos)
    return theta


# speakers consts
SPEAKERS_CONFIG = {
    "almaram": {
        "median": np.array(
            [
                0.0,
                -106.0,
                -194.0,
                -104.0,
                106.0,
                162.0,
                137.0,
                134.0,
                144.0,
                126.0,
                118.0,
                104.0,
                119.0,
                111.0,
                105.0,
                101.0,
                125.0,
                122.0,
                116.0,
                111.0,
                133.0,
                131.0,
                129.0,
                124.0,
                140.0,
                139.0,
                140.0,
                140.0,
                -101.0,
                -87.0,
                -82.0,
                -74.0,
                -75.0,
                -86.0,
                -83.0,
                -81.0,
                -79.0,
                -85.0,
                -85.0,
                -82.0,
                -81.0,
                -83.0,
                -85.0,
                -83.0,
                -82.0,
                -84.0,
                -81.0,
                -80.0,
                -79.0,
                0.0,
                -6.0,
                117.0,
                126.0,
                5.0,
                139.0,
                139.0,
                116.0,
                131.0,
                144.0,
                136.0,
                135.0,
                134.0,
                131.0,
                130.0,
                132.0,
                135.0,
                132.0,
                133.0,
                135.0,
                137.0,
                135.0,
                136.0,
                137.0,
                140.0,
                138.5,
                138.0,
                139.0,
                109.0,
                110.0,
                114.0,
                117.0,
                117.0,
                114.0,
                116.0,
                119.0,
                119.0,
                117.0,
                120.0,
                123.0,
                122.0,
                122.0,
                127.0,
                126.0,
                125.0,
                125.5,
                130.0,
                130.0,
                128.0,
            ]
        ),
        "mean": np.array(
            [
                0.0,
                -102.831,
                -187.225,
                -105.001,
                103.684,
                159.654,
                126.302,
                122.931,
                128.711,
                112.718,
                106.145,
                96.845,
                108.125,
                101.695,
                97.327,
                93.299,
                112.474,
                108.298,
                103.437,
                99.548,
                117.103,
                113.895,
                110.956,
                106.925,
                121.72,
                119.542,
                118.971,
                118.283,
                -96.014,
                -87.539,
                -80.057,
                -73.948,
                -71.795,
                -82.32,
                -79.115,
                -76.73,
                -74.388,
                -82.105,
                -80.296,
                -77.741,
                -76.255,
                -82.054,
                -81.601,
                -79.339,
                -77.542,
                -83.858,
                -79.748,
                -79.177,
                -78.283,
                0.0,
                -5.559,
                113.522,
                114.089,
                4.688,
                134.756,
                128.186,
                105.581,
                113.738,
                127.147,
                112.519,
                113.059,
                119.44,
                113.858,
                114.358,
                116.299,
                120.788,
                116.685,
                117.822,
                119.544,
                126.314,
                122.744,
                122.36,
                122.702,
                131.012,
                127.488,
                126.576,
                125.979,
                102.175,
                101.177,
                100.914,
                99.242,
                96.896,
                99.399,
                99.966,
                100.655,
                100.153,
                102.595,
                104.855,
                107.204,
                106.748,
                107.49,
                111.118,
                111.368,
                110.997,
                112.068,
                114.87,
                115.63,
                114.635,
            ]
        ),
        "scale_factor": 1.518504709101034,
        "std": np.array(
            [
                0.0,
                15.77442357,
                31.74083135,
                38.76473912,
                16.00981399,
                28.00046935,
                40.03541927,
                46.47948191,
                52.37930392,
                47.88657929,
                48.78288609,
                48.42624263,
                46.59846966,
                48.26843663,
                50.59365643,
                52.47084523,
                48.17116694,
                51.37568682,
                53.37495696,
                54.50430897,
                50.88302655,
                54.47836245,
                56.48290063,
                57.29840639,
                54.71323058,
                58.40441966,
                60.72342348,
                62.18302752,
                46.9228708,
                44.15867388,
                46.51470467,
                49.62792859,
                52.8391046,
                49.06342426,
                52.13875502,
                55.0459726,
                57.37028374,
                47.79499948,
                51.69669606,
                54.54852811,
                56.73739486,
                48.16782208,
                51.27987714,
                53.97625477,
                56.09597344,
                49.14352283,
                51.41441914,
                53.19296637,
                54.5650521,
                0.0,
                6.80856218,
                25.98910379,
                51.67654283,
                6.51771862,
                27.4053729,
                48.12067543,
                44.45340751,
                52.2424287,
                71.22975074,
                65.97734186,
                72.21212861,
                66.43695056,
                66.68810866,
                70.34944091,
                74.74944548,
                62.9067171,
                64.10094988,
                67.69410843,
                71.30516155,
                63.17366068,
                63.74567016,
                65.48774236,
                67.96067389,
                63.03325992,
                62.88430532,
                63.75716606,
                64.36825739,
                54.93795023,
                60.33219432,
                67.52062355,
                69.96675951,
                72.42787574,
                67.3515538,
                68.93075398,
                70.52320168,
                71.7720112,
                64.30512402,
                66.268982,
                68.01139893,
                69.14937813,
                62.07604933,
                64.26042387,
                64.83709259,
                65.68755583,
                59.83643853,
                61.15464905,
                62.18182291,
                62.71329823,
            ]
        ),
    },
    "angelica": {
        "median": np.array(
            [
                0.0,
                -112.0,
                -170.0,
                -51.0,
                112.0,
                169.0,
                89.0,
                65.0,
                49.5,
                35.0,
                37.0,
                40.0,
                40.0,
                41.0,
                41.0,
                42.0,
                45.0,
                45.0,
                45.0,
                45.0,
                50.0,
                49.0,
                49.0,
                48.0,
                55.0,
                54.0,
                53.0,
                53.0,
                -39.0,
                -20.0,
                4.0,
                19.0,
                28.0,
                4.5,
                21.0,
                28.0,
                32.0,
                -1.0,
                17.0,
                23.0,
                25.0,
                -6.0,
                9.0,
                15.0,
                18.0,
                -11.0,
                2.0,
                7.0,
                10.0,
                0.0,
                4.0,
                153.0,
                154.0,
                0.0,
                155.0,
                158.0,
                157.0,
                156.0,
                157.0,
                159.0,
                160.0,
                158.0,
                170.0,
                179.0,
                188.0,
                163.0,
                178.0,
                190.0,
                197.0,
                167.0,
                183.0,
                194.0,
                200.0,
                173.0,
                187.0,
                195.0,
                200.0,
                153.0,
                146.0,
                139.0,
                137.0,
                134.0,
                139.0,
                148.0,
                157.0,
                163.0,
                146.0,
                158.0,
                168.0,
                173.0,
                154.0,
                166.0,
                174.0,
                179.0,
                163.0,
                172.0,
                177.0,
                180.0,
            ]
        ),
        "mean": np.array(
            [
                0.0,
                -109.943,
                -170.558,
                -58.044,
                109.827,
                168.036,
                94.467,
                58.97,
                52.736,
                45.407,
                44.249,
                45.665,
                51.639,
                49.735,
                48.165,
                46.499,
                56.536,
                53.554,
                51.313,
                48.981,
                60.293,
                57.029,
                54.887,
                53.198,
                62.166,
                59.695,
                58.707,
                57.117,
                -43.247,
                -27.359,
                -8.778,
                3.673,
                12.136,
                -8.683,
                7.022,
                14.388,
                18.369,
                -13.301,
                3.559,
                10.722,
                14.248,
                -18.083,
                -2.826,
                4.011,
                7.615,
                -21.951,
                -9.82,
                -4.64,
                -0.922,
                0.0,
                3.994,
                150.072,
                139.343,
                -0.505,
                152.459,
                153.141,
                150.053,
                147.183,
                146.11,
                148.093,
                149.845,
                146.275,
                155.367,
                162.994,
                169.658,
                152.608,
                163.311,
                173.255,
                179.806,
                158.304,
                168.954,
                177.697,
                184.216,
                163.439,
                172.377,
                178.879,
                183.864,
                137.297,
                129.411,
                121.703,
                118.802,
                115.731,
                120.401,
                126.067,
                131.436,
                136.041,
                127.648,
                134.987,
                142.396,
                146.487,
                135.083,
                142.758,
                148.748,
                152.58,
                143.117,
                149.36,
                153.495,
                156.382,
            ]
        ),
        "scale_factor": 1.4269190517359058,
        "std": np.array(
            [
                0.0,
                16.41102529,
                31.97449978,
                46.67209085,
                17.08171745,
                27.65228208,
                37.84749544,
                64.7177804,
                56.76208509,
                51.92178108,
                51.05505851,
                53.54873271,
                53.50798706,
                53.75848561,
                55.10932566,
                57.11749293,
                53.06833994,
                51.87146695,
                53.27754716,
                55.13937467,
                53.40742599,
                51.39184915,
                51.61963029,
                53.751026,
                54.54957785,
                52.46150946,
                52.15593112,
                52.43355139,
                55.59562924,
                58.58003174,
                62.68405472,
                66.61520901,
                72.01281486,
                63.33601275,
                68.34514991,
                69.40195571,
                71.46270943,
                61.3120086,
                65.63071323,
                66.73936407,
                68.31931276,
                59.29323832,
                62.04278946,
                63.52757574,
                65.27939012,
                57.65251598,
                59.16748769,
                60.96555093,
                62.12406873,
                0.0,
                8.30312977,
                26.11135416,
                53.26602436,
                11.54088277,
                29.07432405,
                38.48177645,
                44.61889948,
                46.82268159,
                51.29107037,
                55.75426756,
                61.06446573,
                52.26399693,
                56.81973522,
                59.92917456,
                62.63712187,
                52.8356351,
                56.60500224,
                59.76263026,
                61.87583021,
                53.49947275,
                56.04178695,
                58.49736055,
                60.91419657,
                54.07829767,
                55.98037934,
                57.79308228,
                59.49702097,
                56.72689654,
                60.67602557,
                67.52811852,
                73.58046477,
                78.81067592,
                71.40644368,
                79.9644578,
                85.45076889,
                89.87280634,
                71.75058255,
                79.95804419,
                84.27783329,
                87.16994798,
                71.19769737,
                78.32231761,
                82.11062353,
                85.16347574,
                70.63294777,
                75.82125296,
                78.49320974,
                80.60754354,
            ]
        ),
    },
    "chemistry": {
        "median": np.array(
            [
                0.0,
                -149.0,
                -196.0,
                -90.0,
                145.0,
                208.0,
                235.0,
                246.0,
                230.5,
                216.0,
                210.0,
                211.0,
                246.0,
                243.0,
                234.0,
                227.0,
                254.0,
                245.0,
                231.0,
                223.0,
                258.0,
                248.0,
                235.0,
                227.0,
                258.0,
                249.0,
                241.0,
                234.0,
                -78.0,
                -57.0,
                -32.0,
                -10.0,
                7.0,
                -48.0,
                -22.0,
                -7.0,
                1.0,
                -54.0,
                -26.0,
                -10.0,
                -3.5,
                -58.0,
                -31.0,
                -17.0,
                -11.0,
                -57.0,
                -35.0,
                -25.0,
                -19.0,
                0.0,
                6.0,
                218.0,
                261.0,
                -5.0,
                163.0,
                145.0,
                133.0,
                120.5,
                108.0,
                104.0,
                103.0,
                101.0,
                99.0,
                102.0,
                105.0,
                115.0,
                115.0,
                119.0,
                121.0,
                129.0,
                131.0,
                131.0,
                132.0,
                142.0,
                143.0,
                144.0,
                144.0,
                264.0,
                244.0,
                229.0,
                225.0,
                217.0,
                226.0,
                225.0,
                232.0,
                237.0,
                241.0,
                241.0,
                249.0,
                252.0,
                257.0,
                258.0,
                264.0,
                266.0,
                275.0,
                278.0,
                280.0,
                279.0,
            ]
        ),
        "mean": np.array(
            [
                0.0,
                -143.897,
                -190.058,
                -86.903,
                140.926,
                217.721,
                264.637,
                268.052,
                258.891,
                250.801,
                250.009,
                253.757,
                274.376,
                274.907,
                272.892,
                271.535,
                283.333,
                280.266,
                273.551,
                270.236,
                287.871,
                283.827,
                275.362,
                270.974,
                288.984,
                285.165,
                278.785,
                274.5,
                -77.25,
                -57.731,
                -34.007,
                -13.901,
                0.662,
                -47.15,
                -22.265,
                -8.555,
                -1.11,
                -52.623,
                -24.446,
                -11.432,
                -6.058,
                -55.034,
                -29.605,
                -18.433,
                -13.892,
                -54.819,
                -35.755,
                -27.038,
                -22.352,
                0.0,
                6.167,
                206.923,
                216.101,
                -6.115,
                152.987,
                128.342,
                124.441,
                115.255,
                103.173,
                99.066,
                98.378,
                89.811,
                85.753,
                88.11,
                90.737,
                99.924,
                99.372,
                105.05,
                107.36,
                111.877,
                113.49,
                117.972,
                119.45,
                124.973,
                126.641,
                128.84,
                129.162,
                217.45,
                200.878,
                185.423,
                180.274,
                176.279,
                180.945,
                177.688,
                181.782,
                185.668,
                194.886,
                193.136,
                196.672,
                198.439,
                209.824,
                208.904,
                210.14,
                210.388,
                224.81,
                224.579,
                223.847,
                222.846,
            ]
        ),
        "scale_factor": 1.1010136119625171,
        "std": np.array(
            [
                0.0,
                17.54703368,
                35.7581688,
                69.24384154,
                16.8056099,
                53.67166067,
                105.93793103,
                109.97522128,
                119.78379322,
                134.17275207,
                147.06528115,
                156.34138272,
                135.87825663,
                152.2457827,
                163.87231107,
                172.43461014,
                134.22994491,
                152.57799725,
                160.81889006,
                165.36223361,
                132.95311339,
                148.92147283,
                155.09689538,
                158.15342337,
                132.44675815,
                145.00957822,
                149.17857344,
                151.5445677,
                70.96735517,
                74.05220212,
                79.28031881,
                86.12266368,
                91.10061337,
                85.69535285,
                94.60962306,
                97.50350237,
                98.95066397,
                87.13493485,
                96.15947735,
                97.23624518,
                97.90133112,
                87.86163465,
                96.21616795,
                96.25821269,
                96.51474673,
                88.89298194,
                95.43154078,
                95.6565134,
                95.6844193,
                0.0,
                9.75823299,
                41.59960422,
                85.24175502,
                9.68275658,
                49.8952586,
                94.65167212,
                102.899779,
                105.34503299,
                110.68926358,
                117.52109446,
                123.02262847,
                116.44959974,
                125.51849263,
                131.95820513,
                136.88519946,
                120.07525234,
                129.27803223,
                132.21424848,
                134.24947821,
                122.7018332,
                129.69374657,
                130.27591956,
                130.28394951,
                124.37462873,
                129.23850092,
                129.14637587,
                128.23497868,
                92.32908263,
                93.77521589,
                97.21511236,
                102.35374406,
                107.13176541,
                95.68562052,
                103.19170827,
                108.58317768,
                113.0156174,
                96.96912397,
                104.87073712,
                109.90668049,
                113.97662163,
                98.84680584,
                106.12451547,
                109.89005597,
                112.6861813,
                101.29443173,
                106.64136045,
                109.06442862,
                110.48723132,
            ]
        ),
    },
    "conan": {
        "mean": np.array(
            [
                0.0,
                -109.583,
                -156.881,
                -120.313,
                109.631,
                152.443,
                108.144,
                101.458,
                92.114,
                81.513,
                76.847,
                74.993,
                91.03,
                83.972,
                81.598,
                81.622,
                95.874,
                87.808,
                85.537,
                85.997,
                99.22,
                92.344,
                90.057,
                89.867,
                102.278,
                97.839,
                95.828,
                94.729,
                -112.329,
                -107.723,
                -101.084,
                -98.403,
                -97.372,
                -113.236,
                -106.546,
                -100.633,
                -97.867,
                -115.78,
                -107.062,
                -100.376,
                -97.709,
                -115.577,
                -107.58,
                -101.694,
                -98.566,
                -113.886,
                -107.761,
                -103.555,
                -100.291,
                0.0,
                -3.122,
                154.074,
                210.401,
                3.051,
                167.82,
                232.961,
                237.28,
                231.731,
                227.719,
                228.673,
                230.681,
                232.244,
                237.448,
                240.62,
                242.516,
                240.195,
                246.415,
                249.652,
                249.489,
                247.002,
                253.542,
                255.679,
                254.841,
                254.024,
                258.919,
                260.762,
                260.172,
                216.536,
                210.82,
                205.289,
                204.407,
                205.708,
                212.984,
                215.676,
                216.734,
                217.611,
                222.036,
                225.523,
                225.602,
                225.524,
                230.145,
                233.169,
                232.708,
                231.662,
                236.648,
                239.776,
                239.635,
                238.414,
            ]
        ),
        "scale_factor": 1.4305381955532037,
        "std": np.array(
            [
                0.0,
                10.59231377,
                32.5747577,
                87.34243545,
                11.07947828,
                28.23531036,
                81.80955485,
                94.92227471,
                96.95924404,
                102.26105726,
                108.35750824,
                113.98373985,
                105.4720489,
                115.84258809,
                120.26970689,
                122.74060907,
                105.35736388,
                116.27625353,
                119.70779687,
                121.70631451,
                104.85591829,
                114.45731809,
                117.19618488,
                118.52391873,
                104.49567798,
                111.82849851,
                114.05433975,
                114.97168155,
                99.95218236,
                100.40852688,
                105.43183079,
                111.24512839,
                116.71825742,
                109.49891462,
                119.41624632,
                124.78480801,
                128.55843539,
                111.29522721,
                121.82060645,
                127.12367452,
                129.74770256,
                112.66641945,
                122.448853,
                126.91806161,
                128.77232484,
                114.58103248,
                122.30987646,
                125.25131925,
                126.38526939,
                0.0,
                6.75537682,
                32.26199814,
                97.00566065,
                6.26788633,
                24.78805357,
                94.33954356,
                105.77244254,
                112.9200719,
                123.72302146,
                132.94217567,
                139.79612741,
                125.72067636,
                134.83989505,
                139.963108,
                143.67274531,
                124.0620771,
                133.07969332,
                137.87443888,
                140.63537208,
                122.2001882,
                130.13695953,
                134.74150051,
                137.58544152,
                120.85215523,
                126.25547291,
                130.08463151,
                131.9334545,
                105.97377366,
                113.70617222,
                125.14332375,
                132.79858189,
                140.62497195,
                128.00962364,
                137.0962473,
                141.59214401,
                144.98927436,
                126.15767398,
                134.63195561,
                138.48896561,
                140.98466379,
                124.44862384,
                131.4354459,
                134.99263956,
                137.01364077,
                122.28814373,
                127.69337424,
                130.25399716,
                131.22054185,
            ]
        ),
        "median": np.array(
            [
                0.0,
                -110.0,
                -153.0,
                -106.0,
                110.0,
                149.0,
                106.0,
                97.0,
                83.0,
                74.0,
                71.0,
                70.0,
                85.0,
                82.0,
                81.0,
                81.0,
                90.0,
                89.0,
                87.0,
                86.0,
                93.0,
                92.0,
                91.0,
                90.0,
                95.0,
                93.0,
                94.0,
                92.0,
                -101.0,
                -91.0,
                -78.0,
                -74.0,
                -74.0,
                -90.0,
                -80.0,
                -73.0,
                -69.0,
                -93.0,
                -80.0,
                -72.0,
                -69.0,
                -93.0,
                -80.0,
                -72.0,
                -69.5,
                -92.0,
                -81.0,
                -76.0,
                -73.0,
                0.0,
                -4.0,
                159.0,
                207.0,
                4.0,
                171.0,
                230.0,
                235.0,
                225.0,
                213.0,
                212.0,
                216.0,
                219.0,
                226.0,
                233.0,
                238.0,
                231.0,
                241.0,
                247.0,
                248.0,
                242.0,
                252.0,
                256.0,
                256.0,
                252.0,
                260.0,
                262.0,
                262.0,
                215.0,
                202.0,
                191.0,
                189.0,
                193.0,
                207.0,
                210.0,
                209.0,
                210.0,
                220.0,
                222.0,
                220.0,
                220.0,
                230.0,
                232.0,
                229.0,
                228.0,
                238.0,
                240.0,
                238.0,
                236.0,
            ]
        ),
    },
    "ellen": {
        "median": np.array(
            [
                0.0,
                -129.0,
                -172.0,
                -147.0,
                129.0,
                171.0,
                141.0,
                133.0,
                128.0,
                119.0,
                107.5,
                101.0,
                124.0,
                121.0,
                118.0,
                118.0,
                125.0,
                119.0,
                114.0,
                114.0,
                123.0,
                116.0,
                113.0,
                112.0,
                121.0,
                113.0,
                111.0,
                109.0,
                -143.0,
                -137.0,
                -130.0,
                -120.0,
                -116.0,
                -139.0,
                -137.0,
                -135.0,
                -135.0,
                -142.0,
                -138.0,
                -134.0,
                -133.0,
                -141.0,
                -136.0,
                -132.0,
                -130.0,
                -139.0,
                -134.0,
                -131.5,
                -129.0,
                0.0,
                -2.0,
                198.0,
                229.0,
                0.0,
                199.0,
                253.0,
                261.0,
                251.0,
                243.0,
                238.0,
                235.0,
                263.0,
                266.0,
                265.0,
                265.0,
                273.0,
                277.0,
                277.0,
                274.0,
                280.0,
                284.0,
                283.0,
                282.0,
                285.0,
                287.0,
                288.0,
                286.0,
                228.0,
                222.0,
                217.0,
                218.0,
                219.0,
                230.0,
                236.0,
                238.0,
                240.0,
                242.0,
                249.0,
                251.0,
                250.0,
                251.0,
                257.0,
                257.0,
                255.0,
                257.0,
                262.0,
                262.0,
                260.0,
            ]
        ),
        "mean": np.array(
            [
                0.0,
                -118.909,
                -164.154,
                -147.246,
                118.925,
                160.707,
                133.202,
                126.031,
                122.365,
                116.286,
                108.719,
                106.006,
                118.932,
                113.969,
                113.305,
                115.011,
                118.991,
                112.665,
                109.438,
                109.385,
                117.644,
                111.169,
                108.96,
                107.772,
                116.547,
                110.923,
                109.41,
                107.968,
                -144.238,
                -140.508,
                -135.596,
                -132.849,
                -131.928,
                -145.429,
                -143.271,
                -141.212,
                -141.904,
                -146.314,
                -142.76,
                -138.772,
                -137.964,
                -145.332,
                -140.897,
                -137.975,
                -136.323,
                -143.97,
                -139.602,
                -138.326,
                -136.509,
                0.0,
                -1.674,
                186.215,
                222.679,
                1.261,
                186.058,
                252.238,
                256.284,
                254.343,
                250.461,
                249.989,
                248.952,
                262.385,
                264.888,
                265.272,
                265.825,
                268.538,
                271.047,
                272.562,
                272.724,
                273.782,
                276.197,
                277.758,
                278.16,
                276.863,
                279.468,
                282.137,
                281.792,
                221.492,
                219.701,
                217.669,
                217.751,
                219.06,
                225.513,
                228.427,
                229.216,
                229.918,
                232.378,
                236.486,
                238.776,
                239.216,
                238.599,
                242.803,
                244.281,
                244.736,
                242.657,
                246.497,
                248.185,
                248.794,
            ]
        ),
        "scale_factor": 1.3185415037379011,
        "std": np.array(
            [
                0.0,
                25.8187668,
                41.89625621,
                77.94319396,
                26.03765302,
                36.60665446,
                60.07478003,
                68.73073577,
                71.76289971,
                78.7986688,
                85.17248405,
                91.8425063,
                81.57343548,
                90.51250764,
                96.94054866,
                103.783818,
                80.62698629,
                90.21175519,
                96.14923898,
                101.66000578,
                80.05647547,
                88.31894723,
                94.51180032,
                98.51348139,
                80.68749464,
                88.48727067,
                91.83456811,
                94.89260759,
                85.40677582,
                91.29359198,
                100.86450706,
                110.52797021,
                117.97610273,
                102.74902899,
                113.07612285,
                119.03282344,
                124.60098228,
                101.47065292,
                111.75965462,
                117.53972101,
                121.85632812,
                99.92104771,
                109.12218102,
                114.81892864,
                118.45598622,
                99.84089893,
                107.37479032,
                112.15367905,
                113.79890122,
                0.0,
                5.87807145,
                42.05188194,
                94.98783058,
                5.69902439,
                41.39882409,
                85.89787748,
                92.3838262,
                100.51717938,
                109.75256935,
                116.35522712,
                122.94281474,
                110.31635769,
                115.28223391,
                118.60499153,
                121.26193292,
                105.71004,
                110.80258477,
                115.78894661,
                118.8850614,
                103.46256558,
                108.43064231,
                113.94664293,
                117.36026755,
                102.35001823,
                107.34869806,
                111.92460065,
                114.05449897,
                103.00641697,
                112.17914066,
                121.99203023,
                127.82240414,
                133.5572177,
                124.74606138,
                130.2611403,
                133.63072006,
                136.23373032,
                120.91488377,
                127.17007433,
                131.01745618,
                132.5830432,
                119.50055313,
                125.03061302,
                127.97185643,
                129.91735952,
                117.63924239,
                121.72976625,
                124.69851954,
                126.28790743,
            ]
        ),
    },
    "jon": {
        "mean": np.array(
            [
                0.0,
                -153.331,
                -220.516,
                -210.796,
                160.263,
                215.725,
                113.459,
                106.156,
                81.586,
                56.863,
                41.095,
                30.188,
                70.704,
                50.813,
                37.224,
                28.324,
                78.826,
                54.748,
                40.502,
                32.23,
                84.64,
                62.526,
                49.402,
                42.049,
                87.848,
                71.01,
                61.826,
                55.67,
                -205.849,
                -185.743,
                -168.707,
                -161.135,
                -152.156,
                -190.978,
                -188.077,
                -185.31,
                -183.466,
                -206.802,
                -204.832,
                -201.539,
                -199.346,
                -218.691,
                -218.876,
                -215.868,
                -212.868,
                -227.754,
                -229.963,
                -229.562,
                -227.931,
                0.0,
                -2.292,
                190.993,
                231.52,
                -1.083,
                220.65,
                257.155,
                261.606,
                251.047,
                243.471,
                243.151,
                243.737,
                237.272,
                240.32,
                248.198,
                255.309,
                249.663,
                256.813,
                265.245,
                269.657,
                262.648,
                268.498,
                275.582,
                278.131,
                275.337,
                280.445,
                284.139,
                285.841,
                241.15,
                242.714,
                245.433,
                247.933,
                247.489,
                234.907,
                242.81,
                254.631,
                265.567,
                239.662,
                249.287,
                264.716,
                275.327,
                246.93,
                256.517,
                270.548,
                280.467,
                255.458,
                263.393,
                273.444,
                281.315,
            ]
        ),
        "median": np.array(
            [
                0.0,
                -155.0,
                -220.0,
                -208.0,
                162.0,
                214.0,
                102.0,
                94.0,
                66.0,
                37.0,
                19.0,
                6.0,
                53.0,
                32.0,
                16.5,
                6.0,
                64.0,
                38.0,
                22.0,
                13.0,
                71.0,
                48.0,
                33.0,
                25.0,
                76.0,
                59.0,
                49.0,
                41.0,
                -201.0,
                -177.0,
                -157.0,
                -147.0,
                -135.0,
                -180.0,
                -177.0,
                -173.0,
                -171.0,
                -200.0,
                -198.0,
                -193.0,
                -191.0,
                -214.5,
                -215.0,
                -212.0,
                -208.0,
                -227.0,
                -229.0,
                -229.0,
                -226.0,
                0.0,
                -4.0,
                192.0,
                253.0,
                0.0,
                231.0,
                283.0,
                290.0,
                281.0,
                277.0,
                279.0,
                283.0,
                269.0,
                276.0,
                289.0,
                298.0,
                282.0,
                295.0,
                309.0,
                314.0,
                295.0,
                307.0,
                318.0,
                321.0,
                309.0,
                318.0,
                324.0,
                327.0,
                268.0,
                273.0,
                282.0,
                290.0,
                290.0,
                269.0,
                283.0,
                300.0,
                315.0,
                274.0,
                289.0,
                308.0,
                322.0,
                281.0,
                295.0,
                312.0,
                324.0,
                289.0,
                300.0,
                313.0,
                322.0,
            ]
        ),
        "scale_factor": 1.0,
        "std": np.array(
            [
                0.0,
                13.60674241,
                33.3032993,
                58.68593003,
                14.80816771,
                41.0566849,
                86.83690643,
                91.52707613,
                96.46133217,
                103.81552018,
                111.29798729,
                116.84988941,
                108.953423,
                118.5386858,
                121.7592864,
                123.60705896,
                109.22557267,
                118.82313115,
                122.45853174,
                125.15311862,
                109.25032906,
                117.86855952,
                121.46853253,
                123.86147342,
                109.55747759,
                116.71509714,
                119.36929976,
                120.8869021,
                69.0435674,
                73.14218312,
                81.05269367,
                88.65717554,
                97.30981278,
                84.00480651,
                92.37692932,
                96.86237608,
                100.46773036,
                82.47765028,
                91.27185643,
                96.26633097,
                99.31366615,
                80.67351188,
                89.02701064,
                93.30791272,
                96.34672063,
                80.04087383,
                86.67089264,
                90.58648992,
                93.14206482,
                0.0,
                10.88231299,
                30.72401261,
                64.20069782,
                11.80025894,
                38.96731323,
                67.39309293,
                73.62073596,
                79.57721276,
                89.74364133,
                98.04464391,
                105.0374687,
                90.90715052,
                99.81535754,
                105.95001084,
                110.26701011,
                91.25035579,
                100.25840629,
                105.86755393,
                108.97285603,
                91.38375182,
                99.14092997,
                103.26581853,
                106.88325331,
                91.70622351,
                97.17438436,
                99.73720308,
                102.19299251,
                75.27206321,
                82.64365798,
                93.43973197,
                101.8475258,
                107.69945162,
                95.75379027,
                106.19971704,
                113.93437953,
                121.08109477,
                94.56100547,
                104.48614564,
                110.77791,
                116.16508973,
                94.30819212,
                101.95049637,
                106.9177146,
                111.37067348,
                93.46864841,
                99.52853134,
                103.17545669,
                105.90626882,
            ]
        ),
    },
    "oliver": {
        "mean": np.array(
            [
                0.0,
                -163.658,
                -211.057,
                -134.649,
                164.739,
                209.073,
                143.511,
                127.913,
                116.269,
                103.244,
                96.397,
                93.487,
                127.25,
                111.415,
                99.029,
                90.083,
                132.054,
                113.831,
                99.465,
                91.78,
                130.525,
                111.719,
                97.237,
                89.394,
                125.449,
                109.247,
                100.154,
                93.562,
                -117.402,
                -100.158,
                -82.374,
                -73.054,
                -67.696,
                -111.641,
                -100.162,
                -88.474,
                -79.601,
                -119.885,
                -105.883,
                -91.469,
                -83.153,
                -122.363,
                -108.076,
                -95.898,
                -88.328,
                -121.041,
                -110.486,
                -103.011,
                -97.96,
                0.0,
                1.885,
                226.397,
                229.072,
                -4.987,
                213.13,
                243.52,
                255.207,
                231.348,
                204.754,
                188.757,
                177.801,
                206.763,
                198.08,
                197.119,
                196.928,
                223.176,
                215.778,
                214.844,
                213.122,
                239.312,
                233.451,
                230.949,
                228.755,
                253.464,
                248.937,
                246.076,
                243.138,
                232.561,
                211.604,
                184.101,
                165.544,
                151.386,
                178.313,
                165.155,
                163.223,
                162.372,
                192.993,
                181.789,
                181.059,
                180.34,
                208.741,
                200.467,
                198.325,
                196.636,
                224.591,
                218.906,
                215.748,
                213.304,
            ]
        ),
        "scale_factor": 0.9549234615419752,
        "std": np.array(
            [
                0.0,
                11.99879311,
                29.82817043,
                54.03489427,
                12.11713163,
                35.70626935,
                100.127588,
                114.55109529,
                117.61694027,
                122.42752331,
                129.34672547,
                135.35726737,
                120.82736238,
                130.10660542,
                136.48968517,
                139.7453903,
                122.16887936,
                132.40670844,
                138.38685911,
                141.79375727,
                123.35014947,
                133.45671223,
                139.08317954,
                142.11474506,
                126.82329202,
                133.81198747,
                138.99624558,
                141.54416327,
                61.03361693,
                62.88763818,
                68.25358689,
                73.29697868,
                78.72461867,
                68.02637811,
                76.81368209,
                81.46072258,
                84.88038524,
                67.26606704,
                77.41239766,
                82.52517821,
                85.17540485,
                67.84581955,
                77.28375136,
                81.87896919,
                84.03993346,
                69.44094843,
                77.42084864,
                80.58891288,
                82.31571174,
                0.0,
                9.47827912,
                29.89226306,
                65.29199657,
                9.53880658,
                33.56934763,
                59.26234555,
                71.23782809,
                69.40388243,
                72.38679081,
                78.91335724,
                86.99427222,
                74.79921678,
                82.52043141,
                88.62611827,
                93.39188838,
                77.27343026,
                84.96602095,
                90.18950972,
                93.68292863,
                79.41305092,
                85.97462183,
                89.45524243,
                92.88002463,
                80.98173068,
                85.93479523,
                88.12695515,
                89.9635646,
                74.11004169,
                73.49017066,
                76.71515365,
                82.82322177,
                89.53648979,
                78.33528599,
                87.32146915,
                95.1113835,
                101.48254833,
                81.44670006,
                91.03851097,
                96.9321181,
                101.12747599,
                84.49668585,
                93.10840408,
                97.03436183,
                99.7947569,
                87.07782564,
                93.60984544,
                96.28646061,
                97.48070365,
            ]
        ),
        "median": np.array(
            [
                0.0,
                -165.0,
                -211.0,
                -128.0,
                167.0,
                205.0,
                118.0,
                96.5,
                82.0,
                66.0,
                56.0,
                50.0,
                94.0,
                77.0,
                62.0,
                51.0,
                99.0,
                82.0,
                63.0,
                53.0,
                99.0,
                77.0,
                59.0,
                50.0,
                92.0,
                72.0,
                60.0,
                53.0,
                -110.0,
                -93.0,
                -74.0,
                -63.0,
                -56.0,
                -104.0,
                -94.0,
                -81.0,
                -71.0,
                -112.0,
                -99.0,
                -83.0,
                -73.0,
                -114.0,
                -101.0,
                -86.0,
                -77.0,
                -112.0,
                -101.0,
                -93.0,
                -86.0,
                0.0,
                2.0,
                227.0,
                257.0,
                -4.0,
                219.0,
                267.0,
                279.0,
                253.0,
                220.0,
                200.0,
                182.0,
                227.0,
                219.0,
                221.0,
                222.0,
                247.0,
                241.0,
                242.0,
                242.0,
                267.0,
                262.0,
                260.0,
                258.0,
                284.0,
                280.0,
                277.0,
                273.0,
                264.0,
                241.0,
                210.0,
                188.0,
                167.0,
                211.0,
                196.0,
                192.0,
                190.0,
                226.0,
                215.0,
                214.0,
                212.0,
                243.0,
                235.0,
                235.0,
                232.0,
                260.0,
                255.0,
                253.0,
                251.0,
            ]
        ),
    },
    "median": np.array(
        [
            0.0,
            -165.0,
            -211.0,
            -128.0,
            167.0,
            205.0,
            118.0,
            96.5,
            82.0,
            66.0,
            56.0,
            50.0,
            94.0,
            77.0,
            62.0,
            51.0,
            99.0,
            82.0,
            63.0,
            53.0,
            99.0,
            77.0,
            59.0,
            50.0,
            92.0,
            72.0,
            60.0,
            53.0,
            -110.0,
            -93.0,
            -74.0,
            -63.0,
            -56.0,
            -104.0,
            -94.0,
            -81.0,
            -71.0,
            -112.0,
            -99.0,
            -83.0,
            -73.0,
            -114.0,
            -101.0,
            -86.0,
            -77.0,
            -112.0,
            -101.0,
            -93.0,
            -86.0,
            0.0,
            2.0,
            227.0,
            257.0,
            -4.0,
            219.0,
            267.0,
            279.0,
            253.0,
            220.0,
            200.0,
            182.0,
            227.0,
            219.0,
            221.0,
            222.0,
            247.0,
            241.0,
            242.0,
            242.0,
            267.0,
            262.0,
            260.0,
            258.0,
            284.0,
            280.0,
            277.0,
            273.0,
            264.0,
            241.0,
            210.0,
            188.0,
            167.0,
            211.0,
            196.0,
            192.0,
            190.0,
            226.0,
            215.0,
            214.0,
            212.0,
            243.0,
            235.0,
            235.0,
            232.0,
            260.0,
            255.0,
            253.0,
            251.0,
        ]
    ),
    "rock": {
        "mean": np.array(
            [
                0.0,
                -50.691,
                -71.908,
                -59.31,
                52.451,
                78.76,
                39.172,
                35.689,
                30.193,
                21.265,
                14.115,
                9.367,
                21.133,
                11.618,
                6.135,
                2.322,
                20.812,
                10.702,
                4.949,
                1.614,
                20.973,
                11.516,
                6.355,
                3.296,
                20.881,
                12.962,
                9.191,
                6.544,
                -56.623,
                -53.151,
                -46.877,
                -42.133,
                -38.616,
                -51.007,
                -45.297,
                -41.204,
                -38.231,
                -51.745,
                -45.244,
                -40.455,
                -37.947,
                -51.901,
                -45.412,
                -40.849,
                -38.384,
                -51.166,
                -45.603,
                -42.475,
                -40.21,
                0.0,
                2.919,
                71.638,
                62.753,
                -2.236,
                68.846,
                61.088,
                62.271,
                55.003,
                47.461,
                44.187,
                41.541,
                47.717,
                45.33,
                44.813,
                44.858,
                53.181,
                51.377,
                51.07,
                50.835,
                58.485,
                57.221,
                56.71,
                56.121,
                63.687,
                62.794,
                62.234,
                61.799,
                62.994,
                56.582,
                49.842,
                46.872,
                44.653,
                49.173,
                46.988,
                47.094,
                47.456,
                54.367,
                52.627,
                52.811,
                52.692,
                59.522,
                58.338,
                58.022,
                57.695,
                64.378,
                63.897,
                63.478,
                62.855,
            ]
        ),
        "median": np.array(
            [
                0.0,
                -53.0,
                -74.0,
                -61.0,
                54.0,
                82.0,
                39.0,
                36.0,
                29.0,
                18.0,
                9.0,
                3.0,
                19.0,
                9.0,
                3.0,
                -1.0,
                19.0,
                8.0,
                2.0,
                -2.0,
                19.0,
                9.0,
                3.0,
                0.0,
                19.0,
                10.0,
                6.0,
                3.0,
                -60.0,
                -54.0,
                -47.0,
                -41.0,
                -36.0,
                -52.0,
                -45.0,
                -39.5,
                -36.0,
                -53.0,
                -45.0,
                -39.0,
                -35.0,
                -54.0,
                -44.0,
                -39.0,
                -36.0,
                -52.0,
                -45.0,
                -41.0,
                -38.0,
                0.0,
                3.0,
                75.0,
                67.0,
                -2.0,
                71.0,
                63.0,
                65.0,
                57.0,
                49.0,
                46.0,
                44.0,
                50.0,
                49.0,
                50.0,
                50.0,
                57.0,
                56.0,
                57.0,
                57.0,
                63.0,
                63.0,
                63.0,
                62.0,
                69.0,
                69.0,
                68.0,
                68.0,
                67.0,
                60.0,
                52.0,
                49.0,
                47.0,
                52.0,
                50.0,
                51.0,
                52.0,
                58.0,
                57.0,
                58.0,
                58.0,
                64.0,
                64.0,
                64.0,
                64.0,
                70.0,
                70.0,
                69.0,
                69.0,
            ]
        ),
        "scale_factor": 3.0404103081189042,
        "std": np.array(
            [
                0.0,
                10.4203416,
                17.22636166,
                24.77684201,
                11.10331478,
                17.75664383,
                18.53861958,
                20.16805095,
                20.55582037,
                23.09192012,
                25.92936125,
                28.61632945,
                23.87838585,
                26.28121146,
                27.0651949,
                28.08466336,
                23.62597418,
                25.974626,
                26.90238649,
                28.14425348,
                22.98891626,
                25.03772641,
                26.18272283,
                27.28751333,
                22.26856167,
                23.93914276,
                24.86223077,
                25.93993184,
                29.16729112,
                28.9929681,
                30.65772123,
                32.47656557,
                34.01532807,
                33.28412461,
                35.77885955,
                36.57866023,
                37.38547364,
                33.74483627,
                36.30537789,
                36.96885142,
                37.77928256,
                34.01107465,
                36.46546662,
                37.06834497,
                37.90272476,
                34.39137165,
                36.44109481,
                36.96086275,
                37.45362332,
                0.0,
                2.89973085,
                18.24277819,
                20.42860717,
                2.76048981,
                13.92466459,
                17.1719031,
                19.71708799,
                19.53716947,
                21.61500588,
                24.15897413,
                26.41163227,
                24.7449977,
                27.6888985,
                29.30245776,
                30.29448524,
                25.62081652,
                28.73668163,
                30.19561392,
                31.28564807,
                25.91670841,
                28.75941861,
                30.06825402,
                31.11173989,
                26.03480422,
                28.16124223,
                29.02597533,
                29.7304322,
                23.28072087,
                22.67441898,
                24.5621464,
                26.42123419,
                28.12181699,
                26.97838155,
                29.05460129,
                30.11018373,
                30.98118887,
                27.92701758,
                30.10780415,
                30.95133727,
                31.63882324,
                28.46049044,
                30.59816589,
                30.90853468,
                31.19961498,
                28.92246732,
                30.4676614,
                30.74221066,
                30.69778453,
            ]
        ),
    },
    "seth": {
        "mean": np.array(
            [
                0.00000e00,
                -1.56603e02,
                -1.92734e02,
                -1.32233e02,
                1.60156e02,
                1.93264e02,
                7.84210e01,
                6.13590e01,
                3.63920e01,
                1.03240e01,
                3.24000e00,
                5.41000e-01,
                2.59350e01,
                7.05000e00,
                -5.32800e00,
                -1.25190e01,
                3.17200e01,
                8.77700e00,
                -6.74700e00,
                -1.21180e01,
                3.12780e01,
                1.12180e01,
                -3.30400e00,
                -8.38000e00,
                2.93330e01,
                1.41880e01,
                3.79600e00,
                -4.10200e00,
                -1.22910e02,
                -1.04130e02,
                -8.88500e01,
                -7.73330e01,
                -6.66150e01,
                -1.06764e02,
                -9.15200e01,
                -7.91270e01,
                -7.09780e01,
                -1.12913e02,
                -9.24190e01,
                -7.87410e01,
                -7.28720e01,
                -1.11232e02,
                -9.46040e01,
                -8.03730e01,
                -7.46850e01,
                -1.05766e02,
                -9.38100e01,
                -8.45570e01,
                -7.68080e01,
                0.00000e00,
                -1.52000e-01,
                2.18895e02,
                2.68892e02,
                3.11000e-01,
                2.37138e02,
                2.60438e02,
                2.62680e02,
                2.46628e02,
                2.28206e02,
                2.22251e02,
                2.19554e02,
                2.28401e02,
                2.20632e02,
                2.23361e02,
                2.28428e02,
                2.42971e02,
                2.34319e02,
                2.39472e02,
                2.41920e02,
                2.55531e02,
                2.52430e02,
                2.51910e02,
                2.51151e02,
                2.67728e02,
                2.67377e02,
                2.66409e02,
                2.64099e02,
                2.76742e02,
                2.61222e02,
                2.46399e02,
                2.44755e02,
                2.41459e02,
                2.54082e02,
                2.51658e02,
                2.56695e02,
                2.62400e02,
                2.68415e02,
                2.68020e02,
                2.72175e02,
                2.74369e02,
                2.80791e02,
                2.83345e02,
                2.84913e02,
                2.83823e02,
                2.92152e02,
                2.94754e02,
                2.95650e02,
                2.94466e02,
            ]
        ),
        "median": np.array(
            [
                0.0,
                -160.0,
                -188.0,
                -90.0,
                164.0,
                188.0,
                74.0,
                61.0,
                30.0,
                -5.0,
                -13.0,
                -15.0,
                14.0,
                -17.0,
                -37.0,
                -47.0,
                22.0,
                -15.0,
                -39.0,
                -48.0,
                21.0,
                -12.0,
                -35.0,
                -45.0,
                15.0,
                -9.0,
                -26.0,
                -40.0,
                -82.0,
                -55.0,
                -35.0,
                -19.0,
                -1.0,
                -50.0,
                -19.0,
                3.0,
                17.0,
                -54.0,
                -12.5,
                12.0,
                23.0,
                -50.0,
                -14.0,
                12.0,
                23.0,
                -38.0,
                -14.0,
                6.0,
                20.0,
                0.0,
                0.0,
                231.0,
                280.5,
                0.0,
                243.5,
                284.0,
                288.0,
                270.0,
                243.0,
                237.0,
                237.0,
                250.0,
                236.0,
                243.0,
                253.0,
                271.0,
                260.0,
                269.0,
                273.0,
                286.0,
                285.0,
                286.0,
                285.0,
                303.0,
                306.0,
                305.0,
                302.0,
                287.0,
                268.0,
                244.0,
                241.0,
                234.0,
                260.0,
                251.0,
                258.0,
                266.0,
                279.0,
                277.0,
                283.0,
                284.0,
                295.0,
                299.0,
                301.0,
                297.0,
                309.0,
                314.0,
                314.0,
                312.0,
            ]
        ),
        "scale_factor": 0.9900081765632547,
        "std": np.array(
            [
                0.0,
                18.55767741,
                35.88235282,
                101.25383307,
                19.41946611,
                38.02917701,
                54.45006666,
                61.64462766,
                64.83266411,
                72.31580065,
                77.08544869,
                83.25050342,
                74.10669858,
                79.17970384,
                85.60273603,
                88.84267915,
                71.75098327,
                79.86841222,
                86.6311664,
                90.07606828,
                73.40176235,
                79.49821681,
                84.53137633,
                89.01422134,
                72.98420453,
                77.71971858,
                83.04868683,
                87.2696946,
                111.3822423,
                118.55779645,
                126.86364925,
                137.85477181,
                149.29311027,
                136.38734657,
                153.90880287,
                164.70497525,
                173.08522616,
                139.26315173,
                160.31123304,
                173.69513499,
                183.07759452,
                143.54942764,
                162.06102303,
                175.3751404,
                183.9359502,
                148.61482175,
                163.27092178,
                173.38245803,
                181.60665499,
                0.0,
                9.34959336,
                37.72078969,
                49.82852934,
                9.37562153,
                35.3828342,
                61.75611837,
                69.91869278,
                69.9318641,
                72.31696595,
                75.38982689,
                78.29895966,
                76.43157855,
                80.22123519,
                83.73378457,
                87.34744882,
                76.80201924,
                79.60171631,
                84.10195727,
                87.62829223,
                78.27895655,
                82.02017496,
                84.37008889,
                86.20353936,
                80.41539664,
                84.47919786,
                85.72448728,
                86.26808911,
                54.1489006,
                55.01033281,
                59.79178705,
                62.95996327,
                68.53929033,
                60.30863351,
                64.76271332,
                66.97766773,
                69.2184224,
                60.48514508,
                63.85550564,
                65.756052,
                68.09354477,
                61.19543544,
                64.2909634,
                65.19778701,
                67.21045805,
                62.52371467,
                65.29180258,
                66.37902907,
                65.94090418,
            ]
        ),
    },
    "shelly": {
        "median": np.array(
            [
                0.0,
                -44.0,
                -60.0,
                -53.0,
                44.0,
                65.0,
                40.0,
                34.0,
                33.0,
                32.0,
                32.0,
                32.0,
                31.0,
                28.0,
                26.0,
                25.0,
                31.0,
                28.0,
                26.0,
                25.0,
                31.0,
                28.0,
                26.0,
                25.0,
                30.0,
                28.0,
                27.0,
                26.0,
                -49.0,
                -49.0,
                -52.0,
                -55.0,
                -56.0,
                -55.0,
                -57.0,
                -57.0,
                -58.0,
                -56.0,
                -57.0,
                -57.0,
                -57.0,
                -56.0,
                -56.0,
                -57.0,
                -56.0,
                -55.0,
                -56.0,
                -56.0,
                -56.0,
                0.0,
                0.0,
                70.0,
                99.0,
                0.0,
                69.0,
                84.0,
                86.0,
                84.0,
                81.0,
                79.0,
                77.0,
                85.0,
                85.0,
                84.0,
                83.0,
                88.0,
                88.0,
                87.0,
                86.0,
                91.0,
                91.0,
                90.0,
                89.0,
                92.0,
                92.0,
                91.0,
                91.0,
                104.0,
                102.0,
                100.0,
                99.0,
                99.0,
                107.0,
                109.0,
                110.0,
                111.0,
                111.0,
                114.0,
                115.0,
                115.0,
                115.0,
                118.0,
                119.0,
                119.0,
                117.0,
                120.0,
                121.0,
                121.0,
            ]
        ),
        "mean": np.array(
            [
                0.00000e00,
                -4.39670e01,
                -6.16120e01,
                -5.66750e01,
                4.38510e01,
                6.52460e01,
                4.23140e01,
                3.73650e01,
                3.57040e01,
                3.45580e01,
                3.44570e01,
                3.45120e01,
                3.52910e01,
                3.31350e01,
                3.19850e01,
                3.09850e01,
                3.51300e01,
                3.28280e01,
                3.14670e01,
                3.08340e01,
                3.51450e01,
                3.27940e01,
                3.16110e01,
                3.05940e01,
                3.47090e01,
                3.29040e01,
                3.22040e01,
                3.11530e01,
                -5.37470e01,
                -5.32070e01,
                -5.42620e01,
                -5.62220e01,
                -5.78420e01,
                -5.81480e01,
                -5.93390e01,
                -5.98870e01,
                -6.00440e01,
                -5.89260e01,
                -5.98730e01,
                -5.95250e01,
                -5.97740e01,
                -5.86410e01,
                -5.93170e01,
                -5.91710e01,
                -5.94890e01,
                -5.80360e01,
                -5.85560e01,
                -5.88470e01,
                -5.87110e01,
                0.00000e00,
                -9.70000e-02,
                6.69060e01,
                9.19000e01,
                -4.16000e-01,
                6.65610e01,
                8.19670e01,
                8.38610e01,
                8.18550e01,
                7.90090e01,
                7.72360e01,
                7.61760e01,
                8.11380e01,
                8.04890e01,
                7.99180e01,
                7.96400e01,
                8.42210e01,
                8.41600e01,
                8.36870e01,
                8.31360e01,
                8.67250e01,
                8.67590e01,
                8.62470e01,
                8.56190e01,
                8.85240e01,
                8.86890e01,
                8.82870e01,
                8.75840e01,
                9.63500e01,
                9.51850e01,
                9.30020e01,
                9.14720e01,
                9.06760e01,
                9.54290e01,
                9.63560e01,
                9.65460e01,
                9.66780e01,
                9.88890e01,
                9.99080e01,
                1.00404e02,
                1.00404e02,
                1.01832e02,
                1.02755e02,
                1.03448e02,
                1.03503e02,
                1.04009e02,
                1.05167e02,
                1.05725e02,
                1.06154e02,
            ]
        ),
        "scale_factor": 3.570953563050855,
        "std": np.array(
            [
                0.0,
                5.97075464,
                18.08920827,
                33.06550128,
                6.05266875,
                18.51673524,
                32.79398427,
                37.3746408,
                38.17355608,
                41.0028857,
                43.89186885,
                46.5736176,
                42.3892005,
                46.75329694,
                48.91665131,
                50.78065355,
                42.70645267,
                46.58178202,
                48.63481172,
                50.08577087,
                42.50759903,
                45.92044821,
                47.71441794,
                49.30368307,
                42.41971616,
                45.19445524,
                46.42829293,
                47.59075111,
                38.04543325,
                38.97140171,
                40.60807008,
                42.62166956,
                45.15082542,
                42.1350934,
                44.92540572,
                47.14573396,
                49.22062641,
                42.10518405,
                45.64207347,
                47.96439695,
                49.88419513,
                42.26076335,
                45.48921313,
                47.56071655,
                49.44677825,
                42.74354576,
                45.27401975,
                46.8043544,
                48.27524706,
                0.0,
                4.71376612,
                19.68423643,
                46.76840814,
                4.8071763,
                17.32877027,
                37.98475893,
                44.62642355,
                44.27660754,
                46.27339321,
                49.00555381,
                51.54084811,
                48.50106139,
                51.8787999,
                54.01876781,
                55.82720126,
                49.17186349,
                53.1482869,
                55.37935564,
                56.9398411,
                49.60537647,
                53.15278844,
                55.01163505,
                56.67173757,
                49.79045515,
                52.37627592,
                53.64364483,
                54.5685527,
                53.91743225,
                54.13352727,
                55.90663642,
                58.86213737,
                61.06556332,
                58.86913418,
                62.15002224,
                64.03989291,
                65.85472129,
                59.38530693,
                62.81211297,
                64.88760116,
                66.08761445,
                59.60905784,
                62.46751936,
                64.10454973,
                65.54253574,
                59.33884831,
                61.90099443,
                63.20263741,
                64.26842369,
            ]
        ),
    },
}