postprocess/post.py

'''

graph of C-mesh
===
    _____________________   
    / *  *__*_*_|_________|
    | * /                 |
    | * |   ^       i1    |
    | * |   | <======-----|
    | * |   |____   i0    | <- j=0
    | * \_________________|
    \_*___*__*_|__________| <- j=NJ

    * the area used to calculate average velocity field


'''



import numpy as np
import torch

from typing import List, NewType, Tuple, Dict, Union
Tensor = NewType('Tensor', torch.Tensor)

WORKCOD = {'Tinf':460.0,'Minf':0.76,'Re':5e6,'AoA':0.0,'gamma':1.4, 'x_mc':0.25, 'y_mc':0.0}

# the base rotation matrix:
#  / (1, 0)  (0, 1) \
#  \ (0,-1)  (1, 0) /
# if one want to rotate the vector (x_o, y_o) in origin coordinate (o) to the target coordinate (t), 
# the rotate matrix should be the base matrix dot the origin x unit-vector in the target coordinate.
# for example: transfer force (f_x, f_y) to lift and drag
#   - the target coor.(along the freestream) can be obtained by rotate the origin coor.(along the chord)
#     a angle of AoA c.c.w.
#   - the x unit-vector in target coor. is /  cos(AoA) \
#                                          \ -sin(AoA) /
#
#   - thus, ( Drag, Lift ) = ( f_x, f_y ) .  / (1, 0)  (0, 1) \  .  /  cos(AoA) \
#                                            \ (0,-1)  (1, 0) /     \ -sin(AoA) /

#* here collect the Tensor version
#  original numpy version can be found in cfdpost.utils

_rot_metrix = torch.Tensor([[[1.0,0], [0,1.0]], [[0,-1.0], [1.0,0]]])

#* function to rotate x-y to aoa

def _aoa_rot_t(aoa: Tensor) -> Tensor:
    '''
    aoa is in size (B, )
    
    '''
    aoa = aoa * np.pi / 180
    return torch.cat((torch.cos(aoa).unsqueeze(1), -torch.sin(aoa).unsqueeze(1)), dim=1)#.squeeze(-1)

def _xy_2_cl_t(dfp: Tensor, aoa: float) -> Tensor:
    '''
    transfer fx, fy to CD, CL

    param:
    dfp:    (Fx, Fy), Tensor with size (2,)
    aoa:    angle of attack, float

    return:
    ===
    Tensor: (CD, CL)
    '''
    aoa = torch.FloatTensor([aoa])
    # print(dfp.size(), _rot_metrix.size(), _aoa_rot_t(aoa).size())
    return torch.einsum('p,prs,s->r', dfp, _rot_metrix.to(dfp.device), _aoa_rot_t(aoa).squeeze().to(dfp.device))

def _xy_2_cl_tc(dfp: Tensor, aoa: Tensor) -> Tensor:
    '''
    batch version of _xy_2_cl
    
    transfer fx, fy to CD, CL

    param:
    dfp:    (Fx, Fy), Tensor with size (B, 2,)
    aoa:    angle of attack, Tensor with size (B, )

    return:
    ===
    Tensor: (CD, CL),  with size (B, 2)
    '''
    # print(dfp.shape, _rot_metrix.shape, aoa.shape, _aoa_rot_t(aoa).shape)
    return torch.einsum('bp,prs,bs->br', dfp,  _rot_metrix.to(dfp.device), _aoa_rot_t(aoa).to(dfp.device))

#* function to extract information from 2-D flowfield
def get_aoa(vel):
    '''
    This function is to extract the angle of attack(AoA) from the far-field velocity field

    param:
    ===
    `vel`:   the velocity field, shape: (2 x H x W), the two channels should be U and V (x and y direction velocity)
        only the field at the front and farfield is used to averaged (see comments of post.py)

    return:
    ===
    (torch.Tensor): the angle of attack

    '''

    # inlet_avg = torch.mean(vel[:, 3: -3, -5:-2], dim=(1, 2))
    inlet_avg = torch.mean(vel[:, 100: -100, -5:-2], dim=(1, 2))
    # inlet_avg = torch.mean(vel[:, 3: -3, -1], dim=1)

    return torch.atan(inlet_avg[1] / inlet_avg[0]) / 3.14 * 180

