HDFEOS2.h

//  This file is part of the hdf4 data handler for the OPeNDAP data server.
//
// Author:   Kent Yang,Choonghwan Lee <myang6@hdfgroup.org>
// Copyright (c) The HDF Group
 
//#include <libdap/InternalErr.h>
#ifdef USE_HDFEOS2_LIB
 
#ifndef _HDFEOS2_H
#define _HDFEOS2_H
#ifdef _WIN32
#ifdef _DEBUG
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
#endif
#endif
 
 
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include "mfhdf.h"
#include "hdf.h"
#include "HdfEosDef.h"
 
 
// Add MISR SOM projection header
#include "misrproj.h"
 
#include "HDFEOS2EnumType.h"
 
#ifdef _WIN32
#ifdef _MSC_VER
#pragma warning(disable:4290)
#endif
#endif

namespace HDFEOS2
{
    class Exception:public std::exception
    {
        public:
            explicit Exception (const std::string & msg)
                : message (msg)
            {
            }

            ~ Exception () throw () override = default;

            const char *what () const throw () override
            {
                return this->message.c_str ();
            }

            virtual bool getFileType ()
            {
                return this->isHDFEOS2;
            }

            virtual void setFileType (bool isHDFEOS2_flag)
            {
                this->isHDFEOS2 = isHDFEOS2_flag;
            }

            virtual void setException (const std::string & exception_message)
            {
                this->message = exception_message;
            }
 
        private:
            std::string message;
            bool isHDFEOS2 = true;
    };

    template < typename T > class LightVector {
        public:
            LightVector () = default;
 
            LightVector (const LightVector < T > &that)
            {
                this->data = new T[that.length];
                for (unsigned int i = 0; i < that.length; ++i)
                    this->data[i] = that[i];
                this->length = that.length;
                this->capacity = that.length;
            }
 
            ~LightVector () {
                if (this->data)
                    delete[]data;
            }
 
            void push_back (const T & d)
            {
                this->reserve (this->length + 1);
                this->data[this->length] = d;
                ++this->length;
            }
 
            void reserve (unsigned int len)
            {
                if (this->capacity >= len)
                    return;
 
                this->capacity = len;
                T *old = this->data;
 
                this->data = new T[len];
                if (old) {
                    for (unsigned int i = 0; i < this->length; ++i)
                        this->data[i] = old[i];
                    delete[]old;
                }
            }
 
            void resize (unsigned int len)
            {
                if (this->length == len)
                    return;
                else if (this->length < len) {
                    if (this->capacity < len) {
                        this->capacity = len;
                        T *old = this->data;
 
                        this->data = new T[len];
                        if (old) {
                            for (unsigned int i = 0; i < this->length; ++i)
                                this->data[i] = old[i];
                            delete[]old;
                        }
                    }
                }
                else {
                    this->capacity = len;
                    T *old = this->data;
 
                    this->data = new T[len];
                    for (unsigned int i = 0; i < len; ++i)
                        this->data[i] = old[i];
                    if (old)
                        delete[]old;
                }
                this->length = len;
            }
 
            unsigned int size () const
            {
                return this->length;
            }
 
            T & operator[] (unsigned int i)
            {
                return this->data[i];
            }
            const T & operator[] (unsigned int i) const
            {
                return this->data[i];
            }
 
            LightVector < T > &operator= (const LightVector < T > &that)
            {
                if (this != &that) {
                    this->data = new T[that.length];
                    for (unsigned int i = 0; i < that.length; ++i)
                        this->data[i] = that[i];
                    this->length = that.length;
                    this->capacity = that.length;
                }
                return *this;
            }
 
        private:
            T * data = nullptr;
            unsigned int length = 0;
            unsigned int capacity = 0;
    };
 
    class SwathDimensionAdjustment;

    class Dimension
    {
        public:
            const std::string & getName () const
            {
                return this->name;
            }
            int32 getSize () const
            {
                return this->dimsize;
            }
 
        protected:
            Dimension (const std::string & eos_dname, int32 eos_dimsize)
                : name (eos_dname), dimsize (eos_dimsize)
            {
            }
 
        private:
            std::string name;
            int32 dimsize;
 
        friend class File;
        friend class Dataset;
        friend class SwathDimensionAdjustment;
    };

    class Field
    {
        public:
            Field () = default;
            virtual ~ Field ();

            const std::string & getName () const
            {
                return this->name;
            }

            const std::string & getNewName () const
            {
                return this->newname;
            }

