Data preprocessing & generation

data generation to derive HLS chips and MERRA, flux csv.

fluxconfig.yaml

@@ -0,0 +1,78 @@
+model:
+  name: "Base_Flux"
+  n_channel: 6
+  n_class: 1
+  embed_dim: 1024
+  dropout_rate: 0.5
+
+device_name: "cuda"
+
+n_iteration: 50
+
+prithvi_model_new_weight: "/vol/cephfs/impact/srija/Prithvi-Global-downstream_v0/new_flood/checkpoint.pt"
+
+training:
+  train_batch_size: 16
+  shuffle: True
+
+  optimizer:
+    name: "AdamW"
+    params:
+      lr: 5e-5
+       
+
+  scheduler:
+    use: 1
+    name: "ReduceLROnPlateau"
+
+  dropout:
+    use: 1
+    val: 0.2
+
+  bn: 1
+
+
+
+testing:
+  test_batch_size: 16
+  shuffle: False
+
+normalization: "z-score-std"
+test_year: 2021
+
+
+data:
+  n_frame: 1
+  chips: "/vol/cephfs/impact/srija/Prithvi-Global-downstream_v0/new_flood_v2/chips/"
+  input_size: [6,50, 50]
+  means_for2018test: [0.07286696773903256, 0.10036772476940378, 0.11363777043869523, 0.2720510638470194, 0.2201167122609674, 0.1484162876040495]
+  stds_for2018test: [0.13271414936598172, 0.13268933338964875, 0.1384673725283858, 0.12089142598551804, 0.10977084890500641, 0.0978705241034744]
+  merra_means_for2018test: [282.011721, 295.823746,288.291530, 278.243071,0.552373,55.363476, 48.984387, 202.461732, 22.907336,0.000004]
+  merra_stds_for2018test: [9.141752,11.374619,10.224494,7.912334,0.178115,50.069111,48.238661,74.897672,9.277971,0.000014]
+  gpp_means_for2018test: [3.455948]
+  gpp_stds_for2018test: [3.754123]
+  means_for2019test: [0.07287311832611834,0.10025904848484847,0.1122947444733045,0.27563822551226563,0.21583184092352084,0.14331408109668098]
+  stds_for2019test: [0.13511944688809177,0.1349403534769768,0.14037014996437144,0.12365673294486092,0.10852189245620811,0.09485890083382985]
+  merra_means_for2019test: [281.960274,295.974675, 288.330014,278.306133,0.548831,55.167287,48.381169,202.003449,23.097742,0.000004]
+  merra_stds_for2019test: [9.077508,11.436697,10.178588,7.750465, 0.175302,50.656796,49.182061,73.949519,9.422290,0.000016]
+  gpp_means_for2019test: [3.581604]
+  gpp_stds_for2019test: [3.889343]
+  means_for2020test: [0.07372144372093026,0.10117611215116282,0.11269885680232558,0.2775572554069766,0.21387001372093037, 0.14144541145348838]
+  stds_for2020test: [0.13324302628303733, 0.13308921403475235, 0.13829909331863693,0.12039809083338567,0.1088096350639653,0.09366368859284444]
+  merra_means_for2020test: [282.373169, 296.706468, 288.852922, 278.612209, 0.540145, 53.830276, 53.827718, 206.817980, 23.077581, 0.000003]
+  merra_stds_for2020test: [9.296960, 11.402008, 10.311107, 8.064209, 0.171909, 49.945953, 48.907351, 74.591578, 8.746668, 0.000014  ]
+  gpp_means_for2020test: [3.668982]
+  gpp_stds_for2020test: [3.804261]
+  means_for2021test: [0.06743080268702287,0.09420638137404584,0.10626692164885497,0.2692502415877864,0.21780909367938925,0.1468194037862596]
+  stds_for2021test: [0.12261400510468322,0.12276593355350174,0.12836180894665594,0.11639597942158948,0.10570861595781685,0.09646322486302224]
+  merra_means_for2021test: [281.762443,294.883832,287.753053, 279.168366,0.569313,61.064687,45.930611,200.842519,23.072735,0.000003]
+  merra_stds_for2021test: [9.040586,11.143439,10.063070,8.121612,0.172953,52.172274,47.056911,76.875468,9.553304,0.000010]
+  gpp_means_for2021test: [3.787582]
+  gpp_stds_for2021test: [3.862494]
+
+
+logging:
+  checkpoint_dir: "/vol/cephfs/impact/srija/Prithvi-Global-downstream_v0/Prithvi-global-v1/flux_base_pred_logs/"
+  metrics_dir: "/vol/cephfs/impact/srija/Prithvi-Global-downstream_v0/Prithvi-global-v1/flux_base_pred_logs/metrics/"
+  plots_dir: "/vol/cephfs/impact/srija/Prithvi-Global-downstream_v0/Prithvi-global-v1/flux_base_pred_logs/plots/"
+  