def get_p_line(X, P, i0=15, i1=316):
    '''
    This function is to extract p values at the airfoil surface from the P field

    The surface p value is obtained by averaging the four corner values on each first layer grid

    param:
    ===
    `X`:    The X field, shape: (H x W)

    `P`:    The P field, shape: (H x W)

    `i0` and `i1`:  The position of the start and end grid number of the airfoil surface

    return:
    ===
    Tuple(torch.Tensor, list):  X, P (shape of each: (i1-i0, ))
    '''
    p_cen = []
    for j in range(i0, i1):
        p_cen.append(-0.25 * (P[j, 0] + P[j, 1] + P[j+1, 0] + P[j+1, 1]))
    return X[i0: i1, 0], p_cen

def get_vector(X: Tensor, Y: Tensor, i0: int, i1: int):
    '''
    get the geometry variables on the airfoil surface
    
    remark:
    ===
    ** `should only run once at the begining, since is very slow` **

    param:
    ===
    `X`:    The X field, shape: (H x W)

    `Y`:    The Y field, shape: (H x W)

    `i0` and `i1`:  The position of the start and end grid number of the airfoil surface

    return:
    ===
    Tuple(torch.Tensor):  `_vec_sl`, `_veclen`, `_area`

    `_vec_sl`:  shape : (i1-i0-1, 2), the surface section vector (x2-x1, y2-y1)

    `_veclen`:  shape : (i1-i0-1, ), the length of the surface section vector

    `area`:     shape : (i1-i0-1, ), the area of the first layer grid (used to calculate tau)
    '''
    _vec_sl = torch.zeros((i1-i0-1, 2,))
    _veclen = torch.zeros(i1-i0-1) 
    _area   = torch.zeros(i1-i0-1) 
    # _sl_cen = np.zeros((i1-i0-1, 2)) 

    for idx, j in enumerate(range(i0, i1-1)):
            
        point1 = torch.Tensor([X[j, 0], Y[j, 0], 0])        # coordinate of surface point j
        point2 = torch.Tensor([X[j, 1], Y[j, 1], 0]) 
        point3 = torch.Tensor([X[j + 1, 0], Y[j + 1, 0], 0])
        point4 = torch.Tensor([X[j + 1, 1], Y[j + 1, 1], 0])
                    
        vec_sl = point3 - point1                    # surface vector sl
        _veclen[idx] = torch.sqrt((vec_sl * vec_sl).sum())   # length of surface vector sl
        _vec_sl[idx] = (vec_sl / _veclen[idx])[:2]
        ddiag = torch.cross(point4 - point1, point3 - point2)
        _area[idx] = 0.5 * torch.sqrt((ddiag * ddiag).sum())
        
        # _sl_cen[idx] = 0.5 * (point1 + point3)
    
    return _vec_sl, _veclen, _area

def get_force_xy(vec_sl: Tensor, veclen: Tensor, area: Tensor,
                  vel: Tensor, T: Tensor, P: Tensor, 
                  i0: int, i1: int, paras: Dict, ptype: str = 'Cp'):
    '''
    integrate the force on x and y direction

    param:
    `_vec_sl`, `_veclen`, `_area`: obtained by _get_vector
    
    `vel`:   the velocity field, shape: (2 x H x W), the two channels should be U and V (x and y direction velocity)

    `T`:    The temperature field, shape: (H x W)
    
    `P`:    The pressure field, shape: (H x W); should be non_dimensional pressure field by CFL3D

    `i0` and `i1`:  The position of the start and end grid number of the airfoil surface

    `paras`:    the work condtion to non-dimensionalize; should include the key of (`gamma`, `Minf`, `Tinf`, `Re`)

    return:
    ===
    Tensor: (Fx, Fy)
    '''

    p_cen = 0.25 * (P[i0:i1-1, 0] + P[i0:i1-1, 1] + P[i0+1:i1, 0] + P[i0+1:i1, 1])
    t_cen = 0.25 * (T[i0:i1-1, 0] + T[i0:i1-1, 1] + T[i0+1:i1, 0] + T[i0+1:i1, 1])
    uv_cen = 0.5 * (vel[:, i0:i1-1, 1] + vel[:, i0+1:i1, 1])

    # if ptype == 'P':
    #     dfp_n = 1.43 / (paras['gamma'] * paras['Minf']**2) * (paras['gamma'] * p_cen - 1) * veclen
    # else:
    #     dfp_n = p_cen * veclen
    dfp_n = 1.43 / (paras['gamma'] * paras['Minf']**2) * (paras['gamma'] * p_cen - 1) * veclen
    mu = t_cen**1.5 * (1 + 198.6 / paras['Tinf']) / (t_cen + 198.6 / paras['Tinf'])
    dfv_t = 0.063 / (paras['Minf'] * paras['Re']) * mu * torch.einsum('kj,jk->j', uv_cen, vec_sl) * veclen**2 / area

    # cx, cy
    dfp = torch.einsum('lj,lpk,jk->p', torch.cat((dfv_t.unsqueeze(0), -dfp_n.unsqueeze(0)),dim=0), _rot_metrix.to(dfv_t.device), vec_sl)

    return dfp