            int32 getRank () const 
            {   
                return this->rank;
            }

            int32 getType () const
            {
                return this->type;
            }

            const std::vector < Dimension * >&getCorrectedDimensions () const
            {
                return this->correcteddims;
            }

            std::vector < Dimension * >*getCorrectedDimensionsPtr ()
            {
                return &(this->correcteddims);
            }

            void setCorrectedDimensions (const std::vector < Dimension * >& eos_dims)
            {
                correcteddims = eos_dims;
            }

            std::string getCoordinate () const
            {
                return this->coordinates;
            }

            void setCoordinates (const std::string& coor)
            {
                coordinates = coor;
            }

            std::string getUnits () const
            {
                return this->units;
            }

            void setUnits (const std::string& uni)
            {
                units = uni;
            }

            float getAddedFillValue () const
            {
                return this->addedfv;
            }
 
            // Add the "_FillValue" attribute
            // This is for supporting the old versions of HDF-EOS2 data(AIRS) because
            // some data products have fillvalue(-9999.0) but don't specify the fillvalue.
            // We add the fillvalue to ensure the netCDF client can successfully display the data.
            // KY 2013-06-30
            void addFillValue (float fv)
            {
                addedfv = fv;
            }

            bool haveAddedFillValue () const
            {
                return this->haveaddedfv;
            }

            void setAddedFillValue (bool havefv)
            {
                haveaddedfv = havefv;
            }
 
            
            // Obtain fieldtype values
            // For fieldtype values:
            // 0 is general fields
            // 1 is latitude.
            // 2 is longtitude.    
            // 3 is defined level.
            // 4 is an inserted natural number.
            // 5 is time.
 
            int getFieldType () const
            {
                return this->fieldtype;
            }

            const std::vector < Dimension * >&getDimensions () const
            {
                return this->dims;
            }

            const std::vector < char >&getFillValue () const
            {
                return this->filler;
            }

            int getLLDim0Offset () const
            {
                return this->ll_dim0_offset;
            }
            int getLLDim0Inc () const
            {
                return this->ll_dim0_inc;
            }
            int getLLDim1Offset () const
            {
                return this->ll_dim1_offset;
            }
            int getLLDim1Inc () const
            {
                return this->ll_dim1_inc;
            }
 

            bool getYDimMajor () const
            {
                return this->ydimmajor;
            }

            bool getSpecialLon () const
            {
                return this->speciallon;
            }

            int getSpecialLLFormat () const
            {
                return this->specialformat;
            }

            bool getCondensedDim () const
            {
                return this->condenseddim;
            }

            bool UseDimMap () const
            {
                return this->dmap;
            }
 
        private:
            // field name
            std::string name;
 
            // field dimension rank
            int32 rank = -1;
 
            // field  datatype
            int32 type = -1;
 
            // field dimensions with original dimension names
            std::vector < Dimension * >dims;
 
            // field dimensions with the corrected(CF) dimension names
            std::vector < Dimension * >correcteddims;
            
            // This is for reading the fillvalue. 
            // HDF-EOS2 provides a special routine to read fillvalue.
            // Up to HDF-EOS2 version 2.18, this is the only field attribute
            // that HDF-EOS2 APIs provide. KY 2013-07-01
            
            std::vector < char >filler;
 
            // Coordinate attributes that includes coordinate variable list.
            std::string coordinates;
 
            // newname is to record CF Grid/Swath name + "_"+ CF field name(special characters replaced by underscores).
            std::string newname;
 
 
            // This flag will specify the fieldtype.
            // 0 means this field is general field.
            // 1 means this field is lat.
            // 2 means this field is lon.
            // 3 means this field is other dimension variable.
            // 4 means this field is added other dimension variable with nature number.
            // 5 means time, but currently the units is not correct.
            int fieldtype = 0;
 
            //  Latitude and longitude retrieved by HDF-EOS2 are always
            //  2-D arrays(XDim * YDim). However, for some projections
            // (geographic etc.), latiude and longitude can be condensed to
            //  1-D arrays. The handler will track such projections and condense
            //  the latitude and longitude to 1-D arrays. This can reduce       
            //  the disk storage and can greatly improve the performance for 
            //  the visualization tool to access the latitude and longitde.
            //  condenseddim is the flag internally used by the handler to track this.
            bool condenseddim = false;
 
            //   This flag is to mark if the data should follow COARDS.
            bool iscoard = false;
 
