///////////////////////////////////////////////////////////////////////////
// NAME: MODIS_ADP.cpp
// FUNCTION: Implementation of the Class_ABI_ADP class.
// DESCRIPTION: This is the major program of MODIS smoke/dust detection.
// REFERENCE: none
// CALLING SEQUENCE: none
// INPUTS: none
// OUTPUTS: none
// DEPENDENCIES: ABI_ADP.h
// RESTRICTIONS: none
// HISTORY: none 
//////////////////////////////////////////////////////////////////////////

#include <cassert>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <cmath>
#include <string>
#include <iostream>
#include <fstream>
#include <cstdio>
#include <time.h>
#include "utility.h"
#include "ABI_const.h"
#include "ABI_ADP.h"
///////////////////////////////////////////////////////////////////////////
// NAME: Class_ABI_ADP::Class_ABI_ADP()
// FUNCTION: Initial housekeeping
// DESCRIPTION: Constructor of class "Class_ABI_ADP"
// REFERENCE: non 
// CALLING SEQUENCE: non
// INPUTS: non
// OUTPUTS: non
// DEPENDENCIES: non RESTRICTIONS: non
// HISTORY: non
//////////////////////////////////////////////////////////////////////////

Class_ABI_ADP::Class_ABI_ADP()
{
   m_count_fitRefl4=0;
}

///////////////////////////////////////////////////////////////////////////
// NAME: Class_ABI_ADP::~Class_ABI_ADP()
// FUNCTION: Termination housekeeping
// DESCRIPTION: Destructor of class "Class_ABI_ADP"
// REFERENCE: non
// CALLING SEQUENCE: non
// INPUTS: non
// OUTPUTS: non
// DEPENDENCIES: non
// RESTRICTIONS: non
// HISTORY: non
//////////////////////////////////////////////////////////////////////////
Class_ABI_ADP::~Class_ABI_ADP()
{

}

///////////////////////////////////////////////////////////////////////////
// NAME: int main
// FUNCTION:  The main program                                          
// DESCRIPTION: The main routine for the smoke and dust detection algorithm
// REFERENCE: non
// CALLING SEQUENCE: main(argc, argv[])
// INPUTS:
//    int argc - number of command line input arguments  
//    char* argv[] - pointer to the command line input argument
// OUTPUTS: return value 0: normal
// DEPENDENCIES:  ProcessADP (called functions)
//                granuleData - reference of Class_ABI_ADP
// RESTRICTIONS: non
// HISTORY: non
//////////////////////////////////////////////////////////////////////////
int main( ) 
{

   cout << "------------- Program Start Now -------------" << endl;
   string strHelp ="";
   strHelp = strHelp +
      "Example script to run this program:   \n\n" +
      "    create_SDR_ADP_v5_GranuleHDF_ospo.exe  [, configure_file_name] \n\n" +
      "    ex:    create_SDR_ADP_v5_GranuleHDF_dblue_ospo.exec  \n\n" +
      "    other parameters required will be read from the configure file,\n" +
      "    by default is 'MODIS_ADP_OSPO.config' \n           \n" +
      "Please check the parameters and run again. \n";

   char configFname[STRMAX] = "MODIS_ADP_OSPO.config";
   Class_ABI_ADP 	granuleData;
   granuleData.ProcessADP(configFname);

   cout << "------------ Program Completed Successfully ------------" << endl;

   return 0;
}

/*********************************************/
/******* P U B L I C  F U N C T I O N S ******/
/*********************************************/

///////////////////////////////////////////////////////////////////////////
// NAME: void Class_ABI_ADP::ProcessADP
// FUNCTION: The driving class
// DESCRIPTION: The driving class for processing the smoke and dust detection
// REFERENCE: non
// CALLING SEQUENCE: ProcessADP(granuleName, configFname)
// INPUTS:
//      string granuleName - name of current granule
//      char *configFname - pointer to the name of the configuration file
// OUTPUTS: non
// DEPENDENCIES: 
//      Subroutines:
//               read_ABI_ADP_configFile, create_ADP_file, openInputFiles,
//               cleanData, closeInputFiles
//      mgd - reference of ABI_GranuleData
// RESTRICTIONS: non
// HISTORY: non
//////////////////////////////////////////////////////////////////////////

void Class_ABI_ADP::ProcessADP(char *configFname)
{
   ABI_GranuleData mgd;
     
   read_ABI_ADP_configFile(configFname);

   string sep="/";
    
   string temp=sep;

   strcat(m_Config.MODIS_data_folder, temp.c_str());

   bool dataNeeded[3] = {true, true, true}; 
   bool success;

   /*************** S E T U P ***************/
              
   success = mgd.openInputFiles(m_Config.MODIS_data_folder,dataNeeded);
   if (!success) return ;
   //cout<<"opening completed!"<<endl;
   //cout<<"021KM_index---"<<mgd.get021KM_index()<<endl;
   //cout<<"03_index---"<<mgd.get03_index()<<endl;
   //processing ABI smoke and dust (ASD) detection
   m_skipLines = 0;
   //create ASD detection output file
   char ipfile[STRMAX];
	             
   char extention[STRMAX]="_v5_deepblue.hdf";
                   
   sprintf(ipfile, "%s%s%s", m_Config.output_ADP_folder , "ABI_ADP_MASK",
            extention);
   // Produce Output for Cloud Mask and Smoke and Dust detection.


   create_ADP_file(ipfile, 1, mgd);

   //cleanup and close files
   mgd.cleanData();	
   mgd.closeInputFiles();
     
}

/*********************************************/
/***** P R I V A T E   F U N C T I O N S *****/
/*********************************************/

///////////////////////////////////////////////////////////////////////////
// NAME: int Class_ABI_ADP::calculateStdDev
// FUNCTION: Calculate mean and standard deviation for a pixel
// DESCRIPTION:  Calculate mean and standard deviation for a pixel
// REFERENCE: non
// CALLING SEQUENCE: calculateStdDev(pdata, ndex_x, index_y, NX_size, NY_size,
//                   boxSize, mean_value, StdDev_value)
// INPUTS: pdata[NX_size,NY_size]: input data field
//         index_x, index_y: the target position in data field
//         boxSize: the window size for mean and standard deviation,
//                  ususally is odd number, 3 or 5...
// OUTPUTS: mean_value, StdDev_value - mean and standard deviation over the
//          pixels surounding the target pixel
// DEPENDENCIES: non
// RESTRICTIONS: non
// HISTORY: non
//////////////////////////////////////////////////////////////////////////
int Class_ABI_ADP::calculateStdDev( float32 *pdata, int index_x,
   int index_y, int NX_size, int NY_size, int boxSize,
   float *mean_value, float *StdDev_value)
{
   //avoiding the edge
   int boxSize_half =  boxSize/2;
   if( index_x <   boxSize_half)             index_x=boxSize_half; 
   if( index_x >= (NX_size-boxSize_half))    index_x=NX_size-boxSize_half-1; 
   if( index_y <   boxSize_half)             index_y=boxSize_half; 
   if( index_y >= (NY_size-boxSize_half))    index_y=NY_size-boxSize_half-1; 

   int Nvalidpindex_xels=0;
   float32  rmean = 0;
   float32  rsqd  = 0;
   float32  value;
       
   for (int jindex=index_y-boxSize_half; jindex<= index_y+boxSize_half;
   jindex++){
      int32 pos= jindex * NX_size ;
      for (int iindex=index_x-boxSize_half; iindex<= index_x+boxSize_half;
      iindex++){
         value =  *(pdata +pos+iindex);
         if (value > 0) {
            rmean += value;
            rsqd  += (value * value);
            Nvalidpindex_xels++; 
         }

      }//iindex
          
   }//jindex
    
      *mean_value = MeanStdDev_Default;
    *StdDev_value = MeanStdDev_Default;

   if(Nvalidpindex_xels ==1) {
      *mean_value = rmean  ;
      *StdDev_value = 0;
   }else if(Nvalidpindex_xels >1) {
      value = (rsqd - (rmean *rmean /Nvalidpindex_xels) ) /
              (Nvalidpindex_xels-1);
      if (value > 0.) {
         *mean_value =  rmean /Nvalidpindex_xels;
         *StdDev_value = sqrt(value);
      }
   }

   return Nvalidpindex_xels;
}


///////////////////////////////////////////////////////////////////////////
// NAME: void Class_ABI_ADP::sliding_mean_StdDev_of_scan 
// FUNCTION: Perform spatial average.         
// DESCRIPTION: Perfrom 3 by 3 pixel spatial average for a scan
// REFERENCE: none
// CALLING SEQUENCE: sliding_mean_StdDev_of_scan(NX_size, NY_size, boxsize,
//                   data, meandata, stddata)
// INPUTS: 
//      int NX_size - Size of subdomain in x-direction
//      int NY_size - Size of subdomain in y-direction
//      int boxsize - Size of subdomain
//      float32 *data - Pointer to the processed data
// OUTPUTS: 
//      float32 *meandata - Pointer to spatially averaged data
//      float32 *stddata - Standard deviation of spatially averaged data
// DEPENDENCIES: calculateStdDev - Subroutine
// RESTRICTIONS: non
// HISTORY: non
//////////////////////////////////////////////////////////////////////////
void Class_ABI_ADP::sliding_mean_StdDev_of_scan(int NX_size,int NY_size,
   int boxsize,float32 *data, float32 *meandata, float32 *stddata)
{
   // loop over each scan line
   for (int32 index_y=0; index_y<NY_size; index_y++) {
      int32 pos = index_y*NX_size;
      for (int32 index_x=0; index_x<NX_size; index_x++) {
         calculateStdDev(data, index_x, index_y, NX_size, NY_size, boxsize,
            meandata+pos+index_x, stddata+pos+index_x);
      }
   }
}