def get_force_cl(aoa: float, **kwargs):
    '''
    get the lift and drag

    param:
    `aoa`:  angle of attack

    `_vec_sl`, `_veclen`, `_area`: obtained by _get_vector
    
    `vel`:   the velocity field, shape: (2 x H x W), the two channels should be U and V (x and y direction velocity)

    `T`:    The temperature field, shape: (H x W)
    
    `P`:    The pressure field, shape: (H x W); should be non_dimensional pressure field by CFL3D

    `i0` and `i1`:  The position of the start and end grid number of the airfoil surface

    `paras`:    the work condtion to non-dimensionalize; should include the key of (`gamma`, `Minf`, `Tinf`, `Re`)

    return:
    ===
    Tensor: (CD, CL)
    '''
    dfp = get_force_xy(**kwargs)
    fld = _xy_2_cl(dfp, aoa)
    return fld

#* function to extract pressure force from 1-d pressure profile
# numpy.ndarray version in `cfdpost.utils`
def get_dxyforce_1d_t(geom: Tensor, cp: Tensor, cf: Tensor=None) -> Tensor:
    '''
    integrate the force on each surface grid cell, batch data
    
    paras:
    ---
    - `geom`  Tensor  (B, N, 2) -> (x, y)
    - `cp`    Tensor  (B, N)
    - `cf`    Tensor  (B, N), default is `None`

    ### retrun
    Tensor (B, N-1, 2) -> (dFx, dFy)
    
    '''
    
    dfp_n  = (0.5 * (cp[:, 1:] + cp[:, :-1])).unsqueeze(1)
    if cf is None:
        dfv_t  = torch.zeros_like(dfp_n)
    else:
        dfv_t = (0.5 * (cf[:, 1:] + cf[:, :-1])).unsqueeze(1)

    dr     = (geom[:, 1:] - geom[:, :-1])
    # print(torch.cat((dfv_t, -dfp_n), dim=1).shape, dr.shape)
    return torch.einsum('blj,lpk,bjk->bjp', torch.cat((dfv_t, -dfp_n), dim=1), _rot_metrix.to(dfv_t.device), dr)

def get_xyforce_1d_t(geom: Tensor, cp: Tensor, cf: Tensor=None) -> Tensor:
    '''
    integrate the force on x and y direction

    param:
    ===
    - `geom`  Tensor  (B, N, 2) -> (x, y)
    - `cp`    Tensor  (B, N)
        The pressure profile; should be non_dimensional pressure profile by freestream condtion
        
        `Cp = (p - p_inf) / 0.5 * rho * U^2`
        
    - `cf`    Tensor  (B, N), default is `None`
        The friction profile; should be non_dimensional pressure profile by freestream condtion
        
        `Cf = tau / 0.5 * rho * U^2`

    return:
    ===
    Tensor: (B, 2) -> (Fx, Fy)
    '''

    dr_tail = geom[:, 0] - geom[:, -1]
    dfp_n_tail = 0.5 * (cp[:, 0] + cp[:, -1]).unsqueeze(1)
    dfv_t_tail = torch.zeros_like(dfp_n_tail)
    
    force_surface = torch.sum(get_dxyforce_1d_t(geom, cp, cf), dim=1)
    force_tail = torch.einsum('bl,lpk,bk->bp', torch.cat((dfv_t_tail, -dfp_n_tail), dim=1), _rot_metrix.to(dfp_n_tail.device), dr_tail)
    
    return force_surface + force_tail