            //   This flag is to check if the field is YDim major(temp(YDim,XDim). This
            //   flag is necessary when calling GDij2ll to retrieve latitude and longitude.
            bool ydimmajor = true;
 
            // SOme special longitude is from 0 to 360.We need to check this case with this flag.
            bool speciallon = false;
 
            // This flag specifies the special latitude/longitude coordinate format
            // The latiude and longitude should represent as DDDMMMSSS format
            // However, we found some files simply represent lat/lon as -180.0000000 or -90.000000. 
            // Some other files use default. So we this flag to record this and correctly retrieve
            // the latitude and longitude values in the DAP output.
            // 0 means normal 
            // 1 means the coordinate is -180 to 180
            // 2 means the coordinate is default(0)
            int specialformat = 0;
 
            // CF units attribute(mostly to add latitude and longitude CF units).
            std::string units;
 
            // Some data products have fillvalue(-9999.0) but don't specify the fillvalue.
            // We add the fillvalue to ensure the netCDF client can successfully display the data.
            // haveaddedfv and addedfv are to check if having added fillvalues.
            bool haveaddedfv = false;
            int ll_dim0_offset = 0;
            int ll_dim0_inc = 0;
            int ll_dim1_offset = 0;
            int ll_dim1_inc = 0;
             
            float addedfv = -9999.0;
 
            // Check if this swath uses the dimension map. 
            bool dmap = false;
 
        friend class Dataset;
        friend class SwathDimensionAdjustment;
        friend class GridDataset;
        friend class SwathDataset;
        friend class File;
    };
 

    class Attribute
    {
        public:

            const std::string & getName () const
            {
                return this->name;
            }

            const std::string & getNewName () const
            {
                return this->newname;
            }

            int32 getType () const
            {
                return this->type;
            }

            int32 getCount () const
            {
                return this->count;
            }

            const std::vector < char >&getValue () const
            {
                return this->value;
            }
 
        private:

            std::string name;

            std::string newname;

            int32 type;

            int32 count;

            std::vector < char >value;
 
        friend class Dataset;
    };

    class Dataset
    {
        public:
            const std::string & getName () const
            {
                return this->name;
            }
            const std::vector < Dimension * >&getDimensions () const
            {
                return this->dims;
            }
            const std::vector < Field * >&getDataFields () const
            {
                return this->datafields;
            }

            const std::vector < Attribute * >&getAttributes () const
            {
                return this->attrs;
            }

            SOType getScaleType () const
            {
                return this->scaletype;
            }
 
 
        protected:
            explicit Dataset (const std::string & n)
                : name (n){}
            virtual ~ Dataset ();

            void ReadDimensions (int32 (*entries) (int32, int32, int32 *),
                int32 (*inq) (int32, char *, int32 *),
                std::vector < Dimension * >&dims) ;

            void ReadFields (int32 (*entries) (int32, int32, int32 *),
                int32 (*inq) (int32, char *, int32 *, int32 *),
                intn (*fldinfo) (int32, char *, int32 *, int32 *,
                int32 *, char *),
                intn (*getfill) (int32, char *, VOIDP),
                bool geofield, std::vector < Field * >&fields) 
                ;

            void ReadAttributes (int32 (*inq) (int32, char *, int32 *),
                intn (*attrinfo) (int32, char *, int32 *, int32 *),
                intn (*readattr) (int32, char *, VOIDP),
                std::vector < Attribute * >&attrs)
                ;
 
            void SetScaleType(const std::string & EOS2ObjName);
 
            int obtain_dimsize_with_dimname(const std::string& dimname) const;
        protected:
            int32 datasetid = -1;

            bool addfvalueattr = false;

            std::string name;

            std::vector < Dimension * >dims;

            std::vector < Field * >datafields;

            std::vector < Attribute * >attrs;

            std::map < std::string, std::string > dimcvarlist;

            std::map < std::string, std::string > ncvarnamelist;

            std::map < std::string, std::string > ndimnamelist;
 
            // Some MODIS files don't use the CF linear equation y = scale * x + offset,
            // The scaletype distinguishs products following different scale and offset rules.
            // Note the assumption here: we assume that all fields will
            // use one scale and offset function in a file. If
            // multiple scale and offset equations are used in one file, our
            // function will fail. So far only one scale and offset equation is
            //  applied for NASA HDF-EOS2 files we observed. KY 2012-6-13
            // Since I found one MODIS product(MOD09GA) uses different scale offset
            // equations for different grids. I had to move the scaletype to the
            // group level. Hopefully this is the final fix. Truly hope that 
            // this will not happen at the field level since it will be too messy to 
            // check.  KY 2012-11-21
            SOType scaletype = SOType::DEFAULT_CF_EQU;
 
