116class open():
117    """
118    GRIB2 File Object.
119
120    This class can accommodate a physical file with one or more GRIB2
121    messages or a bytes object containing a GRIB2 messages.
122
123    A physical file can contain one or more GRIB2 messages.  When instantiated,
124    class `grib2io.open`, the file named `filename` is opened for reading (`mode
125    = 'r'`) and is automatically indexed.  The indexing procedure reads some of
126    the GRIB2 metadata for all GRIB2 Messages.  A GRIB2 Message may contain
127    submessages whereby Section 2-7 can be repeated.  grib2io accommodates for
128    this by flattening any GRIB2 submessages into multiple individual messages.
129
130    It is important to note that GRIB2 files from some Meteorological agencies
131    contain other data than GRIB2 messages.  GRIB2 files from ECMWF can contain
132    GRIB1 and GRIB2 messages.  grib2io checks for these and safely ignores them.
133
134    Attributes
135    ----------
136    closed : bool
137        `True` is file handle is close; `False` otherwise.
138    current_message : int
139        Current position of the file in units of GRIB2 Messages. (read only)
140    indexfile : str
141        Index file for the GRIB2 file.
142    levels : tuple
143        Tuple containing a unique list of wgrib2-formatted level/layer strings.
144    messages : int
145        Count of GRIB2 Messages contained in the file.
146    mode : str
147        File IO mode of opening the file.
148    name : str
149        Full path name of the GRIB2 file.
150    save_index : bool
151        Whether to save a pickle-based index file for the GRIB2 file. Default is `True`.
152    size : int
153        Size of the file in units of bytes.
154    use_index
155        Whether to use an existing pickle-based index file for the GRIB2 file. Default is `True`.
156    variables : tuple
157        Tuple containing a unique list of variable short names (i.e. GRIB2
158        abbreviation names).
159    """
160
161    __slots__ = ('_fileid', '_filehandle', '_hasindex', '_index', '_msgs', '_pos',
162                 'closed', 'current_message', 'indexfile', 'messages', 'mode',
163                 'name', 'size', 'save_index', 'use_index',)
164
165    def __init__(
166        self,
167        filename: Union[bytes, str, Path],
168        mode: Literal["r", "w", "x"] = "r",
169        *,
170        save_index = True,
171        use_index = True,
172        _xarray_backend = False,
173        **kwargs,
174        ):
175        """
176        Initialize GRIB2 File object instance.
177
178        Parameters
179        ----------
180        filename
181            File path containing GRIB2 messages OR bytes.
182        mode
183            File access mode where "r" opens the files for reading only; "w"
184            opens the file for overwriting and "x" for writing to a new file.
185        save_index
186            Whether to save a pickle-based index file for the GRIB2 file. Default is True.
187
188            .. versionadded:: 2.6.0
189        use_index
190            Whether to use an existing pickle-based index file for the GRIB2 file. Default is True.
191
192            .. versionadded:: 2.6.0
193        """
194
195        # All write modes are read/write.
196        # All modes are binary.
197        if mode in ("a", "x", "w"):
198            mode += "+"
199        mode = mode + "b"
200
201        self.mode = mode
202        self._hasindex = False
203        self.indexfile = None
204        self.save_index = save_index
205        self.use_index = use_index
206
207        if isinstance(filename, bytes):
208            if 'r' not in self.mode:
209                raise ValueError("bytes grib2 can only be opened as read")
210            self.current_message = 0
211            if filename[:2] == _GZIP_HEADER:
212                filename = gzip.decompress(filename)
213            if filename[:4]+filename[-4:] != b'GRIB7777':
214                raise ValueError("Invalid GRIB bytes")
215            self._filehandle = BytesIO(filename)
216            self.name = "<in-memory-file>"
217            self.size = len(filename)
218            self._fileid = hashlib.sha1((self.name+str(self.size)).encode('ASCII')).hexdigest()
219            self._index = build_index(self._filehandle)
220            self._msgs = msgs_from_index(self._index, filehandle=self._filehandle)
221            self.messages = len(self._msgs)
222
223        else:
224            self.current_message = 0
225            if 'r' in mode:
226                self._filehandle = builtins.open(filename, mode=mode)
227                # Some GRIB2 files are gzipped, so check for that here, but
228                # raise error when using xarray backend.
229                # Gzip files contain a 2-byte header b'\x1f\x8b'.
230                if self._filehandle.read(2) == _GZIP_HEADER:
231                    self._filehandle.close()
232                    if _xarray_backend:
233                        raise RuntimeError('Gzip GRIB2 files are not supported by the Xarray backend.')
234                    self._filehandle = gzip.open(filename, mode=mode)
235                else:
236                    self._filehandle = builtins.open(filename, mode=mode)
237            else:
238                self._filehandle = builtins.open(filename, mode=mode)
239                self.name = os.path.abspath(filename)
240            self.name = os.path.abspath(filename)
241            fstat = os.stat(self.name)
242            self.size = fstat.st_size
243            self._fileid = hashlib.sha1((self.name+str(fstat.st_ino)+
244                                     str(self.size)).encode('ASCII')).hexdigest()
245
246            if 'r' in self.mode:
247
248                self.indexfile = f"{self.name}_{self._fileid}.grib2ioidx"
249                if self.use_index and os.path.exists(self.indexfile):
250                    try:
251                        with builtins.open(self.indexfile, 'rb') as file:
252                            index = pickle.load(file)
253                        self._index = index
254                    except Exception as e:
255                        warnings.warn(f"found indexfile: {self.indexfile}, but unable to load it: {e}\n" 
256                                      f"re-forming index from grib2file, but not writing indexfile")
257                        self._index = build_index(self._filehandle)
258                    self._hasindex = True
259                else:
260                    self._index = build_index(self._filehandle)
261                    if self.save_index:
262                        try:
263                            serialize_index(self._index, self.indexfile)
264                        except Exception as e:
265                            warnings.warn(f"index was not serialized for future use: {e}")
266
267                self._msgs = msgs_from_index(self._index, filehandle=self._filehandle)
268
269                self.messages = len(self._msgs)
270            elif 'w' or 'x' in self.mode:
271                self.messages = 0
272                self.current_message = None
273
274        self.closed = self._filehandle.closed
275
276
277    def __delete__(self, instance):
278        self.close()
279        del self._index
280
281
282    def __enter__(self):
283        return self
284
285
286    def __exit__(self, atype, value, traceback):
287        self.close()
288
289
290    def __iter__(self):
291        yield from self._msgs
292
293
294    def __len__(self):
295        return self.messages
296
297
298    def __repr__(self):
299        strings = []
300        for k in self.__slots__:
301            if k.startswith('_'): continue
302            strings.append('%s = %s\n'%(k,eval('self.'+k)))
303        return ''.join(strings)
304
305
306    def __getitem__(self, key):
307        if isinstance(key,int):
308            if abs(key) >= len(self._msgs):
309                raise IndexError("index out of range")
310            else:
311                return self._msgs[key]
312        elif isinstance(key,str):
313            return self.select(shortName=key)
314        elif isinstance(key,slice):
315            return self._msgs[key]
316        else:
317            raise KeyError('Key must be an integer, slice, or GRIB2 variable shortName.')
318
319
320
321    @property
322    def levels(self):
323        """Provides a unique tuple of level strings."""
324        if self._hasindex:
325            return tuple(sorted(set([msg.level for msg in self._msgs])))
326        else:
327            return None
328
329
330    @property
331    def variables(self):
332        """Provides a unique tuple of variable shortName strings."""
333        if self._hasindex:
334            return tuple(sorted(set([msg.shortName for msg in self._msgs])))
335        else:
336            return None
337
338
339    def close(self):
340        """Close the file handle."""
341        if not self._filehandle.closed:
342            self.messages = 0
343            self.current_message = 0
344            self._filehandle.close()
345            self.closed = self._filehandle.closed
346
347
348    def read(self, size: Optional[int]=None):
349        """
350        Read size amount of GRIB2 messages from the current position.
351
352        If no argument is given, then size is None and all messages are returned
353        from the current position in the file. This read method follows the
354        behavior of Python's builtin open() function, but whereas that operates
355        on units of bytes, we operate on units of GRIB2 messages.
356
357        Parameters
358        ----------
359        size: default=None
360            The number of GRIB2 messages to read from the current position. If
361            no argument is give, the default value is None and remainder of
362            the file is read.
363
364        Returns
365        -------
366        read
367            ``Grib2Message`` object when size = 1 or a list of Grib2Messages
368            when size > 1.
369        """
370        if size is not None and size < 0:
371            size = None
372        if size is None or size > 1:
373            start = self.tell()
374            stop = self.messages if size is None else start+size
375            if size is None:
376                self.current_message = self.messages-1
377            else:
378                self.current_message += size
379            return self._msgs[slice(start,stop,1)]
380        elif size == 1:
381            self.current_message += 1
382            return self._msgs[self.current_message]
383        else:
384            None
385
386
387    def seek(self, pos: int):
388        """
389        Set the position within the file in units of GRIB2 messages.
390
391        Parameters
392        ----------
393        pos
394            The GRIB2 Message number to set the file pointer to.
395        """
396        if self._hasindex:
397            self._filehandle.seek(self._index['sectionOffset'][0][pos])
398            self.current_message = pos
399
400
401    def tell(self):
402        """Returns the position of the file in units of GRIB2 Messages."""
403        return self.current_message
404
405
406    def select(self, **kwargs):
407        """Select GRIB2 messages by `Grib2Message` attributes."""
408        # TODO: Added ability to process multiple values for each keyword (attribute)
409        idxs = []
410        nkeys = len(kwargs.keys())
411        for k,v in kwargs.items():
412            for m in self._msgs:
413                if hasattr(m,k) and getattr(m,k) == v: idxs.append(m._msgnum)
414        idxs = np.array(idxs,dtype=np.int32)
415        return [self._msgs[i] for i in [ii[0] for ii in collections.Counter(idxs).most_common() if ii[1] == nkeys]]
416
417
418    def write(self, msg):
419        """
420        Writes GRIB2 message object to file.
421
422        Parameters
423        ----------
424        msg
425            GRIB2 message objects to write to file.
426        """
427        if isinstance(msg,list):
428            for m in msg:
429                self.write(m)
430            return
431
432        if issubclass(msg.__class__,_Grib2Message):
433            # TODO: We can consider letting pack return packed bytes instead of associating with message object
434            if hasattr(msg,'_msg'):
435                # write already packed bytes
436                self._filehandle.write(msg._msg)
437            else:
438                if msg._signature == msg._generate_signature() and \
439                   msg._data is None and \
440                   hasattr(msg._ondiskarray,'filehandle'):
441                   # write unchanged message from input
442                   offset = msg._ondiskarray.filehandle.tell()
443                   msg._ondiskarray.filehandle.seek(msg._ondiskarray.offset)
444                   self._filehandle.write(msg._ondiskarray.filehandle.read(msg.section0[-1]))
445                   msg._ondiskarray.filehandle.seek(offset)
446                else:
447                    msg.pack()
448                    self._filehandle.write(msg._msg)
449            self.size = os.path.getsize(self.name)
450            self.messages += 1
451        else:
452            raise TypeError("msg must be a Grib2Message object.")
453        return
454
455
456    def flush(self):
457        """Flush the file object buffer."""
458        self._filehandle.flush()
459
460
461    def levels_by_var(self, name: str):
462        """
463        Return a list of level strings given a variable shortName.
464
465        Parameters
466        ----------
467        name
468            Grib2Message variable shortName
469
470        Returns
471        -------
472        levels_by_var
473            A list of unique level strings.
474        """
475        return list(sorted(set([msg.level for msg in self.select(shortName=name)])))
476
477
478    def vars_by_level(self, level: str):
479        """
480        Return a list of variable shortName strings given a level.
481
482        Parameters
483        ----------
484        level
485            Grib2Message variable level
486
487        Returns
488        -------
489        vars_by_level
490            A list of unique variable shortName strings.
491        """
492        return list(sorted(set([msg.shortName for msg in self.select(level=level)])))

