/home/pascal/depot/filedata/src/caliopfiledata.h

/***************************************************************************
 *   Copyright (C) 2005 by Nicolas PASCAL                                  *
 *   nicolas.pascal@icare.univ-lille1.fr                                   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

/**************************************************************************
*  History :                                                             *
*  1/08/05 : start                                                        *
**************************************************************************/

#ifndef CALIOPFILEDATA_H
#define CALIOPFILEDATA_H

#include "hdffiledata.h"
// #include "tools.h"
#include "file_tools.h"
#include <iterator>
#include <algorithm>
#include "satellitefiledata.h"

struct FeatureClassFlag{
        unsigned int type : 3;
        unsigned int typeQA : 2;
        unsigned int phase : 2;
        unsigned int phaseQA : 2;
        unsigned int subtype : 3;
        unsigned int subtypeQA : 1;
        unsigned int horizontal_avg_detection : 3;
    };

class CALIOPFileData : public SatelliteFileData, public HDFFileData {
public:
    static const int nb_cloud_layer=10;
    static const int nb_lidar_surface_elevation=8;
    static const int nb_aerosol_layer=8;
    static const int nb_vbins=583;
    static const int nb_vfm_bins=5515;
    static const int nb_vfm_samples_per_profile=545;

    static const int nb_meteo_level=33;
    static const int nb_05kmcpro_bins=345;

    static const float32 meteo_level_altitude[];
    static const float32 cal_lid_l2_vfm_altitude[];
    static const float32 cal_lid_l2_vfm_altitude_ud[];

    static const float32 cal_lid_l2_05kmCPro_altitude[];

    static const float colocation_tolerance;

    enum ProductType{
            CAL_LID_UNDEFINED,
            CAL_LID_L1,
            CAL_LID_L2_333mCLay,
            CAL_LID_L2_01kmCLay,
            CAL_LID_L2_05kmCLay,
            CAL_LID_L2_05kmALay,
            CAL_LID_L2_40kmAPro,
            CAL_LID_L2_05kmCPro,
            CAL_LID_L2_VFM
    };

    static inline bool is_same_orbit(const CALIOPFileData* fd1, const CALIOPFileData* fd2) {
      string fd1_timestamp=(fd1->get_name()).substr((fd1->get_name()).size()-25,21);
      string fd2_timestamp=(fd2->get_name()).substr((fd2->get_name()).size()-25,21);
      return fd1_timestamp==fd2_timestamp;
    }
//     virtual void load_viewing_directions ();
    virtual bool is_viewing_directions_data_loaded();
    virtual void load_viewing_directions_data ();
    virtual void free_viewing_directions_data ();
    virtual void get_viewing_directions (const vector <int> & ipix, vector <Observation> & v_obs);
private:
    int level;
    ProductType product_type;
    float resolution;
    bool day_mode;
    int nb_layer;

    string product;

    int lat_lon_index_max[2];

    float lat_min,lat_max,lon_min,lon_max;

    float64 * v_pos_data;
    float32 * v_alt_data;

    // some constant specific to CALIOP
    string latitude_sds_name;
    string longitude_sds_name;
    string time_sds_name;

    void init();

public:

    CALIOPFileData(const string &_name = string(""), const string & mode = string("r"));
    ~CALIOPFileData();
    const int get_level() const {
        return level;
    };
    void set_lat_lon_index_max();
    const int * get_lat_lon_index_max() const {
        return lat_lon_index_max;
    }
    const bool is_day() const;
    const int get_nb_geo_points() const ;
    int get_nb_layer() const {
      return nb_layer;
    };
    template <class T>
    static const T get_calipso_fill_value(const string &typecode);

    const bool get_index(const float &lat, const float& lon, int &nearest_pix_idx, const float colocation_tolerance=CALIOPFileData::colocation_tolerance);

     virtual void get_vindex(vector < vector < int > > &v_index, const float &lat, const float& lon,
                                                    const float colocation_tolerance = CALIOPFileData::colocation_tolerance ) ;

    const float get_nearest_point_distance(const float &lat,const float &lon,const float coloc_tolerance=CALIOPFileData::colocation_tolerance);
    const bool contain_location(const float &lat,const float &lon, const double &tolerance=CALIOPFileData::colocation_tolerance);
    const bool contain_data(const float &lat, const float &lon, const double &time, const double &colocation_tolerance=CALIOPFileData::colocation_tolerance) ;
    void load_geolocation_data();
    void free_geolocation_data();
    const bool is_geolocation_data_loaded() const;
//     virtual void load_lines_of_sight ();
//     virtual void free_lines_of_sight ();
    virtual void load_v_pixel() ;
    virtual void close_data_file() {
        free_hdf_file();
    };
    virtual void open_data_file() {
        load_hdf_file();
    };
    virtual void get_pixel_coord ( const vector < int > & ipix, float &lat, float &lon, double &time ) {
        if (!is_geolocation_data_loaded())
            load_geolocation_data();
        lat  = lat_data  [ ipix[0] ];
        lon  = lon_data  [ ipix[0] ];
        time = time_data [ ipix[0] ];
    };

    const float get_resolution() const {
        return resolution;
    }
    virtual string get_product(){
        return product;
    };

    static const float32* get_cal_lid_l2_vfm_altitude() {
        return cal_lid_l2_vfm_altitude;
    }

    static const float32* get_cal_lid_l2_05kmcpro_altitude() {
        return cal_lid_l2_05kmCPro_altitude;
    }

private:
    void check_filename( const string& short_filename ) const;
    void parse_filename( const string& short_filename );
    void set_time_coverage();
protected:
    void set_lat_lon_min_max();
};
template <class T>
const T CALIOPFileData::get_calipso_fill_value(const string &typecode) {
    if (typecode=="float64" || typecode=="double" ||
        typecode=="float32" || typecode=="float" ||
        typecode=="int32"   || typecode=="long" ||
        typecode=="int16"   || typecode=="short"
        )
        return static_cast<T>(-9999);
    else if (typecode=="int8"
            )
        return static_cast<T>(-99);
    else {
        cerr<<"In "<<__FILE__<<" at "<<__LINE__<<" : case of typecode "<<typecode<<" not treated yet"<<endl;
        exit(0);
    }
}

#endif