        friend class File;
    };

    class GridDataset:public Dataset
    {
        public:
            class Info
            {
                public:

                    int32 getX ()const
                    {
                        return this->xdim;
                    }

                    int32 getY () const
                    {
                        return this->ydim;
                    }

                    const float64 *getUpLeft () const
                    {
                        return this->upleft;
                    }

                    const float64 *getLowRight () const
                    {
                        return this->lowright;
                    }
                protected:
                    Info() = default;
 
                private:
                    int32 xdim = -1;
                    int32 ydim = -1;
                    float64 upleft[2];
                    float64 lowright[2];
 
                friend class GridDataset;
            };
 
            class Projection
            {
                public:

                    int32 getCode () const
                    {
                        return this->code;
                    }

                    int32 getZone () const
                    {
                        return this->zone;
                    }

                    int32 getSphere () const
                    {
                        return this->sphere;
                    }

                    const float64 *getParam () const
                    {
                        return this->param;
                    }

                    int32 getPix () const
                    {
                        return this->pix;
                    }

                    int32 getOrigin () const
                    {
                        return this->origin;
                    }
 
                protected:
                    Projection() = default;
 
                private:
                    int32 code = -1;
                    int32 zone = -1;
                    int32 sphere = -1;
                    float64 param[16];
                    int32 pix = -1;
                    int32 origin =-1;
 
                friend class GridDataset;
            };

            class Calculated
            {
                public:

                    bool isYDimMajor () ;
 
                protected:
 
                    explicit Calculated (const GridDataset * eos_grid)
                        : grid (eos_grid)
                    {
                    }
 
                    Calculated & operator= (const Calculated & victim)
                    {
                        if (this != &victim) {
                            this->grid = victim.grid;
                            this->ydimmajor = victim.ydimmajor;
                        }
                        return *this;
                    }

                    void DetectMajorDimension () ;

                    int DetectFieldMajorDimension () const;
 
 
                private:
                    const GridDataset *grid;
                    bool ydimmajor = false;
 
                friend class GridDataset;
                friend class File;
            };
 
            public:
                static GridDataset *Read (int32 fd, const std::string & gridname) ;
 
                ~ GridDataset () override;

                const Info & getInfo () const
                {
                    return this->info;
                }

                const Projection & getProjection () const
                {
                    return this->proj;
                }

                Calculated & getCalculated () const;

                void setDimxName (const std::string &dxname)
                {
                    dimxname = dxname;
                }
                void setDimyName (const std::string &dyname)
                {
                    dimyname = dyname;
                }

                bool getLatLonFlag () const
                {
                    return this->ownllflag;
                }
 
            private:
                explicit GridDataset (const std::string & g_name)
                    : Dataset (g_name),calculated(0)
                {
                }
 
            private:

                Info info;

                Projection proj;

                mutable Calculated calculated;

                bool ownllflag = false;

                bool iscoard = false;

                Field *latfield = nullptr;
                Field *lonfield = nullptr;

                std::string dimxname;
                std::string dimyname;
 
            friend class File;
 
        };
 
        class File;

 
        class SwathDataset:public Dataset
        {
 
            public:
 
                class DimensionMap
                {
              
                    public:
                        const std::string & getGeoDimension () const
                        {
                            return this->geodim;
                        }
                        const std::string & getDataDimension () const
                        {
                            return this->datadim;
                        }
                        int32 getOffset () const
                        {
                            return this->offset;
                        }
                        int32 getIncrement () const
                        {
                            return this->increment;
                        }
 
                    protected:
                        DimensionMap (const std::string & eos_geodim, const std::string & eos_datadim, int32 eos_offset, int32 dimmap_increment)
                            : geodim (eos_geodim), datadim (eos_datadim), offset (eos_offset), increment (dimmap_increment)
                        {
                        }
 
                    private:
 
                        std::string geodim;
                        std::string datadim;
                        int32 offset;
                        int32 increment;
 
                    friend class SwathDataset;
                    friend class SwathDimensionAdjustment;
                    friend class File;
                };

                class IndexMap
                {
                    public:
                        const std::string & getGeoDimension () const
                        {
                            return this->geo;
                        }
                        const std::string & getDataDimension () const
                        {
                            return this->data;
                        }
                        const LightVector < int32 > &getIndices () const
                        {
                            return this->indices;
                        }
 
