Пример #1
0
def get_kinetic_and_classicB(path, fprefix, time, xlim=-1):
    '''
       classic_biermann,kinetic_biermann = get_kinetic_and_classicB(path,fprefix,time)
    '''
    dict = cf.load_data_all_1D(path, fpre(path), time)
    ne = dict['ne']
    Te = dict['Te']
    qx = dict['qx']
    qy = dict['qy']
    jx = dict['jx']
    jy = dict['jy']
    dxT = dict['dxT']
    dyT = dict['dyT']
    Bz = dict['Bz']
    x_grid = dict['x_grid']
    y_grid = dict['y_grid']
    Z2ni = dict['Z2ni']
    prof_Z = dict['Z']
    fo = dict['fo']
    nv = dict['nv']
    ny = dict['ny']
    nx = dict['nx']
    rA = (Z2ni)**-1

    dict_fo = cf.load_dict_1D(path, fpre(path), 'fo', time)
    fo = dict_fo['mat']
    time_col = dict_fo['time'] * tstep_factor

    rA = (Z2ni)**-1

    #===============
    grid = dict['grid']
    dxfo, dyfo = cf.get_grad_3d_varZ(grid, fo)

    omega = Bz * rA
    rho_vyx = extend_grid_xy_to_vxy(nv, ny, nx, rA)
    Bz_vyx = extend_grid_xy_to_vxy(nv, ny, nx, Bz)
    omega_vyx = extend_grid_xy_to_vxy(nv, ny, nx, omega)
    Te_vyx = extend_grid_xy_to_vxy(nv, ny, nx, Te)
    ne_vyx = extend_grid_xy_to_vxy(nv, ny, nx, ne)

    #------ NERNST -----------------------------------------------------
    print '\n\n--------- time ==================== ', time

    #v_nx,v_ny = get_v_N(grid,rho_vyx,Bz_vyx,fo)
    print(' bier init= ', np.shape(rho_vyx), np.shape(Bz_vyx),
          np.shape(ne_vyx), np.shape(Te_vyx))

    classic_biermann = get_Biermann_classic(grid, rho_vyx, Bz_vyx, ne_vyx,
                                            Te_vyx)
    kinetic_biermann = get_Biermann(grid, rho_vyx, Bz_vyx, fo)

    classic_biermann = np.transpose(classic_biermann)
    kinetic_biermann = np.transpose(kinetic_biermann)

    return classic_biermann, kinetic_biermann
Пример #2
0
def get_vN_from_path(path, fprefix, time):
    '''
        v_nx,v_ny = get_vN_from_path(path,fprefix,time)
    '''

    dict = cf.load_data_all_1D(path, fpre(path), time)
    ne = dict['ne']
    Te = dict['Te']
    qx = dict['qx']
    qy = dict['qy']
    jx = dict['jx']
    jy = dict['jy']
    dxT = dict['dxT']
    dyT = dict['dyT']
    Bz = dict['Bz']
    x_grid = dict['x_grid']
    y_grid = dict['y_grid']
    Z2ni = dict['Z2ni']
    prof_Z = dict['Z']
    fo = dict['fo']
    nv = dict['nv']
    ny = dict['ny']
    nx = dict['nx']
    rA = (Z2ni)**-1

    dict_fo = cf.load_dict_1D(path, fpre(path), 'fo', time)
    fo = dict_fo['mat']
    grid = fo
    v_grid = dict_fo['v_grid']
    nv, ny, nx = np.shape(fo)

    v_nx = np.zeros((ny, nx))
    v_ny = np.zeros((ny, nx))
    v_nx_hf = np.zeros((ny, nx))
    v_ny_hf = np.zeros((ny, nx))

    #v_nx,v_ny = get_v_N(grid,rho_vyx,Bz_vyx,fo)

    for ix in range(nx):
        for iy in range(ny):
            Z2ni_loc = Z2ni[iy, ix]
            v_nx[iy,
                 ix], v_ny[iy,
                           ix] = get_v_N_classical(v_grid, Z2ni_loc, ne[iy,
                                                                        ix],
                                                   Te[iy, ix], Bz[iy, ix],
                                                   dxT[iy, ix], dyT[iy, ix])

            v_nx_hf[iy, ix] = qx[iy, ix] / (2.5 * ne[iy, ix] * Te[iy, ix])
            v_ny_hf[iy, ix] = qy[iy, ix] / (2.5 * ne[iy, ix] * Te[iy, ix])

    v_nx = np.where(Bz == 0.0, 0.0, v_nx)
    v_ny = np.where(Bz == 0.0, 0.0, v_ny)
    return v_nx, v_ny, v_nx_hf, v_ny_hf