///////////////////////////////////////////////////////////////////////////
// NAME: void Class_ABI_ADP::spatialMeanStd
// FUNCTION: Compute the standard deviation of spatial varibility and the mean
// DESCRIPTION: Compute the standard deviation of spatial varibility of
//              reflectance and the mean at band 1, 2 and BT at band 31.
// REFERENCE: non
// CALLING SEQUENCE: spatialMeanStd(gd)
// INPUTS: ABI_GranuleData& gd - reference of ABI_GranuleData
// OUTPUTS: non
// DEPENDENCIES: sliding_mean_StdDev_of_scan - subroutine
// RESTRICTIONS: non
// HISTORY: non
//////////////////////////////////////////////////////////////////////////
void Class_ABI_ADP::spatialMeanStd(ABI_GranuleData& gd)
{ 
   for(int32 iscan= gd.scanStart; iscan<= gd.scanEnd; iscan++){
   int NX_size = gd.m_nPixScan_2KM;
   int NY_size = ABI_LINES_PER_SCAN_2KM;

   int32 pos = (iscan - gd.scanStart)* NX_size*NY_size;
   int boxsize=3;

   // band 1 (0.66um) -- smoke detection  2km 
   sliding_mean_StdDev_of_scan(NX_size, NY_size, boxsize,
      gd.m_ABIData.pREFB1 +pos, 
      gd.m_ABIData.spaMean1 +pos,
      gd.m_ABIData.spaStd1 +pos);

   // band 2 (0.86um) -- dust detection 2km 
   sliding_mean_StdDev_of_scan(NX_size, NY_size, boxsize,
      gd.m_ABIData.pREFB2 +pos, 
      gd.m_ABIData.spaMean2 +pos,
      gd.m_ABIData.spaStd2 +pos);
           
   // band 31 (11.0um) -- dust detection 2km
      pos= (iscan - gd.scanStart)* NX_size*NY_size;
   sliding_mean_StdDev_of_scan(NX_size, NY_size, boxsize,
      gd.m_ABIData.pBTB31 +pos, 
      gd.m_ABIData.spaMean31 +pos,
      gd.m_ABIData.spaStd31 +pos);

   }
}

void Class_ABI_ADP::smokeMaskingOcean(STRUCT_ABI_DATA *pABIData,
   int32 index2KM, uint8 &tmp_mask, uint8 &mask_con)
   //  int32 index2KM, short &tmp_mask,short &mask_con)

{
 
   int8 Cloud35_Bit09, Cloud35_Bit15, Cloud35_Bit16, Cloud35_Bit18, Cloud35_Bit19;
   uint8 Snow_Ice;   
 
/* Pass M?D35  15, 16, 18 Cloud Test */

    Cloud35_Bit15 = *(pABIData->pCLDMS_Bit15 + index2KM);
    Cloud35_Bit16 = *(pABIData->pCLDMS_Bit16 + index2KM);
    Cloud35_Bit18 = *(pABIData->pCLDMS_Bit18 + index2KM);
         Snow_Ice = *(pABIData->pSICMS       + index2KM);

   if ((Snow_Ice ==1 )) {
       tmp_mask=10;
       return;
   }


   if ((Cloud35_Bit15 == 1 ) || (Cloud35_Bit16 == 1 ) || (Cloud35_Bit18 == 1 )) {
      tmp_mask=1;
       return;
    }

   float64 Refl_Chn1, Refl_Chn2, Refl_Chn3, Refl_Chn5, Refl_Chn7;
   float64 Refl_Chn2_Mean, Refl_Chn2_Sigma, Refl_Chn3_Mean;
   uint8 fire=0;

   Refl_Chn1 = *(pABIData->pREFB1 + index2KM);   //0.66um
   Refl_Chn2 = *(pABIData->pREFB2 + index2KM);   //0.86um
   Refl_Chn3 = *(pABIData->pREFB3 + index2KM);   //0.47um

   Refl_Chn5 = *(pABIData->pREFB6 + index2KM);   //1.61um
   Refl_Chn7 = *(pABIData->pREFB7 + index2KM);   //2.13um
   Refl_Chn2_Mean = *(pABIData->spaMean2 + index2KM);   //0.86um
   Refl_Chn2_Sigma = *(pABIData->spaStd2 + index2KM);   //0.86um
   Refl_Chn3_Mean = *(pABIData->spaMean31 + index2KM);   //11.0um
    tmp_mask=2; 
   if(Refl_Chn2 > 0 && Refl_Chn3 > 0 && Refl_Chn5>0 && Refl_Chn7 > 0 ) {
            tmp_mask=3;
            float64 smkrat1 = Refl_Chn3/Refl_Chn5;
            float64 smkrat2 = Refl_Chn7/Refl_Chn5;

         if(Refl_Chn2_Sigma <= SONCSTD086) {
              if((smkrat1 >=SONCRAT1_1) && (Refl_Chn3 >= SONC047) && (Refl_Chn5 >= SONC123_L) && (Refl_Chn5 < SONC123_U) && (smkrat2 < SONCRAT2_1)) {

                tmp_mask=5;
//Determine confidence level
                float32 Con_Lev1 = ConfidenceLevel_U(smkrat1, SONCRAT1_1);
                float32 Con_Lev2 = ConfidenceLevel_U(Refl_Chn3, SONC047);
                float32 Con_Lev3 = ConfidenceLevel_M(Refl_Chn5, SONC123_L,SONC123_U);
                float32 Con_Lev4 = ConfidenceLevel_L(smkrat2,SONCRAT2_1);
                float32 Con_Lev =(Con_Lev1+Con_Lev2+Con_Lev3+Con_Lev4)/4.0;
                if( Con_Lev <=0.25 ) int mask_con=1;
                if( Con_Lev >=0.75 ) int mask_con=3;
                if( Con_Lev  >0.25 && Con_Lev <0.75 ) int mask_con=2;
                return;

//end of determination
                            }
               
                if (Refl_Chn2>SONC086) {
                if((smkrat1 >=SONCRAT1_2 )) {
                   tmp_mask=4;
//Determine confidence level

                float32 Con_Lev1 =ConfidenceLevel_U(smkrat1, SONCRAT1_2);
                float32 Con_Lev =Con_Lev1;

/*                if(Con_Lev ==0.0 ) int mask_con=1;
                if(Con_Lev ==0.5 ) int mask_con=2;
                if(Con_Lev ==1.0 ) int mask_con=3;

                if( abs(Con_Lev) <1.e-6 ) int mask_con=1;
                if( abs(Con_Lev-0.5) <1.e-6 ) int mask_con=2;
                if( abs(Con_Lev-1.0) <1.e-6 ) int mask_con=3;


                if( abs(Con_Lev) <1.e-15 ) int mask_con=1;
                if( abs(Con_Lev-0.5) <1.e-15 ) int mask_con=2;
                if( abs(Con_Lev-1.0) <1.e-15 ) int mask_con=3;
*/
                if((int) Con_Lev == 0 ) mask_con=1;
                if((int) (Con_Lev*10) ==5 ) mask_con=2;
                if((int) (Con_Lev*10) ==10 ) mask_con=3;

                return;
//end of determination

                }
                }
             
              }
                
                 if (Refl_Chn2>SONC086) {
                   if((smkrat1 >=SONCRAT1_2) && (smkrat2 < SONCRAT2_2)) {
                      tmp_mask=4;

//Determine confidence level
                float32 Con_Lev1 =ConfidenceLevel_U(smkrat1, SONCRAT1_2);
                float32 Con_Lev2 =ConfidenceLevel_L(smkrat2, SONCRAT2_2);
                float32 Con_Lev =(Con_Lev1+Con_Lev2)/2.0;
                if(Con_Lev <=0.25 ) int mask_con=1;
                if(Con_Lev >=0.75 ) int mask_con=3;
                if(Con_Lev >0.25 && Con_Lev <0.75 ) int mask_con=2;

                return;
//end of determination


                   }

                }
              
              }
  
} 

///////////////////////////////////////////////////////////////////////////
// NAME: void Class_ABI_ADP::dustMaskingOcean
// FUNCTION: Peform dust detection over water
// DESCRIPTION: Peform dust detection over water
//              Dust  Value
//              0:  no dust detected.
//              1:  dust detected.
// REFERENCE: ATBD of ABI Aerosol Imagery Product (Version 0.1)
// CALLING SEQUENCE: dustMaskingOcean(pABIData,index2KM,mask)
// INPUTS: 
//    STRUCT_ABI_DATA *pABIData - Pointer to the current processing data
//    int32 index2KM - Index of the data in 1-km resolution
// OUTPUTS: uint8 &mask - Reference to the masking flag
// DEPENDENCIES: none
// RESTRICTIONS: none
// HISTORY: none
//////////////////////////////////////////////////////////////////////////
void Class_ABI_ADP::dustMaskingOcean(STRUCT_ABI_DATA *pABIData,
   int32 index2KM, uint8 &tmp_mask,uint8 &tmp_mask_db,uint8 &mask_con)
   //int32 index2KM, short &tmp_mask,short &tmp_mask_db,short &mask_con)

