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