Пример #3
0
def get_Nernst_abs(path, time):
    '''
    data_x,data_y = get_Nernst_ratio(path,time)
    '''
    dict = cf.load_data_all_1D(path, fpre(path), time)
    ne = dict['ne']
    Te = dict['Te']
    qx = dict['qx']
    qy = dict['qy']
    jx = dict['jx']
    jy = dict['jy']
    dxT = dict['dxT']
    dyT = dict['dyT']
    Bz = dict['Bz']
    x_grid = dict['x_grid']
    y_grid = dict['y_grid']
    Z2ni = dict['Z2ni']
    prof_Z = dict['Z']
    fo = dict['fo']
    nv = dict['nv']
    ny = dict['ny']
    nx = dict['nx']
    rA = (Z2ni)**-1

    dict_fo = cf.load_dict_1D(path, fpre(path), 'fo', time)
    fo = dict_fo['mat']

    rA = (Z2ni)**-1

    #===============
    grid = dict['grid']
    dxfo, dyfo = cf.get_grad_3d_varZ(grid, fo)
    rho = rA
    omega = Bz * rA
    rho_vyx = extend_grid_xy_to_vxy(nv, ny, nx, rA)
    Bz_vyx = extend_grid_xy_to_vxy(nv, ny, nx, Bz)
    omega_vyx = extend_grid_xy_to_vxy(nv, ny, nx, omega)
    #------ NERNST -----------------------------------------------------
    v_nx, v_ny = get_v_N(grid, rho_vyx, Bz_vyx, fo)
    v_nx_classical, v_ny_classical, v_nx_hf, v_ny_hf = get_vN_from_path(
        path, fpre(path), time)

    v_nx_c = np.transpose(v_nx_classical)
    v_ny_c = np.transpose(
        v_ny_classical)  #np.transpoe(v_ny_classical)#[:,::-1]
    v_nx_k = np.transpose(v_nx)
    v_ny_k = np.transpose(v_ny)  #np.transpose(v_ny)#[:,::-1]

    return v_nx_k, v_ny_k, v_nx_c, v_ny_c
Пример #4
0
def get_kinetic_heatflow_b(path, time):
    '''
        dict = get_kinetic_heatflow_b(path,time)
        var_list = ['q_SH_x','q_SH_y','q_RL_x','q_RL_y','q_TE_x','q_TE_y','q_E_x','q_E_y']
        for var in range(len(dict.keys())):
            var_name = var_list[var]
            ax = fig.add_subplot(ny_plots,nx_plots,var+1)
            plot_2D(ax,dict[var_name]['data'],dict[var_name]['name'])
    
    '''

    dict = cf.load_data_all_1D(path, fpre(path), time)
    ne = dict['ne']
    Te = dict['Te']
    qx = dict['qx']
    qy = dict['qy']
    jx = dict['jx']
    jy = dict['jy']
    dxT = dict['dxT']
    dyT = dict['dyT']
    Bz = dict['Bz']
    x_grid = dict['x_grid']
    y_grid = dict['y_grid']
    Z2ni = dict['Z2ni']
    prof_Z = dict['Z']
    fo = dict['fo']
    nv = dict['nv']
    ny = dict['ny']
    nx = dict['nx']
    rA = (Z2ni)**-1

    dict_fo = cf.load_dict_1D(path, fpre(path), 'fo', time)

    #===============
    grid = dict['grid']
    dxfo, dyfo = cf.get_grad_3d_varZ(grid, fo)
    rho = rA
    omega = Bz * rA
    rho_vyx = extend_grid_xy_to_vxy(nv, ny, nx, rA)
    Bz_vyx = extend_grid_xy_to_vxy(nv, ny, nx, Bz)
    omega_vyx = extend_grid_xy_to_vxy(nv, ny, nx, omega)
    dict = get_qSH_kinetic(grid, rho_vyx, Bz_vyx, jx, jy, fo)
    dict['x_grid'] = dict_fo['x_grid']
    dict['y_grid'] = dict_fo['y_grid']
    dict['v_grid'] = dict_fo['v_grid']
    dict['time'] = dict_fo['time']
    return dict
