Beispiel #1
0
 def fromCDF(cls, filepath, **kwargs):
     '''
     Create a DataModel from a CDF data file.
     Not available without SpacePy.
     '''
     if USE_SPACEPY:
         return cls.fromSpaceData(spdm.fromCDF(filepath, **kwargs))
     else:
         raise NotImplementedError
Beispiel #2
0
def data_in(f_name, LOCATION):
    try:
        data = dm.fromCDF(f_name).copy()
    except:
        try:
            data = pycdf.CDF(f_name)
        except:
            print('Issue with:', f_name)
            return pd.DataFrame(), False

    time = data['thg_mag_' + LOCATION + '_time'].copy()
    D = data['thg_mag_' + LOCATION].copy()
    df = pd.DataFrame(D, index=time)
    df.index = pd.to_datetime(df.index, unit='s')
    df = df.resample('1min').mean()

    return df, True
def release(filename):
    connection = pymongo.MongoClient()
    tdb = connection.CDF_Release
    post_attrs = tdb.attrs
    post_datas = tdb.data

    cdf_file = dm.fromCDF(filename)
    cdf = readCDF(filename, cdf_file)
    attrs_value = cdf[0]
    data_value = cdf[1]

    try:
        if post_attrs.find_one({'_id': filename}) == None:
            post_attrs.insert(attrs_value)
            post_datas.insert(data_value)
        else:
            print 'the file attrs has been imported'
    except Exception as e:
        print '---------------wrong cdf---------------'
Beispiel #4
0
def get_cdf(*args, **kwargs):
    """
    Get a CDF file and read it (all arguments are passed to cdaweb.get_file)

    Example:

    from datetime import datetime
    get_cdf('sp_phys','OMNI2_H0_MRG1HR',datetime(2005,1,1),datetime(2005,2,1),['KP1800'])

    """

    resp = get_file(*args, **kwargs)

    from tempfile import NamedTemporaryFile
    from shutil import copyfileobj
    import spacepy.datamodel as dm

    with NamedTemporaryFile() as tmpfile:
        copyfileobj(resp, tmpfile)
        tmpfile.seek(0)
        data = dm.fromCDF(tmpfile.name)

    return data
Beispiel #5
0
 def test_toCDFroundtrip_method(self):
     """toCDF should be able to make a file and then read it in the same"""
     self.SDobj.toCDF(self.testfile)
     tst = dm.fromCDF(self.testfile)
     for k in self.SDobj:
         np.testing.assert_array_equal(self.SDobj[k], tst[k])
#-*-coding:utf8-*-
"""
releaseCDF
releaseCDF input/output filters
Written by Zahi Yang May 2017
- contains read function
"""

import pymongo
import time, datetime
import spacepy.datamodel as dm
from spacepy import pycdf

filename = 'ac_at_def_19970826_v01.cdf'
cdf_file = dm.fromCDF(filename)


def readCDF(filename, cdf_file):
    diction_attrs = {}
    diction_data = {}
    diction_attrs['_id'] = filename
    for key in cdf_file.attrs.keys():
        value = cdf_file.attrs[key]
        if not value == ' ':
            diction_attrs[key] = value
        else:
            diction_attrs[key] = None

    data_recorder = []
    keys = cdf_file.keys()
    for key in keys:
Beispiel #7
0
 def test_toCDF_method(self):
     """Convert to CDF, using the method, catching #404"""
     a = dm.SpaceData({'dat': dm.dmarray([1, 2, 3])})
     a.toCDF(self.testfile, mode='a')
     newobj = dm.fromCDF(self.testfile)
     np.testing.assert_array_equal([1, 2, 3], newobj['dat'])
def integrate_HOPE_moments(time_start, time_end, probe, pad, rbsp_path='E://DATA//RBSP//'):
    '''
    Testing self-integration of ion moments from pitch angle data :: Compare to actual
    calculated L3-MOM products.
    
    Based on equation from RBSPICE Data Handbook Rev. E (2018) p. 31.
    
    Questions:
        - Do we have to account for gaps between energy channels? As in, fit a smooth
            curve to the fluxes and integrate that way?
        - Should be able to ignore channels below 30eV for the comparison, and then
        include them once the fluxes are corrected for a few things? To get an idea
        of the plasmaspheric composition
    '''
    qp = 1.602e-19
    mp = 1.673e-27
    
    import spacepy.datamodel as dm
    pa_data  = dm.fromCDF(_test_file_pa)
    mom_data = dm.fromCDF(_test_file_mom)
    
    mom_times = mom_data['Epoch_Ion']
    mom_hdens = mom_data['Dens_p_30']
    
    pa_times  = pa_data['Epoch_Ion']
    
    n_times = pa_times.shape[0]
    vdens     = np.zeros(n_times, dtype=np.float64)
    
    # Organize pitch angle stuff
    pitch  = pa_data['PITCH_ANGLE']             # PA bin centers
    n_pitch= pitch.shape[0]
    da     = np.ones(n_pitch) * 18.             # PA bin widths
    da[0]  = da[-1] = 9.
    da    *= np.pi / 180.
    
    # Do energy stuff
    energy   = pa_data['HOPE_ENERGY_Ion']         # Energy bin centers
    n_energy = energy.shape[1]

    # Energy bin limits
    erange = np.zeros((n_times, n_energy, 2))
    for ii in range(n_energy):
        erange[:, ii, 0] = (pa_data['HOPE_ENERGY_Ion'][:, ii] - pa_data['ENERGY_Ion_DELTA'][:, ii])
        erange[:, ii, 1] = (pa_data['HOPE_ENERGY_Ion'][:, ii] + pa_data['ENERGY_Ion_DELTA'][:, ii])
    
    E_min = 30.0; E_max = None
    for ii in range(n_times):
        E  = energy[ii]
        dE = erange[ii]
     
        # Find energy min/max channels for integration
        if E_min is None:
            min_idx = 0
        else:
            diffs   = np.abs(energy - E_min)
            min_idx = np.where(diffs == diffs.min())[0][0]
            
        if E_max is None:
            max_idx = energy.shape[0] - 1
        else:
            diffs   = np.abs(energy - E_max)
            min_idx = np.where(diffs == diffs.min())[0][0]
        
        #vdens[ii] = vdist[ii, min_idx:max_idx].sum()
        
        # Need:
        # Pitch angle bin list
        # Pitch angle widths
        # Energy bin list
        # Energy bin widths
        
        
    # Filter bad values (fill value -1E-31, and no density should be negative)
    for ii in range(mom_hdens.shape[0]):
        if mom_hdens[ii] < 0.0:
            mom_hdens[ii] = np.nan
    for ii in range(vdens.shape[0]):
        if vdens[ii] < 0.0:
             vdens[ii] = np.nan

    plt.ioff()
    plt.figure()
    plt.plot(mom_times, mom_hdens, label='MOM-L3')
    plt.plot(pa_times , vdens    , label='Manual')
    plt.legend()
    plt.show()
    return