Metadata-Version: 2.1
Name: oblopy
Version: 0.0.5
Summary: Python toolbox for reading, analysing and processing profiling Lidar observations.
Home-page: https://github.com/cdu022/oblopy
Author: Christiane Duscha
Author-email: christiane.duscha@uib.no
License: bsd-3-clause
Download-URL: https://github.com/cdu022/oblopy/archive/refs/tags/v0.0.5.tar.gz
Description: # oblopy
        
        ## toblo
        A toolbox for analysing Lidar observational data and related meteorological data
        
        ## retrieval
        Toolbox to retrieve the 3D wind vector from profiling Lidar observations in Doppler beam swinging mode (DBS). In the current state of the retrieval module the input of radial (LOS) velocity observations need to be prepared. For all functions, the LOS velocity input needs to be prepared carefully, such that the the LOS velocity input is consistent with the coordinate of the utilized Lidar system and the retrieval coordinate system. Each beam in the retrieval coordinate system corresponds to a certain azimuth and zenith angle:
        ### azimuth, a, unit = deg
        Lidar beam pointing in the following direction
        
        (x,y) = ( 1, 0) : a = 180 
        
        (x,y) = ( 0, 1) : a = 270 
        
        (x,y) = (-1, 0) : a =   0
        
        (x,y) = ( 0,-1) : a =  90 
        
        ### zenith, z, unit = deg
        The zenith angle corresponds either to the cone angle of the DBS (e.g. z=28 deg) or is upward pointing (z=0)
        
        ### An example for utilizing the retrieval module: Simulate a wind speed series of a Lidar, that is installed on a moving platform 
        #### Import the necesary python modules
        `from oblopy.retrieval import *`
        
        `import numpy as np`
        
        `import pandas as pd`
        
        #### Make a sample velocity vector
        Define a series of time stamps
        
        `time = np.arange(0,40*np.pi, 0.1)`
        
        Define the 3 wind speed components (artificial)
        
        `u = 2*(np.cos(time*2.5)+np.cos(time*1.5)+np.sin(time/2.5)+np.cos(time/3.5))+np.random.rand(len(time))*2` 
        
        `v = -2*(np.cos(time*3.5)+np.sin(time*1.5)+np.sin(time/3.5)-np.cos(time/4.5))-np.random.rand(len(time))*2`
        
        `w = np.cos((time-np.pi)/2*3.5)-np.random.randn(len(time))*0.5`
        
        #### Define a series of roll pitch and yaw angles 
        Note: If you do not want to include motion angles and corresponding correction in your retrieval, set the series of roll, pitch and yaw to zero
        
        Define the motion angles (artificial)
        
        `roll  = np.ones(len(time))`       
        
        `pitch = -np.ones(len(time)) + 10`
        
        `yaw   = np.zeros(len(time)) + 45`
        
        Get the corresponding rotation matrix
        
        `R = get_R(roll, pitch, yaw, time, order = 'zyx')`
        
        rotate the simulated wind speed vector 
        
        `vec_u_ = multi_dim_matrix_mult(R,vec_u,time)`
        
        `u_ = vec_u_[0,0,:]`
        
        `v_ = vec_u_[1,0,:]`
        
        `w_ = vec_u_[2,0,:]`
        
        #### Make a sample radial velocity vector
        The input to the retrieval should be of similar type. The amount of beams is free to choose. Beams are seperated by azimuth and zenith coordinates. The beams need to be organized in a pandas DataFrame as following. Naming of the collumns (time series corresponding to one beam) is free.
        
        Define the cone angle of the DBS scan
        
        `theta = np.deg2rad(28)`
        
        B1: pointing in oposite x-direction (az=0, ze = 28)
        
        `B1 = pd.DataFrame({'B1':u_[0::5]*np.sin(theta)+w_[0::5]*np.cos(theta)}, index = time[0::5])`
        
        B2: pointing in oposite y-direction (az=90, ze = 28)
        
        `B2 = pd.DataFrame({'B2':v_[1::5]*np.sin(theta)+w_[1::5]*np.cos(theta)}, index = time[1::5])`
        
        B3: pointing in x-direction (az=180, ze = 28)
        
        `B3 = pd.DataFrame({'B3':-u_[2::5]*np.sin(theta)+w_[2::5]*np.cos(theta)}, index = time[2::5])`
        
        B4: pointing in oposite x-direction (az=270, ze = 28)
        
        `B4 = pd.DataFrame({'B4':-v_[3::5]*np.sin(theta)+w_[3::5]*np.cos(theta)}, index = time[3::5])`
        
        B5: vertical pointing beam (az=*, ze = 0), here the choice of azimuth is free
        
        `B5 = pd.DataFrame({'B5':w_[4::5]}, index = time[4::5])`
        
        
        Define the corresponding azimuth and zenith list. 
        
        Note: Needs to be the same length as the amount of utilized beams
        
        `az = [0,90,180,270,0]`
        
        `ze = [28,28,28,28,0]`
        
        Create a pandas DataFrame contaning the time series of all defined beams
        
        `all_beams = pd.DataFrame(index=time)`
        
        `all_beams['B1'] = B1.copy()`
        
        `all_beams['B2'] = B2.copy()`
        
        `all_beams['B3'] = B3.copy()`
        
        `all_beams['B4'] = B4.copy()`
        
        `all_beams['B5'] = B5.copy()`
        
        #### Do a retrieval of the sample radial velocity vector
        Correct the beams by the ship velocity. 
        
        `corr_beams = correct_LOS_vel(all_beams.interpolate(method='pchip'), u_plat, 
                                     az = az, ze = ze)`
        
        Retrieve the 3D velocity vector. 
        
        `retr_int = DBS_least_squares_retrieval(corr_beams, roll, pitch, yaw, 
                                               az = az, ze = ze, 
                                               rot=True, order = 'xyz')`
Keywords: Offshore Boundary Layer Observatory (OBLO),Marine Boundary Layer,Lidar,Retrieval,Motion correction,meteorology,bergen
Platform: UNKNOWN
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Developers
Classifier: Topic :: Software Development :: Build Tools
Classifier: License :: OSI Approved :: BSD License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Description-Content-Type: text/markdown