Пример #5
0
def get_q_abs(path, time):
    '''
    dict_ratio = get_q_ratio(path,time)
    '''
    time_int = int(time)
    dict = cf.load_data_all_1D(path, fpre(path), time)
    ne = dict['ne']
    Te = dict['Te']
    qx = dict['qx']
    qy = dict['qy']
    jx = dict['jx']
    jy = dict['jy']
    dxT = dict['dxT']
    dyT = dict['dyT']
    Bz = dict['Bz']
    U = dict['U']
    x_grid = dict['x_grid']
    y_grid = dict['y_grid']
    Z2ni = dict['Z2ni']
    prof_Z = dict['Z']
    fo = dict['fo']
    nv = dict['nv']
    ny = dict['ny']
    nx = dict['nx']
    rA = (Z2ni)**-1

    dict_fo = cf.load_dict_1D(path, fpre(path), 'fo', time)
    fo = dict_fo['mat']
    rA = (Z2ni)**-1

    #===============
    grid = dict['grid']
    dxfo, dyfo = cf.get_grad_3d_varZ(grid, fo)
    rho = rA
    omega = Bz * rA
    rho_vyx = extend_grid_xy_to_vxy(nv, ny, nx, rA)
    Bz_vyx = extend_grid_xy_to_vxy(nv, ny, nx, Bz)
    omega_vyx = extend_grid_xy_to_vxy(nv, ny, nx, omega)
    #heat flow ratios

    #--- kinetic
    dict = get_qSH_kinetic(grid, rho_vyx, Bz_vyx, jx, jy, fo)
    name_list = [
        'q_SH_x', 'q_SH_y', 'q_RL_x', 'q_RL_y', 'q_TE_x', 'q_TE_y', 'q_E_x',
        'q_E_y'
    ]
    for name in name_list:
        dict[name]['data'] = np.transpose(dict[name]['data'])[:]

    q_KSH_x, q_KSH_y, q_KRL_x, q_KRL_y, q_KTE_x, q_KTE_y, q_KE_x, q_KE_y = dict[
        'q_SH_x']['data'], dict['q_SH_y']['data'], dict['q_RL_x'][
            'data'], dict['q_RL_y']['data'], dict['q_TE_x']['data'], dict[
                'q_TE_y']['data'], dict['q_E_x']['data'], dict['q_E_y']['data']
    #--- classical

    q_dir = path + '/'
    q_SH_x = np.load(q_dir + 'q_SH_x.txt.npy')
    q_SH_y = np.load(q_dir + 'q_SH_y.txt.npy')
    q_RL_x = np.load(q_dir + 'q_RL_x.txt.npy')
    q_RL_y = np.load(q_dir + 'q_RL_y.txt.npy')
    q_E_x = np.load(q_dir + 'q_E_x.txt.npy')
    q_E_y = np.load(q_dir + 'q_E_y.txt.npy')
    q_xX = np.load(q_dir + 'q_xX.txt.npy')
    q_yY = np.load(q_dir + 'q_yY.txt.npy')
    #nt,ny,nx
    q_x_VFP = (q_xX[:, 1:, :] + q_xX[:, :-1, :]) * 0.5
    q_y_VFP = (q_yY[:, :, 1:] + q_yY[:, :, :-1]) * 0.5
    q_x_B = q_RL_x + q_E_x + q_SH_x
    q_y_B = q_RL_y + q_E_y + q_SH_y

    dict_c = {}
    dict_c['tot x'] = q_x_B[time_int, :, :]  #q_xc
    dict_c['tot y'] = q_y_B[time_int, :, :]

    dict_c['SH x'] = q_SH_x[time_int, :, :]  #q_SH_x[time_int,:x_lim,:]
    dict_c['SH y'] = q_SH_y[time_int, :, :]  #q_SH_y[time_int,:x_lim,:]
    dict_c['RL x'] = q_RL_x[time_int, :, :]
    dict_c['RL y'] = q_RL_y[time_int, :, :]
    dict_c['E x'] = q_E_x[time_int, :, :]
    dict_c['E y'] = q_E_y[time_int, :, :]

    dict_k = {}
    dict_k['tot x'] = q_x_VFP[time_int, :, :]
    dict_k['tot y'] = q_y_VFP[time_int, :, :]

    dict_k['SH x'] = q_KSH_x  #q_SH_x[time_int,:x_lim,:]
    dict_k['SH y'] = q_KSH_y  #q_SH_y[time_int,:x_lim,:]
    dict_k['RL x'] = q_KRL_x
    dict_k['RL y'] = q_KRL_y
    dict_k['E x'] = q_KTE_x + q_KE_x
    dict_k['E y'] = q_KTE_y + q_KE_y

    dict_k['time'] = dict_fo['time']
    dict_c['x_grid'] = x_grid[1:-1]
    dict_c['y_grid'] = y_grid
    dict_k['x_grid'] = x_grid[1:-1]
    dict_k['y_grid'] = y_grid
    dict_k['ne'] = np.transpose(ne)
    dict_k['Te'] = np.transpose(Te)
    dict_k['jx'] = np.transpose(jx)
    dict_k['jy'] = np.transpose(jy)
    dict_k['dxT'] = np.transpose(dxT)
    dict_k['dyT'] = np.transpose(dyT)
    dict_k['Bz'] = np.transpose(Bz)
    dict_k['Z2ni'] = np.transpose(Z2ni)
    dict_k['U'] = np.transpose(U)

    return dict_c, dict_k
