From 4bce71a7aa9e9c0a9ea7f145b33e5ecfdb9ed355 Mon Sep 17 00:00:00 2001 From: martin-rdz Date: Wed, 20 May 2026 20:19:21 +0200 Subject: [PATCH 1/4] first try to address #76 --- ppcpy/cloudmask/cloudscreen.py | 4 +- ppcpy/cloudmask/profilesegment.py | 4 +- ppcpy/interface/picassoProc.py | 29 +- ppcpy/preprocess/profiles.py | 35 +- ...t_case_cpv_2024-08-21_exclude_clouds.ipynb | 702 ++++++++++++++++++ 5 files changed, 753 insertions(+), 21 deletions(-) create mode 100644 tests/test_case_cpv_2024-08-21_exclude_clouds.ipynb diff --git a/ppcpy/cloudmask/cloudscreen.py b/ppcpy/cloudmask/cloudscreen.py index a2b44f0..aa0cb53 100644 --- a/ppcpy/cloudmask/cloudscreen.py +++ b/ppcpy/cloudmask/cloudscreen.py @@ -79,11 +79,11 @@ def cloudscreen(data_cube, wv:int=532, collect_debug:bool=False) -> np.ndarray: # Cloud screen mode dependent configuration if config_dict['cloudScreenMode'] == 0: # No cloud screening - logging.warning(f'cloud screen mode {config_dict['cloudScreenMode']}: No cloud screening.') + logging.warning(f"cloud screen mode {config_dict['cloudScreenMode']}: No cloud screening.") return np.ones(bg.shape, dtype=bool) elif config_dict['cloudScreenMode'] == 1: # MSG method - logging.info(f'cloud screen mode {config_dict['cloudScreenMode']}: MSG method.') + logging.info(f"cloud screen mode {config_dict['cloudScreenMode']}: MSG method.") screenfunc = cloudScreen_MSG sig = 'RCS' kwargs = { diff --git a/ppcpy/cloudmask/profilesegment.py b/ppcpy/cloudmask/profilesegment.py index 34b7c72..1b4a43f 100644 --- a/ppcpy/cloudmask/profilesegment.py +++ b/ppcpy/cloudmask/profilesegment.py @@ -22,11 +22,9 @@ def segment(data_cube) -> np.ndarray: """ config_dict = data_cube.polly_config_dict - flagValPrf = data_cube.flagCloudFree & (~data_cube.retrievals_highres['depCalMask']) \ - & (~data_cube.retrievals_highres['shutterOnMask']) & (~data_cube.retrievals_highres['fogMask']) print('intNProfiles', config_dict['intNProfiles'], 'minIntNProfiles', config_dict['minIntNProfiles']) - clFreeGrps = clFreeSeg(flagValPrf, config_dict['intNProfiles'], config_dict['minIntNProfiles']) + clFreeGrps = clFreeSeg(data_cube.flagValPrf, config_dict['intNProfiles'], config_dict['minIntNProfiles']) return clFreeGrps diff --git a/ppcpy/interface/picassoProc.py b/ppcpy/interface/picassoProc.py index 9dcce38..55d7ab8 100644 --- a/ppcpy/interface/picassoProc.py +++ b/ppcpy/interface/picassoProc.py @@ -375,6 +375,14 @@ def cloudScreen(self, collect_debug:bool=False): self.flagCloudFree = cloudscreen.cloudscreen(self, collect_debug=collect_debug) + def genFlagValPrf(self): + """combine the cloudFree, depCal, shutterOn and fog masks to obtain valid profiles + + """ + self.flagValPrf = self.flagCloudFree & (~self.retrievals_highres['depCalMask']) \ + & (~self.retrievals_highres['shutterOnMask']) & (~self.retrievals_highres['fogMask']) + + def cloudFreeSeg(self): """cloud free profile segmentation @@ -388,21 +396,32 @@ def cloudFreeSeg(self): ] """ + self.genFlagValPrf() self.clFreeGrps = profilesegment.segment(self) - def aggregate_profiles(self, var=None): + def aggregate_profiles(self, var=None, flagVal=None): """Aggregate highres profiles over cloud free segments + Parameters + ---------- + var : None | string + variables to aggregate. If `None`, `'RCS'`, `'sigBGCor'` and `'BG'` will be aggregated. + flagVal : None | bool | np.ndarray + cut out single invalid profiles form `clFreeGrps`. If `True` the `data_cube.flagValPrf` is used. Individual array can also be supplied. + .. TODO:: Decide on a consistent way for doing the aggregation, do not mix mean and sum """ + if flagVal and not isinstance(flagVal, np.ndarray): + flagVal = self.flagValPrf + if var == None: self.retrievals_profile['RCS'] = \ - preprocprofiles.aggregate_clFreeGrps(self, 'RCS', func=np.nanmean) + preprocprofiles.aggregate_clFreeGrps(self, 'RCS', func=np.nanmean, flagVal=flagVal) self.retrievals_profile['sigBGCor'] = \ - preprocprofiles.aggregate_clFreeGrps(self, 'sigBGCor') + preprocprofiles.aggregate_clFreeGrps(self, 'sigBGCor', flagVal=flagVal) self.retrievals_profile['BG'] = \ - preprocprofiles.aggregate_clFreeGrps(self, 'BG') + preprocprofiles.aggregate_clFreeGrps(self, 'BG', flagVal=flagVal) # Remove empty dict keys (temporarly solution) for v in ['RCS', 'sigBGCor', 'BG']: @@ -411,7 +430,7 @@ def aggregate_profiles(self, var=None): else: self.retrievals_profile[var] = \ - preprocprofiles.aggregate_clFreeGrps(self, var) + preprocprofiles.aggregate_clFreeGrps(self, var, flagVal=flagVal) # Remove empty dict keys (temporarly solution) if self.retrievals_profile[var] is None: diff --git a/ppcpy/preprocess/profiles.py b/ppcpy/preprocess/profiles.py index da0a44d..465486f 100644 --- a/ppcpy/preprocess/profiles.py +++ b/ppcpy/preprocess/profiles.py @@ -1,17 +1,24 @@ import numpy as np -def aggregate_clFreeGrps(data_cube, var:str, func=np.nansum): - """ - Aggregate the highres signal over the periods of the cloud free signal. +def aggregate_clFreeGrps(data_cube, var:str, func=np.nansum, flagVal=None): + """aggregate the highres signal over the periods of the cloud free signal. - Input: - - data_cube (object): Main PicassoProc object. - - var (string): name of variable to be aggregated. - - func (function): function to do the aggregateion (mean, sum, median, etc), defult: np.nansum. - - Output: - - out (np.ndarray): Aggregated highres signal for each cloud free segment. + Parameters + ---------- + data_cube : object + Main PicassoProc object. + var : string + name of variable to be aggregated. + func : function + function to do the aggregateion (mean, sum, median, etc), defult: np.nansum. + flagVal : None | np.ndarray + boolean flag for valid profiles + + Returns + ------- + out : np.ndarray + Aggregated highres signal for each cloud free segment. """ # Check if variable exists, if not return. if var not in data_cube.retrievals_highres: @@ -24,6 +31,12 @@ def aggregate_clFreeGrps(data_cube, var:str, func=np.nansum): for i, cldFree in enumerate(data_cube.clFreeGrps): cldFree = cldFree[0], cldFree[1] + 1 - out[i, ...] = func(data_cube.retrievals_highres[var][slice(*cldFree), ...], axis=0) + data_chunk = data_cube.retrievals_highres[var][slice(*cldFree), ...] + print(data_chunk.shape) + if isinstance(flagVal, np.ndarray): + data_chunk = data_chunk[flagVal[slice(*cldFree)], ...] + print(data_chunk.shape) + out[i, ...] = func(data_chunk, axis=0) + return out \ No newline at end of file diff --git a/tests/test_case_cpv_2024-08-21_exclude_clouds.ipynb b/tests/test_case_cpv_2024-08-21_exclude_clouds.ipynb new file mode 100644 index 0000000..073d7c5 --- /dev/null +++ b/tests/test_case_cpv_2024-08-21_exclude_clouds.ipynb @@ -0,0 +1,702 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "07a5e20f-3b1c-4d25-90ec-58e659beb604", + "metadata": {}, + "source": [ + "# **PicassoPy Workshop --> Test case: cpv 2024-08-21**\n", + "---\n", + "\n", + "\n", + "- Folder for data `test_case_data` -> download separately\n", + "- Folder for configs `test_case_config`\n", + "\n", + "The autoreload below is needed to directly pull in changes in the picassopy source code" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b9f15a03-c987-48c0-91c3-0fb32aa9ea76", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "id": "61e316d2", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d9357e59-6b1c-48ef-887f-92bc1bfdad3f", + "metadata": {}, + "outputs": [], + "source": [ + "import os, sys\n", + "import argparse\n", + "import datetime\n", + "import logging\n", + "from pathlib import Path\n", + "import numpy as np\n", + "\n", + "sys.path.append('../')\n", + "import ppcpy\n", + "import ppcpy.io.loadConfigs as loadConfigs\n", + "import ppcpy.io.readPollyRawData as readPollyRawData\n", + "import ppcpy.interface.picassoProc as picassoProc\n", + "import ppcpy.misc.helper as helper\n", + "import ppcpy.misc.startscreen as startscreen\n", + "from ppcpy.io.write2nc import write_channelwise_2_nc_file, write2nc_file, write_profile2nc_file\n", + "\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "plt.rcParams['axes.prop_cycle'] = plt.cycler(color=plt.cm.tab20.colors)" + ] + }, + { + "cell_type": "markdown", + "id": "a1dcfcd1", + "metadata": {}, + "source": [ + "## Defining Script Inputs\n", + "\n", + "- The parameters `args.device`, `args.timestamp`, `args.picasso_config_file`, `args.level0_file_to_process`, need to be manually specified per case.\n", + "- The parameter `DATABASE_PATH` is the path to the database used for storing the retrieved calibration constants" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "757db1a3-8f88-4d02-bb42-235dee8f1ff6", + "metadata": {}, + "outputs": [], + "source": [ + "## For purpose of the notebook mimic the argparse interface\n", + "from types import SimpleNamespace\n", + "args = SimpleNamespace()\n", + "\n", + "## The used device and time of mesurment\n", + "args.device = 'pollyxt_cpv'\n", + "args.timestamp = '20240821'\n", + "dt = datetime.datetime.strptime(args.timestamp, \"%Y%m%d\")\n", + "\n", + "## The used config file\n", + "args.picasso_config_file = \"test_case_config/pollynet_processing_chain_config_test.json\"\n", + "\n", + "## The data file to use\n", + "args.level0_file_to_process = f\"test_case_data/{dt:%Y_%m_%d_%a}_CPV_00_00_01.nc\"\n", + "\n", + "\n", + "## Database path\n", + "DATABASE_PATH = \"PicassoPyDatabase.db\" # I should test if it works to read this directly from the config files." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4fcd069d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ____ _ ____ ___ ____ \n", + " / __ \\(_)________ _______________ / __ \\__ __ < // __ \\\n", + " / /_/ / / ___/ __ `/ ___/ ___/ __ \\/ /_/ / / / / / // / / /\n", + " / ____/ / /__/ /_/ (__ |__ ) /_/ / ____/ /_/ / / // /_/ / \n", + " /_/ /_/\\___/\\__,_/____/____/\\____/_/ \\__, / /_(_)____/ \n", + " /____/ \n" + ] + } + ], + "source": [ + "startscreen.startscreen()" + ] + }, + { + "cell_type": "markdown", + "id": "e2144e6f", + "metadata": {}, + "source": [ + "## Load Data and Config-files\n", + "\n", + "Loads data and information from the config files into the following three dictionaries:\n", + "- `picasso_config_dict`: Paths and other information stored in the picasso config file\n", + "- `polly_config_dict`: Configuration variables from polly config and polly default files\n", + "- `rawdata_dict`: Measurement data and information extracted from the level0 file" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "648de474-fe46-4f39-82ee-d1731db90ec8", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-05-20 17:39:55,041 - INFO - picasso_default_config_file: /mnt/c/Users/radenz/dev/PicassoPy/PicassoPy/ppcpy/config/pollynet_processing_chain_config.json\n", + "2026-05-20 17:39:55,058 - INFO - picasso_config_file: test_case_config/pollynet_processing_chain_config_test.json\n", + "2026-05-20 17:39:55,073 - INFO - pollynet_config_link_file: test_case_config/pollynet_processing_chain_config_links.xlsx\n", + "2026-05-20 17:39:59,161 - INFO - polly_default_config_file: /mnt/c/Users/radenz/dev/PicassoPy/PicassoPy/ppcpy/config/polly_global_config.json\n", + "2026-05-20 17:39:59,172 - INFO - polly_config_file: test_case_config/pollyxt_cpv_config_20230927.json\n", + "2026-05-20 17:39:59,181 - INFO - keys default/template file, but not in specific file {'refH_FR_532', 'yLim_cloudinfo', 'maxCloudSearchHeight_NR', 'zLim_FR_RCS_607', 'polCaliEtaStd1064', 'ice_thres_vol_depol', 'cloud_thres_par_beta_1064', 'zLim_FR_RCS_407', 'molDepol1064', 'droplet_thres_par_depol', 'xLim_Profi_LR', 'isParallel', 'yLim_beta_532_Poliphon', 'minSNR_4_sigNorm', 'depol_cal_time_fixed_p_start', 'turbid_thres_par_beta_532', 'small_thres_ang', 'turbid_thres_par_beta_1064', 'imgFormat', 'zLim_quasi_ANG', 'zLim_NR_RCS_387', 'maxCloudSearchHeight', 'flagMolDepolCali', 'zLim_VolDepol_355', 'ice_thres_par_depol', 'bgCorRangeIndxHigh', 'bgCorRangeIndxLow', 'zLim_NR_RCS_407', 'depol_cal_time_fixed_m_start', 'tTwilight', 'colormap_basic', 'search_cloud_below', 'smoothWin_klett_NR_532', 'spheroid_thres_par_depol', 'volDepolerror355', 'yLim_all_profiles_low_range', 'polCaliEta1064', 'depol_cal_time_fixed_m_end', 'flagPicassoComparison', 'flagUseTheoreticalMDR', 'polCaliEta532', 'depol_cal_time_fixed_p_end', 'xLim_Profi_AE', 'flagUseRetrievedExt4LCCalc', 'zLim_VolDepol_532', 'zLim_VolDepol_1064', 'refH_FR_1064', 'xLim_beta_532_Poliphon', 'polCaliEta355', 'deltaT', 'zLim_NR_RCS_607', 'radiosondeFolder', 'polCaliEtaStd355', 'large_thres_ang', 'flagSigTempCor', 'zLim_FR_RCS_387', 'indexing_convention', 'search_cloud_above', 'smoothWin_klett_NR_355', 'radiosondeType', 'prodSaveList', 'min_atten_par_beta_1064', 'tempCorFunc', 'volDepolerror1064', 'yLim_all_profiles_high_range', 'unspheroid_thres_par_depol', 'overlapFile_355_total_FR', 'molDepolStd1064', 'yLim_Profi_WV_RH', 'logbookPath', 'polCaliEtaStd532', 'xLim_Profi_RH', 'depol_cali_mode', 'clear_thres_par_beta_1064', 'volDepolerror532', 'refH_FR_355', 'overlapFile_532_total_FR', 'logbookFileName', 'flagUseManualRefH'}\n", + "2026-05-20 17:39:59,184 - INFO - keys specific file, but not in default/template file {'meteo_file', 'overlapFile532', 'overlapFile355', 'bgCorRangeIndx'}\n", + "2026-05-20 17:39:59,190 - INFO - reading nc-file: test_case_data/2024_08_21_Wed_CPV_00_00_01.nc\n" + ] + } + ], + "source": [ + "## Path to dafault Picasso config file\n", + "picasso_default_config_file = Path(\n", + " helper.detect_path_type(Path.cwd().parent), 'ppcpy', 'config', 'pollynet_processing_chain_config.json')\n", + "\n", + "## Load Picasso config file\n", + "picasso_config_dict = loadConfigs.loadPicassoConfig(args.picasso_config_file, picasso_default_config_file)\n", + "\n", + "## load polly config file\n", + "polly_config_array = loadConfigs.readPollyNetConfigLinkTable(picasso_config_dict['pollynet_config_link_file'], timestamp=args.timestamp, device=args.device)\n", + "polly_config_dict = loadConfigs.getPollyConfigfromArray(\n", + " polly_config_array, picasso_config_dict\n", + ")\n", + "\n", + "## Load level0-data file\n", + "rawfile_fullname = args.level0_file_to_process\n", + "rawfile = helper.detect_path_type(rawfile_fullname)\n", + "rawdata_dict = readPollyRawData.readPollyRawData(rawfile)" + ] + }, + { + "cell_type": "markdown", + "id": "1ca5548d", + "metadata": {}, + "source": [ + "## Initialize PicassoProc object\n", + "\n", + "PicassoProc is the main object in the PicassoPy, and is responsible for running all processes included and storing the data." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "5615d419-693f-43e9-836a-91121cae3785", + "metadata": {}, + "outputs": [], + "source": [ + "time_period = [0, 500]\n", + "rawdata_dict['raw_signal']['var_data'] = rawdata_dict['raw_signal']['var_data'][slice(*time_period),...]\n", + "rawdata_dict['measurement_shots']['var_data'] = rawdata_dict['measurement_shots']['var_data'][slice(*time_period),...]\n", + "rawdata_dict['measurement_time']['var_data'] = rawdata_dict['measurement_time']['var_data'][slice(*time_period),...]\n", + "rawdata_dict['depol_cal_angle']['var_data'] = rawdata_dict['depol_cal_angle']['var_data'][slice(*time_period),...]\n", + "rawdata_dict['location_coordinates']['var_data'] = rawdata_dict['location_coordinates']['var_data'][slice(*time_period),...]" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "1141175f-1f22-47ae-96dd-d9226e854e18", + "metadata": {}, + "outputs": [], + "source": [ + "## Initialize PicassoProc\n", + "data_cube = picassoProc.PicassoProc(rawdata_dict, polly_config_dict, picasso_config_dict)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "70b3264d-9b4d-4994-8d88-557cba209d84", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-05-20 18:14:18,554 - INFO - date consistency-check... \n", + "2026-05-20 18:14:18,559 - INFO - ... date in nc-file equals date of filename\n", + "2026-05-20 18:14:18,573 - INFO - ChannelLabels: ['FR-total-355 nm', 'FR-cross-355 nm', 'FR-387 nm', 'FR-407 nm', 'FR-total-532 nm', 'FR-cross-532 nm', 'FR-607 nm', 'FR-total-1064 nm', 'NR-total-532 nm', 'NR-607 nm', 'NR-total-355 nm', 'NR-387 nm', 'DFOV', '1058', '1064s']\n", + "2026-05-20 18:14:18,577 - INFO - date consistency-check... \n", + "2026-05-20 18:14:18,579 - INFO - ... date in nc-file equals date of filename\n" + ] + } + ], + "source": [ + "## reset date if date in filename differs date within nc-file \n", + "data_cube.reset_date_infile()\n", + "\n", + "## checking for correct mshots\n", + "data_cube.check_for_correct_mshots()\n", + "\n", + "## setting channelTags\n", + "data_cube.setChannelTags()\n", + "\n", + "## check for correct date in nc-file\n", + "data_cube.reset_date_infile()" + ] + }, + { + "cell_type": "markdown", + "id": "7215c4d2", + "metadata": {}, + "source": [ + "## Preprocessing & Saturation Detection\n", + "\n", + "The preprocessing includes the following processes:\n", + "- Deadtime correction\n", + "- Background correction\n", + "- SNR claculations\n", + "- Flagging of data\n", + "- Range correction" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "75e45529-0a19-4580-9bc5-269eadba869b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-05-20 18:14:24,308 - INFO - starting data preprocessing...\n", + "2026-05-20 18:14:24,313 - INFO - ... time conversion\n", + "2026-05-20 18:14:24,330 - WARNING - ... mShots not constant min 2993 max 2999\n", + "2026-05-20 18:14:24,344 - INFO - ... Deadtime-correction (Mode: 1)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mShots_norm (500, 15) mShots_norm [2995.756 2995.756 2995.756 2995.756 2995.756 2995.756 2995.756 2995.756\n", + " 2995.738 2995.738 2995.738 2995.738 2995.738 2995.738 2995.738]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-05-20 18:14:47,823 - INFO - ... removing background from signal\n", + "2026-05-20 18:15:02,544 - INFO - ... height bin calculations\n", + "2026-05-20 18:15:05,396 - INFO - ... mask bins with low SNR\n", + "2026-05-20 18:15:20,136 - INFO - ... mask for polarization calibration\n", + "2026-05-20 18:15:20,166 - INFO - ... calculate range-corrected Signal\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "flag 532 FR [False False False False True False False False False False False False\n", + " False False False]\n", + "flag 355 FR [ True False False False False False False False False False False False\n", + " False False False]\n", + "flag 607 FR [False False False False False False True False False False False False\n", + " False False False]\n", + "flagNDepCal [False False False False False False False False False False False False\n", + " True True True True True True True True False]\n", + "flagPDepCal [False False True True True True True True True True False False\n", + " False False False False False False False False False]\n", + "depCalPeriods [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + " 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0\n", + " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", + " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]\n", + "flagIDepCal [1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]\n", + "21 21\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-05-20 18:15:21,927 - INFO - finished data preprocessing.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(500, 4000, 15)\n", + "ranges2d (500, 4000)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## Perform preprocessing, this includes Dead-time correction, Background correction, and Range correction\n", + "data_cube.preprocessing(collect_debug=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "774aa365", + "metadata": {}, + "outputs": [], + "source": [ + "## Save high resolution signal-to-noise ratio, background, and range corrected signal\n", + "#write_channelwise_2_nc_file(data_cube=data_cube, prod_ls=['SNR', 'BG', 'RCS'])" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "0df6f7b6-f5a2-4cc2-9257-64e0d5fe8a88", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{0: 'FR-total-355 nm',\n", + " 1: 'FR-cross-355 nm',\n", + " 2: 'FR-387 nm',\n", + " 3: 'FR-407 nm',\n", + " 4: 'FR-total-532 nm',\n", + " 5: 'FR-cross-532 nm',\n", + " 6: 'FR-607 nm',\n", + " 7: 'FR-total-1064 nm',\n", + " 8: 'NR-total-532 nm',\n", + " 9: 'NR-607 nm',\n", + " 10: 'NR-total-355 nm',\n", + " 11: 'NR-387 nm',\n", + " 12: 'DFOV',\n", + " 13: '1058',\n", + " 14: '1064s'}" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## Display available channels\n", + "data_cube.channel_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "3dfe7541-d789-4a4a-be43-b7a6d08d4dd5", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-05-20 18:15:39,297 - INFO - Saturation detection\n" + ] + } + ], + "source": [ + "## Detect and flag saturated signal\n", + "data_cube.SaturationDetect()" + ] + }, + { + "cell_type": "markdown", + "id": "9031d7c5", + "metadata": {}, + "source": [ + "## Cloud Screening\n", + "\n", + "Three modes of cloud Screening are currently implemented:\n", + "\n", + "0. No cloud screening. Return cloud free for all timestamps\n", + "1. Cloud screen with Maximum Gradiant Signal (MSG) algorithm\n", + "2. Cloud screen with Zhao's algorithm\n", + "\n", + "Clouds are screened per timestamp (30s). After the screening the data is splitt up into cloud free segments and aggregated." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "9279e9d1-b4d9-4f81-a50d-e970ccbf4c48", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-05-20 18:15:50,048 - INFO - cloud screen mode 1: MSG method.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting cloud screen\n" + ] + } + ], + "source": [ + "## Apply cloud screening\n", + "data_cube.cloudScreen()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "cb1ecc63-0bb1-40da-9a2d-d03a7e3a2202", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "intNProfiles 120 minIntNProfiles 30\n" + ] + } + ], + "source": [ + "## Segmentate cloud free groups\n", + "data_cube.cloudFreeSeg()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "2a502a15", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 113],\n", + " [144, 244]])" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## Display cloud free groups\n", + "data_cube.clFreeGrps" + ] + }, + { + "cell_type": "markdown", + "id": "89926a8c-96eb-4a2e-921c-1df53f8ef69a", + "metadata": {}, + "source": [ + "### Exclude individual cloudy profiles" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "98eeacdd-23f4-4730-a97f-feb043556d10", + "metadata": {}, + "outputs": [], + "source": [ + "# Manually set the the start and stop of the profile including the cloud period\n", + "data_cube.clFreeGrps = np.array([[325, 365]])\n", + "\n", + "# If needed modify the data_cube.flagCloudFree and run data_cube.genFlagValPrf()\n", + "\n", + "# then when calling aggregate_profiles the function call has to be modified (see below)" + ] + }, + { + "cell_type": "markdown", + "id": "2aeda343", + "metadata": {}, + "source": [ + "### Plot example: Cloud free groups" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "685a5a0f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "wv, t, tel = 532, 'cross', 'FR'\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 4))\n", + "pcmesh = ax.pcolormesh(\n", + " data_cube.retrievals_highres['time64'],\n", + " data_cube.retrievals_highres['height']/1000,\n", + " np.squeeze(data_cube.retrievals_highres['RCS'][:, :, data_cube.gf(wv, t, tel)]).T,\n", + " shading='nearest',\n", + " vmin=5, vmax=1e7\n", + ")\n", + "\n", + "flag1 = ax.pcolormesh(\n", + " data_cube.retrievals_highres['time64'],\n", + " [4.9,5],\n", + " np.repeat(data_cube.flagCloudFree[:,np.newaxis], 2, axis=1).T,\n", + " shading='nearest', cmap='binary_r'\n", + ")\n", + "ax.text(data_cube.retrievals_highres[\"time64\"][0], 4.9, \"flagCloudFree\", fontsize=6, color='red')\n", + "flag2 = ax.pcolormesh(\n", + " data_cube.retrievals_highres['time64'],\n", + " [4.7,4.8],\n", + " np.repeat(data_cube.flagValPrf[:,np.newaxis], 2, axis=1).T,\n", + " shading='nearest', cmap='binary_r'\n", + ")\n", + "ax.text(data_cube.retrievals_highres[\"time64\"][0], 4.7, \"flagValPrf\", fontsize=6, color='red')\n", + "\n", + "for cldFreGrp in data_cube.clFreeGrps:\n", + " ax.axvspan(\n", + " data_cube.retrievals_highres[\"time64\"][cldFreGrp[0]],\n", + " data_cube.retrievals_highres[\"time64\"][cldFreGrp[1]],\n", + " color=\"red\", alpha=0.2\n", + " )\n", + "\n", + "cbar = fig.colorbar(pcmesh)\n", + "cbar.set_label(f'RCS {wv}nm {t} {tel} [MCPS]')\n", + "ax.yaxis.set_minor_locator(matplotlib.ticker.AutoMinorLocator())\n", + "ax.set_xlabel('Time [UTC]')\n", + "ax.set_ylabel('Height [km]')\n", + "ax.set_title('Cloud free groups marked in red')\n", + "ax.set_ylim(0, 5.05)\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "id": "623aeeb1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(41, 4000, 15)\n", + "(36, 4000, 15)\n", + "(41, 4000, 15)\n", + "(36, 4000, 15)\n", + "(41, 15)\n", + "(36, 15)\n" + ] + } + ], + "source": [ + "## Aggregate background, background corrected signal, and range corrected signal\n", + "# data_cube.aggregate_profiles()\n", + "data_cube.aggregate_profiles(flagVal=True)" + ] + }, + { + "cell_type": "markdown", + "id": "8c222841", + "metadata": {}, + "source": [ + "### Plot example: Aggregated profiles" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "id": "ee64aec2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, figsize=(3, 8), sharey=True)\n", + "ax.plot(np.squeeze(data_cube.retrievals_profile['RCS'][0, :, data_cube.gf(355, 'total', 'FR')]), data_cube.retrievals_highres['height']/1000, color='blue', alpha=0.9, linewidth=1, label='355nm FR')\n", + "ax.plot(np.squeeze(data_cube.retrievals_profile['RCS'][0, :, data_cube.gf(532, 'total', 'FR')]), data_cube.retrievals_highres['height']/1000, color='green', alpha=0.9, linewidth=1, label='532nm FR')\n", + "ax.plot(np.squeeze(data_cube.retrievals_profile['RCS'][0, :, data_cube.gf(1064, 'total', 'FR')]), data_cube.retrievals_highres['height']/1000, color='red', alpha=0.9, linewidth=1, label='1064nm FR')\n", + "ax.plot(np.squeeze(data_cube.retrievals_profile['RCS'][0, :, data_cube.gf(355, 'total', 'NR')]), data_cube.retrievals_highres['height']/1000, color='lightblue', alpha=0.9, linewidth=1, label='355nm NR')\n", + "ax.plot(np.squeeze(data_cube.retrievals_profile['RCS'][0, :, data_cube.gf(532, 'total', 'NR')]), data_cube.retrievals_highres['height']/1000, color='lightgreen', alpha=0.9, linewidth=1, label='532nm NR')\n", + "ax.grid()\n", + "ax.set_ylim(0, 5)\n", + "ax.set_xlim(right=7e6)\n", + "ax.legend(loc='upper right')\n", + "ax.set_ylabel('Height [m]')\n", + "ax.set_xlabel('RCS [MCPS]')\n", + "ax.set_title('cldFreeGrp 0')\n", + "\n", + "fig.suptitle(\"Aggregated Profiles\", fontweight='bold')\n", + "fig.tight_layout()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "831b02cf-bada-42c3-8220-75b04b15a094", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pyppc_env", + "language": "python", + "name": "pyppc_env" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0rc1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 56cabe646f519ef0136a6694e73a6daf5566222f Mon Sep 17 00:00:00 2001 From: martin-rdz Date: Thu, 2 Jul 2026 14:18:41 +0200 Subject: [PATCH 2/4] fix minior bug where providing an bool array resulted in an issue #76 --- ppcpy/interface/picassoProc.py | 4 +- ...t_case_cpv_2024-08-21_exclude_clouds.ipynb | 165 +++++++++++++----- 2 files changed, 125 insertions(+), 44 deletions(-) diff --git a/ppcpy/interface/picassoProc.py b/ppcpy/interface/picassoProc.py index 55d7ab8..ef282c8 100644 --- a/ppcpy/interface/picassoProc.py +++ b/ppcpy/interface/picassoProc.py @@ -412,7 +412,9 @@ def aggregate_profiles(self, var=None, flagVal=None): .. TODO:: Decide on a consistent way for doing the aggregation, do not mix mean and sum """ - if flagVal and not isinstance(flagVal, np.ndarray): + if isinstance(flagVal, np.ndarray): + flagVal = flagVal + elif flagVal and not isinstance(flagVal, np.ndarray): flagVal = self.flagValPrf if var == None: diff --git a/tests/test_case_cpv_2024-08-21_exclude_clouds.ipynb b/tests/test_case_cpv_2024-08-21_exclude_clouds.ipynb index 073d7c5..654f880 100644 --- a/tests/test_case_cpv_2024-08-21_exclude_clouds.ipynb +++ b/tests/test_case_cpv_2024-08-21_exclude_clouds.ipynb @@ -146,14 +146,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "2026-05-20 17:39:55,041 - INFO - picasso_default_config_file: /mnt/c/Users/radenz/dev/PicassoPy/PicassoPy/ppcpy/config/pollynet_processing_chain_config.json\n", - "2026-05-20 17:39:55,058 - INFO - picasso_config_file: test_case_config/pollynet_processing_chain_config_test.json\n", - "2026-05-20 17:39:55,073 - INFO - pollynet_config_link_file: test_case_config/pollynet_processing_chain_config_links.xlsx\n", - "2026-05-20 17:39:59,161 - INFO - polly_default_config_file: /mnt/c/Users/radenz/dev/PicassoPy/PicassoPy/ppcpy/config/polly_global_config.json\n", - "2026-05-20 17:39:59,172 - INFO - polly_config_file: test_case_config/pollyxt_cpv_config_20230927.json\n", - "2026-05-20 17:39:59,181 - INFO - keys default/template file, but not in specific file {'refH_FR_532', 'yLim_cloudinfo', 'maxCloudSearchHeight_NR', 'zLim_FR_RCS_607', 'polCaliEtaStd1064', 'ice_thres_vol_depol', 'cloud_thres_par_beta_1064', 'zLim_FR_RCS_407', 'molDepol1064', 'droplet_thres_par_depol', 'xLim_Profi_LR', 'isParallel', 'yLim_beta_532_Poliphon', 'minSNR_4_sigNorm', 'depol_cal_time_fixed_p_start', 'turbid_thres_par_beta_532', 'small_thres_ang', 'turbid_thres_par_beta_1064', 'imgFormat', 'zLim_quasi_ANG', 'zLim_NR_RCS_387', 'maxCloudSearchHeight', 'flagMolDepolCali', 'zLim_VolDepol_355', 'ice_thres_par_depol', 'bgCorRangeIndxHigh', 'bgCorRangeIndxLow', 'zLim_NR_RCS_407', 'depol_cal_time_fixed_m_start', 'tTwilight', 'colormap_basic', 'search_cloud_below', 'smoothWin_klett_NR_532', 'spheroid_thres_par_depol', 'volDepolerror355', 'yLim_all_profiles_low_range', 'polCaliEta1064', 'depol_cal_time_fixed_m_end', 'flagPicassoComparison', 'flagUseTheoreticalMDR', 'polCaliEta532', 'depol_cal_time_fixed_p_end', 'xLim_Profi_AE', 'flagUseRetrievedExt4LCCalc', 'zLim_VolDepol_532', 'zLim_VolDepol_1064', 'refH_FR_1064', 'xLim_beta_532_Poliphon', 'polCaliEta355', 'deltaT', 'zLim_NR_RCS_607', 'radiosondeFolder', 'polCaliEtaStd355', 'large_thres_ang', 'flagSigTempCor', 'zLim_FR_RCS_387', 'indexing_convention', 'search_cloud_above', 'smoothWin_klett_NR_355', 'radiosondeType', 'prodSaveList', 'min_atten_par_beta_1064', 'tempCorFunc', 'volDepolerror1064', 'yLim_all_profiles_high_range', 'unspheroid_thres_par_depol', 'overlapFile_355_total_FR', 'molDepolStd1064', 'yLim_Profi_WV_RH', 'logbookPath', 'polCaliEtaStd532', 'xLim_Profi_RH', 'depol_cali_mode', 'clear_thres_par_beta_1064', 'volDepolerror532', 'refH_FR_355', 'overlapFile_532_total_FR', 'logbookFileName', 'flagUseManualRefH'}\n", - "2026-05-20 17:39:59,184 - INFO - keys specific file, but not in default/template file {'meteo_file', 'overlapFile532', 'overlapFile355', 'bgCorRangeIndx'}\n", - "2026-05-20 17:39:59,190 - INFO - reading nc-file: test_case_data/2024_08_21_Wed_CPV_00_00_01.nc\n" + "2026-07-02 14:10:20,018 - INFO - picasso_default_config_file: /mnt/c/Users/radenz/dev/PicassoPy/PicassoPy/ppcpy/config/pollynet_processing_chain_config.json\n", + "2026-07-02 14:10:20,032 - INFO - picasso_config_file: test_case_config/pollynet_processing_chain_config_test.json\n", + "2026-07-02 14:10:20,043 - INFO - pollynet_config_link_file: test_case_config/pollynet_processing_chain_config_links.xlsx\n", + "2026-07-02 14:10:24,140 - INFO - polly_default_config_file: /mnt/c/Users/radenz/dev/PicassoPy/PicassoPy/ppcpy/config/polly_global_config.json\n", + "2026-07-02 14:10:24,157 - INFO - polly_config_file: test_case_config/pollyxt_cpv_config_20230927.json\n", + "2026-07-02 14:10:24,169 - INFO - keys default/template file, but not in specific file {'search_cloud_below', 'isParallel', 'yLim_all_profiles_high_range', 'polCaliEta532', 'large_thres_ang', 'prodSaveList', 'smoothWin_klett_NR_355', 'flagUseTheoreticalMDR', 'ice_thres_par_depol', 'molDepol1064', 'xLim_Profi_LR', 'flagPicassoComparison', 'colormap_basic', 'tTwilight', 'cloud_thres_par_beta_1064', 'zLim_FR_RCS_407', 'zLim_FR_RCS_387', 'zLim_quasi_ANG', 'depol_cali_mode', 'droplet_thres_par_depol', 'small_thres_ang', 'yLim_beta_532_Poliphon', 'polCaliEta1064', 'radiosondeFolder', 'depol_cal_time_fixed_p_end', 'turbid_thres_par_beta_532', 'polCaliEtaStd355', 'polCaliEtaStd1064', 'zLim_VolDepol_355', 'deltaT', 'logbookFileName', 'overlapFile_355_total_FR', 'depol_cal_time_fixed_p_start', 'smoothWin_klett_NR_532', 'yLim_all_profiles_low_range', 'unspheroid_thres_par_depol', 'flagUseManualRefH', 'xLim_beta_532_Poliphon', 'radiosondeType', 'flagSigTempCor', 'maxCloudSearchHeight_NR', 'polCaliEta355', 'refH_FR_355', 'bgCorRangeIndxLow', 'zLim_NR_RCS_607', 'yLim_Profi_WV_RH', 'volDepolerror355', 'xLim_Profi_AE', 'zLim_NR_RCS_387', 'polCaliEtaStd532', 'volDepolerror1064', 'volDepolerror532', 'indexing_convention', 'zLim_VolDepol_1064', 'refH_FR_532', 'minSNR_4_sigNorm', 'min_atten_par_beta_1064', 'flagUseRetrievedExt4LCCalc', 'refH_FR_1064', 'tempCorFunc', 'turbid_thres_par_beta_1064', 'zLim_NR_RCS_407', 'bgCorRangeIndxHigh', 'clear_thres_par_beta_1064', 'zLim_VolDepol_532', 'yLim_cloudinfo', 'imgFormat', 'flagMolDepolCali', 'overlapFile_532_total_FR', 'spheroid_thres_par_depol', 'xLim_Profi_RH', 'depol_cal_time_fixed_m_end', 'logbookPath', 'maxCloudSearchHeight', 'molDepolStd1064', 'ice_thres_vol_depol', 'zLim_FR_RCS_607', 'search_cloud_above', 'depol_cal_time_fixed_m_start'}\n", + "2026-07-02 14:10:24,172 - INFO - keys specific file, but not in default/template file {'overlapFile355', 'overlapFile532', 'meteo_file', 'bgCorRangeIndx'}\n", + "2026-07-02 14:10:24,180 - INFO - reading nc-file: test_case_data/2024_08_21_Wed_CPV_00_00_01.nc\n" ] } ], @@ -189,7 +189,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 6, "id": "5615d419-693f-43e9-836a-91121cae3785", "metadata": {}, "outputs": [], @@ -204,7 +204,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 7, "id": "1141175f-1f22-47ae-96dd-d9226e854e18", "metadata": {}, "outputs": [], @@ -215,7 +215,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 8, "id": "70b3264d-9b4d-4994-8d88-557cba209d84", "metadata": {}, "outputs": [ @@ -223,11 +223,12 @@ "name": "stderr", "output_type": "stream", "text": [ - "2026-05-20 18:14:18,554 - INFO - date consistency-check... \n", - "2026-05-20 18:14:18,559 - INFO - ... date in nc-file equals date of filename\n", - "2026-05-20 18:14:18,573 - INFO - ChannelLabels: ['FR-total-355 nm', 'FR-cross-355 nm', 'FR-387 nm', 'FR-407 nm', 'FR-total-532 nm', 'FR-cross-532 nm', 'FR-607 nm', 'FR-total-1064 nm', 'NR-total-532 nm', 'NR-607 nm', 'NR-total-355 nm', 'NR-387 nm', 'DFOV', '1058', '1064s']\n", - "2026-05-20 18:14:18,577 - INFO - date consistency-check... \n", - "2026-05-20 18:14:18,579 - INFO - ... date in nc-file equals date of filename\n" + "2026-07-02 14:11:00,248 - INFO - date consistency-check... \n", + "2026-07-02 14:11:00,250 - INFO - ... date in nc-file equals date of filename\n", + "2026-07-02 14:11:00,256 - INFO - ChannelLabels: ['FR-total-355 nm', 'FR-cross-355 nm', 'FR-387 nm', 'FR-407 nm', 'FR-total-532 nm', 'FR-cross-532 nm', 'FR-607 nm', 'FR-total-1064 nm', 'NR-total-532 nm', 'NR-607 nm', 'NR-total-355 nm', 'NR-387 nm', 'DFOV', '1058', '1064s', 'none']\n", + "2026-07-02 14:11:00,258 - WARNING - removed none tag from channel list [15]\n", + "2026-07-02 14:11:00,261 - INFO - date consistency-check... \n", + "2026-07-02 14:11:00,262 - INFO - ... date in nc-file equals date of filename\n" ] } ], @@ -262,7 +263,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 9, "id": "75e45529-0a19-4580-9bc5-269eadba869b", "metadata": {}, "outputs": [ @@ -270,10 +271,10 @@ "name": "stderr", "output_type": "stream", "text": [ - "2026-05-20 18:14:24,308 - INFO - starting data preprocessing...\n", - "2026-05-20 18:14:24,313 - INFO - ... time conversion\n", - "2026-05-20 18:14:24,330 - WARNING - ... mShots not constant min 2993 max 2999\n", - "2026-05-20 18:14:24,344 - INFO - ... Deadtime-correction (Mode: 1)\n" + "2026-07-02 14:11:05,721 - INFO - starting data preprocessing...\n", + "2026-07-02 14:11:05,724 - INFO - ... time conversion\n", + "2026-07-02 14:11:05,730 - WARNING - ... mShots not constant min 2993 max 2999\n", + "2026-07-02 14:11:05,735 - INFO - ... Deadtime-correction (Mode: 1)\n" ] }, { @@ -288,11 +289,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "2026-05-20 18:14:47,823 - INFO - ... removing background from signal\n", - "2026-05-20 18:15:02,544 - INFO - ... height bin calculations\n", - "2026-05-20 18:15:05,396 - INFO - ... mask bins with low SNR\n", - "2026-05-20 18:15:20,136 - INFO - ... mask for polarization calibration\n", - "2026-05-20 18:15:20,166 - INFO - ... calculate range-corrected Signal\n" + "2026-07-02 14:11:13,932 - INFO - ... removing background from signal\n", + "2026-07-02 14:11:14,997 - INFO - ... height bin calculations\n", + "/mnt/c/Users/radenz/dev/PicassoPy/PicassoPy/tests/../ppcpy/preprocess/pollyPreprocess.py:653: UserWarning: no explicit representation of timezones available for np.datetime64\n", + " data_dict['time64'] = np.array([np.datetime64(t) for t in mTime_obj])\n", + "2026-07-02 14:11:15,166 - INFO - ... mask bins with low SNR\n", + "2026-07-02 14:11:25,011 - INFO - ... mask for polarization calibration\n", + "2026-07-02 14:11:25,030 - INFO - ... calculate range-corrected Signal\n" ] }, { @@ -331,7 +334,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2026-05-20 18:15:21,927 - INFO - finished data preprocessing.\n" + "2026-07-02 14:11:27,386 - INFO - finished data preprocessing.\n" ] }, { @@ -345,10 +348,10 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 20, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -360,7 +363,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 10, "id": "774aa365", "metadata": {}, "outputs": [], @@ -371,7 +374,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 11, "id": "0df6f7b6-f5a2-4cc2-9257-64e0d5fe8a88", "metadata": {}, "outputs": [ @@ -395,7 +398,7 @@ " 14: '1064s'}" ] }, - "execution_count": 22, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -407,7 +410,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 12, "id": "3dfe7541-d789-4a4a-be43-b7a6d08d4dd5", "metadata": {}, "outputs": [ @@ -415,7 +418,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2026-05-20 18:15:39,297 - INFO - Saturation detection\n" + "2026-07-02 14:11:44,741 - INFO - Saturation detection\n" ] } ], @@ -442,7 +445,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 13, "id": "9279e9d1-b4d9-4f81-a50d-e970ccbf4c48", "metadata": {}, "outputs": [ @@ -450,7 +453,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2026-05-20 18:15:50,048 - INFO - cloud screen mode 1: MSG method.\n" + "2026-07-02 14:11:54,594 - INFO - cloud screen mode 1: MSG method.\n" ] }, { @@ -468,7 +471,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 14, "id": "cb1ecc63-0bb1-40da-9a2d-d03a7e3a2202", "metadata": {}, "outputs": [ @@ -487,7 +490,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 15, "id": "2a502a15", "metadata": {}, "outputs": [ @@ -498,7 +501,7 @@ " [144, 244]])" ] }, - "execution_count": 26, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -518,7 +521,7 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 16, "id": "98eeacdd-23f4-4730-a97f-feb043556d10", "metadata": {}, "outputs": [], @@ -541,7 +544,7 @@ }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 17, "id": "685a5a0f", "metadata": {}, "outputs": [ @@ -602,7 +605,83 @@ }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 22, + "id": "ff05f258-edd5-494f-8238-cd7bf7302117", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, False, False, False,\n", + " False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, True, False, False, True,\n", + " False, True, True, False, False, False, False, False, False,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, False, True, True, False, True, True, True,\n", + " True, True, True, True, True, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, False, False, False, False, False, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False,\n", + " False, True, True, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False,\n", + " False, False, False, True, True, True, True, False, False,\n", + " True, True, True, True, True, True, True, True, False,\n", + " False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False])" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_cube.flagValPrf" + ] + }, + { + "cell_type": "code", + "execution_count": 29, "id": "623aeeb1", "metadata": {}, "outputs": [ @@ -635,7 +714,7 @@ }, { "cell_type": "code", - "execution_count": 90, + "execution_count": 30, "id": "ee64aec2", "metadata": {}, "outputs": [ From d013613508a02b00a8b2b1e34b820795231cda77 Mon Sep 17 00:00:00 2001 From: martin_rdz <31452472+martin-rdz@users.noreply.github.com> Date: Sun, 5 Jul 2026 11:11:07 +0200 Subject: [PATCH 3/4] Update ppcpy/interface/picassoProc.py MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Håvard Strid Buholdt <143713192+HavardStridBuholdt@users.noreply.github.com> --- ppcpy/interface/picassoProc.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ppcpy/interface/picassoProc.py b/ppcpy/interface/picassoProc.py index e9265ca..2e00f47 100644 --- a/ppcpy/interface/picassoProc.py +++ b/ppcpy/interface/picassoProc.py @@ -424,9 +424,9 @@ def aggregate_profiles(self, var:str=None, flagVal=None): .. TODO:: Decide on a consistent way for doing the aggregation, do not mix mean and sum """ - if isinstance(flagVal, np.ndarray): - flagVal = flagVal - elif flagVal and not isinstance(flagVal, np.ndarray): + if isinstance(flagVal, (np.ndarray, list)): + flagVal = np.asarray(flagVal) + elif flagVal and not isinstance(flagVal, (np.ndarray, list)): flagVal = self.flagValPrf if var == None: From eb09e97da89008814e2d26d424e79586c61fb90d Mon Sep 17 00:00:00 2001 From: martin_rdz <31452472+martin-rdz@users.noreply.github.com> Date: Sun, 5 Jul 2026 11:15:23 +0200 Subject: [PATCH 4/4] Update picassoProc.py MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Apply Håvards suggestion in #83 / #76 --- ppcpy/interface/picassoProc.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ppcpy/interface/picassoProc.py b/ppcpy/interface/picassoProc.py index 2e00f47..957f5ac 100644 --- a/ppcpy/interface/picassoProc.py +++ b/ppcpy/interface/picassoProc.py @@ -426,6 +426,7 @@ def aggregate_profiles(self, var:str=None, flagVal=None): if isinstance(flagVal, (np.ndarray, list)): flagVal = np.asarray(flagVal) + self.flagValPrf = flagVal elif flagVal and not isinstance(flagVal, (np.ndarray, list)): flagVal = self.flagValPrf