def get_force_1d_t(geom: Tensor, aoa: Tensor, cp: Tensor, cf: Tensor=None) -> Tensor:
    '''
    batch version of integrate the lift and drag

    param:
    ===
    - `geom`  Tensor  (B, N, 2) -> (x, y)
    - `cp`    Tensor  (B, N)
        The pressure profile; should be non_dimensional pressure profile by freestream condtion
        
        `Cp = (p - p_inf) / 0.5 * rho * U^2`
        
    - `cf`    Tensor  (B, N), default is `None`
        The friction profile; should be non_dimensional pressure profile by freestream condtion
        
        `Cf = tau / 0.5 * rho * U^2`
        
    - `aoa`   Tensor (B,), in angle degree

    return:
    ===
    Tensor: (B, 2) -> (CD, CL)
    '''
    
    dfp = get_xyforce_1d_t(geom, cp, cf)
    return _xy_2_cl_tc(dfp, aoa)

def get_flux_1d_t(geom: Tensor, pressure: Tensor, xvel: Tensor, yvel: Tensor, rho: Tensor) -> Tensor:
    '''
    obtain the mass and momentum flux through a line

    param:
    ===
    `geom`:    The geometry (x, y), shape: (2, N)
    
    `pressure`: The pressure on every line points, shape: (N, ); should be dimensional pressure profile
    
    `xvel`: x-direction velocity on every line points, shape: (N, )

    `yvel`: y-direction velocity on every line points, shape: (N, )

    `rho`: density on every line points, shape: (N, )

    return:
    ===
    Tensor: (mass_flux, moment_flux)
    '''
    
    dx      = (geom[0, 1:] - geom[0, :-1])
    dy      = (geom[1, 1:] - geom[1, :-1])
    pressure = 0.5 * (pressure[1:] + pressure[:-1])
    xvel    = 0.5 * (xvel[1:] + xvel[:-1])
    yvel    = 0.5 * (yvel[1:] + yvel[:-1])
    rho     = 0.5 * (rho[1:] + rho[:-1])

    phixx = rho * xvel**2 + pressure
    phixy = rho * xvel * yvel
    phiyy = rho * yvel**2 + pressure

    mass_flux   = torch.sum(rho * xvel * dy - rho * yvel * dx)
    moment_flux = torch.zeros((2,))
    moment_flux[0] = torch.sum(phixx * dy - phixy * dx)
    moment_flux[1] = torch.sum(phixy * dy - phiyy * dx)

    return mass_flux, moment_flux

#* functions to get force from 2-D surfaces

def get_cellinfo_2d_t(geom: Tensor) -> Tuple[Tensor]:
    
    '''
    get the normal vector and area of each surface grid cell
    :param geom: The geometry (x, y, z)
    :type geom: torch.Tensor (..., I, J, 3)
    :return: normals and areas
    :rtype: Tuple(torch.Tensor, torch.Tensor), shape (..., I-1, J-1, 3), (..., I-1, J-1)
    '''
    
    # get corner points（p0, p1, p2, p3）
    p0 = geom[..., :-1, :-1, :] # SW
    p1 = geom[..., :-1, 1:, :]  # SE
    p2 = geom[..., 1:, 1:, :]   # NW
    p3 = geom[..., 1:, :-1, :]  # NE

    # calculate two groups of normal vector and average
    normals = torch.cross(p2 - p0, p3 - p1, dim=-1)
    areas   = 0.5 * (torch.linalg.norm(torch.cross(p1 - p0, p2 - p0, dim=-1), dim=-1) + torch.linalg.norm(torch.cross(p2 - p0, p3 - p0, dim=-1), dim=-1))

    # normalization
    normals = normals / (torch.linalg.norm(normals, dim=-1, keepdim=True) + 1e-20)
    # print(np.sum(normals * areas[..., np.newaxis], axis=(0,1)))
    return normals, areas    