{

   int8 Cloud35_Bit09, Cloud35_Bit15, Cloud35_Bit16, Cloud35_Bit18, Cloud35_Bit19, Cloud35_Bit27;
   uint8 Snow_Ice;
   mask_con=1;
/* Pass M?D35  15, 18 Cloud Test */


    Cloud35_Bit15 = *(pABIData->pCLDMS_Bit15 + index2KM);
    Cloud35_Bit18 = *(pABIData->pCLDMS_Bit18 + index2KM);
         Snow_Ice = *(pABIData->pSICMS       + index2KM);

   if ((Snow_Ice ==1 )) {
       tmp_mask=20;
      return;
   }

   if ((Cloud35_Bit15 == 1 ) || (Cloud35_Bit18 == 1 )) {
      //cout<<"Cloud35_Bit15= "<<Cloud35_Bit15<<endl;
      //cout<<"Cloud35_Bit18= "<<Cloud35_Bit18<<endl;

      tmp_mask=11;
      return;
   }

   //cout<<"1="<<tmp_mask<<endl;

   float64 Refl_Chn1, Refl_Chn2, Refl_Chn3,Refl_Chn7, Refl_Chn8, Refl_Chn9, Refl_Chn8_Ray, Refl_Chn9_Ray; 
   float64 BrtTemp_Chn21, BrtTemp_Chn31, BrtTemp_Chn32;        
   float64 Refl_Chn2_Mean, Refl_Chn2_Sigma;
   
 
   Refl_Chn1 = *(pABIData->pREFB1 + index2KM);   //0.66um
   Refl_Chn2 = *(pABIData->pREFB2 + index2KM);   //0.86um
   Refl_Chn3 = *(pABIData->pREFB3 + index2KM);   //0.47um
   BrtTemp_Chn21 = *(pABIData->pBTB21 + index2KM);   //3.96um BT
   BrtTemp_Chn31 = *(pABIData->pBTB31 + index2KM);   //11.um BT
   BrtTemp_Chn32 = *(pABIData->pBTB32 + index2KM);   //12.um BT
   Refl_Chn2_Mean = *(pABIData->spaMean2 + index2KM);   //0.86um
   Refl_Chn2_Sigma = *(pABIData->spaStd2 + index2KM);   //0.86um
// deep-blue detection
   Refl_Chn7 = *(pABIData->pREFB7 + index2KM);   //2.13um
   Refl_Chn8 = *(pABIData->pREFB8 + index2KM);   //0.41um (deep blue)
   Refl_Chn9 = *(pABIData->pREFB9 + index2KM);   //0.44um (deep blue)
// calculate rayleigh reflectance for deep channles
   
   float32  RelAzi = (*(pABIData->pSOLAZ + index2KM))- (*(pABIData->pSENAZ + index2KM));
   float32  CosSza = cos((*(pABIData->pSOLZA + index2KM)) * DEG2RAD);
   float32  CosVza = cos((*(pABIData->pSENZA + index2KM)) * DEG2RAD);
//   float32  MolOD  = MOLOD_DB [0];

   float32  MolOD  = MOLOD_DB[0] * exp(-(*(pABIData->pHEGHT + index2KM))*0.001/8.24);
   Refl_Chn8_Ray = RayRefl(MolOD,CosSza,CosVza,RelAzi,0);
            MolOD  = MOLOD_DB [1] * exp(-(*(pABIData->pHEGHT + index2KM))*0.001/8.24); 
   Refl_Chn9_Ray = RayRefl(MolOD,CosSza,CosVza,RelAzi,1);
   tmp_mask_db=12;
   //if (Refl_Chn7 > 0 && Refl_Chn8 > 0 && Refl_Chn9 > 0 ){
   if (Refl_Chn7 > 0 && Refl_Chn8 > 0 && Refl_Chn9 > 0 && Refl_Chn9_Ray > 0){
      tmp_mask_db=13;
      float32 dbdi = -100.0 * (log10 (Refl_Chn8/Refl_Chn9)-log10 (Refl_Chn8_Ray/Refl_Chn9_Ray));
      float32 dbsc =  -10.0 * (log10( Refl_Chn8/Refl_Chn7));
      if (dbdi >4.0 && dbsc > -10.0 && tmp_mask !=11 && Refl_Chn2_Sigma <= DONCSIG){
      tmp_mask_db=14;
      }     
    }

   //cout<<"2="<<tmp_mask_db<<endl;
// Dust detection start 
     tmp_mask=12;
   if (BrtTemp_Chn21 > 0 && BrtTemp_Chn31 > 0 && BrtTemp_Chn32 > 0
      && Refl_Chn3 > 0 && Refl_Chn2 > 0 && Refl_Chn1 > 0) {
      tmp_mask=24;
      float64 tdif1 = BrtTemp_Chn21 - BrtTemp_Chn31;
      float64 tdif2 = BrtTemp_Chn31 - BrtTemp_Chn32;
      float64 r3ov1  = Refl_Chn3/Refl_Chn1;
      float64 rndvi = (Refl_Chn2 - Refl_Chn1)/(Refl_Chn2 + Refl_Chn1);
      // Check 0.86um reflectance and STD
      if(Refl_Chn2_Mean > 0 && Refl_Chn2_Sigma <= DONCSIG) {
//        tmp_mask=13;
         if(Refl_Chn3 <= DONC047) {
              if(r3ov1 < DONCRAT1) {
                 tmp_mask=13;       
// Check 3.96-11um BTD
            if(tdif1 > DONC39_11_L && tdif1 <= DONC39_11_U) {
               if(tdif2 < DONC11_12_1 && rndvi <= DONCNDVI_U && rndvi >= DONCNDVI_L) {
//Determine confidence level
                float32 Con_Lev1 =ConfidenceLevel_M(tdif1, DONC39_11_L,DONC39_11_U);
                float32 Con_Lev2 =ConfidenceLevel_M(rndvi, DONCNDVI_L, DONCNDVI_U);
                float32 Con_Lev3 =ConfidenceLevel_L(tdif2, DONC11_12_1);
                
                float32 Con_Lev =(Con_Lev1+Con_Lev2+Con_Lev3)/3.0;
                if(Con_Lev <=0.33 ) mask_con=1;
                if(Con_Lev >=0.66 ) mask_con=3;
                if(Con_Lev > 0.33 && Con_Lev <0.66 ) mask_con=2;
               tmp_mask=14;
               return;
//end of determination

               }
               if(r3ov1 < DONCRAT2) {
//Determine confidence level
                float32 Con_Lev1 =ConfidenceLevel_M(tdif1, DONC39_11_L,DONC39_11_U);
                float32 Con_Lev2 =ConfidenceLevel_L(r3ov1, DONCRAT2);
                float32 Con_Lev  =(Con_Lev1+Con_Lev2)/2.0;
                if(Con_Lev <=0.25 ) mask_con=1;
                if(Con_Lev >=0.75 ) mask_con=3;
                if(Con_Lev >0.25 && Con_Lev <0.75 ) mask_con=2;
                tmp_mask=14;
                return; 
//end of determination

               }
                  if(tdif1 > DONC39_11_3 && tdif2 < DONC11_12_3) {
//Determine confidence level

		float32 Con_Lev1 =ConfidenceLevel_M(tdif1, DONC39_11_3,DONC39_11_U);
                float32 Con_Lev2 =ConfidenceLevel_L(tdif2, DONC11_12_3);

                float32 Con_Lev  =(Con_Lev1+Con_Lev2)/2.0;
                if(Con_Lev <=0.25 ) mask_con=1;
                if(Con_Lev >=0.75 ) mask_con=3;
                if(Con_Lev > 0.25 && Con_Lev <0.75 ) mask_con=2;
                tmp_mask=14;
                return;   
//end of determination

               }
            }
            else
            {
// Thick Dust detection
               if(tdif1 > DONC39_11_U) {
                  if(tdif2 < DONC11_12_2 && rndvi <= DONCNDVI_U1 && rndvi >= DONCNDVI_L) {
                    tmp_mask=15;
//Determine confidence level
                float32 Con_Lev1 =ConfidenceLevel_U(tdif1, DONC39_11_U);
                float32 Con_Lev2 =ConfidenceLevel_M(rndvi, DONCNDVI_L, DONCNDVI_U1);
                float32 Con_Lev3 =ConfidenceLevel_L(tdif2, DONC11_12_2);

                float32 Con_Lev  =(Con_Lev1+Con_Lev2+Con_Lev3)/3.0;
                if(Con_Lev <=0.33 ) mask_con=1;
                if(Con_Lev >=0.66 ) mask_con=3;
                if(Con_Lev > 0.33 && Con_Lev <0.66 ) mask_con=2;
              
//end of determination

                 }
               }
            }
         }
      }
   }
}

} 

    
///////////////////////////////////////////////////////////////////////////
// NAME: void Class_ABI_ADP::smokeMaskingLand
// FUNCTION: Make smoke detection over land. 
// DESCRIPTION: Perform smoke detection over land. 
//              Smoke  Value
//              0:  no smoke detected.
//              1:  smoke detected.
// REFERENCE:   ATBD of ABI Aerosol Imagery Product (Version 0.1)
// CALLING SEQUENCE: smokeMaskingLand(pABIData,index2KM,mask)
// INPUTS: 
//    STRUCT_ABI_DATA *pABIData - Pointer to the current processing data
//    int32 index2KM - Index of the data in 1-km resolution
// OUTPUTS: uint8 &mask - Reference to the masking flag
// DEPENDENCIES: non
// RESTRICTIONS: non
// HISTORY: non
//////////////////////////////////////////////////////////////////////////
void Class_ABI_ADP::smokeMaskingLand(STRUCT_ABI_DATA *pABIData,
   int32 index2KM, uint8 &tmp_mask,uint8 &tmp_mask_ism,uint8 &mask_con)
   //int32 index2KM, short &tmp_mask,short &tmp_mask_ism,short &mask_con)

