def build_profile(fname, z, T, S, ua): """ docstring for build_profile """ # Prepare the data for insertion in the netCDF database data = np.zeros((z.shape[0], 4)) names = ['z', 'temperature', 'salinity', 'ua'] units = ['m', 'K', 'psu', 'm/s'] data[:,0] = z.transpose() data[:,1] = T.transpose() data[:,2] = S.transpose() data[:,3] = ua.transpose() # Create the netCDF file to store the data nc_file = fname summary = 'Test case for jet in crossflow' source = 'Laboratory data' sea_name = 'Laboratory' p_lat = 0. p_lon = 0. p_time = date2num(datetime(2014, 10, 15, 16, 0, 0), units = 'seconds since 1970-01-01 00:00:00 0:00', calendar = 'julian') nc = ambient.create_nc_db(nc_file, summary, source, sea_name, p_lat, p_lon, p_time) # Insert the data into the netCDF dataset comments = ['measured', 'measured', 'measured', 'measured'] nc = ambient.fill_nc_db(nc, data, names, units, comments, 0) # Compute the pressure and insert into the netCDF dataset P = ambient.compute_pressure(data[:,0], data[:,1], data[:,2], 0) P_data = np.vstack((data[:,0], P)).transpose() nc = ambient.fill_nc_db(nc, P_data, ['z', 'pressure'], ['m', 'Pa'], ['measured', 'computed'], 0) # Create an ambient.Profile object from this dataset profile = ambient.Profile(nc, chem_names='all') profile.close_nc() return profile
def build_profile(fname, z, T, S, ua): """ docstring for build_profile """ # Prepare the data for insertion in the netCDF database data = np.zeros((z.shape[0], 4)) names = ['z', 'temperature', 'salinity', 'ua'] units = ['m', 'K', 'psu', 'm/s'] data[:, 0] = z.transpose() data[:, 1] = T.transpose() data[:, 2] = S.transpose() data[:, 3] = ua.transpose() # Create the netCDF file to store the data nc_file = fname summary = 'Test case for jet in crossflow' source = 'Laboratory data' sea_name = 'Laboratory' p_lat = 0. p_lon = 0. p_time = date2num(datetime(2014, 10, 15, 16, 0, 0), units='seconds since 1970-01-01 00:00:00 0:00', calendar='julian') nc = ambient.create_nc_db(nc_file, summary, source, sea_name, p_lat, p_lon, p_time) # Insert the data into the netCDF dataset comments = ['measured', 'measured', 'measured', 'measured'] nc = ambient.fill_nc_db(nc, data, names, units, comments, 0) # Compute the pressure and insert into the netCDF dataset P = ambient.compute_pressure(data[:, 0], data[:, 1], data[:, 2], 0) P_data = np.vstack((data[:, 0], P)).transpose() nc = ambient.fill_nc_db(nc, P_data, ['z', 'pressure'], ['m', 'Pa'], ['measured', 'computed'], 0) # Create an ambient.Profile object from this dataset profile = ambient.Profile(nc, chem_names='all') profile.close_nc() return profile
calendar='julian') nc = ambient.create_nc_db(nc_file, summary, source, sea_name, p_lat, p_lon, p_time) # Insert the CTD data into the netCDF dataset comments = ['digitized', 'digitized'] nc = ambient.fill_nc_db(nc, C_profile, ['salinity', 'z'], C_units, comments, 1) nc = ambient.fill_nc_db(nc, T_profile, ['temperature', 'z'], T_units, comments, 1) # Calculate and insert the pressure data z = nc.variables['z'][:] T = nc.variables['temperature'][:] S = nc.variables['salinity'][:] P = ambient.compute_pressure(z, T, S, 0) P_data = np.vstack((z, P)).transpose() nc = ambient.fill_nc_db(nc, P_data, ['z', 'pressure'], ['m', 'Pa'], ['measured', 'computed'], 0) # Create an ambient.Profile object for this dataset ds = ambient.Profile(nc) # Close the netCDF dataset ds.nc.close() # Since the netCDF file is now fully stored on the hard drive in the # correct format, we can initialize an ambient.Profile object directly # from the netCDF file ds = ambient.Profile(nc_file, chem_names='all')
def test_from_calcs(): """ Test the ambient data methods on synthetic profiles. This unit test creates synthetic data (e.g., profiles matching laboratory idealized conditions) and then uses this data to test the data manipulation and storage methods in ambient.py. """ # Create the synthetic temperature and salinity profiles z = np.array([0.0, 2.4]) T = np.array([21.0, 20.0]) S = np.array([0.0, 30.0]) # Create an empty netCDF4-classic dataset to store the CTD information nc_file = os.path.join(OUTPUT_DIR, 'test_Lab.nc') summary = 'Py.Test test file' source = 'Synthetic profiles for idealized laboratory conditions' sea_name = 'None' p_lat = -999 p_lon = -999 p_time = date2num(datetime(2013, 7, 12, 11, 54, 0), units='seconds since 1970-01-01 00:00:00 0:00', calendar='julian') nc = check_nc_db(nc_file, summary, source, sea_name, p_lat, p_lon, p_time) # Convert the temperature units T, T_units = get_units(T, ['deg C'], 1, 2, ['K']) # Fill the netCDF4-classic dataset with the data in these variables nc = get_filled_nc_db(nc, z, ['z'], ['m'], ['synthetic'], 0, ['depth below the water surface'], ['depth']) # Check that we cannot overwrite this existing z-data try: nc = ambient.fill_nc_db(nc, z, 'z', 'm', 'synthetic', 0) except ValueError: assert True is True else: assert True is False # Fill in the remaining data data = np.zeros((2, 3)) data[:, 0] = z data[:, 1] = T data[:, 2] = S nc = get_filled_nc_db(nc, data, ['z', 'temperature', 'salinity'], ['m', 'K', 'psu'], ['synthetic', 'synthetic', 'synthetic'], 0, [ 'depth below the water surface', 'Absolute temperature', 'Practical salinity' ], ['depth', 'temperature', 'salinity']) # Calculate and insert the pressure data P = ambient.compute_pressure(data[:, 0], data[:, 1], data[:, 2], 0) P_data = np.vstack((data[:, 0], P)).transpose() nc = ambient.fill_nc_db(nc, P_data, ['z', 'pressure'], ['m', 'Pa'], ['measured', 'computed'], 0) # Create and test a Profile object for this dataset. lab = get_profile_obj(nc, [], []) # Close down the pipes to the netCDF dataset files lab.nc.close()
def test_using_numpy(): """ Test the ambient data methods using only numpy This unit test repeats the tests in `test_from_txt()`, but using only the `numpy` array part of the `Profile` object instead of a netCDF dataset. """ # Get the profile objuect using netCDF datasets net_profile = test_from_txt() # Get a platform-independent path to the datafile cdat_file = os.path.join(DATA_DIR, 'C.dat') tdat_file = os.path.join(DATA_DIR, 'T.dat') # Load in the raw data using np.loadtxt C_raw = np.loadtxt(cdat_file, comments='%') T_raw = np.loadtxt(tdat_file, comments='%') # Clean the profile to remove depth reversals C_data = get_profile(C_raw, 1, 25, None, 0., 1.0256410e+01, 8.0000000e+02, 34, 2) T_data = get_profile(T_raw, 1, 25, None, 0., 1.0831721e+01, 7.9922631e+02, 34, 2) # Convert the data to standard units C_data, C_units = get_units(C_data, ['psu', 'm'], 34, 2, ['psu', 'm']) T_data, T_units = get_units(T_data, ['deg C', 'm'], 34, 2, ['K', 'm']) # Create an numpy array to hold depth and salinity var_names = ['depth', 'salinity'] var_units = ['m', 'psu'] data = np.zeros((C_data.shape[0], 3)) data[:, 0] = C_data[:, 1] data[:, 2] = C_data[:, 0] # Add the temperature data using the existing depth data data = ambient.add_data(data, 1, 'temperature', T_data, ['temperature', 'z'], T_units, ['measured', 'measured'], 1) z = data[:, 0] T = data[:, 1] S = data[:, 2] P = ambient.compute_pressure(z, T, S, 0) P_data = np.vstack((z, P)).transpose() data = ambient.add_data(data, 3, 'pressure', P_data, ['z', 'pressure'], ['m', 'Pa'], ['measured', 'measured'], 0) # Create the profile object ztsp = ['z', 'temperature', 'salinity', 'pressure'] ztsp_units = ['m', 'K', 'psu', 'Pa'] ds = ambient.Profile(data, ztsp, None, 0.01, ztsp_units, None, current=np.array([0., 0.]), current_units=['m/s', 'm/s']) # Add currents currents = np.array([[0, 0.1, 0.05], [500, 0.1, 0.05]]) var_names = ['z', 'u', 'v'] var_units = ['m', 'm/s', 'm/s'] ds.append(currents, var_names, var_units, 0) # Check if the two objects are equal check_net_numpy(net_profile, ds, currents) return ds
def test_from_txt(): """ Test the ambient data methods on simple text files. This unit test reads in the text files ./data/C.dat and ./data/T.dat using `numpy.loadtxt` and then uses this data to test the data manipulation and storage methods in ambient.py. """ cdat_file = os.path.join(DATA_DIR, 'C.dat') tdat_file = os.path.join(DATA_DIR, 'T.dat') # Load in the raw data using np.loadtxt C_raw = np.loadtxt(cdat_file, comments='%') T_raw = np.loadtxt(tdat_file, comments='%') # Clean the profile to remove depth reversals C_data = get_profile(C_raw, 1, 25, None, 0., 1.0256410e+01, 8.0000000e+02, 34, 2) T_data = get_profile(T_raw, 1, 25, None, 0., 1.0831721e+01, 7.9922631e+02, 34, 2) # Convert the data to standard units C_data, C_units = get_units(C_data, ['psu', 'm'], 34, 2, ['psu', 'm']) T_data, T_units = get_units(T_data, ['deg C', 'm'], 34, 2, ['K', 'm']) # Create an empty netCDF4-classic dataset to store the CTD information nc_file = os.path.join(OUTPUT_DIR, 'test_DS.nc') summary = 'Py.Test test file' source = 'Profiles from the SINTEF DeepSpill Report' sea_name = 'Norwegian Sea' p_lat = 64.99066 p_lon = 4.84725 p_time = date2num(datetime(2000, 6, 27, 12, 0, 0), units='seconds since 1970-01-01 00:00:00 0:00', calendar='julian') nc = check_nc_db(nc_file, summary, source, sea_name, p_lat, p_lon, p_time) # Fill the netCDF4-classic dataset with the data in the salinity profile symbols = ['salinity', 'z'] comments = ['measured', 'measured'] long_names = ['Practical salinity', 'depth below the water surface'] std_names = ['salinity', 'depth'] nc = get_filled_nc_db(nc, C_data, symbols, C_units, comments, 1, long_names, std_names) # Because the temperature data will be interpolated to the vertical # coordinates in the salinity profile, insert the data and test that # insertion worked correctly by hand symbols = ['temperature', 'z'] comments = ['measured', 'measured'] long_names = ['Absolute temperature', 'depth below the water surface'] std_names = ['temperature', 'depth'] nc = ambient.fill_nc_db(nc, T_data, symbols, T_units, comments, 1) assert_array_almost_equal(nc.variables['z'][:], C_data[:, 1], decimal=6) z = nc.variables['z'][:] T = nc.variables['temperature'][:] f = interp1d(z, T) for i in range(T_data.shape[0]): assert_approx_equal(T_data[i, 0], f(T_data[i, 1]), significant=5) assert nc.variables['temperature'].comment == comments[0] # Calculate and insert the pressure data z = nc.variables['z'][:] T = nc.variables['temperature'][:] S = nc.variables['salinity'][:] P = ambient.compute_pressure(z, T, S, 0) P_data = np.vstack((z, P)).transpose() nc = ambient.fill_nc_db(nc, P_data, ['z', 'pressure'], ['m', 'Pa'], ['measured', 'computed'], 0) # Test the Profile object ds = get_profile_obj(nc, [], []) # Close down the pipes to the netCDF dataset files ds.nc.close() return ds
def test_from_calcs(): """ Test the ambient data methods on synthetic profiles. This unit test creates synthetic data (e.g., profiles matching laboratory idealized conditions) and then uses this data to test the data manipulation and storage methods in ambient.py. """ # Create the synthetic temperature and salinity profiles z = np.array([0.0, 2.4]) T = np.array([21.0, 20.0]) S = np.array([0.0, 30.0]) # Create an empty netCDF4-classic dataset to store the CTD information __location__ = os.path.realpath(os.path.join(os.getcwd(), os.path.dirname(__file__), 'output')) nc_file = os.path.join(__location__,'test_Lab.nc') summary = 'Py.Test test file' source = 'Synthetic profiles for idealized laboratory conditions' sea_name = 'None' p_lat = -999 p_lon = -999 p_time = date2num(datetime(2013, 7, 12, 11, 54, 0), units = 'seconds since 1970-01-01 00:00:00 0:00', calendar = 'julian') nc = check_nc_db(nc_file, summary, source, sea_name, p_lat, p_lon, p_time) # Convert the temperature units T, T_units = get_units(T, ['deg C'], 1, 2, ['K']) # Fill the netCDF4-classic dataset with the data in these variables nc = get_filled_nc_db(nc, z, ['z'], ['m'], ['synthetic'], 0, ['depth below the water surface'], ['depth']) # Check that we cannot overwrite this existing z-data try: nc = ambient.fill_nc_db(nc, z, 'z', 'm', 'synthetic', 0) except ValueError: assert True is True else: assert True is False # Fill in the remaining data data = np.zeros((2, 3)) data[:,0] = z data[:,1] = T data[:,2] = S nc = get_filled_nc_db(nc, data, ['z', 'temperature', 'salinity'], ['m', 'K', 'psu'], ['synthetic', 'synthetic', 'synthetic'], 0, ['depth below the water surface', 'Absolute temperature', 'Practical salinity'], ['depth', 'temperature', 'salinity']) # Calculate and insert the pressure data P = ambient.compute_pressure(data[:,0], data[:,1], data[:,2], 0) P_data = np.vstack((data[:,0], P)).transpose() nc = ambient.fill_nc_db(nc, P_data, ['z', 'pressure'], ['m', 'Pa'], ['measured', 'computed'], 0) # Create and test a Profile object for this dataset. lab = get_profile_obj(nc, [], []) # Close down the pipes to the netCDF dataset files lab.nc.close()
def test_from_txt(): """ Test the ambient data methods on simple text files. This unit test reads in the text files ./data/C.dat and ./data/T.dat using `numpy.loadtxt` and then uses this data to test the data manipulation and storage methods in ambient.py. """ # Get a platform-independent path to the datafile __location__ = os.path.realpath(os.path.join(os.getcwd(), os.path.dirname(__file__), '../tamoc/data')) cdat_file = os.path.join(__location__,'C.dat') tdat_file = os.path.join(__location__,'T.dat') # Load in the raw data using np.loadtxt C_raw = np.loadtxt(cdat_file, comments = '%') T_raw = np.loadtxt(tdat_file, comments = '%') # Clean the profile to remove depth reversals C_data = get_profile(C_raw, 1, 25, None, 0., 1.0256410e+01, 8.0000000e+02, 34, 2) T_data = get_profile(T_raw, 1, 25, None, 0., 1.0831721e+01, 7.9922631e+02, 34, 2) # Convert the data to standard units C_data, C_units = get_units(C_data, ['psu', 'm'], 34, 2, ['psu', 'm']) T_data, T_units = get_units(T_data, ['deg C', 'm'], 34, 2, ['K', 'm']) # Create an empty netCDF4-classic dataset to store the CTD information __location__ = os.path.realpath(os.path.join(os.getcwd(), os.path.dirname(__file__), 'output')) nc_file = os.path.join(__location__,'test_DS.nc') summary = 'Py.Test test file' source = 'Profiles from the SINTEF DeepSpill Report' sea_name = 'Norwegian Sea' p_lat = 64.99066 p_lon = 4.84725 p_time = date2num(datetime(2000, 6, 27, 12, 0, 0), units = 'seconds since 1970-01-01 00:00:00 0:00', calendar = 'julian') nc = check_nc_db(nc_file, summary, source, sea_name, p_lat, p_lon, p_time) # Fill the netCDF4-classic dataset with the data in the salinity profile symbols = ['salinity', 'z'] comments = ['measured', 'measured'] long_names = ['Practical salinity', 'depth below the water surface'] std_names = ['salinity', 'depth'] nc = get_filled_nc_db(nc, C_data, symbols, C_units, comments, 1, long_names, std_names) # Because the temperature data will be interpolated to the vertical # coordinates in the salinity profile, insert the data and test that # insertion worked correctly by hand symbols = ['temperature', 'z'] comments = ['measured', 'measured'] long_names = ['Absolute temperature', 'depth below the water surface'] std_names = ['temperature', 'depth'] nc = ambient.fill_nc_db(nc, T_data, symbols, T_units, comments, 1) assert_array_almost_equal(nc.variables['z'][:], C_data[:,1], decimal = 6) z = nc.variables['z'][:] T = nc.variables['temperature'][:] f = interp1d(z, T) for i in range(T_data.shape[0]): assert_approx_equal(T_data[i,0], f(T_data[i,1]), significant = 5) assert nc.variables['temperature'].comment == comments[0] # Calculate and insert the pressure data z = nc.variables['z'][:] T = nc.variables['temperature'][:] S = nc.variables['salinity'][:] P = ambient.compute_pressure(z, T, S, 0) P_data = np.vstack((z, P)).transpose() nc = ambient.fill_nc_db(nc, P_data, ['z', 'pressure'], ['m', 'Pa'], ['measured', 'computed'], 0) # Test the Profile object ds = get_profile_obj(nc, [], []) # Close down the pipes to the netCDF dataset files ds.nc.close()
def get_profile(self, nc_name, fname, u_a, v_a, w_a, depths): """ Read in the ambient CTD data Read in the CTD data specified by API for all test cases. Append the velocity information to the CTD file. Parameters ---------- nc_name : str Name to call the netCDF4 dataset. u_a : float Crossflow velocity for this test case (m/s). Returns ------- profile : `ambient.Profile` object Returns an `ambient.Profile` object of the ambient CTD and velocity information """ # Get the ambient CTD data names = ['z', 'temperature', 'salinity', 'oxygen'] units = ['m', 'deg C', 'psu', 'mmol/m^3'] data = np.loadtxt(fname, comments='%') # Convert the data to standard units M_o2 = 31.9988 / 1000. # kg/mol data[:, 3] = data[:, 3] / 1000. * M_o2 units[3] = 'kg/m^3' data, units = ambient.convert_units(data, units) # Create an empty netCDF4 dataset to store the CTD dat summary = 'Global horizontal mean hydrographic and oxygen data' source = 'Taken from page 226 of Sarmiento and Gruber' sea_name = 'Global' p_lat = 0. p_lon = 0. p_time = date2num(datetime(1998, 1, 1, 1, 0, 0), units='seconds since 1970-01-01 00:00:00 0:00', calendar='julian') nc = ambient.create_nc_db(nc_name, summary, source, sea_name, p_lat, p_lon, p_time) # Insert the data into the netCDF dataset comments = ['average', 'average', 'average', 'average'] nc = ambient.fill_nc_db(nc, data, names, units, comments, 0) # Compute the pressure and insert into the netCDF dataset P = ambient.compute_pressure(data[:, 0], data[:, 1], data[:, 2], 0) P_data = np.vstack((data[:, 0], P)).transpose() nc = ambient.fill_nc_db(nc, P_data, ['z', 'pressure'], ['m', 'Pa'], ['average', 'computed'], 0) # Create an ambient.Profile object from this dataset profile = ambient.Profile(nc, chem_names='all') # Force the max depth to model # depths[-1] = profile.z_max # Add the crossflow velocity print '******************' print depths print '******************' u_crossflow = np.zeros((len(depths), 2)) u_crossflow[:, 0] = depths if u_a.shape != depths.shape: u_crossflow[:, 1] = np.linspace(u_a[0], u_a[-1], len(depths)) else: u_crossflow[:, 1] = u_a symbols = ['z', 'ua'] units = ['m', 'm/s'] comments = ['provided', 'provided'] profile.append(u_crossflow, symbols, units, comments, 0) v_crossflow = np.zeros((len(depths), 2)) v_crossflow[:, 0] = depths if v_a.shape != depths.shape: v_crossflow[:, 1] = np.linspace(v_a[0], v_a[-1], len(depths)) else: v_crossflow[:, 1] = v_a symbols = ['z', 'va'] units = ['m', 'm/s'] comments = ['provided', 'provided'] profile.append(v_crossflow, symbols, units, comments, 0) w_crossflow = np.zeros((len(depths), 2)) w_crossflow[:, 0] = depths if w_a.shape != depths.shape: w_crossflow[:, 1] = np.linspace(w_a[0], w_a[-1], len(depths)) else: w_crossflow[:, 1] = w_a symbols = ['z', 'wa'] units = ['m', 'm/s'] comments = ['provided', 'provided'] profile.append(w_crossflow, symbols, units, comments, 0) # Finalize the profile (close the nc file) profile.close_nc() # Return the final profile return profile
def create_ambient_profile(data, labels, units, comments, nc_name, summary, source, sea_name, p_lat, p_lon, p_time, ca=[]): """ Create an ambient Profile object from given data Create an ambient.Profile object using the given CTD and current data. This function performs some standard operations to this data (unit conversion, computation of pressure, insertion of concentrations for dissolved gases, etc.) and returns the working ambient.Profile object. The idea behind this function is to separate data manipulation and creation of the ambient.Profile object from fetching of the data itself. Parameters ---------- data : np.array Array of the ambient ocean data to write to the CTD file. The contents and dimensions of this data are specified in the labels and units lists, below. labels : list List of string names of each variable in the data array. units : list List of units as strings for each variable in the data array. comments : list List of comments as strings that explain the types of data in the data array. Typical comments include 'measured', 'modeled', or 'computed'. nc_name : str String containing the file path and file name to use when creating the netCDF4 dataset that will contain this data. summary : str String describing the simulation for which this data will be used. source : str String documenting the source of the ambient ocean data provided. sea_name : str NC-compliant name for the ocean water body as a string. p_lat : float Latitude (deg) p_lon : float Longitude, negative is west of 0 (deg) p_time : netCDF4 time format Date and time of the CTD data using netCDF4.date2num(). ca : list, default=[] List of gases for which to compute a standard dissolved gas profile; choices are 'nitrogen', 'oxygen', 'argon', and 'carbon_dioxide'. Returns ------- profile : ambient.Profile Returns an ambient.Profile object for manipulating ambient water column data in TAMOC. """ # Convert the data to standard units data, units = ambient.convert_units(data, units) # Create an empty netCDF4-classic datast to store this CTD data nc = ambient.create_nc_db(nc_name, summary, source, sea_name, p_lat, p_lon, p_time) # Put the CTD and current profile data into the ambient netCDF file nc = ambient.fill_nc_db(nc, data, labels, units, comments, 0) # Compute and insert the pressure data z = nc.variables['z'][:] T = nc.variables['temperature'][:] S = nc.variables['salinity'][:] P = ambient.compute_pressure(z, T, S, 0) P_data = np.vstack((z, P)).transpose() nc = ambient.fill_nc_db(nc, P_data, ['z', 'pressure'], ['m', 'Pa'], ['measured', 'computed'], 0) # Use this netCDF file to create an ambient object profile = ambient.Profile( nc, ztsp=['z', 'temperature', 'salinity', 'pressure', 'ua', 'va']) # Compute dissolved gas profiles to add to this dataset if len(ca) > 0: # Create a gas mixture object for air gases = ['nitrogen', 'oxygen', 'argon', 'carbon_dioxide'] air = dbm.FluidMixture(gases) yk = np.array([0.78084, 0.20946, 0.009340, 0.00036]) m = air.masses(yk) # Set atmospheric conditions Pa = 101325. # Compute the desired concentrations for i in range(len(ca)): # Initialize a dataset of concentration data conc = np.zeros(len(profile.z)) # Compute the concentrations at each depth for j in range(len(conc)): # Get the local water column properties T, S, P = profile.get_values( profile.z[j], ['temperature', 'salinity', 'pressure']) # Compute the gas solubility at this temperature and salinity # at the sea surface Cs = air.solubility(m, T, Pa, S)[0, :] # Adjust the solubility to the present depth Cs = Cs * seawater.density(T, S, P) / \ seawater.density(T, S, 101325.) # Extract the right chemical conc[j] = Cs[gases.index(ca[i])] # Add this computed dissolved gas to the Profile dataset data = np.vstack((profile.z, conc)).transpose() symbols = ['z', ca[i]] units = ['m', 'kg/m^3'] comments = ['measured', 'computed from CTD data'] profile.append(data, symbols, units, comments, 0) # Close the netCDF dataset profile.close_nc() # Return the profile object return profile
def get_lake_data(): """ Create the netCDF dataset of CTD data for a lake simulation Creates the ambient.Profile object and netCDF dataset of CTD data for a lake simualtion from the `./data/lake.dat` text file, digitized from the data in McGinnis et al. (2002) for Lake Hallwil. """ # Read in the lake CTD data fname = '../../tamoc/data/lake.dat' raw = np.loadtxt(fname, skiprows=9) variables = ['z', 'temperature', 'salinity', 'oxygen'] units = ['m', 'deg C', 'psu', 'kg/m^3'] # Convert the units to mks profile, units = ambient.convert_units(raw, units) # Calculate the pressure data P = ambient.compute_pressure(profile[:,0], profile[:,1], profile[:,2], 0) profile = np.hstack((profile, np.atleast_2d(P).transpose())) variables = variables + ['pressure'] units = units + ['Pa'] # Set up a netCDF dataset object summary = 'Default lake.dat dataset provided by TAMOC' source = 'Lake CTD data digitized from figures in McGinnis et al. 2004' sea_name = 'Lake Hallwil, Switzerland' lat = 47.277166666666666 lon = 8.217294444444445 date = datetime(2002, 7, 18) t_units = 'seconds since 1970-01-01 00:00:00 0:00' calendar = 'julian' time = date2num(date, units=t_units, calendar=calendar) nc = ambient.create_nc_db('../../test/output/lake.nc', summary, source, sea_name, lat, lon, time) # Insert the measured data comments = ['digitized from measured data'] * 4 comments = comments + ['computed from z, T, S'] nc = ambient.fill_nc_db(nc, profile, variables, units, comments, 0) # Insert an additional column with data for nitrogen and argon equal to # their saturation concentrations at the free surface. composition = ['nitrogen', 'oxygen', 'argon'] yk = np.array([0.78084, 0.209476, 0.009684]) air = dbm.FluidMixture(composition) m = air.masses(yk) Cs = air.solubility(m, profile[0,1], 101325., profile[0,2]) N2 = np.zeros((profile.shape[0], 1)) Ar = np.zeros((profile.shape[0], 1)) N2 = N2 + Cs[0,0] Ar = Ar + Cs[0,2] z = np.atleast_2d(profile[:,0]).transpose() comments = ['calculated potential saturation value']*3 nc = ambient.fill_nc_db(nc, np.hstack((z, N2, Ar)), ['z', 'nitrogen', 'argon'], ['m', 'kg/m^3', 'kg/m^3'], comments, 0) # Create an ambient.Profile object lake = ambient.Profile(nc, chem_names=['oxygen', 'nitrogen', 'argon']) lake.close_nc() # Return the Profile object return lake
calendar = 'julian') nc = ambient.create_nc_db(nc_file, summary, source, sea_name, p_lat, p_lon, p_time) # Insert the CTD data into the netCDF dataset comments = ['digitized', 'digitized'] nc = ambient.fill_nc_db(nc, C_profile, ['salinity', 'z'], C_units, comments, 1) nc = ambient.fill_nc_db(nc, T_profile, ['temperature', 'z'], T_units, comments, 1) # Calculate and insert the pressure data z = nc.variables['z'][:] T = nc.variables['temperature'][:] S = nc.variables['salinity'][:] P = ambient.compute_pressure(z, T, S, 0) P_data = np.vstack((z, P)).transpose() nc = ambient.fill_nc_db(nc, P_data, ['z', 'pressure'], ['m', 'Pa'], ['measured', 'computed'], 0) # Create an ambient.Profile object for this dataset ds = ambient.Profile(nc) # Close the netCDF dataset ds.nc.close() # Since the netCDF file is now fully stored on the hard drive in the # correct format, we can initialize an ambient.Profile object directly # from the netCDF file ds = ambient.Profile(nc_file, chem_names='all')
def get_lake_data(): """ Create the netCDF dataset of CTD data for a lake simulation Creates the ambient.Profile object and netCDF dataset of CTD data for a lake simualtion from the `./data/lake.dat` text file, digitized from the data in McGinnis et al. (2002) for Lake Hallwil. """ # Read in the lake CTD data fname = '../../tamoc/data/lake.dat' raw = np.loadtxt(fname, skiprows=9) variables = ['z', 'temperature', 'salinity', 'oxygen'] units = ['m', 'deg C', 'psu', 'kg/m^3'] # Convert the units to mks profile, units = ambient.convert_units(raw, units) # Calculate the pressure data P = ambient.compute_pressure(profile[:, 0], profile[:, 1], profile[:, 2], 0) profile = np.hstack((profile, np.atleast_2d(P).transpose())) variables = variables + ['pressure'] units = units + ['Pa'] # Set up a netCDF dataset object summary = 'Default lake.dat dataset provided by TAMOC' source = 'Lake CTD data digitized from figures in McGinnis et al. 2004' sea_name = 'Lake Hallwil, Switzerland' lat = 47.277166666666666 lon = 8.217294444444445 date = datetime(2002, 7, 18) t_units = 'seconds since 1970-01-01 00:00:00 0:00' calendar = 'julian' time = date2num(date, units=t_units, calendar=calendar) nc = ambient.create_nc_db('../../test/output/lake.nc', summary, source, sea_name, lat, lon, time) # Insert the measured data comments = ['digitized from measured data'] * 4 comments = comments + ['computed from z, T, S'] nc = ambient.fill_nc_db(nc, profile, variables, units, comments, 0) # Insert an additional column with data for nitrogen and argon equal to # their saturation concentrations at the free surface. composition = ['nitrogen', 'oxygen', 'argon'] yk = np.array([0.78084, 0.209476, 0.009684]) air = dbm.FluidMixture(composition) m = air.masses(yk) Cs = air.solubility(m, profile[0, 1], 101325., profile[0, 2]) N2 = np.zeros((profile.shape[0], 1)) Ar = np.zeros((profile.shape[0], 1)) N2 = N2 + Cs[0, 0] Ar = Ar + Cs[0, 2] z = np.atleast_2d(profile[:, 0]).transpose() comments = ['calculated potential saturation value'] * 3 nc = ambient.fill_nc_db(nc, np.hstack( (z, N2, Ar)), ['z', 'nitrogen', 'argon'], ['m', 'kg/m^3', 'kg/m^3'], comments, 0) # Create an ambient.Profile object lake = ambient.Profile(nc, chem_names=['oxygen', 'nitrogen', 'argon']) lake.close_nc() # Return the Profile object return lake