def get_dxyforce_2d_t(geom: Union[Tensor, List[Tensor]], cp: Tensor, cf: Tensor=None) -> Tensor:
    '''
    integrate forces from 2D surface data on every surface grid cell
    
    :param geom: The geometry (x, y, z)
    :type geom: torch.Tensor (..., I, J, 3)
    :param cp: pressure coefficients Cp = (p - p_inf) / 0.5 * rho * U_\infty^2
    :type cp: torch.Tensor (..., I-1, J-1)
    :param cf: friction coefficients Cf = (tau @ n) / 0.5 * rho * U_\infty^2
    :type cf: torch.Tensor (..., I-1, J-1, 3)
        
    :return: coefficients of forces in x, y, z directions
    :rtype: torch.Tensor, (dCx, dCy, dCz), shape (..., I-1, J-1, 3)
    
    '''
    # calculate normal vector
    if isinstance(geom, list):
        n, a = geom
    else:
        n, a = get_cellinfo_2d_t(geom)
    dfp = cp[..., None] * n * a[..., None]
    
    if not (cf is None or len(cf) == 0):
        shear = (cf - torch.sum(cf * n, dim=-1, keepdim=True) * n) * a[..., None]
        dfp = dfp + shear
    
    return dfp

def get_xyforce_2d_t(geom: Union[Tensor, List[Tensor]], cp: Tensor, cf: Tensor=None) -> Tensor:
    '''
    integrate forces from 2D surface data
    
    :param geom: The geometry (x, y, z)
    :type geom: torch.Tensor (..., I, J, 3)
    :param cp: pressure coefficients Cp = (p - p_inf) / 0.5 * rho * U_\infty^2
    :type cp: torch.Tensor (..., I-1, J-1)
    :param cf: friction coefficients Cf = (tau @ n) / 0.5 * rho * U_\infty^2
    :type cf: torch.Tensor (..., I-1, J-1, 3)
        
    :return: coefficients of forces in x, y, z directions
    :rtype: torch.Tensor (CX, CY, CZ)
    '''
    return torch.sum(get_dxyforce_2d_t(geom, cp, cf), dim=(-3,-2))

def get_force_2d_t(geom: Union[Tensor, List[Tensor]], aoa: Tensor, cp: Tensor, cf: Tensor=None) -> Tensor:
    '''
    integrate lift and drag from 2D surface data
    
    :param geom: The geometry (x, y, z)
    :type geom: torch.Tensor (..., I, J, 3)
    :param aoa: angle of attack in Degree
    :type aoa: torch.Tensor (..., )
    :param cp: pressure coefficients Cp = (p - p_inf) / 0.5 * rho * U_\infty^2
    :type cp: torch.Tensor (..., I-1, J-1)
    :param cf: friction coefficients Cf = (tau @ n) / 0.5 * rho * U_\infty^2
    :type cf: torch.Tensor (..., I-1, J-1, 3)
        
    :return: coefficients of drag, lift, and side force
    :rtype: torch.Tensor (CD, CL, CZ)
    '''
    dfp = get_xyforce_2d_t(geom, cp, cf)
    dfp_xy = _xy_2_cl_tc(dfp[..., :2], aoa)
    dfp = torch.concatenate((dfp_xy, dfp[..., 2:]), axis=-1)
    return dfp

def get_moment_2d_t(geom: torch.Tensor, cp: torch.Tensor, cf: torch.Tensor=None, ref_point: torch.Tensor=np.array([0.25, 0, 0])) -> torch.Tensor:
    '''
    :param geom: The geometry (x, y, z)
    :type geom: torch.Tensor (..., I, J, 3)
    :param cp: pressure coefficients Cp = (p - p_inf) / 0.5 * rho * U_\infty^2
    :type cp: torch.Tensor (..., I-1, J-1)
    :param cf: friction coefficients Cf = (tau @ n) / 0.5 * rho * U_\infty^2
    :type cf: torch.Tensor (..., I-1, J-1, 3)
    :param ref_point: ref point for moment calculation
    :type ref_point: torch.Tensor (..., 3)
        
    :return: moment around z-axis
    :rtype: torch.Tensor (CMx, CMy, CMz)
    '''
    
    dxyforce = get_dxyforce_2d_t(geom, cp, cf)
    r = 0.25 * (geom[..., :-1, :-1, :] + geom[..., :-1, 1:, :] + geom[..., 1:, 1:, :] + geom[..., 1:, :-1, :]) - ref_point.to(geom.device)
    
    return torch.sum(torch.cross(r, dxyforce, dim=-1), dim=(-3, -2))