make_chips.py

@@ -0,0 +1,283 @@
+"""
+make_chips.py
+
+This script reads in HLS S30/L30 data and extracts
+band information around a chip_size x chip_size subset
+of the original raster grid. Snowy and cloudy chips beyond a
+threshold are discarded.
+
+Author: Besart Mujeci, Srija Chakraborty, Christopher Phillips
+
+Usage:
+    python make_chips.py
+"""
+import rclone
+from pathlib import Path
+import shutil
+import pandas as pd
+from collections import Counter
+import cartopy.crs as ccrs
+import numpy as np
+import rasterio
+from rasterio.transform import from_gcps
+from rasterio.warp import transform
+from rasterio.windows import Window
+import os
+
+
+# --- --- ---
+def point_to_index(dataset, long, lat):
+    """
+    Converts long/lat point to row, col position on rasterio grid.
+
+    Args:
+        dataset (Rasterio Object): rasterio object
+        long (float): longitude float
+        lat (float): latitude float
+
+
+    Returns:
+        tuple: tuple representing point mapping on grid
+    """
+    from_crs = rasterio.crs.CRS.from_epsg(4326)
+    to_crs = dataset.crs
+    new_x,new_y = transform(from_crs,to_crs, [long], [lat])
+    new_x = new_x[0]
+    new_y = new_y[0]
+
+    # get row and col
+    row, col = dataset.index(new_x,new_y)
+    return(row, col)
+# --- --- ---
+
+
+# --- --- --- Citation for this function: Christopher Phillips
+def check_qc_bit(data, bit):
+    """
+    Function to check QC flags
+
+    Args:
+        data (numpy array): rasterio numpy grid
+        bit (int): 1 or 4 representing cloud or snow
+
+    Returns:
+        numpy array: numpy array with flagged indices marking cloud/snow
+    """
+    qc = np.array(data//(10**bit), dtype='int')
+    qc = qc-((qc//2)*2)
+
+    return np.sum(qc)/qc.size
+# --- --- ---
+
+
+# --- --- --- rclone configuration, file collection
+cfg = ""
+result = rclone.with_config(cfg).run_cmd("ls", extra_args=[f"{idir}/"])
+output_lines = result['out'].decode('utf-8').splitlines()
+file_list = [line.split(maxsplit=1)[1] for line in output_lines if line]
+# --- --- ---
+
+
+# --- --- --- Options
+hls_type = 'L30' # Switch between 'L30' and 'S30' manually.
+idir = "" # Raw Images Dir
+odir = "" # Output Chips Dir
+chip_size = 50 # Chip dimensions
+scale = 0.0001 # Scale value for HLS bandssqm
+cthresh = 0.05 # Cloud threshold
+sthresh = 0.02 # Snow/ice threshold 
+# --- --- ---
+
+
+# --- --- --- Read station site data
+df = pd.read_csv("./TILED_filtered_flux_sites_2018_2021.csv")
+stations = df['SITE_ID'].tolist()
+tiles = [tile.split(";")[0] for tile in df['tiles'].tolist()]
+sYear = df['start_year'].tolist()
+eYear = df['end_year'].tolist()
+longs = df['LOCATION_LONG'].tolist()
+lats = df['LOCATION_LAT'].tolist()
+all_years = [str(sYear[i]) + "-" + str(eYear[i]) for i in range(len(df))]
+coords = [str(lat) + ";" + str(long) for lat, long in zip(lats, longs)]
+# --- --- ---
+
+
+for i, line in enumerate(tiles):
+    station_data = [stations[i], coords[i].split(";")[0], coords[i].split(";")[1], all_years[i].split("-")[0], all_years[i].split("-")[1], "filler", tiles[i]]
+    tile = station_data[-1].strip()
+    print(f"Working on {tile}")
+
+    # Determine years for this station
+    years = range(int(station_data[3]), int(station_data[4])+1)
+    for year in years:
+        print(year)
+
+        # Build path to this tile and locate all tifs
+        tifs1 = sorted([filepath for filepath in file_list if tile in filepath and "B01" in filepath and hls_type in filepath and str(year) == filepath.split(".")[3][:4]]) # Numbered by band
+        tifs2 = sorted([filepath for filepath in file_list if tile in filepath and "B02" in filepath and hls_type in filepath and str(year) == filepath.split(".")[3][:4]]) # Numbered by band
+        tifs3 = sorted([filepath for filepath in file_list if tile in filepath and "B03" in filepath and hls_type in filepath and str(year) == filepath.split(".")[3][:4]]) # Numbered by band
+        tifs4 = sorted([filepath for filepath in file_list if tile in filepath and "B04" in filepath and hls_type in filepath and str(year) == filepath.split(".")[3][:4]]) # Numbered by band
+        tifs5 = sorted([filepath for filepath in file_list if tile in filepath and "B05" in filepath and hls_type in filepath and str(year) == filepath.split(".")[3][:4]]) # Numbered by band
+        tifs6 = sorted([filepath for filepath in file_list if tile in filepath and "B06" in filepath and hls_type in filepath and str(year) == filepath.split(".")[3][:4]]) # Numbered by band
+        tifs7 = sorted([filepath for filepath in file_list if tile in filepath and "B07" in filepath and hls_type in filepath and str(year) == filepath.split(".")[3][:4]]) # Numbered by band
+        tifs8 = sorted([filepath for filepath in file_list if tile in filepath and "B08" in filepath and hls_type in filepath and str(year) == filepath.split(".")[3][:4]]) # Numbered by band
+        tifs8A = sorted([filepath for filepath in file_list if tile in filepath and "B8A" in filepath and hls_type in filepath and str(year) == filepath.split(".")[3][:4]]) # Numbered by band
+        tifs9 = sorted([filepath for filepath in file_list if tile in filepath and "B09" in filepath and hls_type in filepath and str(year) == filepath.split(".")[3][:4]]) # Numbered by band
+        tifs10 = sorted([filepath for filepath in file_list if tile in filepath and "B10" in filepath and hls_type in filepath and str(year) == filepath.split(".")[3][:4]]) # Numbered by band
+        tifs11 = sorted([filepath for filepath in file_list if tile in filepath and "B11" in filepath and hls_type in filepath and str(year) == filepath.split(".")[3][:4]]) # Numbered by band
+        tifs12 = sorted([filepath for filepath in file_list if tile in filepath and "B12" in filepath and hls_type in filepath and str(year) == filepath.split(".")[3][:4]]) # Numbered by band
+        tifsF = sorted([filepath for filepath in file_list if tile in filepath and "Fmask" in filepath and hls_type in filepath and str(year) == filepath.split(".")[3][:4]]) # Numbered by band
+        
+        # Loop over each tif
+        first = True
+        chip_flag = False # Flag for detecting chip size errors
+        for i in range(len(tifs2)):
+
+            # Open tifs based on HLS product
+            skip_file_iteration = False
+            if (hls_type == 'L30'):
+                # Ensure the sorted files are aligned correctly.
+                # If a band is missing then things can go out of order.
+                # Push 'filler' if layer is missing a band to maintain sorting.
+                checkListMain = [tifs2, tifs3, tifs4, tifs5, tifs6, tifs7, tifsF]
+                checkList = [tifs2[i], tifs3[i], tifs4[i], tifs5[i], tifs6[i], tifs7[i], tifsF[i]]
+                checkList = ['.'.join(ele.split(".")[2:4]) for ele in checkList]
+                counts = Counter(checkList)
+                common_value, _ = counts.most_common(1)[0]
+                for z, value in enumerate(checkList):
+                    if value != common_value:
+                        checkListMain[z].insert(i, "filler") # Push 
+                        skip_file_iteration=True
+                        print(f"Misaligned - {checkList}")
+                        break
+                if skip_file_iteration:
+                    continue
+                try:
+                    if not os.path.exists(f"./{tile}"):
+                        os.makedirs(f"./{tile}")
+                    rclone.with_config(cfg).copy(f"{idir}/{tifs2[i]}", f"./{tile}")
+                    rclone.with_config(cfg).copy(f"{idir}/{tifs3[i]}", f"./{tile}")
+                    rclone.with_config(cfg).copy(f"{idir}/{tifs4[i]}", f"./{tile}")
+                    rclone.with_config(cfg).copy(f"{idir}/{tifs5[i]}", f"./{tile}")
+                    rclone.with_config(cfg).copy(f"{idir}/{tifs6[i]}", f"./{tile}")
+                    rclone.with_config(cfg).copy(f"{idir}/{tifs7[i]}", f"./{tile}")
+                    rclone.with_config(cfg).copy(f"{idir}/{tifsF[i]}", f"./{tile}")
+                except:
+                    print(f"MISALIGNED FOR - {tifs2[i]} check if all bands exist")
+                    continue
+                
+                src2 = rasterio.open(tifs2[i])
+                src3 = rasterio.open(tifs3[i])
+                src4 = rasterio.open(tifs4[i])
+                src5 = rasterio.open(tifs5[i])
+                src6 = rasterio.open(tifs6[i])
+                src7 = rasterio.open(tifs7[i])
+                srcF = rasterio.open(tifsF[i])
+
+            elif (hls_type == 'S30'):
+                # Ensure the sorted files are aligned correctly.
+                # If a band is missing then order is compromised.
+                # Push 'filler' if layer is missing a band to maintain sorting.
+                checkListMain = [tifs2, tifs3, tifs4, tifs8A, tifs11, tifs12, tifsF]
+                checkList = [tifs2[i], tifs3[i], tifs4[i], tifs8A[i], tifs11[i], tifs12[i], tifsF[i]]
+                checkList = ['.'.join(ele.split(".")[2:4]) for ele in checkList]
+                counts = Counter(checkList)
+                common_value, _ = counts.most_common(1)[0]
+                for z, value in enumerate(checkList):
+                    if value != common_value:
+                        checkListMain[z].insert(i, "filler")
+                        skip_file_iteration=True
+                        break
+                if skip_file_iteration:
+                    continue
+                try:
+                    if not os.path.exists(f"./{tile}"):
+                        os.makedirs(f"./{tile}")
+                    rclone.with_config(cfg).copy(f"{idir}/{tifs2[i]}", f"./{tile}")
+                    rclone.with_config(cfg).copy(f"{idir}/{tifs3[i]}", f"./{tile}")
+                    rclone.with_config(cfg).copy(f"{idir}/{tifs4[i]}", f"./{tile}")
+                    rclone.with_config(cfg).copy(f"{idir}/{tifs8A[i]}", f"./{tile}")
+                    rclone.with_config(cfg).copy(f"{idir}/{tifs11[i]}", f"./{tile}")
+                    rclone.with_config(cfg).copy(f"{idir}/{tifs12[i]}", f"./{tile}")
+                    rclone.with_config(cfg).copy(f"{idir}/{tifsF[i]}", f"./{tile}")
+                except:
+                    print(f"MISALIGNED FOR - {tifs2[i]} check if all bands exist")
+                    continue
+
+                
+                src2 = rasterio.open(f"./{tifs2[i]}")
+                src3 = rasterio.open(f"./{tifs3[i]}")
+                src4 = rasterio.open(f"./{tifs4[i]}")
+                src5 = rasterio.open(f"./{tifs8A[i]}")
+                src6 = rasterio.open(f"./{tifs11[i]}")
+                src7 = rasterio.open(f"./{tifs12[i]}")
+                srcF = rasterio.open(f"./{tifsF[i]}")
+
+            else:
+                raise ValueError(f'HLS product type must be \"L30\" or \"S30\" not \"{hls_type}\".')
+
+            # Station remains in the same spot/tile so only gather information once.
+            if first:
+                row, col = point_to_index(src2, float(station_data[2]), float(station_data[1]))
+                
+                y_offset = row - (chip_size // 2) 
+                x_offset = col - (chip_size // 2)
+                
+                window = Window(y_offset, x_offset, chip_size, chip_size)
+                window_data = src2.read(window=window, boundless=True)
+                window_transform = src2.window_transform(window)
+
+                first = False
+
+            # Subset tif
+            bands = []
+            for src in (src2,src3,src4,src5,src6,src7): # Set the tuple to match desired bands
+            
+                # Scale and clip reflectances
+                band = np.clip(src.read(1)[y_offset:y_offset + chip_size, x_offset:x_offset + chip_size]*scale, 0, 1)
+                bands.append(band)
+            bands = np.array(bands)
+
+            # Check chip size and break out if wrong shape
+            if (bands.shape[1] != chip_size) or (bands.shape[2] != chip_size):
+                print(f'ERROR: Chip for tile {tile} is wronge size!\n Size is {band.shape[1:]} and not ({chip_size},{chip_size}).\nSkipping to next tile.')
+                chip_flag = True
+                break
+
+            # Subset Fmask to get imperfections
+            cbands = np.array(srcF.read(1)[y_offset:y_offset + 50, x_offset:x_offset + 50], dtype='int')
+            cloud_frac = check_qc_bit(cbands, 1)
+            snow_frac = check_qc_bit(cbands, 4)
+            
+            # Check cloud fraction
+            if (cloud_frac > cthresh):
+                print("CLOUDY")
+                continue
+            
+            # Check snow/ice fraction
+            if (snow_frac > sthresh):
+                print("SNOWY")
+                continue
+
+            # Save chip with new metadata
+            out_meta = src2.meta
+            out_meta.update({'driver':'GTiff', 'height':bands.shape[1],
+                'width':bands.shape[2], 'count':bands.shape[0], 'dtype':bands.dtype,
+                'transform':window_transform})
+            save_name = f'./chips/{tifs2[i].replace("B02", f"{station_data[0]}_merged.{chip_size}x{chip_size}pixels")}'
+            if not os.path.exists(save_name):
+                os.makedirs(f"./chips/{tile}")
+            with rasterio.open(save_name, 'w', **out_meta) as dest:
+                dest.write(bands)
+            
+            rclone.with_config(cfg).copy(f"./chips/{tile}", f"{odir}/{tile}/")
+            shutil.rmtree(Path(f"./chips/"))
+
+        # If chip is the wrong size break to next station
+        if chip_flag:
+            print("Breaking to tile -- wrong size ")
+            break
+    shutil.rmtree(Path(f"./{tile}"))
+    break
+
+print('Done chipping.')

prep_input.py

@@ -0,0 +1,169 @@
+"""
+prep_input.py
+
+This script reads in MERRA2 SLV,LND data in combination with 
+flux station data together with HLS chips to produce a CSV with 
+aggregate data values that can be used to train for GPP flux prediction.
+
+Author: Besart Mujeci, Srija Chakraborty, Christopher Phillips
+
+Usage:
+    python prep_input.py
+"""
+import rclone
+from pathlib import Path
+import shutil
+import os
+import pandas as pd
+import netCDF4 as nc
+import numpy as np
+import pandas as pd
+
+
+# --- --- ---
+def convert_HLS_date(chip_name):
+    """
+    Extracts date string from HLS tile name and returns date object
+
+    Args:
+        chip_name (string): name of hls file
+
+    Returns:
+        datetime: datetime object of time string
+    """
+    hls_date = chip_name.split('.')[3][:7]
+    year = int(hls_date[:4])
+    day = int(hls_date[4:])    
+    date = datetime(year, 1, 1)+timedelta(days=day-1)
+        
+    return date
+# --- --- ---
+
+
+# --- --- --- Set up rclone and get chips and merra files
+rawdir = ''
+merradir = ''
+cfg = ""
+result = rclone.with_config(cfg).run_cmd("ls", extra_args=[f"{rawdir}/"])
+output_lines = result['out'].decode('utf-8').splitlines()
+file_list = [line.split(maxsplit=1)[1] for line in output_lines if line]
+result = rclone.with_config(cfg).run_cmd("ls", extra_args=[f"{merradir}/"])
+output_lines = result['out'].decode('utf-8').splitlines()
+merras = [line.split(maxsplit=1)[1] for line in output_lines if line]
+# --- --- ---
+
+
+# --- --- --- Set up paths
+# Location of station tile list
+station_file = './TILED_filtered_flux_sites_2018_2021.csv'
+# Location to save the input file
+spath = './all_inputs.csv'
+odir = ''
+# --- --- ---
+
+
+# --- --- --- Get station information
+stations = {}
+fn = open(station_file, 'r')
+for line in list(fn)[1:]:
+    dummy = line.split(',')
+    stations[dummy[1].strip()] = (dummy[1], float(dummy[9]), float(dummy[8]), dummy[3], dummy[4])
+fn.close()
+flux_nets = os.listdir("./fluxnets/flux_sites_2018_2021/")
+# --- --- ---
+
+# Locate all HLS chips
+chips = sorted(file_list)
+skipped = []
+
+# Make the input file to which to save the data
+out_fn = open(spath, 'w')
+out_fn.write(f'Chip,Station,T2MIN,T2MAX,T2MEAN,TSMDEWMEAN,GWETROOT,LHLAND,SHLAND,SWLAND,PARDFLAND,PRECTOTLAND,GPP')
+
+# And loop over them
+for chip in chips:
+    rclone.with_config(cfg).copy(f"{rawdir}/{chip}", f"./{chip}")
+
+    # Match to an Ameriflux station
+    chip_name = chip.split('/')[-1]
+    tile = chip_name.split('.')[2][1:]
+    station_name = chip_name.split('.')[6].split("_")[0]
+    try: # Skip tiles for which no station exists
+        station = stations[station_name]
+    except:
+        print(f"exception - {('station dict indexing', station_name, tile)}")
+        continue
+    date = helpers.convert_HLS_date(chip_name)
+
+    # Locate station from tile and pull in the daily reference value
+    try: # Skip tiles for which no station data is available
+        station_file = [fluxnet for fluxnet in flux_nets if station[0] in fluxnet][0]
+        flux_df = pd.read_csv(f"genai-usra-east/impact/fluxnets/flux_sites_2018_2021/{station_file}")
+    except:
+        print(f"exception - {('station exception', station_name, tile)}")
+        continue
+
+    flux_times = np.array(flux_df.TIMESTAMP, dtype='str')
+    flux_gpp = np.array(flux_df.GPP_NT_VUT_REF)
+    try: # Skip if cannot find CO2 data
+        quality_flag = np.array(flux_df.NEE_VUT_REF_QC)
+        if quality_flag[flux_times==date.strftime("%Y%m%d")][0] >= 0.6:
+            co2 = flux_gpp[flux_times==date.strftime("%Y%m%d")][0]
+        else: # Quality not met, skip
+            print(f"co2 quality not met for - {('co2', station_name, tile)}")
+            continue
+    except:
+        print(f"co2 quality not met for - {('co2 exception', station_name, tile)}")
+        skipped.append(('co2 exception', station_name, tile))
+        continue
+
+
+    # Pull MERRA-2 data for temperature and dew
+    merra_file = [file for file in merras if "slv" in file and str(date.strftime("%Y%m%d")) in file][0]
+    rclone.with_config(cfg).copy(f"{merradir}/{merra_file}", f"./merra/")
+    merra_fn = nc.Dataset(f'./merra/{merra_file}')
+
+    # Pull in the MERRA-2 grid and find closest point
+    mlons = merra_fn.variables['lon'][:]
+    mlats = merra_fn.variables['lat'][:]
+    xind = np.argmin((mlons-station[1])**2)
+    yind = np.argmin((mlats-station[2])**2)
+    
+    # Read the variables and collect stats based on time dimension
+    tmax = np.max(merra_fn.variables['T2M'], keepdims=True, axis=0)
+    tmin = np.min(merra_fn.variables['T2M'], keepdims=True, axis=0)
+    tmean = np.nanmean(merra_fn.variables['T2M'][:,yind, xind])
+    tmax = tmax[0,yind,xind]
+    tmin = tmin[0,yind,xind]
+    tdewmean = np.nanmean(merra_fn.variables['T2MDEW'][:,yind, xind])
+    
+
+    shutil.rmtree(Path(f"./merra"))
+    
+    # Pull MERRA-2 data for surface data
+    merra_file = [file for file in merras if "lnd" in file and str(date.strftime("%Y%m%d")) in file][0]
+    rclone.with_config(cfg).copy(f"{merradir}/{merra_file}", f"./merra/")
+    merra_fn = nc.Dataset(f'./merra/{merra_file}')
+    
+    # Pull in the MERRA-2 grid and find closest point
+    mlons = merra_fn.variables['lon'][:]
+    mlats = merra_fn.variables['lat'][:]
+    xind = np.argmin((mlons-station[1])**2)
+    yind = np.argmin((mlats-station[2])**2)
+    
+    # Read the variables and collect stats based on time dimension
+    GWETROOT = np.nanmean(merra_fn.variables['GWETROOT'][:,yind,xind])
+    LHLAND = np.nanmean(merra_fn.variables['LHLAND'][:,yind,xind])
+    SHLAND = np.nanmean(merra_fn.variables['SHLAND'][:,yind,xind])
+    PARDFLAND = np.nanmean(merra_fn.variables['PARDFLAND'][:,yind,xind])
+    PRECTOTLAND = np.nanmean(merra_fn.variables['PRECTOTLAND'][:,yind,xind])
+    SWLAND = np.nanmean(merra_fn.variables['SWLAND'][:,yind,xind])
+
+    shutil.rmtree(Path(f"./merra"))
+    shutil.rmtree(Path(f"./{tile}"))
+    # Save chip name, MERRA-2 values, and Ameriflux measurement to data file
+    out_fn.write(f'\n{chip_name},{station[0]},{tmin:.2f},{tmax:.2f},{tmean:.2f},{tdewmean:.2f},{GWETROOT:.2f},{LHLAND:.2f},{SHLAND:.2f},{SWLAND:.2f},{PARDFLAND:2f},{PRECTOTLAND:2f},{co2}')
+# Close the file
+out_fn.close()
+rclone.with_config(cfg).copy(f"{spath}", f"{odir}")
+print("DONE")