{
 
   int8 Cloud35_Bit09, Cloud35_Bit15, Cloud35_Bit16, Cloud35_Bit18, Cloud35_Bit19, Cloud35_Bit27;
   uint8 Snow_Ice;
   mask_con=1;
   float64 Refl_Chn1, Refl_Chn2, Refl_Chn3,  Refl_Chn5,Refl_Chn7;
   float64 BrtTemp_Chn20, BrtTemp_Chn21, BrtTemp_Chn31;
   
/* Pass M?D35  9, 15, 16, 18 and 19 Cloud Test */


    Cloud35_Bit09 = *(pABIData->pCLDMS_Bit09 + index2KM);
    Cloud35_Bit15 = *(pABIData->pCLDMS_Bit15 + index2KM);
    Cloud35_Bit16 = *(pABIData->pCLDMS_Bit16 + index2KM);
    Cloud35_Bit18 = *(pABIData->pCLDMS_Bit18 + index2KM);
    Cloud35_Bit19 = *(pABIData->pCLDMS_Bit19 + index2KM);
         Snow_Ice = *(pABIData->pSICMS       + index2KM);

   if ((Snow_Ice ==1)) {
     tmp_mask=10;
     return;
     }

  /* internal Snow/ice test */

   Refl_Chn2 = *(pABIData->pREFB2 + index2KM);      //0.86um

   Refl_Chn5 = *(pABIData->pREFB6 + index2KM);      //1.61um
   BrtTemp_Chn31 = *(pABIData->pBTB31 + index2KM);  //11.um BT
          
   if ((Refl_Chn2 > 0.) && (Refl_Chn5 > 0.) && (BrtTemp_Chn31 > 0.)) {
      if ((((Refl_Chn2-Refl_Chn5)/(Refl_Chn2+Refl_Chn5) > ABI_LndSIndvi) &&
         (BrtTemp_Chn31 <= ABI_LndSIbt)))   {

         tmp_mask_ism = 16;

       }
   }

   if ((Cloud35_Bit09 ==1)|| (Cloud35_Bit15 ==1 ) || (Cloud35_Bit16 ==1 ) || (Cloud35_Bit18 ==1 ) || (Cloud35_Bit19 ==1 )) {
      tmp_mask=1;
       return;
   }
          
 
   Refl_Chn1 = *(pABIData->pREFB1 + index2KM);   //0.66um
   Refl_Chn2 = *(pABIData->pREFB2 + index2KM);   //0.86um
   Refl_Chn3 = *(pABIData->pREFB3 + index2KM);   //0.47um
   Refl_Chn7 = *(pABIData->pREFB7 + index2KM);   //2.13um
//   BrtTemp_Chn20 = *(pABIData->pBTB20 + index2KM);   //3.75um BT
   BrtTemp_Chn21 = *(pABIData->pBTB21 + index2KM);   //3.96um BT
   BrtTemp_Chn31 = *(pABIData->pBTB31 + index2KM);   //11.um BT
// Check for fires (hot spots).
   tmp_mask=2;
   if (BrtTemp_Chn21 > 0 && BrtTemp_Chn31 > 0) {
      tmp_mask=3;
      float64 tdif = BrtTemp_Chn21 - BrtTemp_Chn31; 
      if(BrtTemp_Chn21 > SLBT39 && tdif > SLNC39_11) {
       tmp_mask=4;
//Determine confidence level
                float32 Con_Lev1 =ConfidenceLevel_U(BrtTemp_Chn21, SLBT39);
                float32 Con_Lev2 =ConfidenceLevel_U(tdif,SLNC39_11);
                 float32 Con_Lev =(Con_Lev1+Con_Lev2)/2.0;
                if(Con_Lev <=0.25 ) mask_con=1;
                if(Con_Lev >=0.75 ) mask_con=3;
                if(Con_Lev > 0.25 && Con_Lev <0.75 ) mask_con=2;
//end of determination
      }
   }
// Test for thick smoke.
      if (tmp_mask != 4) tmp_mask=2;
   if (Refl_Chn1 > 0 && Refl_Chn2 > 0 && Refl_Chn3 > 0 && Refl_Chn7 > 0) {
      if (tmp_mask != 4) tmp_mask=3;
      if((Refl_Chn7*100.0) < SLNC21) {
         float64 Coeff = 6.0 + Refl_Chn7*100.0;
         if((Refl_Chn1*100.0) > Coeff) {
            float64 smkrat = Refl_Chn3/Refl_Chn1;
            if(smkrat >= SLNCRAT) {
               float64 vrat = Refl_Chn2/Refl_Chn1;
               if(vrat >= SLNCVRAT) {
                  float32 sigma1 = *(pABIData->spaStd1 + index2KM);
                  if(sigma1 <= SLNCSIG) {
                      tmp_mask=5;

//Determine confidence level
                float32 Con_Lev1 =ConfidenceLevel_L(Refl_Chn7*100.0, SLNC21);
                float32 Con_Lev2 =ConfidenceLevel_U(Refl_Chn1*100.0, Coeff);
                float32 Con_Lev3 =ConfidenceLevel_U( smkrat, SLNCRAT);
                float32 Con_Lev4 =ConfidenceLevel_U(  vrat, SLNCVRAT);
                float32 Con_Lev  =(Con_Lev1+Con_Lev2+Con_Lev3+Con_Lev4)/4.0;
                if(Con_Lev <=0.25 ) mask_con=1;
                if(Con_Lev >=0.75 ) mask_con=3;
                if(Con_Lev > 0.25 && Con_Lev <0.75 ) mask_con=2;
//end of determination
                  }
               }
            }
         }
      }
   }


} 