34def show_config():
35    """Print grib2io build configuration information."""
36    print(f'grib2io version {__version__} Configuration:')
37    print(f'')
38    print(f'NCEPLIBS-g2c library version: {__g2clib_version__}')
39    print(f'\tStatic library: {g2c_static}')
40    print(f'\tJPEG compression support: {has_jpeg_support}')
41    print(f'\tPNG compression support: {has_png_support}')
42    print(f'\tAEC compression support: {has_aec_support}')
43    print(f'')
44    print(f'NCEPLIPS-ip support: {has_interpolation}')
45    print(f'\tStatic library: {ip_static}')
46    print(f'\tOpenMP support: {has_openmp_support}')
47    print(f'')
48    print(f'Static libs:')
49    for lib in extra_objects:
50        print(f'\t{lib}')
51    print(f'')
52    print(f'NCEP GRIB2 Table Version: {_ncep_grib2_table_version}')

2035def interpolate(a,
2036    method: Union[int, str],
2037    grid_def_in,
2038    grid_def_out,
2039    method_options=None,
2040    num_threads=1,
2041):
2042    """
2043    This is the module-level interpolation function.
2044
2045    This interfaces with the 4-byte (32-bit float) [NCEPLIBS-ip library](https://github.com/NOAA-EMC/NCEPLIBS-ip)
2046    through grib2io's internal iplib Cython extension module.
2047
2048    Parameters
2049    ----------
2050    a : numpy.ndarray or tuple
2051        Input data.  If `a` is a `numpy.ndarray`, scalar interpolation will be
2052        performed.  If `a` is a `tuple`, then vector interpolation will be
2053        performed with the assumption that u = a[0] and v = a[1] and are both
2054        `numpy.ndarray`.
2055
2056        These data are expected to be in 2-dimensional form with shape (ny, nx)
2057        or 3-dimensional (:, ny, nx) where the 1st dimension represents another
2058        spatial, temporal, or classification (i.e. ensemble members) dimension.
2059        The function will properly flatten the (ny,nx) dimensions into (nx * ny)
2060        acceptable for input into the interpolation subroutines. If needed, these
2061        data will be converted to `np.float32`.
2062    method
2063        Interpolate method to use. This can either be an integer or string using
2064        the following mapping:
2065
2066        | Interpolate Scheme | Integer Value |
2067        | :---:              | :---:         |
2068        | 'bilinear'         | 0             |
2069        | 'bicubic'          | 1             |
2070        | 'neighbor'         | 2             |
2071        | 'budget'           | 3             |
2072        | 'spectral'         | 4             |
2073        | 'neighbor-budget'  | 6             |
2074
2075    grid_def_in : grib2io.Grib2GridDef
2076        Grib2GridDef object for the input grid.
2077    grid_def_out : grib2io.Grib2GridDef
2078        Grib2GridDef object for the output grid or station points.
2079    method_options : list of ints, optional
2080        Interpolation options. See the NCEPLIBS-ip documentation for
2081        more information on how these are used.
2082    num_threads : int, optional
2083        Number of OpenMP threads to use for interpolation. The default
2084        value is 1. If NCEPLIBS-ip and grib2io's iplib extension module
2085        was not built with OpenMP, then this keyword argument and value
2086        will have no impact.
2087
2088    Returns
2089    -------
2090    interpolate
2091        Returns a `numpy.ndarray` of dtype `np.float32` when scalar interpolation
2092        is performed or a `tuple` of `numpy.ndarray`s when vector interpolation is
2093        performed with the assumptions that 0-index is the interpolated u and
2094        1-index is the interpolated v.
2095    """
2096
2097    from . import iplib
2098
2099    prev_num_threads = 1
2100    try:
2101        prev_num_threads = iplib.openmp_get_num_threads()
2102        iplib.openmp_set_num_threads(num_threads)
2103    except(AttributeError):
2104        pass
2105
2106    print(f"grib2io.interpolate thread report: OpenMP num threads = {iplib.openmp_get_num_threads()}")
2107
2108    if isinstance(method,int) and method not in _interp_schemes.values():
2109        raise ValueError('Invalid interpolation method.')
2110    elif isinstance(method,str):
2111        if method in _interp_schemes.keys():
2112            method = _interp_schemes[method]
2113        else:
2114            raise ValueError('Invalid interpolation method.')
2115
2116    if method_options is None:
2117        method_options = np.zeros((20),dtype=np.int32)
2118        if method in {3,6}:
2119            method_options[0:2] = -1
2120
2121    mi = grid_def_in.npoints
2122    mo = grid_def_out.npoints
2123
2124    # Adjust shape of input array(s)
2125    a, newshp = _adjust_array_shape_for_interp(a, grid_def_in, grid_def_out)
2126
2127    # Call interpolation subroutines according to type of a.
2128    if isinstance(a,np.ndarray):
2129        # Scalar
2130        km = a.shape[0]
2131        if np.any(np.isnan(a)):
2132            ibi = np.ones((km), dtype=np.int32)
2133            li = np.where(np.isnan(a),0,1).astype(np.uint8)
2134        else:
2135            ibi = np.zeros((km), dtype=np.int32)
2136            li = np.zeros(a.shape,dtype=np.uint8)
2137        no, rlat, rlon, ibo, lo, go, iret = iplib.interpolate_scalar(
2138            method,
2139            method_options,
2140            grid_def_in.gdtn,
2141            np.array(grid_def_in.gdt, dtype=np.int32),
2142            grid_def_out.gdtn,
2143            np.array(grid_def_out.gdt, dtype=np.int32),
2144            mi,
2145            mo,
2146            km,
2147            ibi,
2148            li,
2149            a,
2150        )
2151        out = np.where(lo==0,np.nan,go).reshape(newshp)
2152    elif isinstance(a,tuple):
2153        # Vector
2154        km = a[0].shape[0]
2155        if np.any(np.isnan(a)):
2156            ibi = np.ones((km), dtype=np.int32)
2157            li = np.where(np.isnan(a),0,1).astype(np.uint8)
2158        else:
2159            ibi = np.zeros((km), dtype=np.int32)
2160            li = np.zeros(a[0].shape,dtype=np.uint8)
2161        no, rlat, rlon, crot, srot, ibo, lo, uo, vo, iret = iplib.interpolate_vector(
2162            method,
2163            method_options,
2164            grid_def_in.gdtn,
2165            np.array(grid_def_in.gdt, dtype=np.int32),
2166            grid_def_out.gdtn,
2167            np.array(grid_def_out.gdt, dtype=np.int32),
2168            mi,
2169            mo,
2170            km,
2171            ibi,
2172            li,
2173            a[0],
2174            a[1],
2175        )
2176        uo = np.where(lo==0,np.nan,uo).reshape(newshp)
2177        vo = np.where(lo==0,np.nan,vo).reshape(newshp)
2178        out = (uo,vo)
2179
2180    try:
2181        iplib.openmp_set_num_threads(prev_num_threads)
2182    except(AttributeError):
2183        pass
2184
2185    return out