def get_cellinfo_1d_t(geom: torch.Tensor) -> Tuple[torch.Tensor]:
    '''
    :param geom: The geometry (x, y)
    :type geom: torch.Tensor (..., I, 2)

    :return: tangens, normals
    :rtype: Tuple[torch.Tensor] (..., I-1, 2), (..., I-1, 2)
    '''
    
    # grid centric
    tangens = geom[..., 1:, :] - geom[..., :-1, :]
    tangens = tangens / (torch.linalg.norm(tangens, dim=-1, keepdim=True) + 1e-20)
    normals = torch.concatenate((-tangens[..., [1]], tangens[..., [0]]), axis=-1)
    
    return tangens, normals

#* functions for wings

def rotate_input(inp: torch.Tensor, cnd: torch.Tensor, root_twist: float = 6.7166) -> Tuple[torch.Tensor]:
    '''
    rotate the input and condition to remove the baseline twist effect
    
    :param inp: geometric mesh input
    :type inp: torch.Tensor (B, C, H, W)
    :param cnd: operating condition (AoA, Mach)
    :type cnd: torch.Tensor (B, 2)
    :param root_twist: The root twist value to be removed
    :type root_twist: float
    :return: inp, cnd
    :rtype: Tuple[Tensor]
    '''

    B, C, H, W = inp.shape
    
    # rotate to without baseline twist ( w.r.t centerline LE (0,0,0))
    inp = torch.cat([
        _xy_2_cl_tc(inp[:, :2].permute(0, 2, 3, 1).reshape(-1, 2), -root_twist * torch.ones((B*H*W,))).reshape(B, H, W, 2).permute(0, 3, 1, 2),
        inp[:, 2:]
    ], dim = 1) 
    
    cnd = torch.cat([
        cnd[:, :1] + root_twist,
        cnd[:, 1:]
    ], dim = 1)

    return inp, cnd

def intergal_output(geom: torch.Tensor, outputs: torch.Tensor, aoa: torch.Tensor,
                    s: float, c: float, xref: float, yref: float) -> torch.Tensor:
    '''
    torch version intergal_output from cell-centric outputs to forces/moments
    
    :param geom: geometric
    :type geom: torch.Tensor (B, 3, I, J)
    :param outputs: pressure and friction coefficients (cp, cf_tau, cf_z)
    :type outputs: torch.Tensor (B, 3, I-1, J-1)
    :param aoa: angle of attacks
    :type aoa: torch.Tensor (B, )
    :param s: reference area
    :type s: float
    :param c: reference chord
    :type c: float
    :param xref: x reference point
    :type xref: float
    :param yref: y reference point
    :type yref: float
    :return: lift, drag, moment_z
    :rtype: torch.Tensor (B, 3)  
    '''

    cp = outputs[:, 0]
    tangens, normals2d = get_cellinfo_1d_t(geom[:, :2].permute(0, 2, 3, 1))                    
    tangens = 0.5 * (tangens[:, 1:] + tangens[:, :-1])    # transfer to cell centre at spanwise direction

    cf = torch.concatenate((outputs[:, [1]].permute(0, 2, 3, 1) * tangens / 150, outputs[:, [2]].permute(0, 2, 3, 1) / 300), axis=-1)
    forces = get_force_2d_t(geom.permute(0, 2, 3, 1), aoa=aoa, cp=cp, cf=cf)[:, [1, 0]] / s
    moment = get_moment_2d_t(geom.permute(0, 2, 3, 1), cp=cp, cf=cf, 
                             ref_point=torch.Tensor([xref, yref, 0.]))[:, [2]] / s / c

    return torch.cat((forces, moment), dim=-1)

def _get_xz_cf_t(geom: torch.Tensor, cf: torch.Tensor):
    '''
    params:
    ===
    `geom`:  The geometry (x, y), shape: (..., Z, I, 3)
    `cf`:  The geometry (cft, cfz), shape: (..., Z, I, 2)

    returns:
    ===
    `cfxyz`: shape: (..., I, J, 3)
    '''

    tangens, normals = get_cellinfo_1d_t(geom[..., [0,1]])
    tangens = 0.5 * (tangens[..., 1:, :, :] + tangens[..., :-1, :, :])    # transfer to cell centre at spanwise direction
    # normals = 0.5 * (normals[1:] + normals[:-1])
    # cfn = np.zeros_like(cf[..., 0])
    # print(cf[..., [0]].shape, tangens.shape)
    cfxyz = torch.concatenate((cf[..., [0]] * tangens, cf[..., [1]]), axis=-1)

    return cfxyz