From af1390ea730084962fc02f25f2e48e223d665c1e Mon Sep 17 00:00:00 2001 From: Peter Isaac Date: Wed, 24 Jun 2015 09:01:20 +1000 Subject: [PATCH] Mods to some and some new ones. --- .ipynb_checkpoints/Untitled1-checkpoint.ipynb | 9 - .ipynb_checkpoints/aws2nc-checkpoint.ipynb | 10 +- L4_ipynb.txt | 259 +++ accessnc2xls.ipynb | 213 ++- aws2nc.ipynb | 10 +- aws_update.ipynb | 567 ++++++ basics.py | 3 + check_negative_Fre_values.ipynb | 264 +++ compare_DINGO.ipynb | 278 +++ compare_access_tower_daily_q.ipynb | 159 +- copy_ACCESS_to_daily.ipynb | 340 ++++ debug_timestepdrift.ipynb | 209 +++ nocturnal_Fc_negative_hour_histogram.ipynb | 168 ++ read_example.ipynb | 188 ++ respiration_LloydTaylor.ipynb | 538 ++++++ test.nc | Bin 539 -> 0 bytes test_L6_summary.ipynb | 302 +++ test_MergeSeriesUsingDict.ipynb | 171 ++ test_SMAP_output.ipynb | 350 ++++ test_VPD_gapfilling.ipynb | 136 ++ test_autoSOLO.ipynb | 200 ++ test_averageAWSto60minutes.ipynb | 165 ++ test_gfalternate.ipynb | 1643 +++++++++++++++++ test_lasslop.ipynb | 346 +++- test_opendap.ipynb | 1398 ++++++++++++++ test_plotcoveragelines.ipynb | 179 ++ test_split_gui.ipynb | 95 + test_ttk_python2.7.ipynb | 124 ++ wrangle_csats.ipynb | 285 +++ 29 files changed, 8413 insertions(+), 196 deletions(-) delete mode 100644 .ipynb_checkpoints/Untitled1-checkpoint.ipynb create mode 100644 L4_ipynb.txt create mode 100644 aws_update.ipynb create mode 100644 check_negative_Fre_values.ipynb create mode 100644 compare_DINGO.ipynb create mode 100644 copy_ACCESS_to_daily.ipynb create mode 100644 debug_timestepdrift.ipynb create mode 100644 nocturnal_Fc_negative_hour_histogram.ipynb create mode 100644 read_example.ipynb create mode 100644 respiration_LloydTaylor.ipynb delete mode 100644 test.nc create mode 100644 test_L6_summary.ipynb create mode 100644 test_MergeSeriesUsingDict.ipynb create mode 100644 test_SMAP_output.ipynb create mode 100644 test_VPD_gapfilling.ipynb create mode 100644 test_autoSOLO.ipynb create mode 100644 test_averageAWSto60minutes.ipynb create mode 100644 test_gfalternate.ipynb create mode 100644 test_opendap.ipynb create mode 100644 test_plotcoveragelines.ipynb create mode 100644 test_split_gui.ipynb create mode 100644 test_ttk_python2.7.ipynb create mode 100644 wrangle_csats.ipynb diff --git a/.ipynb_checkpoints/Untitled1-checkpoint.ipynb b/.ipynb_checkpoints/Untitled1-checkpoint.ipynb deleted file mode 100644 index 9574ba0..0000000 --- a/.ipynb_checkpoints/Untitled1-checkpoint.ipynb +++ /dev/null @@ -1,9 +0,0 @@ -{ - "metadata": { - "name": "", - "signature": "sha256:12c0066c4bb390438a3270b1cd9acb16c159e1c9efad94f2a630ed2e8a0237d1" - }, - "nbformat": 3, - "nbformat_minor": 0, - "worksheets": [] -} \ No newline at end of file diff --git a/.ipynb_checkpoints/aws2nc-checkpoint.ipynb b/.ipynb_checkpoints/aws2nc-checkpoint.ipynb index 527e89e..bdd7c9d 100644 --- a/.ipynb_checkpoints/aws2nc-checkpoint.ipynb +++ b/.ipynb_checkpoints/aws2nc-checkpoint.ipynb @@ -1,7 +1,7 @@ { "metadata": { "name": "", - "signature": "sha256:2ba45e8206638f2fb61a97b321ecb211c4d71d4658c88215f55eabf8bcf8778d" + "signature": "sha256:adba59372f724bc695b58c9251a05f1e4ef852ad2a8a8a2a227e9ca07b7b74f0" }, "nbformat": 3, "nbformat_minor": 0, @@ -26,7 +26,7 @@ "cell_type": "code", "collapsed": false, "input": [ - "xlname = \"../../AWS/Locations/AWS_Locations.xls\"\n", + "xlname = \"../../BoM/Locations/AWS_Locations.xls\"\n", "wb = xlrd.open_workbook(xlname)\n", "sheet = wb.sheet_by_name(\"OzFlux\")\n", "xl_row = 10\n", @@ -56,7 +56,7 @@ "cell_type": "code", "collapsed": false, "input": [ - "in_path = \"../../AWS/30MinuteMeteorology/\"\n", + "in_path = \"../../BoM/AWS/Current/\"\n", "in_filename = in_path+\"HM01X_Data*.txt\"\n", "file_list = sorted(glob.glob(in_filename))" ], @@ -149,12 +149,12 @@ " attr=qcutils.MakeAttributeDictionary(long_name='Wind direction',units='degT')\n", " qcutils.CreateSeries(ds,'Wd',data_dict[bom_id][:,11],Flag=flag,Attr=attr)\n", " attr=qcutils.MakeAttributeDictionary(long_name='Wind gust',units='m/s')\n", - " qcutils.CreateSeries(ds,'Wd',data_dict[bom_id][:,12],Flag=flag,Attr=attr)\n", + " qcutils.CreateSeries(ds,'Wg',data_dict[bom_id][:,12],Flag=flag,Attr=attr)\n", " data_dict[bom_id][:,13] = data_dict[bom_id][:,13]/float(10)\n", " attr=qcutils.MakeAttributeDictionary(long_name='Air Pressure',units='kPa')\n", " qcutils.CreateSeries(ds,'ps',data_dict[bom_id][:,13],Flag=flag,Attr=attr)\n", " # now interpolate\n", - " for label in [\"Precip\",\"Ta\",\"Td\",\"RH\",\"Ws\",\"Wd\",\"ps\"]:\n", + " for label in [\"Precip\",\"Ta\",\"Td\",\"RH\",\"Ws\",\"Wd\",\"Wg\",\"ps\"]:\n", " qcts.InterpolateOverMissing(ds,series=label,maxlen=2)\n", " # put this stations data into the data structure dictionary\n", " ds_dict[bom_id] = ds" diff --git a/L4_ipynb.txt b/L4_ipynb.txt new file mode 100644 index 0000000..659966f --- /dev/null +++ b/L4_ipynb.txt @@ -0,0 +1,259 @@ +[Files] + file_path = ../../Sites/SturtPlains/Data/Processed/all/ + in_filename = SturtPlains_2008_to_2014_L3.nc + out_filename = SturtPlains_2008_to_2014_L4.nc + plot_path = ../plots/ + +[Output] + # uncomment the xl and nc lists to output specific variables + #xl = "['Ah','Cc','Fa','Fc','Fe','Fg','Fh','Fld','Flu','Fm','Fn','Fsd','Fsu','ps','RH','Sws','Ta','Ts','ustar','Ws','Wd']" + #nc = "['Ah','Cc','eta','EVI','Fa','Fc','Fc_storage','Fe','Fg','Fh','Fld','Flu','Fm','Fn','Fsd','Fsu','Precip','ps','q','RH','Sws','SHD','Ta','theta','Ts','ustar','Ws','Wd']" + +[Options] + UseExistingOutFile = No + +[Drivers] + [[Ah]] + [[[GapFillFromAlternate]]] + [[[[Ah_aws]]]] + source = "AWS" + file_name = ../../Sites/SturtPlains/Data/AWS/SturtPlains_AWS.nc + [[[[Ah_access]]]] + source = "ACCESS" + file_name = ../../Sites/SturtPlains/Data/ACCESS/SturtPlains_ACCESS.nc + [[[[Ah_bios2]]]] + source = "BIOS2" + file_name = ../../Sites/SturtPlains/Data/BIOS2/SturtPlains_BIOS2.nc + [[[GapFillFromClimatology]]] + [[[[Ah_cli]]]] + file_name = ../../Sites/SturtPlains/Data/Processed/all/SturtPlains_2008_to_2014_L3_Climatology.xls + method = "interpolated daily" + [[[MergeSeries]]] + Source = "['Ah','Ah_aws','Ah_access','Ah_bios2','Ah_cli']" + [[Cc]] + [[[GapFillFromClimatology]]] + [[[[Cc_cli]]]] + file_name = ../../Sites/SturtPlains/Data/Processed/all/SturtPlains_2008_to_2014_L3_Climatology.xls + method = "interpolated daily" + [[[MergeSeries]]] + Source = "['Cc','Cc_cli']" + [[Fa]] + [[[RangeCheck]]] + Lower = "[-150]*12" + Upper = "[850]*12" + [[[GapFillFromAlternate]]] + [[[[Fa_acc]]]] + source = "ACCESS" + file_name = ../../Sites/SturtPlains/Data/ACCESS/SturtPlains_ACCESS.nc + [[[[Fa_bios]]]] + source = "BIOS2" + file_name = ../../Sites/SturtPlains/Data/BIOS2/SturtPlains_BIOS2.nc + [[[GapFillFromClimatology]]] + [[[[Fa_cli]]]] + file_name = ../../Sites/SturtPlains/Data/Processed/all/SturtPlains_2008_to_2014_L3_Climatology.xls + method = "interpolated daily" + [[[MergeSeries]]] + Source = "['Fa','Fa_acc','Fa_bios','Fa_cli']" + [[Fg]] + [[[GapFillFromAlternate]]] + [[[[Fg_acc]]]] + source = "ACCESS" + file_name = ../../Sites/SturtPlains/Data/ACCESS/SturtPlains_ACCESS.nc + [[[[Fg_bios]]]] + source = "BIOS2" + file_name = ../../Sites/SturtPlains/Data/BIOS2/SturtPlains_BIOS2.nc + [[[GapFillFromClimatology]]] + [[[[Fg_cli]]]] + file_name = ../../Sites/SturtPlains/Data/Processed/all/SturtPlains_2008_to_2014_L3_Climatology.xls + method = "interpolated daily" + [[[MergeSeries]]] + Source = "['Fg','Fg_acc','Fg_bios','Fg_cli']" + [[Fld]] + [[[GapFillFromAlternate]]] + [[[[Fld_acc]]]] + source = "ACCESS" + file_name = ../../Sites/SturtPlains/Data/ACCESS/SturtPlains_ACCESS.nc + [[[[Fld_bios]]]] + source = "BIOS2" + file_name = ../../Sites/SturtPlains/Data/BIOS2/SturtPlains_BIOS2.nc + [[[GapFillFromClimatology]]] + [[[[Fld_cli]]]] + file_name = ../../Sites/SturtPlains/Data/Processed/all/SturtPlains_2008_to_2014_L3_Climatology.xls + method = "interpolated daily" + [[[MergeSeries]]] + Source = "['Fld','Fld_acc','Fld_bios','Fld_cli']" + [[Flu]] + [[[GapFillFromAlternate]]] + [[[[Flu_acc]]]] + source = "ACCESS" + file_name = ../../Sites/SturtPlains/Data/ACCESS/SturtPlains_ACCESS.nc + [[[[Flu_bios]]]] + source = "BIOS2" + file_name = ../../Sites/SturtPlains/Data/BIOS2/SturtPlains_BIOS2.nc + [[[GapFillFromClimatology]]] + [[[[Flu_cli]]]] + file_name = ../../Sites/SturtPlains/Data/Processed/all/SturtPlains_2008_to_2014_L3_Climatology.xls + method = "interpolated daily" + [[[MergeSeries]]] + Source = "['Flu','Flu_acc','Flu_bios','Flu_cli']" + [[Fn]] + [[[GapFillFromAlternate]]] + [[[[Fn_acc]]]] + source = "ACCESS" + file_name = ../../Sites/SturtPlains/Data/ACCESS/SturtPlains_ACCESS.nc + [[[[Fn_bios]]]] + source = "BIOS2" + file_name = ../../Sites/SturtPlains/Data/BIOS2/SturtPlains_BIOS2.nc + [[[GapFillFromClimatology]]] + [[[[Fn_cli]]]] + file_name = ../../Sites/SturtPlains/Data/Processed/all/SturtPlains_2008_to_2014_L3_Climatology.xls + method = "interpolated daily" + [[[MergeSeries]]] + Source = "['Fn','Fn_acc','Fn_bios','Fn_cli']" + [[Fsd]] + [[[ExcludeDates]]] + 0 = "['2011-09-19 00:00','2011-09-28 00:00']" + [[[GapFillFromAlternate]]] + [[[[Fsd_acc]]]] + source = "ACCESS" + file_name = ../../Sites/SturtPlains/Data/ACCESS/SturtPlains_ACCESS.nc + [[[[Fsd_bios]]]] + source = "BIOS2" + file_name = ../../Sites/SturtPlains/Data/BIOS2/SturtPlains_BIOS2.nc + [[[GapFillFromClimatology]]] + [[[[Fsd_cli]]]] + file_name = ../../Sites/SturtPlains/Data/Processed/all/SturtPlains_2008_to_2014_L3_Climatology.xls + method = "interpolated daily" + [[[MergeSeries]]] + Source = "['Fsd','Fsd_acc','Fsd_bios','Fsd_cli']" + [[Fsu]] + [[[ExcludeDates]]] + 0 = "['2011-09-19 00:00','2011-09-28 00:00']" + [[[GapFillFromAlternate]]] + [[[[Fsu_acc]]]] + source = "ACCESS" + file_name = ../../Sites/SturtPlains/Data/ACCESS/SturtPlains_ACCESS.nc + [[[[Fsu_bios]]]] + source = "BIOS2" + file_name = ../../Sites/SturtPlains/Data/BIOS2/SturtPlains_BIOS2.nc + [[[GapFillFromClimatology]]] + [[[[Fsu_cli]]]] + file_name = ../../Sites/SturtPlains/Data/Processed/all/SturtPlains_2008_to_2014_L3_Climatology.xls + method = "interpolated daily" + [[[MergeSeries]]] + Source = "['Fsu','Fsu_acc','Fsu_bios','Fsu_cli']" + [[ps]] + [[[GapFillFromAlternate]]] + [[[[ps_aws]]]] + source = "AWS" + file_name = ../../Sites/SturtPlains/Data/AWS/SturtPlains_AWS.nc + [[[GapFillFromClimatology]]] + [[[[ps_cli]]]] + file_name = ../../Sites/SturtPlains/Data/Processed/all/SturtPlains_2008_to_2014_L3_Climatology.xls + method = "interpolated daily" + [[[MergeSeries]]] + Source = "['ps','ps_aws','ps_cli']" + [[Sws]] + [[[GapFillFromAlternate]]] + [[[[Sws_acc]]]] + source = "ACCESS" + file_name = ../../Sites/SturtPlains/Data/ACCESS/SturtPlains_ACCESS.nc + fit = "replace" + lag = "no" + [[[[Sws_bios]]]] + source = "BIOS2" + file_name = ../../Sites/SturtPlains/Data/BIOS2/SturtPlains_BIOS2.nc + fit = "replace" + lag = "no" + [[[MergeSeries]]] + Source = "['Sws','Sws_acc','Sws_bios']" + [[Ta]] + [[[GapFillFromAlternate]]] + [[[[Ta_aws]]]] + source = "AWS" + file_name = ../../Sites/SturtPlains/Data/AWS/SturtPlains_AWS.nc + [[[GapFillFromClimatology]]] + [[[[Ta_cli]]]] + file_name = ../../Sites/SturtPlains/Data/Processed/all/SturtPlains_2008_to_2014_L3_Climatology.xls + method = "interpolated daily" + [[[MergeSeries]]] + Source = "['Ta','Ta_aws','Ta_cli']" + [[Ts]] + [[[GapFillFromAlternate]]] + [[[[Ts_acc]]]] + source = "ACCESS" + file_name = ../../Sites/SturtPlains/Data/ACCESS/SturtPlains_ACCESS.nc + [[[[Ts_bios]]]] + source = "BIOS2" + file_name = ../../Sites/SturtPlains/Data/BIOS2/SturtPlains_BIOS2.nc + [[[GapFillFromClimatology]]] + [[[[Ts_cli]]]] + file_name = ../../Sites/SturtPlains/Data/Processed/all/SturtPlains_2008_to_2014_L3_Climatology.xls + method = "interpolated daily" + [[[MergeSeries]]] + Source = "['Ts','Ts_acc','Ts_bios','Ts_cli']" + [[Ws]] + [[[GapFillFromAlternate]]] + [[[[Ws_aws]]]] + source = "AWS" + file_name = ../../Sites/SturtPlains/Data/AWS/SturtPlains_AWS.nc + fit = "replace" + lag = "no" + [[[GapFillFromClimatology]]] + [[[[Ws_cli]]]] + file_name = ../../Sites/SturtPlains/Data/Processed/all/SturtPlains_2008_to_2014_L3_Climatology.xls + method = "interpolated daily" + [[[MergeSeries]]] + Source = "['Ws','Ws_aws','Ws_cli']" + [[Wd]] + [[[GapFillFromAlternate]]] + [[[[Wd_aws]]]] + source = "AWS" + file_name = ../../Sites/SturtPlains/Data/AWS/SturtPlains_AWS.nc + fit = "replace" + lag = "no" + [[[GapFillFromClimatology]]] + [[[[Wd_cli]]]] + file_name = ../../Sites/SturtPlains/Data/Processed/all/SturtPlains_2008_to_2014_L3_Climatology.xls + method = "interpolated daily" + [[[MergeSeries]]] + Source = "['Wd','Wd_aws','Wd_cli']" + [[Precip]] + [[[GapFillFromAlternate]]] + [[[[Precip_aws]]]] + source = "AWS" + file_name = ../../Sites/SturtPlains/Data/AWS/SturtPlains_AWS.nc + fit = "replace" + lag = "no" + [[[[Precip_bios]]]] + source = "BIOS2" + file_name = ../../Sites/SturtPlains/Data/BIOS2/SturtPlains_BIOS2.nc + fit = "replace" + lag = "no" + [[[MergeSeries]]] + Source = "['Precip','Precip_aws','Precip_bios']" + [[[RangeCheck]]] + Lower = "[0]*12" + Upper = "[50]*12" + +[Plots] + [[1]] + Title = "Radiative fluxes" + Variables = "['Fsd','Fsu','Fld','Flu','Fn']" + [[2]] + Title = "Meteorology" + Variables = "['Ta','Ah','Cc','Ws','Wd','ps']" + [[3]] + Title = "Soil temperature, water content and heat flux" + Variables = "['Precip','Sws','Ts','Fg']" + +[Alternate_Summary] + [[1]] + Title = "Radiation" + Variables = "['Fsd_acc','Fld_acc','Fn_acc','Fa_acc']" + [[2]] + Title = "Meteorology" + Variables = "['Ta_aws','Ah_aws','Ws_aws','ps_aws']" + [[3]] + Title = "Soil" + Variables = "['Ts_acc','Sws_acc','Fg_acc','Precip_aws']" diff --git a/accessnc2xls.ipynb b/accessnc2xls.ipynb index 6706958..7137358 100644 --- a/accessnc2xls.ipynb +++ b/accessnc2xls.ipynb @@ -1,76 +1,171 @@ { "metadata": { - "name": "accessnc2xls" - }, - "nbformat": 2, + "name": "", + "signature": "sha256:6ce34a3d061e2b1f4dbbe2896281f42c3c3260e38da52b3bc4ab60e065d8ad2a" + }, + "nbformat": 3, + "nbformat_minor": 0, "worksheets": [ { "cells": [ { - "cell_type": "code", - "collapsed": true, + "cell_type": "code", + "collapsed": true, "input": [ - "import glob", - "from netCDF4 import Dataset", - "import qcio", - "import qcutils" - ], - "language": "python", - "outputs": [], + "%run basics\n", + "import glob\n", + "import pytz" + ], + "language": "python", + "metadata": {}, + "outputs": [], "prompt_number": 1 - }, + }, { - "cell_type": "code", - "collapsed": true, + "cell_type": "code", + "collapsed": false, + "input": [ + "infilename = qcio.get_filename_dialog(path=\"../../ACCESS\")\n", + "xlfilename= infilename.replace('.nc','.xls')" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 2 + }, + { + "cell_type": "code", + "collapsed": true, + "input": [ + "ds_60minutes = qcio.DataStructure()\n", + "ncFile = netCDF4.Dataset(infilename)\n", + "nRecs = len(ncFile.dimensions[\"time\"])\n", + "for attr in ncFile.ncattrs():\n", + " ds_60minutes.globalattributes[attr] = getattr(ncFile,attr)\n", + "ds_60minutes.globalattributes[\"xl_datemode\"] = str(0)\n", + "ds_60minutes.globalattributes[\"nc_nrecs\"] = str(nRecs)\n", + "flag_60minutes = numpy.zeros(nRecs)\n", + "item_list=[item for item in ncFile.variables.keys() if \"time\" in ncFile.variables[item].dimensions]\n", + "for label in item_list:\n", + " attr = {}\n", + " for this_attr in ncFile.variables[label].ncattrs():\n", + " attr[this_attr] = getattr(ncFile.variables[label],this_attr)\n", + " var_dim_list = list(ncFile.variables[label].dimensions)\n", + " if len(var_dim_list)==1:\n", + " # only the \"time\" dimension\n", + " series = ncFile.variables[label][:]\n", + " qcutils.CreateSeries(ds_60minutes,label,series,Flag=flag_60minutes,Attr=attr)\n", + " if len(var_dim_list)==3:\n", + " var_dim_list.remove(\"time\")\n", + " for i in range(0,len(ncFile.dimensions[var_dim_list[0]])):\n", + " for j in range(0,len(ncFile.dimensions[var_dim_list[1]])):\n", + " label_ij = label+'_'+str(i)+str(j)\n", + " series = ncFile.variables[label][:,i,j]\n", + " qcutils.CreateSeries(ds_60minutes,label_ij,series,Flag=flag_60minutes,Attr=attr)\n", + "# if len(var_dim_list)==4:\n", + "# var_dim_list.remove(\"time\")\n", + "# for i in range(0,len(ncFile.dimensions[var_dim_list[0]])):\n", + "# for j in range(0,len(ncFile.dimensions[var_dim_list[1]])):\n", + "# for k in range(0,len(ncFile.dimensions[var_dim_list[2]])):\n", + "# label_ijk = label+'_'+str(i)+str(j)+str(k)\n", + "# series = ncFile.variables[label][:,k,i,j]\n", + "# qcutils.CreateSeries(ds_60minutes,label_ijk,series,Flag=flag_60minutes,Attr=attr)\n", + "# do some datetime things\n", + "valid_date = ncFile.variables[\"valid_date\"][:]\n", + "valid_time = ncFile.variables[\"valid_time\"][:]\n", + "#ncFile.close()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 3 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# trap valid_date==0 occurrences, these happened in some of the files produced\n", + "# in the second batch while the accum_prcp was being sorted out\n", + "index = numpy.where(valid_date==0)[0]\n", + "# if there are some valid_date==0 then replace them with the correct date\n", + "if len(index)!=0:\n", + " for i in index:\n", + " dt = datetime.datetime.strptime(str(int(valid_date[i-1])),\"%Y%m%d\")\n", + " dt = dt+datetime.timedelta(days=1)\n", + " valid_date[i] = datetime.datetime.strftime(dt,\"%Y%m%d\")\n", + "print \"Finished replacing valid_date when 0\"\n", + "dt_utc_60minutes=[datetime.datetime.strptime(str(int(valid_date[i])*10000+int(valid_time[i])),\"%Y%m%d%H%M\") for i in range(0,len(valid_date))]\n", + "# make utc_dt timezone aware\n", + "dt_utc_60minutes=[x.replace(tzinfo=pytz.utc) for x in dt_utc_60minutes]\n", + "# get local time from UTC\n", + "print \"Getting the local time from UTC\"\n", + "site_name = ds_60minutes.globalattributes[\"site_name\"]\n", + "print site_name\n", + "site_timezone = c.tz_dict[site_name.lower().replace(\" \",\"\").replace(\"_\",\"\")]\n", + "print site_timezone\n", + "site_tz = pytz.timezone(site_timezone)\n", + "print \"Got pytz timezone\"\n", + "dt_loc_60minutes=[x.astimezone(site_tz) for x in dt_utc_60minutes]\n", + "print \"Finished getting local time\"\n", + "# NOTE: will have to disable daylight saving at some stage, towers stay on Standard Time\n", + "# PRI hopes that the following line will do this ...\n", + "dt_loc_60minutes=[x-x.dst() for x in dt_loc_60minutes]\n", + "print \"Disabled daylight saving\"\n", + "# make local time timezone naive to match datetimes in OzFluxQC\n", + "dt_loc_60minutes=[x.replace(tzinfo=None) for x in dt_loc_60minutes]\n", + "print \"Made local time timezone naive\"\n", + "ds_60minutes.series[\"DateTime\"] = {}\n", + "ds_60minutes.series[\"DateTime\"][\"Data\"] = dt_loc_60minutes\n", + "print \"Added local datetime to data structure\"\n", + "# get the year, month etc from the datetime\n", + "flag_60minutes = numpy.zeros(nRecs,dtype=numpy.int32)\n", + "ds_60minutes.series[\"DateTime\"][\"Flag\"] = flag_60minutes\n", + "qcutils.get_xldatefromdatetime(ds_60minutes)\n", + "print \"Got the xlDateTime\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Finished replacing valid_date when 0\n", + "Getting the local time from UTC\n", + "Alice Springs Mulga\n", + "Australia/Darwin\n", + "Got pytz timezone\n", + "Finished getting local time\n", + "Disabled daylight saving\n", + "Made local time timezone naive\n", + "Added local datetime to data structure\n", + "Got the xlDateTime\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "code", + "collapsed": true, "input": [ - "infilename = qcio.get_filename_dialog()", - "xlfilename= infilename.replace('.nc','.xls')", - "ds_60minutes = qcio.DataStructure()", - "ncFile = Dataset(infilename)", - "nRecs = len(ncFile.dimensions[\"time\"])", - "for attr in ncFile.ncattrs():", - " ds_60minutes.globalattributes[attr] = getattr(ncFile,attr)", - "flag_60minutes = numpy.zeros(nRecs)", - "item_list=[item for item in ncFile.variables.keys() if \"time\" in ncFile.variables[item].dimensions]", - "for label in item_list:", - " attr = {}", - " for this_attr in ncFile.variables[label].ncattrs():", - " attr[this_attr] = getattr(ncFile.variables[label],this_attr)", - " var_dim_list = list(ncFile.variables[label].dimensions)", - " if len(var_dim_list)==1:", - " # only the \"time\" dimension", - " series = ncFile.variables[label][:]", - " qcutils.CreateSeries(ds_60minutes,label,series,Flag=flag_60minutes,Attr=attr)", - " if len(var_dim_list)==3:", - " var_dim_list.remove(\"time\")", - " for i in range(0,len(ncFile.dimensions[var_dim_list[0]])):", - " for j in range(0,len(ncFile.dimensions[var_dim_list[1]])):", - " label_ij = label+'_'+str(i)+str(j)", - " series = ncFile.variables[label][:,i,j]", - " qcutils.CreateSeries(ds_60minutes,label_ij,series,Flag=flag_60minutes,Attr=attr)", - "# if len(var_dim_list)==4:", - "# var_dim_list.remove(\"time\")", - "# for i in range(0,len(ncFile.dimensions[var_dim_list[0]])):", - "# for j in range(0,len(ncFile.dimensions[var_dim_list[1]])):", - "# for k in range(0,len(ncFile.dimensions[var_dim_list[2]])):", - "# label_ijk = label+'_'+str(i)+str(j)+str(k)", - "# series = ncFile.variables[label][:,k,i,j]", - "# qcutils.CreateSeries(ds_60minutes,label_ijk,series,Flag=flag_60minutes,Attr=attr)", - "", "qcio.xl_write_series(ds_60minutes, xlfilename, outputlist=None)" - ], - "language": "python", - "outputs": [], - "prompt_number": 5 - }, + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 8 + }, { - "cell_type": "code", - "collapsed": true, - "input": [], - "language": "python", + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, "outputs": [] } - ] + ], + "metadata": {} } ] } \ No newline at end of file diff --git a/aws2nc.ipynb b/aws2nc.ipynb index 527e89e..bdd7c9d 100644 --- a/aws2nc.ipynb +++ b/aws2nc.ipynb @@ -1,7 +1,7 @@ { "metadata": { "name": "", - "signature": "sha256:2ba45e8206638f2fb61a97b321ecb211c4d71d4658c88215f55eabf8bcf8778d" + "signature": "sha256:adba59372f724bc695b58c9251a05f1e4ef852ad2a8a8a2a227e9ca07b7b74f0" }, "nbformat": 3, "nbformat_minor": 0, @@ -26,7 +26,7 @@ "cell_type": "code", "collapsed": false, "input": [ - "xlname = \"../../AWS/Locations/AWS_Locations.xls\"\n", + "xlname = \"../../BoM/Locations/AWS_Locations.xls\"\n", "wb = xlrd.open_workbook(xlname)\n", "sheet = wb.sheet_by_name(\"OzFlux\")\n", "xl_row = 10\n", @@ -56,7 +56,7 @@ "cell_type": "code", "collapsed": false, "input": [ - "in_path = \"../../AWS/30MinuteMeteorology/\"\n", + "in_path = \"../../BoM/AWS/Current/\"\n", "in_filename = in_path+\"HM01X_Data*.txt\"\n", "file_list = sorted(glob.glob(in_filename))" ], @@ -149,12 +149,12 @@ " attr=qcutils.MakeAttributeDictionary(long_name='Wind direction',units='degT')\n", " qcutils.CreateSeries(ds,'Wd',data_dict[bom_id][:,11],Flag=flag,Attr=attr)\n", " attr=qcutils.MakeAttributeDictionary(long_name='Wind gust',units='m/s')\n", - " qcutils.CreateSeries(ds,'Wd',data_dict[bom_id][:,12],Flag=flag,Attr=attr)\n", + " qcutils.CreateSeries(ds,'Wg',data_dict[bom_id][:,12],Flag=flag,Attr=attr)\n", " data_dict[bom_id][:,13] = data_dict[bom_id][:,13]/float(10)\n", " attr=qcutils.MakeAttributeDictionary(long_name='Air Pressure',units='kPa')\n", " qcutils.CreateSeries(ds,'ps',data_dict[bom_id][:,13],Flag=flag,Attr=attr)\n", " # now interpolate\n", - " for label in [\"Precip\",\"Ta\",\"Td\",\"RH\",\"Ws\",\"Wd\",\"ps\"]:\n", + " for label in [\"Precip\",\"Ta\",\"Td\",\"RH\",\"Ws\",\"Wd\",\"Wg\",\"ps\"]:\n", " qcts.InterpolateOverMissing(ds,series=label,maxlen=2)\n", " # put this stations data into the data structure dictionary\n", " ds_dict[bom_id] = ds" diff --git a/aws_update.ipynb b/aws_update.ipynb new file mode 100644 index 0000000..1f217c5 --- /dev/null +++ b/aws_update.ipynb @@ -0,0 +1,567 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:066c2a2d804a7899c8209f180cca66f7b75355aa7fdf4e20b4903f84a2f79507" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "code", + "collapsed": false, + "input": [ + "%run basics\n", + "import glob\n", + "import ntpath" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 1 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "cf = qcio.load_controlfile(path=\"../controlfiles\")" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 2 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "base_pattern = \"HM01X_Data*.txt\"\n", + "in_file_pattern = cf[\"Files\"][\"In\"][\"file_path\"]+base_pattern\n", + "in_file_list = sorted(glob.glob(in_file_pattern))\n", + "for in_filename in in_file_list:\n", + " p = ntpath.basename(in_filename).split(\"_\")\n", + " out_filename = cf[\"Files\"][\"Out\"][\"file_path\"]+p[0]+\"_\"+p[1]+\"_\"+p[2]+\".csv\"\n", + " # open the output file\n", + " out_file = open(out_filename,\"a\")\n", + " # open the first input file and append\n", + " print \"Adding contents of \"+in_filename+\" to \"+out_filename\n", + " for line in open(in_filename):\n", + " out_file.write(line)\n", + " # now loop over the folders containing the files to be appended\n", + " add_path_list = [cf[\"Files\"][\"Add\"][i] for i in cf[\"Files\"][\"Add\"].keys()]\n", + " bom_id = in_filename.split(\"_\")[2]\n", + " for add_path in add_path_list:\n", + " # build the file name\n", + " add_filepattern = add_path+\"HM01X_Data_\"+bom_id+\"*.txt\"\n", + " add_filename_list = sorted(glob.glob(add_filepattern))\n", + " for add_filename in add_filename_list:\n", + " #print \"Appending contents of \"+add_filename+\" to \"+out_filename\n", + " add_file = open(add_filename)\n", + " add_file.next()\n", + " for line in add_file:\n", + " out_file.write(line)\n", + " add_file.close()\n", + " out_file.close()" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_005008_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_005008.csv\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_007176_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_007176.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_007185_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_007185.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_009053_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_009053.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_009178_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_009178.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_009214_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_009214.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_012038_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_012038.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_012320_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_012320.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_014015_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_014015.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_014041_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_014041.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_014046_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_014046.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_014272_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_014272.csv\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_014626_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_014626.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_014901_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_014901.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_014932_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_014932.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_014949_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_014949.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_014954_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_014954.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_015590_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_015590.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_015643_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_015643.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_024024_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_024024.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_024048_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_024048.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_031011_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_031011.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_031037_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_031037.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_031209_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_031209.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_031210_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_031210.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_032040_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_032040.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_033002_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_033002.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_033307_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_033307.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_035129_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_035129.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_035139_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_035139.csv\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_035264_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_035264.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_040004_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_040004.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_040082_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_040082.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_040211_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_040211.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_040913_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_040913.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_041529_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_041529.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_067105_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_067105.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_067108_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_067108.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_067113_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_067113.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_067119_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_067119.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_070349_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_070349.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_071032_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_071032.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_071075_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_071075.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_072161_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_072161.csv\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_072162_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_072162.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_076031_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_076031.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_081049_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_081049.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_081125_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_081125.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_083055_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_083055.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_083084_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_083084.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_083085_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_083085.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_086282_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_086282.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_088051_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_088051.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_088109_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_088109.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_088162_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_088162.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_089002_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_089002.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_090175_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_090175.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_090176_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_090176.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_090186_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_090186.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_094191_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_094191.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_094220_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_094220.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_097024_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_097024.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Adding contents of ../../BoM/AWS/Historic/HM01X_Data_097083_999999998179626.txt to ../../BoM/AWS/Current/HM01X_Data_097083.csv" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/basics.py b/basics.py index 4785142..f471fc0 100644 --- a/basics.py +++ b/basics.py @@ -3,10 +3,13 @@ sys.path.append('../scripts') import constants as c import datetime +import dateutil import matplotlib.pyplot as plt import meteorologicalfunctions as mf import netCDF4 import numpy +import qcck +import qcgf import qcio import qcts import qcutils diff --git a/check_negative_Fre_values.ipynb b/check_negative_Fre_values.ipynb new file mode 100644 index 0000000..c0fc287 --- /dev/null +++ b/check_negative_Fre_values.ipynb @@ -0,0 +1,264 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:96329606c9dc2f4f5b6ee4d1d8e92a1225dc01a7a15a1f6081e30face9a92145" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "code", + "collapsed": false, + "input": [ + "%run basics\n", + "import pysolar" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 1 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# get the netCDF file name\n", + "ncname = qcio.get_filename_dialog(path=\"../../Sites\")" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 2 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# read the netCDF file contents into the data structure\n", + "ds = qcio.nc_read_series(ncname)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 3 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# calculate the synthetic incoming shortwave radiation\n", + "qcts.get_synthetic_fsd(ds)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 4 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# get the necessary data from the data structure\n", + "dt = ds.series[\"DateTime\"][\"Data\"]\n", + "Fsd,f,a = qcutils.GetSeriesasMA(ds,\"Fsd\")\n", + "Fsd_syn,f,a = qcutils.GetSeriesasMA(ds,\"Fsd_syn\")\n", + "Fsd_filtered,f,a = qcutils.GetSeriesasMA(ds,\"Fsd_filtered\")\n", + "Fc,f,a = qcutils.GetSeriesasMA(ds,\"Fc\")\n", + "ustar,f,a = qcutils.GetSeriesasMA(ds,\"ustar\")\n", + "Hour,f,a = qcutils.GetSeriesasMA(ds,\"Hour\")\n", + "sa,f,a = qcutils.GetSeriesasMA(ds,\"solar_altitude\")" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 4 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "fig=plt.figure()\n", + "plt.plot(dt,sa,'b.')\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "display_data", + "png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEACAYAAAC08h1NAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nZ1IDfy211FLLOpMa+GuppZZa1pn8/7ZRAkrLcj+oAAAAAElFTkSuQmCC\n", + "text": [ + "" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# plot a figure of the observed and synthetic incoming shortwave radiation\n", + "fig=plt.figure()\n", + "plt.plot(dt,Fsd,'b.')\n", + "plt.plot(dt,Fsd_syn,'ro')\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "display_data", + "png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAEACAYAAAC9Gb03AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSUVORK5CYII=\n", + "text": [ + "" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# first, filter using Fsd and ustar only\n", + "index = numpy.ma.where((Fsd<10)&(ustar>0.25))[0]\n", + "ldt = [dt[i] for i in index]\n", + "Fc_nu = Fc[index]\n", + "Hour_nu = Hour[index]\n", + "q = numpy.percentile(Fc[index],[2.5,97.5])\n", + "print q\n", + "Fc_nuq = numpy.ma.masked_where((Fc_nuq[1]),Fc_nu)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "[-1.47454549 6.99107132]\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# and plot the results\n", + "fig=plt.figure()\n", + "plt.subplot(211)\n", + "plt.plot(ldt,Fc_nu,'b.')\n", + "plt.plot(ldt,Fc_nuq,'r+')\n", + "plt.subplot(212)\n", + "plt.plot(ldt,Hour_nu,'ro')\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "display_data", + "png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEACAYAAACj0I2EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text": [ + "" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# now filter using Fsd, Fsd_syn and ustar\n", + "index = numpy.ma.where((Fsd<10)&(Fsd_syn<10)&(ustar>0.25))[0]\n", + "ldt = [dt[i] for i in index]\n", + "Fc_nu = Fc[index]\n", + "Hour_nu = Hour[index]\n", + "q = numpy.percentile(Fc[index],[2.5,97.5])\n", + "print q\n", + "Fc_nuq = numpy.ma.masked_where((Fc_nuq[1]),Fc_nu)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "[-1.48893422 6.96937251]\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# and plot the results\n", + "fig=plt.figure()\n", + "plt.subplot(211)\n", + "plt.plot(ldt,Fc_nu,'b.')\n", + "plt.plot(ldt,Fc_nuq,'r+')\n", + "plt.subplot(212)\n", + "plt.plot(ldt,Hour_nu,'ro')\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "display_data", + "png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEACAYAAACj0I2EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYII=\n", + "text": [ + "" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "fig=plt.figure()\n", + "plt.plot(dt,Fsd_filtered,'b.')\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "display_data", + "png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEACAYAAAC08h1NAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text": [ + "" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/compare_DINGO.ipynb b/compare_DINGO.ipynb new file mode 100644 index 0000000..318c716 --- /dev/null +++ b/compare_DINGO.ipynb @@ -0,0 +1,278 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:d25d548783fae5a17a262185def6a9a5027cb4030fe958eeb27afbb3e4a96831" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "code", + "collapsed": false, + "input": [ + "%run basics\n", + "%matplotlib" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Using matplotlib backend: Qt4Agg\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "dingo_name = \"../../Sites/Whroo/Data/DINGO/V12a/Whroo_2011_to_2014_L6.nc\"\n", + "ofqc_name = \"../../Sites/Whroo/Data/Processed/all/Whroo_2011_to_2014_L6.nc\"" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 2 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "ds_dingo = qcio.nc_read_series(dingo_name)\n", + "ds_ofqc = qcio.nc_read_series(ofqc_name)\n", + "dt_dingo = ds_dingo.series[\"DateTime\"][\"Data\"]\n", + "dt_ofqc = ds_ofqc.series[\"DateTime\"][\"Data\"]\n", + "ts = int(ds_ofqc.globalattributes[\"time_step\"])" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 3 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "start_date = \"2011-01-01 00:30\"\n", + "end_date = \"2015-01-01 00:00\"\n", + "si_dingo = qcutils.GetDateIndex(dt_dingo,start_date,ts=ts,default=0,match=\"startnextday\")\n", + "ei_dingo = qcutils.GetDateIndex(dt_dingo,end_date,ts=ts,default=len(dt_dingo)-1,match=\"endpreviousday\")\n", + "si_ofqc = qcutils.GetDateIndex(dt_ofqc,start_date,ts=ts,default=0,match=\"startnextday\")\n", + "ei_ofqc = qcutils.GetDateIndex(dt_ofqc,end_date,ts=ts,default=len(dt_ofqc)-1,match=\"endpreviousday\")\n", + "print si_dingo,ei_dingo\n", + "print si_ofqc,ei_ofqc" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 11 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "ldt_dingo = dt_dingo[si_dingo:ei_dingo+1]\n", + "ldt_ofqc = dt_ofqc[si_ofqc:ei_ofqc+1]\n", + "NEE_dingo,f,a = qcutils.GetSeriesasMA(ds_dingo,\"NEE\",si=si_dingo,ei=ei_dingo)\n", + "NEE_ofqc,f,a = qcutils.GetSeriesasMA(ds_ofqc,\"NEE_SOLO\",si=si_ofqc,ei=ei_ofqc)\n", + "Fc_ofqc,f,a = qcutils.GetSeriesasMA(ds_ofqc,\"Fc\",si=si_ofqc,ei=ei_ofqc)\n", + "ustar_ofqc,f,a = qcutils.GetSeriesasMA(ds_ofqc,\"ustar\",si=si_ofqc,ei=ei_ofqc)\n", + "Fsd_ofqc,f,a = qcutils.GetSeriesasMA(ds_ofqc,\"Fsd\",si=si_ofqc,ei=ei_ofqc)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 13 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "Fre_obs = numpy.ma.masked_where((Fsd_ofqc>10)|(ustar_ofqc<0.25),Fc_ofqc)\n", + "Fre_dingo = numpy.ma.masked_where((Fsd_ofqc>10)|(ustar_ofqc<0.25),NEE_dingo)\n", + "Fre_ofqc = numpy.ma.masked_where((Fsd_ofqc>10)|(ustar_ofqc<0.25),NEE_ofqc)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 14 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "fig=plt.figure()\n", + "plt.plot(ldt_ofqc,NEE_ofqc,'b.')\n", + "plt.plot(ldt_ofqc,Fre_obs,'go')\n", + "plt.plot(ldt_dingo,NEE_dingo,'r+')\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 15 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "nperhour = int(float(60)/float(ts)+0.5)\n", + "nperday = int(float(24)*nperhour+0.5)\n", + "ndays = int(len(ldt_ofqc)/nperday)\n", + "ldt_daily = numpy.ma.reshape(ldt_ofqc,[ndays,nperday])\n", + "Fre_obs_daily = numpy.ma.reshape(Fre_obs,[ndays,nperday])\n", + "Fre_dingo_daily = numpy.ma.reshape(Fre_dingo,[ndays,nperday])\n", + "Fre_ofqc_daily = numpy.ma.reshape(Fre_ofqc,[ndays,nperday])\n", + "Fre_obs_daily_avg = numpy.ma.average(Fre_obs_daily,axis=1)\n", + "Fre_dingo_daily_avg = numpy.ma.average(Fre_dingo_daily,axis=1)\n", + "Fre_ofqc_daily_avg = numpy.ma.average(Fre_ofqc_daily,axis=1)\n", + "fig=plt.figure()\n", + "plt.plot(ldt_daily[:,0],Fre_ofqc_daily_avg,'b.')\n", + "plt.plot(ldt_daily[:,0],Fre_obs_daily_avg,'go')\n", + "plt.plot(ldt_daily[:,0],Fre_dingo_daily_avg,'r+')\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 16 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "NEE_dingo_night = numpy.ma.masked_where(Fsd_ofqc>10,NEE_dingo)\n", + "NEE_ofqc_night = numpy.ma.masked_where(Fsd_ofqc>10,NEE_ofqc)\n", + "NEE_dingo_night_daily = numpy.ma.reshape(NEE_dingo_night,[ndays,nperday])\n", + "NEE_ofqc_night_daily = numpy.ma.reshape(NEE_ofqc_night,[ndays,nperday])\n", + "NEE_dingo_night_daily_avg = numpy.ma.average(NEE_dingo_night_daily,axis=1)\n", + "NEE_ofqc_night_daily_avg = numpy.ma.average(NEE_ofqc_night_daily,axis=1)\n", + "fig=plt.figure()\n", + "plt.plot(ldt_daily[:,0],NEE_ofqc_night_daily_avg,'b.')\n", + "plt.plot(ldt_daily[:,0],Fre_obs_daily_avg,'go')\n", + "plt.plot(ldt_daily[:,0],NEE_dingo_night_daily_avg,'r+')\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 17 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "Fre_obs_daily_avg_mt15 = numpy.ma.masked_where(numpy.ma.count(Fre_obs_daily,axis=1)<15,Fre_obs_daily_avg)\n", + "fig=plt.figure()\n", + "plt.plot(ldt_daily[:,0],NEE_ofqc_night_daily_avg,'b.')\n", + "plt.plot(ldt_daily[:,0],Fre_obs_daily_avg_mt15,'go')\n", + "plt.plot(ldt_daily[:,0],NEE_dingo_night_daily_avg,'r+')\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 34 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "print numpy.ma.sum(Fre_obs_daily_avg_mt15-NEE_ofqc_night_daily_avg),numpy.ma.sum(Fre_obs_daily_avg_mt15-NEE_dingo_night_daily_avg)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "-21.0808367218 -93.700227942\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "print numpy.ma.sum(NEE_ofqc),numpy.ma.sum(NEE_dingo)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "-75546.8538883 -69303.9435135\n" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "Year_dingo,f,a = qcutils.GetSeriesasMA(ds_dingo,\"Year\")\n", + "NEE_dingo,f,a = qcutils.GetSeriesasMA(ds_dingo,\"NEE\")\n", + "GPP_dingo,f,a = qcutils.GetSeriesasMA(ds_dingo,\"GPP\")\n", + "Fre_dingo,f,a = qcutils.GetSeriesasMA(ds_dingo,\"Fre\")\n", + "Year_ofqc,f,a = qcutils.GetSeriesasMA(ds_ofqc,\"Year\")\n", + "NEE_ofqc,f,a = qcutils.GetSeriesasMA(ds_ofqc,\"NEE_SOLO\")\n", + "GPP_ofqc,f,a = qcutils.GetSeriesasMA(ds_ofqc,\"GPP_SOLO\")\n", + "Fre_ofqc,f,a = qcutils.GetSeriesasMA(ds_ofqc,\"Fre_SOLO\")\n", + "year_list = [2008,2009,2010,2011,2012,2013,2014]\n", + "for year in year_list:\n", + " ind_dingo = numpy.ma.where(Year_dingo==year)[0]\n", + " NEE_dingo_year = NEE_dingo[ind_dingo]\n", + " GPP_dingo_year = GPP_dingo[ind_dingo]\n", + " Fre_dingo_year = Fre_dingo[ind_dingo]\n", + " ind_ofqc = numpy.ma.where(Year_ofqc==year)[0]\n", + " NEE_ofqc_year = NEE_ofqc[ind_ofqc]\n", + " GPP_ofqc_year = GPP_ofqc[ind_ofqc]\n", + " Fre_ofqc_year = Fre_ofqc[ind_ofqc]\n", + " print year,numpy.ma.sum(NEE_dingo_year),numpy.ma.sum(NEE_ofqc_year),\\\n", + " numpy.ma.sum(GPP_dingo_year),numpy.ma.sum(GPP_ofqc_year),\\\n", + " numpy.ma.sum(Fre_dingo_year),numpy.ma.sum(Fre_ofqc_year)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "2008 -- 0.0 -- 0.0 -- 0.0\n", + "2009 -- 0.0 -- 0.0 -- 0.0\n", + "2010 -- 0.0 -- 0.0 -- 0.0\n", + "2011 -2542.27565658 -2724.07589936 -6837.7041331 6683.86811878 4295.42847653 3959.79\n", + "2012 -13071.1520101 -14010.9729386 -59165.941426 55219.7499531 46094.7894159 41208.8\n", + "2013 -9643.81973637 -14891.6924913 -55565.6626663 49482.030716 45921.8429299 34590.3\n", + "2014 -17992.7975269 -19114.4759544 -61576.353793 60912.245213 45074.7722054 41797.8\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/compare_access_tower_daily_q.ipynb b/compare_access_tower_daily_q.ipynb index 59828c0..a13c87a 100644 --- a/compare_access_tower_daily_q.ipynb +++ b/compare_access_tower_daily_q.ipynb @@ -1,7 +1,7 @@ { "metadata": { "name": "", - "signature": "sha256:9cf80b7ce0f8db3d7cc1535890cfb5c51957f3d43dc355ec33867dcacb1f5a76" + "signature": "sha256:7e93874d224e662e77a2b4cf2a32f97206c959aed818da215fec5e7ac65049fc" }, "nbformat": 3, "nbformat_minor": 0, @@ -23,7 +23,17 @@ "cell_type": "code", "collapsed": false, "input": [ - "access_name=qcio.get_filename_dialog()" + "def match_masks(series_list):\n", + " if len(series_list)<2:\n", + " print \"match_masks: only 1 series, nothing to do\"\n", + " return\n", + " mask=numpy.ma.mask_or(series_list[0].mask,series_list[1].mask)\n", + " if len(series_list)>2:\n", + " for item in series_list[2:]:\n", + " mask=numpy.ma.mask_or(mask,item.mask)\n", + " for item in series_list:\n", + " item.mask=mask\n", + " return" ], "language": "python", "metadata": {}, @@ -34,7 +44,7 @@ "cell_type": "code", "collapsed": false, "input": [ - "tower_name=qcio.get_filename_dialog()" + "access_name=qcio.get_filename_dialog()" ], "language": "python", "metadata": {}, @@ -45,12 +55,43 @@ "cell_type": "code", "collapsed": false, "input": [ - "ds_access=qcio.nc_read_series(access_name)\n", - "ds_tower=qcio.nc_read_series(tower_name)" + "aws_name=qcio.get_filename_dialog()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 4 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "tower_name=qcio.get_filename_dialog()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 5 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "ds={}\n", + "ds[\"access\"]=qcio.nc_read_series(access_name)\n", + "ds[\"aws\"]=qcio.nc_read_series(aws_name)\n", + "ds[\"tower\"]=qcio.nc_read_series(tower_name)" ], "language": "python", "metadata": {}, "outputs": [ + { + "output_type": "stream", + "stream": "stderr", + "text": [ + "ERROR:qc.utils:get_UTCfromlocaltime: time_zone not in global attributes, checking elsewhere ...\n" + ] + }, { "output_type": "stream", "stream": "stderr", @@ -59,26 +100,29 @@ ] } ], - "prompt_number": 4 + "prompt_number": 6 }, { "cell_type": "code", "collapsed": false, "input": [ - "ts = int(ds_tower.globalattributes[\"time_step\"])\n", - "ldt_tower=ds_tower.series[\"DateTime\"][\"Data\"]\n", - "ldt_access=ds_access.series[\"DateTime\"][\"Data\"]\n", - "ldt_start=max(ldt_tower[0],ldt_access[0])\n", - "ldt_end=min(ldt_tower[-1],ldt_access[-1])\n", + "ts = int(ds[\"tower\"].globalattributes[\"time_step\"])\n", + "ldt={\"tower\":{},\"access\":{},\"aws\":{}}\n", + "for item in [\"tower\",\"access\",\"aws\"]:\n", + " ldt[item][\"30minute\"]=ds[item].series[\"DateTime\"][\"Data\"]\n", + "ldt_start=ldt[\"tower\"][\"30minute\"][0]\n", + "ldt_end=ldt[\"tower\"][\"30minute\"][-1]\n", + "for item in [\"access\",\"aws\"]:\n", + " ldt_start=max(ldt_start,ldt[item][\"30minute\"][0])\n", + " ldt_end=min(ldt_end,ldt[item][\"30minute\"][-1])\n", "print ldt_start,ldt_end\n", - "si_tower=qcutils.GetDateIndex(ldt_tower,str(ldt_start),match=\"startnextday\",ts=ts)\n", - "ei_tower=qcutils.GetDateIndex(ldt_tower,str(ldt_end),match=\"endpreviousday\",ts=ts)\n", - "si_access=qcutils.GetDateIndex(ldt_access,str(ldt_start),match=\"startnextday\",ts=ts)\n", - "ei_access=qcutils.GetDateIndex(ldt_access,str(ldt_end),match=\"endpreviousday\",ts=ts)\n", - "ldt_tower=ldt_tower[si_tower:ei_tower+1]\n", - "ldt_access=ldt_access[si_access:ei_access+1]\n", - "print ldt_tower[0],ldt_tower[-1]\n", - "print ldt_access[0],ldt_access[-1]" + "si={}\n", + "ei={}\n", + "for item in [\"tower\",\"access\",\"aws\"]:\n", + " si[item]=qcutils.GetDateIndex(ldt[item][\"30minute\"],str(ldt_start),match=\"startnextday\",ts=ts)\n", + " ei[item]=qcutils.GetDateIndex(ldt[item][\"30minute\"],str(ldt_end),match=\"endpreviousday\",ts=ts)\n", + " ldt[item][\"30minute\"]=ldt[item][\"30minute\"][si[item]:ei[item]+1]\n", + " print ldt[item][\"30minute\"][0],ldt[item][\"30minute\"][-1]" ], "language": "python", "metadata": {}, @@ -89,11 +133,12 @@ "text": [ "2011-01-01 08:00:00 2013-11-30 23:00:00\n", "2011-01-02 00:30:00 2013-11-30 00:00:00\n", + "2011-01-02 00:30:00 2013-11-30 00:00:00\n", "2011-01-02 00:30:00 2013-11-30 00:00:00\n" ] } ], - "prompt_number": 14 + "prompt_number": 11 }, { "cell_type": "code", @@ -101,7 +146,56 @@ "input": [ "nPerHr = int(float(60)/ts+0.5)\n", "nPerDay = int(float(24)*nPerHr+0.5)\n", - "nDays = len(ldt_tower)/nPerDay" + "nDays = len(ldt[\"tower\"][\"30minute\"])/nPerDay" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 12 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "RH={\"tower\":{},\"access\":{},\"aws\":{}}\n", + "Ta={\"tower\":{},\"access\":{},\"aws\":{}}\n", + "ps={\"tower\":{},\"access\":{},\"aws\":{}}\n", + "q={\"tower\":{},\"access\":{},\"aws\":{}}\n", + "for item,label in zip([\"tower\",\"access\",\"aws\"],[\"RH\",\"RH_11\",\"RH_0\"]):\n", + " RH[item][\"30minute\"],f,a=qcutils.GetSeriesasMA(ds[item],label,si=si[item],ei=ei[item])\n", + "for item,label in zip([\"tower\",\"access\",\"aws\"],[\"Ta\",\"Ta_11\",\"Ta_0\"]):\n", + " Ta[item][\"30minute\"],f,a=qcutils.GetSeriesasMA(ds[item],label,si=si[item],ei=ei[item])\n", + "for item,label in zip([\"tower\",\"access\",\"aws\"],[\"ps\",\"ps_11\",\"ps_0\"]):\n", + " ps[item][\"30minute\"],f,a=qcutils.GetSeriesasMA(ds[item],label,si=si[item],ei=ei[item])\n", + "for item,label in zip([\"tower\",\"access\"],[\"q\",\"q_11\"]):\n", + " q[item][\"30minute\"],f,a=qcutils.GetSeriesasMA(ds[item],label,si=si[item],ei=ei[item])\n", + "q[\"aws\"][\"30minute\"]=mf.specifichumidityfromRH(RH[\"aws\"][\"30minute\"],Ta[\"aws\"][\"30minute\"],ps[\"aws\"][\"30minute\"])\n", + "ldt[\"tower\"][\"day\"]=ldt[\"tower\"][\"30minute\"][0::nPerDay]\n", + "match_masks([q[\"tower\"][\"30minute\"],q[\"access\"][\"30minute\"],q[\"aws\"][\"30minute\"]])\n", + "for item in [\"tower\",\"access\",\"aws\"]:\n", + " q[item][\"day\"]=q[item][\"30minute\"].reshape(nDays,nPerDay)\n", + " q[item][\"day_avg\"]=numpy.ma.average(q[item][\"day\"],axis=1)\n", + "for item in [\"tower\",\"access\",\"aws\"]:\n", + " RH[item][\"day\"]=RH[item][\"30minute\"].reshape(nDays,nPerDay)\n", + " RH[item][\"day_avg\"]=numpy.ma.average(RH[item][\"day\"],axis=1)\n", + "for item in [\"tower\",\"access\",\"aws\"]:\n", + " Ta[item][\"day\"]=Ta[item][\"30minute\"].reshape(nDays,nPerDay)\n", + " Ta[item][\"day_avg\"]=numpy.ma.average(Ta[item][\"day\"],axis=1)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 19 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "fig=plt.figure()\n", + "plt.plot(ldt[\"tower\"][\"day\"],q[\"tower\"][\"day_avg\"],'b')\n", + "plt.plot(ldt[\"tower\"][\"day\"],q[\"access\"][\"day_avg\"],'r+')\n", + "plt.plot(ldt[\"tower\"][\"day\"],q[\"aws\"][\"day_avg\"],'go')\n", + "plt.show()" ], "language": "python", "metadata": {}, @@ -112,16 +206,11 @@ "cell_type": "code", "collapsed": false, "input": [ - "q_tower,f,a=qcutils.GetSeriesasMA(ds_tower,\"q\",si=si_tower,ei=ei_tower)\n", - "q_access,f,a=qcutils.GetSeriesasMA(ds_access,\"q_11\",si=si_access,ei=ei_access)\n", - "q_tower_day = q_tower.reshape(nDays,nPerDay)\n", - "q_access_day = q_access.reshape(nDays,nPerDay)\n", - "ldt_tower_day = ldt_tower[0::nPerDay]\n", - "mask = numpy.ma.mask_or(q_tower_day.mask,q_access_day.mask)\n", - "q_tower_day = numpy.ma.array(q_tower_day,mask=mask)\n", - "q_access_day = numpy.ma.array(q_access_day,mask=mask)\n", - "q_tower_day_avg = numpy.ma.average(q_tower_day,axis=1)\n", - "q_access_day_avg = numpy.ma.average(q_access_day,axis=1)" + "fig=plt.figure()\n", + "plt.plot(ldt[\"tower\"][\"day\"],RH[\"tower\"][\"day_avg\"],'b')\n", + "plt.plot(ldt[\"tower\"][\"day\"],RH[\"access\"][\"day_avg\"],'r+')\n", + "plt.plot(ldt[\"tower\"][\"day\"],RH[\"aws\"][\"day_avg\"],'go')\n", + "plt.show()" ], "language": "python", "metadata": {}, @@ -133,13 +222,15 @@ "collapsed": false, "input": [ "fig=plt.figure()\n", - "plt.plot(ldt_tower_day,q_tower_day_avg,'b')\n", - "plt.plot(ldt_tower_day,q_access_day_avg,'r+')\n", + "plt.plot(ldt[\"tower\"][\"day\"],Ta[\"tower\"][\"day_avg\"],'b')\n", + "plt.plot(ldt[\"tower\"][\"day\"],Ta[\"access\"][\"day_avg\"],'r+')\n", + "plt.plot(ldt[\"tower\"][\"day\"],Ta[\"aws\"][\"day_avg\"],'go')\n", "plt.show()" ], "language": "python", "metadata": {}, - "outputs": [] + "outputs": [], + "prompt_number": 20 }, { "cell_type": "code", diff --git a/copy_ACCESS_to_daily.ipynb b/copy_ACCESS_to_daily.ipynb new file mode 100644 index 0000000..6d3788d --- /dev/null +++ b/copy_ACCESS_to_daily.ipynb @@ -0,0 +1,340 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:6803e19ca2344b6f6b31ea1de10cc534b4462f5214d61ee2e1730ae25966a9d6" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "code", + "collapsed": false, + "input": [ + "%run basics\n", + "import glob\n", + "import shutil" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 1 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "dir_dict = {}\n", + "dir_dict[\"AdelaideRiver\"]=\"access_Adelaide_River_*.nc\"\n", + "dir_dict[\"AliceSpringsMulga\"]=\"access_Alice_Springs_Mulga_*.nc\"\n", + "dir_dict[\"Arcturus\"]=\"access_Arcturus_*.nc\"\n", + "dir_dict[\"Calperum\"]=\"access_Calperum_*.nc\"\n", + "dir_dict[\"CapeTribulation\"]=\"access_Cape_Tribulation_*.nc\"\n", + "dir_dict[\"CumberlandPlains\"]=\"access_Cumberland_Plains_*.nc\"\n", + "dir_dict[\"Daintree\"]=\"access_Daintree_*.nc\"\n", + "dir_dict[\"DalyPasture\"]=\"access_Daly_Pasture_*.nc\"\n", + "dir_dict[\"DalyUncleared\"]=\"access_Daly_Uncleared_*.nc\"\n", + "dir_dict[\"Darbalara\"]=\"access_Darbalara_*.nc\"\n", + "dir_dict[\"Dargo\"]=\"access_Dargo_*.nc\"\n", + "dir_dict[\"DryRiver\"]=\"access_Dry_River_*.nc\"\n", + "dir_dict[\"Gingin\"]=\"access_Gingin_*.nc\"\n", + "dir_dict[\"GreatWesternWoodlands\"]=\"access_Great_Western_Woodlands_*.nc\"\n", + "dir_dict[\"HowardSprings\"]=\"access_Howard_Springs_*.nc\"\n", + "dir_dict[\"Jaxa\"]=\"access_Jaxa_*.nc\"\n", + "dir_dict[\"Litchfield\"]=\"access_Litchfield_*.nc\"\n", + "dir_dict[\"Nimmo\"]=\"access_Nimmo_*.nc\"\n", + "dir_dict[\"RedDirtMelonFarm\"]=\"access_Red_Dirt_Melon_Farm_*.nc\"\n", + "dir_dict[\"RiggsCreek\"]=\"access_Riggs_Creek_*.nc\"\n", + "dir_dict[\"RobsonCreek\"]=\"access_Robson_Creek_*.nc\"\n", + "dir_dict[\"Samford\"]=\"access_Samford_*.nc\"\n", + "dir_dict[\"SturtPlains\"]=\"access_Sturt_Plains_*.nc\"\n", + "dir_dict[\"TiTreeEast\"]=\"access_Ti_Tree_East_*.nc\"\n", + "dir_dict[\"Tumbarumba\"]=\"access_Tumbarumba_*.nc\"\n", + "dir_dict[\"WallabyCreek\"]=\"access_Wallaby_Creek_*.nc\"\n", + "dir_dict[\"Warra\"]=\"access_Warra_*.nc\"\n", + "dir_dict[\"Whroo\"]=\"access_Whroo_*.nc\"\n", + "dir_dict[\"WombatStateForest\"]=\"access_Wombat_State_Forest_*.nc\"" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 2 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "in_path = \"/home/peter/OzFlux/ACCESS/Incoming/\"\n", + "outpath_base = \"/home/peter/OzFlux/ACCESS/\"" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 3 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "dir_list = dir_dict.keys()\n", + "#dir_list = [\"AliceSpringsMulga\"]\n", + "for dir_name in dir_list:\n", + " print \"Copying \"+dir_name\n", + " outpath = outpath_base+str(dir_name)+\"/Daily/\"\n", + " in_filename = in_path+dir_dict[dir_name]\n", + " file_list = sorted(glob.glob(in_filename))\n", + " for file_name in file_list:\n", + " #print \"Copying \"+file_name+\" to \"+outpath\n", + " shutil.copy2(file_name,outpath)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Copying RiggsCreek\n", + "Copying WombatStateForest" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying Daintree" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying Warra" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying Gingin" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying AliceSpringsMulga" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying Nimmo" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying RobsonCreek" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying GreatWesternWoodlands" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying CumberlandPlains" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying Dargo" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying AdelaideRiver" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying DryRiver" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying Litchfield" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying WallabyCreek" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying RedDirtMelonFarm" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying TiTreeEast" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying SturtPlains" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying Calperum" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying Arcturus" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying HowardSprings" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying DalyUncleared" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying DalyPasture" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying Darbalara" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying Tumbarumba" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying Samford" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying Whroo" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying CapeTribulation" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "Copying Jaxa" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/debug_timestepdrift.ipynb b/debug_timestepdrift.ipynb new file mode 100644 index 0000000..c4439ca --- /dev/null +++ b/debug_timestepdrift.ipynb @@ -0,0 +1,209 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:1dabd3d60921f082e366b72b87d51fdd6235d68c953bbe4f27e19ea7aaa5f21b" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "code", + "collapsed": false, + "input": [ + "%run basics" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 1 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "ncFullName=qcio.get_filename_dialog(path=\"../../Sites\")" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 2 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "netCDF4.default_encoding = 'latin-1'\n", + "ds = qcio.DataStructure()\n", + "# check to see if the requested file exists, return empty ds if it doesn't\n", + "if not qcutils.file_exists(ncFullName,mode=\"quiet\"):\n", + " log.error(' netCDF file '+ncFullName+' not found')\n", + " raise Exception(\"nc_read_series: file not found\")\n", + "# file probably exists, so let's read it\n", + "ncFile = netCDF4.Dataset(ncFullName,'r')\n", + "# now deal with the global attributes\n", + "gattrlist = ncFile.ncattrs()\n", + "if len(gattrlist)!=0:\n", + " for gattr in gattrlist:\n", + " ds.globalattributes[gattr] = getattr(ncFile,gattr)\n", + " if \"time_step\" in ds.globalattributes: c.ts = ds.globalattributes[\"time_step\"]\n", + "# get a list of the variables in the netCDF file (not their QC flags)\n", + "varlist = [x for x in ncFile.variables.keys() if \"_QCFlag\" not in x]\n", + "for ThisOne in varlist:\n", + " # skip variables that do not have time as a dimension\n", + " dimlist = [x.lower() for x in ncFile.variables[ThisOne].dimensions]\n", + " if \"time\" not in dimlist: continue\n", + " # create the series in the data structure\n", + " ds.series[unicode(ThisOne)] = {}\n", + " # get the data and the QC flag\n", + " data,flag,attr = qcio.nc_read_var(ncFile,ThisOne)\n", + " ds.series[ThisOne][\"Data\"] = data\n", + " ds.series[ThisOne][\"Flag\"] = flag\n", + " ds.series[ThisOne][\"Attr\"] = attr\n", + "ncFile.close()\n", + "# make sure all values of -9999 have non-zero QC flag\n", + "qcutils.CheckQCFlags(ds)\n", + "# put a list of Python datetime objects into ds\n", + "qcutils.get_datetimefromymdhms(ds)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 3 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "nRecs = int(ds.globalattributes[\"nc_nrecs\"])\n", + "ts = int(ds.globalattributes[\"time_step\"])\n", + "ldt = ds.series[\"DateTime\"][\"Data\"]\n", + "nc_time = netCDF4.date2num(ldt,\"days since 1800-01-01 00:00:00.0\",calendar=\"gregorian\")\n", + "flag = numpy.zeros(nRecs,dtype=numpy.int32)\n", + "attr = qcutils.MakeAttributeDictionary(long_name=\"time\",standard_name=\"time\",units=\"days since 1800-01-01 00:00:00.0\",\n", + " calendar=\"gregorian\")\n", + "qcutils.CreateSeries(ds,\"time\",nc_time,Flag=flag,Attr=attr)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 11 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def rounddt(dt,ts=30):\n", + " dt += datetime.timedelta(minutes=int(ts/2))\n", + " dt -= datetime.timedelta(minutes=dt.minute % int(ts),seconds=dt.second,microseconds=dt.microsecond)\n", + " return dt" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 32 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "dt = numpy.array([(ldt[i]-ldt[i-1]).total_seconds() for i in range(1,len(ldt))])\n", + "idx = numpy.where(dt!=ts*60)[0]\n", + "if len(idx)!=0:\n", + " print \"Non-integral time steps found\",len(idx),\"times out of\",str(nRecs)\n", + " print \"Maximum time step was\",numpy.max(dt),\"seconds, minimum time step was\",numpy.min(dt)\n", + " dt_diffs = numpy.array([(ldt[i]-rounddt(ldt[i],ts=ts)).total_seconds() for i in range(1,len(ldt))])\n", + " print \"Maximum drift was\",numpy.max(dt_diffs),\"seconds, minimum drift was\",numpy.min(dt_diffs),\"seconds\"\n", + " ans = raw_input(\"Do you want to [Q]uit, [I]nterploate or [R]ound? \")\n", + " if ans.lower()==\"q\":\n", + " print \"Quiting ...\"\n", + " #sys.exit()\n", + " if ans.lower()==\"i\": print \"Interpolate\"\n", + " if ans.lower()==\"r\":\n", + " print \"Rounding to the nearest time step\"\n", + " ldt_rounded = [rounddt(dt,ts=ts) for dt in ldt]\n", + " rdt = numpy.array([(ldt_rounded[i]-ldt_rounded[i-1]).total_seconds() for i in range(1,len(ldt))])\n", + " print \"Maximum time step is now\",numpy.max(rdt),\"seconds, minimum time step is now\",numpy.min(rdt)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Non-integral time steps found 80 times out of 17520\n", + "Maximum time step was 1801.0 seconds, minimum time step was 1799.0\n", + "Maximum drift was 50.0 seconds, minimum drift was 0.0 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "stream": "stdout", + "text": [ + "Do you want to [Q]uit, [I]nterploate or [R]ound? r\n" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Rounding to the nearest time step\n", + "Maximum time step is now 1800.0 seconds, minimum time step is now 1800.0\n" + ] + } + ], + "prompt_number": 45 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "fig = plt.figure()\n", + "plt.plot(ldt[1:],dt,'b.')\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 8 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# round the start and end datetimes to the nearest integral time steps\n", + "print ldt[0],ldt[-1]\n", + "sd = rounddt(ldt[0],ts=ts)\n", + "ed = rounddt(ldt[-1],ts=ts)\n", + "print sd,ed" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "2010-01-01 00:30:00 2011-01-01 00:00:50\n", + "2010-01-01 00:30:00 2011-01-01 00:00:00\n" + ] + } + ], + "prompt_number": 34 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/nocturnal_Fc_negative_hour_histogram.ipynb b/nocturnal_Fc_negative_hour_histogram.ipynb new file mode 100644 index 0000000..9462c59 --- /dev/null +++ b/nocturnal_Fc_negative_hour_histogram.ipynb @@ -0,0 +1,168 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:d9e8e30514fcf063319f51ffbb461dd1badd78f2712e1998d5252ff3c50ecc39" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "code", + "collapsed": false, + "input": [ + "%run basics\n", + "%matplotlib" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Using matplotlib backend: Qt4Agg\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# get the netCDF file name\n", + "ncname = qcio.get_filename_dialog(path=\"../../Sites\")" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 2 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# read the netCDF file contents into the data structure\n", + "ds = qcio.nc_read_series(ncname)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 3 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# get the necessary data from the data structure\n", + "dt = ds.series[\"DateTime\"][\"Data\"]\n", + "Fsd,f,a = qcutils.GetSeriesasMA(ds,\"Fsd\")\n", + "Fsd_syn,f,a = qcutils.GetSeriesasMA(ds,\"Fsd_syn\")\n", + "Fsd_filtered,f,a = qcutils.GetSeriesasMA(ds,\"Fsd_filtered\")\n", + "Fc,f,a = qcutils.GetSeriesasMA(ds,\"Fc\")\n", + "ustar,f,a = qcutils.GetSeriesasMA(ds,\"ustar\")\n", + "Hour,f,a = qcutils.GetSeriesasMA(ds,\"Hour\")\n", + "sa,f,a = qcutils.GetSeriesasMA(ds,\"solar_altitude\")\n", + "Ts,f,a = qcutils.GetSeriesasMA(ds,\"Ts\")" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 45 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "Fc_filtered = numpy.ma.masked_where(numpy.ma.getmaskarray(Fsd_filtered)==True,Fc)\n", + "ustar_filtered = numpy.ma.masked_where(numpy.ma.getmaskarray(Fsd_filtered)==True,ustar)\n", + "Hour_filtered = numpy.ma.masked_where(numpy.ma.getmaskarray(Fsd_filtered)==True,Hour)\n", + "Ts_filtered = numpy.ma.masked_where(numpy.ma.getmaskarray(Fsd_filtered)==True,Ts)\n", + "index = numpy.ma.where(Fc_filtered<=0)[0]\n", + "Hour_filtered_Fcnegative = Hour_filtered[index]" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 46 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "fig=plt.figure()\n", + "ax0 = plt.subplot(411)\n", + "ax0.plot(dt,sa,'bo')\n", + "ax1 = plt.subplot(412,sharex=ax0)\n", + "ax1.plot(dt,Fsd_filtered,'bo')\n", + "ax2 = plt.subplot(413,sharex=ax0)\n", + "ax2.plot(dt,Fc_filtered,'bo')\n", + "ax2.plot([dt[0],dt[-1]],[0,0],'r-')\n", + "ax3 = plt.subplot(414,sharex=ax0)\n", + "ax3.plot(dt,ustar_filtered,'bo')\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 47 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "bins=[i-0.5 for i in range(0,25)]\n", + "fig=plt.figure()\n", + "plt.hist(numpy.ma.compressed(Hour_filtered_Fcnegative),bins=bins)\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 57 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "Hour_f = numpy.ma.compressed(Hour_filtered)\n", + "Ts_f = numpy.ma.compressed(Ts_filtered)\n", + "bin_mean,bin_edges,bin_number = scipy.stats.binned_statistic(Hour_f,Ts_f,statistic='mean',bins=bins)\n", + "bin_width = bin_edges[1] - bin_edges[0]\n", + "bin_centers = bin_edges[1:] - bin_width/2" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 66 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "fig=plt.figure()\n", + "plt.plot(bin_centers,bin_mean,'bo')\n", + "plt.ylabel(\"Ts (C)\")\n", + "plt.xlabel(\"Hour\")\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 69 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/read_example.ipynb b/read_example.ipynb new file mode 100644 index 0000000..6e65994 --- /dev/null +++ b/read_example.ipynb @@ -0,0 +1,188 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:8de9657acd2d51a2997f279607e11a92359f54e05220b71c42fbe03555cbb79e" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import datetime\n", + "import matplotlib.pyplot as plt\n", + "import netCDF4\n", + "import os\n", + "import pandas as pd" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 1 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def read_netcdf(nc_full_name,variable_list=[]):\n", + " # open the netCDF file\n", + " nc_file = netCDF4.Dataset(nc_full_name,\"r\")\n", + " # creat the attribute dictionary\n", + " attr = {}\n", + " attr[\"global\"] = {}\n", + " attr[\"variable\"] = {}\n", + " # get the global attributes\n", + " gattrlist = nc_file.ncattrs()\n", + " if len(gattrlist)!=0:\n", + " for item in gattrlist:\n", + " attr[\"global\"][item] = getattr(nc_file,item)\n", + " # get a list of Python datetimes\n", + " time = time = nc_file.variables[\"time\"][:]\n", + " time_units = getattr(nc_file.variables[\"time\"],\"units\")\n", + " dt = list(netCDF4.num2date(time,time_units))\n", + " # get a list of variables to read from the netCDF file\n", + " # was a variable list passed in as variable_list?\n", + " if len(variable_list)==0:\n", + " # if not, get the variable list from the netCDF file contents\n", + " variable_list = nc_file.variables.keys()\n", + " else:\n", + " # if so, add the QC flags to the list entered as an argument\n", + " flag_list = []\n", + " for item in variable_list: flag_list.append(item+\"_QCFlag\")\n", + " variable_list = variable_list+flag_list\n", + " # create the data dictionary\n", + " data = {}\n", + " # loop over the variables to be read\n", + " for item in variable_list:\n", + " # get the number of dimensions\n", + " # variables in OzFlux netCDF files can have 1 (time) or 3 dimensions (time,latitude,longitude)\n", + " ndims = len(nc_file.variables[item].shape)\n", + " if ndims==1:\n", + " data[item] = ncFile.variables[item][:]\n", + " elif ndims==3:\n", + " data[item] = nc_file.variables[item][:,0,0]\n", + " else:\n", + " raise Exception(\"unrecognised number of dimensions for variable\"+str(item))\n", + " # get the variable attributes\n", + " vattrlist = nc_file.variables[item].ncattrs()\n", + " if len(vattrlist)!=0:\n", + " attr[\"variable\"][item] = {}\n", + " for vattr in vattrlist:\n", + " attr[\"variable\"][item][vattr] = getattr(nc_file.variables[item],vattr)\n", + " # close the netCDF file\n", + " nc_file.close()\n", + " # convert the dictionary to a Pandas data frame\n", + " df = pd.DataFrame(data,index=dt)\n", + " return df,attr" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 2 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "nc_full_name = \"../../Sites/Whroo/Data/Processed/all/Whroo_2011_to_2014_L6.nc\"\n", + "variable_list = ['Fsd','Ta','VPD','NEE_SOLO']" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 3 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "df,attr = read_netcdf(nc_full_name,variable_list=variable_list)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 4 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "fig=plt.figure()\n", + "ax1 = plt.subplot(411)\n", + "ax1.plot(df['Fsd'])\n", + "ax2 = plt.subplot(412)\n", + "ax2.plot(df['Ta'])\n", + "ax3 = plt.subplot(413)\n", + "ax3.plot(df['VPD'])\n", + "ax4 = plt.subplot(414)\n", + "ax4.plot(df['NEE_SOLO'])\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 5 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "attr.keys()" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "prompt_number": 6, + "text": [ + "['variable', 'global']" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "attr[\"variable\"].keys()" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "pyout", + "prompt_number": 8, + "text": [ + "['Fsd',\n", + " 'Fsd_QCFlag',\n", + " 'NEE_SOLO_QCFlag',\n", + " 'VPD',\n", + " 'NEE_SOLO',\n", + " 'Ta_QCFlag',\n", + " 'VPD_QCFlag',\n", + " 'Ta']" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/respiration_LloydTaylor.ipynb b/respiration_LloydTaylor.ipynb new file mode 100644 index 0000000..9b9ac0e --- /dev/null +++ b/respiration_LloydTaylor.ipynb @@ -0,0 +1,538 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:3968c053ae0ee52db48d3440e687d8be13547974499fe13dd32a6bbf2f2f5b59" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "code", + "collapsed": false, + "input": [ + "%run basics\n", + "%matplotlib" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Using matplotlib backend: Qt4Agg\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def Fre_LloydTaylor(T,rb,E0):\n", + " \"\"\"\n", + " Lloyd-Taylor expression for respiration as a function of temperature.\n", + " E0 is the activation energy (sensitivity of respiration to temperature)\n", + " rb is the baseline respiration\n", + " \"\"\"\n", + "# return rb*numpy.exp(E0*(1/(c.Tref-c.T0)-1/(T-c.T0)))\n", + " return rb*numpy.exp(E0*(1/(288.13-227.13)-1/((T+273.15)-227.13)))" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 2 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def plot_Reco(fig,i,Reco,T,Sws,weight_type='Huber'):\n", + " ax = fig.add_subplot(2,2,i)\n", + " popt,pcov = irls_leastsq(residuals_LT,[2,200],args=(Reco,T),maxfev=3,weight_type=weight_type)\n", + " resid = Reco - Reco_LloydTaylor(T,popt[0],popt[1])\n", + " weights = CalculateWeights(resid,weight_type=weight_type)\n", + " plt.scatter(T,Reco,c=weights)\n", + " #mean,edges,number = scipy.stats.binned_statistic(T,Reco,statistic='mean')\n", + " #mid = [(edges[i]+edges[i+1])/2 for i in range(0,len(edges)-1)]\n", + " #plt.plot(mid,mean,'ro')\n", + " Xfit = numpy.linspace(numpy.min(T),numpy.max(T),100)\n", + " Yfit = Reco_LloydTaylor(Xfit,popt[0],popt[1])\n", + " plt.plot(Xfit,Yfit,'r-')\n", + " text_str = ('%.2f < Sws < %.2f'%(Sws[0],Sws[-1]))\n", + " plt.text(0.5,0.9,text_str,horizontalalignment='center',transform=ax.transAxes)\n", + " text_str = ('rb=%.2f,E0=%.2f'%(popt[0],popt[-1]))\n", + " plt.text(0.5,0.8,text_str,horizontalalignment='center',transform=ax.transAxes)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 3 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def irls_leastsq(func,p0,args=(),maxfev=3,weight_type='Huber'):\n", + " weighted = False\n", + " popt,pcov = scipy.optimize.leastsq(func,p0,args=args+(weighted,weight_type))\n", + " print 'After non-weighted call to leastsq: ',popt\n", + " n=1\n", + " weighted = True\n", + " while n<=maxfev:\n", + " popt,pcov = scipy.optimize.leastsq(func,popt,args=args+(weighted,weight_type))\n", + " print 'Weighted call '+str(n)+' to leastsq: ',popt\n", + " n = n + 1\n", + " return popt,pcov" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 4 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def residuals_LloydTaylor(params,Fre,T,weighted,weight_type):\n", + " rb = params[0]\n", + " E0 = params[1]\n", + " resid = Fre - Fre_LloydTaylor(T,rb,E0)\n", + " if weighted:\n", + " weights = CalculateWeights(resid,weight_type=weight_type)\n", + " return resid*weights\n", + " else:\n", + " return resid" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 5 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def CalculateWeights(resid,weight_type='Huber'):\n", + " if weight_type.lower()=='tukey':\n", + " weights = TukeyBiweight(MAD_scale(resid))\n", + " elif weight_type.lower()=='huber':\n", + " weights = HuberTWeight(MAD_scale(resid))\n", + " elif weight_type.lower()=='ols':\n", + " weights = OLSWeight(MAD_scale(resid))\n", + " else:\n", + " print \"CalculateWeights: Unknown weight type, used Huber's t weight\"\n", + " weights = HuberTWeight(MAD_scale(resid))\n", + " return weights" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 6 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def TukeyBiweight(x):\n", + " return ((numpy.abs(x)<1.0)*(1.0 - x**2)**2)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 7 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def HuberTWeight(x):\n", + " weights = numpy.ones(len(x))\n", + " idx = numpy.where(numpy.abs(x)>1.345)[0]\n", + " weights[idx] = 1.345/numpy.abs(x[idx])\n", + " return weights" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 8 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def OLSWeight(x):\n", + " weights = numpy.ones(len(x))\n", + " return weights" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 9 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def MAD_scale(resid):\n", + " scale = numpy.median(numpy.abs(resid - numpy.median(resid))) / 0.6745\n", + " return resid/scale" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 10 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "ncname = qcio.get_filename_dialog(path=\"../../Sites/HowardSprings/Data/Processed/all\")\n", + "print ncname\n", + "ds = qcio.nc_read_series(ncname)\n", + "ldt = ds.series[\"DateTime\"][\"Data\"]\n", + "ts = int(ds.globalattributes[\"time_step\"])\n", + "site_name = ds.globalattributes[\"site_name\"]" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "/home/peter/OzFlux/Sites/HowardSprings/Data/Processed/all/HowardSprings_2011_to_2013_L5.nc\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "Fsd,Fsd_flag,Fsd_attr = qcutils.GetSeriesasMA(ds,\"Fsd\")\n", + "Fc,Fc_flag,Fc_attr = qcutils.GetSeriesasMA(ds,\"Fc\")\n", + "T,T_flag,T_attr = qcutils.GetSeriesasMA(ds,\"Ts\")\n", + "ustar,ustar_flag,ustar_attr = qcutils.GetSeriesasMA(ds,\"ustar\")" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 12 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "fig = plt.figure(1)\n", + "ax1=plt.subplot(411)\n", + "plt.plot(ldt,Fsd)\n", + "ax2=plt.subplot(412,sharex=ax1)\n", + "plt.plot(ldt,Fc)\n", + "ax3=plt.subplot(413,sharex=ax1)\n", + "plt.plot(ldt,ustar)\n", + "ax4=plt.subplot(414,sharex=ax1)\n", + "plt.plot(ldt,T)\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 13 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# only use Fc when Fc QC flag=0\n", + "Fc_best = numpy.ma.masked_where(Fc_flag!=0,Fc)\n", + "Fc_best = numpy.ma.masked_where(Fc_best<0,Fc_best)\n", + "# mask day time values\n", + "Fc_nocturnal = numpy.ma.masked_where(Fsd>=10,Fc_best)\n", + "# mask low ustar values\n", + "# NOTE: ustar threshold value to be read from control file\n", + "Fre = numpy.ma.masked_where(ustar<0.25,Fc_nocturnal)\n", + "# synchronise masks across drivers and targets\n", + "mask = Fre.mask\n", + "for item in [T]:\n", + " mask = numpy.ma.mask_or(mask,item.mask)\n", + "# apply synchronised mask across drivers and targets\n", + "Fre = numpy.ma.array(Fre,mask=mask)\n", + "T = numpy.ma.array(T,mask=mask)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 16 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "fig = plt.figure(1)\n", + "ax1=plt.subplot(211)\n", + "plt.plot(ldt,Fre)\n", + "ax2=plt.subplot(212,sharex=ax1)\n", + "plt.plot(ldt,T)\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 17 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# get the yearly E0 values\n", + "first_date = ldt[0]\n", + "last_date = ldt[-1]\n", + "years = [yr for yr in range(first_date.year,last_date.year+1)]\n", + "for year in [yr for yr in range(first_date.year,last_date.year+1)]:\n", + " idx = numpy.where(ds.series[\"Year\"][\"Data\"]==year)[0]\n", + " Fre_year = numpy.ma.compressed(Fre[idx])\n", + " T_year = numpy.ma.compressed(T[idx])\n", + " popt,pcov = irls_leastsq(residuals_LloydTaylor,[1,100],args=(Fre_year,T_year),maxfev=3,weight_type='Huber')\n", + " Fre_fit = Fre_LloydTaylor(T_year,popt[0],popt[1])\n", + " fig = plt.figure()\n", + " plt.plot(T_year,Fre_year,'b.')\n", + " plt.plot(T_year,Fre_fit,'r-')\n", + " plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "After non-weighted call to leastsq: [ 2.52165456 140.81456929]\n", + "Weighted call 1 to leastsq: [ 2.52165456 140.81456929]\n", + "Weighted call 2 to leastsq: [ 2.52165456 140.81456929]\n", + "Weighted call 3 to leastsq: [ 2.52165456 140.81456929]\n", + "After non-weighted call to leastsq: [ 1.41258216 307.53834432]\n", + "Weighted call 1 to leastsq: " + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + " [ 1.41258216 308.87819755]\n", + "Weighted call 2 to leastsq: [ 1.41258216 308.87819755]\n", + "Weighted call 3 to leastsq: [ 1.41258216 308.87819755]\n", + "After non-weighted call to leastsq: " + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + " [ 2.68473425 143.59185815]\n", + "Weighted call 1 to leastsq: [ 2.68473425 143.59185815]\n", + "Weighted call 2 to leastsq: [ 2.68473425 143.59185815]\n", + "Weighted call 3 to leastsq: [ 2.68473425 143.59185815]\n" + ] + } + ], + "prompt_number": 35 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def update_end_date(end_date,window_units,window_length,window_overlap):\n", + " if window_units.lower()==\"days\":\n", + " end_date = start_date + dateutil.relativedelta.relativedelta(days=window_length)\n", + " elif window_units.lower()==\"months\":\n", + " end_date = start_date + dateutil.relativedelta.relativedelta(months=window_length)\n", + " elif window_units.lower()==\"years\":\n", + " end_date = start_date + dateutil.relativedelta.relativedelta(years=window_length)\n", + " else:\n", + " print \"Unrecognised option for window length units\"\n", + " return end_date\n", + "def update_start_date(start_date,window_units,window_length,window_overlap):\n", + " window_jump = window_length - window_overlap\n", + " if window_units.lower()==\"days\":\n", + " start_date = start_date + dateutil.relativedelta.relativedelta(days=window_jump)\n", + " elif window_units.lower()==\"months\":\n", + " start_date = start_date + dateutil.relativedelta.relativedelta(months=window_jump)\n", + " elif window_units.lower()==\"years\":\n", + " start_date = start_date + dateutil.relativedelta.relativedelta(years=window_jump)\n", + " else:\n", + " print \"Unrecognised option for window length units\"\n", + " return start_date" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 36 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Get the long term E0\n", + "# set the window units, length and overlap\n", + "# these will be read from the control file\n", + "window_units = \"years\"\n", + "window_length = 1\n", + "window_overlap = 0\n", + "# get the first and last dates in the data set\n", + "first_date = ldt[0]\n", + "last_date = ldt[-1]\n", + "print first_date,last_date\n", + "# get the initial start date\n", + "start_date = ldt[0]\n", + "# get the initial end date\n", + "end_date = update_end_date(start_date,window_units,window_length,window_overlap)\n", + "# create empty lists to hold the start and end dates of the data window\n", + "start_dates = []\n", + "end_dates = []\n", + "# loop until the last date to create the lists of start and end dates\n", + "while start_date?pP2{b zVgX?2Kpd;Uz{&*@Vb%iifs6(YA&@(n8DV~fc}i3Utc9700Vab^^XP(gGH@|)fRyIs z=cUKzCFZ6w2m{6WfEeU}aQ9#ZLrV)2g_OjS(p(-(kfqEFLJ%$KMVTq_xrqe@naEl} e4gzV-Ni4}MDNRX@2bm0JF(?6ri2(M0>=FU~5_;SK diff --git a/test_L6_summary.ipynb b/test_L6_summary.ipynb new file mode 100644 index 0000000..10604be --- /dev/null +++ b/test_L6_summary.ipynb @@ -0,0 +1,302 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:523a0b359e256d88c2ce45eb0f3bfcfa8854f4a0794c975ae22545db426ce8cc" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "code", + "collapsed": false, + "input": [ + "%run basics\n", + "%matplotlib\n", + "import xlwt" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Using matplotlib backend: Qt4Agg\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def xl_write_data(xlSheet,data):\n", + " xlCol = 0\n", + " # write the data to the xl file\n", + " series_list = data.keys()\n", + " xlSheet.write(1,xlCol,'Day')\n", + " nrows = len(data[\"DateTime\"])\n", + " ncols = len(series_list)\n", + " d_xf = xlwt.easyxf(num_format_str='dd/mm/yyyy')\n", + " for j in range(nrows):\n", + " xlSheet.write(j+2,xlCol,data[\"DateTime\"][j],d_xf)\n", + " series_list.remove(\"DateTime\")\n", + " series_list.sort()\n", + " for item in series_list:\n", + " xlCol = xlCol + 1\n", + " xlSheet.write(0,xlCol,data[item][\"units\"])\n", + " xlSheet.write(1,xlCol,item)\n", + " d_xf = xlwt.easyxf(num_format_str=data[item][\"format\"])\n", + " for j in range(nrows):\n", + " xlSheet.write(j+2,xlCol,float(data[item][\"data\"][j]),d_xf)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 2 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#nc_name = \"../../Sites/HowardSprings/Data/Processed/all/HowardSprings_2002_to_2014_L6.nc\"\n", + "nc_name = \"../../Sites/Tumbarumba/Data/Processed/all/yearly/Tumbarumba_2001_to_2014_L6.nc\"\n", + "xl_name = nc_name.replace(\".nc\",\"_Summary.xls\")\n", + "cf = qcio.get_controlfilecontents(\"../controlfiles/standard/L6_summary.txt\")" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 3 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "ds = qcio.nc_read_series(nc_name)\n", + "dt = ds.series[\"DateTime\"][\"Data\"]\n", + "ts = int(ds.globalattributes[\"time_step\"])" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 4 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# calculate ET if it is not present\n", + "if \"ET\" not in ds.series.keys():\n", + " Fe,flag,attr = qcutils.GetSeriesasMA(ds,\"Fe\")\n", + " ET = Fe*ts*60/c.Lv\n", + " attr[\"long_name\"] = \"Evapo-transpiration calculated from latent heat flux\"\n", + " attr[\"units\"] = \"mm\"\n", + " qcutils.CreateSeries(ds,\"ET\",ET,Flag=flag,Attr=attr)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 5 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# adjust units of NEE, NEP, GPP and Fre\n", + "nee_list = [item for item in cf[\"Variables\"].keys() if \"NEE\" in item]\n", + "nep_list = [item for item in cf[\"Variables\"].keys() if \"NEP\" in item]\n", + "gpp_list = [item for item in cf[\"Variables\"].keys() if \"GPP\" in item]\n", + "fre_list = [item for item in cf[\"Variables\"].keys() if \"Fre\" in item]\n", + "co2_list = nee_list+nep_list+gpp_list+fre_list\n", + "for item in co2_list:\n", + " data,flag,attr = qcutils.GetSeriesasMA(ds,item)\n", + " data = data*12.01*ts*60/1E6\n", + " attr[\"units\"] = \"gC/m2\"\n", + " qcutils.CreateSeries(ds,item,data,Flag=flag,Attr=attr)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 6 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# open the Excel workbook\n", + "xl_file = xlwt.Workbook()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 22 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# daily averages and totals\n", + "first_date = dt[0]\n", + "si = qcutils.GetDateIndex(dt,str(first_date),ts=ts,default=0,match=\"startnextday\")\n", + "start_date = dt[si]\n", + "last_date = dt[-1]\n", + "ei = qcutils.GetDateIndex(dt,str(last_date),ts=ts,default=len(dt)-1,match=\"endpreviousday\")\n", + "end_date = dt[ei]\n", + "ldt = dt[si:ei+1]\n", + "ntsInDay = int(24.0*60.0/float(ts))\n", + "nDays = int(len(ldt))/ntsInDay\n", + "ldt_daily = [ldt[0]+datetime.timedelta(days=i) for i in range(0,nDays)]\n", + "daily_dict = {\"DateTime\":ldt_daily}\n", + "for item in cf[\"Variables\"].keys():\n", + " if item not in ds.series.keys(): continue\n", + " daily_dict[item] = {}\n", + " data_1d,flag,attr = qcutils.GetSeriesasMA(ds,item,si=si,ei=ei)\n", + " daily_dict[item][\"units\"] = attr[\"units\"]\n", + " data_2d = data_1d.reshape(nDays,ntsInDay)\n", + " if cf[\"Variables\"][item][\"operator\"].lower()==\"average\":\n", + " daily_dict[item][\"data\"] = numpy.ma.average(data_2d,axis=1)\n", + " elif cf[\"Variables\"][item][\"operator\"].lower()==\"sum\":\n", + " daily_dict[item][\"data\"] = numpy.ma.sum(data_2d,axis=1)\n", + " daily_dict[item][\"units\"] = daily_dict[item][\"units\"]+\"/day\"\n", + " else:\n", + " print \"unrecognised operator\"\n", + " daily_dict[item][\"format\"] = cf[\"Variables\"][item][\"format\"]\n", + "# add the daily worksheet to the summary Excel file\n", + "xl_sheet = xl_file.add_sheet(\"Daily\")\n", + "xl_write_data(xl_sheet,daily_dict)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 23 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# annual averages and totals\n", + "start_year = ldt[0].year\n", + "end_year = ldt[-1].year\n", + "year_list = range(start_year,end_year+1,1)\n", + "annual_dict = {\"DateTime\":[datetime.datetime(yr,1,1) for yr in year_list]}\n", + "# create arrays in annual_dict\n", + "for item in cf[\"Variables\"].keys():\n", + " annual_dict[item] = {\"data\":numpy.array([float(-9999)]*len(year_list))}\n", + "annual_dict[\"ET\"] = {\"data\":numpy.array([float(-9999)]*len(year_list))}\n", + "for i,year in enumerate(year_list):\n", + " if ts==30:\n", + " start_date = str(year)+\"-01-01 00:30\"\n", + " elif ts==60:\n", + " start_date = str(year)+\"-01-01 01:00\"\n", + " end_date = str(year+1)+\"-01-01 00:00\"\n", + " si = qcutils.GetDateIndex(dt,start_date,ts=ts,default=0)\n", + " ei = qcutils.GetDateIndex(dt,end_date,ts=ts,default=len(dt)-1)\n", + " for item in cf[\"Variables\"].keys():\n", + " if item not in ds.series.keys(): continue\n", + " data_1d,flag,attr = qcutils.GetSeriesasMA(ds,item,si=si,ei=ei)\n", + " annual_dict[item][\"units\"] = attr[\"units\"]\n", + " if cf[\"Variables\"][item][\"operator\"].lower()==\"average\":\n", + " annual_dict[item][\"data\"][i] = numpy.ma.average(data_1d)\n", + " elif cf[\"Variables\"][item][\"operator\"].lower()==\"sum\":\n", + " annual_dict[item][\"data\"][i] = numpy.ma.sum(data_1d)\n", + " annual_dict[item][\"units\"] = annual_dict[item][\"units\"]+\"/year\"\n", + " else:\n", + " print \"unrecognised operator\"\n", + " annual_dict[item][\"format\"] = cf[\"Variables\"][item][\"format\"]\n", + "# add the annual worksheet to the summary Excel file\n", + "xl_sheet = xl_file.add_sheet(\"Annual\")\n", + "xl_write_data(xl_sheet,annual_dict)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 24 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# cumulative totals\n", + "h2o_list = [\"Precip\",\"ET\"]\n", + "nee_list = [item for item in cf[\"Variables\"].keys() if \"NEE\" in item]\n", + "nep_list = [item for item in cf[\"Variables\"].keys() if \"NEP\" in item]\n", + "gpp_list = [item for item in cf[\"Variables\"].keys() if \"GPP\" in item]\n", + "fre_list = [item for item in cf[\"Variables\"].keys() if \"Fre\" in item]\n", + "co2_list = nee_list+nep_list+gpp_list+fre_list\n", + "series_list = h2o_list+co2_list\n", + "cumulative_dict = {}\n", + "for i,year in enumerate(year_list):\n", + " cumulative_dict[str(year)] = {}\n", + " if ts==30:\n", + " start_date = str(year)+\"-01-01 00:30\"\n", + " elif ts==60:\n", + " start_date = str(year)+\"-01-01 01:00\"\n", + " end_date = str(year+1)+\"-01-01 00:00\"\n", + " si = qcutils.GetDateIndex(dt,start_date,ts=ts,default=0)\n", + " ei = qcutils.GetDateIndex(dt,end_date,ts=ts,default=len(dt)-1)\n", + " ldt = dt[si:ei+1]\n", + " cumulative_dict[str(year)][\"DateTime\"] = ldt\n", + " for item in series_list:\n", + " cumulative_dict[str(year)][item] = {}\n", + " data,flag,attr = qcutils.GetSeriesasMA(ds,item,si=si,ei=ei)\n", + " cumulative_dict[str(year)][item][\"data\"] = numpy.ma.cumsum(data)\n", + " cumulative_dict[str(year)][item][\"units\"] = attr[\"units\"]+\"/year\"\n", + " cumulative_dict[str(year)][item][\"format\"] = cf[\"Variables\"][item][\"format\"]\n", + " xl_sheet = xl_file.add_sheet(\"Cumulative(\"+str(year)+\")\")\n", + " xl_write_data(xl_sheet,cumulative_dict[str(year)])" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 25 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# close the Excel workbook\n", + "xl_file.save(xl_name)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 26 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# plot time series of NEE, GPP and Reco\n", + "fig=plt.figure(1)\n", + "plt.plot(daily_dict[\"DateTime\"],daily_dict[\"NEE_SOLO\"][\"data\"])\n", + "plt.plot(daily_dict[\"DateTime\"],daily_dict[\"GPP_SOLO\"][\"data\"])\n", + "plt.plot(daily_dict[\"DateTime\"],daily_dict[\"Fre_SOLO\"][\"data\"])\n", + "plt.show()\n", + "fig=plt.figure(2)\n", + "plt.plot(daily_dict[\"DateTime\"],daily_dict[\"NEE_FFNET\"][\"data\"])\n", + "plt.plot(daily_dict[\"DateTime\"],daily_dict[\"GPP_FFNET\"][\"data\"])\n", + "plt.plot(daily_dict[\"DateTime\"],daily_dict[\"Fre_FFNET\"][\"data\"])\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 28 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/test_MergeSeriesUsingDict.ipynb b/test_MergeSeriesUsingDict.ipynb new file mode 100644 index 0000000..8ce2ba7 --- /dev/null +++ b/test_MergeSeriesUsingDict.ipynb @@ -0,0 +1,171 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:0406cb461c0f0a3aada67b4e57ebede0eaa2012255cf185132076b4f4622e27c" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "code", + "collapsed": false, + "input": [ + "%run basics" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 1 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "l3name=qcio.get_filename_dialog(path=\"../../Sites\")" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 2 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "l4name=qcio.get_filename_dialog(path=\"../../Sites\")" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 3 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "ds3=qcio.nc_read_series(l3name)\n", + "ds4=qcio.nc_read_series(l4name)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 4 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "dt3=ds3.series[\"DateTime\"][\"Data\"]\n", + "dt4=ds4.series[\"DateTime\"][\"Data\"]" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 8 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "Fsd_l3_data,Fsd_l3_flag,Fsd_l3_attr=qcutils.GetSeriesasMA(ds3,\"Fsd\")\n", + "Fsd_l4_data,Fsd_l4_flag,Fsd_l4_attr=qcutils.GetSeriesasMA(ds4,\"Fsd\")" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 5 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "data_l3=ds3.series[\"Fsd\"]['Data'].copy()\n", + "flag_l3=ds3.series[\"Fsd\"]['Flag'].copy()\n", + "data_l4=ds4.series[\"Fsd_access\"]['Data'].copy()\n", + "flag_l4=ds4.series[\"Fsd_access\"]['Flag'].copy()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 6 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "si=qcutils.GetDateIndex(dt3,\"2013-02-06 12:00\")\n", + "ei=qcutils.GetDateIndex(dt3,\"2013-02-07 00:00\")" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 9 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "index=numpy.where(numpy.mod(flag_l3,10)==0)[0]\n", + "flag_l3[index]=0" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 12 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "index=numpy.where(flag_l3!=0)[0]" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 17 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "flag_l3[index]=flag_l4[index]" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 20 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "print flag_l3[si:ei],flag_l4[si:ei]" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "[ 0 0 0 0 0 0 0 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20] [20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20]\n" + ] + } + ], + "prompt_number": 21 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/test_SMAP_output.ipynb b/test_SMAP_output.ipynb new file mode 100644 index 0000000..2afe73a --- /dev/null +++ b/test_SMAP_output.ipynb @@ -0,0 +1,350 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:d92b51a7b91f24d6635e1ff8e1465ae68db75accbe66179ffaa5b9e4db1fe834" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "code", + "collapsed": false, + "input": [ + "%run basics\n", + "import csv\n", + "from collections import OrderedDict" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 1 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def smap_datetodatadictionary(ds,data_dict,nperday,ndays):\n", + " ldt = ds.series[\"DateTime\"][\"Data\"][si:ei+1]\n", + " # do the months\n", + " month_1d,f,a = qcutils.GetSeries(ds,\"Month\",si=si,ei=ei)\n", + " data_dict[\"Mo\"] = {}\n", + " data_dict[\"Mo\"][\"data\"] = numpy.reshape(month_1d,[ndays,nperday])[:,0]\n", + " data_dict[\"Mo\"][\"fmt\"] = \"0\"\n", + " # do the days\n", + " data_dict[\"Day\"] = {}\n", + " day_1d,f,a = qcutils.GetSeries(ds,\"Day\",si=si,ei=ei)\n", + " data_dict[\"Day\"][\"data\"] = numpy.reshape(day_1d,[ndays,nperday])[:,0]\n", + " data_dict[\"Day\"][\"fmt\"] = \"0\"\n", + " # day of the year\n", + " data_dict[\"DOY\"] = {}\n", + " doy_1d = numpy.array([item.timetuple().tm_yday for item in ldt])\n", + " data_dict[\"DOY\"][\"data\"] = numpy.reshape(doy_1d,[ndays,nperday])[:,0]\n", + " data_dict[\"DOY\"][\"fmt\"] = \"0\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 2 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def smap_updatedatadictionary(cfvars,data_dict,data,flag,smap_label,nperday,ndays):\n", + " data_dict[smap_label] = {}\n", + " if cfvars[smap_label][\"daily\"].lower()==\"sum\":\n", + " data_dict[smap_label][\"data\"] = numpy.ma.sum(numpy.ma.reshape(data,[ndays,nperday]),axis=1)\n", + " elif cfvars[smap_label][\"daily\"].lower()==\"average\":\n", + " data_dict[smap_label][\"data\"] = numpy.ma.average(numpy.ma.reshape(data,[ndays,nperday]),axis=1)\n", + " elif cfvars[smap_label][\"daily\"].lower()==\"skip\":\n", + " data_dict[smap_label][\"data\"] = numpy.reshape(data,[ndays,nperday])[:,0]\n", + " else:\n", + " print \"smap_updatedatadictionary: unrecognised option for daily (\"+str(cfvars[smap_label][\"daily\"])+\")\"\n", + " data_dict[smap_label][\"fmt\"] = cfvars[smap_label][\"format\"]\n", + " if cfvars[smap_label][\"genqc\"]==\"True\":\n", + " smap_qc_label = smap_qclabel(smap_label)\n", + " data_dict[smap_qc_label] = {}\n", + " index_0 = numpy.where(flag==0)[0]\n", + " index_not0 = numpy.where(flag>0)[0]\n", + " flag[index_0] = numpy.int32(1)\n", + " flag[index_not0] = numpy.int32(0)\n", + " data_dict[smap_qc_label][\"data\"] = numpy.ma.sum(numpy.ma.reshape(flag,[ndays,nperday]),axis=1)/float(nperday)\n", + " data_dict[smap_qc_label][\"fmt\"] = \"0.00\"" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 3 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def smap_donetshortwave(ds,smap_label,si,ei):\n", + " ts = int(ds.globalattributes[\"time_step\"])\n", + " # do the net shortwave radiation\n", + " Fsd,Fsd_flag,a = qcutils.GetSeriesasMA(ds,\"Fsd\",si=si,ei=ei)\n", + " Fsu,Fsu_flag,a = qcutils.GetSeriesasMA(ds,\"Fsu\",si=si,ei=ei)\n", + " # get the net shortwave radiation and convert to MJ/m2/day at the same time\n", + " Fnsw = ((Fsd - Fsu)*ts*60)/1E6\n", + " # now get the QC flag\n", + " Fnsw_flag = Fsd_flag+Fsu_flag\n", + " Fnsw = numpy.ma.filled(Fnsw,float(-9999))\n", + " return Fnsw,Fnsw_flag" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 4 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def smap_doshortwave(ds,smap_label,si,ei):\n", + " Fsd,Fsd_flag,a = qcutils.GetSeriesasMA(ds,\"Fsd\",si=si,ei=ei)\n", + " Fsd = (Fsd*ts*60)/1E6\n", + " Fsd = numpy.ma.filled(Fsd,float(-9999))\n", + " return Fsd,Fsd_flag" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 5 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def smap_dopressure(ds,smap_label,si,ei):\n", + " ps,ps_flag,attr = qcutils.GetSeriesasMA(ds,\"ps\",si=si,ei=ei)\n", + " ps = ps/float(1000)\n", + " ps = numpy.ma.filled(ps,float(-9999))\n", + " return ps,ps_flag" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 6 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def smap_docarbonfluxes(ds,smap_label,si,ei):\n", + " data,flag,attr = qcutils.GetSeriesasMA(ds,cfvars[smap_label][\"ncname\"],si=si,ei=ei)\n", + " data = data*12.01*1800/1E6\n", + " data = numpy.ma.filled(data,float(-9999))\n", + " return data,flag" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 7 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def smap_writeheaders(cf,csvfile):\n", + " writer = csv.writer(csvfile)\n", + " # write the header lines to the csv file\n", + " series_list = cf[\"Variables\"].keys()\n", + " for item in cf[\"General\"]:\n", + " if item in [\"SMAP_ID\"]: continue\n", + " writer.writerow([item,str(cf['General'][item])])\n", + " # write the units and variable name header lines to the csv file\n", + " units_list = [\"-\",\"-\",\"-\",\"-\"]\n", + " row_list = ['ID','Mo','Day','DOY']\n", + " for smap_label in series_list:\n", + " row_list.append(smap_label)\n", + " units_list.append(cf[\"Variables\"][smap_label][\"units\"])\n", + " if cf[\"Variables\"][smap_label][\"genqc\"]==\"True\":\n", + " smap_qc_label = smap_qclabel(smap_label)\n", + " row_list.append(smap_qc_label)\n", + " units_list.append(\"-\")\n", + " writer.writerow(units_list)\n", + " writer.writerow(row_list)\n", + " return writer" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 8 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def smap_parseformat(fmt):\n", + " if \".\" in fmt:\n", + " numdec = len(fmt) - (fmt.index(\".\") + 1)\n", + " strfmt = \"{0:.\"+str(numdec)+\"f}\"\n", + " else:\n", + " strfmt = \"{0:d}\"\n", + " return strfmt" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 9 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def smap_qclabel(smap_label):\n", + " if \"_f\" in smap_label:\n", + " smap_qc_label=smap_label.replace(\"_f\",\"_qc\")\n", + " else:\n", + " smap_qc_label=smap_label+\"_qc\"\n", + " return smap_qc_label" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 10 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "cf=qcio.load_controlfile(path=\"../controlfiles/\")\n", + "cfvars = cf[\"Variables\"]\n", + "smap_list = cfvars.keys()\n", + "ncFileName = qcio.get_infilenamefromcf(cf)\n", + "csvFileName_base = qcio.get_outfilenamefromcf(cf)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 11 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# read the netCDF file\n", + "ds = qcio.nc_read_series(ncFileName)\n", + "ts = int(ds.globalattributes[\"time_step\"])\n", + "nRecs = int(ds.globalattributes[\"nc_nrecs\"])\n", + "nperhr = int(float(60)/ts+0.5)\n", + "nperday = int(float(24)*nperhr+0.5)\n", + "dt = ds.series[\"DateTime\"][\"Data\"]\n", + "# get a list of years in the data file\n", + "year_list = range(dt[0].year,dt[-1].year+1)\n", + "years = numpy.array([item.year for item in dt])" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 12 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# loop over years in the data file\n", + "data_dict = OrderedDict()\n", + "for year in year_list:\n", + " csvFileName = csvFileName_base+\"_\"+str(year)+\"_SMAP.csv\"\n", + " # open the csv file\n", + " csvfile = open(csvFileName,'wb')\n", + " # write the header lines\n", + " writer = smap_writeheaders(cf,csvfile)\n", + " # get the start and end datetime\n", + " year_index = numpy.where(years==year)[0]\n", + " # add the last record from this year\n", + " year_index = numpy.append(year_index,year_index[-1]+1)\n", + " sdate = dt[max([0,year_index[0]])]\n", + " edate = dt[min([year_index[-1],nRecs-1])]\n", + " si = qcutils.GetDateIndex(dt,str(sdate),ts=ts,default=0,match=\"startnextday\")\n", + " ei = qcutils.GetDateIndex(dt,str(edate),ts=ts,default=nRecs-1,match=\"endpreviousday\")\n", + " data_dict[\"DateTime\"] = dt[si:ei+1]\n", + " print data_dict[\"DateTime\"][0],data_dict[\"DateTime\"][-1]\n", + " ndays = len(data_dict[\"DateTime\"])/nperday\n", + " # put the month, day and DOY into the data dictionary\n", + " smap_datetodatadictionary(ds,data_dict,nperday,ndays)\n", + " # first column in SMAP csv file will be the SMAP ID number\n", + " smap_id = numpy.array([cf[\"General\"][\"SMAP_ID\"]]*ndays)\n", + " # loop over the data required, massage units if necessary and put the data into a dictionary for later use\n", + " smap_list = [\"Rn_f\",\"Rs_f\",\"PAR_f\",\"Ta\",\"VPD\",\"Ts_f\",\"PREC\",\"SWC\",\"NEE\",\"GPP\",\"Reco\",\"PRESS\",\"SNOWD\"]\n", + " for smap_label in smap_list:\n", + " if smap_label in [\"Mo\",\"Day\",\"DOY\"]: continue\n", + " if smap_label==\"Rn_f\":\n", + " data,flag = smap_donetshortwave(ds,smap_label,si,ei)\n", + " elif smap_label==\"Rs_f\":\n", + " data,flag = smap_doshortwave(ds,smap_label,si,ei)\n", + " elif smap_label==\"PAR_f\" or smap_label==\"SNOWD\":\n", + " data = numpy.array([-9999]*len(data_dict[\"DateTime\"]))\n", + " flag = numpy.array([1]*len(data_dict[\"DateTime\"]))\n", + " cfvars[smap_label][\"daily\"] = \"skip\"\n", + " elif smap_label==\"PRESS\":\n", + " data,flag = smap_dopressure(ds,smap_label,si,ei)\n", + " elif smap_label in [\"GPP\",\"NEE\",\"Reco\"]:\n", + " data,flag = smap_docarbonfluxes(ds,smap_label,si,ei)\n", + " else:\n", + " data,flag,attr = qcutils.GetSeries(ds,cfvars[smap_label][\"ncname\"],si=si,ei=ei)\n", + " smap_updatedatadictionary(cfvars,data_dict,data,flag,smap_label,nperday,ndays)\n", + " # now loop over the days and write the data out\n", + " for i in range(ndays):\n", + " data_list = []\n", + " data_list.append(smap_id[i])\n", + " for smap_label in data_dict.keys():\n", + " if smap_label==\"DateTime\": continue\n", + " strfmt = smap_parseformat(data_dict[smap_label][\"fmt\"])\n", + " if \"d\" in strfmt:\n", + " data_list.append(strfmt.format(int(round(data_dict[smap_label][\"data\"][i]))))\n", + " else:\n", + " data_list.append(strfmt.format(data_dict[smap_label][\"data\"][i]))\n", + " writer.writerow(data_list)\n", + " csvfile.close()" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "2013-01-01 00:30:00 2014-01-01 00:00:00\n", + "2014-01-01 00:30:00 2014-12-31 00:00:00\n" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "print data_dict.keys()" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "['DateTime', 'Mo', 'Day', 'DOY', 'Rn_f', 'Rn_qc', 'Rs_f', 'Rs_qc', 'PAR_f', 'PAR_qc', 'Ta', 'Ta_qc', 'VPD', 'VPD_qc', 'Ts_f', 'Ts_qc', 'PREC', 'SWC', 'NEE', 'NEE_qc', 'GPP', 'GPP_qc', 'Reco', 'Reco_qc', 'PRESS', 'SNOWD']\n" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/test_VPD_gapfilling.ipynb b/test_VPD_gapfilling.ipynb new file mode 100644 index 0000000..d5fd2f7 --- /dev/null +++ b/test_VPD_gapfilling.ipynb @@ -0,0 +1,136 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:a389bddb5399778cfb368f6556abb02a24b06200b26e9e9692b6a4d2dfef4071" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "code", + "collapsed": false, + "input": [ + "%run basics" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 2 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "tower_name=qcio.get_filename_dialog(path=\"../../Sites/\")\n", + "aws_name=qcio.get_filename_dialog(path=\"../../Sites/\")" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 3 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "ds_tower=qcio.nc_read_series(tower_name)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 4 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "ds_aws=qcio.nc_read_series(aws_name)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 5 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "dt_tower=ds_tower.series[\"DateTime\"][\"Data\"]\n", + "dt_aws=ds_aws.series[\"DateTime\"][\"Data\"]" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 6 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "startdate = \"2011-01-01 00:30\"\n", + "enddate = \"2012-01-01 00:00\"\n", + "si_tower=qcutils.GetDateIndex(dt_tower,startdate)\n", + "ei_tower=qcutils.GetDateIndex(dt_tower,enddate)\n", + "si_aws=qcutils.GetDateIndex(dt_aws,startdate)\n", + "ei_aws=qcutils.GetDateIndex(dt_aws,enddate)\n", + "ldt_towere=dt_tower[si_tower:ei_tower+1]\n", + "ldt_aws=dt_aws[si_aws:ei_aws+1]" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 18 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "Ts_tower,f,a=qcutils.GetSeriesasMA(ds_tower,\"Ts\")\n", + "Flu_tower,f,a=qcutils.GetSeriesasMA(ds_tower,\"Flu\")\n", + "Ts_bios,f,a=qcutils.GetSeriesasMA(ds_bios,\"Ts\",si=si_bios,ei=ei_bios)\n", + "Flu_bios,f,a=qcutils.GetSeriesasMA(ds_bios,\"Flu\",si=si_bios,ei=ei_bios)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 19 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "fig=plt.figure(1)\n", + "ax1=plt.subplot(411)\n", + "ax1.plot(dt_tower,Ts_tower,'b.')\n", + "plt.ylabel(\"Ts_tower\")\n", + "ax2=plt.subplot(412)\n", + "ax2.plot(dt_bios,Ts_bios,'b.')\n", + "plt.ylabel(\"Ts_BIOS2\")\n", + "ax3=plt.subplot(413)\n", + "ax3.plot(dt_tower,Flu_tower,'r+')\n", + "plt.ylabel(\"Flu_tower\")\n", + "ax4=plt.subplot(414)\n", + "ax4.plot(dt_bios,Flu_bios,'r+')\n", + "plt.ylabel(\"Flu_BIOS2\")\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 22 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/test_autoSOLO.ipynb b/test_autoSOLO.ipynb new file mode 100644 index 0000000..3c4a58d --- /dev/null +++ b/test_autoSOLO.ipynb @@ -0,0 +1,200 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:0a22945b1bc9db903c8b0b438e3e3e0c8cd5156d2554b1035a28ae8b98b09152" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "code", + "collapsed": false, + "input": [ + "%run basics" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 1 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "ncname=qcio.get_filename_dialog(path=\"../../Sites\")" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 2 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "ds=qcio.nc_read_series(ncname)\n", + "Fc_SOLO,f,a=qcutils.GetSeriesasMA(ds,\"Fc_SOLO\")\n", + "Fc_SOLO_mask=numpy.ma.getmaskarray(Fc_SOLO)\n", + "idx_array = qcutils.contiguous_regions(Fc_SOLO_mask)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 3 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "print idx_array.shape,idx_array.shape[0],idx_array.shape[1]" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(6, 2) 6 2\n" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "print idx_array" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "[[ 7297 11568]\n", + " [ 40849 42336]\n", + " [ 59857 61248]\n", + " [ 62737 64176]\n", + " [ 86113 89040]\n", + " [103633 105120]]\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "si_gap=idx_array[0,0]\n", + "ei_gap=idx_array[0,1]" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 6 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "ldt = ds.series[\"DateTime\"][\"Data\"]\n", + "Fc,f,a=qcutils.GetSeriesasMA(ds,\"Fc\")" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 14 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "si_gfperiod = si_gap\n", + "ei_gfperiod = ei_gap\n", + "min_points = int((ei_gfperiod-si_gfperiod)/2)\n", + "num_good_points = numpy.ma.count(Fc[si_gfperiod:ei_gfperiod])\n", + "print min_points,num_good_points\n", + "while num_good_points= nx or maxlags < 1:\n", + " raise ValueError('qcts.get_laggedcorrelation: maglags must be None or strictly positive < %d'%nx)\n", + " corr = corr[nx-1-maxlags:nx+maxlags]\n", + " return lags,corr\n" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 4 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def gfalternate_loadoutputdata(ds_tower,data_dict,alternate_info):\n", + " label_tower = alternate_info[\"label_tower\"]\n", + " label_output = alternate_info[\"label_output\"]\n", + " label_composite = alternate_info[\"label_composite\"]\n", + " label_alternate = alternate_info[\"label_alternate\"]\n", + " data_tower = data_dict[label_tower][\"data\"]\n", + " if numpy.ma.count(data_tower)D0)[0]\n", - " VPD[idx] = numpy.exp(-k*(D[idx]-D0))\n", - " return VPD" + " SHD_func[idx] = numpy.exp(-k*(D[idx]-D0))\n", + " return SHD_func" ], "language": "python", "metadata": {}, "outputs": [], - "prompt_number": 4 + "prompt_number": 8 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def SHD_func_Isaac(D,D0):\n", + " SHD_func = numpy.ones(len(D))\n", + " idx = numpy.where(D>D0)[0]\n", + " SHD_func[idx] = 1/(1+(D[idx]-D0)/D0)\n", + " return SHD_func" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 9 }, { "cell_type": "code", "collapsed": false, "input": [ "def Reco_LloydTaylor(T,rb,E0):\n", - " return rb*numpy.exp(E0*(1/(c.Tref-c.T0)-1/(T-c.T0)))" + "# return rb*numpy.exp(E0*(1/(c.Tref-c.T0)-1/(T-c.T0)))\n", + " return rb*numpy.exp(E0*(1/(288.13-227.13)-1/((T+273.15)-227.13)))" ], "language": "python", "metadata": {}, "outputs": [], - "prompt_number": 5 + "prompt_number": 10 }, { "cell_type": "code", @@ -106,7 +177,7 @@ "language": "python", "metadata": {}, "outputs": [], - "prompt_number": 6 + "prompt_number": 11 }, { "cell_type": "code", @@ -114,28 +185,36 @@ "input": [ "def irls_leastsq(func,p0,args=(),maxfev=3,weight_type='Huber'):\n", " weighted = False\n", - " p,cov = scipy.optimize.leastsq(func,p0,args=args+(weighted,weight_type))\n", - " print 'After non-weighted call to leastsq: ',p[0],p[1]\n", + " popt,pcov = scipy.optimize.leastsq(func,p0,args=args+(weighted,weight_type))\n", + " print 'After non-weighted call to leastsq: ',popt\n", " n=1\n", " weighted = True\n", " while n<=maxfev:\n", - " p,cov = scipy.optimize.leastsq(func,[p[0],p[1]],args=args+(weighted,weight_type))\n", - " print 'Weighted call '+str(n)+' to leastsq: ',p[0],p[1]\n", + " popt,pcov = scipy.optimize.leastsq(func,popt,args=args+(weighted,weight_type))\n", + " print 'Weighted call '+str(n)+' to leastsq: ',popt\n", + " NEE_plt = NEE_Isaac(args[1],args[2],args[3],args[4],args[5],popt[0],popt[1],popt[2])\n", + "# NEE_plt = NEE_Isaac(args[1:],popt)\n", + " resid = args[0] - NEE_plt\n", + " weights = CalculateWeights(resid,weight_type=weight_type)\n", + " fig = plt.figure()\n", + " plt.scatter(args[1],args[0],c=weights)\n", + " plt.plot(args[1],NEE_plt,'r+')\n", + " plt.show()\n", " n = n + 1\n", - " return p,cov" + " return popt,pcov" ], "language": "python", "metadata": {}, "outputs": [], - "prompt_number": 7 + "prompt_number": 12 }, { "cell_type": "code", "collapsed": false, "input": [ - "def residuals_LT(p,Reco,T,weighted,weight_type):\n", - " rb = p[0]\n", - " E0 = p[1]\n", + "def residuals_LloydTaylor(params,Reco,T,weighted,weight_type):\n", + " rb = params[0]\n", + " E0 = params[1]\n", " resid = Reco - Reco_LloydTaylor(T,rb,E0)\n", " if weighted:\n", " weights = CalculateWeights(resid,weight_type=weight_type)\n", @@ -146,18 +225,18 @@ "language": "python", "metadata": {}, "outputs": [], - "prompt_number": 8 + "prompt_number": 13 }, { "cell_type": "code", "collapsed": false, "input": [ - "def residuals_LL(p,NEE,Fsd,D,T,D0,E0,weighted,weight_type):\n", - " alpha = p[0]\n", - " beta0 = p[1]\n", - " k = p[2]\n", - " rb = p[3]\n", - " resid = NEE - NEE_Lasslop(Fsd,D,T,alpha,beta0,k,rb,D0,E0)\n", + "def residuals_Lasslop(params,NEE,Fsd,D,T,D0,E0,weighted,weight_type):\n", + " alpha = params[0]\n", + " beta0 = params[1]\n", + " k = params[2]\n", + " rb = params[3]\n", + " resid = NEE - NEE_Lasslop(Fsd,D,T,D0,E0,alpha,beta0,k,rb)\n", " if weighted:\n", " weights = CalculateWeights(resid,weight_type=weight_type)\n", " return resid*weights\n", @@ -167,7 +246,28 @@ "language": "python", "metadata": {}, "outputs": [], - "prompt_number": 9 + "prompt_number": 14 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def residuals_Isaac(params,NEE,Fsd,D,T,D0,E0,weighted,weight_type):\n", + " alpha = params[0]\n", + " beta0 = params[1]\n", + " eta = params[2]\n", + " rb = params[3]\n", + " resid = NEE - NEE_NRH_Isaac(Fsd,D,T,D0,E0,alpha,beta0,eta,rb)\n", + " if weighted:\n", + " weights = CalculateWeights(resid,weight_type=weight_type)\n", + " return resid*weights\n", + " else:\n", + " return resid" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 15 }, { "cell_type": "code", @@ -188,7 +288,7 @@ "language": "python", "metadata": {}, "outputs": [], - "prompt_number": 10 + "prompt_number": 16 }, { "cell_type": "code", @@ -200,7 +300,7 @@ "language": "python", "metadata": {}, "outputs": [], - "prompt_number": 11 + "prompt_number": 17 }, { "cell_type": "code", @@ -215,7 +315,7 @@ "language": "python", "metadata": {}, "outputs": [], - "prompt_number": 12 + "prompt_number": 18 }, { "cell_type": "code", @@ -228,7 +328,7 @@ "language": "python", "metadata": {}, "outputs": [], - "prompt_number": 13 + "prompt_number": 19 }, { "cell_type": "code", @@ -241,7 +341,7 @@ "language": "python", "metadata": {}, "outputs": [], - "prompt_number": 14 + "prompt_number": 20 }, { "cell_type": "code", @@ -257,22 +357,15 @@ "language": "python", "metadata": {}, "outputs": [ - { - "output_type": "stream", - "stream": "stderr", - "text": [ - "ERROR:qc.utils:get_UTCfromlocaltime: time_zone not in global attributes, checking elsewhere ...\n" - ] - }, { "output_type": "stream", "stream": "stdout", "text": [ - "/home/peter/OzFlux/Sites/Whroo/Data/Processed/all/Whroo_2011_to_2013_L3.nc\n" + "/home/peter/OzFlux/Sites/HowardSprings/Data/Processed/all/HowardSprings_2011_to_2013_L5.nc\n" ] } ], - "prompt_number": 38 + "prompt_number": 21 }, { "cell_type": "code", @@ -281,19 +374,43 @@ "Fsd,f,a = qcutils.GetSeriesasMA(ds,\"Fsd\")\n", "D,f,a = qcutils.GetSeriesasMA(ds,\"SHD\")\n", "T,f,a = qcutils.GetSeriesasMA(ds,\"Ts\")\n", - "Fc,f,a = qcutils.GetSeriesasMA(ds,\"Fc\")\n", - "fig1,axs = plt.subplots(nrows=4,ncols=1,sharex=True)\n", - "axs[0].plot(Fsd)\n", - "axs[1].plot(D)\n", - "axs[2].plot(T)\n", - "axs[3].plot(Fc)\n", - "plt.show\n", + "Fc,f,a = qcutils.GetSeriesasMA(ds,\"Fc\")" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 22 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "fig = plt.figure(1)\n", + "ax1=plt.subplot(411)\n", + "plt.plot(ldt,Fsd)\n", + "ax2=plt.subplot(412,sharex=ax1)\n", + "plt.plot(ldt,D)\n", + "ax3=plt.subplot(413,sharex=ax1)\n", + "plt.plot(ldt,T)\n", + "ax4=plt.subplot(414,sharex=ax1)\n", + "plt.plot(ldt,Fc)\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 23 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ "Fc = numpy.ma.masked_where(f!=0,Fc)\n", "Fc_day = numpy.ma.masked_where(Fsd<=10,Fc)\n", "mask = Fc_day.mask\n", "for item in [D,T]:\n", " mask = numpy.ma.mask_or(mask,item.mask)\n", - "NEP_day = -1*numpy.ma.array(Fc_day,mask=mask)\n", + "NEE_day = numpy.ma.array(Fc_day,mask=mask)\n", "Fsd = numpy.ma.array(Fsd,mask=mask)\n", "D = numpy.ma.array(D,mask=mask)\n", "T = numpy.ma.array(T,mask=mask)" @@ -301,19 +418,27 @@ "language": "python", "metadata": {}, "outputs": [], - "prompt_number": 39 + "prompt_number": 24 }, { "cell_type": "code", "collapsed": false, "input": [ - "plt.plot(T)\n", + "fig = plt.figure(1)\n", + "ax1=plt.subplot(411)\n", + "plt.plot(ldt,Fsd)\n", + "ax2=plt.subplot(412,sharex=ax1)\n", + "plt.plot(ldt,D)\n", + "ax3=plt.subplot(413,sharex=ax1)\n", + "plt.plot(ldt,T)\n", + "ax4=plt.subplot(414,sharex=ax1)\n", + "plt.plot(ldt,NEE_day)\n", "plt.show()" ], "language": "python", "metadata": {}, "outputs": [], - "prompt_number": 30 + "prompt_number": 25 }, { "cell_type": "code", @@ -322,41 +447,68 @@ "start_date = ldt[0]\n", "end_date = datetime.datetime(start_date.year+1,1,1)+datetime.timedelta(minutes=ts)\n", "this_date = start_date + datetime.timedelta(days=10)\n", - "while this_date\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 9\u001b[0m \u001b[0mD_plt\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnumpy\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mma\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcompressed\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mD\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0msi\u001b[0m\u001b[1;33m:\u001b[0m\u001b[0mei\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 10\u001b[0m \u001b[0mT_plt\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnumpy\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mma\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcompressed\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mT\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0msi\u001b[0m\u001b[1;33m:\u001b[0m\u001b[0mei\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 11\u001b[1;33m \u001b[0mpopt\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mpcov\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mirls_leastsq\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mresiduals_LL\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0.1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m100\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mNEP_plt\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mFsd_plt\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mD_plt\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mT_plt\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m0.01\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m210\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mmaxfev\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mweight_type\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'Huber'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 12\u001b[0m \u001b[1;32mprint\u001b[0m \u001b[0mstart_date\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mthis_date\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mpopt\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mpopt\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 13\u001b[0m \u001b[0mstart_date\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mstart_date\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mdatetime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtimedelta\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdays\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m\u001b[0m in \u001b[0;36mirls_leastsq\u001b[1;34m(func, p0, args, maxfev, weight_type)\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mirls_leastsq\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mp0\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mmaxfev\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mweight_type\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'Huber'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0mweighted\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mFalse\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mp\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mcov\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mscipy\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0moptimize\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mleastsq\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mp0\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mweighted\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mweight_type\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 4\u001b[0m \u001b[1;32mprint\u001b[0m \u001b[1;34m'After non-weighted call to leastsq: '\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mp\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mp\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[0mn\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m/home/peter/anaconda/lib/python2.7/site-packages/scipy/optimize/minpack.pyc\u001b[0m in \u001b[0;36mleastsq\u001b[1;34m(func, x0, args, Dfun, full_output, col_deriv, ftol, xtol, gtol, maxfev, epsfcn, factor, diag)\u001b[0m\n\u001b[0;32m 370\u001b[0m \u001b[0mm\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 371\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mn\u001b[0m \u001b[1;33m>\u001b[0m \u001b[0mm\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 372\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Improper input: N=%s must not exceed M=%s'\u001b[0m \u001b[1;33m%\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mn\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mm\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 373\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mepsfcn\u001b[0m \u001b[1;32mis\u001b[0m \u001b[0mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 374\u001b[0m \u001b[0mepsfcn\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfinfo\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdtype\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0meps\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mTypeError\u001b[0m: Improper input: N=4 must not exceed M=0" - ] - } + "outputs": [], + "prompt_number": 26 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "fig=plt.figure(1)\n", + "ax1=plt.subplot(411)\n", + "plt.plot(ldt_plt,Fsd_plt,'b.')\n", + "ax2=plt.subplot(412,sharex=ax1)\n", + "plt.plot(ldt_plt,D_plt,'b.')\n", + "ax3=plt.subplot(413,sharex=ax1)\n", + "plt.plot(ldt_plt,T_plt,'b.')\n", + "ax4=plt.subplot(414,sharex=ax1)\n", + "plt.plot(ldt_plt,NEE_plt,'b.')\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 27 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "fig=plt.figure(1)\n", + "plt.plot(Fsd_plt,NEE_plt,'b.')\n", + "plt.show()" ], - "prompt_number": 33 + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 26 }, { "cell_type": "code", "collapsed": false, "input": [ - "print len(NEP_day)" + "#popt,pcov = irls_leastsq(residuals_Lasslop,[0.1,100,0,1],args=(NEE_plt,Fsd_plt,D_plt,T_plt,0.005,210),maxfev=3,weight_type='Huber')\n", + "popt,pcov = irls_leastsq(residuals_Isaac,[0.1,100,1,1],args=(NEE_plt,Fsd_plt,D_plt,T_plt,0.005,50),maxfev=3,weight_type='Huber')\n", + "print start_date,this_date,popt\n", + "start_date = start_date + datetime.timedelta(days=5)\n", + "this_date = start_date + datetime.timedelta(days=10)" ], "language": "python", "metadata": {}, @@ -365,23 +517,49 @@ "output_type": "stream", "stream": "stdout", "text": [ - "52607\n" + "After non-weighted call to leastsq: [ 3.99699570e-02 7.51855105e+01 2.77850107e-01 1.00000000e+00]\n", + "Weighted call 1 to leastsq: [ 3.92300536e-02 7.56530178e+01 2.73494580e-01 1.00000000e+00]\n", + "Weighted call 2 to leastsq: " + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + " [ 3.92300550e-02 7.56530243e+01 2.73494709e-01 1.00000000e+00]\n", + "Weighted call 3 to leastsq: " + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + " [ 3.92300550e-02 7.56530243e+01 2.73494709e-01 1.00000000e+00]\n", + "2011-01-16 00:30:00" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + " 2011-01-26 00:30:00 [ 3.92300550e-02 7.56530243e+01 2.73494709e-01 1.00000000e+00]\n" ] } ], - "prompt_number": 19 + "prompt_number": 31 }, { "cell_type": "code", "collapsed": false, "input": [ - "plt.plot(Fsd)\n", + "fig=plt.figure()\n", + "plt.plot(D_plt,SHD_func_Isaac(D_plt,0.005),'b.')\n", "plt.show()" ], "language": "python", "metadata": {}, "outputs": [], - "prompt_number": 26 + "prompt_number": 44 }, { "cell_type": "code", diff --git a/test_opendap.ipynb b/test_opendap.ipynb new file mode 100644 index 0000000..9fe7f3c --- /dev/null +++ b/test_opendap.ipynb @@ -0,0 +1,1398 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:8d2263d77006985d455b8227d8ff5a2b7d88c7cc97be18be4c3c4b721544ea7b" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import netCDF4\n", + "import matplotlib.pylab as plt" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 1 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# make the URL that points to the Whroo L6 file on the OzFlux DAP server\n", + "dappath = \"http://dap.ozflux.org.au/\"\n", + "dapname = \"/thredds/dodsC/ozflux/sites/Whroo/L6/Whroo_2012_to_2013_L6.nc\"\n", + "dapfullname = dappath+dapname" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 2 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# open the remore file\n", + "root = netCDF4.Dataset(dapfullname)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 3 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# print the dimensions\n", + "for item in root.dimensions:\n", + " print item+\": \",root.dimensions[item]" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "latitude: : name = 'latitude', size = 1\n", + "\n", + "longitude: : name = 'longitude', size = 1\n", + "\n", + "time: : name = 'time', size = 35087\n", + "\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# print a list of variables and their attributes\n", + "for item in root.variables:\n", + " print item+\": \",root.variables[item]" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "latitude: \n", + "float64 latitude(latitude)\n", + " long_name: latitude\n", + " standard_name: latitude\n", + " units: degrees north\n", + "unlimited dimensions: \n", + "current shape = (1,)\n", + "filling off\n", + "\n", + "longitude: \n", + "float64 longitude(longitude)\n", + " long_name: longitude\n", + " standard_name: longitude\n", + " units: degrees east\n", + "unlimited dimensions: \n", + "current shape = (1,)\n", + "filling off\n", + "\n", + "time: \n", + "float32 time(time)\n", + " units: days since 1800-01-01 00:00:00.0\n", + " long_name: time\n", + " standard_name: time\n", + " coverage_L6: 100\n", + " calendar: gregorian\n", + "unlimited dimensions: \n", + "current shape = (35087,)\n", + "filling off\n", + "\n", + "crs: \n", + "int32 crs()\n", + " grid_mapping_name: latitude_longitude\n", + " long_name: WGS 1984 datum\n", + " longitude_of_prime_meridian: 0.0\n", + " semi_major_axis: 6378137.0\n", + " inverse_flattening: 298.257223563\n", + "unlimited dimensions: \n", + "current shape = ()\n", + "filling off\n", + "\n", + "Day: \n", + "int32 Day(time, latitude, longitude)\n", + " long_name: Day\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " coverage_L2: 100\n", + " instrument: not defined\n", + " standard_name: not defined\n", + " coverage_L3: 100\n", + " coverage_L6: 100\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: none\n", + " serial_number: not defined\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Day_QCFlag: \n", + "float64 Day_QCFlag(time, latitude, longitude)\n", + " long_name: DayQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Hdh: \n", + "float64 Hdh(time, latitude, longitude)\n", + " long_name: Decimal hour of the day\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " coverage_L2: 100\n", + " instrument: not defined\n", + " standard_name: not defined\n", + " coverage_L3: 100\n", + " coverage_L6: 100\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: none\n", + " serial_number: not defined\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Hdh_QCFlag: \n", + "float64 Hdh_QCFlag(time, latitude, longitude)\n", + " long_name: HdhQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Hour: \n", + "int32 Hour(time, latitude, longitude)\n", + " long_name: Hour\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " coverage_L2: 100\n", + " instrument: not defined\n", + " standard_name: not defined\n", + " coverage_L3: 100\n", + " coverage_L6: 100\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: none\n", + " serial_number: not defined\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Hour_QCFlag: \n", + "float64 Hour_QCFlag(time, latitude, longitude)\n", + " long_name: HourQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Minute: \n", + "int32 Minute(time, latitude, longitude)\n", + " long_name: Minute\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " coverage_L2: 100\n", + " instrument: not defined\n", + " standard_name: not defined\n", + " coverage_L3: 100\n", + " coverage_L6: 100\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: none\n", + " serial_number: not defined\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Minute_QCFlag: \n", + "float64 Minute_QCFlag(time, latitude, longitude)\n", + " long_name: MinuteQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Month: \n", + "int32 Month(time, latitude, longitude)\n", + " long_name: Month\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " coverage_L2: 100\n", + " instrument: not defined\n", + " standard_name: not defined\n", + " coverage_L3: 100\n", + " coverage_L6: 100\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: none\n", + " serial_number: not defined\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Month_QCFlag: \n", + "float64 Month_QCFlag(time, latitude, longitude)\n", + " long_name: MonthQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Second: \n", + "int32 Second(time, latitude, longitude)\n", + " long_name: Second\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " coverage_L2: 100\n", + " instrument: not defined\n", + " standard_name: not defined\n", + " coverage_L3: 100\n", + " coverage_L6: 100\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: none\n", + " serial_number: not defined\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Second_QCFlag: \n", + "float64 Second_QCFlag(time, latitude, longitude)\n", + " units: none\n", + " long_name: SecondQC flag\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Year: \n", + "int32 Year(time, latitude, longitude)\n", + " long_name: Year\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " coverage_L2: 100\n", + " instrument: not defined\n", + " standard_name: not defined\n", + " coverage_L3: 100\n", + " coverage_L6: 100\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: none\n", + " serial_number: not defined\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Year_QCFlag: \n", + "float64 Year_QCFlag(time, latitude, longitude)\n", + " long_name: YearQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "xlDateTime: \n", + "float64 xlDateTime(time, latitude, longitude)\n", + " coverage_L3: 100\n", + " cf_role: timeseries_id\n", + " coverage_L2: 100\n", + " long_name: Date/time in Excel format\n", + " standard_name: not defined\n", + " coverage_L6: 100\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: days since 1899-12-31 00:00:00 +9:30\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "xlDateTime_QCFlag: \n", + "int32 xlDateTime_QCFlag(time, latitude, longitude)\n", + " long_name: xlDateTimeQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Ah: \n", + "float32 Ah(time, latitude, longitude)\n", + " instrument: HMP45C\n", + " ancillary_variables: Ah_HMP_16m QC flag\n", + " serial_number: ?\n", + " height: 16m\n", + " coverage_L2: 98\n", + " long_name: Merged from Ah_HMP_16m, Ah_7500_Av, Ah_LI840_32m, Ah_HMP_8m, Ah_HMP_4m, Ah_HMP_2m, Ah_HMP_1m, Ah_HMP_32m, merged from Ah, Ah_acc, Ah_cli\n", + " standard_name: not defined\n", + " coverage_L6: 100\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: g/m3\n", + " coverage_L3: 99\n", + " valid_range: 0,30\n", + " rangecheck_upper: [30]*12\n", + " rangecheck_lower: [0]*12\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Ah_QCFlag: \n", + "float64 Ah_QCFlag(time, latitude, longitude)\n", + " units: none\n", + " long_name: AhQC flag\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Cc: \n", + "float32 Cc(time, latitude, longitude)\n", + " ExcludeDates_0: ['2012-06-01 00:00','2012-06-24 00:00']\n", + " long_name: converted to umol/mol, merged from Cc, Cc_cli\n", + " ExcludeDates_1: ['2012-05-31 03:30','2012-05-31 10:30']\n", + " ancillary_variables: not defined\n", + " serial_number: not defined\n", + " height: not defined\n", + " coverage_L2: 88\n", + " instrument: not defined\n", + " standard_name: not defined\n", + " coverage_L6: 100\n", + " ExcludeDates_2: ['2012-08-13 04:00','2012-08-13 10:30']\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: umol/mol\n", + " coverage_L3: 88\n", + " valid_range: 250,900\n", + " rangecheck_upper: [900]*12\n", + " rangecheck_lower: [250]*12\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Cc_QCFlag: \n", + "float64 Cc_QCFlag(time, latitude, longitude)\n", + " units: none\n", + " long_name: CcQC flag\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "EVI: \n", + "float32 EVI(time, latitude, longitude)\n", + " instrument: not defined\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " long_name: MODIS EVI, 250m, interpolated\n", + " standard_name: not defined\n", + " coverage_L6: 100\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: none\n", + " serial_number: not defined\n", + " missing_value: -9999.0\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "EVI_QCFlag: \n", + "float64 EVI_QCFlag(time, latitude, longitude)\n", + " long_name: EVIQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fa: \n", + "float32 Fa(time, latitude, longitude)\n", + " long_name: Available energy using Fn,Fg, merged from Fa, Fa_acc, Fa_cli\n", + " instrument: not defined\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " coverage_L3: 96\n", + " standard_name: not defined\n", + " coverage_L6: 100\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: W/m2\n", + " serial_number: not defined\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fa_QCFlag: \n", + "float64 Fa_QCFlag(time, latitude, longitude)\n", + " long_name: FaQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fc: \n", + "float32 Fc(time, latitude, longitude)\n", + " coverage_L3: 89\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " long_name: converted to umol/m2/s, merged from Fc, Fc_SOLO\n", + " standard_name: not defined\n", + " coverage_L6: 100\n", + " instrument: not defined\n", + " coverage_L4: 89\n", + " coverage_L5: 100\n", + " units: umol/m2/s\n", + " serial_number: not defined\n", + " valid_range: -15,10\n", + " rangecheck_upper: [10]*12\n", + " rangecheck_lower: [-15]*12\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fc_QCFlag: \n", + "float64 Fc_QCFlag(time, latitude, longitude)\n", + " units: none\n", + " long_name: FcQC flag\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fc_storage: \n", + "float32 Fc_storage(time, latitude, longitude)\n", + " long_name: converted to umol/m2/s\n", + " instrument: not defined\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " coverage_L3: 87\n", + " standard_name: not defined\n", + " coverage_L6: 91\n", + " coverage_L4: 87\n", + " coverage_L5: 87\n", + " units: umol/m2/s\n", + " serial_number: not defined\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fc_storage_QCFlag: \n", + "float64 Fc_storage_QCFlag(time, latitude, longitude)\n", + " long_name: Fc_storageQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fe: \n", + "float32 Fe(time, latitude, longitude)\n", + " long_name: WPL corrected Fe, merged from Fe, Fe_SOLO\n", + " instrument: not defined\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " coverage_L3: 91\n", + " standard_name: surface_upward_latent_heat_flux\n", + " coverage_L6: 100\n", + " coverage_L4: 91\n", + " coverage_L5: 100\n", + " units: W/m2\n", + " serial_number: not defined\n", + " valid_range: -100,190\n", + " rangecheck_upper: [300,350,300,280,200,200,200,190,200,230,255,300]\n", + " rangecheck_lower: [-100]*12\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fe_QCFlag: \n", + "float64 Fe_QCFlag(time, latitude, longitude)\n", + " long_name: FeQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fg: \n", + "float32 Fg(time, latitude, longitude)\n", + " long_name: Soil heat flux corrected for storage, merged from Fg, Fg_acc, Fg_cli\n", + " ancillary_variables: not defined\n", + " serial_number: not defined\n", + " height: not defined\n", + " coverage_L2: 98\n", + " instrument: not defined\n", + " standard_name: downward_heat_flux_in_soil\n", + " coverage_L6: 100\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: W/m2\n", + " coverage_L3: 98\n", + " valid_range: -100,300\n", + " rangecheck_upper: [300]*12\n", + " rangecheck_lower: [-100]*12\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fg_QCFlag: \n", + "float64 Fg_QCFlag(time, latitude, longitude)\n", + " long_name: FgQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fh: \n", + "float32 Fh(time, latitude, longitude)\n", + " coverage_L3: 91\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " long_name: Sensible heat flux from virtual heat flux, merged from Fh, Fh_SOLO\n", + " standard_name: surface_upward_sensible_heat_flux\n", + " coverage_L6: 100\n", + " instrument: not defined\n", + " coverage_L4: 91\n", + " coverage_L5: 100\n", + " units: W/m2\n", + " serial_number: not defined\n", + " valid_range: -100,650\n", + " rangecheck_upper: [650]*12\n", + " rangecheck_lower: [-100]*12\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fh_QCFlag: \n", + "float64 Fh_QCFlag(time, latitude, longitude)\n", + " units: none\n", + " long_name: FhQC flag\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fld: \n", + "float32 Fld(time, latitude, longitude)\n", + " instrument: Kipp and Zonen CNR4\n", + " ancillary_variables: Fld QC flag\n", + " serial_number: ?\n", + " height: 36m\n", + " coverage_L2: 99\n", + " long_name: Down-welling long wave\", merged from Fld, Fld_acc, Fld_cli\n", + " standard_name: surface_downwelling_longwave_flux_in_air\n", + " coverage_L6: 100\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: W/m2\n", + " coverage_L3: 99\n", + " valid_range: 250,700\n", + " rangecheck_upper: [700]*12\n", + " rangecheck_lower: [250]*12\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fld_QCFlag: \n", + "float64 Fld_QCFlag(time, latitude, longitude)\n", + " units: none\n", + " long_name: FldQC flag\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Flu: \n", + "float32 Flu(time, latitude, longitude)\n", + " instrument: Kipp and Zonen CNR4\n", + " ancillary_variables: Flu QC flag\n", + " serial_number: ?\n", + " height: 36m\n", + " coverage_L2: 99\n", + " long_name: Up-welling long wave, merged from Flu, Flu_acc, Flu_cli\n", + " standard_name: surface_upwelling_longwave_flux_in_air\n", + " coverage_L6: 100\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: W/m2\n", + " coverage_L3: 99\n", + " valid_range: 250,700\n", + " rangecheck_upper: [700]*12\n", + " rangecheck_lower: [250]*12\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Flu_QCFlag: \n", + "float64 Flu_QCFlag(time, latitude, longitude)\n", + " units: none\n", + " long_name: FluQC flag\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fm: \n", + "float32 Fm(time, latitude, longitude)\n", + " coverage_L3: 98\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " long_name: Momentum flux, rotated to natural wind coordinates\n", + " standard_name: not defined\n", + " coverage_L6: 98\n", + " instrument: not defined\n", + " coverage_L4: 98\n", + " coverage_L5: 98\n", + " units: kg/m/s2\n", + " serial_number: not defined\n", + " valid_range: -2,3.7\n", + " rangecheck_upper: [3.7]*12\n", + " rangecheck_lower: [-2]*12\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fm_QCFlag: \n", + "float64 Fm_QCFlag(time, latitude, longitude)\n", + " long_name: FmQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fn: \n", + "float32 Fn(time, latitude, longitude)\n", + " coverage_L3: 98\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " long_name: Calculated net radiation using Fsd,Fsu,Fld,Flu, merged from Fn, Fn_acc, Fn_cli\n", + " standard_name: surface_net_allwave_radiation\n", + " coverage_L6: 100\n", + " instrument: not defined\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: W/m2\n", + " serial_number: not defined\n", + " valid_range: -150,1100\n", + " rangecheck_upper: [1100]*12\n", + " rangecheck_lower: [-150]*12\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fn_QCFlag: \n", + "float64 Fn_QCFlag(time, latitude, longitude)\n", + " long_name: FnQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fre: \n", + "float32 Fre(time, latitude, longitude)\n", + " long_name: Ecosystem respiration (observed)\n", + " ustar_threshold_1: ['2013-01-01 00:30', '2014-01-01 00:00', 0.4]\n", + " ustar_threshold_0: ['2012-01-01 00:30', '2013-01-01 00:00', 0.4]\n", + " ancillary_variables: not defined\n", + " Fsd_threshold: 10.0\n", + " height: not defined\n", + " instrument: not defined\n", + " standard_name: not defined\n", + " coverage_L6: 19\n", + " units: umol/m2/s\n", + " serial_number: not defined\n", + " missing_value: -9999.0\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fre_QCFlag: \n", + "int32 Fre_QCFlag(time, latitude, longitude)\n", + " long_name: FreQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fre_FFNET: \n", + "float32 Fre_FFNET(time, latitude, longitude)\n", + " long_name: Ecosystem respiration (observed), merged from Fre, Fre_FFNET_all\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " instrument: not defined\n", + " standard_name: not defined\n", + " coverage_L6: 19\n", + " units: umol/m2/s\n", + " serial_number: not defined\n", + " missing_value: -9999.0\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fre_FFNET_QCFlag: \n", + "int32 Fre_FFNET_QCFlag(time, latitude, longitude)\n", + " long_name: Fre_FFNETQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fre_FFNET_all: \n", + "float64 Fre_FFNET_all(time, latitude, longitude)\n", + " instrument: not defined\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " long_name: not defined\n", + " standard_name: not defined\n", + " coverage_L6: 0\n", + " units: not defined\n", + " serial_number: not defined\n", + " missing_value: -9999.0\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fre_FFNET_all_QCFlag: \n", + "int32 Fre_FFNET_all_QCFlag(time, latitude, longitude)\n", + " long_name: Fre_FFNET_allQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fre_LL: \n", + "float32 Fre_LL(time, latitude, longitude)\n", + " long_name: Ecosystem respiration (observed), merged from Fre\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " instrument: not defined\n", + " standard_name: not defined\n", + " coverage_L6: 19\n", + " units: umol/m2/s\n", + " serial_number: not defined\n", + " missing_value: -9999.0\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fre_LL_QCFlag: \n", + "int32 Fre_LL_QCFlag(time, latitude, longitude)\n", + " units: none\n", + " long_name: Fre_LLQC flag\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fre_LT: \n", + "float32 Fre_LT(time, latitude, longitude)\n", + " long_name: Ecosystem respiration (observed), merged from Fre\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " instrument: not defined\n", + " standard_name: not defined\n", + " coverage_L6: 19\n", + " units: umol/m2/s\n", + " serial_number: not defined\n", + " missing_value: -9999.0\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fre_LT_QCFlag: \n", + "int32 Fre_LT_QCFlag(time, latitude, longitude)\n", + " long_name: Fre_LTQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fre_SOLO: \n", + "float32 Fre_SOLO(time, latitude, longitude)\n", + " long_name: Ecosystem respiration (observed), merged from Fre, Fre_SOLO_all\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " instrument: not defined\n", + " standard_name: not defined\n", + " coverage_L6: 19\n", + " units: umol/m2/s\n", + " serial_number: not defined\n", + " missing_value: -9999.0\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fre_SOLO_QCFlag: \n", + "int32 Fre_SOLO_QCFlag(time, latitude, longitude)\n", + " units: none\n", + " long_name: Fre_SOLOQC flag\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fre_SOLO_all: \n", + "float64 Fre_SOLO_all(time, latitude, longitude)\n", + " instrument: not defined\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " long_name: not defined\n", + " standard_name: not defined\n", + " coverage_L6: 0\n", + " units: not defined\n", + " serial_number: not defined\n", + " missing_value: -9999.0\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fre_SOLO_all_QCFlag: \n", + "int32 Fre_SOLO_all_QCFlag(time, latitude, longitude)\n", + " units: none\n", + " long_name: Fre_SOLO_allQC flag\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fsd: \n", + "float32 Fsd(time, latitude, longitude)\n", + " instrument: Kipp and Zonen CNR4\n", + " ancillary_variables: Fsd QC flag\n", + " serial_number: ?\n", + " height: 36m\n", + " coverage_L2: 98\n", + " long_name: Down-welling short wave, merged from Fsd, Fsd_acc, Fsd_cli\n", + " standard_name: surface_downwelling_shortwave_flux_in_air\n", + " coverage_L6: 100\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: W/m2\n", + " coverage_L3: 98\n", + " valid_range: -10,1500\n", + " rangecheck_upper: [1500]*12\n", + " rangecheck_lower: [-10]*12\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fsd_QCFlag: \n", + "float64 Fsd_QCFlag(time, latitude, longitude)\n", + " long_name: FsdQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fsu: \n", + "float32 Fsu(time, latitude, longitude)\n", + " instrument: Kipp and Zonen CNR4\n", + " ancillary_variables: Fsu QC flag\n", + " serial_number: ?\n", + " height: 36m\n", + " coverage_L2: 99\n", + " long_name: Up-welling short wave, merged from Fsu, Fsu_acc, Fsu_cli\n", + " standard_name: surface_upwelling_shortwave_flux_in_air\n", + " coverage_L6: 100\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: W/m2\n", + " coverage_L3: 99\n", + " valid_range: -10,200\n", + " rangecheck_upper: [200]*12\n", + " rangecheck_lower: [-10]*12\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Fsu_QCFlag: \n", + "float64 Fsu_QCFlag(time, latitude, longitude)\n", + " long_name: FsuQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "GPP_FFNET: \n", + "float64 GPP_FFNET(time, latitude, longitude)\n", + " instrument: not defined\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " long_name: Gross Primary Productivity calculated from NEE_FFNET (NEE) and Fre_FFNET (Fre)\n", + " standard_name: not defined\n", + " coverage_L6: 100\n", + " units: umol/m2/s\n", + " serial_number: not defined\n", + " missing_value: -9999.0\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "GPP_FFNET_QCFlag: \n", + "int32 GPP_FFNET_QCFlag(time, latitude, longitude)\n", + " long_name: GPP_FFNETQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "GPP_SOLO: \n", + "float64 GPP_SOLO(time, latitude, longitude)\n", + " instrument: not defined\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " long_name: Gross Primary Productivity calculated from NEE_SOLO (NEE) and Fre_SOLO (Fre)\n", + " standard_name: not defined\n", + " coverage_L6: 100\n", + " units: umol/m2/s\n", + " serial_number: not defined\n", + " missing_value: -9999.0\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "GPP_SOLO_QCFlag: \n", + "int32 GPP_SOLO_QCFlag(time, latitude, longitude)\n", + " units: none\n", + " long_name: GPP_SOLOQC flag\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "NEE_FFNET: \n", + "float64 NEE_FFNET(time, latitude, longitude)\n", + " instrument: not defined\n", + " comment1: Fsd threshold used was 10.0\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " long_name: Net Ecosystem Exchange calculated from Fc (Fc) and Fre_FFNET (Fre)\n", + " standard_name: not defined\n", + " coverage_L6: 68\n", + " units: umol/m2/s\n", + " serial_number: not defined\n", + " missing_value: -9999.0\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "NEE_FFNET_QCFlag: \n", + "int32 NEE_FFNET_QCFlag(time, latitude, longitude)\n", + " long_name: NEE_FFNETQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "NEE_SOLO: \n", + "float64 NEE_SOLO(time, latitude, longitude)\n", + " instrument: not defined\n", + " comment1: Fsd threshold used was 10.0\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " long_name: Net Ecosystem Exchange calculated from Fc (Fc) and Fre_SOLO (Fre)\n", + " standard_name: not defined\n", + " coverage_L6: 68\n", + " units: umol/m2/s\n", + " serial_number: not defined\n", + " missing_value: -9999.0\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "NEE_SOLO_QCFlag: \n", + "int32 NEE_SOLO_QCFlag(time, latitude, longitude)\n", + " long_name: NEE_SOLOQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Precip: \n", + "float32 Precip(time, latitude, longitude)\n", + " ExcludeDates_0: ['2012-01-01 00:00','2013-01-01 00:00']\n", + " long_name: Rainfall, 30 minute total, merged from Precip, Precip_bios\n", + " ancillary_variables: Precip QC flag\n", + " height: 0.6m\n", + " coverage_L2: 0\n", + " instrument: Hydrological Services CS7000\n", + " standard_name: rainfall_amount\n", + " coverage_L3: 0\n", + " coverage_L6: 100\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: mm\n", + " serial_number: ?\n", + " valid_range: 0,50\n", + " rangecheck_upper: [50]*12\n", + " rangecheck_lower: [0]*12\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Precip_QCFlag: \n", + "float64 Precip_QCFlag(time, latitude, longitude)\n", + " long_name: PrecipQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "RH: \n", + "float32 RH(time, latitude, longitude)\n", + " instrument: not defined\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " long_name: Relative humidity\n", + " standard_name: not defined\n", + " coverage_L6: 100\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: %\n", + " serial_number: not defined\n", + " missing_value: -9999.0\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "RH_QCFlag: \n", + "float64 RH_QCFlag(time, latitude, longitude)\n", + " long_name: RHQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Sws: \n", + "float32 Sws(time, latitude, longitude)\n", + " instrument: Campbell Scientific CS616\n", + " ancillary_variables: Sws_10cma QC flag\n", + " serial_number: ?\n", + " height: -0.1m\n", + " coverage_L2: 98\n", + " long_name: Element-wise average of series Sws_10cma, Sws_10cmb, Sws_10cmc, Sws_10cmd, merged from Sws, Sws_bios\n", + " standard_name: soil_moisture_content\n", + " coverage_L6: 100\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: frac\n", + " coverage_L3: 98\n", + " valid_range: 0,0.7\n", + " rangecheck_upper: [0.70]*12\n", + " rangecheck_lower: [0]*12\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Sws_QCFlag: \n", + "float64 Sws_QCFlag(time, latitude, longitude)\n", + " long_name: SwsQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Ta: \n", + "float32 Ta(time, latitude, longitude)\n", + " instrument: HMP45C\n", + " ancillary_variables: Ta_HMP_16m QC flag\n", + " serial_number: ?\n", + " height: 16m\n", + " coverage_L2: 98\n", + " long_name: Merged from Ta_HMP_16m, Ta_CSAT, Ta_HMP_8m, Ta_HMP_4m, Ta_HMP_2m, Ta_HMP_1m, Ta_HMP_32m, merged from Ta, Ta_acc, Ta_cli\n", + " standard_name: air_temperature\n", + " coverage_L6: 100\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: C\n", + " coverage_L3: 99\n", + " valid_range: -10,50\n", + " rangecheck_upper: [50]*12\n", + " rangecheck_lower: [-10]*12\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Ta_QCFlag: \n", + "float64 Ta_QCFlag(time, latitude, longitude)\n", + " long_name: TaQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Ts: \n", + "float32 Ts(time, latitude, longitude)\n", + " instrument: Campbell Scientific TCAV\n", + " ancillary_variables: Ts_8cma QC flag\n", + " serial_number: ?\n", + " height: -0.08m\n", + " coverage_L2: 98\n", + " long_name: Element-wise average of series Ts_8cma, Ts_8cmb, Ts_8cmc, Ts_8cmd, merged from Ts, Ts_acc, Ts_cli\n", + " standard_name: soil_temperature\n", + " coverage_L6: 100\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: C\n", + " coverage_L3: 98\n", + " valid_range: 0,60\n", + " rangecheck_upper: [60]*12\n", + " rangecheck_lower: [0]*12\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Ts_QCFlag: \n", + "float64 Ts_QCFlag(time, latitude, longitude)\n", + " long_name: TsQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Wd: \n", + "float32 Wd(time, latitude, longitude)\n", + " instrument: RM Young\n", + " ancillary_variables: Wd_32m QC flag\n", + " serial_number: ?\n", + " height: 32m\n", + " coverage_L2: 98\n", + " long_name: Merged from Wd_RMY_32m, Wd_CSAT\n", + " standard_name: wind_from_direction\n", + " coverage_L6: 99\n", + " coverage_L4: 99\n", + " coverage_L5: 99\n", + " units: deg\n", + " coverage_L3: 99\n", + " valid_range: 0,360\n", + " rangecheck_upper: [360]*12\n", + " rangecheck_lower: [0]*12\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Wd_QCFlag: \n", + "float64 Wd_QCFlag(time, latitude, longitude)\n", + " units: none\n", + " long_name: WdQC flag\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Ws: \n", + "float32 Ws(time, latitude, longitude)\n", + " instrument: RM Young\n", + " ancillary_variables: Ws_32m QC flag\n", + " serial_number: ?\n", + " height: 32m\n", + " coverage_L2: 98\n", + " long_name: Merged from Ws_RMY_32m, Ws_CSAT, merged from Ws, Ws_acc, Ws_cli\n", + " standard_name: wind_speed\n", + " coverage_L6: 100\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: m/s\n", + " coverage_L3: 99\n", + " valid_range: 0,30\n", + " rangecheck_upper: [30]*12\n", + " rangecheck_lower: [0]*12\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "Ws_QCFlag: \n", + "float64 Ws_QCFlag(time, latitude, longitude)\n", + " long_name: WsQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "eta: \n", + "float32 eta(time, latitude, longitude)\n", + " coverage_L3: 98\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " long_name: Horizontal rotation angle\n", + " standard_name: not defined\n", + " coverage_L6: 98\n", + " instrument: not defined\n", + " coverage_L4: 98\n", + " coverage_L5: 98\n", + " units: deg\n", + " serial_number: not defined\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "eta_QCFlag: \n", + "float64 eta_QCFlag(time, latitude, longitude)\n", + " long_name: etaQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "ps: \n", + "float32 ps(time, latitude, longitude)\n", + " instrument: Li-7500\n", + " ancillary_variables: ps QC flag\n", + " serial_number: ?\n", + " height: 36m\n", + " coverage_L2: 99\n", + " long_name: Air pressure, standard deviation, merged from ps, ps_acc, ps_cli\n", + " standard_name: surface_air_pressure\n", + " coverage_L6: 100\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: kPa\n", + " coverage_L3: 99\n", + " valid_range: 95,105\n", + " rangecheck_upper: [105]*12\n", + " rangecheck_lower: [95]*12\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "ps_QCFlag: \n", + "float64 ps_QCFlag(time, latitude, longitude)\n", + " long_name: psQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "q: \n", + "float32 q(time, latitude, longitude)\n", + " instrument: not defined\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " long_name: Specific humidity\n", + " standard_name: specific_humidity\n", + " coverage_L6: 100\n", + " coverage_L4: 100\n", + " coverage_L5: 100\n", + " units: kg/kg\n", + " serial_number: not defined\n", + " missing_value: -9999.0\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "q_QCFlag: \n", + "float64 q_QCFlag(time, latitude, longitude)\n", + " long_name: qQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "theta: \n", + "float32 theta(time, latitude, longitude)\n", + " coverage_L3: 98\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " long_name: Vertical rotation angle\n", + " standard_name: not defined\n", + " coverage_L6: 98\n", + " instrument: not defined\n", + " coverage_L4: 98\n", + " coverage_L5: 98\n", + " units: deg\n", + " serial_number: not defined\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "theta_QCFlag: \n", + "float64 theta_QCFlag(time, latitude, longitude)\n", + " long_name: thetaQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "time_QCFlag: \n", + "float64 time_QCFlag(time, latitude, longitude)\n", + " long_name: timeQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "ustar: \n", + "float32 ustar(time, latitude, longitude)\n", + " coverage_L3: 98\n", + " ancillary_variables: not defined\n", + " height: not defined\n", + " long_name: Friction velocity, rotated to natural wind coordinates, merged from ustar, ustar_SOLO\n", + " standard_name: not defined\n", + " coverage_L6: 100\n", + " instrument: not defined\n", + " coverage_L4: 98\n", + " coverage_L5: 100\n", + " units: m/s\n", + " serial_number: not defined\n", + " valid_range: 0,2\n", + " rangecheck_upper: [2]*12\n", + " rangecheck_lower: [0]*12\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n", + "ustar_QCFlag: \n", + "float64 ustar_QCFlag(time, latitude, longitude)\n", + " long_name: ustarQC flag\n", + " units: none\n", + "unlimited dimensions: \n", + "current shape = (35087, 1, 1)\n", + "filling off\n", + "\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# get the netCDF time and the CO2 flux\n", + "time = root.variables[\"time\"][:]\n", + "Fc = root.variables[\"Fc\"][:]" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 6 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# plot the CO2 flux\n", + "fig=plt.figure()\n", + "plt.plot(time,Fc[:,0,0])\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 7 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/test_plotcoveragelines.ipynb b/test_plotcoveragelines.ipynb new file mode 100644 index 0000000..d7f6c63 --- /dev/null +++ b/test_plotcoveragelines.ipynb @@ -0,0 +1,179 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:f702a1aef13f8ec44422c25f2098c750b8282b7314a5b7bf16ea50dfa34731ed" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import pylab\n", + "%run basics\n", + "%matplotlib" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Using matplotlib backend: Qt4Agg\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "ncname = \"../../Sites/RiggsCreek/Data/Processed/all/Riggs_2011_to_2014_L3.nc\"\n", + "ds = qcio.nc_read_series(ncname)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 2 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "ldt = ds.series[\"DateTime\"][\"Data\"]\n", + "series_list = ['ps', 'Wd', 'Fsd', 'Ah', 'Flu', 'Ts', 'Fa', 'Precip', 'Ws', 'Fsu', 'Fg', 'Sws', 'Fld', 'Fn', 'Ta']\n", + "ylabel_list = [\"\"]+series_list+[\"\"]\n", + "ylabel_right_list = [\"\"]\n", + "color_list = [\"blue\",\"red\",\"green\",\"yellow\",\"magenta\",\"black\",\"cyan\",\"brown\"]\n", + "xsize = 15.0\n", + "ysize = len(series_list)*0.2\n", + "plt.ion\n", + "fig=plt.figure(0,figsize=(xsize,ysize))\n", + "ax1 = plt.subplot(111)\n", + "fig.canvas.set_window_title(\"Coverage\")\n", + "plt.ylim([0,len(series_list)+1])\n", + "plt.xlim([ldt[0],ldt[-1]])\n", + "composite_lines = {}\n", + "for series,n in zip(series_list,range(1,len(series_list)+1)):\n", + " data_series,f,a = qcutils.GetSeriesasMA(ds,series)\n", + " percent = 100*numpy.ma.count(data_series)/len(data_series)\n", + " ylabel_right_list.append(\"{0:.0f}\".format(percent))\n", + " ind_series = numpy.ma.ones(len(data_series))*float(n)\n", + " ind_series = numpy.ma.masked_where(numpy.ma.getmaskarray(data_series)==True,ind_series)\n", + " ax1.plot(ldt,ind_series,color=color_list[numpy.mod(n,8)],linewidth=1)\n", + " #if series+\"_composite\" in ds.series.keys():\n", + " #data_composite,f,a = qcutils.GetSeriesasMA(ds,series+\"_composite\")\n", + " data_composite = numpy.ma.masked_all_like(data_series)\n", + " ind_composite = numpy.ma.ones(len(data_composite))*float(n)\n", + " ind_composite = numpy.ma.masked_where(numpy.ma.getmaskarray(data_composite)==True,ind_composite)\n", + " composite_lines[series], = ax1.plot(ldt,ind_composite,color=color_list[numpy.mod(n,8)],linewidth=4)\n", + "ylabel_posn = range(0,len(series_list)+2)\n", + "pylab.yticks(ylabel_posn,ylabel_list)\n", + "ylabel_right_list.append(\"\")\n", + "ax2 = ax1.twinx()\n", + "pylab.yticks(ylabel_posn,ylabel_right_list)\n", + "fig.tight_layout()\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 21 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "fig=plt.figure(0)\n", + "plt.clf()\n", + "ax1 = plt.subplot(111)\n", + "fig.canvas.set_window_title(\"Coverage\")\n", + "plt.ylim([0,len(series_list)+1])\n", + "plt.xlim([ldt[0],ldt[-1]])\n", + "composite_lines = {}\n", + "for series,n in zip(series_list,range(1,len(series_list)+1)):\n", + " data_series,f,a = qcutils.GetSeriesasMA(ds,series)\n", + " percent = 100*numpy.ma.count(data_series)/len(data_series)\n", + " ylabel_right_list.append(\"{0:.0f}\".format(percent))\n", + " ind_series = numpy.ma.ones(len(data_series))*float(n)\n", + " ind_series = numpy.ma.masked_where(numpy.ma.getmaskarray(data_series)==True,ind_series)\n", + " ax1.plot(ldt,ind_series,color=color_list[numpy.mod(n,8)],linewidth=1)\n", + " #if series+\"_composite\" in ds.series.keys():\n", + " #data_composite,f,a = qcutils.GetSeriesasMA(ds,series+\"_composite\")\n", + " data_composite = numpy.ma.masked_all_like(data_series)\n", + " ind_composite = numpy.ma.ones(len(data_composite))*float(n)\n", + " ind_composite = numpy.ma.masked_where(numpy.ma.getmaskarray(data_composite)==True,ind_composite)\n", + " composite_lines[series], = ax1.plot(ldt,ind_composite,color=color_list[numpy.mod(n,8)],linewidth=4)\n", + "ylabel_posn = range(0,len(series_list)+2)\n", + "pylab.yticks(ylabel_posn,ylabel_list)\n", + "ylabel_right_list.append(\"\")\n", + "ax2 = ax1.twinx()\n", + "pylab.yticks(ylabel_posn,ylabel_right_list)\n", + "fig.tight_layout()\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 22 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "sdate = ldt[0]\n", + "edate = dateutil.parser.parse(\"2012-01-01 00:30\")\n", + "ind_ldt = range(len(ldt))\n", + "for n,series in enumerate(composite_lines.keys()):\n", + " ind_composite = numpy.ma.ones(len(data_composite))*float(n+1)\n", + " ind_composite = numpy.ma.masked_where(ind_ldt>1000,ind_composite)\n", + " composite_lines[series].set_ydata(ind_composite)\n", + " fig.canvas.draw()" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "total size of new array must be unchanged", + "output_type": "pyerr", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 6\u001b[0m \u001b[0mind_composite\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnumpy\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mma\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmasked_where\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mind_ldt\u001b[0m\u001b[1;33m>\u001b[0m\u001b[1;36m1000\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mind_composite\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 7\u001b[0m \u001b[0mcomposite_lines\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mseries\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mset_ydata\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mind_composite\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 8\u001b[1;33m \u001b[0mfig\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;32m/home/peter/anaconda/lib/python2.7/site-packages/matplotlib/backends/backend_qt5agg.pyc\u001b[0m in \u001b[0;36mdraw\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 146\u001b[0m \u001b[1;31m# causes problems with code that uses the result of the\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 147\u001b[0m \u001b[1;31m# draw() to update plot elements.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 148\u001b[1;33m \u001b[0mFigureCanvasAgg\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 149\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_priv_update\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 150\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m/home/peter/anaconda/lib/python2.7/site-packages/matplotlib/backends/backend_agg.pyc\u001b[0m in \u001b[0;36mdraw\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 467\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 468\u001b[0m \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 469\u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 470\u001b[0m \u001b[1;32mfinally\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 471\u001b[0m \u001b[0mRendererAgg\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlock\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrelease\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m/home/peter/anaconda/lib/python2.7/site-packages/matplotlib/artist.pyc\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[1;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[0;32m 57\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mdraw_wrapper\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0martist\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 58\u001b[0m \u001b[0mbefore\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0martist\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 59\u001b[1;33m \u001b[0mdraw\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0martist\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 60\u001b[0m \u001b[0mafter\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0martist\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 61\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m/home/peter/anaconda/lib/python2.7/site-packages/matplotlib/figure.pyc\u001b[0m in \u001b[0;36mdraw\u001b[1;34m(self, renderer)\u001b[0m\n\u001b[0;32m 1077\u001b[0m \u001b[0mdsu\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msort\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mitemgetter\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 1078\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mzorder\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfunc\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0margs\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mdsu\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1079\u001b[1;33m \u001b[0mfunc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 1080\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 1081\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mclose_group\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'figure'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m/home/peter/anaconda/lib/python2.7/site-packages/matplotlib/artist.pyc\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[1;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[0;32m 57\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mdraw_wrapper\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0martist\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 58\u001b[0m \u001b[0mbefore\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0martist\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 59\u001b[1;33m \u001b[0mdraw\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0martist\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 60\u001b[0m \u001b[0mafter\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0martist\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 61\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m/home/peter/anaconda/lib/python2.7/site-packages/matplotlib/axes/_base.pyc\u001b[0m in \u001b[0;36mdraw\u001b[1;34m(self, renderer, inframe)\u001b[0m\n\u001b[0;32m 2090\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2091\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mzorder\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0ma\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mdsu\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2092\u001b[1;33m \u001b[0ma\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 2093\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2094\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mclose_group\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'axes'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m/home/peter/anaconda/lib/python2.7/site-packages/matplotlib/artist.pyc\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[1;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[0;32m 57\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mdraw_wrapper\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0martist\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 58\u001b[0m \u001b[0mbefore\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0martist\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 59\u001b[1;33m \u001b[0mdraw\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0martist\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 60\u001b[0m \u001b[0mafter\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0martist\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 61\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m/home/peter/anaconda/lib/python2.7/site-packages/matplotlib/lines.pyc\u001b[0m in \u001b[0;36mdraw\u001b[1;34m(self, renderer)\u001b[0m\n\u001b[0;32m 663\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 664\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_invalidy\u001b[0m \u001b[1;32mor\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_invalidx\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 665\u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrecache\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 666\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mind_offset\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;31m# Needed for contains() method.\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 667\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_subslice\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0maxes\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m/home/peter/anaconda/lib/python2.7/site-packages/matplotlib/lines.pyc\u001b[0m in \u001b[0;36mrecache\u001b[1;34m(self, always)\u001b[0m\n\u001b[0;32m 575\u001b[0m \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_x\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 576\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0malways\u001b[0m \u001b[1;32mor\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_invalidy\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 577\u001b[1;33m \u001b[0myconv\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconvert_yunits\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_yorig\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 578\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mma\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0misMaskedArray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_yorig\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 579\u001b[0m \u001b[0my\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mma\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0myconv\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfloat_\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m/home/peter/anaconda/lib/python2.7/site-packages/matplotlib/artist.pyc\u001b[0m in \u001b[0;36mconvert_yunits\u001b[1;34m(self, y)\u001b[0m\n\u001b[0;32m 170\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0max\u001b[0m \u001b[1;32mis\u001b[0m \u001b[0mNone\u001b[0m \u001b[1;32mor\u001b[0m \u001b[0max\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0myaxis\u001b[0m \u001b[1;32mis\u001b[0m \u001b[0mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 171\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 172\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0max\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0myaxis\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconvert_units\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 173\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 174\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mset_axes\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxes\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m/home/peter/anaconda/lib/python2.7/site-packages/matplotlib/axis.pyc\u001b[0m in \u001b[0;36mconvert_units\u001b[1;34m(self, x)\u001b[0m\n\u001b[0;32m 1441\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mconvert_units\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 1442\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconverter\u001b[0m \u001b[1;32mis\u001b[0m \u001b[0mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1443\u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconverter\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmunits\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mregistry\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_converter\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 1444\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 1445\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconverter\u001b[0m \u001b[1;32mis\u001b[0m \u001b[0mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m/home/peter/anaconda/lib/python2.7/site-packages/matplotlib/units.pyc\u001b[0m in \u001b[0;36mget_converter\u001b[1;34m(self, x)\u001b[0m\n\u001b[0;32m 139\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 140\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mndarray\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msize\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 141\u001b[1;33m \u001b[0mxravel\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mravel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 142\u001b[0m \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 143\u001b[0m \u001b[1;31m# pass the first value of x that is not masked back to\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m/home/peter/anaconda/lib/python2.7/site-packages/numpy/ma/core.pyc\u001b[0m in \u001b[0;36mravel\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 4066\u001b[0m \u001b[0mr\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_update_from\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4067\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_mask\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mnomask\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 4068\u001b[1;33m \u001b[0mr\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_mask\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mndarray\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mravel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_mask\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mr\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 4069\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4070\u001b[0m \u001b[0mr\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_mask\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnomask\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mValueError\u001b[0m: total size of new array must be unchanged" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/test_split_gui.ipynb b/test_split_gui.ipynb new file mode 100644 index 0000000..7b5c7fa --- /dev/null +++ b/test_split_gui.ipynb @@ -0,0 +1,95 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:a8216f60ae18402f15a54395f9b1fab1e508a6982a3319d3cf83cbea7a1d2abe" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "code", + "collapsed": false, + "input": [ + "%run basics" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 1 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import Tkinter" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 2 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def split_netcdf_done(split_gui):\n", + " split_gui.destroy()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 3 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "root = Tkinter.Frame()\n", + "root.grid()\n", + "splitButton = Tkinter.Button(root,text=\"Split netCDF\")\n", + "split_gui = Tkinter.Toplevel()\n", + "split_gui.wm_title(\"Split netCDF file\")\n", + "split_gui.grid()\n", + "nrow = 0\n", + "split_gui.infilenameLabel = Tkinter.Label(split_gui,text=\"Input file\")\n", + "split_gui.infilenameLabel.grid(row=nrow,column=0,columnspan=1)\n", + "split_gui.infilenameEntry = Tkinter.Entry(split_gui,width=15)\n", + "split_gui.infilenameEntry.grid(row=nrow,column=2,columnspan=3)\n", + "# quit button\n", + "nrow = nrow + 1\n", + "split_gui.doneButton = Tkinter.Button(split_gui,text=\"Done\",command=lambda:split_netcdf_done(split_gui))\n", + "split_gui.doneButton.grid(row=nrow,column=0,columnspan=3)\n", + "\n", + "split_gui.wait_window(split_gui)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "Frame instance has no attribute 'wm_title'", + "output_type": "pyerr", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[0msplit_gui\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mTkinter\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mFrame\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0msplit_gui\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mwm_title\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Split netCDF file\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 3\u001b[0m \u001b[0msplit_gui\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mgrid\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[0mnrow\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[0msplit_gui\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minfilenameLabel\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mTkinter\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mLabel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msplit_gui\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mtext\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"Input file\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mAttributeError\u001b[0m: Frame instance has no attribute 'wm_title'" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/test_ttk_python2.7.ipynb b/test_ttk_python2.7.ipynb new file mode 100644 index 0000000..f622a11 --- /dev/null +++ b/test_ttk_python2.7.ipynb @@ -0,0 +1,124 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:fa188fb20092bacabb6cc7ed3bdb078c78d9fdb4a06f16ebbc915514720a6ac2" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import Tkinter\n", + "import ttk" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 1 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def calculate(*args):\n", + " try:\n", + " value = float(feet.get())\n", + " meters.set((0.3048 * value * 10000.0 + 0.5)/10000.0)\n", + " except ValueError:\n", + " pass\n", + " \n", + "root = Tkinter.Tk()\n", + "root.title(\"Feet to Meters\")\n", + "\n", + "mainframe = ttk.Frame(root, padding=\"3 3 12 12\")\n", + "mainframe.grid(column=0, row=0, sticky=(N, W, E, S))\n", + "mainframe.columnconfigure(0, weight=1)\n", + "mainframe.rowconfigure(0, weight=1)\n", + "\n", + "feet = StringVar()\n", + "meters = StringVar()\n", + "\n", + "feet_entry = ttk.Entry(mainframe, width=7, textvariable=feet)\n", + "feet_entry.grid(column=2, row=1, sticky=(W, E))\n", + "\n", + "ttk.Label(mainframe, textvariable=meters).grid(column=2, row=2, sticky=(W, E))\n", + "ttk.Button(mainframe, text=\"Calculate\", command=calculate).grid(column=3, row=3, sticky=W)\n", + "\n", + "ttk.Label(mainframe, text=\"feet\").grid(column=3, row=1, sticky=W)\n", + "ttk.Label(mainframe, text=\"is equivalent to\").grid(column=1, row=2, sticky=E)\n", + "ttk.Label(mainframe, text=\"meters\").grid(column=3, row=2, sticky=W)\n", + "\n", + "for child in mainframe.winfo_children(): child.grid_configure(padx=5, pady=5)\n", + "\n", + "feet_entry.focus()\n", + "root.bind('', calculate)\n", + "\n", + "root.mainloop()" + ], + "language": "python", + "metadata": {}, + "outputs": [] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def option_not_implemented():\n", + " print \"option not implemented\"" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 12 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "parent = Tkinter.Tk()\n", + "parent.title(\"Tab interface\")\n", + "n = ttk.Notebook(parent)\n", + "f1 = ttk.Frame(n); # first page, which would get widgets gridded into it\n", + "L1Label = ttk.Label(f1,text='L1: Raw data')\n", + "L1Label.grid(row=0,column=0,columnspan=2)\n", + "L2Label = ttk.Label(f1,text='L2: QA/QC')\n", + "L2Label.grid(row=0,column=2,columnspan=2)\n", + "L3Label = ttk.Label(f1,text='L3: Process')\n", + "L3Label.grid(row=0,column=4,columnspan=2)\n", + "doL1Button = ttk.Button (f1, text=\"Read L1 file\", command=option_not_implemented )\n", + "doL1Button.grid(row=1,column=0,columnspan=2)\n", + "doL2Button = ttk.Button (f1, text=\"Do L2 QA/QC\", command=option_not_implemented )\n", + "doL2Button.grid(row=1,column=2,columnspan=2)\n", + "doL3Button = ttk.Button (f1, text=\"Do L3 processing\", command=option_not_implemented )\n", + "doL3Button.grid(row=1,column=4,columnspan=2)\n", + "\n", + "#ttk.Button(f1, text='Exit', command=parent.destroy).grid(column=1, row=1)\n", + "f2 = ttk.Frame(n); # second page\n", + "ttk.Button(f2, text='Exit', command=parent.destroy).grid(column=1, row=1)\n", + "n.add(f1, text='One')\n", + "n.add(f2, text='Two')\n", + "n.grid()\n", + "parent.mainloop()" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 13 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/wrangle_csats.ipynb b/wrangle_csats.ipynb new file mode 100644 index 0000000..52c4e1c --- /dev/null +++ b/wrangle_csats.ipynb @@ -0,0 +1,285 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:b4c28d85f79179c2a107785bda067bdc901587e1fa054b3535a83b803805576f" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import csv\n", + "import datetime\n", + "import numpy\n", + "import matplotlib.pyplot as plt\n", + "import sys\n", + "sys.path.append('../scripts')\n", + "import qcio\n", + "import qcutils" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 1 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def get_datetimefromymdhms(ds):\n", + " ''' Creates a series of Python datetime objects from the year, month,\n", + " day, hour, minute and second series stored in the netCDF file.'''\n", + " SeriesList = ds.series.keys()\n", + " if 'Year' not in SeriesList or 'Month' not in SeriesList or 'Day' not in SeriesList or 'Hour' not in SeriesList or 'Minute' not in SeriesList or 'Second' not in SeriesList:\n", + " #log.info(' get_datetimefromymdhms: unable to find all datetime fields required')\n", + " print 'get_datetimefromymdhms: unable to find all datetime fields required'\n", + " return\n", + " #log.info(' Getting the date and time series')\n", + " print 'Getting the date and time series'\n", + " nRecs = ds.globalattributes[\"nc_nrecs\"]\n", + " ds.series[unicode('DateTime')] = {}\n", + " ds.series['DateTime']['Data'] = [None]*nRecs\n", + " ds.series[unicode('Date')] = {}\n", + " ds.series['Date']['Data'] = [None]*nRecs\n", + " ds.series[unicode('Time')] = {}\n", + " ds.series['Time']['Data'] = [None]*nRecs\n", + " if \"Microsecond\" in ds.series.keys():\n", + " microseconds = ds.series[\"Microsecond\"][\"Data\"]\n", + " else:\n", + " microseconds = numpy.zeros(nRecs,dtype=numpy.float64)\n", + " for i in range(nRecs):\n", + " ds.series['DateTime']['Data'][i] = datetime.datetime(int(ds.series['Year']['Data'][i]),\n", + " int(ds.series['Month']['Data'][i]),\n", + " int(ds.series['Day']['Data'][i]),\n", + " int(ds.series['Hour']['Data'][i]),\n", + " int(ds.series['Minute']['Data'][i]),\n", + " int(ds.series['Second']['Data'][i]),\n", + " int(microseconds[i]))\n", + " ds.series['Date']['Data'][i] = datetime.date(int(ds.series['Year']['Data'][i]),\n", + " int(ds.series['Month']['Data'][i]),\n", + " int(ds.series['Day']['Data'][i]))\n", + " ds.series['Time']['Data'][i] = datetime.time(int(ds.series['Hour']['Data'][i]),\n", + " int(ds.series['Minute']['Data'][i]),\n", + " int(ds.series['Second']['Data'][i]),\n", + " int(microseconds[i]))\n", + " ds.series['DateTime']['Flag'] = numpy.zeros(nRecs)\n", + " ds.series['DateTime']['Attr'] = {}\n", + " ds.series['DateTime']['Attr']['long_name'] = 'Date-time object'\n", + " ds.series['DateTime']['Attr']['units'] = 'None'\n", + " ds.series['Date']['Flag'] = numpy.zeros(nRecs)\n", + " ds.series['Date']['Attr'] = {}\n", + " ds.series['Date']['Attr']['long_name'] = 'Date object'\n", + " ds.series['Date']['Attr']['units'] = 'None'\n", + " ds.series['Time']['Flag'] = numpy.zeros(nRecs)\n", + " ds.series['Time']['Attr'] = {}\n", + " ds.series['Time']['Attr']['long_name'] = 'Time object'\n", + " ds.series['Time']['Attr']['units'] = 'None'" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 3 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "infilename = \"../../Sites/WombatStateForest/Data/Fast/3952/test_3952.dat\"\n", + "# columns are:\n", + "# data file description\n", + "# 0 0 Year\n", + "# 1 1 Month\n", + "# 2 2 Day\n", + "# 3 3 Hour\n", + "# 4 4 Minute\n", + "# 5 5 Second\n", + "# 6 7 Ux\n", + "# 7 8 Uy\n", + "# 8 9 Uz\n", + "# 9 12 Tv\n", + "#10 13 Diag_CSAT\n", + "data_3952 = numpy.genfromtxt(infilename,skip_header=4,delimiter=\",\",usecols=(0,1,2,3,4,5,7,8,9,12,13),\n", + " missing_values=-9999,filling_values=-9999)\n", + "data_3952 = numpy.ma.masked_equal(data,float(-9999),copy=True)\n", + "nRecs = data_3952.shape[0]\n", + "flag = numpy.zeros(nRecs,dtype=numpy.int32)\n", + "ds_3952=qcio.DataStructure()\n", + "ds_3952.globalattributes[\"nc_nrecs\"] = nRecs\n", + "seconds = numpy.array(data[:,5],dtype=numpy.int32)\n", + "microseconds = numpy.rint((data[:,5]%1)*float(1000000))\n", + "qcutils.CreateSeries(ds_3952,'Year',data[:,0],Flag=flag,Attr=qcutils.MakeAttributeDictionary(long_name='Year',units='years'))\n", + "qcutils.CreateSeries(ds_3952,'Month',data[:,1],Flag=flag,Attr=qcutils.MakeAttributeDictionary(long_name='Month',units='months'))\n", + "qcutils.CreateSeries(ds_3952,'Day',data[:,2],Flag=flag,Attr=qcutils.MakeAttributeDictionary(long_name='Day',units='days'))\n", + "qcutils.CreateSeries(ds_3952,'Hour',data[:,3],Flag=flag,Attr=qcutils.MakeAttributeDictionary(long_name='Hour',units='hours'))\n", + "qcutils.CreateSeries(ds_3952,'Minute',data[:,4],Flag=flag,Attr=qcutils.MakeAttributeDictionary(long_name='Minute',units='minutes'))\n", + "qcutils.CreateSeries(ds_3952,'Second',seconds,Flag=flag,Attr=qcutils.MakeAttributeDictionary(long_name='Second',units='seconds'))\n", + "qcutils.CreateSeries(ds_3952,'Microsecond',microseconds,Flag=flag,Attr=qcutils.MakeAttributeDictionary(long_name='Microseconds',units='microseconds'))\n", + "get_datetimefromymdhms(ds_3952)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Getting the date and time series\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "infilename = \"../../Sites/WombatStateForest/Data/Fast/6281/test_6281.dat\"\n", + "# columns are:\n", + "# data file description\n", + "# 0 0 Year\n", + "# 1 1 Month\n", + "# 2 2 Day\n", + "# 3 3 Hour\n", + "# 4 4 Minute\n", + "# 5 5 Second\n", + "# 6 7 Ux\n", + "# 7 8 Uy\n", + "# 8 9 Uz\n", + "# 9 10 Cc_7500\n", + "#10 11 Ah_7500\n", + "#11 12 Tv\n", + "#12 13 Diag_CSAT\n", + "#13 14 Diag_7500\n", + "data_6281 = numpy.genfromtxt(infilename,skip_header=4,delimiter=\",\",usecols=(0,1,2,3,4,5,7,8,9,10,11,12,13,14),\n", + " missing_values=-9999,filling_values=-9999)\n", + "data_6281 = numpy.ma.masked_equal(data,float(-9999),copy=True)\n", + "nRecs = data_6281.shape[0]\n", + "seconds = numpy.array(data[:,5],dtype=numpy.int32)\n", + "microseconds = numpy.rint((data[:,5]%1)*float(1000000))\n", + "ldt_6281 = [None]*nRecs\n", + "for i in range(0,nRecs):\n", + " ldt_6281[i] = datetime.datetime(int(data_6281[i,0]),int(data_6281[i,1]),int(data_6281[i,2]),\n", + " int(data_6281[i,3]),int(data_6281[i,4]),int(seconds[i]),int(microseconds[i]))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 21 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "ldt_3952=ds_3952.series[\"DateTime\"][\"Data\"]\n", + "ldt_6281=ds_6281.series[\"DateTime\"][\"Data\"]\n", + "ld_3952=ds_3952.series[\"Date\"][\"Data\"]\n", + "ld_6281=ds_6281.series[\"Date\"][\"Data\"]\n", + "lt_3952=ds_3952.series[\"Time\"][\"Data\"]\n", + "lt_6281=ds_6281.series[\"Time\"][\"Data\"]" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 22 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "ldt_10hz = [x for x in qcutils.perdelta(ldt_3952[0],ldt_3952[-1],datetime.timedelta(seconds=0.1))]" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 23 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "for i in range(10,20):\n", + " print ldt_10hz[i],ldt_3952[i],ldt_6281[i],microseconds[i]" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "2014-08-31 15:11:01.100000 2014-08-31 15:11:01.100000 2014-08-31 15:11:01.100000 100000.0\n", + "2014-08-31 15:11:01.200000 2014-08-31 15:11:01.200000 2014-08-31 15:11:01.200000 200000.0\n", + "2014-08-31 15:11:01.300000 2014-08-31 15:11:01.300000 2014-08-31 15:11:01.300000 300000.0\n", + "2014-08-31 15:11:01.400000 2014-08-31 15:11:01.400000 2014-08-31 15:11:01.400000 400000.0\n", + "2014-08-31 15:11:01.500000 2014-08-31 15:11:01.500000 2014-08-31 15:11:01.500000 500000.0\n", + "2014-08-31 15:11:01.600000 2014-08-31 15:11:01.600000 2014-08-31 15:11:01.600000 600000.0\n", + "2014-08-31 15:11:01.700000 2014-08-31 15:11:01.700000 2014-08-31 15:11:01.700000 700000.0\n", + "2014-08-31 15:11:01.800000 2014-08-31 15:11:01.800000 2014-08-31 15:11:01.800000 800000.0\n", + "2014-08-31 15:11:01.900000 2014-08-31 15:11:01.900000 2014-08-31 15:11:01.900000 900000.0\n", + "2014-08-31 15:11:02 2014-08-31 15:11:02 2014-08-31 15:11:02 0.0\n" + ] + } + ], + "prompt_number": 24 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "data_10hz = numpy.ma.array((len(ldt_10hz),13))" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 10 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "idx=qcutils.find_indices(ldt_10hz,ldt_3952)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 12 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "data_10hz[idx,0]=data_3952[:,0]" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'data_3952' is not defined", + "output_type": "pyerr", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mdata_10hz\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0midx\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mdata_3952\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mNameError\u001b[0m: name 'data_3952' is not defined" + ] + } + ], + "prompt_number": 15 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +} \ No newline at end of file