///////////////////////////////////////////////////////////////////////////
// NAME: void Class_ABI_ADP::dustMaskingLand
// FUNCTION: Peform dust detection over land 
// DESCRIPTION: Peform dust detection over land 
//              Dust  Value
//              0:  no dust detected.
//              1:  dust detected.
// REFERENCE: ATBD of ABI Aerosol Imagery Product (Version 0.1)
// CALLING SEQUENCE: dustMaskingLand(pABIData,index2KM,mask)
// INPUTS: 
//    STRUCT_ABI_DATA *pABIData - Pointer to the current processing data
//    int32 index2KM - Index of the data in 1-km resolution
// OUTPUTS: uint8 &mask - Reference to the masking flag
// DEPENDENCIES: none
// RESTRICTIONS: none
// HISTORY: none
//////////////////////////////////////////////////////////////////////////
void Class_ABI_ADP::dustMaskingLand(STRUCT_ABI_DATA *pABIData,
   int32 index2KM, uint8 &tmp_mask,uint8 &tmp_mask_ism,uint8 &tmp_mask_db,uint8 &mask_con)
 //    int32 index2KM, short &tmp_mask,short &tmp_mask_ism,short &tmp_mask_db,short &mask_con)
{
   int8 Cloud35_Bit09, Cloud35_Bit15, Cloud35_Bit16, Cloud35_Bit18, Cloud35_Bit19, Cloud35_Bit27;
   uint8 Snow_Ice;
   mask_con=1;
   float64 Refl_Chn1, Refl_Chn2, Refl_Chn3, Refl_Chn5,Refl_Chn26,Refl_Chn7,Refl_Chn8,Refl_Chn9; 
   float64 Refl_Chn1_db, Refl_Chn2_db, Refl_Chn3_db;
   float64 BrtTemp_Chn21, BrtTemp_Chn31, BrtTemp_Chn32;        
   float64 r1a3n, rndvin;
   float64 Refl_Chn8_Ray,Refl_Chn9_Ray;
   float64 Th20_Chn1_db,Th20_Chn2_db,Th20_Chn3_db;
   float64 TO3_Chn1_db,T03_Chn2_db,T03_Chn3_db;
   uint8 Thin_dust=0, Thk_dust=0;


/* Pass M?D35  9, 15, 18 Cloud Test */


    Cloud35_Bit09 = *(pABIData->pCLDMS_Bit09 + index2KM);
    Cloud35_Bit15 = *(pABIData->pCLDMS_Bit15 + index2KM);
    Cloud35_Bit18 = *(pABIData->pCLDMS_Bit18 + index2KM);
         Snow_Ice = *(pABIData->pSICMS       + index2KM);

   if ((Snow_Ice ==1)) {
     tmp_mask = 20;
     return;
     }
   
  /* Snow/ice test */

   Refl_Chn2 = *(pABIData->pREFB2 + index2KM);      //0.86um
   Refl_Chn5 = *(pABIData->pREFB6 + index2KM);      //1.61um
   BrtTemp_Chn31 = *(pABIData->pBTB31 + index2KM);  //11.um BT
          
   if ((Refl_Chn2 > 0.) && (Refl_Chn5 > 0.) && (BrtTemp_Chn31 > 0.)) {
      if ((((Refl_Chn2-Refl_Chn5)/(Refl_Chn2+Refl_Chn5) > ABI_LndSIndvi) &&
         (BrtTemp_Chn31 <= ABI_LndSIbt)))   {

         tmp_mask_ism = 26;

       }
   }

   if (( Cloud35_Bit09 ==1 ) ||( Cloud35_Bit15 ==1 ) || (Cloud35_Bit18 ==1 )) {
//   if (( Cloud35_Bit15 ==1 ) ||( Cloud35_Bit18 ==1 )  ) {
      tmp_mask = 11;
      return;
   }

 
   Refl_Chn1 = *(pABIData->pREFB1 + index2KM);   //0.66um
   Refl_Chn2 = *(pABIData->pREFB2 + index2KM);   //0.86um
   Refl_Chn3 = *(pABIData->pREFB3 + index2KM);   //0.47um
   Refl_Chn26 = *(pABIData->pREFB26 + index2KM);   //1.38um
   BrtTemp_Chn21 = *(pABIData->pBTB21 + index2KM);   //3.96um BT
   BrtTemp_Chn31 = *(pABIData->pBTB31 + index2KM);   //11.um BT
   BrtTemp_Chn32 = *(pABIData->pBTB32 + index2KM);   //12.um BT
// deep-blue detection
   Refl_Chn7 = *(pABIData->pREFB7 + index2KM);   //2.13um
   Refl_Chn8 = *(pABIData->pREFB8 + index2KM);   //0.41um (deep blue)
   Refl_Chn9 = *(pABIData->pREFB9 + index2KM);   //0.44um (deep blue)
// calculate rayleigh reflectance for deep channles

   float32  RelAzi = (*(pABIData->pSOLAZ + index2KM))- (*(pABIData->pSENAZ + index2KM));
   float32  CosSza = cos((*(pABIData->pSOLZA + index2KM)) * DEG2RAD);
   float32  CosVza = cos((*(pABIData->pSENZA + index2KM)) * DEG2RAD);
   float32  MolOD  = MOLOD_DB [0];
   Refl_Chn8_Ray = RayRefl(MolOD,CosSza,CosVza,RelAzi,0);
            MolOD  = MOLOD_DB [1];
   Refl_Chn9_Ray = RayRefl(MolOD,CosSza,CosVza,RelAzi,1);
   tmp_mask_db=12;
   if (Refl_Chn7 > 0 && Refl_Chn8 > 0 && Refl_Chn9 > 0 ){
      tmp_mask_db=13;
      float32 dbdi = -100.0 * (log10(Refl_Chn8/Refl_Chn9)-log10(Refl_Chn8_Ray/Refl_Chn9_Ray));
      float32 dbsc =  -10.0 * (log10(Refl_Chn8/Refl_Chn7));

//      if (dbdi >10.0 && dbsc > 0.0 ){

      if (dbdi >7.5 && dbsc > 1.3 ){
      tmp_mask_db=14;
      }
    }


// Dust detection start 
   tmp_mask=12;
   if (BrtTemp_Chn21 > 0 && BrtTemp_Chn31 > 0 && BrtTemp_Chn32 > 0 &&
      Refl_Chn3 > 0 && Refl_Chn2 > 0 && Refl_Chn1 > 0 && Refl_Chn26 > 0) {
      tmp_mask=13;
      float64 tdif1 = BrtTemp_Chn21 - BrtTemp_Chn31;
      float64 tdif2 = BrtTemp_Chn31 - BrtTemp_Chn32;
      float64 r1a3  = (Refl_Chn1-Refl_Chn3)/(Refl_Chn1+Refl_Chn3);
      r1a3n = (r1a3 * r1a3)/(Refl_Chn3 * Refl_Chn3);
      float64 rndvi = (Refl_Chn2 - Refl_Chn1)/(Refl_Chn2 + Refl_Chn1);
      rndvin = (rndvi * rndvi)/(Refl_Chn1 * Refl_Chn1);             
// Check 11-12um & 3.96-11um BTD & 1.38um Reflectance
      if(tdif2 <= DLNC11_12&& tdif1 >= DLNC39_11_1 && Refl_Chn26 < DLNC137_1 ) {
         if(rndvin < DLNCNDVIN_1 && r1a3n > DLNCNDVIN) 
         {
              tmp_mask=14;
//Determine confidence level
                float32 Con_Lev1 =ConfidenceLevel_L(tdif2, DLNC11_12);
                float32 Con_Lev2 =ConfidenceLevel_U(tdif1, DLNC39_11_1);
                float32 Con_Lev3 =ConfidenceLevel_L(Refl_Chn26, DLNC137_1);
//                float32 Con_Lev4 =ConfidenceLevel_L(rndvin, DLNCNDVIN_1);
//                float32 Con_Lev5 =ConfidenceLevel_U(r1a3n,  DLNCNDVIN);

                 float32 Con_Lev =(Con_Lev1+Con_Lev2+Con_Lev3)/3.0;
                if(Con_Lev <=0.33 ) mask_con=1;
                if(Con_Lev >=0.66 ) mask_con=3;
                if(Con_Lev > 0.33 && Con_Lev <0.66 ) mask_con=2;
//end of determination

         }
         else
         {
         if(tdif1 >= DLNC39_11_2) 
         {
              tmp_mask=14;
//Determine confidence level

                float32 Con_Lev1 =ConfidenceLevel_U(tdif1, DLNC39_11_2);
                float32 Con_Lev = Con_Lev1;
/*
                if(Con_Lev  == 0.0 ) mask_con=1;
                if(Con_Lev  == 1.0 ) mask_con=3;
                if(Con_Lev  == 0.5 ) mask_con=2;

                if( abs(Con_Lev) <1.e-6 ) int mask_con=1;
                if( abs(Con_Lev-0.5) <1.e-6 ) int mask_con=2;
                if( abs(Con_Lev-1.0) <1.e-6 ) int mask_con=3;

                if( abs(Con_Lev) <1.e-15 ) int mask_con=1;
                if( abs(Con_Lev-0.5) <1.e-15 ) int mask_con=2;
                if( abs(Con_Lev-1.0) <1.e-15 ) int mask_con=3;
*/
                if((int) Con_Lev == 0 ) mask_con=1;
                if((int) (Con_Lev*10) ==5 ) mask_con=2;
                if((int) (Con_Lev*10) ==10 ) mask_con=3;
//end of determination
         }
         }

// Thick Dust detection
      if(tdif2 < DLNC11_12 && tdif1 >= DLNC39_11_2 && Refl_Chn26 < DLNC137_2) {
         if(rndvin < DLNCNDVIN_2) {
              tmp_mask=15;

//Determine confidence level
                float32 Con_Lev1 =ConfidenceLevel_L(tdif2, DLNC11_12);
                float32 Con_Lev2 =ConfidenceLevel_U(tdif1, DLNC39_11_2);
//                float32 Con_Lev3 =ConfidenceLevel_L(Refl_Chn26, DLNC139_2);
//                float32 Con_Lev4 =ConfidenceLevel_L(rndvin, DLNCNDVIN_2);


                 float32 Con_Lev =(Con_Lev1+Con_Lev2)/2.0;
                if(Con_Lev <=0.25 ) mask_con=1;
                if(Con_Lev >=0.75 ) mask_con=3;
                if(Con_Lev > 0.25 && Con_Lev <0.75 ) mask_con=2;
//end of determination
         }
      }
    }
   }


} 


///////////////////////////////////////////////////////////////////////////
// NAME:  void Class_ABI_ADP::readABIScanData
// FUNCTION: Read ABI Scan line input data
// DESCRIPTION: Read ABI Scan line input data
// REFERENCE: 
// CALLING SEQUENCE: readABIScanData(fid_input,sds_name,start,edge,pBuffer)
// INPUTS: 
//     int32 fid_input - Id of the input HDF file
//     char *sds_name - name of the SDS  parameter in the file
//     int32 *start - Pointer to the start position of SDS parameter data
//     int32 *edge - Pointer to the end position of SDS parameter data
// OUTPUTS: void*pBuffer - Pointer to the output ABI data
// DEPENDENCIES: none
// RESTRICTIONS: none
// HISTORY: none
//////////////////////////////////////////////////////////////////////////
void Class_ABI_ADP::readABIScanData(int32 fid_input, char *sds_name,
   int32 *start, int32 *edge, void*pBuffer)
{
   printf(" read '%s'\n", sds_name);


   int32 index= SDnametoindex(fid_input, sds_name);
   int32    sds_id = SDselect(fid_input, index);
   SDreaddata(sds_id, start, NULL, edge, pBuffer);
   
   SDendaccess(sds_id);  
}

