{ "cells": [ { "cell_type": "code", "execution_count": 8, "id": "d5cf2b3d-0f34-4d13-9ba3-dd2e3fb66337", "metadata": {}, "outputs": [], "source": [ "from docx import Document\n", "import pandas as pd\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import matplotlib.ticker as mticker\n", "from itertools import chain\n", "\n", "file_path1 = \"/Users/cdz/Desktop/Khafid_etal/BMKG_SurfaceStationData/CombinedStations.docx\"\n", "\n", "# Load the Word document\n", "doc = Document(file_path1)\n", "\n", "len(doc.tables)\n", "\n", "table = doc.tables[0]\n", "\n", "data = []\n", "for row in table.rows:\n", " data.append([cell.text.strip() for cell in row.cells])\n", "\n", "df = pd.DataFrame(data)\n", "df.head()\n", "\n", "# Define column names\n", "df.columns = [\n", " \"station_id\",\n", " \"station_name\",\n", " \"region\",\n", " \"longitude\",\n", " \"latitude\",\n", " \"elevation_m\",\n", " \"value\"\n", "]\n", "\n", "id = pd.to_numeric(df[\"station_id\"], errors=\"coerce\")\n", "nid = id.shape[0]\n", "\n", "x_labs = ['T (˚C)', 'p (hPa)', 'V (m/s)', 'q (g/kg)', 'Rain (mm/3hrs)', 'RH (%)'] \n", "y_labs = \"%\"\n", "labs = ['(a)', '(b)', '(c)', '(d)', '(e)', '(f)']\n", "\n", "count_std = np.zeros(6) \n", "\n", "binn = 20\n", "\n", "var = ['Temp', 'Pres', 'Windspeed', 'Specific humidity', 'rainfall3h', 'RH'] " ] }, { "cell_type": "code", "execution_count": 9, "id": "fd38cdc2-08f1-4d00-a542-2f6faaada257", "metadata": {}, "outputs": [], "source": [ "def remove_pressure_tide(p, dt_hours=1):\n", " t = np.arange(len(p)) * dt_hours / 24 # days\n", "\n", " X = np.column_stack([\n", " np.cos(2*np.pi*t), # S1\n", " np.sin(2*np.pi*t),\n", " np.cos(4*np.pi*t), # S2\n", " np.sin(4*np.pi*t),\n", " ])\n", "\n", " mask = np.isfinite(p)\n", "\n", " coef, *_ = np.linalg.lstsq(X[mask], p[mask], rcond=None)\n", " p_tide = X @ coef\n", "\n", " p_notide = p - p_tide\n", " p_notide[~mask] = np.nan\n", "\n", " return p_notide, p_tide" ] }, { "cell_type": "code", "execution_count": 10, "id": "065b287c-6d5e-4b19-a4c2-970dde0ed275", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:42: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " rain[rain > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:43: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " rain[rain < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:44: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T[T > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:45: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH[RH > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:46: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH[RH < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:47: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p[p >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:48: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " spd[spd >1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:13: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " T1[T1 > 1000] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 > 100] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:16: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " RH1[RH1 < 0] = np.nan\n", "/var/folders/2j/jt4cdpb52j3fh_1z31cdsbd00000gr/T/ipykernel_13232/2151692808.py:18: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " p1[p1 >2000] = np.nan\n" ] } ], "source": [ "#Read the attached CSV file\n", "\n", "#print(\" \", *var, sep=\" \")\n", "\n", "for n in range(nid): \n", "\n", " if id[n] == 96147 or id[n] == 96607 or id[n] == 97686: \n", " continue\n", " \n", " file_path = f\"/Users/cdz/Desktop/Khafid_etal/BMKG_SurfaceStationData/Combined Data/{id[n]}.csv\" \n", " df = pd.read_csv(file_path)\n", " T1 = df['Temp']\n", " T1[T1 > 1000] = np.nan\n", " RH1 = df['RH']\n", " RH1[RH1 > 100] = np.nan\n", " RH1[RH1 < 0] = np.nan\n", " p1 = df['Pres']\n", " p1[p1 >2000] = np.nan\n", " e_s = 6.112 * np.exp((17.67 * T1) / (T1 + 243.5))\n", " e = (RH1 / 100) * e_s\n", " df['Specific humidity'] = 1000*(0.622 * e) / (p1 - (0.378 * e))\n", "\n", " df['Windspeed'] = df['Windspeed']*0.514444 # convert from knot to m/s\n", "\n", "# df['Pres'], t_notide = remove_pressure_tide(p1, dt_hours=1)\n", " \n", " if n == 0:\n", " rain = df['rainfall3h']\n", " T = df['Temp']\n", " RH = df['RH']\n", " p = df['Pres']\n", " q = df['Specific humidity']\n", " spd = df['Windspeed']\n", " else:\n", " rain = np.concatenate((rain, df['rainfall3h']))\n", " T = np.concatenate((T, df['Temp']))\n", " q = np.concatenate((q, df['Specific humidity'])) \n", " p = np.concatenate((p, df['Pres']))\n", " spd = np.concatenate((spd, df['Windspeed']))\n", " RH = np.concatenate((RH,df['RH']))\n", "\n", " rain[rain > 100] = np.nan\n", " rain[rain < 0] = np.nan\n", " T[T > 1000] = np.nan\n", " RH[RH > 100] = np.nan\n", " RH[RH < 0] = np.nan\n", " p[p >2000] = np.nan\n", " spd[spd >1000] = np.nan\n", "\n", " \n", "# print(n, id[n], rain.shape)" ] }, { "cell_type": "code", "execution_count": 12, "id": "51ce5ba3-dcbb-4870-a512-b2c338c0e4f1", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Temp 1898643 27.3 2.6 16.4 38.8 55.9 96.8 99.9 100.0 100.0 0.0\n", "Pres 1898643 1009.8 2.1 993.8 1107.8 82.9 97.6 99.7 99.9 100.0 0.0\n", "Windspeed 1568257 2.1 1.7 0.0 23.1 81.2 94.0 98.8 99.4 99.9 0.1\n", "Specific humidity 1898643 18.5 1.5 5.6 33.9 82.8 85.1 98.8 99.7 99.9 0.1\n", "rainfall3h 84457 0.8 4.4 0.0 100.0 69.8 81.3 87.3 91.0 93.3 6.7\n", "RH 1898643 82.3 12.1 15.0 100.0 56.2 85.4 99.3 99.9 100.0 0.0\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# plot histograms\n", "\n", "fig, axs = plt.subplots(nrows=3, ncols=2, figsize=(8, 10), layout=\"constrained\")\n", "\n", "nv = 0\n", "for v in var:\n", " \n", " if v == \"Temp\":\n", "# x = np.zeros(T.shape[0])\n", "# x = x[~np.isnan(T)]\n", " x = T\n", " if v == \"Specific humidity\":\n", "# x = np.zeros(q.shape[0])\n", "# x = x[~np.isnan(q)]\n", " x = q\n", " \n", " if v == \"Pres\":\n", "# x = np.zeros(p.shape[0])\n", "# x = x[~np.isnan(p)]\n", " x = p\n", " if v == \"Windspeed\":\n", "# x = np.zeros(spd.shape[0])\n", "# x = x[~np.isnan(spd)]\n", " x = spd\n", " if v == \"RH\":\n", "# x = np.zeros(RH.shape[0])\n", "# x = x[~np.isnan(RH)]\n", " x = RH\n", " if v == \"rainfall3h\":\n", "# x = np.zeros(rain.shape[0]) \n", "# x = x[~np.isnan(rain)]\n", " x = rain\n", "\n", " x[x == 9999] = np.nan\n", " \n", " vmin = np.nanmin(x)\n", " vmax = np.nanmax(x)\n", " vmean = np.nanmean(x)\n", " vstd = np.nanstd(x)\n", "\n", " dv = 0.3*vstd\n", " binw = np.arange(vmin, vmax + dv, dv)\n", "\n", " num = x.shape[0]\n", "\n", " z = x\n", " \n", "# mask = (x 0) \n", " z = x[mask]\n", " num = z.shape[0]\n", " if v == \"RH\":\n", " xlimit2 = 100\n", "# print(num)\n", "# hist, bin_edges = np.histogram(x, bins=15, density=True)\n", "\n", "# binw = np.histogram_bin_edges(z, bins=\"fd\") # Freedman–Diaconis\n", "# pdf, bin_edges = np.histogram(z, bins=binw, density=True)\n", "# pdf = pdf*100\n", " \n", " ax = axs[int(nv/2)][int(nv%2)]\n", " xlim = ax.set_xlim(xlimit1,xlimit2)\n", "# ax.plot(x_spline, smoothed_values, color=colorss[d], label=labelss[j][d],ls=lineST[j], lw=lws[d])\n", "# ax.plot(pdf) \n", "# ax.hist(z, bins=binn, density=True)\n", " ax.hist(z, bins=binw)\n", " ax.axvline(vmean, ls='-', c='black', lw=.85,alpha=0.5) #BT: add vertical mean lines\n", " ax.axvline(vmean+vstd, ls='--', c='black', lw=.85,alpha=0.5) #BT: add vertical mean lines\n", " ax.axvline(vmean-vstd, ls='--', c='black', lw=.85,alpha=0.5) #BT: add vertical mean lines\n", " ax.axvline(vmean+2*vstd, ls='-.', c='black', lw=.85,alpha=0.5) #BT: add vertical mean lines\n", " ax.axvline(vmean-2*vstd, ls='-.', c='black', lw=.85,alpha=0.5) #BT: add vertical mean lines\n", " ax.axvline(vmean+3*vstd, ls=':', c='black', lw=.85,alpha=0.5) #BT: add vertical mean lines\n", " ax.axvline(vmean-3*vstd, ls=':', c='black', lw=.85,alpha=0.5) #BT: add vertical mean lines\n", " ax.axvline(vmean+4*vstd, ls=(0, (9,2)), c='red', lw=.85,alpha=0.5) #BT: add vertical mean lines\n", " ax.axvline(vmean-4*vstd, ls=(0, (9,2)), c='red', lw=.85,alpha=0.5) #BT: add vertical mean lines\n", " ax.axvline(vmean+5*vstd, ls=(0, (5,1,1,1)), c='black', lw=.85,alpha=0.5) #BT: add vertical mean lines\n", " ax.axvline(vmean-5*vstd, ls=(0, (5,1,1,1)), c='black', lw=.85,alpha=0.5) #BT: add vertical mean lines\n", " ax.set_title(labs[nv], fontsize=10, loc='left')\n", " ax.set_xlabel(x_labs[nv])\n", " ax.yaxis.set_major_formatter(mticker.StrMethodFormatter('{x:,.0f}'))\n", " ax.set_ylabel(\"Number\")\n", "# ax.set_ylabel(\"Probability density (%)\")\n", "# ax.yaxis.set_major_formatter(lambda x, pos: f\"{100*x:.1f}\")\n", " nv = nv +1\n", " if v == \"rainfall3h\":\n", " for k in range(5):\n", " count_std[k] = (np.sum(zvmean+5*vstd))*100/num\n", " else:\n", " for k in range(5):\n", " count_std[k] = (np.sum(zvmean-(k+1)*vstd))*100/num\n", " count_std[5] = (np.sum(z>vmean+5*vstd) + np.sum(z50:\n", "# print('no data after 2019 for pressure')\n", " nan_percent = nan_count*100/num \n", " print(v, num, nan_count, nan_percent)\n" ] }, { "cell_type": "code", "execution_count": 25, "id": "a9e6cf21-eebd-4993-8001-39d13619aced", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0 2017-01-01 00:00:00\n", "1 2017-01-01 01:00:00\n", "2 2017-01-01 02:00:00\n", "3 2017-01-01 03:00:00\n", "4 2017-01-01 04:00:00\n", " ... \n", "61221 2023-12-31 19:00:00\n", "61222 2023-12-31 20:00:00\n", "61223 2023-12-31 21:00:00\n", "61224 2023-12-31 22:00:00\n", "61225 2023-12-31 23:00:00\n", "Name: Time, Length: 61226, dtype: object\n" ] } ], "source": [ "for n in range(1): \n", " file_path = f\"/Users/cdz/Desktop/Khafid_etal/BMKG_SurfaceStationData/Combined Data/{id[n]}.csv\" \n", " df = pd.read_csv(file_path)\n", " print(df[\"Time\"])" ] }, { "cell_type": "code", "execution_count": null, "id": "05e1c70f-34b3-47a9-a176-27a83c2fcbdd", "metadata": {}, "outputs": [], "source": [ "nid = id.shape[0]-1\n", "print(nid)\n", "for n in range(nid):\n", " file_path = f\"/Users/cdz/Desktop/Khafid_etal/BMKG_SurfaceStationData/Combined Data/{id[n]}.csv\"\n", " print(n, id[n], file_path)\n" ] }, { "cell_type": "code", "execution_count": 59, "id": "34a3067c-f5c5-466d-bd31-788942e7e377", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(61226,)\n", "0 0.0\n", "1 NaN\n", "2 NaN\n", "3 0.0\n", "4 NaN\n", "5 NaN\n", "6 0.0\n", "7 NaN\n", "8 NaN\n", "Name: rainfall3h, dtype: float64\n" ] } ], "source": [ "print(df[\"rainfall3h\"].shape)\n", "print(df[\"rainfall3h\"][:9])" ] }, { "cell_type": "code", "execution_count": 51, "id": "d7b77a12-9fe5-4783-830e-bafd57ea1679", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " ()\n", " ()\n", " (1,)\n" ] } ], "source": [ "print(type(vmean), np.shape(vmean))\n", "print(type(vstd), np.shape(vstd))\n", "print(type(num), np.shape(num))" ] }, { "cell_type": "code", "execution_count": 13, "id": "11741438-8bf2-4599-9bd8-97673fcac393", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.8551021577828164 4.59640269235608 0.0 231.0\n" ] } ], "source": [ "print(vmean, vstd, vmin, vmax)" ] }, { "cell_type": "code", "execution_count": 22, "id": "efb5ca95-19e5-437a-a61e-d7fd3a66cc93", "metadata": {}, "outputs": [], "source": [ "# x = df[v]\n", "# x = x[~np.isnan(x)]\n", "# plt.hist(x, bins=15)\n", "# plt.show\n", " " ] }, { "cell_type": "code", "execution_count": null, "id": "4503ad29-45cb-493a-b5c7-aee5e1214606", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "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.7" } }, "nbformat": 4, "nbformat_minor": 5 }