2188def interpolate_to_stations(
2189    a,
2190    method: Union[int, str],
2191    grid_def_in,
2192    lats,
2193    lons,
2194    method_options=None,
2195    num_threads=1
2196):
2197    """
2198    Module-level interpolation function for interpolation to stations.
2199
2200    Interfaces with the 4-byte (32-bit float) [NCEPLIBS-ip library](https://github.com/NOAA-EMC/NCEPLIBS-ip)
2201    via grib2io's iplib Cython exntension module. It supports scalar and
2202    vector interpolation according to the type of object a.
2203
2204    Parameters
2205    ----------
2206    a : numpy.ndarray or tuple
2207        Input data.  If `a` is a `numpy.ndarray`, scalar interpolation will be
2208        performed.  If `a` is a `tuple`, then vector interpolation will be
2209        performed with the assumption that u = a[0] and v = a[1] and are both
2210        `numpy.ndarray`.
2211
2212        These data are expected to be in 2-dimensional form with shape (ny, nx)
2213        or 3-dimensional (:, ny, nx) where the 1st dimension represents another
2214        spatial, temporal, or classification (i.e. ensemble members) dimension.
2215        The function will properly flatten the (ny,nx) dimensions into (nx * ny)
2216        acceptable for input into the interpolation subroutines. If needed, these
2217        data will be converted to `np.float32`.
2218    method
2219        Interpolate method to use. This can either be an integer or string using
2220        the following mapping:
2221
2222        | Interpolate Scheme | Integer Value |
2223        | :---:              | :---:         |
2224        | 'bilinear'         | 0             |
2225        | 'bicubic'          | 1             |
2226        | 'neighbor'         | 2             |
2227        | 'budget'           | 3             |
2228        | 'spectral'         | 4             |
2229        | 'neighbor-budget'  | 6             |
2230
2231    grid_def_in : grib2io.Grib2GridDef
2232        Grib2GridDef object for the input grid.
2233    lats : numpy.ndarray or list
2234        Latitudes for station points
2235    lons : numpy.ndarray or list
2236        Longitudes for station points
2237    method_options : list of ints, optional
2238        Interpolation options. See the NCEPLIBS-ip documentation for
2239        more information on how these are used.
2240    num_threads : int, optional
2241        Number of OpenMP threads to use for interpolation. The default
2242        value is 1. If NCEPLIBS-ip and grib2io's iplib extension module
2243        was not built with OpenMP, then this keyword argument and value
2244        will have no impact.
2245
2246    Returns
2247    -------
2248    interpolate_to_stations
2249        Returns a `numpy.ndarray` of dtype `np.float32` when scalar
2250        interpolation is performed or a `tuple` of `numpy.ndarray`s
2251        when vector interpolation is performed with the assumptions
2252        that 0-index is the interpolated u and 1-index is the
2253        interpolated v.
2254    """
2255    from . import iplib
2256
2257    # Define function to apply mask when stations are outside grid domain
2258    def _reshape_and_mask_post_interp(a, shape, mask):
2259        a = a.reshape(shape)
2260        if a.shape[-1] != mask.shape[0]:
2261            raise ValueError(f"Station mask length does not match interpolated data.")
2262        a[..., mask] = np.nan
2263        return a
2264
2265    prev_num_threads = 1
2266    try:
2267        prev_num_threads = iplib.openmp_get_num_threads()
2268        iplib.openmp_set_num_threads(num_threads)
2269    except(AttributeError):
2270        pass
2271
2272    if isinstance(method,int) and method not in _interp_schemes.values():
2273        raise ValueError('Invalid interpolation method.')
2274    elif isinstance(method,str):
2275        if method in _interp_schemes.keys():
2276            method = _interp_schemes[method]
2277        else:
2278            raise ValueError('Invalid interpolation method.')
2279
2280    if method_options is None:
2281        method_options = np.zeros((20),dtype=np.int32)
2282        if method in {3,6}:
2283            method_options[0:2] = -1
2284
2285    # Check lats and lons
2286    if isinstance(lats,list):
2287        nlats = len(lats)
2288    elif isinstance(lats,np.ndarray) and len(lats.shape) == 1:
2289        nlats = lats.shape[0]
2290    else:
2291        raise ValueError('Station latitudes must be a list or 1-D NumPy array.')
2292    if isinstance(lons,list):
2293        nlons = len(lons)
2294    elif isinstance(lons,np.ndarray) and len(lons.shape) == 1:
2295        nlons = lons.shape[0]
2296    else:
2297        raise ValueError('Station longitudes must be a list or 1-D NumPy array.')
2298    if nlats != nlons:
2299        raise ValueError('Station lats and lons must be same size.')
2300
2301    mi = grid_def_in.npoints
2302    mo = nlats
2303
2304    # Adjust shape of input array(s)
2305    a, newshp = _adjust_array_shape_for_interp_stations(a, grid_def_in, mo)
2306
2307    # Use gdtn = -1 for stations and an empty template array
2308    gdtn_out = -1
2309    gdt_out = np.zeros((200),dtype=np.int32)
2310
2311    # Before we interpolate, get the grid coordinates for stations.
2312    xloc, yloc = utils.latlon_to_ij(
2313        grid_def_in.gdtn,
2314        grid_def_in.gdt,
2315        np.array(lats, dtype=np.float32),
2316        np.array(lons, dtype=np.float32),
2317    )
2318    xloc_mask = np.where(np.isnan(xloc), True, False)
2319    yloc_mask = np.where(np.isnan(yloc), True, False)
2320    mask = xloc_mask & yloc_mask
2321
2322    # Call interpolation subroutines according to type of a.
2323    if isinstance(a,np.ndarray):
2324        # Scalar
2325        km = a.shape[0]
2326        ibi = np.zeros((km), dtype=np.int32)
2327        li = np.zeros(a.shape,dtype=np.uint8)
2328        no, rlat, rlon, ibo, lo, go, iret = iplib.interpolate_scalar(
2329            method,
2330            method_options,
2331            grid_def_in.gdtn,
2332            np.array(grid_def_in.gdt, dtype=np.int32),
2333            gdtn_out,
2334            gdt_out,
2335            mi,
2336            mo,
2337            km,
2338            ibi,
2339            li,
2340            a,
2341            lats=np.array(lats, dtype=np.float32),
2342            lons=np.array(lons, dtype=np.float32),
2343        )
2344        out = _reshape_and_mask_post_interp(go, newshp, mask)
2345
2346    elif isinstance(a,tuple):
2347        # Vector
2348        km = a[0].shape[0]
2349        ibi = np.zeros((km), dtype=np.int32)
2350        li = np.zeros(a[0].shape,dtype=np.uint8)
2351        no, rlat, rlon, crot, srot, ibo, lo, uo, vo, iret = iplib.interpolate_vector(
2352            method,
2353            method_options,
2354            grid_def_in.gdtn,
2355            np.array(grid_def_in.gdt, dtype=np.int32),
2356            gdtn_out,
2357            gdt_out,
2358            mi,
2359            mo,
2360            km,
2361            ibi,
2362            li,
2363            a[0],
2364            a[1],
2365            lats=np.array(lats, dtype=np.float32),
2366            lons=np.array(lons, dtype=np.float32),
2367        )
2368        out = (
2369            _reshape_and_mask_post_interp(uo, newshp, mask),
2370            _reshape_and_mask_post_interp(vo, newshp, mask)
2371        )
2372
2373    try:
2374        iplib.openmp_set_num_threads(prev_num_threads)
2375    except(AttributeError):
2376        pass
2377
2378    return out