///////////////////////////////////////////////////////////////////////////
// NAME: void Class_ABI_ADP::create_ADP_file
// FUNCTION: Produce output for cloud mask and smoke and dust detection
// DESCRIPTION: Produce output for cloud mask and smoke and dust detection
// REFERENCE:                                                        
// CALLING SEQUENCE: create_ADP_file(ADPfile,outputFileType,gd)
// INPUTS:
//     char *ADPfile - Pointer to the name of output cloud mask file
//     int outputFileType - Type of output cloud mask file:
//                          (Linux or Unix: 1 or Window: 0)
//     ABI_GranuleData& gd - reference of ABI_GranuleData
// OUTPUTS: char *ADPfile - Pointer to the output cloud mask file
// DEPENDENCIES:
//         Subroutines: readABIScanData, process2kmADP
// RESTRICTIONS: none
// HISTORY: none
//////////////////////////////////////////////////////////////////////////
void Class_ABI_ADP::create_ADP_file(char *ADPfile, int outputFileType,
   ABI_GranuleData& gd)
{
   //cout<<"021KM_index---"<<gd.get021KM_index()<<endl;
   //cout<<"03_index---"<<gd.get03_index()<<endl;
   char ADP_SWname[20]="ABI_ADP_IP";
   char ADP_SDname[20]="ABI ADP MASK IP";
   char IP_SDname3Flag[20]="ABI ADP Flags"; // 8 flags
// THE 8 FLAGS ARE:
//   cloud mask, snow/ice mask, sunglint mask, land/water mask, day/night mask, Aerosol flag, smoke flag, dust flag 
//
//tets 
   char IP_SDname3Flag_qual[25]="ABI ADP Quality Flags"; // Qualityflags for ADP algorithm
//test
   int32 fid  = HDF_SWopen(ADPfile, DFACC_CREATE);
   int32 swid = HDF_SWcreate(fid, ADP_SWname);
   int32 stat;

   int32 altrack=gd.m_nPixTrack_2KM;      //2040 or 2030 or 856 for wrf_chem
   int32 alscan=gd.m_nPixScan_2KM;        //1354 OR 1252 FRO wrf_chem
   // Define Dimensions
   HDF_SWdefdim(swid,"BYTES_OF_ADP_MASK",	4);
   HDF_SWdefdim(swid,"BYTES_OF_QUALFLAGS",      5);
   HDF_SWdefdim(swid,"Along_Track",	altrack);
   HDF_SWdefdim(swid,"Along_Scan",	alscan);

   char str[STRMAX];
   strcpy(str,"V");
   double value=0.0;

   //; Define Geofield.
   char dimlist[STRMAX]="Along_Track,Along_Scan";
   stat = SWdefgeofield(swid, "Latitude", dimlist, DFNT_FLOAT32, HDFE_NOMERGE);
   stat = SWdefgeofield(swid, "Longitude", dimlist,DFNT_FLOAT32, HDFE_NOMERGE);

   //; Define Output Data Field.
   stat = SWdefdatafield(swid, IP_SDname3Flag,
      "BYTES_OF_ADP_MASK,Along_Track,Along_Scan", DFNT_UINT8 , HDFE_NOMERGE);

   stat = SWdefdatafield(swid, IP_SDname3Flag_qual,
      "BYTES_OF_QUALFLAGS,Along_Track,Along_Scan", DFNT_UINT8, HDFE_NOMERGE);


   HDF_SWdetach(swid);
   HDF_SWclose(fid);

   fid = SDstart(ADPfile, DFACC_RDWR);
   HDF_setSDSattributes(fid, IP_SDname3Flag,
      "aerosol,smoke,dust,dust_db");
    
   SDend(fid);

   fid  = HDF_SWopen(ADPfile, DFACC_RDWR);
   swid = HDF_SWattach(fid, ADP_SWname);
   //cout<<"021KM_index---"<<gd.get021KM_index()<<endl;
	
   //write CM (8*2016*1354 uint8) 
   process2kmADP(gd, swid, ADP_SDname,altrack, outputFileType);

   printf(" write SDS: '%s'\n", ADP_SDname);

   HDF_SWdetach(swid);
   HDF_SWclose(fid);
}

