docs: def lsm_precip_to_gssha_precip_gage(self, out_gage_file, lsm_data_var, precip_type="RADAR"):
          """This function takes array data and writes out a GSSHA precip gage file.
          See: http://www.gsshawiki.com/Precipitation:Spatially_and_Temporally_Varied_Precipitation
  
          .. note::
              GSSHA CARDS:
                  * PRECIP_FILE card with path to gage file
                  * RAIN_INV_DISTANCE or RAIN_THIESSEN
  
          Parameters:
              out_gage_file(str): Location of gage file to generate.
              lsm_data_var(str or list): This is the variable name for precipitation in the LSM files.
                                            If there is a string, it assumes a single variable. If it is a
                                            list, then it assumes the first element is the variable name for
                                            RAINC and the second is for RAINNC
                                            (see: http://www.meteo.unican.es/wiki/cordexwrf/OutputVariables).
              precip_type(Optional[str]): This tells if the data is the ACCUM, RADAR, or GAGES data type. Default is 'RADAR'.
  
          GRIDtoGSSHA Example:
  
          .. code:: python
  
              from gsshapy.grid import GRIDtoGSSHA
  
              #STEP 1: Initialize class
              g2g = GRIDtoGSSHA(gssha_project_folder='/path/to/gssha_project',
                                gssha_project_file_name='gssha_project.prj',
                                lsm_input_folder_path='/path/to/wrf-data',
                                lsm_search_card='*.nc',
                                lsm_lat_var='XLAT',
                                lsm_lon_var='XLONG',
                                lsm_time_var='Times',
                                lsm_lat_dim='south_north',
                                lsm_lon_dim='west_east',
                                lsm_time_dim='Time',
                                )
  
              #STEP 2: Generate GAGE data (from WRF)
              g2g.lsm_precip_to_gssha_precip_gage(out_gage_file="E:/GSSHA/wrf_gage_1.gag",
                                                  lsm_data_var=['RAINC', 'RAINNC'],
                                                  precip_type='ACCUM')
  
          HRRRtoGSSHA Example:
  
          .. code:: python
  
              from gsshapy.grid import HRRRtoGSSHA
  
              #STEP 1: Initialize class
              h2g = HRRRtoGSSHA(
                                #YOUR INIT PARAMETERS HERE
                               )
  
              #STEP 2: Generate GAGE data
              g2g.lsm_precip_to_gssha_precip_gage(out_gage_file="E:/GSSHA/hrrr_gage_1.gag",
                                                  lsm_data_var='prate',
                                                  precip_type='RADAR')
  
          """
          VALID_TYPES = ["ACCUM", "RADAR", "GAGES"] #NOTE: "RATES" currently not supported
          if precip_type not in VALID_TYPES:
              raise ValueError("ERROR: {0} is not a valid type. Valid types include: {1}".format(type, VALID_TYPES))
  
          gssha_precip_type = "precipitation_inc"
          if precip_type == "ACCUM":
              gssha_precip_type = "precipitation_acc"
          elif precip_type == "RADAR":
              gssha_precip_type = "precipitation_rate"
  
          self._load_converted_gssha_data_from_lsm(gssha_precip_type, lsm_data_var, 'gage')
          gssha_data_var_name = self.netcdf_attributes[gssha_precip_type]['gssha_name']
          self.data = self.data.lsm.to_projection(gssha_data_var_name,
                                                  projection=self.gssha_grid.projection)
  
          #LOOP THROUGH TIME
          with io_open(out_gage_file, 'w') as gage_file:
              if self.data.dims['time']>1:
                  gage_file.write(u"EVENT \"Event of {0} to {1}\"\n".format(self._time_to_string(self.data.lsm.datetime[0]),
                                                                            self._time_to_string(self.data.lsm.datetime[-1])))
              else:
                  gage_file.write(u"EVENT \"Event of {0}\"\n".format(self._time_to_string(self.data.lsm.datetime[0])))
              gage_file.write(u"NRPDS {0}\n".format(self.data.dims['time']))
              gage_file.write(u"NRGAG {0}\n".format(self.data.dims['x']*self.data.dims['y']))
              y_coords, x_coords = self.data.lsm.coords
              for y_idx in range(self.data.dims['y']):
                  for x_idx in range(self.data.dims['x']):
                      coord_idx = y_idx*self.data.dims['x'] + x_idx
                      gage_file.write(u"COORD {0} {1} \"center of pixel #{2}\"\n".format(x_coords[y_idx, x_idx],
                                                                                         y_coords[y_idx, x_idx],
                                                                                         coord_idx))
              for time_idx in range(self.data.dims['time']):
                  date_str = self._time_to_string(self.data.lsm.datetime[time_idx])
                  data_str = " ".join(self.data[gssha_data_var_name][time_idx].values.ravel().astype(str))
                  gage_file.write(u"{0} {1} {2}\n".format(precip_type, date_str, data_str))