Пример #6
0
    def __init__(self, run_obj, **kwargs):
        path = run_obj.path
        self.time = kwargs.get('time', run_obj.time_max)
        iy = kwargs.get('iy', 20)
        self.dim = run_obj.dim

        self.cfg = run_obj.norm
        if self.dim == '1D':
            dict_load = cf.load_data_all_1D(path, fpre(path), self.time)
            convert_array = lambda key: dict_load[key]
            convert_array_dy = lambda key: dict_load[key]
            self.ny = 1
        else:
            dict_load = cf.load_data_all(path, fpre(path), self.time)
            convert_array = lambda key: dict_load[key]
            convert_array_dy = lambda key: np.transpose(dict_load[key]
                                                        )[:, ::-1][:, iy]
            self.ny = dict_load['ny']
        # data in

        self.ne_ref = self.cfg.n0
        self.Te_ref = self.cfg.T0
        self.Bz_ref = (
            m_e / (q_e * self.cfg.tau_ei)) * 1.0  # assumes that norm Bz is 1T
        self.v_te = self.cfg.v_te
        self.tau_ei = self.cfg.tau_ei
        self.Z_ref = self.cfg.Z
        self.Ar = self.cfg.Ar
        self.lambda_mfp = self.cfg.lambda_mfp

        # Only load in line outs of arrays
        # swap y direction after transpose for y gradients
        self.time_secs = dict_load['time'] * self.tau_ei
        if self.dim == '1D':
            self.dyB = None
            self.dyT = None
        else:
            self.dyB = convert_array_dy('dyB')
            self.dyT = convert_array_dy('dyT')
        self.dict_load = dict_load

        self.fo = dict_load['fo']

        self.Te1 = cf.get_U_dev(dict_load['Te'].T)
        self.Bz1 = cf.get_U_dev(dict_load['Bz'].T)

        self.Z = convert_array('Z') * self.Z_ref
        self.U = convert_array('U')
        self.Te = convert_array('Te')
        self.ne = convert_array('ne')
        self.Cx = convert_array('Cx')

        self.wt = convert_array('wt')
        self.Bz = convert_array('Bz')
        if self.dim == '1D':
            self.x_grid = cf.trim_array_1D(dict_load['x_grid'],
                                           dict_load['nx'], 1)
            self.y_grid = None
        else:
            self.x_grid = cf.trim_array_1D(dict_load['x_grid'],
                                           dict_load['nx'], self.ny)
            self.y_grid = cf.trim_array_1D(dict_load['y_grid'],
                                           dict_load['ny'], dict_load['nx'])

        self.v_grid = dict_load['v_grid']

        self.dxT = convert_array('dxT')
        self.dxB = convert_array('dxB')

        self.n_factor = 1.0
        self.Te_factor = 1.0
        self.Bz_factor = 1.0
        self.C_factor = 1.0
        self.P_factor = 2.0 / 3.0
        self.x_factor = 1.0