///////////////////////////////////////////////////////////////////////////
// NAME: void Class_ABI_ADP::process2kmADP
// FUNCTION: Initiate the cloud mask processing and smoke and dust detection
// DESCRIPTION: This is the core part of the detection algorithm.
//              First, cloud mask was claculated on 2KM grid using the same
//              algorithm as in ABI_unitData.cpp.
//              Second, perform smoke and dust detections.
//              Last, set cloud mask and smoke, dust flags (6 bytes) which 
//              is in 2KM grid.
// REFERENCE: none                                               
// CALLING SEQUENCE: process2kmADP(gd,swid,ADP_SDname,output_lines,outputFileType)
// INPUTS: gd - reference of ABI_GranuleData
// OUTPUTS: Updated struct data member:
//          ADP:   ADP data struct (STRUCT_ADP)
// DEPENDENCIES: 
//     Subroutines:
//               allocateRAMforBuffer, readScanDataToBuffer,
//               spatialVaribityTests, spatialMeanStd
//               smokeMaskingLand, dustMaskingLand, smokeMaskingOcean, dustMaskingOcean,
//               HDF_SWwritefield
// RESTRICTIONS: none
// HISTORY: none
//////////////////////////////////////////////////////////////////////////
void Class_ABI_ADP::process2kmADP(ABI_GranuleData& gd, int32 swid,
   char *ADP_SDname, int32 output_lines, int outputFileType)
{
   uint8 Temp_Byte=255;
   int32 ADP_index, i_index, j_index, k_index;
   int32 flag_index;
   //process cloud masking
   int nPixScan2km = gd.m_nPixScan_2KM;
   int nRowsPerScan2km = ABI_LINES_PER_SCAN_2KM;

   //int pix_index=0;

//   int nRowsPerScan2km = 1;
//   int nPixScan5km = gd.m_nPixScan_2KM/5;
//   int MaxScansPerBlock = 1;
   int MaxScansPerBlock =ABI_LINES_PER_SCAN_2KM;	 

   gd.allocateRAMforBuffer(MaxScansPerBlock);

   STRUCT_ABI_DATA *pABIData = &gd.m_ABIData;


   time_t time_begin= time(NULL);
   int32 field_size = nRowsPerScan2km * nPixScan2km * MaxScansPerBlock;
  
   /* allocate memory for ADP (result)    */
   STRUCT_ADP ADP;
   uint8 *pCM0 = (uint8 *) malloc(field_size * 4);  //for ADP byte 0
   uint8 **pADP= (uint8 **) &ADP;

   //short *pCM0 = (short *) malloc(field_size * 4);  //for ADP byte 0
   //short **pADP= (short **) &ADP;

   for (ADP_index=0; ADP_index< 4; ADP_index++ ) {
      pADP[ADP_index]= pCM0 + field_size *ADP_index;
   }

   /* allocate memory for Quality flags (result)    */
   STRUCT_QUALITYDATA Qual_Flag;
   uint8 *pqual0 = (uint8 *) malloc(field_size * 5);  //for ADP quality flags byte 0
   uint8 **pqual= (uint8 **) &Qual_Flag;

   for (flag_index=0; flag_index< 5; flag_index++ ) {
      pqual[flag_index]= pqual0 + field_size *flag_index;
   }



// OUTPUT INPUT DATA STRUCTURE

   uint8 *pIsLand;

   int total_scans = gd.m_nPixTrack_2KM/ABI_LINES_PER_SCAN_2KM;

   int NBlocks= total_scans/ MaxScansPerBlock;
   if( total_scans % MaxScansPerBlock != 0) NBlocks++;


   int32  index2KM, index5KM;
   float32 absCorRefl[7];  // Atmopheric absorption corrected reflectance
                           // for 1 point of 500m

   for (int iBlock=0; iBlock<NBlocks; iBlock++) {//loop for each scan block
   //for (int iBlock=0; iBlock < 1; iBlock++) {
      time_t time1= time(NULL);

      /* read scan data of NScansPerBlock scans
         ( NScansPerBlock*ABI_LINES_PER_SCAN_2KM lines for 2KM data) */

      int scanStart = iBlock * MaxScansPerBlock;
      int scanEnd = scanStart+ MaxScansPerBlock-1;
      if(scanEnd >= (total_scans-1)) scanEnd = total_scans-1;

      memset(pCM0,0,field_size*4);
      memset(pqual0,0,field_size*5);

      gd.readScanDataToBuffer(scanStart, scanEnd);

      printf(" Read scans= [%d, %d] \n",scanStart,  scanEnd);
      /* perfrom spatial varibility test on reflectance at Band3 (0.47um) */

//      spatialVaribityTests(gd);

      /* perform spatial average on reflectance at Band1 (0.66um)
        (land smoke); Band 2 (0.86um) (ocean dust), and on BT at Band31
        (11um) (land dust) used for smoke and dust detection. */

      spatialMeanStd(gd);
   
      pIsLand = pABIData->pLSMSK;
         
      float32 **pMdata= (float32 **)&gd.m_ABIData;

      for (i_index=0; i_index< gd.m_linesInBuffer_2KM; i_index++){	
         for (j_index=0; j_index< gd.m_nPixScan_2KM; j_index++){
            index2KM = i_index * nPixScan2km +j_index; // index of 2KM data
//            for(int k_index=0; k_index<7; k_index++){
//               float temp = absCorRefl[k_index] ;
//               gd.m_count_REFL[3][k_index]++;
//               if(temp >0 && temp <1 ) gd.m_count_REFL[2][k_index]++;
//            }
//Initilization  
            uint8 mask=0;
            uint8 mask_ism=0;
            uint8 mask_db=0;
            uint8 mask_c=0;
            /*short mask=0;
            short mask_ism=0;
            short mask_db=0;
            short mask_c=0;*/

            float32 SunGlintA=Missing_Value;        
// calculating sunglint angle 
            float32 SOLZA = pABIData->pSOLZA[index2KM];
            float32 SENZA = pABIData->pSENZA[index2KM];
            float32 SOLAZ = pABIData->pSOLAZ[index2KM];
            float32 SENAZ = pABIData->pSENAZ[index2KM];

            SunGlintA = SunGlintAng(SOLZA, SENZA, SOLAZ, SENAZ);
           
//            ADP.sungt[index2KM]=0;
//            if ( SunGlintA < ABI_SunGlint ) {
//            ADP.sungt[index2KM]=1; 
//            }
            /*if (pix_index == 25363 || pix_index == 25364 || pix_index == 25365)
            {
               cout<<"---------------------------------"<<endl;
               cout<<"lat= "<<*(pABIData->pLATGD + index2KM)<<endl;
               cout<<"lon= "<<*(pABIData->pLONGD + index2KM)<<endl;
               //cout<<"lat= "<<(pABIData->pLATGD[index2KM])<<endl;
               //cout<<"lon= "<<(pABIData->pLONGD[index2KM])<<endl;
               //cout<<"masks= "<<mask<<","<<mask_db<<","<<mask_c<<endl;
               //printf("masks= %d %d %d\n", mask, mask_db, mask_c);
            }*/
//set product quality information:sunglint mask (0 -no, 1 -yes)
            if (SunGlintA > 0.0 && SunGlintA < ABI_SunGlint  ) {

                Qual_Flag.Byte3[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte3[index2KM], 2);
//sunglint source
                Qual_Flag.Byte2[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte2[index2KM], 1);
                } 
//land/sea mask from input (0 - water, 1 - land)
//            ADP.lndwat[index2KM]=pABIData->pLSMSK[index2KM];
//set product quality information: land/water flag
            if (*(pABIData->pLSMSK + index2KM) ==1 ) {

                Qual_Flag.Byte3[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte3[index2KM], 3);

                }
//day/night defined by solar zenith angle
 // product quality information: day/night 1 -night 0- day
            if (SOLZA > 87.0) {

//                ADP.day[index2KM]=1;
                Qual_Flag.Byte3[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte3[index2KM], 4);

               continue;
//jump out the process for this pixel.
               } 
            
//* set product quality information: input quality (0 -good  1- bad)

            if (*(pABIData->pLONGD + index2KM) >180 || *(pABIData->pLONGD + index2KM) <-180) {

                Qual_Flag.Byte2[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte2[index2KM], 1);

               continue;
               } 
            if (*(pABIData->pLATGD + index2KM) >90 || *(pABIData->pLATGD + index2KM) <-90) {

                Qual_Flag.Byte2[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte2[index2KM], 2);
               
               continue;
               }

            if (*(pABIData->pSOLZA + index2KM) <0 || *(pABIData->pSOLZA + index2KM) > 90) {

                Qual_Flag.Byte2[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte2[index2KM], 4);

               continue;
               }

            if (*(pABIData->pSOLZA + index2KM) >60 && *(pABIData->pSOLZA + index2KM) <= 90) {


                Qual_Flag.Byte2[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte2[index2KM], 3);
                Qual_Flag.Byte2[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte2[index2KM], 4);
               }

            if (*(pABIData->pSENZA + index2KM) <0 || *(pABIData->pSENZA + index2KM) > 90) {


                Qual_Flag.Byte2[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte2[index2KM], 6);
 
              continue;

               }

            if (*(pABIData->pSENZA + index2KM) >60 && *(pABIData->pSENZA + index2KM) <= 90) {


                Qual_Flag.Byte2[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte2[index2KM], 5);
                Qual_Flag.Byte2[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte2[index2KM], 6);

               }




//* set product quality information:  input source: (fix me later)

   //SNOW/ICE MASK

          /*if (CASE 1:from IMS) {
               Qual_Flag.Byte2[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte2[index2KM], 8);
               } */



            if (*(pIsLand + index2KM) == 1) { 	/* Land process */
                

               /* Smoke detection */
               smokeMaskingLand(pABIData, index2KM, mask,mask_ism,mask_c);

//quality flag: snow/ice source (00: from ABI mask;  01:from IMS mask ; 11 from internal mask)
              if (mask_ism == 16 ) {

                Qual_Flag.Byte2[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte2[index2KM], 7);
                Qual_Flag.Byte2[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte2[index2KM], 8);

               }

               if (mask == 2 ) {

// set production quality information: input data

               Qual_Flag.Byte4[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte4[index2KM], 5);

               }

//set quality flag: smoke over land
//determination flag (0 determined 1-not determined)

               if (mask == 2 || mask==10 ||mask==1 ) {

               Qual_Flag.Byte1[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte1[index2KM], 1);

               }

// set production quality information: clouds
               if (mask == 1 ) {

               Qual_Flag.Byte4[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte4[index2KM], 6);

               }

//set production quality information: snow/ice mask
//               if(mask_snow == 5 || mask_snow == 6){

//               Qual_Flag.Byte4[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte4[index2KM], 7);

//               }
               if(mask == 10 ){

               Qual_Flag.Byte4[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte4[index2KM], 7);

               }

               if(mask_ism == 16 && mask != 1){

               Qual_Flag.Byte4[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte4[index2KM], 7);

               }

//set production quality information: smoke type
               if(mask == 5 ) {

               Qual_Flag.Byte4[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte4[index2KM], 8);

               }

// confidence flag for smoke
             if(mask_c ==2 ) {

               Qual_Flag.Byte1[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte1[index2KM], 4);

               }

              if(mask_c ==3 ) {

               Qual_Flag.Byte1[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte1[index2KM], 3);
               Qual_Flag.Byte1[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte1[index2KM], 4);

               }

                
//
//               if(mask ==  1 ) ADP.cldmsk[index2KM] =1;
               if (mask == 4 || mask ==5 ) ADP.smoke[index2KM] =1;
//               if(mask_snow == 5 || mask_snow == 6) ADP.snowice[index2KM]=1;
               if (mask == 4 || mask ==5 ) ADP.aerosol[index2KM] =1; 

               /* Dust detection */
               dustMaskingLand(pABIData, index2KM, mask,mask_ism,mask_db,mask_c);

               if (mask == 12) {

// set production quality information: input data

               Qual_Flag.Byte5[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte5[index2KM], 1);

               }

//set qulaity flag: dust over land
//determination flag (0 determined 1-not determined)

               if (mask == 12 || mask==20 || mask == 11   ) {


               Qual_Flag.Byte1[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte1[index2KM], 2);


               }
//
// set production quality information: clouds
               if (mask == 11 ) {

               Qual_Flag.Byte5[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte5[index2KM], 2);

               }
// set production quality information: snow/ice
//               if(mask_snow == 5 || mask_snow == 6){
//
//               Qual_Flag.Byte5[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte5[index2KM], 3);

//              }
//quality flag: snow/ice source 
              if (mask_ism == 26 ) {

                Qual_Flag.Byte2[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte2[index2KM], 7);
                Qual_Flag.Byte2[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte2[index2KM], 8);

               }


               if(mask == 20 ){

               Qual_Flag.Byte5[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte5[index2KM], 3);

               }

               if( mask_ism  == 26 && mask !=11){

               Qual_Flag.Byte5[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte5[index2KM], 3);

               }



// set production quality information: dust type

               if(mask == 15 ) {

               Qual_Flag.Byte5[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte5[index2KM], 4);

               }
// confidence flag for dust
             if(mask_c == 2 ) {

               Qual_Flag.Byte1[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte1[index2KM], 6);

               }

              if(mask_c == 3 ) {

               Qual_Flag.Byte1[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte1[index2KM], 5);
               Qual_Flag.Byte1[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte1[index2KM], 6);

               }

//
//               if(mask == 11 ) ADP.cldmsk[index2KM] =1;
               if(mask_db == 14           ) ADP.dust_db[index2KM] =1;
               if(mask == 14 || mask ==15 ) ADP.dust[index2KM] =1;
               if(mask == 14 || mask ==15 ) ADP.aerosol[index2KM] =1;
//               if(mask_snow == 5 || mask_snow == 6) ADP.snowice[index2KM]=1;

               /*if (pix_index == 25363 || pix_index == 25364 || pix_index == 25365)
                   cout<<" Land----"<<endl;*/

            }else { 				/* Ocean process */

               /* Smoke detection */
               smokeMaskingOcean(pABIData, index2KM, mask,mask_c);

//set quality flag: smoke over water
//determination flag (0 determined 1-not determined)
               /*if (pix_index == 25363 || pix_index == 25364 || pix_index == 25365)
                  //cout<<"smoke mask = "<<mask<<endl;
                  printf("smoke mask = %d\n", mask);*/

               if (mask == 2) {
// set production quality information: input data
               Qual_Flag.Byte3[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte3[index2KM], 5);
               }

               if (mask == 2 || mask==10 ||mask==1 ) {

               Qual_Flag.Byte1[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte1[index2KM], 1);

               }


// set production quality information: cloud

               if (mask == 1 ) {

              Qual_Flag.Byte3[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte3[index2KM], 6);

               }

// set production quality information: snow/ice

               if(mask == 10 ){

               Qual_Flag.Byte3[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte3[index2KM], 7);

               }

// set production quality information: smoke type
               if(mask == 5 ) {

               Qual_Flag.Byte3[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte3[index2KM], 8);

               }
// confidence flag for smoke
             if(mask_c ==2 ) {

               Qual_Flag.Byte1[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte1[index2KM], 4);

               }

              if(mask_c ==3 ) {

               Qual_Flag.Byte1[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte1[index2KM], 3);
               Qual_Flag.Byte1[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte1[index2KM], 4);

               }

//
               if((mask == 4 || mask == 5)) ADP.smoke[index2KM] =1;
               if((mask == 4 || mask == 5)) ADP.aerosol[index2KM] =1;
//               if ( ASP.sungt[index2KM] == 1 &&  mask == 4 ) ADP.smoke[index2KM] =0;
//               if(mask == 1 ) ADP.cldmsk[index2KM] =1;

               /* Dust detection */
               dustMaskingOcean(pABIData, index2KM, mask,mask_db,mask_c);

               /*if (pix_index == 25363 || pix_index == 25364 || pix_index == 25365)
               {
                   printf("dusk mask = %d\n", mask);//cout<<"dust mask = "<< mask <<endl;
                   printf("DB dusk mask = %d\n", mask_db);//cout<<"DB dust mask = "<< mask_db <<endl;

                   printf("Cloud35_Bit15= %d\n",*(pABIData->pCLDMS_Bit15 + index2KM));
                   printf("Cloud35_Bit18= %d\n",*(pABIData->pCLDMS_Bit18 + index2KM));
               }*/

               if (mask == 12 ) {

// set production quality information: input data

               Qual_Flag.Byte4[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte4[index2KM], 1);

              }

//set qulaity flag: dust over water
//determination flag (0 determined 1-not determined)

               if ( mask == 12 || mask == 20 || mask == 11  ) {


              
               Qual_Flag.Byte1[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte1[index2KM], 2);

               }

//set production quality information: cloud

               if ( mask == 11 ) {

               Qual_Flag.Byte4[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte4[index2KM], 2);

               }
//set production quality information: snow/ice

               if( mask == 20 ){

               Qual_Flag.Byte4[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte4[index2KM], 3);
              
               }

//set production quality information: dust type

               if( mask == 15 ) {

               Qual_Flag.Byte4[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte4[index2KM], 4);

               }
// confidence flag for dust
             if(mask_c ==2 ) {

               Qual_Flag.Byte1[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte1[index2KM], 6);

               }

              if(mask_c ==3 ) {

               Qual_Flag.Byte1[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte1[index2KM], 5);
               Qual_Flag.Byte1[index2KM]= Set_QualityFlag_bit(Qual_Flag.Byte1[index2KM], 6);

               }

               //if (pix_index == 25363)
               //   cout<<"DB dust mask = "<<mask_db<<endl;

               if(mask_db == 14           ) ADP.dust_db[index2KM] =1;
               if((mask == 14 || mask ==15)) ADP.dust[index2KM] =1;
               if((mask == 14 || mask ==15)) ADP.aerosol[index2KM] =1;
//think about it??
//               if ( sunglint== 1 &&  mask ==14) ADP.dust[index2KM] =0;

//               if(mask == 11 ) ADP.cldmsk[index2KM] =1;
              /*if (pix_index == 25363)
              {
                  cout<<" Ocean----"<<endl;
                  printf("dust mask = %d\n", ADP.dust[index2KM] );
                  printf("DB dust mask = %d\n", ADP.dust_db[index2KM]);
                  //cout<<"dust mask = "<< (int) ADP.dust[index2KM] <<endl;
                  //cout<<"DB dust mask = "<< (int) ADP.dust_db[index2KM] <<endl;

              }*/
            }

            //pix_index++;

         }//j_index
      }//i_index

     //for each pixel in 2km, process CM 
      int32 NP= gd.m_linesInBuffer_2KM * nPixScan2km;  
      int32 start2d[2]={0,0};         
      int32 start3d[3] = {0,0,0};
      int nx= nPixScan2km;
      int ny= (scanEnd- scanStart +1) * nRowsPerScan2km;
//      int ny= (scanEnd- scanStart +1);
       
      int32 edge3d[3] ={1,ny,nx};
      int32 edge2d[2] ={ny,nx};
      start3d[1]= scanStart * nRowsPerScan2km- m_skipLines;
      start2d[0]= scanStart * nRowsPerScan2km- m_skipLines;
      if(iBlock == 0)  start3d[1]=0;
      if(iBlock == 0)  start2d[0]=0;
      int32 pos_skipped= (iBlock == 0) ? (m_skipLines * nPixScan2km) : 0;
      if(iBlock == 0)  edge3d[1]= ny - m_skipLines;
      if(iBlock == 0)  edge2d[0]= ny - m_skipLines;
      if(iBlock == NBlocks-1) edge3d[1]=  
         output_lines - scanStart * nRowsPerScan2km + m_skipLines;
      if(iBlock == NBlocks-1) edge2d[0]=
         output_lines - scanStart * nRowsPerScan2km + m_skipLines;


   // Write Geodata field.
 
      char *input_sd_name[] = {"lat", "lon"};
      char *output_sd_name[] = {"Latitude", "Longitude"};


      HDF_SWwritefield(swid, output_sd_name[0], start2d, NULL, edge2d,pABIData->pLATGD+pos_skipped);
      printf(" write SDS: '%s'\n", output_sd_name[0]);
      HDF_SWwritefield(swid, output_sd_name[1], start2d, NULL, edge2d,pABIData->pLONGD+pos_skipped);
      printf(" write SDS: '%s'\n", output_sd_name[1]);



      // 3 flag from ABI algorithm 
      char IP_SDname3Flag[20]="ABI ADP Flags";
      char IP_SDname3Flag_qual[25]="ABI ADP Quality Flags";


      /* the SDS "ABI ADP Flags" contains:
       aerosol flag, smoke flsg,dust flag
      */
      //  one byte per variable 
      for (k_index=0; k_index< 4; k_index++){
         start3d[0]= k_index;
         HDF_SWwritefield(swid, IP_SDname3Flag, start3d, NULL,
             edge3d,pADP[k_index]+pos_skipped);
          }

      /* the SDS "ABI ADP Quality Flags" contains various quality flgas as shown in Table 1 in ATBD*/
      //  one byte per variable
      for (k_index=0; k_index< 5; k_index++){
         start3d[0]= k_index;
         HDF_SWwritefield(swid, IP_SDname3Flag_qual, start3d, NULL,
             edge3d,pqual[k_index]+pos_skipped);
          }

      time_t time_end=time(NULL);
//how much time used to read data
      int seconds_used = int(difftime( time_end , time_begin));
		  
      printf(" used% d seconds,  estimated total time= %5.2f minutes\n", 
         seconds_used,  
         (double(time_end - time_begin)/(iBlock+1) * NBlocks /60 ));

   }

   free(pqual0);
   free(pCM0);	
}