                    private:
                        std::string geo;
                        std::string data;
                        LightVector < int32 > indices;
 
                    friend class SwathDataset;
                };
 
            public:
                static SwathDataset *Read (int32 fd, const std::string & swathname) ;
 
                ~ SwathDataset () override;

                const std::vector < DimensionMap * >&getDimensionMaps () const
                {
                    return this->dimmaps;
                }
                const std::vector < IndexMap * >&getIndexMaps () const
                {
                    return this->indexmaps;
                }

                const std::vector < Field * >&getGeoFields () const
                {
                    return this->geofields;
                }
 

                void set_num_map (int this_num_map)
                {
                    num_map = this_num_map;
                }
                int get_num_map () const
                {
                    return num_map;
                };
 
            private:
                 explicit SwathDataset (const std::string & swath_name)
                    : Dataset (swath_name) {
                 }
 

                int ReadDimensionMaps (std::vector < DimensionMap * >&dimmaps) ;
 
                bool obtain_dmap_offset_inc(const std::string& o_dimname,const std::string& n_dimmname,int&,int&) const;

                void ReadIndexMaps (std::vector < IndexMap * >&indexmaps) ;
 
                
                std::vector < DimensionMap * >dimmaps;

                std::vector < IndexMap * >indexmaps;

                std::set < std::string > nonmisscvdimlist;

                std::vector < Field * >geofields;

                int num_map = 0;
 
                bool GeoDim_in_vars = false;
 
            friend class File;
        };

        class PointDataset:public Dataset
        {
            public:
                static PointDataset *Read (int32 fd, const std::string & point_name) ;
                ~ PointDataset () override;
 
            private:
                explicit PointDataset (const std::string & point_name)
                    : Dataset (point_name)
                {
                }
        };
 

        class File
        {
            public:

                static File *Read (const char *path,int32 gridfd,int32 swathfd) ;
 

                void Prepare(const char *path);

                bool check_special_1d_grid();
 

                bool getOneLatLon () const
                {
                    return this->onelatlon;
                }

                ~File ();
 
                const std::string & getPath () const
                {
                    return this->path;
                }
 
                const std::vector < GridDataset * >&getGrids () const
                {
                    return this->grids;
                }
 
                const std::vector < SwathDataset * >&getSwaths () const
                {
                    return this->swaths;
                }
 
                bool getMultiDimMaps() const 
                {
                    return this->multi_dimmap;
                }
                const std::vector < PointDataset * >&getPoints () const
                {
                    return this->points;
                }
 
                std::string get_first_grid_name() const 
                { 
                    return this->grids[0]->getName();
                }
 
 
            protected:
                explicit File (const char *eos2_file_path)
                    : path (eos2_file_path)
                {
                }
 
            private:

                std::string path;

                std::vector < GridDataset * >grids;

                std::vector < SwathDataset * >swaths;

                std::vector < PointDataset * >points;
 
                // This is for the case that only one lat/lon
                // set is provided for multiple grid cases.
                //  The current case is that the user provides
                // the latitude and longitude under a special grid.
                // By default, the grid name is "location". This will
                // cover the AIRS grid case.
                bool onelatlon = false;

                bool iscoard = false;

                bool handle_swath_dimmap = false;
                
                bool backward_handle_swath_dimmap = false;

                bool multi_dimmap = false;
 
            protected:
                /* 
                  A grid's X-dimension can have different names: XDim, LatDim, etc.
                 * Y-dimension also has YDim, LonDim, etc.
                 * This function returns the name of X-dimension which is used in
                 * the given file.
                 * For better performance, we check the first grid or swath only.
                 */
                std::string get_geodim_x_name ();
                std::string get_geodim_y_name ();
 
                // Internal function used by  
                // get_geodim_x_name and get_geodim_y_name functions.
                // This function is not intended to be used outside the 
                // get_geodim_x_name and get_geodim_y_name functions.
                void _find_geodim_names ();
 
                std::string _geodim_x_name;
                std::string _geodim_y_name;
                static const char *_geodim_x_names[];
                static const char *_geodim_y_names[];

                std::string get_latfield_name ();
                std::string get_lonfield_name ();
 
                // Internal function used by  
                // get_latfield_name and get_lonfield_name functions.
                // This function is not intended to be used outside 
                // the get_latfield_name and get_lonfield_name functions.
                void _find_latlonfield_names ();
 
