def l4qc(main_gui, cf, ds3): ds4 = pfp_io.copy_datastructure(cf, ds3) # ds4 will be empty (logical false) if an error occurs in copy_datastructure # return from this routine if this is the case if not ds4: return ds4 # set some attributes for this level pfp_utils.UpdateGlobalAttributes(cf, ds4, "L4") # check to see if we have any imports pfp_gf.ImportSeries(cf, ds4) # re-apply the quality control checks (range, diurnal and rules) pfp_ck.do_qcchecks(cf, ds4) # now do the meteorological driver gap filling # parse the control file for information on how the user wants to do the gap filling l4_info = pfp_gf.ParseL4ControlFile(cf, ds4) if ds4.returncodes["value"] != 0: return ds4 # *** start of the section that does the gap filling of the drivers *** # read the alternate data files ds_alt = pfp_gf.ReadAlternateFiles(ds4, l4_info) # fill short gaps using interpolation pfp_gf.GapFillUsingInterpolation(cf, ds4) # gap fill using climatology if "GapFillFromClimatology" in l4_info: pfp_gf.GapFillFromClimatology(ds4, l4_info, "GapFillFromClimatology") # do the gap filling using the ACCESS output if "GapFillFromAlternate" in l4_info: pfp_gfALT.GapFillFromAlternate(main_gui, ds4, ds_alt, l4_info, "GapFillFromAlternate") if ds4.returncodes["value"] != 0: return ds4 # merge the first group of gap filled drivers into a single series pfp_ts.MergeSeriesUsingDict(ds4, l4_info, merge_order="prerequisite") # re-calculate the ground heat flux but only if requested in control file opt = pfp_utils.get_keyvaluefromcf(cf,["Options"], "CorrectFgForStorage", default="No", mode="quiet") if opt.lower() != "no": pfp_ts.CorrectFgForStorage(cf, ds4, Fg_out='Fg', Fg_in='Fg_Av', Ts_in='Ts', Sws_in='Sws') # re-calculate the net radiation pfp_ts.CalculateNetRadiation(cf, ds4, Fn_out='Fn', Fsd_in='Fsd', Fsu_in='Fsu', Fld_in='Fld', Flu_in='Flu') # re-calculate the available energy pfp_ts.CalculateAvailableEnergy(ds4, Fa_out='Fa', Fn_in='Fn', Fg_in='Fg') # merge the second group of gap filled drivers into a single series pfp_ts.MergeSeriesUsingDict(ds4, l4_info, merge_order="standard") # re-calculate the water vapour concentrations pfp_ts.CalculateHumiditiesAfterGapFill(ds4, l4_info) # re-calculate the meteorological variables pfp_ts.CalculateMeteorologicalVariables(ds4, l4_info) # check for any missing data pfp_utils.get_missingingapfilledseries(ds4, l4_info) # write the percentage of good data as a variable attribute pfp_utils.get_coverage_individual(ds4) # write the percentage of good data for groups pfp_utils.get_coverage_groups(ds4) # remove intermediate series from the data structure pfp_ts.RemoveIntermediateSeries(ds4, l4_info) return ds4
def l5qc(main_gui, cf, ds4): ds5 = pfp_io.copy_datastructure(cf, ds4) # ds5 will be empty (logical false) if an error occurs in copy_datastructure # return from this routine if this is the case if not ds5: return ds5 # set some attributes for this level pfp_utils.UpdateGlobalAttributes(cf, ds5, "L5") # parse the control file for information on how the user wants to do the gap filling l5_info = pfp_gf.ParseL5ControlFile(cf, ds5) if ds5.returncodes["value"] != 0: return ds5 # check to see if we have any imports pfp_gf.ImportSeries(cf, ds5) # re-apply the quality control checks (range, diurnal and rules) pfp_ck.do_qcchecks(cf, ds5) pfp_gf.CheckL5Drivers(ds5, l5_info) if ds5.returncodes["value"] != 0: return ds5 # now do the flux gap filling methods # *** start of the section that does the gap filling of the fluxes *** pfp_gf.CheckGapLengths(cf, ds5, l5_info) if ds5.returncodes["value"] != 0: return ds5 # apply the turbulence filter (if requested) pfp_ck.ApplyTurbulenceFilter(cf, ds5, l5_info) # fill short gaps using interpolation pfp_gf.GapFillUsingInterpolation(cf, ds5) # gap fill using marginal distribution sampling if "GapFillUsingMDS" in l5_info: pfp_gfMDS.GapFillUsingMDS(ds5, l5_info, "GapFillUsingMDS") # do the gap filling using SOLO if "GapFillUsingSOLO" in l5_info: pfp_gfSOLO.GapFillUsingSOLO(main_gui, ds5, l5_info, "GapFillUsingSOLO") if ds5.returncodes["value"] != 0: return ds5 # fill long gaps using SOLO if "GapFillLongSOLO" in l5_info: pfp_gfSOLO.GapFillUsingSOLO(main_gui, ds5, l5_info, "GapFillLongSOLO") if ds5.returncodes["value"] != 0: return ds5 # merge the gap filled drivers into a single series pfp_ts.MergeSeriesUsingDict(ds5, l5_info, merge_order="standard") # check that all targets were gap filled pfp_gf.CheckL5Targets(ds5, l5_info) if ds5.returncodes["value"] != 0: return ds5 # calculate Monin-Obukhov length pfp_ts.CalculateMoninObukhovLength(ds5) # write the percentage of good data as a variable attribute pfp_utils.get_coverage_individual(ds5) # write the percentage of good data for groups pfp_utils.get_coverage_groups(ds5) # remove intermediate series from the data structure pfp_ts.RemoveIntermediateSeries(ds5, l5_info) return ds5
def l6qc(main_gui, cf, ds5): ds6 = pfp_io.copy_datastructure(cf, ds5) # ds6 will be empty (logical false) if an error occurs in copy_datastructure # return from this routine if this is the case if not ds6: return ds6 # set some attributes for this level pfp_utils.UpdateGlobalAttributes(cf, ds6, "L6") # parse the control file l6_info = pfp_rp.ParseL6ControlFile(cf, ds6) # check to see if we have any imports pfp_gf.ImportSeries(cf, ds6) # check units of Fc Fc_list = [label for label in ds6.series.keys() if label[0:2] == "Fc"] pfp_utils.CheckUnits(ds6, Fc_list, "umol/m2/s", convert_units=True) # get ER from the observed Fc pfp_rp.GetERFromFc(cf, ds6) # return code will be non-zero if turbulance filter not applied to CO2 flux if ds6.returncodes["value"] != 0: return ds6 # estimate ER using SOLO if "ERUsingSOLO" in l6_info: pfp_rp.ERUsingSOLO(main_gui, ds6, l6_info, "ERUsingSOLO") if ds6.returncodes["value"] != 0: return ds6 # estimate ER using FFNET #pfp_rp.ERUsingFFNET(cf, ds6, l6_info) # estimate ER using Lloyd-Taylor pfp_rp.ERUsingLloydTaylor(cf, ds6, l6_info) # estimate ER using Lasslop et al pfp_rp.ERUsingLasslop(ds6, l6_info) # merge the estimates of ER with the observations pfp_ts.MergeSeriesUsingDict(ds6, l6_info, merge_order="standard") # calculate NEE from Fc and ER pfp_rp.CalculateNEE(cf, ds6, l6_info) # calculate NEP from NEE pfp_rp.CalculateNEP(cf, ds6) # calculate ET from Fe pfp_rp.CalculateET(ds6) # partition NEE into GPP and ER pfp_rp.PartitionNEE(ds6, l6_info) # write the percentage of good data as a variable attribute pfp_utils.get_coverage_individual(ds6) # write the percentage of good data for groups pfp_utils.get_coverage_groups(ds6) # remove intermediate series from the data structure pfp_ts.RemoveIntermediateSeries(ds6, l6_info) # do the L6 summary pfp_rp.L6_summary(cf, ds6) return ds6
def l5qc(cf, ds4): ds5 = pfp_io.copy_datastructure(cf, ds4) # ds4 will be empty (logical false) if an error occurs in copy_datastructure # return from this routine if this is the case if not ds5: return ds5 # set some attributes for this level pfp_utils.UpdateGlobalAttributes(cf, ds5, "L5") ds5.cf = cf # create a dictionary to hold the gap filling data ds_alt = {} # check to see if we have any imports pfp_gf.ImportSeries(cf, ds5) # re-apply the quality control checks (range, diurnal and rules) pfp_ck.do_qcchecks(cf, ds5) # now do the flux gap filling methods label_list = pfp_utils.get_label_list_from_cf(cf) for label in label_list: # parse the control file for information on how the user wants to do the gap filling pfp_gf.GapFillParseControlFile(cf, ds5, label, ds_alt) # *** start of the section that does the gap filling of the fluxes *** # apply the turbulence filter (if requested) pfp_ck.ApplyTurbulenceFilter(cf, ds5) # fill short gaps using interpolation pfp_gf.GapFillUsingInterpolation(cf, ds5) # do the gap filling using SOLO pfp_gfSOLO.GapFillUsingSOLO(cf, ds4, ds5) if ds5.returncodes["solo"] == "quit": return ds5 # gap fill using marginal distribution sampling pfp_gfMDS.GapFillFluxUsingMDS(cf, ds5) # gap fill using climatology pfp_gf.GapFillFromClimatology(ds5) # merge the gap filled drivers into a single series pfp_ts.MergeSeriesUsingDict(ds5, merge_order="standard") # calculate Monin-Obukhov length pfp_ts.CalculateMoninObukhovLength(ds5) # write the percentage of good data as a variable attribute pfp_utils.get_coverage_individual(ds5) # write the percentage of good data for groups pfp_utils.get_coverage_groups(ds5) return ds5
def l4qc(cf, ds3): # !!! code here to use existing L4 file # logic # if the L4 doesn't exist # - create ds4 by using copy.deepcopy(ds3) # if the L4 does exist and the "UseExistingL4File" option is False # - create ds4 by using copy.deepcopy(ds3) # if the L4 does exist and the "UseExistingL4File" option is True # - read the contents of the L4 netCDF file # - check the start and end dates of the L3 and L4 data # - if these are the same then tell the user there is nothing to do # - copy the L3 data to the L4 data structure # - replace the L3 data with the L4 data #ds4 = copy.deepcopy(ds3) ds4 = pfp_io.copy_datastructure(cf, ds3) # ds4 will be empty (logical false) if an error occurs in copy_datastructure # return from this routine if this is the case if not ds4: return ds4 # set some attributes for this level pfp_utils.UpdateGlobalAttributes(cf, ds4, "L4") ds4.cf = cf ## calculate the available energy #if "Fa" not in ds4.series.keys(): #pfp_ts.CalculateAvailableEnergy(ds4,Fa_out='Fa',Fn_in='Fn',Fg_in='Fg') # create a dictionary to hold the gap filling data ds_alt = {} # check to see if we have any imports pfp_gf.ImportSeries(cf, ds4) # re-apply the quality control checks (range, diurnal and rules) pfp_ck.do_qcchecks(cf, ds4) # now do the meteorological driver gap filling for ThisOne in cf["Drivers"].keys(): if ThisOne not in ds4.series.keys(): logger.warning("Series " + ThisOne + " not in data structure") continue # parse the control file for information on how the user wants to do the gap filling pfp_gf.GapFillParseControlFile(cf, ds4, ThisOne, ds_alt) # *** start of the section that does the gap filling of the drivers *** # fill short gaps using interpolation pfp_gf.GapFillUsingInterpolation(cf, ds4) # gap fill using climatology pfp_gf.GapFillFromClimatology(ds4) # do the gap filling using the ACCESS output pfp_gfALT.GapFillFromAlternate(cf, ds4, ds_alt) if ds4.returncodes["alternate"] == "quit": return ds4 # gap fill using SOLO pfp_gfSOLO.GapFillUsingSOLO(cf, ds3, ds4) if ds4.returncodes["solo"] == "quit": return ds4 # merge the first group of gap filled drivers into a single series pfp_ts.MergeSeriesUsingDict(ds4, merge_order="prerequisite") # re-calculate the ground heat flux but only if requested in control file opt = pfp_utils.get_keyvaluefromcf(cf, ["Options"], "CorrectFgForStorage", default="No", mode="quiet") if opt.lower() != "no": pfp_ts.CorrectFgForStorage(cf, ds4, Fg_out='Fg', Fg_in='Fg_Av', Ts_in='Ts', Sws_in='Sws') # re-calculate the net radiation pfp_ts.CalculateNetRadiation(cf, ds4, Fn_out='Fn', Fsd_in='Fsd', Fsu_in='Fsu', Fld_in='Fld', Flu_in='Flu') # re-calculate the available energy pfp_ts.CalculateAvailableEnergy(ds4, Fa_out='Fa', Fn_in='Fn', Fg_in='Fg') # merge the second group of gap filled drivers into a single series pfp_ts.MergeSeriesUsingDict(ds4, merge_order="standard") # re-calculate the water vapour concentrations pfp_ts.CalculateHumiditiesAfterGapFill(ds4) # re-calculate the meteorological variables pfp_ts.CalculateMeteorologicalVariables(ds4) # the Tumba rhumba pfp_ts.CalculateComponentsFromWsWd(ds4) # check for any missing data pfp_utils.get_missingingapfilledseries(ds4) # write the percentage of good data as a variable attribute pfp_utils.get_coverage_individual(ds4) # write the percentage of good data for groups pfp_utils.get_coverage_groups(ds4) return ds4