///////////////////////////////////////////////////////////////////////////
// NAME: void Class_ABI_ADP::read_ABI_ADP_configFile
// FUNCTION: Read input configuration file.
// DESCRIPTION: Read input configuration file.
// REFERENCE:                                                     
// CALLING SEQUENCE: read_ABI_ADP_configFile(configFname)
// INPUTS:  char *configFname - Pointer to the configuration file
// OUTPUTS: none
// DEPENDENCIES: 
//     Subroutine
//            getTextFileContent, getTagValue
// RESTRICTIONS: none
// HISTORY: none
//////////////////////////////////////////////////////////////////////////
void Class_ABI_ADP::read_ABI_ADP_configFile(char *configFname)
{

   char *strConfig = getTextFileContent(configFname);

   if (VERBOSE > 0 ) printf("    Read config file: '%s'.\n", configFname );

   char tempstring[STRMAX];

   
   getTagValue(strConfig,  "MODIS_data_folder",	tempstring);
   strcpy(m_Config.MODIS_data_folder , (strcmp(tempstring, "") == 0  )? "./" :
      tempstring);

   getTagValue(strConfig,  "output_ADP_folder",	tempstring);
   strcpy(m_Config.output_ADP_folder,(strcmp(tempstring, "") == 0  )? "./" :
      tempstring);


   free(strConfig);
    
}