def generate_iwc(categorize_file, output_file): """Generates Cloudnet ice water content product. This function calculates ice water content using the so-called Z-T method. In this method, ice water content is calculated from attenuated-corrected radar reflectivity and model temperature. The results are written in a netCDF file. Args: categorize_file (str): Categorize file name. output_file (str): Output file name. Examples: >>> from cloudnetpy.products import generate_iwc >>> generate_iwc('categorize.nc', 'iwc.nc') References: Hogan, R.J., M.P. Mittermaier, and A.J. Illingworth, 2006: The Retrieval of Ice Water Content from Radar Reflectivity Factor and Temperature and Its Use in Evaluating a Mesoscale Model. J. Appl. Meteor. Climatol., 45, 301–317, https://doi.org/10.1175/JAM2340.1 """ iwc_data = IwcSource(categorize_file) ice_class = _IceClassification(categorize_file) _append_iwc_including_rain(iwc_data, ice_class) _append_iwc(iwc_data, ice_class) _append_iwc_bias(iwc_data) _append_iwc_error(iwc_data, ice_class) _append_iwc_sensitivity(iwc_data) _append_iwc_status(iwc_data, ice_class) output.update_attributes(iwc_data.data, IWC_ATTRIBUTES) output.save_product_file('iwc', iwc_data, output_file) iwc_data.close()
def generate_classification(categorize_file, output_file): """Generates Cloudnet classification product. This function reads the initial classification masks from a categorize file and creates a more comprehensive classification for different atmospheric targets. The results are written in a netCDF file. Args: categorize_file (str): Categorize file name. output_file (str): Output file name. Examples: >>> from cloudnetpy.products import generate_classification >>> generate_classification('categorize.nc', 'classification.nc') """ data_handler = DataSource(categorize_file) categorize_bits = CategorizeBits(categorize_file) classification = _get_target_classification(categorize_bits) data_handler.append_data(classification, 'target_classification') status = _get_detection_status(categorize_bits) data_handler.append_data(status, 'detection_status') output.update_attributes(data_handler.data, CLASSIFICATION_ATTRIBUTES) output.save_product_file('classification', data_handler, output_file) data_handler.close()
def generate_lwc(categorize_file, output_file): """Generates Cloudnet liquid water content product. This function calculates cloud liquid water content using the so-called adiabatic-scaled method. In this method, liquid water content measured by microwave radiometer is used to constrain the theoretical liquid water content of observed liquid clouds. The results are written in a netCDF file. Args: categorize_file (str): Categorize file name. output_file (str): Output file name. Examples: >>> from cloudnetpy.products import generate_lwc >>> generate_lwc('categorize.nc', 'lwc.nc') References: Illingworth, A.J., R.J. Hogan, E. O'Connor, D. Bouniol, M.E. Brooks, J. Delanoé, D.P. Donovan, J.D. Eastment, N. Gaussiat, J.W. Goddard, M. Haeffelin, H.K. Baltink, O.A. Krasnov, J. Pelon, J. Piriou, A. Protat, H.W. Russchenberg, A. Seifert, A.M. Tompkins, G. van Zadelhoff, F. Vinit, U. Willén, D.R. Wilson, and C.L. Wrench, 2007: Cloudnet. Bull. Amer. Meteor. Soc., 88, 883–898, https://doi.org/10.1175/BAMS-88-6-883 """ lwc_source = LwcSource(categorize_file) lwc_obj = Lwc(lwc_source) cloud_obj = LwcStatus(lwc_source, lwc_obj) error_obj = LwcError(lwc_source, lwc_obj) _append_data(lwc_source, lwc_obj, cloud_obj, error_obj) output.update_attributes(lwc_source.data, LWC_ATTRIBUTES) output.save_product_file('lwc', lwc_source, output_file, copy_from_cat=('lwp', 'lwp_error')) lwc_source.close()
def generate_classification(categorize_file, output_file, keep_uuid=False): """Generates Cloudnet classification product. This function reads the initial classification masks from a categorize file and creates a more comprehensive classification for different atmospheric targets. The results are written in a netCDF file. Args: categorize_file (str): Categorize file name. output_file (str): Output file name. keep_uuid (bool, optional): If True, keeps the UUID of the old file, if that exists. Default is False when new UUID is generated. Returns: str: UUID of the generated file. Examples: >>> from cloudnetpy.products import generate_classification >>> generate_classification('categorize.nc', 'classification.nc') """ data_handler = DataSource(categorize_file) categorize_bits = CategorizeBits(categorize_file) classification = _get_target_classification(categorize_bits) data_handler.append_data(classification, 'target_classification') status = _get_detection_status(categorize_bits) data_handler.append_data(status, 'detection_status') output.update_attributes(data_handler.data, CLASSIFICATION_ATTRIBUTES) uuid = output.save_product_file('classification', data_handler, output_file, keep_uuid) data_handler.close() return uuid
def generate_drizzle(categorize_file: str, output_file: str, keep_uuid: bool = False, uuid: Union[str, None] = None) -> str: """Generates Cloudnet drizzle product. This function calculates different drizzle properties from cloud radar and lidar measurements. The results are written in a netCDF file. Args: categorize_file (str): Categorize file name. output_file (str): Output file name. keep_uuid (bool, optional): If True, keeps the UUID of the old file, if that exists. Default is False when new UUID is generated. uuid (str, optional): Set specific UUID for the file. Returns: str: UUID of the generated file. Examples: >>> from cloudnetpy.products import generate_drizzle >>> generate_drizzle('categorize.nc', 'drizzle.nc') References: O’Connor, E.J., R.J. Hogan, and A.J. Illingworth, 2005: Retrieving Stratocumulus Drizzle Parameters Using Doppler Radar and Lidar. J. Appl. Meteor., 44, 14–27, https://doi.org/10.1175/JAM-2181.1 """ drizzle_source = DrizzleSource(categorize_file) drizzle_class = DrizzleClassification(categorize_file) spectral_width = SpectralWidth(categorize_file) drizzle_solver = DrizzleSolver(drizzle_source, drizzle_class, spectral_width) derived_products = DrizzleProducts(drizzle_source, drizzle_solver) errors = get_drizzle_error(drizzle_source, drizzle_solver) retrieval_status = RetrievalStatus(drizzle_class) results = { **drizzle_solver.params, **derived_products.derived_products, **errors } results = _screen_rain(results, drizzle_class) results['drizzle_retrieval_status'] = retrieval_status.retrieval_status _append_data(drizzle_source, results) date = drizzle_source.get_date() attributes = output.add_time_attribute(DRIZZLE_ATTRIBUTES, date) output.update_attributes(drizzle_source.data, attributes) uuid = output.save_product_file('drizzle', drizzle_source, output_file, keep_uuid, uuid) drizzle_source.close() return uuid
def generate_drizzle(categorize_file, output_file): """Generates Cloudnet drizzle product. This function calculates different drizzle properties from cloud radar and lidar measurements. The results are written in a netCDF file. Args: categorize_file (str): Categorize file name. output_file (str): Output file name. Examples: >>> from cloudnetpy.products import generate_drizzle >>> generate_drizzle('categorize.nc', 'drizzle.nc') References: O’Connor, E.J., R.J. Hogan, and A.J. Illingworth, 2005: Retrieving Stratocumulus Drizzle Parameters Using Doppler Radar and Lidar. J. Appl. Meteor., 44, 14–27, https://doi.org/10.1175/JAM-2181.1 """ drizzle_data = DrizzleSource(categorize_file) drizzle_class = DrizzleClassification(categorize_file) spectral_width = CorrectSpectralWidth(categorize_file) drizzle_parameters = DrizzleSolving(drizzle_data, drizzle_class, spectral_width) derived_products = CalculateProducts(drizzle_data, drizzle_parameters) errors = get_drizzle_error(drizzle_data, drizzle_parameters) retrieval_status = RetrievalStatus(drizzle_class) results = { **drizzle_parameters.params, **derived_products.derived_products, **errors } results = _screen_rain(results, drizzle_class) results['drizzle_retrieval_status'] = retrieval_status.retrieval_status _append_data(drizzle_data, results) output.update_attributes(drizzle_data.data, DRIZZLE_ATTRIBUTES) output.save_product_file('drizzle', drizzle_data, output_file) drizzle_data.close()
def generate_lwc(categorize_file: str, output_file: str, uuid: Optional[str] = None) -> str: """Generates Cloudnet liquid water content product. This function calculates cloud liquid water content using the so-called adiabatic-scaled method. In this method, liquid water content measured by microwave radiometer is used to constrain the theoretical liquid water content of observed liquid clouds. The results are written in a netCDF file. Args: categorize_file: Categorize file name. output_file: Output file name. uuid: Set specific UUID for the file. Returns: str: UUID of the generated file. Examples: >>> from cloudnetpy.products import generate_lwc >>> generate_lwc('categorize.nc', 'lwc.nc') References: Illingworth, A.J., R.J. Hogan, E. O'Connor, D. Bouniol, M.E. Brooks, J. Delanoé, D.P. Donovan, J.D. Eastment, N. Gaussiat, J.W. Goddard, M. Haeffelin, H.K. Baltink, O.A. Krasnov, J. Pelon, J. Piriou, A. Protat, H.W. Russchenberg, A. Seifert, A.M. Tompkins, G. van Zadelhoff, F. Vinit, U. Willén, D.R. Wilson, and C.L. Wrench, 2007: Cloudnet. Bull. Amer. Meteor. Soc., 88, 883–898, https://doi.org/10.1175/BAMS-88-6-883 """ lwc_source = LwcSource(categorize_file) lwc = Lwc(lwc_source) clouds = CloudAdjustor(lwc_source, lwc) lwc_error = LwcError(lwc_source, lwc) lwc_source.append_results(lwc.lwc, clouds.status, lwc_error.error) date = lwc_source.get_date() attributes = output.add_time_attribute(LWC_ATTRIBUTES, date) output.update_attributes(lwc_source.data, attributes) uuid = output.save_product_file( "lwc", lwc_source, output_file, uuid, copy_from_cat=( "lwp", "lwp_error", ), ) lwc_source.close() return uuid
def generate_iwc(categorize_file: str, output_file: str, keep_uuid: Optional[bool] = False, uuid: Optional[str] = None) -> str: """Generates Cloudnet ice water content product. This function calculates ice water content using the so-called Z-T method. In this method, ice water content is calculated from attenuated-corrected radar reflectivity and model temperature. The results are written in a netCDF file. Args: categorize_file: Categorize file name. output_file: Output file name. keep_uuid: If True, keeps the UUID of the old file, if that exists. Default is False when new UUID is generated. uuid: Set specific UUID for the file. Returns: UUID of the generated file. Examples: >>> from cloudnetpy.products import generate_iwc >>> generate_iwc('categorize.nc', 'iwc.nc') References: Hogan, R.J., M.P. Mittermaier, and A.J. Illingworth, 2006: The Retrieval of Ice Water Content from Radar Reflectivity Factor and Temperature and Its Use in Evaluating a Mesoscale Model. J. Appl. Meteor. Climatol., 45, 301–317, https://doi.org/10.1175/JAM2340.1 """ iwc_source = IwcSource(categorize_file) ice_classification = IceClassification(categorize_file) iwc_source.append_iwc_including_rain(ice_classification) iwc_source.append_iwc(ice_classification) iwc_source.append_bias() iwc_source.append_sensitivity() iwc_source.append_error(ice_classification) iwc_source.append_status(ice_classification) date = iwc_source.get_date() attributes = output.add_time_attribute(IWC_ATTRIBUTES, date) output.update_attributes(iwc_source.data, attributes) uuid = output.save_product_file('iwc', iwc_source, output_file, keep_uuid, uuid) iwc_source.close() return uuid
def generate_classification(categorize_file: str, output_file: str, keep_uuid: bool = False, uuid: Optional[str] = None) -> str: """Generates Cloudnet classification product. This function reads the initial classification masks from a categorize file and creates a more comprehensive classification for different atmospheric targets. The results are written in a netCDF file. Args: categorize_file: Categorize file name. output_file: Output file name. keep_uuid: If True, keeps the UUID of the old file, if that exists. Default is False when new UUID is generated. uuid: Set specific UUID for the file. Returns: str: UUID of the generated file. Examples: >>> from cloudnetpy.products import generate_classification >>> generate_classification('categorize.nc', 'classification.nc') """ product_container = DataSource(categorize_file) categorize_bits = CategorizeBits(categorize_file) classification = _get_target_classification(categorize_bits) product_container.append_data(classification, 'target_classification') status = _get_detection_status(categorize_bits) product_container.append_data(status, 'detection_status') bases, tops = _get_cloud_base_and_top_heights(classification, product_container) product_container.append_data(bases, 'cloud_base_height_amsl') product_container.append_data(tops, 'cloud_top_height_amsl') product_container.append_data(bases - product_container.altitude, 'cloud_base_height_agl') product_container.append_data(tops - product_container.altitude, 'cloud_top_height_agl') date = product_container.get_date() attributes = output.add_time_attribute(CLASSIFICATION_ATTRIBUTES, date) output.update_attributes(product_container.data, attributes) uuid = output.save_product_file('classification', product_container, output_file, keep_uuid, uuid) product_container.close() return uuid