                std::string _latfield_name;
                std::string _lonfield_name;
                static const char *_latfield_names[];
                static const char *_lonfield_names[];

                std::string get_geogrid_name ();
 
                // Internal function used by
                // the get_geogrid_name function.
                // This function is not intended to be used outside the get_geogrid_name function.
                void _find_geogrid_name ();
 
                std::string _geogrid_name;
                static const char *_geogrid_names[];
 
 
                // All the following functions are called by the Prepare() function.
 
                // Check if we have the dedicated lat/lon grid.
                void check_onelatlon_grids();                
 
                // For one grid, need to handle the third-dimension(both existing and missing) coordinate variables
                void handle_one_grid_zdim(GridDataset*);
 
                // For one grid, need to handle lat/lon(both existing lat/lon and calculated lat/lon from EOS2 APIs)
                void handle_one_grid_latlon(GridDataset*);
 
                // For the case of which all grids have one dedicated lat/lon grid,
                // this function shows how to handle lat/lon fields.
                void handle_onelatlon_grids() ;
 
                // Handle the dimension name to coordinate variable map for grid. 
                void handle_grid_dim_cvar_maps() ;
 
                // Follow COARDS for grids.
                void handle_grid_coards();
 
                // Create the corrected dimension vector for each field when COARDS is not followed.
                void update_grid_field_corrected_dims();
 
                // Handle CF attributes for grids. 
                // The CF attributes include "coordinates", "units" for coordinate variables and "_FillValue". 
                void handle_grid_cf_attrs();
 
                // Special handling SOM(Space Oblique Mercator) projection files
                void handle_grid_SOM_projection();
 
                bool find_dim_in_dims(const std::vector<Dimension*>&dims,const std::string &dim_name) const;
 
                // Check if we need to handle dim. map and set handle_swath_dimmap if necessary.
                // The input parameter is the number of swath.
                void check_swath_dimmap(int numswath);
 
                void check_swath_dimmap_bk_compat(int numswath);
 
                // Create the dimension name to coordinate variable name map for lat/lon. 
                // The input parameter is the number of dimension maps in this file.
                void create_swath_latlon_dim_cvar_map();
 
                // Create the dimension name to coordinate variable name map for non lat/lon coordinate variables.
                void create_swath_nonll_dim_cvar_map();
 
                // Handle swath dimension name to coordinate variable name maps. 
                // The input parameter is the number of dimension maps in this file.
                void handle_swath_dim_cvar_maps();
 
                // Handle CF attributes for swaths. 
                // The CF attributes include "coordinates", "units" for coordinate variables and "_FillValue". 
                void handle_swath_cf_attrs();
 
                bool check_ll_in_coords(const std::string& vname);

                //  is not to keep original latitude/longitude. Now some MODIS files 
                //  have the variables that still use the low resolution. See HFRHANDLER-332.
                void check_dm_geo_dims_in_vars() const;

                void create_swath_latlon_dim_cvar_map_for_dimmap(SwathDataset*,Field*,Field*);
 
                void create_geo_varnames_list(std::vector<std::string> &,const std::string &, 
                                              const std::string &,int,bool) const;
 
                void create_geo_dim_var_maps(SwathDataset*, Field*, const std::vector<std::string>&,
                                         const std::vector<std::string>&,
                                         std::vector<Dimension*>&, std::vector<Dimension*>&) const;
                void create_geo_vars(SwathDataset*,Field*,Field*,const std::vector<std::string>&,const std::vector<std::string>&,
                                     std::vector<Dimension*>&, std::vector<Dimension*>&);
 
                void update_swath_dims_for_dimmap(const SwathDataset*,
                                     const std::vector<Dimension*>&, const std::vector<Dimension*>&) const;
 
 
 
             private:
 
                // HDF-EOS2 Grid File ID. Notice this ID is not an individual grid ID but the grid file ID returned by 
                // calling the HDF-EOS2 API GDopen. 
                int32 gridfd = -1;
 
                // HDF-EOS2 Swath File ID. Notice this ID is not an individual swath ID but the swath file ID returned by
                 // calling the HDF-EOS2 API SWopen.
                int32 swathfd = -1;

 
#if 0
#endif
        };
 
 
        struct Utility
        {

            static bool ReadNamelist (const char *path,
                int32 (*inq) (char *, char *, int32 *),
                std::vector < std::string > &names);
 
 
        };
 
}
#endif
 
#endif