l1c.cpp

Go to the documentation of this file.

 
//  Created by Martin Montes on 10/26/20.
//latest update 3/7/2022
//****************************************************8
#include "l1c.h"
#include "l1c_filehandle.h"
#include "l1c_input.h"
#include "l1c_str.h"
#include "l2_str.h"
#include <string>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <list>
#include <stack>
#include <vector>
#include <iostream>
#include <fstream>
#include <sstream>
#include <netcdf.h>
#include <nc4utils.h>
#include "hawkeye_methods.h"
#include "allocate4d.h"
#include <allocate3d.h>
#include <allocate2d.h>
#include <algorithm> 
#include <bits/stdc++.h>
#include <cstdlib>
#include <ctime>
#include <chrono>
#include <GeographicLib/Geodesic.hpp>
#include <GeographicLib/Constants.hpp>
#include <timeutils.h>
#include <genutils.h>
#include <stdint.h>
#include "l2prod.h"
 
 
 
static size_t INPIX,TOTPIX,OUTPIX;
static size_t num_scans, num_pixels,num_frames,nviews;
static size_t num_blue_bands, num_red_bands, num_SWIR_bands;
static int ncid_L1B,ncid_L2,ncid_L1A;
 
// scan line attributes
//static double* scan_time; // seconds of day
//static int16_t scan_time_year, scan_time_month, scan_time_day, scan_time_hour, scan_time_min;
//static double scan_time_secs;
 
//Navigation data
static int navGrp, scGrp, geoGrp, obsGrp;
static int ovId, opId, otId, latId, lonId, solzId, Lt_blueId, Lt_redId, Lt_SWIRId,I_Id,Ipol_Id,frameId;
static float** lat, ** lon;
static short** solz;
static float degrad = M_PI / 180, Re = 6378.137;//Re earth radius in km at equator
//static float *orbp;
//static float *attang;
//static double *timeArr;
 
//L1C vars
static int16_t nswath, nswtfiles, ndswaths;
 
 
using namespace std;
using namespace boost::assign;
using namespace std::chrono;
using namespace GeographicLib;
 
 
namespace bg = boost::geometry;
typedef bg::model::point<double, 2, bg::cs::geographic<bg::degree>> Point_t;
typedef bg::model::polygon<Point_t> Polygon_t;
typedef bg::model::box<Point_t> Box_t;
 
 
namespace l1c {
 
 
    L1C::L1C() {
    }
 
 
    L1C::~L1C() {
    }
 
 
//function to calculate cross product of two vectors, 3 components each vector
   void cross_product_double(double vector_a[], double vector_b[], double temp[]) {
        temp[0] = vector_a[1] * vector_b[2] - vector_a[2] * vector_b[1];
        temp[1] = -(vector_a[0] * vector_b[2] - vector_a[2] * vector_b[0]);
        temp[2] = vector_a[0] * vector_b[1] - vector_a[1] * vector_b[0];
        }
 
    double cross_product_norm_double(double vector_a[], double vector_b[]) {
        double temp[3],nvec;
        temp[0] = vector_a[1] * vector_b[2] - vector_a[2] * vector_b[1];
        temp[1] = -(vector_a[0] * vector_b[2] - vector_a[2] * vector_b[0]);
        temp[2] = vector_a[0] * vector_b[1] - vector_a[1] * vector_b[0];
         
        nvec=sqrt(temp[0]*temp[0]+temp[1]*temp[1]+temp[2]*temp[2]);
        return nvec;
        }
 
 
 
int32_t L1C::azmean_swt2(int swt,L1C_input *l1cinput,l1c_filehandle *l1cfile,float *lati,float *loni){
  float az,lat1_l,lat2,lon1_l,lon2,dlambda,az_r;
  float sum=0,tot=0;
  int32_t num_gridlines=-1;
  size_t azc=0;
 
 
   num_gridlines = l1cfile->num_gridlines;
 
  
     for (int i = 0;i < num_gridlines-1;i++) {
        if(lati[i]>=-10. && lati[i]<=10.){
            //assign central positions---
            lat1_l = lati[i] * M_PI / 180.;
            lat2 = lati[i + 1] * M_PI / 180.;
            lon1_l = loni[i] * M_PI / 180.;
            lon2 = loni[i + 1] * M_PI / 180.;
            dlambda = (lon2 - lon1_l);
            //bearing---
            //make sure there are not NAN values ----------
            az = atan2(sin(dlambda) * cos(lat2), cos(lat1_l) * sin(lat2) - sin(lat1_l) * cos(lat2) * cos(dlambda));//this is the satellite track bearing in radians
 
         //   cout<<"gd#..."<<i+1<<"az..track bearing with respdct to north"<<az<<"lati.."<<lat1_l<<endl;
          //  cout<<az*180/M_PI<<endl;
 
            if (az > M_PI | az < -M_PI) {
                cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "az in degrees.." << az * 180 / M_PI << endl;
                exit(1);
                    }
            if (isnan(az) < 1) {
                az_r = (az + M_PI / 2.);
                sum = az_r * 180. / M_PI;
                if (sum < 0.0001 && sum>0) sum = 0.0;
                tot += sum;
                azc++;
                 }
            else {
                sum = NAN;
                  }
  
              }
 
           }
 
        float mean_az_east = tot / (azc);
 
        cout << "mean_az_east.." << mean_az_east << "numgridlines.." <<num_gridlines<< endl;
 
        l1cfile->mean_az_east = mean_az_east;
 
    return 0;
}
 
 
 
 
int32_t L1C::azmean_swt(int swt,L1C_input *l1cinput,l1c_filehandle *l1cfile,float *lati,float *loni){
  float az,lat1_l,lat2,lon1_l,lon2,dlambda,az_r;
  float sum=0,tot=0;
  int32_t num_gridlines=-1;
  size_t azc=0;
 
 
   num_gridlines = l1cfile->num_gridlines;
 
 
     for (int i = 0;i < num_gridlines - 1;i++) {
         
            //assign central positions---
            lat1_l = lati[i] * M_PI / 180.;
            lat2 = lati[i + 1] * M_PI / 180.;
            lon1_l = loni[i] * M_PI / 180.;
            lon2 = loni[i + 1] * M_PI / 180.;
            dlambda = (lon2 - lon1_l);
            //bearing---
            //make sure there are not NAN values ----------
            az = atan2(sin(dlambda) * cos(lat2), cos(lat1_l) * sin(lat2) - sin(lat1_l) * cos(lat2) * cos(dlambda));//this is the satellite track bearing in radians
 
         //   cout<<"gd#..."<<i+1<<"az..track bearing with respdct to north"<<az<<"lati.."<<lat1_l<<endl;
          //  cout<<az*180/M_PI<<endl;
 
            if (az > M_PI | az < -M_PI) {
                cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "az in degrees.." << az * 180 / M_PI << endl;
                exit(1);
                    }
            if (isnan(az) < 1) {         
                az_r = (az + M_PI / 2.);
                sum = az_r * 180. / M_PI;
                if (sum < 0.0001 && sum>0) sum = 0.0;
                tot += sum;
                azc++;
                 }
            else {
                sum = NAN;
                  }
           }
        float mean_az_east = tot / (azc);
 
        cout << "mean_az_east.." << mean_az_east << "numgridlines-1.." <<num_gridlines-1<< endl;
 
        l1cfile->mean_az_east = mean_az_east;  
 
    
    return 0;
}
 
 
 
int32_t L1C::swtime_swt2(int swt,L1C_input *l1cinput,l1c_filehandle *l1cfile,int32_t norbs,double *tswt,double tcross,double mgv,double *tmgv){
  int16_t bina=0,binb=0,ix=-1,ngridlines,gd=0;
  double tg=0.,mot=0.,tini=0.,tend=0.;
//  double dtime;
//  int asc_mode=-1;
 
 
  mot = ((l1cinput->gres) * 1000) /mgv;//in seconds
 // asc_mode=l1cfile->orb_dir;
  ngridlines=l1cfile->num_gridlines;
//  ngridlines=l1cfile->num_gridlines;
  tini=tswt[0];
  ix=norbs-1;
  tend=tswt[ix];
 
//  dtime=tswt[0]-tcross;//relative time qith respect to equator
 
 
       cout<<"mgv.."<<mgv<<"tini.."<<tini<<"tend.."<<tend<<"tcross..."<<tcross<<endl;
        int flag_time=-1;
 
    if (tcross > 0.0) {
          flag_time=0;
          cout<<"computing time series assuming mean swath velocity..for swath#."<<swt<<endl;
 
         tg = tcross - mot / 2;          
         gd=ngridlines/2-1;
         tmgv[gd]=tg;
         binb=1;
 
         while(binb<ngridlines/2){
             binb++;
             tg -= mot;
             gd--;
             tmgv[gd]=tg;
         }
         tg = tcross + mot / 2;
         gd=ngridlines/2;
         tmgv[gd]=tg;
         bina=1;
 
         while(bina<ngridlines/2+1){
             bina++; 
             tg += mot;
             gd++;
             tmgv[gd]=tg;        
         }
 
         cout<<"bina.."<<bina<<"binb.."<<binb<<endl;
 
         l1cfile->num_gridlines = binb + bina;
 
            cout<<"number of L1C gridlines along-track..."<<l1cfile->num_gridlines<<"for swath #.."<<swt<<endl;
             }//end equat crossing
     else{
       cout<<"time series not possible for swath #.."<<swt<<"tcross<0...."<<endl;
       flag_time=1;
       }
 
     //for(size_t g=0;g<l1cfile->num_gridlines;g++) cout<<"time series (constant mean swath velocity) for gd#.."<<g+1<<"...."<<tmgv[g]<<endl;
 
 
   return flag_time;
}
 
 
 
 
 
 
 
int32_t L1C::swtime_swt(int swt,L1C_input *l1cinput,l1c_filehandle *l1cfile,int32_t norbs,int16_t time_index[6],double *tswt,double tcross,double mgv,double *tmgv){
  int16_t bina=0,binb=0,ix=-1;
  double tg=0.,mot=0.,tini=0.,tend=0.;
 
  mot = ((l1cinput->gres) * 1000) /mgv;
 
 
//  if(time_index[0]>=0 & time_index[4]<0){ //consecutive swaths
       tini=tswt[0];
       ix=norbs-1;
       tend=tswt[ix];
 
       cout<<"mgv.."<<mgv<<"tini.."<<tini<<"tend.."<<tend<<"tcross..."<<tcross<<endl;
        int flag_time=-1;
 
    if (tcross > 0.0) {
          flag_time=0;
          cout<<"computing time series assuming mean swath velocity..for swath#."<<swt<<endl;
 
 
            tg = tcross - mot / 2;
 
            while (tg > (tini - mot / 2)) {
                binb++; //bins below eq crossing bin which is eq cros time +-mot/2
                tg -= mot;
            }
 
            tg = tcross + mot / 2;
 
            while (tg < (tend + mot / 2)) {
                bina++;//time bins aove eq crossing time
                tg += mot;
              }
 
            l1cfile->num_gridlines = binb + bina;
 
            cout<<"number of L1C gridlines along-track..."<<l1cfile->num_gridlines<<"for swath #.."<<swt<<endl;
 
            //before--
            for (int bin = 0;bin < binb;bin++) //300 seconds are 5 minutes or 1 file from Fred
                tmgv[bin] = tini + bin * mot;
 
            int binc = binb-1;
 
            //after
            for (int bin = 1;bin < bina+1;bin++) //300 seconds are 5 minutes or 1 file from Fred
                tmgv[binc + bin] = tmgv[binc] + bin * mot;
 
             }//end equat crossing
     else{
       cout<<"time series not possible for swath #.."<<swt<<"tcross<0...."<<endl;
       flag_time=1;
       }
 
 
 
 
   return flag_time;
   }
 
 
 
 
int32_t L1C::swtime_vec(int swt,L1C_input *l1cinput,l1c_filehandle *l1cfile,int16_t time_index[6],vector<double>&tvec,double tcross,double mgv,double *tmgv){
  int16_t bina=0,binb=0,ix=-1;
  double tg=0.,mot=0.,tini=0.,tend=0.;
 
  mot = ((l1cinput->gres) * 1000) /mgv;
 
 
 
       tini=tvec[0];
       ix=tvec.size()-1;
       tend=tvec[ix];
 
       cout<<"mgv.."<<mgv<<"tini.."<<tini<<"tend.."<<tend<<"tcross..."<<tcross<<endl;
 
 
  int flag_time=-1;
 
    if (tcross > 0.0) {
          flag_time=0;
          cout<<"computing time series assuming mean swath velocity..for swath#."<<swt<<endl;
 
 
            tg = tcross - mot / 2;
         
            while (tg > (tini - mot / 2)) {
                binb++; //bins below eq crossing bin which is eq cros time +-mot/2
                tg -= mot;
            }
 
            tg = tcross + mot / 2;
 
            while (tg < (tend + mot / 2)) {
                bina++;//time bins aove eq crossing time
                tg += mot;
              }
 
            l1cfile->num_gridlines = binb + bina;
 
            cout<<"number of L1C gridlines along-track..."<<l1cfile->num_gridlines<<"for swath #.."<<swt<<endl;
 
            //before--
            for (int bin = 0;bin < binb;bin++) //300 seconds are 5 minutes or 1 file from Fred
                tmgv[bin] = tini + bin * mot;
 
            int binc = binb-1;
 
            //after
            for (int bin = 1;bin < bina+1;bin++) //300 seconds are 5 minutes or 1 file from Fred
                tmgv[binc + bin] = tmgv[binc] + bin * mot;
 
             }//end equat crossing 
     else{
       cout<<"time series not possible for swath #.."<<swt<<"tcross<0...."<<endl;
       flag_time=1;
       }
 
 
 
   return flag_time;
   }      
 
 
 
 
int32_t L1C::ect_swt(int swt,l1c_filehandle *l1cfile,int32_t norbs,double *tswt,double *latswt,double *lonswt,float*tcross,float*loncross){
    //determine equatorial crossing time--------------
        double t1=-1,t2=-1;
        int asc_mode=-1;
        size_t tindex=-1;
        int scan_brack[2] = { -1,-1 };
        float lat1, lat2, lon1, lon2;//lat,lon defined globally       
        int flag_ect=-1;
 
        //determine orbit direction--asc/desc
           if (latswt[0] > latswt[1])
                asc_mode = 0;//descending
            else
                asc_mode = 1;//ascending
 
        cout<<"computing equatorial crossing time and longitude at crossing for a specific swath...#..."<<swt<<"orbit direction 0: descending, 1: ascending..."<<asc_mode<<endl;
           for (int i = 0;i < norbs - 1;i++) { //improve with binary search
            if (asc_mode == 1 && latswt[i] < 0. && latswt[i + 1]>0.) {
                scan_brack[0] = i + 1;
                scan_brack[1] = i + 2;
                lat1 = latswt[i];
                lat2 = latswt[i + 1];
                lon1 = lonswt[i];
                lon2 = lonswt[i + 1];
                tindex=i;
                i=norbs;
                break;
              }
 
            else if (asc_mode == 0 && latswt[i] > 0. && latswt[i + 1] < 0) { //descending orbit
                scan_brack[0] = i + 2;//negative lat first convention
                scan_brack[1] = i + 1;
                lat1 = latswt[i + 1];
                lat2 = latswt[i];
                lon1 = lonswt[i + 1];
                lon2 = lonswt[i];
                tindex=i;
                i=norbs;
                break;
              }
             } //end for
 
 
         //interpolate time--linear
 
        if (scan_brack[0] > -1) {//if file with equat crossing
            t1 = tswt[tindex];
            t2 = tswt[tindex + 1];
            cout<<"lat1.."<<lat1<<"lat2..."<<lat2<<"t1.."<<t1<<"t2..."<<t2<<endl;
            *tcross = t1 - lat1 * (t2 - t1) / (lat2 - lat1);//equat crossing time
 
            float dtcross = (*tcross - t1) / (t2 - t1);
            *loncross = lon1 + (lon2 - lon1) * dtcross;//latcross is zero
 
            l1cfile->eqt =*tcross;
            l1cfile->orbit_node_lon = *loncross;
            l1cfile->orb_dir = asc_mode;
            flag_ect=0;
        }
        else {
            l1cfile->eqt = -999.0;
            l1cfile->orbit_node_lon = -999.0;
            l1cfile->orb_dir = asc_mode;
            flag_ect=1;
        }
 
 
    return flag_ect;
    }
 
 
 
 
 
 
int32_t L1C::ect_vec(int swt,l1c_filehandle *l1cfile,vector<double>& tvec,vector<double>& latvec,vector<double>& lonvec,float*tcross,float*loncross){
    //determine equatorial crossing time--------------
        double t1=-1,t2=-1;
        int asc_mode=-1;
        size_t tindex=-1;
        int scan_brack[2] = { -1,-1 };
        float lat1, lat2, lon1, lon2;//lat,lon defined globally
        int flag_ect=-1;
 
        //determine orbit direction--asc/desc
           if (latvec[0] > latvec[1])
                asc_mode = 0;//descending
            else
                asc_mode = 1;//ascending
 
        cout<<"computing equatorial crossing time and longitude at crossing for a specific swath...#..."<<swt<<"orbit direction 0: descending, 1: ascending..."<<asc_mode<<endl;
           for (size_t i = 0;i < latvec.size() - 1;i++) { //improve with binary search
            if (asc_mode == 1 && latvec[i] < 0. && latvec[i + 1]>0.) {
                scan_brack[0] = i + 1;
                scan_brack[1] = i + 2;
                lat1 = latvec[i];
                lat2 = latvec[i + 1];
                lon1 = lonvec[i];
                lon2 = lonvec[i + 1];
                tindex=i;
                i=latvec.size();
                break;
              }
 
            else if (asc_mode == 0 && latvec[i] > 0. && latvec[i + 1] < 0) { //descending orbit
                scan_brack[0] = i + 2;//negative lat first convention
                scan_brack[1] = i + 1;
                lat1 = latvec[i + 1];
                lat2 = latvec[i];
                lon1 = lonvec[i + 1];
                lon2 = lonvec[i];
                tindex=i;
                i=latvec.size();
                break;
              }
             } //end for
 
 
         //interpolate time--linear
 
        if (scan_brack[0] > -1) {//if file with equat crossing
            t1 = tvec[tindex];
            t2 = tvec[tindex + 1];
            cout<<"lat1.."<<lat1<<"lat2..."<<lat2<<"t1.."<<t1<<"t2..."<<t2<<endl;
            *tcross = t1 - lat1 * (t2 - t1) / (lat2 - lat1);//equat crossing time
            
            float dtcross = (*tcross - t1) / (t2 - t1);
            *loncross = lon1 + (lon2 - lon1) * dtcross;//latcross is zero
 
            l1cfile->eqt =*tcross;
            l1cfile->orbit_node_lon = *loncross;
            l1cfile->orb_dir = asc_mode;
            flag_ect=0;
        }
        else {
            l1cfile->eqt = -999.0;
            l1cfile->orbit_node_lon = -999.0;
            l1cfile->orb_dir = asc_mode;
            flag_ect=1;
        }
 
 
    return flag_ect;
    }
 
 
//open telemetry file parameters for creating L1C grid----
 
    int32_t L1C::open_l1atol1c(L1C_input *l1cinput,l1c_filehandle *l1cfile){
         int32_t n_files;
         const char* ptstr;
         char *ifile_char;
         string str,ifile_str;
         int status=-1,status1=-1,status2=-1;
         int telGrp,navGrp,scpId,otimeId,olatId,olonId;
         int dimhp,dimtp,dimor;
         unsigned char  **hkpackets=nullptr;
         uint8_t *apids=nullptr;
         size_t number_hkpack,number_scpack,number_orecords;
         uint8_t ubnum1,ubnum2;
         double *sec=nullptr,*tai58_sec=nullptr;
         int16_t *year=nullptr,*mon=nullptr,*day=nullptr,*hour=nullptr,*min=nullptr;
         int16_t oneyear,onemon,oneday,onehour,onemin;
         double onesec;
         double *orb_time=nullptr,*orb_lat=nullptr,*orb_lon=nullptr;
         float *lati=nullptr,*loni=nullptr,*lati2=nullptr,*loni2=nullptr;
         float **lat_gd=nullptr,**lon_gd=nullptr,*az_gd=nullptr;
         double  omeg = 7.29211585494e-5;
         short n_ephem;
         string temp_str,tai_str;
         double vxyz=0,sum1=0,sum2=0,mov1=0.,mgv1=0.,mov2=0,mgv2,*orb_vel=nullptr,*grn_vel=nullptr;
         double sum3=0;
         int *orb_dir=nullptr;
         size_t nswath;
         int32_t  ix1=-1,ix2=-1,ix3=-1,ix4=-1,ix5=-1,ix6=-1;
         double *tmgv1=nullptr,*tmgv2=nullptr,*tmgvf=nullptr,*tmgvf2=nullptr;   
         int32_t num_gridlines=-1,norbs=-1;
         double *tswt=nullptr,*latswt=nullptr,*lonswt=nullptr;
         double *tswt2=nullptr,*latswt2=nullptr,*lonswt2=nullptr;
         const char* outfile;
         string ofile_str,senstr;
         size_t fi=0;     
         float latmin,latmax;
         string y_swt,mo_swt,d_swt,h_swt,mi_swt,s_swt,tswt_ini,tswt_end;
         int32_t gd_per_gran=-1,numgran=-1;
         double deltasec=-1;
         string  s_swt2;
         int length;
         string tswt_ini_file;
         double v1[3],v2[3],vecout[3],orbnorm[3],nvec,vi,toff;
         double rl2,pos_norm,clatg2,fe=1/298.257;
 
         double oangle,G[3],glat,glon,gnorm,rem=6371,omf2,omf2p,pxy,temp;
//         double alt=0.,rl,clatg;
         vector<size_t> ix;
         double tfile_ini;
         size_t att_len;
         int16_t syear, smon, sday,shour,smin;
         double secs,second;
         int logoff=-1;
 
 
         ifile_str = l1cinput->files[0];
         ifile_char = &ifile_str[0];
         ofile_str=ifile_str.substr(0,24);
         outfile=ofile_str.c_str();
         strcpy(l1cinput->ofile,outfile);
 
         cout<<"output file token...."<<l1cinput->ofile<<endl;
         l1cfile->nbinx=l1cinput->nbinx;
         l1cfile->gransize=l1cinput->gransize;
 
         file_format format = getFormat(ifile_char);
         cout<<"format.type.."<<format.type<<endl;
         cout<<"# of L1C across gridlines..."<<l1cfile->nbinx<<endl;
 
         l1cfile->sensor=l1cinput->sensor;//SPEX 1, OCI 2 and HARP 3
 
         if(l1cinput->sensor==1){
             senstr="SPEXone";
             l1cfile->nbinx=20;
              }
        else if (l1cinput->sensor==2){
            senstr="OCI";
            l1cfile->nbinx=514;
             }
        else if (l1cinput->sensor==3){
            senstr="HARP2";
            l1cfile->nbinx=452;
            }
        else{cout<<"sensor by default is OCI option 2....."<<endl;
            senstr="OCI";
             l1cfile->nbinx=514;
          }
 
         cout<<"PACE sensor to be griddded....."<<senstr<<endl;
 
         n_files = l1cfile->ifiles.size();
         cout<<"number of files in the list...."<<n_files<<endl;
 
//big loop-------         
         //opening datafile for binning-----       
            fi=0;
            str = l1cfile->ifiles[fi];
            ptstr = str.c_str();
            cout<<"*********************************************************************************************************"<<endl;
            cout<<"Opening L1A file ..."<<ptstr<<"for telemetry......."<<ptstr<<"file index list #...."<<l1cinput->fileix<<endl;
            cout<<"*********************************************************************************************************"<<endl;
 
            // Open the netcdf4 input file
            // NC_UBYTE
            status = nc_open(ptstr, NC_NOWRITE, &ncid_L1A);
            if (status != NC_NOERR) {
                fprintf(stderr, "-E- Error failed nc_open.\n");
                        exit(EXIT_FAILURE);
            }
 
       //   reading file start coverage time---------
            //make sure the date (year/month.day) is the same for the bunch of files--
            status = nc_inq_attlen(ncid_L1A, NC_GLOBAL, "time_coverage_start", &att_len);
            check_err(status, __LINE__, __FILE__);
            // allocate required space before retrieving values 
            char* time_str = (char*)malloc(att_len + 1); // + 1 for trailing null 
         // get global attribute values 
            status = nc_get_att_text(ncid_L1A, NC_GLOBAL, "time_coverage_start", time_str);
            check_err(status, __LINE__, __FILE__);
            time_str[att_len] = '\0';
            tfile_ini = isodate2unix(time_str);//iso time string to unix since 1970
            unix2ymds(tfile_ini, &syear, &smon, &sday,&secs);
            cout<<"secs elapsed.."<<secs<<"initial granule #..."<<round(secs/(l1cfile->gransize*60))<<endl;
            unix2ymdhms(tfile_ini, &syear,&smon,&sday,&shour,&smin,&second);
            cout<<"HKT file start time................."<<"year.."<<syear<<"month..."<<smon<<"day..."<<sday<<"hour.."<<shour<<"min.."<<smin<<"sec..."<<second<<endl;
 
            secs=0.;
 
            double tfile_ini_sec=ymds2unix(syear,smon,sday,secs);
 
            int16_t y_ini,mo_ini,d_ini,h_ini,mi_ini;
            double sec_ini; 
            unix2ymdhms(tfile_ini_sec,&y_ini,&mo_ini,&d_ini, &h_ini, &mi_ini, &sec_ini);
            cout<<"tfile_ini_sec.."<<"YEAR.."<<y_ini<<"MONTH.."<<mo_ini<<"DAY.."<<d_ini<<"HOUR.."<<h_ini<<"MIN.."<<mi_ini<<"SEC.."<<sec_ini<<endl;
 
            
       //open dimensions
            status = nc_inq_dimid(ncid_L1A, "SC_hkt_pkts", &dimhp);//number of spacecraft packets
             check_err(status, __LINE__, __FILE__);
            status = nc_inq_dimid(ncid_L1A, "max_SC_packet", &dimtp);//size of packets
             check_err(status, __LINE__, __FILE__);
            status = nc_inq_dimid(ncid_L1A, "orb_records", &dimor);//number of orbital records for SC track lat/lon
            check_err(status, __LINE__, __FILE__);
 
         nc_inq_dimlen(ncid_L1A, dimhp, &number_hkpack);
         nc_inq_dimlen(ncid_L1A, dimtp, &number_scpack);
            nc_inq_dimlen(ncid_L1A, dimor, &number_orecords);
 
            cout<<"number_hkpack.."<<number_hkpack<<"number_scpack.."<<number_scpack<<"number of orbit records.."<<number_orecords<<endl;
 
  //allocat mem
            hkpackets=allocate2d_uchar(number_hkpack, number_scpack);//NUMBER of ephem elements x max SIZE of package
         apids=(uint8_t*)calloc(number_hkpack,sizeof(uint8_t));
 
            orb_time=(double*)calloc(number_orecords,sizeof(double));
            orb_lat=(double*)calloc(number_orecords,sizeof(double));
            orb_lon=(double*)calloc(number_orecords,sizeof(double));
            orb_dir = (int*)calloc(number_orecords,sizeof(int));
 
        //open groups   
         status = nc_inq_grp_ncid(ncid_L1A, "housekeeping_data", &telGrp);
                check_err(status, __LINE__, __FILE__);   
            status = nc_inq_grp_ncid(ncid_L1A, "navigation_data", &navGrp);
                check_err(status, __LINE__, __FILE__);
          
         //open vars ids
         status = nc_inq_varid(telGrp, "SC_HKT_packets", &scpId);
                check_err(status, __LINE__, __FILE__);
            status = nc_inq_varid(navGrp, "orb_time", &otimeId);//second of the day
                check_err(status, __LINE__, __FILE__);
            status = nc_inq_varid(navGrp, "orb_lat", &olatId);
                check_err(status, __LINE__, __FILE__);
            status = nc_inq_varid(navGrp, "orb_lon", &olonId);
                check_err(status, __LINE__, __FILE__);
 
         //get data       
         status = nc_get_var_ubyte(telGrp, scpId, &hkpackets[0][0]);
            check_err(status, __LINE__, __FILE__);      
 
 
            status = nc_get_var_double(navGrp, otimeId, &orb_time[0]);
             check_err(status, __LINE__, __FILE__);
            status = nc_get_var_double(navGrp, olatId, &orb_lat[0]);
              check_err(status, __LINE__, __FILE__);
            status = nc_get_var_double(navGrp, olonId, &orb_lon[0]);
             check_err(status, __LINE__, __FILE__);
 
 
         for(size_t hk=0;hk<number_hkpack;hk++){
            ubnum1=(uint8_t)hkpackets[hk][0]; //-48;//48 is 0 ascii code
            ubnum2=(uint8_t)hkpackets[hk][1];
 
            apids[hk] = (ubnum1%8)*256 + ubnum2;
            if(apids[hk]==128){
                ix.push_back(hk);//packet index where ephemr               
               } 
               }
 
         cout<<"#number of ephem elements...."<<ix.size()<<endl;
         n_ephem=ix.size();
         
         // Reverse the byte order  from small endian to large endian, small endian last byte is stored first
         // convert to double and later swap endian
 
      //allocate mem
            orb_vel = (double*)calloc(n_ephem,sizeof(double));
            grn_vel = (double*)calloc(n_ephem,sizeof(double));
 
         sec=(double*)calloc(n_ephem,sizeof(double));
         year=(int16_t*)calloc(n_ephem,sizeof(int16_t));
         mon=(int16_t*)calloc(n_ephem,sizeof(int16_t));
         day=(int16_t*)calloc(n_ephem,sizeof(int16_t));
         hour=(int16_t*)calloc(n_ephem,sizeof(int16_t));
         min=(int16_t*)calloc(n_ephem,sizeof(int16_t));
 
            tai58_sec=(double*)calloc(n_ephem,sizeof(double));
 
 
     //process all packets----
            double tai58;
            size_t c=0;
         //TIME   
            while (c<ix.size()){
               double *tai_ptr = (double*) (hkpackets[ix[c]] + 16);//moving pointer to position 16
               swapc_bytes((char*) tai_ptr, 8, 1);//swap 8 bytes once or 1 16-23 pos, lets say we have 16-32 indexes and we want to swap 8 bytes at the time, some we need ntime=2
               tai58 = *tai_ptr;
               double tai58unix=tai58_to_unix(tai58);
 
               unix2ymdhms(tai58unix,&oneyear,&onemon,&oneday, &onehour, &onemin, &onesec);
 
               year[c]=oneyear;
               mon[c]=onemon;
               day[c]=oneday;
               hour[c]=onehour;
               min[c]=onemin;
               sec[c]=onesec;
 
               tai58_sec[c]=tai58unix;
 
              c++;               
                }
 
 
        //POS/VEL alloc mem-----
              orb_array2* posr = new orb_array2[n_ephem]();
              orb_array2* velr = new orb_array2[n_ephem]();
 
         double dp1,dp2,dp3;
 
            //computed orbital velocity from ephemeris
         c=0;
            while (c<ix.size()){
               double *posi = (double*) (hkpackets[ix[c]] + 120);
               double *veli = (double*) (hkpackets[ix[c]] + 144);
               double *ecmat = (double*) (hkpackets[ix[c]] + 176);
 
             swapc_bytes((char*) posi, 8, 3);
             swapc_bytes((char*) veli, 8, 3);
             swapc_bytes((char*) ecmat, 8, 9);
    
       //assuming ecmat index 1-3 first row, 4-6 second row and 7-9 third row
       //dot product
            //position          
             dp1=posi[0]*ecmat[0]+posi[1]*ecmat[1]+posi[2]*ecmat[2];
             dp2=posi[0]*ecmat[3]+posi[1]*ecmat[4]+posi[2]*ecmat[5];
             dp3=posi[0]*ecmat[6]+posi[1]*ecmat[7]+posi[2]*ecmat[8];
 
             posr[c][0]=dp1;
             posr[c][1]=dp2;
             posr[c][2]=dp3;
       
       //velocity
             dp1=veli[0]*ecmat[0]+veli[1]*ecmat[1]+veli[2]*ecmat[2];
             dp2=veli[0]*ecmat[3]+veli[1]*ecmat[4]+veli[2]*ecmat[5];
             dp3=veli[0]*ecmat[6]+veli[1]*ecmat[7]+veli[2]*ecmat[8];
 
             velr[c][0]=dp1;
             velr[c][1]=dp2;
             velr[c][2]=dp3;
 
             velr[c][0]=velr[c][0] + posr[c][1]*omeg;
             velr[c][1]=velr[c][1] - posr[c][0]*omeg;
 
         //computing orbital velocity
               vxyz = sqrt(velr[c][0] * velr[c][0] + velr[c][1] * velr[c][1] + velr[c][2] * velr[c][2]);//units m/s
               orb_vel[c]=vxyz;               
 
               pos_norm=sqrt(posr[c][0]*posr[c][0]+posr[c][1]*posr[c][1]+posr[c][2]*posr[c][2]);
               clatg2=sqrt(posr[c][0]*posr[c][0]+posr[c][1]*posr[c][1])/pos_norm;
               rl2=Re*(1-fe)/(sqrt(1-(2-fe)*fe*clatg2*clatg2));
               grn_vel[c]=vxyz*rl2/pos_norm;
 
         c++;    
         }
 
            if (hkpackets != nullptr)
               delete[](hkpackets);
            hkpackets= nullptr;
 
            if (apids != nullptr)
               delete[](apids);
            apids= nullptr;
 
 
//determine ini/end time indexes for asc/desc passes
             for(size_t k=0;k<number_orecords-1;k++){
                 if(orb_lat[k+1]>orb_lat[k])
                     orb_dir[k]=1;//ascending
                 else orb_dir[k]=0;//descending
                    }
 
//find time limits for half-orbits
            int swt=1;
            int16_t tlimits_swt[2][2]={{-1,-1},{-1,-1}};//2 swath x time limits ini/end
            tlimits_swt[swt-1][0]=0;//only the indexes
 
 
            for(size_t k=0;k<number_orecords-1;k++){
              if(orb_dir[k]!=orb_dir[k+1]){
                if(swt==1){           
                  tlimits_swt[swt-1][1]=k;//this time is a 'local' end cause may continue circling the earth after ascending or descending
                  swt++;
                  tlimits_swt[swt-1][0]=k+1;
                    }         
                else if(swt==2){//another partial swath
                  tlimits_swt[swt-1][1]=k;
                  tlimits_swt[swt-2][1]=number_orecords-1;    
                  swt++;
                  }                       
                 }
         
                if(k==number_orecords-2 && swt==2)  tlimits_swt[swt-1][1]=number_orecords-1;
                 }     
 
            nswath=swt;
 
 
//split half-orbits----  group lat/lon time and velocity vector
 
            for (size_t sw=0;sw<2;sw++){
              if(nswath==2){
                 if(sw==0){ 
                    ix1=tlimits_swt[sw][0];
                    ix2=tlimits_swt[sw][1];
                    cout<<"swat#1...ix1"<<ix1<<"ix2.."<<ix2<<endl;
                   }
                 else if(sw==1){
                    ix3=tlimits_swt[sw][0];
                    ix4=tlimits_swt[sw][1];
                    cout<<"swat#2...ix3"<<ix3<<"ix4.."<<ix4<<endl;
                    }   
                 }
              else if(nswath==3){ //>2 we have 4 limits for swath 1
                 if(sw==0){ 
                     ix1=tlimits_swt[sw][0];
                     ix2=tlimits_swt[sw+1][0]-1;
                     ix3=tlimits_swt[sw+1][1]+1;
                     ix4=tlimits_swt[sw][1];
                      cout<<"swat#1...ix1"<<ix1<<"ix2.."<<ix2<<"ix3.."<<ix3<<"ix4..."<<ix4<<endl;
                     }
                 else if(sw==1){
                    ix5=tlimits_swt[sw][0];
                    ix6=tlimits_swt[sw][1];
                    cout<<"swat#2...ix5"<<ix5<<"ix6.."<<ix6<<endl;
                   }               
                  }
              else{
                cout<<"number of swaths is less than 2..!! exit..."<<endl;
                 exit(1);            
                 }
              }
 
          int kk;
          float tcross1=-999.,loncross1=-999.,tcross2=-999.,loncross2=-999.;
 
//--------------------------------------------------------------------------------------          
//----half orbits are consecutive          
//swath1
//--------------------------------------------------------------------------------------
          if(nswath==2){
            if(ix1>=0 && ix5<0){
                norbs=ix2-ix1+1;
                kk=ix1;       
                c=0;
                latmin=orb_lat[ix1];
                latmax=orb_lat[ix2];
        
//orbit direction 
                l1cfile->orb_dir=orb_dir[ix1];
 
//ini and end UTC--this is swath orbital time, not interpolated time
                y_swt=std::to_string(year[ix1]);
                mo_swt=std::to_string(mon[ix1]);                
                d_swt=std::to_string(day[ix1]);
                h_swt=std::to_string(hour[ix1]);
                mi_swt=std::to_string(min[ix1]);       
                s_swt2=std::to_string(round(sec[ix1]));
 
                length = (int) floor( log10 (mon[ix1]) ) + 1;
                if(length==1) mo_swt="0"+mo_swt;
                length = (int) floor( log10 (day[ix1]) ) + 1;
                if(length==1) d_swt="0"+d_swt;
 
                if(hour[ix1]==0) logoff=1; else logoff=0;
                length = (int) floor( log10 (hour[ix1]+logoff)) + 1;
                if(length==1) h_swt="0"+h_swt;
 
                if(min[ix1]==0) logoff=1; else logoff=0;
                length = (int) floor( log10 (min[ix1]+logoff)) + 1;
                if(length==1) mi_swt="0"+mi_swt;
 
                if(sec[ix1]==0) logoff=1; else logoff=0;
                length = (int) floor( log10 (round(sec[ix1])+logoff)) + 1;
                if(length==1) s_swt2="0"+s_swt2;
                         
                tswt_ini=y_swt+"-"+mo_swt+"-"+d_swt+"T"+h_swt+":"+mi_swt+":"+s_swt2.substr(0,2)+"Z";
                tswt_ini_file=y_swt+mo_swt+d_swt+"T"+h_swt+mi_swt+s_swt2.substr(0,2)+"Z";
 
                y_swt=std::to_string(year[ix2]);
                mo_swt=std::to_string(mon[ix2]);
                d_swt=std::to_string(day[ix2]);
                h_swt=std::to_string(hour[ix2]);
                mi_swt=std::to_string(min[ix2]);
 
                length = (int) floor( log10 (mon[ix2]) ) + 1;
                if(length==1) mo_swt="0"+mo_swt;
                length = (int) floor( log10 (day[ix2]) ) + 1;
                if(length==1) d_swt="0"+d_swt;
 
                 if(hour[ix2]==0) logoff=1; else logoff=0;
                length = (int) floor( log10 (hour[ix2]+logoff)) + 1;
                if(length==1) h_swt="0"+h_swt;
 
                if(min[ix2]==0) logoff=1; else logoff=0;
                length = (int) floor( log10 (min[ix2]+logoff)) + 1;
                if(length==1) mi_swt="0"+mi_swt;
 
                if(sec[ix2]==0) logoff=1; else logoff=0;
                length = (int) floor( log10 (round(sec[ix2])+logoff)) + 1;
                if(length==1) s_swt2="0"+s_swt2;
 
                tswt_end=y_swt+"-"+mo_swt+"-"+d_swt+"T"+h_swt+":"+mi_swt+":"+s_swt2.substr(0,2)+"Z";
 
                tswt=(double*)calloc(norbs,sizeof(double));
                latswt=(double*)calloc(norbs,sizeof(double));
                lonswt=(double*)calloc(norbs,sizeof(double));
 
                sum1=0,sum3=0,c=0;
                while(kk<=ix2){
                   latswt[c]=orb_lat[kk];
                   lonswt[c]=orb_lon[kk];
                   tswt[c]=orb_time[kk];
 
                   if(orb_lat[kk]<=latmin){ 
                       latmin=orb_lat[kk];                          
                        }
                   if(orb_lat[kk]>=latmax){ 
                       latmax=orb_lat[kk];
                        }   
 
                   sum1+=orb_vel[kk];
                   sum3+=grn_vel[kk];
                   kk++;
                   c++;
                     }
                //computing mean swath velocity (m/s) --------------------------
                mov1 = (sum1 /norbs);//mean velocity in m/s 
                mgv1 = (sum3 /norbs)*1000;//in meters/s
 
                cout<<"mov1..."<<mov1<<"mvg1..."<<mgv1<<endl;
                
                status=ect_swt(1,l1cfile,norbs,tswt,latswt,lonswt,&tcross1,&loncross1);
                cout<<"nswath==2 --tcross equat crossing in (s)..swath#1..."<<tcross1<<"loncross1..."<<loncross1<<endl;
                cout<<"latmin.."<<latmin<<"latmax..."<<latmax<<endl;
 
 
                if (latswt != nullptr)
                     delete[](latswt);
                latswt= nullptr;
                if (lonswt != nullptr)
                     delete[](lonswt);
                lonswt= nullptr;
                
                l1cfile->num_gridlines=4001;                
                if(status==0){
                   tmgv1=(double*)calloc(l1cfile->num_gridlines,sizeof(double));
                   tmgvf=(double*)calloc(l1cfile->num_gridlines,sizeof(double));
 
                   swtime_swt2(1,l1cinput,l1cfile,norbs,tswt,tcross1,mgv1,tmgv1);
                   
                   //ini/end times for swath
                   num_gridlines = l1cfile->num_gridlines;
 
                   //tini/tend swath
                   l1cfile->tswt_ini=tswt_ini;
                   l1cfile->tswt_end=tswt_end;
                   l1cfile->tswt_ini_file=tswt_ini_file;
 
                //first interpolation
                   lati=(float*)calloc(num_gridlines,sizeof(float));
                   loni=(float*)calloc(num_gridlines,sizeof(float));
                   lati2=(float*)calloc(num_gridlines,sizeof(float));
                   loni2=(float*)calloc(num_gridlines,sizeof(float));
                   az_gd = (float*)calloc(num_gridlines,sizeof(float));
                
                   cout<<"number of across bins L1C grid...#.."<<l1cfile->nbinx<<endl;
 
//FRED SOCEA---
                 //  search_SOCEA(l1cinput,l1cfile, lat_gd,lon_gd,tmgv1,tcross1,loncross1);
 
                   lat_gd = allocate2d_float(4001, l1cfile->nbinx);
                   lon_gd = allocate2d_float(4001, l1cfile->nbinx);
 
                   orb_array2* posgrid = new orb_array2[num_gridlines]();//these are doubles
                   orb_array2* velgrid = new orb_array2[num_gridlines]();
 
                   orb_array2* posgrid2 = new orb_array2[num_gridlines]();//these are doubles
                   orb_array2* velgrid2 = new orb_array2[num_gridlines]();
 
//interp 1-- always based on orbitals---                   
     //interpola pos/veloc as a function of time                  
                   orb_interp2(number_orecords, num_gridlines,orb_time,posr,velr,tmgv1, posgrid,velgrid);
                 
                   for(int i=0;i<num_gridlines-1;i++){
                          pos_norm=sqrt(posgrid[i][0]*posgrid[i][0]+posgrid[i][1]*posgrid[i][1]+posgrid[i][2]*posgrid[i][2]);
                          clatg2=sqrt(posgrid[i][0]*posgrid[i][0]+posgrid[i][1]*posgrid[i][1])/pos_norm;
                          rl2=Re*(1-fe)/(sqrt(1-(2-fe)*fe*clatg2*clatg2));
 
                          v2[0]=velgrid[i][0]*rl2/pos_norm;
                          v2[1]=velgrid[i][1]*rl2/pos_norm;
                          v2[2]=velgrid[i][2]*rl2/pos_norm;
 
                          vi=sqrt(v2[0]*v2[0]+v2[1]*v2[1]+v2[2]*v2[2])*1000;
                          toff=vi/mgv1;    
                          tmgvf[i]=tmgv1[i]+toff;
 
                            }
 
                   orb_interp2(number_orecords, num_gridlines,orb_time,posr,velr,tmgvf, posgrid2,velgrid2);
 
 
                  //angle subsat track----
                  omf2=(1-fe)*(1-fe);
 
                  for(int i=0;i<num_gridlines-1;i++){ 
                        pos_norm=sqrt(posgrid2[i][0]*posgrid2[i][0]+posgrid2[i][1]*posgrid2[i][1]+posgrid2[i][2]*posgrid2[i][2]);
                        clatg2=sqrt(posgrid2[i][0]*posgrid2[i][0]+posgrid2[i][1]*posgrid2[i][1])/pos_norm;
                        rl2=Re*(1-fe)/(sqrt(1-(2-fe)*fe*clatg2*clatg2));
 
                        v1[0]=(posgrid2[i][0])*rl2/pos_norm;
                        v1[1]=(posgrid2[i][1])*rl2/pos_norm;
                        v1[2]=(posgrid2[i][2])*rl2/pos_norm;
 
                        v2[0]=(velgrid2[i][0])*rl2/pos_norm;
                        v2[1]=(velgrid2[i][1])*rl2/pos_norm;
                        v2[2]=(velgrid2[i][2])*rl2/pos_norm;         
 
                        cross_product_double(v1,v2,vecout);
                        nvec=cross_product_norm_double(v1,v2);//length of orb norm vect
 
                        orbnorm[0]=vecout[0]/nvec;
                        orbnorm[1]=vecout[1]/nvec;
                        orbnorm[2]=vecout[2]/nvec;
 
                   for(int j=0;j<l1cfile->nbinx;j++){
 
                      pos_norm=sqrt(v1[0]*v1[0]+v1[1]*v1[1]+v1[2]*v1[2]);//first gridline 
 
                      oangle=asin((j-(l1cfile->nbinx-1)/2)*5.2/pos_norm);
 
                  //Geocentric vector
                      G[0]=v1[0]*cos(oangle)-orbnorm[0]*pos_norm*sin(oangle);
                      G[1]=v1[1]*cos(oangle)-orbnorm[1]*pos_norm*sin(oangle);
                      G[2]=v1[2]*cos(oangle)-orbnorm[2]*pos_norm*sin(oangle);
                      
                      glon=atan2(G[1],G[0])*180/M_PI;
 
                      gnorm = sqrt(G[0]*G[0]+G[1]*G[1]+G[2]*G[2]);
                      omf2p = (omf2*rem + gnorm - rem)/gnorm;
                      pxy = G[0]*G[0]+G[1]*G[1];
                      temp = sqrt(G[2]*G[2] + omf2p*omf2p*pxy);
                      glat=asin(G[2]/temp)*180/M_PI;
 
                      lat_gd[i][j]=glat;
                      lon_gd[i][j]=glon;
 
                      //altitude
           //           clatg = cos(atan(omf2*tan(glat*M_PI/180.)));
//                      rl = re*(1.-fe)/sqrt(1.-(2.-fe)*fe*clatg*clatg);
      //                alt = gnorm - rl;
                   }
                  }
                  
                   if (posgrid != nullptr)
                     delete[](posgrid);
               
                   if (velgrid != nullptr)
                     delete[](velgrid);  
                   
                   if (posgrid2 != nullptr)
                     delete[](posgrid2);
 
                   if (velgrid2 != nullptr)
                     delete[](velgrid2);           
 
                  l1cfile->num_gridlines = l1cfile->num_gridlines-1;
            //      create_SOCEA(1,l1cinput,l1cfile,lat_gd,lon_gd);//THIS IS SWATH PROCESSING
 
//--------------------------------------------------------------
//granule processing---------------------------------------------                 
//---------------------------------------------------------------
 
                   l1cfile->tfile_ini_sec=tfile_ini_sec;
                   deltasec=tmgvf[num_gridlines-2]-tmgvf[0]+1;
                   cout<<"deltasec..swath."<<deltasec<<endl;
 
                   if(tswt != nullptr)
                     delete[](tswt);
                   tswt= nullptr;
 
                   numgran=144*2;
                   l1cfile->numgran=numgran;
                   gd_per_gran=round(num_gridlines/10);//10 granules per half orbit
                   l1cfile->gd_per_gran=gd_per_gran;
 
                   cout<<"estimated # of granules to be processed..."<<numgran<<"gd_per_gran..."<<gd_per_gran<<"#gridlines.."<<num_gridlines<<endl;
 
                   write_L1C_granule(1,l1cfile,l1cinput,tmgvf,lat_gd, lon_gd);
 
//-----------------------------------------------------------------
//-----------------------------------------------------------------   
 
                   if (lat_gd != nullptr)
                      delete [](lat_gd);
                   lat_gd = nullptr;
                   if (lon_gd != nullptr)
                       delete [](lon_gd);
                   lon_gd = nullptr;
                   if (az_gd != nullptr)
                     delete [](az_gd);
                   az_gd = nullptr;
 
                   if (lati != nullptr)
                       delete[](lati);
                   lati= nullptr;
                   if (loni != nullptr)
                     delete[](loni);
                   loni= nullptr;
 
                   if (lati2 != nullptr)
                       delete[](lati2);
                   lati2= nullptr;
                   if (loni2 != nullptr)
                     delete[](loni2);
                   loni2= nullptr;
                 if (tmgv1 != nullptr)
                     delete[](tmgv1);
                 tmgv1= nullptr;
                   if (tmgvf != nullptr)
                     delete[](tmgvf);
                   tmgvf= nullptr;
                 }
                 else{
                   cout<<"ERROR swath #1 does not cross the equator..."<<endl;
                   cout<<"checking swath #2..."<<endl;
                 }
 
//nswath=2                 
//-------------------------------------------------------------------------------------------------------         
//swath#2    
//-------------------------------------------------------------------------------------------------------    
                kk=ix3;
                c=0;
                norbs=ix4-ix3+1;
                latmin=orb_lat[ix3];
                latmax=orb_lat[ix3];
 
                //orbit direction
                l1cfile->orb_dir=orb_dir[ix3];
 
                //ini and end UTC--this is swath orbital time, not interpolated time
                y_swt=std::to_string(year[ix3]);
                mo_swt=std::to_string(mon[ix3]);
                d_swt=std::to_string(day[ix3]);
                h_swt=std::to_string(hour[ix3]);
                mi_swt=std::to_string(min[ix3]);
                s_swt2=std::to_string(round(sec[ix3]));
 
                length = (int) floor( log10 (mon[ix3]) ) + 1;
                if(length==1) mo_swt="0"+mo_swt;
                length = (int) floor( log10 (day[ix3]) ) + 1;
                if(length==1) d_swt="0"+d_swt;
 
                if(hour[ix3]==0) logoff=1; else logoff=0;
                length = (int) floor( log10 (hour[ix3]+logoff)) + 1;
                if(length==1) h_swt="0"+h_swt;
 
                if(min[ix3]==0) logoff=1; else logoff=0;
                length = (int) floor( log10 (min[ix3]+logoff)) + 1;
                if(length==1) mi_swt="0"+mi_swt;
 
                if(sec[ix3]==0) logoff=1; else logoff=0;
                length = (int) floor( log10 (round(sec[ix3])+logoff)) + 1;
                if(length==1) s_swt2="0"+s_swt2;
 
                tswt_ini=y_swt+"-"+mo_swt+"-"+d_swt+"T"+h_swt+":"+mi_swt+":"+s_swt2.substr(0,2)+"Z";
                tswt_ini_file=y_swt+mo_swt+d_swt+"T"+h_swt+mi_swt+s_swt2.substr(0,2)+"Z";
 
                y_swt=std::to_string(year[ix4]);
                mo_swt=std::to_string(mon[ix4]);
                d_swt=std::to_string(day[ix4]);
                h_swt=std::to_string(hour[ix4]);
                mi_swt=std::to_string(min[ix4]);
                s_swt2=std::to_string(round(sec[ix4]));
 
 
                length = (int) floor( log10 (mon[ix4]) ) + 1;
                if(length==1) mo_swt="0"+mo_swt;
                length = (int) floor( log10 (day[ix4]) ) + 1;
                if(length==1) d_swt="0"+d_swt;
 
                if(hour[ix4]==0) logoff=1; else logoff=0;
                length = (int) floor( log10 (hour[ix4]+logoff)) + 1;
                if(length==1) h_swt="0"+h_swt;
 
                if(min[ix4]==0) logoff=1; else logoff=0;
                length = (int) floor( log10 (min[ix4]+logoff)) + 1;
                if(length==1) mi_swt="0"+mi_swt;
 
                if(sec[ix4]==0) logoff=1; else logoff=0;
                length = (int) floor( log10 (round(sec[ix4])+logoff)) + 1;
                if(length==1) s_swt2="0"+s_swt2;
 
                tswt_end=y_swt+"-"+mo_swt+"-"+d_swt+"T"+h_swt+":"+mi_swt+":"+s_swt2.substr(0,2)+"Z";
 
                tswt2=(double*)calloc(norbs,sizeof(double));
                latswt2=(double*)calloc(norbs,sizeof(double));
                lonswt2=(double*)calloc(norbs,sizeof(double));
 
                sum2=0,sum3=0,c=0;
                while(kk<=ix4){
                   latswt2[c]=orb_lat[kk];
                   lonswt2[c]=orb_lon[kk];
                   tswt2[c]=orb_time[kk];
 
                   if(orb_lat[kk]<=latmin){
                       latmin=orb_lat[kk];
                        }
                   if(orb_lat[kk]>=latmax){
                       latmax=orb_lat[kk];
                        }
 
                   sum2+=orb_vel[kk];
                   sum3+=grn_vel[kk];
                   kk++;
                   c++;
                     }
                mov2 = (sum2 /norbs);//mean velocity in m/s x 10^3
                mgv2 = (sum3 /norbs)*1000;//in meters/s  
 
                cout<<"mov2..."<<mov2<<"mvg2..."<<mgv2<<endl;
 
                status=ect_swt(2,l1cfile,norbs,tswt2,latswt2,lonswt2,&tcross2,&loncross2);
                cout<<"nswath==2 ---tcross equat crossing in (s)..swath#2..."<<tcross2<<"loncross2..."<<loncross2<<endl;
                cout<<"latmin.."<<latmin<<"latmax..."<<latmax<<endl;
 
                if (latswt2 != nullptr)
                     delete[](latswt2);
                latswt2= nullptr;
                if (lonswt2 != nullptr)
                     delete[](lonswt2);
                lonswt2= nullptr;               
 
                l1cfile->num_gridlines=4001;
 
                if(status==0){
                  tmgv2=(double*)calloc(l1cfile->num_gridlines,sizeof(double)); 
                  tmgvf2=(double*)calloc(l1cfile->num_gridlines,sizeof(double));
 
                  swtime_swt2(2,l1cinput,l1cfile,norbs,tswt2,tcross2,mgv2,tmgv2);                 
                  num_gridlines = l1cfile->num_gridlines;
 
//granule processing ------------------------                  
   
                  numgran=144;         
                  l1cfile->numgran=numgran;
                  gd_per_gran=round(num_gridlines/10);
                  l1cfile->gd_per_gran=gd_per_gran;
 
                  cout<<"# of granules to be processed..."<<numgran<<"gd_per_gran..."<<gd_per_gran<<endl;
 
                  //tini/tend swath
                  l1cfile->tswt_ini=tswt_ini;
                  l1cfile->tswt_end=tswt_end;
                  l1cfile->tswt_ini_file=tswt_ini_file;
 
                  if(tswt2 != nullptr)
                     delete[](tswt2);
                  tswt2= nullptr;
 
                 //first interpolation                
                  lati=(float*)calloc(num_gridlines,sizeof(float));
                  loni=(float*)calloc(num_gridlines,sizeof(float));
                  lati2=(float*)calloc(num_gridlines,sizeof(float));
                  loni2=(float*)calloc(num_gridlines,sizeof(float));
                  az_gd = (float*)calloc(num_gridlines,sizeof(float));
 
                  cout<<"number of across bins L1C grid...#.."<<l1cfile->nbinx<<endl;
                  lat_gd = allocate2d_float(4001, l1cfile->nbinx);
                  lon_gd = allocate2d_float(4001, l1cfile->nbinx);
 
                  orb_array2* posgrid = new orb_array2[num_gridlines]();//these are doubles
                  orb_array2* velgrid = new orb_array2[num_gridlines]();
                  orb_array2* posgrid2 = new orb_array2[num_gridlines]();//these are doubles
                  orb_array2* velgrid2 = new orb_array2[num_gridlines]();
 
                  orb_interp2(number_orecords, num_gridlines,orb_time,posr,velr,tmgv2, posgrid,velgrid);
                 
                  for(int i=0;i<num_gridlines-1;i++){
                          pos_norm=sqrt(posgrid[i][0]*posgrid[i][0]+posgrid[i][1]*posgrid[i][1]+posgrid[i][2]*posgrid[i][2]);
                          clatg2=sqrt(posgrid[i][0]*posgrid[i][0]+posgrid[i][1]*posgrid[i][1])/pos_norm;
                          rl2=Re*(1-fe)/(sqrt(1-(2-fe)*fe*clatg2*clatg2));
 
                          v2[0]=velgrid[i][0]*rl2/pos_norm;
                          v2[1]=velgrid[i][1]*rl2/pos_norm;
                          v2[2]=velgrid[i][2]*rl2/pos_norm;
 
                          vi=sqrt(v2[0]*v2[0]+v2[1]*v2[1]+v2[2]*v2[2])*1000;
                          toff=vi/mgv2;    
                          tmgvf2[i]=tmgv2[i]+toff;
                            }
 
 
                   orb_interp2(number_orecords, num_gridlines,orb_time,posr,velr,tmgvf2, posgrid2,velgrid2);
 
                  //angle subsat track----
                  omf2=(1-fe)*(1-fe);
 
                  for(int i=0;i<num_gridlines-1;i++){ 
                        pos_norm=sqrt(posgrid2[i][0]*posgrid2[i][0]+posgrid2[i][1]*posgrid2[i][1]+posgrid2[i][2]*posgrid2[i][2]);
                        clatg2=sqrt(posgrid2[i][0]*posgrid2[i][0]+posgrid2[i][1]*posgrid2[i][1])/pos_norm;
                        rl2=Re*(1-fe)/(sqrt(1-(2-fe)*fe*clatg2*clatg2));
 
                        v1[0]=(posgrid2[i][0])*rl2/pos_norm;
                        v1[1]=(posgrid2[i][1])*rl2/pos_norm;
                        v1[2]=(posgrid2[i][2])*rl2/pos_norm;
 
                        v2[0]=(velgrid2[i][0])*rl2/pos_norm;
                        v2[1]=(velgrid2[i][1])*rl2/pos_norm;
                        v2[2]=(velgrid2[i][2])*rl2/pos_norm;         
 
                        cross_product_double(v1,v2,vecout);
                        nvec=cross_product_norm_double(v1,v2);//length of orb norm vect
 
                        orbnorm[0]=vecout[0]/nvec;
                        orbnorm[1]=vecout[1]/nvec;
                        orbnorm[2]=vecout[2]/nvec;
 
                   for(int j=0;j<l1cfile->nbinx;j++){
 
                      pos_norm=sqrt(v1[0]*v1[0]+v1[1]*v1[1]+v1[2]*v1[2]);//first gridline 
 
                      oangle=asin((j-(l1cfile->nbinx-1)/2)*5.2/pos_norm);
 
                  //Geocentric vector
                      G[0]=v1[0]*cos(oangle)-orbnorm[0]*pos_norm*sin(oangle);
                      G[1]=v1[1]*cos(oangle)-orbnorm[1]*pos_norm*sin(oangle);
                      G[2]=v1[2]*cos(oangle)-orbnorm[2]*pos_norm*sin(oangle);
                      
                      glon=atan2(G[1],G[0])*180/M_PI;
 
                      gnorm = sqrt(G[0]*G[0]+G[1]*G[1]+G[2]*G[2]);
                      omf2p = (omf2*rem + gnorm - rem)/gnorm;
                      pxy = G[0]*G[0]+G[1]*G[1];
                      temp = sqrt(G[2]*G[2] + omf2p*omf2p*pxy);
                      glat=asin(G[2]/temp)*180/M_PI;
 
                      lat_gd[i][j]=glat;
                      lon_gd[i][j]=glon;
 
                      //altitude
              //        clatg = cos(atan(omf2*tan(glat*M_PI/180.)));
                //      rl = re*(1.-fe)/sqrt(1.-(2.-fe)*fe*clatg*clatg);
                //      alt = gnorm - rl;
                   }
 
                  }
                  
                   if (posgrid != nullptr)
                     delete[](posgrid);
               
                   if (velgrid != nullptr)
                     delete[](velgrid);  
                   
                   if (posgrid2 != nullptr)
                     delete[](posgrid2);
 
                   if (velgrid2 != nullptr)
                     delete[](velgrid2);           
 
                  l1cfile->num_gridlines = l1cfile->num_gridlines-1;
             //     create_SOCEA(1,l1cinput,l1cfile,lat_gd,lon_gd);//this is swath processing---------------
 
//--------------------------------------------------------------
//granule processing---------------------------------------------                 
//---------------------------------------------------------------
                   l1cfile->tfile_ini_sec=tfile_ini_sec;
 
                   deltasec=tmgvf[num_gridlines-2]-tmgvf2[0]+1;
                   cout<<"deltasec..swath."<<deltasec<<endl;
 
                   numgran=144*2;
                   l1cfile->numgran=numgran;
                   gd_per_gran=round(num_gridlines/10);//10 granules per half orbit
                   l1cfile->gd_per_gran=gd_per_gran;
 
                   cout<<"estimated # of granules to be processed..."<<numgran<<"gd_per_gran..."<<gd_per_gran<<"#gridlines.."<<num_gridlines<<endl;
 
                   write_L1C_granule(2,l1cfile,l1cinput,tmgvf2,lat_gd, lon_gd);
//--------------------------------------------------------------------
//--------------------------------------------------------------------
                  if (lat_gd != nullptr)
                    delete [](lat_gd);
                  lat_gd = nullptr;
                  if (lon_gd != nullptr)
                       delete [](lon_gd);
                  lon_gd = nullptr;
                  if (az_gd != nullptr)
                    delete [](az_gd);
                  az_gd = nullptr;
 
                  if (lati != nullptr)
                     delete[](lati);
                  lati= nullptr;
                  if (loni != nullptr)
                     delete[](loni);
                  loni= nullptr;
 
                  if (lati2 != nullptr)
                     delete[](lati2);
                  lati2= nullptr;
                  if (loni2 != nullptr)
                     delete[](loni2);
                  loni2= nullptr;
                 if (tmgv2 != nullptr)
                     delete[](tmgv2);
                 tmgv2= nullptr;
                  if (tmgvf2 != nullptr)
                     delete[](tmgvf2);
                  tmgvf2= nullptr;
 
                    }
                 else{
                     cout<<"ERROR swath #2 does not cross the equator..NO L1C grid for swath #2"<<endl;
                 }
 
             }
 
 
          }//end nswath=2
 
 
//-------------HALF-ORBITS IN TWO NON-CONSECUTIVE PORTIONS ------        
//nswath =3  
//swath1
//------------------------------------------------------------- 
          c=0;
          if(nswath==3){          
            if(ix1>=0 && ix5>0){
                norbs=ix2-ix1+1;
                kk=ix1;
                latmin=orb_lat[ix1];
                latmax=orb_lat[ix2];
 
                //orbit direction
                l1cfile->orb_dir=orb_dir[ix1];
 
                //ini and end UTC--this is swath orbital time, not interpolated time
                y_swt=std::to_string(year[ix1]);
                mo_swt=std::to_string(mon[ix1]);
                d_swt=std::to_string(day[ix1]);
                h_swt=std::to_string(hour[ix1]);
                mi_swt=std::to_string(min[ix1]);
                s_swt2=std::to_string(round(sec[ix1]));
 
                length = (int) floor( log10 (mon[ix1]) ) + 1;
                if(length==1) mo_swt="0"+mo_swt;
                length = (int) floor( log10 (day[ix1]) ) + 1;
                if(length==1) d_swt="0"+d_swt;
 
                 if(hour[ix1]==0) logoff=1; else logoff=0;
                length = (int) floor( log10 (hour[ix1]+logoff)) + 1;
                if(length==1) h_swt="0"+h_swt;
 
                if(min[ix1]==0) logoff=1; else logoff=0;
                length = (int) floor( log10 (min[ix1]+logoff)) + 1;
                if(length==1) mi_swt="0"+mi_swt;
 
                if(sec[ix1]==0) logoff=1; else logoff=0;
                length = (int) floor( log10 (round(sec[ix1])+logoff)) + 1;
                if(length==1) s_swt2="0"+s_swt2;
              
                tswt_ini=y_swt+"-"+mo_swt+"-"+d_swt+"T"+h_swt+":"+mi_swt+":"+s_swt2.substr(0,2)+"Z";
                tswt_ini_file=y_swt+mo_swt+d_swt+"T"+h_swt+mi_swt+s_swt2.substr(0,2)+"Z";
 
                y_swt=std::to_string(year[ix2]);
                mo_swt=std::to_string(mon[ix2]);
                d_swt=std::to_string(day[ix2]);
                h_swt=std::to_string(hour[ix2]);
                mi_swt=std::to_string(min[ix2]);
                s_swt2=std::to_string(round(sec[ix2]));
 
                length = (int) floor( log10 (mon[ix2]) ) + 1;
                if(length==1) mo_swt="0"+mo_swt;
                length = (int) floor( log10 (day[ix2]) ) + 1;
                if(length==1) d_swt="0"+d_swt;
 
                 if(hour[ix2]==0) logoff=1; else logoff=0;
                length = (int) floor( log10 (hour[ix2]+logoff)) + 1;
                if(length==1) h_swt="0"+h_swt;
 
                if(min[ix2]==0) logoff=1; else logoff=0;
                length = (int) floor( log10 (min[ix2]+logoff)) + 1;
                if(length==1) mi_swt="0"+mi_swt;
 
                if(sec[ix2]==0) logoff=1; else logoff=0;
                length = (int) floor( log10 (round(sec[ix2])+logoff)) + 1;
                if(length==1) s_swt2="0"+s_swt2;
 
                tswt_end=y_swt+"-"+mo_swt+"-"+d_swt+"T"+h_swt+":"+mi_swt+":"+s_swt2.substr(0,2)+"Z";
 
                tswt=(double*)calloc(norbs,sizeof(double));
                latswt=(double*)calloc(norbs,sizeof(double));
                lonswt=(double*)calloc(norbs,sizeof(double));
 
                sum1=0,sum3=0,c=0;                
                while(kk<=ix2){
                   latswt[c]=orb_lat[kk];
                   lonswt[c]=orb_lon[kk];
                   tswt[c]=orb_time[kk];
                   sum1+=orb_vel[kk];
                   sum3+=grn_vel[kk];
                   kk++;
                   c++;
                     }
  //computing mean swath velocity (m/s) --------------------------
                mov1 = (sum1 /norbs);//mean velocity in m/s x 10^3
                mgv1 = (sum3 /norbs)*1000;
                cout<<"mov1..."<<mov1<<"mvg1..."<<mgv1<<endl;
 
                status1=ect_swt(1,l1cfile,norbs,tswt,latswt,lonswt,&tcross1,&loncross1);
                cout<<"nswath==3 --tcross equat crossing in (s)..swath#1.(segment #1).."<<tcross1<<"loncross1..."<<loncross1<<endl;
 
                c=0;                 
                if(tcross1<0.){
 
                  if(tswt != nullptr)
                     delete[](tswt);
                  tswt= nullptr;
                  if (latswt != nullptr)
                     delete[](latswt);
                  latswt= nullptr;
                  if (lonswt != nullptr)
                     delete[](lonswt);
                  lonswt= nullptr;  
 
                  norbs=ix4-ix3+1;  
 
                  tswt=(double*)calloc(norbs,sizeof(double));
                  latswt=(double*)calloc(norbs,sizeof(double));
                  lonswt=(double*)calloc(norbs,sizeof(double));
 
                kk=ix3;
                  sum1=0.;
                  tcross1=-999,loncross1=-999.;
 
                  l1cfile->orb_dir=orb_dir[ix3];
 
                  //ini and end UTC--this is swath orbital time, not interpolated time
                  y_swt=std::to_string(year[ix3]);
                  mo_swt=std::to_string(mon[ix3]);
                  d_swt=std::to_string(day[ix3]);
                  h_swt=std::to_string(hour[ix3]);
                  mi_swt=std::to_string(min[ix3]);
                  s_swt2=std::to_string(round(sec[ix3]));
 
                  length = (int) floor( log10 (mon[ix3]) ) + 1;
                  if(length==1) mo_swt="0"+mo_swt;
                  length = (int) floor( log10 (day[ix3]) ) + 1;
                  if(length==1) d_swt="0"+d_swt;
 
                  if(hour[ix3]==0) logoff=1; else logoff=0;
                  length = (int) floor( log10 (hour[ix3]+logoff)) + 1;
                  if(length==1) h_swt="0"+h_swt;
 
                  if(min[ix3]==0) logoff=1; else logoff=0;
                  length = (int) floor( log10 (min[ix3]+logoff)) + 1;
                  if(length==1) mi_swt="0"+mi_swt;
 
                  if(sec[ix3]==0) logoff=1; else logoff=0;
                  length = (int) floor( log10 (round(sec[ix3])+logoff)) + 1;
                  if(length==1) s_swt2="0"+s_swt2;
 
                  tswt_ini=y_swt+"-"+mo_swt+"-"+d_swt+"T"+h_swt+":"+mi_swt+":"+s_swt2+"Z";
                  tswt_ini_file=y_swt+mo_swt+d_swt+"T"+h_swt+mi_swt+s_swt2.substr(0,2)+"Z";
 
                  y_swt=std::to_string(year[ix4]);
                  mo_swt=std::to_string(mon[ix4]);
                  d_swt=std::to_string(day[ix4]);
                  h_swt=std::to_string(hour[ix4]);
                  mi_swt=std::to_string(min[ix4]);
                  s_swt2=std::to_string(round(sec[ix4]));
 
 
                  length = (int) floor( log10 (mon[ix4]) ) + 1;
                  if(length==1) mo_swt="0"+mo_swt;
                  length = (int) floor( log10 (day[ix4]) ) + 1;
                  if(length==1) d_swt="0"+d_swt;
 
                    if(hour[ix4]==0) logoff=1; else logoff=0;
                  length = (int) floor( log10 (hour[ix4]+logoff)) + 1;
                  if(length==1) h_swt="0"+h_swt;
 
                  if(min[ix4]==0) logoff=1; else logoff=0;
                  length = (int) floor( log10 (min[ix4]+logoff)) + 1;
                  if(length==1) mi_swt="0"+mi_swt;
 
                  if(sec[ix4]==0) logoff=1; else logoff=0;
                  length = (int) floor( log10 (round(sec[ix4])+logoff)) + 1;
                  if(length==1) s_swt2="0"+s_swt2;
 
                  tswt_end=y_swt+"-"+mo_swt+"-"+d_swt+"T"+h_swt+":"+mi_swt+":"+s_swt2+"Z";
 
  
                  sum1=0,sum3=0,c=0;
                 while(kk<=ix4){
                      latswt[c]=orb_lat[kk];
                      lonswt[c]=orb_lon[kk];
                      tswt[c]=orb_time[kk];        
                   sum1+=orb_vel[kk];
                      sum3+=grn_vel[kk];
                   kk++;
                      c++;
                     }
                //computing mean swath velocity (m/s) --------------------------
                  mov1 = (sum1 /norbs);//mean velocity in m/s x 10^3
                  mgv1 = (sum3 /norbs)*1000;
                  cout<<"mov1..."<<mov1<<"mvg1..."<<mgv1<<endl;
 
                  status2=ect_swt(1,l1cfile,norbs,tswt,latswt,lonswt,&tcross1,&loncross1);
                  cout<<"nswath==3 --tcross equat crossing in (s)..swath#1.(segment #2).."<<tcross1<<"loncross1..."<<loncross1<<endl;
                }
 
                 l1cfile->num_gridlines=4001;
 
                 if(status1==0 || status2==0){
                   tmgv1=(double*)calloc(l1cfile->num_gridlines,sizeof(double));
                   tmgvf=(double*)calloc(l1cfile->num_gridlines,sizeof(double));
 
                   cout<<"#gridlines..."<<l1cfile->num_gridlines<<"norbs.."<<norbs<<endl;
 
                   swtime_swt2(1,l1cinput,l1cfile,norbs,tswt,tcross1,mgv1,tmgv1);
                               
                   num_gridlines = l1cfile->num_gridlines;
               
                  //tini/tend for each swath
                   l1cfile->tswt_ini=tswt_ini;
                   l1cfile->tswt_end=tswt_end;
                   l1cfile->tswt_ini_file=tswt_ini_file;
 
                   if(tswt != nullptr)
                     delete[](tswt);
                   tswt= nullptr;
                   if (latswt != nullptr)
                     delete[](latswt);
                   latswt= nullptr;
                   if (lonswt != nullptr)
                     delete[](lonswt);
                   lonswt= nullptr;
              
                //first interpolation
                   lati=(float*)calloc(num_gridlines,sizeof(float));
                   loni=(float*)calloc(num_gridlines,sizeof(float));
                   lati2=(float*)calloc(num_gridlines,sizeof(float));
                   loni2=(float*)calloc(num_gridlines,sizeof(float));
                   az_gd = (float*)calloc(num_gridlines,sizeof(float));
 
                   cout<<"number of across bins L1C grid...#.."<<l1cfile->nbinx<<endl;
                   lat_gd = allocate2d_float(4001, l1cfile->nbinx);
                   lon_gd = allocate2d_float(4001, l1cfile->nbinx);
 
                   orb_array2* posgrid = new orb_array2[num_gridlines]();//these are doubles
                   orb_array2* velgrid = new orb_array2[num_gridlines]();
 
                   orb_array2* posgrid2 = new orb_array2[num_gridlines]();//these are doubles
                   orb_array2* velgrid2 = new orb_array2[num_gridlines]();
 
 
//interp 1-- always based on orbitals---                   
     //interpola pos/veloc as a function of time                  
                   orb_interp2(number_orecords, num_gridlines,orb_time,posr,velr,tmgv1, posgrid,velgrid);
                                                  
                   for(int i=0;i<num_gridlines-1;i++){
                          pos_norm=sqrt(posgrid[i][0]*posgrid[i][0]+posgrid[i][1]*posgrid[i][1]+posgrid[i][2]*posgrid[i][2]);
                          clatg2=sqrt(posgrid[i][0]*posgrid[i][0]+posgrid[i][1]*posgrid[i][1])/pos_norm;
                          rl2=Re*(1-fe)/(sqrt(1-(2-fe)*fe*clatg2*clatg2));
 
                          v2[0]=velgrid[i][0]*rl2/pos_norm;
                          v2[1]=velgrid[i][1]*rl2/pos_norm;
                          v2[2]=velgrid[i][2]*rl2/pos_norm;
 
                          vi=sqrt(v2[0]*v2[0]+v2[1]*v2[1]+v2[2]*v2[2])*1000;
                          toff=vi/mgv1;    
                          tmgvf[i]=tmgv1[i]+toff;
                            }
 
                   l1cfile->tfile_ini_sec=tfile_ini_sec;   
 
                   deltasec=tmgvf[num_gridlines-2]-tmgvf[0]+1;
                   cout<<"deltasec..swath."<<deltasec<<endl;
 
                   orb_interp2(number_orecords, num_gridlines,orb_time,posr,velr,tmgvf, posgrid2,velgrid2);
                               
                  //angle subsat track----
                   omf2=(1-fe)*(1-fe);
 
                   for(int i=0;i<num_gridlines-1;i++){ 
                        pos_norm=sqrt(posgrid2[i][0]*posgrid2[i][0]+posgrid2[i][1]*posgrid2[i][1]+posgrid2[i][2]*posgrid2[i][2]);
                        clatg2=sqrt(posgrid2[i][0]*posgrid2[i][0]+posgrid2[i][1]*posgrid2[i][1])/pos_norm;
                        rl2=Re*(1-fe)/(sqrt(1-(2-fe)*fe*clatg2*clatg2));
 
                        v1[0]=(posgrid2[i][0])*rl2/pos_norm;
                        v1[1]=(posgrid2[i][1])*rl2/pos_norm;
                        v1[2]=(posgrid2[i][2])*rl2/pos_norm;
 
                        v2[0]=(velgrid2[i][0])*rl2/pos_norm;
                        v2[1]=(velgrid2[i][1])*rl2/pos_norm;
                        v2[2]=(velgrid2[i][2])*rl2/pos_norm;         
 
                        cross_product_double(v1,v2,vecout);
                        nvec=cross_product_norm_double(v1,v2);//length of orb norm vect
 
                        orbnorm[0]=vecout[0]/nvec;
                        orbnorm[1]=vecout[1]/nvec;
                        orbnorm[2]=vecout[2]/nvec;
 
                   for(int j=0;j<l1cfile->nbinx;j++){
 
                      pos_norm=sqrt(v1[0]*v1[0]+v1[1]*v1[1]+v1[2]*v1[2]);//first gridline 
 
                      oangle=asin((j-(l1cfile->nbinx-1)/2)*5.2/pos_norm);
 
                  //Geocentric vector
                      G[0]=v1[0]*cos(oangle)-orbnorm[0]*pos_norm*sin(oangle);
                      G[1]=v1[1]*cos(oangle)-orbnorm[1]*pos_norm*sin(oangle);
                      G[2]=v1[2]*cos(oangle)-orbnorm[2]*pos_norm*sin(oangle);
                      
                      glon=atan2(G[1],G[0])*180/M_PI;
 
                      gnorm = sqrt(G[0]*G[0]+G[1]*G[1]+G[2]*G[2]);
                      omf2p = (omf2*rem + gnorm - rem)/gnorm;
                      pxy = G[0]*G[0]+G[1]*G[1];
                      temp = sqrt(G[2]*G[2] + omf2p*omf2p*pxy);
                      glat=asin(G[2]/temp)*180/M_PI;
 
                      lat_gd[i][j]=glat;
                      lon_gd[i][j]=glon;
 
                      //altitude
              //        clatg = cos(atan(omf2*tan(glat*M_PI/180.)));
            //          rl = re*(1.-fe)/sqrt(1.-(2.-fe)*fe*clatg*clatg);
               //       alt = gnorm - rl;
                   }
                  }
                                         
                   if (posgrid != nullptr)
                     delete[](posgrid);
               
                   if (velgrid != nullptr)
                     delete[](velgrid);  
                   
                   if (posgrid2 != nullptr)
                     delete[](posgrid2);
 
                   if (velgrid2 != nullptr)
                     delete[](velgrid2);           
 
                   l1cfile->num_gridlines = l1cfile->num_gridlines-1;
          //        create_SOCEA(1,l1cinput,l1cfile,lat_gd,lon_gd);//SWATH PROCESSING
 
//--------------------------------------------------------------
//granule processing---------------------------------------------                 
//---------------------------------------------------------------
                   numgran=144*2;
                   l1cfile->numgran=numgran;
                   gd_per_gran=round(num_gridlines/10);
                   l1cfile->gd_per_gran=gd_per_gran;
 
                   cout<<"estimated # of granules to be processed..."<<numgran<<"gd_per_gran..."<<gd_per_gran<<"#gridlines.."<<num_gridlines<<endl;
 
//                   write_L1C_granule(1,l1cfile,l1cinput,tmgvf,lat_gd, lon_gd);
 
 
 
//-----------------------------------------------------------------
//-----------------------------------------------------------------                   
 
                   if (lat_gd != nullptr)
                      delete [](lat_gd);
                   lat_gd = nullptr;
                   if (lon_gd != nullptr)
                       delete [](lon_gd);
                   lon_gd = nullptr;
                   if (az_gd != nullptr)
                     delete [](az_gd);
                   az_gd = nullptr;
 
                   if (lati != nullptr)
                       delete[](lati);
                   lati= nullptr;
                   if (loni != nullptr)
                     delete[](loni);
                   loni= nullptr;
 
                   if (lati2 != nullptr)
                       delete[](lati2);
                   lati2= nullptr;
                   if (loni2 != nullptr)
                     delete[](loni2);
                   loni2= nullptr;
 
                   if (tmgv1 != nullptr)
                     delete[](tmgv1);
                   tmgv1= nullptr;
                   if (tmgvf != nullptr)
                     delete[](tmgvf);
                   tmgvf= nullptr;
                                   
                   }//end tcross                  
                 } //end 2 segments  swath 1
            
                 else{
                   cout<<"ERROR swath #1 does not cross the equator..."<<endl;
                   cout<<"checking swath #2..."<<endl;  
                 }
 
  
 //exit(1);
 
          
//-----------------------------------------------------------------------------------
//nswath =3
//swath 2
//----------------------------------------------------------------------------------
                kk=ix5;
                c=0;
                norbs=ix6-ix5+1;
                latmin=orb_lat[ix5];
                latmax=orb_lat[ix5];
 
                //orbit direction
                l1cfile->orb_dir=orb_dir[ix5];
 
                //ini and end UTC--this is swath orbital time, not interpolated time
                y_swt=std::to_string(year[ix5]);
                mo_swt=std::to_string(mon[ix5]);
                d_swt=std::to_string(day[ix5]);
                h_swt=std::to_string(hour[ix5]);
                mi_swt=std::to_string(min[ix5]);
                s_swt2=std::to_string(round(sec[ix5]));
 
                length = (int) floor( log10 (mon[ix5]) ) + 1;
                if(length==1) mo_swt="0"+mo_swt;
                length = (int) floor( log10 (day[ix5]) ) + 1;
                if(length==1) d_swt="0"+d_swt;
 
 
                if(hour[ix5]==0) logoff=1; else logoff=0;
                length = (int) floor( log10 (hour[ix5]+logoff)) + 1;
                if(length==1) h_swt="0"+h_swt;
 
                if(min[ix5]==0) logoff=1; else logoff=0;
                length = (int) floor( log10 (min[ix5]+logoff)) + 1;
                if(length==1) mi_swt="0"+mi_swt;
 
                if(sec[ix5]==0) logoff=1; else logoff=0;
                length = (int) floor( log10 (round(sec[ix5])+logoff)) + 1;
                if(length==1) s_swt2="0"+s_swt2;
 
                tswt_ini=y_swt+"-"+mo_swt+"-"+d_swt+"T"+h_swt+":"+mi_swt+":"+s_swt2.substr(0,2)+"Z";
                tswt_ini_file=y_swt+mo_swt+d_swt+"T"+h_swt+mi_swt+s_swt2.substr(0,2)+"Z";
 
                y_swt=std::to_string(year[ix6]);
                mo_swt=std::to_string(mon[ix6]);
                d_swt=std::to_string(day[ix6]);
                h_swt=std::to_string(hour[ix6]);
                mi_swt=std::to_string(min[ix6]);
                s_swt2=std::to_string(round(sec[ix6]));
 
                length = (int) floor( log10 (mon[ix6]) ) + 1;
                if(length==1) mo_swt="0"+mo_swt;
                length = (int) floor( log10 (day[ix6]) ) + 1;
                if(length==1) d_swt="0"+d_swt;
 
                if(hour[ix6]==0) logoff=1; else logoff=0;
                length = (int) floor( log10 (hour[ix6]+logoff)) + 1;
                if(length==1) h_swt="0"+h_swt;
 
                if(min[ix6]==0) logoff=1; else logoff=0;
                length = (int) floor( log10 (min[ix6]+logoff)) + 1;
                if(length==1) mi_swt="0"+mi_swt;
 
                if(sec[ix6]==0) logoff=1; else logoff=0;
                length = (int) floor( log10 (round(sec[ix6])+logoff)) + 1;
                if(length==1) s_swt2="0"+s_swt2;
 
                tswt_end=y_swt+"-"+mo_swt+"-"+d_swt+"T"+h_swt+":"+mi_swt+":"+s_swt2.substr(0,2)+"Z";
 
                tswt2=(double*)calloc(norbs,sizeof(double));
                latswt2=(double*)calloc(norbs,sizeof(double));
                lonswt2=(double*)calloc(norbs,sizeof(double));
 
                sum2=0,sum3=0,c=0;
                while(kk<=ix6){
                   latswt2[c]=orb_lat[kk];
                   lonswt2[c]=orb_lon[kk];
                   tswt2[c]=orb_time[kk];
 
                   if(orb_lat[kk]<=latmin){
                       latmin=orb_lat[kk];
                        }
                   if(orb_lat[kk]>=latmax){
                       latmax=orb_lat[kk];
                        }
 
                   sum2+=orb_vel[kk];
                   sum3+=grn_vel[kk];
                   kk++;
                   c++;
                     }
                mov2 = (sum2 /norbs);//mean velocity in m/s x 10^3
                mgv2 = (sum3 /norbs)*1000;//in meters/s  
 
                cout<<"mov2..."<<mov2<<"mvg2..."<<mgv2<<endl;
 
                status=ect_swt(2,l1cfile,norbs,tswt2,latswt2,lonswt2,&tcross2,&loncross2);
                cout<<"nswath==2 ---tcross equat crossing in (s)..swath#2..."<<tcross2<<"loncross2..."<<loncross2<<endl;
                cout<<"latmin.."<<latmin<<"latmax..."<<latmax<<endl;
 
                if (latswt2 != nullptr)
                     delete[](latswt2);
                latswt2= nullptr;
                if (lonswt2 != nullptr)
                     delete[](lonswt2);
                lonswt2= nullptr;               
 
                l1cfile->num_gridlines=4001;
 
                if(status==0){
                  tmgv2=(double*)calloc(l1cfile->num_gridlines,sizeof(double)); 
                  tmgvf2=(double*)calloc(l1cfile->num_gridlines,sizeof(double));
 
                  swtime_swt2(2,l1cinput,l1cfile,norbs,tswt2,tcross2,mgv2,tmgv2);
                 
                  num_gridlines = l1cfile->num_gridlines;
 
                  //tini/tend swath
                  l1cfile->tswt_ini=tswt_ini;
                  l1cfile->tswt_end=tswt_end;
                  l1cfile->tswt_ini_file=tswt_ini_file;
 
                  if(tswt2 != nullptr)
                     delete[](tswt2);
                  tswt2= nullptr;
 
                 //first interpolation                
                  lati=(float*)calloc(num_gridlines,sizeof(float));
                  loni=(float*)calloc(num_gridlines,sizeof(float));
                  lati2=(float*)calloc(num_gridlines,sizeof(float));
                  loni2=(float*)calloc(num_gridlines,sizeof(float));
                  az_gd = (float*)calloc(num_gridlines,sizeof(float));
 
                  cout<<"number of across bins L1C grid...#.."<<l1cfile->nbinx<<endl;
                  lat_gd = allocate2d_float(4001, l1cfile->nbinx);
                  lon_gd = allocate2d_float(4001, l1cfile->nbinx);
 
                  orb_array2* posgrid = new orb_array2[num_gridlines]();//these are doubles
                  orb_array2* velgrid = new orb_array2[num_gridlines]();
                  orb_array2* posgrid2 = new orb_array2[num_gridlines]();//these are doubles
                  orb_array2* velgrid2 = new orb_array2[num_gridlines]();
 
                  orb_interp2(number_orecords, num_gridlines,orb_time,posr,velr,tmgv2, posgrid,velgrid);
                 
                  for(int i=0;i<num_gridlines-1;i++){
                          pos_norm=sqrt(posgrid[i][0]*posgrid[i][0]+posgrid[i][1]*posgrid[i][1]+posgrid[i][2]*posgrid[i][2]);
                          clatg2=sqrt(posgrid[i][0]*posgrid[i][0]+posgrid[i][1]*posgrid[i][1])/pos_norm;
                          rl2=Re*(1-fe)/(sqrt(1-(2-fe)*fe*clatg2*clatg2));
 
                          v2[0]=velgrid[i][0]*rl2/pos_norm;
                          v2[1]=velgrid[i][1]*rl2/pos_norm;
                          v2[2]=velgrid[i][2]*rl2/pos_norm;
 
                          vi=sqrt(v2[0]*v2[0]+v2[1]*v2[1]+v2[2]*v2[2])*1000;
                          toff=vi/mgv2;    
                          tmgvf2[i]=tmgv2[i]+toff;
                            }
 
                  orb_interp2(number_orecords, num_gridlines,orb_time,posr,velr,tmgvf2, posgrid2,velgrid2);
 
                  //angle subsat track----
                  omf2=(1-fe)*(1-fe);
 
                  for(int i=0;i<num_gridlines-1;i++){ 
                        pos_norm=sqrt(posgrid2[i][0]*posgrid2[i][0]+posgrid2[i][1]*posgrid2[i][1]+posgrid2[i][2]*posgrid2[i][2]);
                        clatg2=sqrt(posgrid2[i][0]*posgrid2[i][0]+posgrid2[i][1]*posgrid2[i][1])/pos_norm;
                        rl2=Re*(1-fe)/(sqrt(1-(2-fe)*fe*clatg2*clatg2));
 
                        v1[0]=(posgrid2[i][0])*rl2/pos_norm;
                        v1[1]=(posgrid2[i][1])*rl2/pos_norm;
                        v1[2]=(posgrid2[i][2])*rl2/pos_norm;
 
                        v2[0]=(velgrid2[i][0])*rl2/pos_norm;
                        v2[1]=(velgrid2[i][1])*rl2/pos_norm;
                        v2[2]=(velgrid2[i][2])*rl2/pos_norm;         
 
                        cross_product_double(v1,v2,vecout);
                        nvec=cross_product_norm_double(v1,v2);//length of orb norm vect
 
                        orbnorm[0]=vecout[0]/nvec;
                        orbnorm[1]=vecout[1]/nvec;
                        orbnorm[2]=vecout[2]/nvec;
 
                   for(int j=0;j<l1cfile->nbinx;j++){
 
                      pos_norm=sqrt(v1[0]*v1[0]+v1[1]*v1[1]+v1[2]*v1[2]);//first gridline 
 
                      oangle=asin((j-(l1cfile->nbinx-1)/2)*5.2/pos_norm);
 
                  //Geocentric vector
                      G[0]=v1[0]*cos(oangle)-orbnorm[0]*pos_norm*sin(oangle);
                      G[1]=v1[1]*cos(oangle)-orbnorm[1]*pos_norm*sin(oangle);
                      G[2]=v1[2]*cos(oangle)-orbnorm[2]*pos_norm*sin(oangle);
                      
                      glon=atan2(G[1],G[0])*180/M_PI;
 
                      gnorm = sqrt(G[0]*G[0]+G[1]*G[1]+G[2]*G[2]);
                      omf2p = (omf2*rem + gnorm - rem)/gnorm;
                      pxy = G[0]*G[0]+G[1]*G[1];
                      temp = sqrt(G[2]*G[2] + omf2p*omf2p*pxy);
                      glat=asin(G[2]/temp)*180/M_PI;
 
                      lat_gd[i][j]=glat;
                      lon_gd[i][j]=glon;
 
                      //altitude
                 //     clatg = cos(atan(omf2*tan(glat*M_PI/180.)));
               //       rl = re*(1.-fe)/sqrt(1.-(2.-fe)*fe*clatg*clatg);
              //        alt = gnorm - rl;
                   }
                  }
                  
                   if (posgrid != nullptr)
                     delete[](posgrid);
               
                   if (velgrid != nullptr)
                     delete[](velgrid);  
                   
                   if (posgrid2 != nullptr)
                     delete[](posgrid2);
 
                   if (velgrid2 != nullptr)
                     delete[](velgrid2);           
 
                   l1cfile->num_gridlines = l1cfile->num_gridlines-1;
           //       create_SOCEA(1,l1cinput,l1cfile,lat_gd,lon_gd);//SWATH PROCESSING
                  
                  //--------------------------------------------------------------
//granule processing---------------------------------------------                 
//---------------------------------------------------------------
                   l1cfile->tfile_ini_sec=tfile_ini_sec;
 
                   deltasec=tmgvf2[num_gridlines-2]-tmgvf2[0]+1;
                   cout<<"deltasec..swath."<<deltasec<<endl;
 
                   numgran=144*2;
 
                   l1cfile->numgran=numgran;
                   gd_per_gran=round(num_gridlines/10);//10 granules per half orbit
                   l1cfile->gd_per_gran=gd_per_gran;
 
                   cout<<"estimated # of granules to be processed..."<<numgran<<"gd_per_gran..."<<gd_per_gran<<"#gridlines.."<<num_gridlines<<endl;
 
                   write_L1C_granule(2,l1cfile,l1cinput,tmgvf2,lat_gd, lon_gd);
 
//---------------------------------------------------------------
//---------------------------------------------------------------
                  if (lat_gd != nullptr)
                    delete [](lat_gd);
                  lat_gd = nullptr;
                  if (lon_gd != nullptr)
                       delete [](lon_gd);
                  lon_gd = nullptr;
                  if (az_gd != nullptr)
                    delete [](az_gd);
                  az_gd = nullptr;
 
                  if (lati != nullptr)
                     delete[](lati);
                  lati= nullptr;
                  if (loni != nullptr)
                     delete[](loni);
                  loni= nullptr;
 
                  if (lati2 != nullptr)
                     delete[](lati2);
                  lati2= nullptr;
                  if (loni2 != nullptr)
                     delete[](loni2);
                  loni2= nullptr;
                 if (tmgv2 != nullptr)
                     delete[](tmgv2);
                 tmgv2= nullptr;
                  if (tmgvf2 != nullptr)
                     delete[](tmgvf2);
                  tmgvf2= nullptr;
 
        }
        else {
                     cout<<"ERROR swath #2 does not cross the equator..NO L1C grid for swath #2"<<endl;
              }
 
    }//end nswath =3
 
         ix.clear();
 
         if (tai58_sec != nullptr)
               delete[](tai58_sec);
         tai58_sec= nullptr;
 
         if (sec != nullptr)
               delete[](sec);
         sec= nullptr;
 
         if (year != nullptr)
               delete[](year);
         year= nullptr;
 
         if (mon != nullptr)
               delete[](mon);
         mon= nullptr;
 
         if (day != nullptr)
               delete[](day);
         day= nullptr;
 
         if (hour != nullptr)
               delete[](hour);
         hour= nullptr;
 
         if (min != nullptr)
               delete[](min);
         min= nullptr;
 
         if (orb_lat != nullptr)              
               delete[](orb_lat);
         orb_lat= nullptr;
 
         if (orb_lon != nullptr)
               delete[](orb_lon);
         orb_lon= nullptr;
 
         if (orb_time != nullptr)
               delete[](orb_time);
         orb_time= nullptr;
 
         if (orb_vel != nullptr)
               delete[](orb_vel);
         orb_vel= nullptr;
 
         if (grn_vel != nullptr)
               delete[](grn_vel);
          grn_vel= nullptr;
 
         if (orb_dir != nullptr)
               delete[](orb_dir);
         orb_dir= nullptr;
 
         if (posr != nullptr)
               delete[](posr);
            posr= nullptr;
 
         if (velr != nullptr)
               delete[](velr);
            velr= nullptr;
 
         if ((status = nc_close(ncid_L1A)))
            check_err(status, __LINE__, __FILE__);
 
    return 0;
    }
 
 
 
 
 
 
 
    int32_t L1C::open_l2tol1c(l1c_filehandle *l1cfile, L1C_input *l1cinput){
           int32_t n_files;
           const char* ptstr;
           int status,nl2prod,dimid;
           string str;
           float **latpix=nullptr, **lonpix=nullptr,**l2pix=nullptr;
           float slope=0,offset=0;
     
    //       cout<<"checking l2 product..index must be between 0 and 345."<<CAT_chl_xx"<<endl;
 
      // If l3bprod="ALL", replace with product list from first file
    /*   if (boost::iequals(input.l3bprod, "ALL")) {
           vector<string> l2prods(l2_str[0].prodname, l2_str[0].prodname+l2_str[0].nprod);
           string joined = boost::algorithm::join(l2prods, ":");
           strcpy(input.l3bprod, joined.c_str());
 
        // fix l3bprod entry in Input Parameters attribute
           string parms = input.parms;
           boost::ireplace_all(parms, "l3bprod = ALL", "l3bprod = " + joined);
           strcpy(input.parms, parms.c_str());
              }
*/
    // Parse L3 Product list
           n_files = l1cfile->ifiles.size();
 
           string delim1 = ":, ";  // product delimiters
           string l2prod = l1cinput->l2prod;
           boost::trim_if(l2prod, boost::is_any_of(delim1));
           vector<string> prodparam;
           boost::algorithm::split(prodparam, l2prod,
                            boost::is_any_of(delim1));
           cout<<"number of L2 products to be processed...................#:..."<<prodparam.size()<<endl;
           for(size_t iprod=0;iprod<prodparam.size();iprod++){
            cout<<"selected L2 ----------- prodparam...."<<prodparam[iprod]<<endl;
             }
 
           nl2prod=prodparam.size();//number of selected l2 products
           int prodims[nl2prod];
 
 
    //opening datafile for binning-----       
         for (int i = 0;i < n_files;i++) {
            str = l1cfile->ifiles[i];
            ptstr = str.c_str();
            cout<<"Opening L2 file ..."<<ptstr<<"for SDS binning......."<<endl;
 
            // Open the netcdf4 input file
            status = nc_open(ptstr, NC_NOWRITE, &ncid_L2);
            if (status != NC_NOERR) {
                fprintf(stderr, "-E- Error failed nc_open.\n");
                        exit(EXIT_FAILURE);            
            }
 
          //dimensions
          //num_scans num_pixels
            status = nc_inq_dimid(ncid_L2, "number_of_lines", &dimid);
            check_err(status, __LINE__, __FILE__);
            nc_inq_dimlen(ncid_L2, dimid, &num_scans);
            status = nc_inq_dimid(ncid_L2, "pixels_per_line", &dimid);
            check_err(status, __LINE__, __FILE__);  
            nc_inq_dimlen(ncid_L2, dimid, &num_pixels);
 
            cout<<"num_scans..."<<num_scans<<"num_pixels...."<<num_pixels<<endl;
            l1cfile->nscan=num_scans;
            l1cfile->npix=num_pixels;
          
 
          //open groups and variables  
            status = nc_inq_grp_ncid(ncid_L2, "navigation_data", &geoGrp);
                check_err(status, __LINE__, __FILE__);
            status = nc_inq_varid(geoGrp, "latitude", &latId);
                check_err(status, __LINE__, __FILE__);
            status = nc_inq_varid(geoGrp, "longitude", &lonId);
                   check_err(status, __LINE__, __FILE__);    
            status = nc_inq_grp_ncid(ncid_L2, "geophysical_data", &obsGrp);
                check_err(status, __LINE__, __FILE__); 
 
            for (int iprod = 0;iprod <nl2prod;iprod++) {          
               cout<<"getting sds id for product.."<<prodparam[iprod].c_str()<<endl; 
               status = nc_inq_varid(obsGrp, prodparam[iprod].c_str(), &prodims[iprod]);
                check_err(status, __LINE__, __FILE__);
                  }
 
         //allocating mem
            latpix = allocate2d_float(num_scans, num_pixels);
            lonpix = allocate2d_float(num_scans, num_pixels);
            l2pix = allocate2d_float(num_scans, num_pixels);
         //opening variables
            status = nc_get_var_float(geoGrp, latId, &latpix[0][0]);
            check_err(status, __LINE__, __FILE__);
            status = nc_get_var_float(geoGrp, lonId, &lonpix[0][0]);
            check_err(status, __LINE__, __FILE__);
            status = nc_get_var_float(obsGrp, prodims[0], &l2pix[0][0]);
            check_err(status, __LINE__, __FILE__);
 
            string ATT_NAME1="scale_factor",ATT_NAME2="add_offset";
 
            if (nc_get_att_float(obsGrp, prodims[0], ATT_NAME1.c_str(), &slope))
             check_err(status, __LINE__, __FILE__);
            if (nc_get_att_float(obsGrp, prodims[0], ATT_NAME2.c_str() , &offset))
             check_err(status, __LINE__, __FILE__);
 
            if ((status = nc_close(ncid_L2)))
            check_err(status, __LINE__, __FILE__);
 
            delete [](latpix);
            delete [](lonpix);
            delete [](l2pix);
           } 
 
    // expand 3D products
        //   string delim2 = ";=";  // minval delimiters
        //   string wave_string=std::string{","} + std::string{input.output_wavelengths} + ",";
 
   return 0;
 
    }
 
 
 
    //write mean Lt as nc file---
    int32_t L1C::savebinL1C_v2(int swtd, L1C_input* l1cinput, l1c_filehandle* l1cfile, float** lat_gd, float** lon_gd, float** Ltfracsum, float** areafracsum, float** nobs_perbin) {
 
        int32_t NY = -1, NX = -1, NY1 = -1, NY2 = -1, num_gridlines, nbinx;//create Lt file
        int16_t selyear = -1, selmon = -1, selday = -1;
        float** lat_out, ** lon_out;
        int status, ncid, x_dimid, y_dimid, varid, varid2, varid3, varid4, NDIMS;
        float** data_out, ** data_out2;
 
        int dimids[2];
        const char* filename_lt;
 
        nbinx = l1cfile->nbinx;
        num_gridlines = l1cfile->num_gridlines;
 
        selday = l1cinput->selday;
        selmon = l1cinput->selmon;
        selyear = l1cinput->selyear;
 
        std::string fname_out, pathstr, senstr, monstr, daystr, yearstr, prodstr, gdstr, swtstr, swtnum, extstr, granstr,ofilestr;
 
        pathstr = "out/";
        senstr = "OCIS_";
        monstr = std::to_string(selmon);
        daystr = std::to_string(selday);
        yearstr = std::to_string(selyear);
        prodstr = "binLt_blue1_AW";//area-weighted binned
        swtstr = "_swt";
        granstr = "";
        swtnum = std::to_string(swtd);
        extstr = ".nc";
        NDIMS = 2;
//        fname_out = pathstr + senstr + monstr + daystr + yearstr + prodstr + swtstr + swtnum + granstr + extstr;
        ofilestr=std::string(l1cinput->ofile);
        fname_out = pathstr + ofilestr+"_"+  prodstr + swtstr + swtnum + granstr + extstr;
 
        filename_lt = fname_out.c_str();
        if ((status = nc_create(filename_lt, NC_CLOBBER, &ncid)))
            check_err(status, __LINE__, __FILE__);
 
     // Define the dimensions. NetCDF will hand back an ID for each. 
 
        NY = num_gridlines;
        NX = nbinx;
 
        NY1 = l1cfile->NY1;//these are indexes not line #!!!!!!!!!!!!!!!!!
        NY2 = l1cfile->NY2;
        cout << "rowgrid ini.." << NY1 << "rowgrid end.." << NY2 << endl;
 
 
        cout << "NY.." << NY << "NX.." << NX << endl;
 
        //alloc mem for data_out and assign values from lat_gdI
        //NX AND NY are inverted for visualization in SeaDAS
        data_out = allocate2d_float(NY, NX);
        data_out2 = allocate2d_float(NY, NX);
        lat_out = allocate2d_float(NY, NX);
        lon_out = allocate2d_float(NY, NX);
 
        int c = 0;
        for (int i = NY1; i < NY2 + 1; i++) {
            for (int j = 0; j < NX; j++) {
                lat_out[NY - 1 - c][NX - 1 - j] = lat_gd[i][j];
                lon_out[NY - 1 - c][j] = lon_gd[i][j];
                //blue
                if (Ltfracsum[i][j] > 0 && areafracsum[i][j] > 0 && nobs_perbin[i][j] > 0) {
                    data_out[NY - 1 - c][NX - 1 - j] = Ltfracsum[i][j] / sqrt(areafracsum[i][j]);
                    data_out2[NY - 1 - c][NX - 1 - j] = nobs_perbin[i][j];
                }
                else {
                    data_out[NY - 1 - c][NX - 1 - j] = NAN;
                    data_out2[NY - 1 - c][NX - 1 - j] = 0;
                }
            }
            c++;
        }
 
 
 
        if ((status = nc_def_dim(ncid, "x", NX, &x_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid, "y", NY, &y_dimid)))
            check_err(status, __LINE__, __FILE__);
        //dims for output var
        dimids[0] = y_dimid;
        dimids[1] = x_dimid;
        //def var
        if ((status = nc_def_var(ncid, "binLt_blue_AW", NC_FLOAT, NDIMS,
            dimids, &varid)))
            check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_def_var(ncid, "lat_gd", NC_FLOAT, NDIMS,
            dimids, &varid2)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_var(ncid, "lon_gd", NC_FLOAT, NDIMS,
            dimids, &varid3)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_var(ncid, "nobs_perbin_AW", NC_FLOAT, NDIMS,
            dimids, &varid4)))
            check_err(status, __LINE__, __FILE__);
 
 
        if ((status = nc_enddef(ncid))) //done def vars etc
            check_err(status, __LINE__, __FILE__);
 
        //writing the whole thing
        if ((status = nc_put_var_float(ncid, varid2, &lat_out[0][0])))
            check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_put_var_float(ncid, varid3, &lon_out[0][0])))
            check_err(status, __LINE__, __FILE__);
        //blue
        if ((status = nc_put_var_float(ncid, varid, &data_out[0][0])))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_put_var_float(ncid, varid4, &data_out2[0][0])))
            check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_close(ncid)))
            check_err(status, __LINE__, __FILE__);
 
        delete[](lat_out);
        delete[](lon_out);
        delete[](data_out);
        delete[](data_out2);
 
        cout << "***********************    sucess writing area-wighted Lt nc file ****************************************************" << endl;
 
        return 0;
    }
 
 
 
 
    bool L1C::binIntersectsPix4corn4_l1c(l1c_filehandle* l1cfile, L1C_input* l1cinput, short row, short col, float** lat_gd, float** lon_gd, Polygon_t& pixelPoly, double areaFracBox[3][3], double areabinBox[3][3]) {
        bool result = false;
        double  ws_lat, wn_lat, es_lat, en_lat, ws_lon, wn_lon, es_lon, en_lon;
        double ws_lat2, wn_lat2, es_lat2, en_lat2, ws_lon2, wn_lon2, es_lon2, en_lon2;
        double ws_lat3, wn_lat3, es_lat3, en_lat3, ws_lon3, wn_lon3, es_lon3, en_lon3;
        double ws_lat4, wn_lat4, es_lat4, en_lat4, ws_lon4, wn_lon4, es_lon4, en_lon4;
        double ws_lat5, wn_lat5, es_lat5, en_lat5, ws_lon5, wn_lon5, es_lon5, en_lon5;
        double ws_lat6, wn_lat6, es_lat6, en_lat6, ws_lon6, wn_lon6, es_lon6, en_lon6;
        double ws_lat7, wn_lat7, es_lat7, en_lat7, ws_lon7, wn_lon7, es_lon7, en_lon7;
        double ws_lat8, wn_lat8, es_lat8, en_lat8, ws_lon8, wn_lon8, es_lon8, en_lon8;
        double ws_lat9, wn_lat9, es_lat9, en_lat9, ws_lon9, wn_lon9, es_lon9, en_lon9;
        bool ingeom = false;
        int pc = 1;
        double intersectArea = 0, binAreapix = 0, binAreagrid = 0.;
        std::string ws_lon_str, ws_lat_str, wn_lon_str, wn_lat_str, en_lon_str, en_lat_str, es_lon_str, es_lat_str, gridstr;
        std::string ws2_lon_str, ws2_lat_str, wn2_lon_str, wn2_lat_str, en2_lon_str, en2_lat_str, es2_lon_str, es2_lat_str;
        std::string ws3_lon_str, ws3_lat_str, wn3_lon_str, wn3_lat_str, en3_lon_str, en3_lat_str, es3_lon_str, es3_lat_str;
        std::string ws4_lon_str, ws4_lat_str, wn4_lon_str, wn4_lat_str, en4_lon_str, en4_lat_str, es4_lon_str, es4_lat_str;
        std::string ws5_lon_str, ws5_lat_str, wn5_lon_str, wn5_lat_str, en5_lon_str, en5_lat_str, es5_lon_str, es5_lat_str;
        std::string ws6_lon_str, ws6_lat_str, wn6_lon_str, wn6_lat_str, en6_lon_str, en6_lat_str, es6_lon_str, es6_lat_str;
        std::string ws7_lon_str, ws7_lat_str, wn7_lon_str, wn7_lat_str, en7_lon_str, en7_lat_str, es7_lon_str, es7_lat_str;
        std::string ws8_lon_str, ws8_lat_str, wn8_lon_str, wn8_lat_str, en8_lon_str, en8_lat_str, es8_lon_str, es8_lat_str;
        std::string ws9_lon_str, ws9_lat_str, wn9_lon_str, wn9_lat_str, en9_lon_str, en9_lat_str, es9_lon_str, es9_lat_str;
        float binres = 0, azgc,deltaphi, deltalam, azpixc;
        float aterm, bterm, dist_u, dist_v, theta, thetares,thetagrad,dist_corn2, mean_az_east;
        double res1, res2, res3, res4, lat1, lon1, lat2, lon2;
        float az1, az2, az3, az4;
        bool infull = false;
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
 
 
        mean_az_east = l1cfile->mean_az_east; //in degrees
 
    //    cout<<"mean az east.for L1C grid................. in degrees..."<<mean_az_east<<endl;
        binres = (l1cinput->gres);//in km
 
//        cout << "binIntersectsPix4corn4_l1c...........................row......" << row << "col...." << col << endl;
 
        //*******************************************************************************************
        //center center bin
        //********************************************************************************************************
        ingeom = 0, binAreagrid = 0., binAreapix = 0, intersectArea = 0., pc = 1;
        deltaphi = (lat_gd[row][col] - lat_gd[row][col + 1]) * degrad;
        deltalam = (lon_gd[row][col] - lon_gd[row][col + 1]) * degrad;
        //across-track grid size
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row][col] * degrad) * cos(lat_gd[row][col + 1] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_u = Re * bterm;         //horizontal distance Harversine in km
 
        deltaphi = (lat_gd[row][col] - lat_gd[row + 1][col]) * degrad;
        deltalam = (lon_gd[row][col] - lon_gd[row + 1][col]) * degrad;
        //along-track distance
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row][col] * degrad) * cos(lat_gd[row + 1][col] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_v = Re * bterm;
 
        lat1 = lat_gd[row][col];
        lon1 = lon_gd[row][col];
        lat2 = lat_gd[row][col + 1];
        lon2 = lon_gd[row][col + 1];
        geod.Inverse(lat1, lon1, lat2, lon2, res1);
 
        //    ad=0.5*(sqrt(dist_u*dist_u+dist_v*dist_v)/Re);   
//        dist_corn = 0.5 * sqrt(dist_u * dist_u + dist_v * dist_v) * 1000;
        dist_corn2 = 0.5 * sqrt(binres * binres + binres * binres) * 1000;
 
        //azimuth grid cell calculation
    //    azgc=atan2(sin(deltalam)*cos(lat_gd[row+1][col]*degrad),cos(lat_gd[row][col]*degrad)*sin(lat_gd[row+1][col]*degrad)-sin(lat_gd[row][col]*degrad)*cos(lat_gd[row+1][col]*degrad)*cos(deltaphi));
        azgc = (mean_az_east - 90) * degrad;//this is the bearing
 
        if (azgc > M_PI || azgc < -M_PI)cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "azpixc in degrees.." << azgc * 180 / M_PI << endl;
 
        theta = atan2(dist_v, dist_u);
        thetagrad = 2 * theta * 180 / M_PI;
        thetares = (M_PI / 2 - theta) * 180 / M_PI;
        azgc = azgc * 180 / M_PI;
 
        //nw corner 
        azpixc = (azgc - thetares) * degrad;//pixel bearing
        if (azpixc > M_PI || azpixc < -M_PI) {
            cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "NW azpixc in degrees.." << azpixc * 180 / M_PI << endl;
            exit(1);
        }
 
        azpixc = azpixc * 180 / M_PI;
        az1 = azpixc;
        geod.Direct(lat_gd[row][col], lon_gd[row][col], azpixc, dist_corn2, wn_lat, wn_lon);
        geod.Inverse(lat_gd[row][col], lon_gd[row][col], wn_lat, wn_lon, res1);
        //    cout<<"azgc.Center-Center."<<azgc<<"azpixc.."<<azpixc<<"dist_corn.."<<dist_corn<<"dist_corn2.."<<dist_corn2<<endl;
        //    cout<<"res1..nw."<<res1<<endl;
 
        //ne corner 
        azpixc = (azgc + thetares) * degrad;//pixel bearing
        if (azpixc > M_PI || azpixc < -M_PI) {
            cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "NE azpixc in degrees.." << azpixc * 180 / M_PI << endl;
            exit(1);
        }
 
        azpixc = azpixc * 180 / M_PI;
        az2 = azpixc;
        geod.Direct(lat_gd[row][col], lon_gd[row][col], azpixc, dist_corn2, en_lat, en_lon);
        geod.Inverse(lat_gd[row][col], lon_gd[row][col], en_lat, en_lon, res2);
        //  cout<<"azpixc.."<<azpixc<<"res2 ne.."<<res2<<endl;
      //sw corner 
        azpixc = (azgc - thetares - thetagrad) * degrad;//pixel bearing
        if (azpixc > M_PI || azpixc < -M_PI) {
            cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "SW azpixc in degrees.." << azpixc * 180 / M_PI << endl;
            exit(1);
        }
 
        azpixc = azpixc * 180 / M_PI;
        az3 = azpixc;
        geod.Direct(lat_gd[row][col], lon_gd[row][col], azpixc, dist_corn2, ws_lat, ws_lon);
        geod.Inverse(lat_gd[row][col], lon_gd[row][col], ws_lat, ws_lon, res3);
        //   cout<<"azpixc.."<<azpixc<<"res3..sw.."<<res3<<endl;
 
       //se corner 
        azpixc = (azgc + thetares + thetagrad) * degrad;//pixel bearing
        if (azpixc > M_PI || azpixc < -M_PI) {
            cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "SE azpixc in degrees.." << azpixc * 180 / M_PI << endl;
            exit(1);
        }
 
        azpixc = azpixc * 180 / M_PI;
        az4 = azpixc;
        geod.Direct(lat_gd[row][col], lon_gd[row][col], azpixc, dist_corn2, es_lat, es_lon);
        geod.Inverse(lat_gd[row][col], lon_gd[row][col], es_lat, es_lon, res4);
        //    cout<<"azpixc.."<<azpixc<<"res4...se.."<<res4<<endl;
 
        Polygon_t gridPoly;
        ws_lon_str = std::to_string(ws_lon);
        ws_lat_str = std::to_string(ws_lat);
        wn_lon_str = std::to_string(wn_lon);
        wn_lat_str = std::to_string(wn_lat);
        en_lon_str = std::to_string(en_lon);
        en_lat_str = std::to_string(en_lat);
        es_lon_str = std::to_string(es_lon);
        es_lat_str = std::to_string(es_lat);
        gridstr = "POLYGON((" + ws_lon_str + " " + ws_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + en_lon_str + " " + en_lat_str + "," + es_lon_str + " " + es_lat_str + "," + ws_lon_str + " " + ws_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2
    /*
        cout<<"center center-----------------"<<endl;
        cout<<"gd_row.."<<row<<"gd_col.."<<col<<endl;
        cout<<"dist_u.."<<dist_u<<"dist_v.."<<dist_v<<endl;
        cout<<"ingeom.."<<ingeom<<"binAreagrid..."<<binAreagrid<<"binAreapix.."<<binAreapix<<endl;
        cout<<"lat_gd.."<<lat_gd[row][col]<<"lon_gd.."<<lon_gd[row][col]<<"wn_lat.."<<wn_lat<<"wn_lon.."<<wn_lon<<endl;
        cout<<"lat_gd.."<<lat_gd[row][col]<<"lon_gd.."<<lon_gd[row][col]<<"ws_lat.."<<ws_lat<<"ws_lon.."<<ws_lon<<endl;
        cout<<"lat_gd.."<<lat_gd[row][col]<<"lon_gd.."<<lon_gd[row][col]<<"en_lat.."<<en_lat<<"en_lon.."<<en_lon<<endl;
        cout<<"lat_gd.."<<lat_gd[row][col]<<"lon_gd.."<<lon_gd[row][col]<<"es_lat.."<<es_lat<<"es_lon.."<<es_lon<<endl;
    */
        areabinBox[1][1] = binAreagrid;
 
        if (ingeom > 0) { //pixel fully inside the grid cell
            infull = true;
            intersectArea = binAreapix;
            result = true;
            areaFracBox[1][1] = intersectArea / binAreagrid;
 
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                std::deque<Polygon_t> output;//this is a list
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[1][1] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[1][1] = 0.0;
                            pc++;
                        }
                    }
                }
            }
        }//end else
 
    //   cout<<"center center.."<<"areaFracBox[1][1].........................................."<<areaFracBox[1][1]<<endl;
 
    //***********************************************************************************************************
       //left center bin
        //********************************************************************************************************
        ingeom = 0, binAreagrid = 0., binAreapix = 0, intersectArea = 0., pc = 1;
        if (col >= 1) {
 
            deltaphi = (lat_gd[row][col - 1] - lat_gd[row][col]) * degrad;
            deltalam = (lon_gd[row][col - 1] - lon_gd[row][col]) * degrad;
            //across-track grid size
            aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row][col - 1] * degrad) * cos(lat_gd[row][col] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
            bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
            dist_u = Re * bterm;         //horizontal distance Harversine in km
 
            deltaphi = (lat_gd[row][col - 1] - lat_gd[row + 1][col - 1]) * degrad;
            deltalam = (lon_gd[row][col - 1] - lon_gd[row + 1][col - 1]) * degrad;
            //along-track distance
            aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row][col - 1] * degrad) * cos(lat_gd[row + 1][col - 1] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
            bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
            dist_v = Re * bterm;
 
            theta = atan2(dist_v, dist_u);
            thetagrad = 2 * theta * 180 / M_PI;
            thetares = (M_PI / 2 - theta) * 180 / M_PI;
 
 
            //nw corner
            azpixc = az1;
            geod.Direct(lat_gd[row][col - 1], lon_gd[row][col - 1], azpixc, dist_corn2, wn_lat2, wn_lon2);
            geod.Inverse(lat_gd[row][col - 1], lon_gd[row][col - 1], wn_lat2, wn_lon2, res1);
            //   cout<<"azgc..CENTER-LEFT"<<azgc<<"azpixc.."<<azpixc<<"dist_corn.."<<dist_corn<<"dist_corn2.."<<dist_corn2<<endl;
            //   cout<<"res1..nw."<<res1<<endl;
           //ne corner 
            azpixc = az2;
            geod.Direct(lat_gd[row][col - 1], lon_gd[row][col - 1], azpixc, dist_corn2, en_lat2, en_lon2);
            geod.Inverse(lat_gd[row][col - 1], lon_gd[row][col - 1], en_lat2, en_lon2, res2);
            //   cout<<"azpixc.."<<azpixc<<"res2 ne.."<<res2<<endl;
           //sw corner 
            azpixc = az3;
            geod.Direct(lat_gd[row][col - 1], lon_gd[row][col - 1], azpixc, dist_corn2, ws_lat2, ws_lon2);
            geod.Inverse(lat_gd[row][col - 1], lon_gd[row][col - 1], ws_lat2, ws_lon2, res3);
            //   cout<<"azpixc.."<<azpixc<<"res3..sw.."<<res3<<endl;
           //se corner 
            azpixc = az4;
            geod.Direct(lat_gd[row][col - 1], lon_gd[row][col - 1], azpixc, dist_corn2, es_lat2, es_lon2);
            geod.Inverse(lat_gd[row][col - 1], lon_gd[row][col - 1], es_lat2, es_lon2, res4);
            //   cout<<"azpixc.."<<azpixc<<"res4...se.."<<res4<<endl;
 
            Polygon_t gridPoly;
            ws2_lon_str = std::to_string(ws_lon2);
            ws2_lat_str = std::to_string(ws_lat2);
            wn2_lon_str = std::to_string(wn_lon2);
            wn2_lat_str = std::to_string(wn_lat2);
            en2_lon_str = std::to_string(en_lon2);
            en2_lat_str = std::to_string(en_lat2);
            es2_lon_str = std::to_string(es_lon2);
            es2_lat_str = std::to_string(es_lat2);
            gridstr = "POLYGON((" + ws2_lon_str + " " + ws2_lat_str + "," + wn2_lon_str + " " + wn2_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + ws_lon_str + " " + ws_lat_str + "," + ws2_lon_str + " " + ws2_lat_str + "))";
            bg::read_wkt(gridstr, gridPoly);
 
            ingeom = within(pixelPoly, gridPoly);
            binAreagrid = bg::area(gridPoly);
            binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2
        /*
            cout<<"center LEFT-----------------"<<endl;
            cout<<"gd_row.."<<row<<"gd_col.."<<col<<endl;
            cout<<"dist_u.."<<dist_u<<"dist_v.."<<dist_v<<endl;
            cout<<"ingeom.."<<ingeom<<"binAreagrid..."<<binAreagrid<<"binAreapix.."<<binAreapix<<endl;
            cout<<"lat_gd.."<<lat_gd[row][col-1]<<"lon_gd.."<<lon_gd[row][col-1]<<"wn_lat.."<<wn_lat2<<"wn_lon.."<<wn_lon2<<endl;
            cout<<"lat_gd.."<<lat_gd[row][col-1]<<"lon_gd.."<<lon_gd[row][col-1]<<"ws_lat.."<<ws_lat2<<"ws_lon.."<<ws_lon2<<endl;
            cout<<"lat_gd.."<<lat_gd[row][col-1]<<"lon_gd.."<<lon_gd[row][col-1]<<"en_lat.."<<wn_lat<<"en_lon.."<<wn_lon<<endl;
            cout<<"lat_gd.."<<lat_gd[row][col-1]<<"lon_gd.."<<lon_gd[row][col-1]<<"es_lat.."<<ws_lat<<"es_lon.."<<ws_lon<<endl;
        */
 
            areabinBox[1][0] = binAreagrid;
 
            if (ingeom > 0) { //pixel fully inside the grid cell
                infull = true;
                intersectArea = binAreapix;
                result = true;
                areaFracBox[1][0] = intersectArea / binAreagrid;
            }
            else {
                if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                    std::deque<Polygon_t> output;
                    if (bg::intersection(pixelPoly, gridPoly, output)) {
                        BOOST_FOREACH(Polygon_t const& p, output)
                        {
                            intersectArea = bg::area(p);
                            if (intersectArea > 0.0 && pc == 1) {
                                result = true;
                                areaFracBox[1][0] = intersectArea / binAreagrid;
                                if (intersectArea / binAreagrid < 0.000001) areaFracBox[1][0] = 0.0;
                                binAreapix = bg::area(pixelPoly);
                                pc++;
                            }
                        }
                    }
                }
            }//end else
 
        }//end col>=1 left center bin
 
       // cout<<"center LEFT.."<<"areaFracBox[1][0]........................................."<<areaFracBox[1][0]<<endl;
 
 
       //***************************************************************************
        //right center bin
       //**************************************************************************8
        ingeom = 0, binAreagrid = 0., binAreapix = 0, intersectArea = 0.;
 
        deltaphi = (lat_gd[row][col + 1] - lat_gd[row][col + 2]) * degrad;
        deltalam = (lon_gd[row][col + 1] - lon_gd[row][col + 2]) * degrad;
        //across-track grid size
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row][col + 1] * degrad) * cos(lat_gd[row][col + 2] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_u = Re * bterm;         //horizontal distance Harversine in km
 
        deltaphi = (lat_gd[row][col + 1] - lat_gd[row + 1][col + 1]) * degrad;
        deltalam = (lon_gd[row][col + 1] - lon_gd[row + 1][col + 1]) * degrad;
        //along-track distance
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row][col + 1] * degrad) * cos(lat_gd[row + 1][col + 1] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_v = Re * bterm;
 
        theta = atan2(dist_v, dist_u);
        thetagrad = 2 * theta * 180 / M_PI;
        thetares = (M_PI / 2 - theta) * 180 / M_PI;
 
        //nw corner
        azpixc = az1;
        geod.Direct(lat_gd[row][col + 1], lon_gd[row][col + 1], azpixc, dist_corn2, wn_lat3, wn_lon3);
        geod.Inverse(lat_gd[row][col + 1], lon_gd[row][col + 1], wn_lat3, wn_lon3, res1);
        //   cout<<"azgc..CENTER-RIGHT..."<<azgc<<"azpixc.."<<azpixc<<"dist_corn.."<<dist_corn<<"dist_corn2.."<<dist_corn2<<endl;
        //   cout<<"res1..nw."<<res1<<endl;
 
       //ne corner 
        azpixc = az2;
        geod.Direct(lat_gd[row][col + 1], lon_gd[row][col + 1], azpixc, dist_corn2, en_lat3, en_lon3);
        geod.Inverse(lat_gd[row][col + 1], lon_gd[row][col + 1], en_lat3, en_lon3, res2);
        //   cout<<"azpixc.."<<azpixc<<"res2 ne.."<<res2<<endl;
       //sw corner 
        azpixc = az3;
        geod.Direct(lat_gd[row][col + 1], lon_gd[row][col + 1], azpixc, dist_corn2, ws_lat3, ws_lon3);
        geod.Inverse(lat_gd[row][col + 1], lon_gd[row][col + 1], ws_lat3, ws_lon3, res3);
        //   cout<<"azpixc.."<<azpixc<<"res3..sw.."<<res3<<endl;
       //se corner 
        azpixc = az4;
        geod.Direct(lat_gd[row][col + 1], lon_gd[row][col + 1], azpixc, dist_corn2, es_lat3, es_lon3);
        geod.Inverse(lat_gd[row][col + 1], lon_gd[row][col + 1], es_lat3, es_lon3, res4);
        //   cout<<"azpixc.."<<azpixc<<"res4...se.."<<res4<<endl;
        ws3_lon_str = std::to_string(ws_lon3);
        ws3_lat_str = std::to_string(ws_lat3);
        wn3_lon_str = std::to_string(wn_lon3);
        wn3_lat_str = std::to_string(wn_lat3);
        en3_lon_str = std::to_string(en_lon3);
        en3_lat_str = std::to_string(en_lat3);
        es3_lon_str = std::to_string(es_lon3);
        es3_lat_str = std::to_string(es_lat3);
        gridstr = "POLYGON((" + es_lon_str + " " + es_lat_str + "," + en_lon_str + " " + en_lat_str + "," + en3_lon_str + " " + en3_lat_str + "," + es3_lon_str + " " + es3_lat_str + "," + es_lon_str + " " + es_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2
 
    /*
        cout<<"center RIGHT-----------------"<<endl;
        cout<<"gd_row.."<<row<<"gd_col.."<<col<<endl;
        cout<<"dist_u.."<<dist_u<<"dist_v.."<<dist_v<<endl;
        cout<<"ingeom.."<<ingeom<<"binAreagrid..."<<binAreagrid<<"binAreapix.."<<binAreapix<<endl;
        cout<<"lat_gd.."<<lat_gd[row][col+1]<<"lon_gd.."<<lon_gd[row][col+1]<<"wn_lat.."<<en_lat<<"wn_lon.."<<en_lon<<endl;
        cout<<"lat_gd.."<<lat_gd[row][col+1]<<"lon_gd.."<<lon_gd[row][col+1]<<"ws_lat.."<<es_lat<<"ws_lon.."<<es_lon<<endl;
        cout<<"lat_gd.."<<lat_gd[row][col+1]<<"lon_gd.."<<lon_gd[row][col+1]<<"en_lat.."<<en_lat3<<"en_lon.."<<en_lon3<<endl;
        cout<<"lat_gd.."<<lat_gd[row][col+1]<<"lon_gd.."<<lon_gd[row][col+1]<<"es_lat.."<<es_lat3<<"es_lon.."<<es_lon3<<endl;
    */
 
        areabinBox[1][2] = binAreagrid;
        if (ingeom > 0) { //pixel fully inside the grid cell
            infull = true;
            intersectArea = binAreapix;
            result = true;
            areaFracBox[1][2] = intersectArea / binAreagrid;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0.) {
                std::deque<Polygon_t> output;
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[1][2] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[1][2] = 0.0;
                            pc++;
                        }
                    }
                }
            }
        }//end else
 
    //  cout<<"center RIGHT.."<<"areaFracBox[1][2]........................................."<<areaFracBox[1][2]<<endl;
 
    //******************************************************************************************************
     //upper center bin
    //*****************************************************************************************************
        ingeom = 0, binAreagrid = 0., binAreapix = 0, intersectArea = 0., pc = 1;
 
        deltaphi = (lat_gd[row + 1][col] - lat_gd[row + 1][col + 1]) * degrad;
        deltalam = (lon_gd[row + 1][col] - lon_gd[row + 1][col + 1]) * degrad;
        //across-track grid size
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row + 1][col] * degrad) * cos(lat_gd[row + 1][col + 1] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_u = Re * bterm;         //horizontal distance Harversine in km
 
        deltaphi = (lat_gd[row + 2][col] - lat_gd[row + 1][col]) * degrad;
        deltalam = (lon_gd[row + 2][col] - lon_gd[row + 1][col]) * degrad;
        //along-track distance
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row + 1][col] * degrad) * cos(lat_gd[row + 2][col] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_v = Re * bterm;
 
        theta = atan2(dist_v, dist_u);
        thetagrad = 2 * theta * 180 / M_PI;
        thetares = (M_PI / 2 - theta) * 180 / M_PI;
 
        //nw corner
        azpixc = az1;
        geod.Direct(lat_gd[row + 1][col], lon_gd[row + 1][col], azpixc, dist_corn2, wn_lat4, wn_lon4);
        geod.Inverse(lat_gd[row + 1][col], lon_gd[row + 1][col], wn_lat4, wn_lon4, res1);
        //   cout<<"azgc..CENTER-UPPER..."<<azgc<<"azpixc.."<<azpixc<<"dist_corn.."<<dist_corn<<"dist_corn2.."<<dist_corn2<<endl;
        //   cout<<"res1..nw."<<res1<<endl;
       //ne corner 
        azpixc = az2;
        geod.Direct(lat_gd[row + 1][col], lon_gd[row + 1][col], azpixc, dist_corn2, en_lat4, en_lon4);
        geod.Inverse(lat_gd[row + 1][col], lon_gd[row + 1][col], en_lat4, en_lon4, res2);
        //   cout<<"azpixc.."<<azpixc<<"res2 ne.."<<res2<<endl;
       //sw corner 
        azpixc = az3;
        geod.Direct(lat_gd[row + 1][col], lon_gd[row + 1][col], azpixc, dist_corn2, ws_lat4, ws_lon4);
        geod.Inverse(lat_gd[row + 1][col], lon_gd[row + 1][col], ws_lat4, ws_lon4, res3);
        //   cout<<"azpixc.."<<azpixc<<"res3..sw.."<<res3<<endl;
 
       //se corner 
        azpixc = az4;
        geod.Direct(lat_gd[row + 1][col], lon_gd[row + 1][col], azpixc, dist_corn2, es_lat4, es_lon4);
        geod.Inverse(lat_gd[row + 1][col], lon_gd[row + 1][col], es_lat4, es_lon4, res4);
        //   cout<<"azpixc.."<<azpixc<<"res4...se.."<<res4<<endl;
 
        ws4_lon_str = std::to_string(ws_lon4);
        ws4_lat_str = std::to_string(ws_lat4);
        wn4_lon_str = std::to_string(wn_lon4);
        wn4_lat_str = std::to_string(wn_lat4);
        en4_lon_str = std::to_string(en_lon4);
        en4_lat_str = std::to_string(en_lat4);
        es4_lon_str = std::to_string(es_lon4);
        es4_lat_str = std::to_string(es_lat4);
        gridstr = "POLYGON((" + wn_lon_str + " " + wn_lat_str + "," + wn4_lon_str + " " + wn4_lat_str + "," + en4_lon_str + " " + en4_lat_str + "," + en_lon_str + " " + en_lat_str + "," + wn_lon_str + " " + wn_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2
 
    /*
        cout<<"center UPPER-----------------"<<endl;
        cout<<"gd_row.."<<row<<"gd_col.."<<col<<endl;
        cout<<"dist_u.."<<dist_u<<"dist_v.."<<dist_v<<endl;
        cout<<"ingeom.."<<ingeom<<"binAreagrid..."<<binAreagrid<<"binAreapix.."<<binAreapix<<endl;
        cout<<"lat_gd.."<<lat_gd[row+1][col]<<"lon_gd.."<<lon_gd[row+1][col]<<"wn_lat.."<<wn_lat4<<"wn_lon.."<<wn_lon4<<endl;
        cout<<"lat_gd.."<<lat_gd[row+1][col]<<"lon_gd.."<<lon_gd[row+1][col]<<"ws_lat.."<<wn_lat<<"ws_lon.."<<wn_lon<<endl;
        cout<<"lat_gd.."<<lat_gd[row+1][col]<<"lon_gd.."<<lon_gd[row+1][col]<<"en_lat.."<<en_lat4<<"en_lon.."<<en_lon4<<endl;
        cout<<"lat_gd.."<<lat_gd[row+1][col]<<"lon_gd.."<<lon_gd[row+1][col]<<"es_lat.."<<en_lat<<"es_lon.."<<en_lon<<endl;
    */
 
        areabinBox[2][1] = binAreagrid;
        if (ingeom > 0) { //pixel fully inside the grid cell
            infull = true;
            intersectArea = binAreapix;
            result = true;
            areaFracBox[2][1] = intersectArea / binAreagrid;
            //        cout<<"pixel fully inside gricell [2][1].."<<endl;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                std::deque<Polygon_t> output;
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[2][1] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[2][1] = 0.0;
                            pc++;
                        }
                    }
                }
            }
        }//end else
 
 
    //  cout<<"CENTER UPPER.."<<"areaFracBox[2][1]........................................."<<areaFracBox[2][1]<<endl;
 
 
    //********************************************************
    //upper left  bin
    //*******************************************************
        ingeom = 0, binAreagrid = 0., binAreapix = 0, intersectArea = 0., pc = 1;
 
        deltaphi = (lat_gd[row + 1][col - 1] - lat_gd[row + 1][col]) * degrad;
        deltalam = (lon_gd[row + 1][col - 1] - lon_gd[row + 1][col]) * degrad;
        //across-track grid size
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row + 1][col - 1] * degrad) * cos(lat_gd[row + 1][col] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_u = Re * bterm;         //horizontal distance Harversine in km
 
        deltaphi = (lat_gd[row + 2][col - 1] - lat_gd[row + 1][col - 1]) * degrad;
        deltalam = (lon_gd[row + 2][col - 1] - lon_gd[row + 1][col - 1]) * degrad;
        //along-track distance
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row + 1][col - 1] * degrad) * cos(lat_gd[row + 2][col - 1] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_v = Re * bterm;
 
        theta = atan2(dist_v, dist_u);
        thetagrad = 2 * theta * 180 / M_PI;
        thetares = (M_PI / 2 - theta) * 180 / M_PI;
 
        //nw corner
        azpixc = az1;
        geod.Direct(lat_gd[row + 1][col - 1], lon_gd[row + 1][col - 1], azpixc, dist_corn2, wn_lat5, wn_lon5);
        geod.Inverse(lat_gd[row + 1][col - 1], lon_gd[row + 1][col - 1], wn_lat5, wn_lon5, res1);
        //   cout<<"azgc..LEFT-UPPER..."<<azgc<<"azpixc.."<<azpixc<<"dist_corn.."<<dist_corn<<"dist_corn2.."<<dist_corn2<<endl;
        //   cout<<"res1..nw."<<res1<<endl;
       //ne corner 
        azpixc = az2;
        geod.Direct(lat_gd[row + 1][col - 1], lon_gd[row + 1][col - 1], azpixc, dist_corn2, en_lat5, en_lon5);
        geod.Inverse(lat_gd[row + 1][col - 1], lon_gd[row + 1][col - 1], en_lat5, en_lon5, res2);
        //   cout<<"azpixc.."<<azpixc<<"res2 ne.."<<res2<<endl;
       //sw corner 
        azpixc = az3;
        geod.Direct(lat_gd[row + 1][col - 1], lon_gd[row + 1][col - 1], azpixc, dist_corn2, ws_lat5, ws_lon5);
        geod.Inverse(lat_gd[row + 1][col - 1], lon_gd[row + 1][col - 1], ws_lat5, ws_lon5, res3);
        //   cout<<"azpixc.."<<azpixc<<"res3..sw.."<<res3<<endl;
       //se corner 
        azpixc = az4;
        geod.Direct(lat_gd[row + 1][col - 1], lon_gd[row + 1][col - 1], azpixc, dist_corn2, es_lat5, es_lon5);
        geod.Inverse(lat_gd[row + 1][col - 1], lon_gd[row + 1][col - 1], es_lat5, es_lon5, res4);
        //  cout<<"azpixc.."<<azpixc<<"res4...se.."<<res4<<endl;
        ws5_lon_str = std::to_string(ws_lon5);
        ws5_lat_str = std::to_string(ws_lat5);
        wn5_lon_str = std::to_string(wn_lon5);
        wn5_lat_str = std::to_string(wn_lat5);
        en5_lon_str = std::to_string(en_lon5);
        en5_lat_str = std::to_string(en_lat5);
        es5_lon_str = std::to_string(es_lon5);
        es5_lat_str = std::to_string(es_lat5);
        gridstr = "POLYGON((" + wn2_lon_str + " " + wn2_lat_str + "," + wn5_lon_str + " " + wn5_lat_str + "," + wn4_lon_str + " " + wn4_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + wn2_lon_str + " " + wn2_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2 
    /*
        cout<<"LEFT UPPER-----------------"<<endl;
        cout<<"gd_row.."<<row<<"gd_col.."<<col<<endl;
        cout<<"dist_u.."<<dist_u<<"dist_v.."<<dist_v<<endl;
        cout<<"ingeom.."<<ingeom<<"binAreagrid..."<<binAreagrid<<"binAreapix.."<<binAreapix<<endl;
        cout<<"lat_gd.."<<lat_gd[row+1][col-1]<<"lon_gd.."<<lon_gd[row+1][col-1]<<"wn_lat.."<<wn_lat5<<"wn_lon.."<<wn_lon5<<endl;
        cout<<"lat_gd.."<<lat_gd[row+1][col-1]<<"lon_gd.."<<lon_gd[row+1][col-1]<<"ws_lat.."<<wn_lat2<<"ws_lon.."<<wn_lon2<<endl;
        cout<<"lat_gd.."<<lat_gd[row+1][col-1]<<"lon_gd.."<<lon_gd[row+1][col-1]<<"en_lat.."<<wn_lat4<<"en_lon.."<<wn_lon4<<endl;
        cout<<"lat_gd.."<<lat_gd[row+1][col-1]<<"lon_gd.."<<lon_gd[row+1][col-1]<<"es_lat.."<<wn_lat<<"es_lon.."<<wn_lon<<endl;
    */
 
        areabinBox[2][0] = binAreagrid;
        if (ingeom > 0) { //pixel fully inside the grid cell
            infull = true;
            intersectArea = binAreapix;
            result = true;
            areaFracBox[2][0] = intersectArea / binAreagrid;
            //        cout<<"pixel fully inside gricell [2][0].."<<endl;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                std::deque<Polygon_t> output;
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[2][0] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[2][0] = 0.0;
                            pc++;
                        }
                    }
                }
            }
        }//end else
 
    //  cout<<"LEFT UPPER.."<<"areaFracBox[2][0]........................................."<<areaFracBox[2][0]<<endl;
 
    //**************************************************************************************
    //upper right bin
    //**************************************************************************************
        ingeom = 0, binAreagrid = 0., binAreapix = 0, intersectArea = 0., pc = 1;
 
        deltaphi = (lat_gd[row + 1][col + 1] - lat_gd[row + 1][col + 2]) * degrad;
        deltalam = (lon_gd[row + 1][col + 1] - lon_gd[row + 1][col + 2]) * degrad;
        //across-track grid size
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row + 1][col + 1] * degrad) * cos(lat_gd[row + 1][col + 2] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_u = Re * bterm;         //horizontal distance Harversine in km
 
        deltaphi = (lat_gd[row + 2][col + 1] - lat_gd[row + 1][col + 1]) * degrad;
        deltalam = (lon_gd[row + 2][col + 1] - lon_gd[row + 1][col + 1]) * degrad;
        //along-track distance
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row + 1][col + 1] * degrad) * cos(lat_gd[row + 2][col + 1] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_v = Re * bterm;
 
        theta = atan2(dist_v, dist_u);
        thetagrad = 2 * theta * 180 / M_PI;
        thetares = (M_PI / 2 - theta) * 180 / M_PI;
 
        //nw corner
        azpixc = az1;
        geod.Direct(lat_gd[row + 1][col + 1], lon_gd[row + 1][col + 1], azpixc, dist_corn2, wn_lat6, wn_lon6);
        geod.Inverse(lat_gd[row + 1][col + 1], lon_gd[row + 1][col + 1], wn_lat6, wn_lon6, res1);
        //  cout<<"azgc..RIGHT-UPPER..."<<azgc<<"azpixc.."<<azpixc<<"dist_corn.."<<dist_corn<<"dist_corn2.."<<dist_corn2<<endl;
       //   cout<<"res1..nw."<<res1<<endl;
      //ne corner 
        azpixc = az2;
        geod.Direct(lat_gd[row + 1][col + 1], lon_gd[row + 1][col + 1], azpixc, dist_corn2, en_lat6, en_lon6);
        geod.Inverse(lat_gd[row + 1][col + 1], lon_gd[row + 1][col + 1], en_lat6, en_lon6, res2);
        //   cout<<"azpixc.."<<azpixc<<"res2 ne.."<<res2<<endl;
       //sw corner 
        azpixc = az3;
        geod.Direct(lat_gd[row + 1][col + 1], lon_gd[row + 1][col + 1], azpixc, dist_corn2, ws_lat6, ws_lon6);
        geod.Inverse(lat_gd[row + 1][col + 1], lon_gd[row + 1][col + 1], ws_lat6, ws_lon6, res3);
        //  cout<<"azpixc.."<<azpixc<<"res3..sw.."<<res3<<endl;
      //se corner 
        azpixc = az4;
        geod.Direct(lat_gd[row + 1][col + 1], lon_gd[row + 1][col + 1], azpixc, dist_corn2, es_lat6, es_lon6);
        geod.Inverse(lat_gd[row + 1][col + 1], lon_gd[row + 1][col + 1], es_lat6, es_lon6, res4);
        //  cout<<"azpixc.."<<azpixc<<"res4...se.."<<res4<<endl;
 
        ws6_lon_str = std::to_string(ws_lon6);
        ws6_lat_str = std::to_string(ws_lat6);
        wn6_lon_str = std::to_string(wn_lon6);
        wn6_lat_str = std::to_string(wn_lat6);
        en6_lon_str = std::to_string(en_lon6);
        en6_lat_str = std::to_string(en_lat6);
        es6_lon_str = std::to_string(es_lon6);
        es6_lat_str = std::to_string(es_lat6);
        gridstr = "POLYGON((" + en_lon_str + " " + en_lat_str + "," + en4_lon_str + " " + en4_lat_str + "," + en6_lon_str + " " + en6_lat_str + "," + en3_lon_str + " " + en3_lat_str + "," + en_lon_str + " " + en_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2
    /*
        cout<<"RIGHT UPPER-----------------"<<endl;
        cout<<"gd_row.."<<row<<"gd_col.."<<col<<endl;
        cout<<"dist_u.."<<dist_u<<"dist_v.."<<dist_v<<endl;
        cout<<"ingeom.."<<ingeom<<"binAreagrid..."<<binAreagrid<<"binAreapix.."<<binAreapix<<endl;
        cout<<"lat_gd.."<<lat_gd[row+1][col+1]<<"lon_gd.."<<lon_gd[row+1][col+1]<<"wn_lat.."<<en_lat4<<"wn_lon.."<<en_lon4<<endl;
        cout<<"lat_gd.."<<lat_gd[row+1][col+1]<<"lon_gd.."<<lon_gd[row+1][col+1]<<"ws_lat.."<<en_lat<<"ws_lon.."<<en_lon<<endl;
        cout<<"lat_gd.."<<lat_gd[row+1][col+1]<<"lon_gd.."<<lon_gd[row+1][col+1]<<"en_lat.."<<en_lat6<<"en_lon.."<<en_lon6<<endl;
        cout<<"lat_gd.."<<lat_gd[row+1][col+1]<<"lon_gd.."<<lon_gd[row+1][col+1]<<"es_lat.."<<en_lat3<<"es_lon.."<<en_lon3<<endl;
    */
 
        areabinBox[2][2] = binAreagrid;
        if (ingeom > 0) { //pixel fully inside the grid cell
            infull = true;
            intersectArea = binAreapix;
            result = true;
            areaFracBox[2][2] = intersectArea / binAreagrid;
            //        cout<<"pixel fully inside gricell [2][2].."<<endl;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                std::deque<Polygon_t> output;
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[2][2] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[2][2] = 0.0;
                            pc++;
                        }
                    }
                }
            }
        }//end else
 
    //  cout<<"RIGHT UPPER.."<<"areaFracBox[2][0]........................................."<<areaFracBox[2][2]<<endl;
 
    //************************************************************
    //lower center  bin
    //*************************************************************
 
        ingeom = 0, binAreagrid = 0., binAreapix = 0, intersectArea = 0., pc = 1;
 
        deltaphi = (lat_gd[row - 1][col] - lat_gd[row - 1][col + 1]) * degrad;
        deltalam = (lon_gd[row - 1][col] - lon_gd[row - 1][col + 1]) * degrad;
        //across-track grid size
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row - 1][col] * degrad) * cos(lat_gd[row - 1][col + 1] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_u = Re * bterm;         //horizontal distance Harversine in km
 
        deltaphi = (lat_gd[row - 1][col] - lat_gd[row][col]) * degrad;
        deltalam = (lon_gd[row - 1][col] - lon_gd[row][col]) * degrad;
        //along-track distance
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row - 1][col] * degrad) * cos(lat_gd[row][col] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_v = Re * bterm;
 
        theta = atan2(dist_v, dist_u);
        thetagrad = 2 * theta * 180 / M_PI;
        thetares = (M_PI / 2 - theta) * 180 / M_PI;
 
        //nw corner
        /*    azpixc=(azgc-thetares)*degrad;//pixel bearing
            if(azpixc>M_PI | azpixc<-M_PI){
                    cout<<"problem with BEARING in across-gridline method...az<-180 or >180...."<<"NW azpixc in degrees.."<<azpixc*180/M_PI<<endl;
                     }
            azpixc=azpixc*180/M_PI;
        */
        azpixc = az1;
        geod.Direct(lat_gd[row - 1][col], lon_gd[row - 1][col], azpixc, dist_corn2, wn_lat7, wn_lon7);
        geod.Inverse(lat_gd[row - 1][col], lon_gd[row - 1][col], wn_lat7, wn_lon7, res1);
        //   cout<<"azgc..LOWER CENTER..."<<azgc<<"azpixc.."<<azpixc<<"dist_corn.."<<dist_corn<<"dist_corn2.."<<dist_corn2<<endl;
        //   cout<<"res1..nw."<<res1<<endl;
 
       //ne corner 
        azpixc = az2;
        geod.Direct(lat_gd[row - 1][col], lon_gd[row - 1][col], azpixc, dist_corn2, en_lat7, en_lon7);
        geod.Inverse(lat_gd[row - 1][col], lon_gd[row - 1][col], en_lat7, en_lon7, res2);
        //   cout<<"azpixc.."<<azpixc<<"res2 ne.."<<res2<<endl;
       //sw corner 
        azpixc = az3;
        geod.Direct(lat_gd[row - 1][col], lon_gd[row - 1][col], azpixc, dist_corn2, ws_lat7, ws_lon7);
        geod.Inverse(lat_gd[row - 1][col], lon_gd[row - 1][col], ws_lat7, ws_lon7, res3);
        //   cout<<"azpixc.."<<azpixc<<"res3..sw.."<<res3<<endl;
 
       //se corner 
        azpixc = az4;
        geod.Direct(lat_gd[row - 1][col], lon_gd[row - 1][col], azpixc, dist_corn2, es_lat7, es_lon7);
        geod.Inverse(lat_gd[row - 1][col], lon_gd[row - 1][col], es_lat7, es_lon7, res4);
        //   cout<<"azpixc.."<<azpixc<<"res4...se.."<<res4<<endl;
 
        ws7_lon_str = std::to_string(ws_lon7);
        ws7_lat_str = std::to_string(ws_lat7);
        wn7_lon_str = std::to_string(wn_lon7);
        wn7_lat_str = std::to_string(wn_lat7);
        en7_lon_str = std::to_string(en_lon7);
        en7_lat_str = std::to_string(en_lat7);
        es7_lon_str = std::to_string(es_lon7);
        es7_lat_str = std::to_string(es_lat7);
        gridstr = "POLYGON((" + ws7_lon_str + " " + ws7_lat_str + "," + ws_lon_str + " " + ws_lat_str + "," + es_lon_str + " " + es_lat_str + "," + es7_lon_str + " " + es7_lat_str + "," + ws7_lon_str + " " + ws7_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2 
    /*
        cout<<"LOWER CENTER-----------------"<<endl;
        cout<<"gd_row.."<<row<<"gd_col.."<<col<<endl;
        cout<<"dist_u.."<<dist_u<<"dist_v.."<<dist_v<<endl;
        cout<<"ingeom.."<<ingeom<<"binAreagrid..."<<binAreagrid<<"binAreapix.."<<binAreapix<<endl;
        cout<<"lat_gd.."<<lat_gd[row-1][col]<<"lon_gd.."<<lon_gd[row-1][col]<<"wn_lat.."<<ws_lat<<"wn_lon.."<<ws_lon<<endl;
        cout<<"lat_gd.."<<lat_gd[row-1][col]<<"lon_gd.."<<lon_gd[row-1][col]<<"ws_lat.."<<ws_lat7<<"ws_lon.."<<ws_lon7<<endl;
        cout<<"lat_gd.."<<lat_gd[row-1][col]<<"lon_gd.."<<lon_gd[row-1][col]<<"en_lat.."<<es_lat<<"en_lon.."<<es_lon<<endl;
        cout<<"lat_gd.."<<lat_gd[row-1][col]<<"lon_gd.."<<lon_gd[row-1][col]<<"es_lat.."<<es_lat7<<"es_lon.."<<es_lon7<<endl;
    */
        areabinBox[0][1] = binAreagrid;
        if (ingeom > 0) { //pixel fully inside the grid cell
            infull = true;
            intersectArea = binAreapix;
            result = true;
            areaFracBox[0][1] = intersectArea / binAreagrid;
            //        cout<<"pixel fully inside gricell [0][1].."<<endl;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                std::deque<Polygon_t> output;
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[0][1] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[0][1] = 0.0;
                            pc++;
                        }
                    }
                }
            }
        }//end else
 
 
    //  cout<<"CENTER LOWER.."<<"areaFracBox[0][1]........................................."<<areaFracBox[0][1]<<endl;
 
 
    //******************************************************************
    //lower left bin
    //****************************************************************
        ingeom = 0, binAreagrid = 0, binAreapix = 0, intersectArea = 0., pc = 1;
 
        deltaphi = (lat_gd[row - 1][col - 1] - lat_gd[row - 1][col]) * degrad;
        deltalam = (lon_gd[row - 1][col - 1] - lon_gd[row - 1][col]) * degrad;
        //across-track grid size
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row - 1][col - 1] * degrad) * cos(lat_gd[row - 1][col] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_u = Re * bterm;         //horizontal distance Harversine in km
 
        deltaphi = (lat_gd[row - 1][col - 1] - lat_gd[row][col - 1]) * degrad;
        deltalam = (lon_gd[row - 1][col - 1] - lon_gd[row][col - 1]) * degrad;
        //along-track distance
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row - 1][col - 1] * degrad) * cos(lat_gd[row][col - 1] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_v = Re * bterm;
 
        theta = atan2(dist_v, dist_u);
        thetagrad = 2 * theta * 180 / M_PI;
        thetares = (M_PI / 2 - theta) * 180 / M_PI;
 
        //nw corner
        azpixc = az1;
        geod.Direct(lat_gd[row - 1][col - 1], lon_gd[row - 1][col - 1], azpixc, dist_corn2, wn_lat8, wn_lon8);
        geod.Inverse(lat_gd[row - 1][col - 1], lon_gd[row - 1][col - 1], wn_lat8, wn_lon8, res1);
        //   cout<<"azgc..LOWER LEFT..."<<azgc<<"azpixc.."<<azpixc<<"dist_corn.."<<dist_corn<<"dist_corn2.."<<dist_corn2<<endl;
        //   cout<<"res1..nw."<<res1<<endl;
 
       //ne corner 
        azpixc = az2;
        geod.Direct(lat_gd[row - 1][col - 1], lon_gd[row - 1][col - 1], azpixc, dist_corn2, en_lat8, en_lon8);
        geod.Inverse(lat_gd[row - 1][col - 1], lon_gd[row - 1][col - 1], en_lat8, en_lon8, res2);
        //   cout<<"azpixc.."<<azpixc<<"res2 ne.."<<res2<<endl;
       //sw corner 
        azpixc = az3;
        geod.Direct(lat_gd[row - 1][col - 1], lon_gd[row - 1][col - 1], azpixc, dist_corn2, ws_lat8, ws_lon8);
        geod.Inverse(lat_gd[row - 1][col - 1], lon_gd[row - 1][col - 1], ws_lat8, ws_lon8, res3);
        //   cout<<"azpixc.."<<azpixc<<"res3..sw.."<<res3<<endl;
 
       //se corner 
        azpixc = az4;
        geod.Direct(lat_gd[row - 1][col - 1], lon_gd[row - 1][col - 1], azpixc, dist_corn2, es_lat8, es_lon8);
        geod.Inverse(lat_gd[row - 1][col - 1], lon_gd[row - 1][col - 1], es_lat8, es_lon8, res4);
        //  cout<<"azpixc.."<<azpixc<<"res4...se.."<<res4<<endl;
        ws8_lon_str = std::to_string(ws_lon8);
        ws8_lat_str = std::to_string(ws_lat8);
        wn8_lon_str = std::to_string(wn_lon8);
        wn8_lat_str = std::to_string(wn_lat8);
        en8_lon_str = std::to_string(en_lon8);
        en8_lat_str = std::to_string(en_lat8);
        es8_lon_str = std::to_string(es_lon8);
        es8_lat_str = std::to_string(es_lat8);
        gridstr = "POLYGON((" + ws8_lon_str + " " + ws8_lat_str + "," + ws2_lon_str + " " + ws2_lat_str + "," + ws_lon_str + " " + ws_lat_str + "," + ws7_lon_str + " " + ws7_lat_str + "," + ws8_lon_str + " " + ws8_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2 
    /*
        cout<<"LOWER LEFT-----------------"<<endl;
        cout<<"gd_row.."<<row<<"gd_col.."<<col<<endl;
        cout<<"dist_u.."<<dist_u<<"dist_v.."<<dist_v<<endl;
        cout<<"ingeom.."<<ingeom<<"binAreagrid..."<<binAreagrid<<"binAreapix.."<<binAreapix<<endl;
        cout<<"lat_gd.."<<lat_gd[row-1][col-1]<<"lon_gd.."<<lon_gd[row-1][col-1]<<"wn_lat.."<<ws_lat2<<"wn_lon.."<<ws_lon2<<endl;
        cout<<"lat_gd.."<<lat_gd[row-1][col-1]<<"lon_gd.."<<lon_gd[row-1][col-1]<<"ws_lat.."<<ws_lat8<<"ws_lon.."<<ws_lon8<<endl;
        cout<<"lat_gd.."<<lat_gd[row-1][col-1]<<"lon_gd.."<<lon_gd[row-1][col-1]<<"en_lat.."<<ws_lat<<"en_lon.."<<ws_lon<<endl;
        cout<<"lat_gd.."<<lat_gd[row-1][col-1]<<"lon_gd.."<<lon_gd[row-1][col-1]<<"es_lat.."<<ws_lat7<<"es_lon.."<<ws_lon7<<endl;
    */
 
        areabinBox[0][0] = binAreagrid;
        if (ingeom > 0) { //pixel fully inside the grid cell
            infull = true;
            intersectArea = binAreapix;
            result = true;
            areaFracBox[0][0] = intersectArea / binAreagrid;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                std::deque<Polygon_t> output;
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[0][0] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[0][0] = 0.0;
                            pc++;
                        }
                    }
                }
            }
        }//end else
 
 
    //  cout<<"LEFT LOWER.."<<"areaFracBox[0][0]........................................."<<areaFracBox[0][0]<<endl;
 
    //******************************************************************
    //lower right bin
    //****************************************************************
        ingeom = 0, binAreagrid = 0, binAreapix = 0, intersectArea = 0., pc = 1;
 
        deltaphi = (lat_gd[row - 1][col + 1] - lat_gd[row - 1][col + 2]) * degrad;
        deltalam = (lon_gd[row - 1][col + 1] - lon_gd[row - 1][col + 2]) * degrad;
        //across-track grid size
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row - 1][col + 1] * degrad) * cos(lat_gd[row - 1][col + 2] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_u = Re * bterm;         //horizontal distance Harversine in km
 
        deltaphi = (lat_gd[row - 1][col + 1] - lat_gd[row][col + 1]) * degrad;
        deltalam = (lon_gd[row - 1][col + 1] - lon_gd[row][col + 1]) * degrad;
        //along-track distance
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row - 1][col + 1] * degrad) * cos(lat_gd[row][col + 1] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_v = Re * bterm;
 
        theta = atan2(dist_v, dist_u);
        thetagrad = 2 * theta * 180 / M_PI;
        thetares = (M_PI / 2 - theta) * 180 / M_PI;
 
        //nw corner
        azpixc = az1;
        geod.Direct(lat_gd[row - 1][col + 1], lon_gd[row - 1][col + 1], azpixc, dist_corn2, wn_lat9, wn_lon9);
        geod.Inverse(lat_gd[row - 1][col + 1], lon_gd[row - 1][col + 1], wn_lat9, wn_lon9, res1);
        //  cout<<"azgc..LOWER RIGHT..."<<azgc<<"azpixc.."<<azpixc<<"dist_corn.."<<dist_corn<<"dist_corn2.."<<dist_corn2<<endl;
        //  cout<<"res1..nw."<<res1<<endl;
 
      //ne corner 
        azpixc = az2;
        geod.Direct(lat_gd[row - 1][col + 1], lon_gd[row - 1][col + 1], azpixc, dist_corn2, en_lat9, en_lon9);
        geod.Inverse(lat_gd[row - 1][col + 1], lon_gd[row - 1][col + 1], en_lat9, en_lon9, res2);
        //  cout<<"azpixc.."<<azpixc<<"res2 ne.."<<res2<<endl;
      //sw corner 
        azpixc = az3;
        geod.Direct(lat_gd[row - 1][col + 1], lon_gd[row - 1][col + 1], azpixc, dist_corn2, ws_lat9, ws_lon9);
        geod.Inverse(lat_gd[row - 1][col + 1], lon_gd[row - 1][col + 1], ws_lat9, ws_lon9, res3);
        //  cout<<"azpixc.."<<azpixc<<"res3..sw.."<<res3<<endl;
 
      //se corner 
        azpixc = az4;
        geod.Direct(lat_gd[row - 1][col + 1], lon_gd[row - 1][col + 1], azpixc, dist_corn2, es_lat9, es_lon9);
        geod.Inverse(lat_gd[row - 1][col + 1], lon_gd[row - 1][col + 1], es_lat9, es_lon9, res4);
        //   cout<<"azpixc.."<<azpixc<<"res4...se.."<<res4<<endl;
 
        ws9_lon_str = std::to_string(ws_lon9);
        ws9_lat_str = std::to_string(ws_lat9);
        wn9_lon_str = std::to_string(wn_lon9);
        wn9_lat_str = std::to_string(wn_lat9);
        en9_lon_str = std::to_string(en_lon9);
        en9_lat_str = std::to_string(en_lat9);
        es9_lon_str = std::to_string(es_lon9);
        es9_lat_str = std::to_string(es_lat9);
        gridstr = "POLYGON((" + es7_lon_str + " " + es7_lat_str + "," + es_lon_str + " " + es_lat_str + "," + es3_lon_str + " " + es3_lat_str + "," + es9_lon_str + " " + es9_lat_str + "," + es7_lon_str + " " + es7_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2 
 
    /*
        cout<<"LOWER RIGHT-----------------"<<endl;
        cout<<"gd_row.."<<row<<"gd_col.."<<col<<endl;
        cout<<"dist_u.."<<dist_u<<"dist_v.."<<dist_v<<endl;
        cout<<"ingeom.."<<ingeom<<"binAreagrid..."<<binAreagrid<<"binAreapix.."<<binAreapix<<endl;
        cout<<"lat_gd.."<<lat_gd[row-1][col+1]<<"lon_gd.."<<lon_gd[row-1][col+1]<<"wn_lat.."<<es_lat<<"wn_lon.."<<es_lon<<endl;
        cout<<"lat_gd.."<<lat_gd[row-1][col+1]<<"lon_gd.."<<lon_gd[row-1][col+1]<<"ws_lat.."<<es_lat7<<"ws_lon.."<<es_lon7<<endl;
        cout<<"lat_gd.."<<lat_gd[row-1][col+1]<<"lon_gd.."<<lon_gd[row-1][col+1]<<"en_lat.."<<es_lat3<<"en_lon.."<<es_lon3<<endl;
        cout<<"lat_gd.."<<lat_gd[row-1][col+1]<<"lon_gd.."<<lon_gd[row-1][col+1]<<"es_lat.."<<es_lat9<<"es_lon.."<<es_lon9<<endl;
    */
 
        areabinBox[0][2] = binAreagrid;
        if (ingeom > 0) { //pixel fully inside the grid cell
            infull = true;
            intersectArea = binAreapix;
            result = true;
            areaFracBox[0][2] = intersectArea / binAreagrid;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                std::deque<Polygon_t> output;
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[0][2] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[0][2] = 0.0;
                            pc++;
                        }
                    }
                }
            }
        }//end else
 
    //  cout<<"RIGHT LOWER.."<<"areaFracBox[0][2]........................................."<<areaFracBox[0][2]<<endl;
 
 
 
        if (infull == true) {
     //       cout << "pixelbox fully inside gridbox..........................................." << endl;
            //    exit(1);
        }
 
        return result;
 
    }
 
 
 
    bool L1C::binIntersectsPix4corn3(short row, short col, double** lat_cgd, double** lon_cgd, Polygon_t& pixelPoly, double areaFracBox[3][3], double areabinBox[3][3]) {
        bool result = false;
        double  ws_lat, wn_lat, es_lat, en_lat, ws_lon, wn_lon, es_lon, en_lon;
        bool ingeom = false;
        //   shape->rowcol2bounds(row, col, n, s, e, w);
        int32_t rowc = 0, colc = 0;
        int pc = 1;
        double intersectArea = 0, binAreapix = 0, binAreagrid = 0.;
        std::string ws_lon_str, ws_lat_str, wn_lon_str, wn_lat_str, en_lon_str, en_lat_str, es_lon_str, es_lat_str, gridstr;
        rowc = row + 1;
        colc = col + 1;
 
        if (rowc < 0 || colc < 0) {
           cout << "ERROR ON binIntersectsPix4corn3...rowc or colc are negative for cornerlines.." << endl;
            exit(1);        
}
 
        ingeom = 0, binAreagrid = 0., binAreapix = 0, intersectArea = 0., pc = 1;
 
        //center center bin---------------------------------------------
 
        ws_lat = lat_cgd[rowc - 1][colc - 1];
        ws_lon = lon_cgd[rowc - 1][colc - 1];
        wn_lat = lat_cgd[rowc][colc - 1];
        wn_lon = lon_cgd[rowc][colc - 1];
        en_lat = lat_cgd[rowc][colc];
        en_lon = lon_cgd[rowc][colc];
        es_lat = lat_cgd[rowc - 1][colc];
        es_lon = lon_cgd[rowc - 1][colc];
 
 
        if (ws_lon > es_lon || wn_lon > en_lon || ws_lat > wn_lat || es_lat > en_lat) {
            cout << "ws_lon>es_lon | wn_lon>en_lon | ws_lat>wn_lat | es_lat>en_lat..." << ws_lon << es_lon << wn_lon << en_lon << ws_lat << wn_lat << es_lat << en_lat << endl;
            cout << "-------------------------------gd_row.." << row << "gd_col.." << col << "----------------------" << endl;
        }
 
 
        Polygon_t gridPoly;
        ws_lon_str = std::to_string(ws_lon);
        ws_lat_str = std::to_string(ws_lat);
        wn_lon_str = std::to_string(wn_lon);
        wn_lat_str = std::to_string(wn_lat);
        en_lon_str = std::to_string(en_lon);
        en_lat_str = std::to_string(en_lat);
        es_lon_str = std::to_string(es_lon);
        es_lat_str = std::to_string(es_lat);
        gridstr = "POLYGON((" + ws_lon_str + " " + ws_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + en_lon_str + " " + en_lat_str + "," + es_lon_str + " " + es_lat_str + "," + ws_lon_str + " " + ws_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2
        if (binAreagrid < 0.000001)areabinBox[1][1] = 0.0;else areabinBox[1][1] = binAreagrid;
        /*  cout<<"inside binIntersectsPix4corn.."<<"ws_lon.."<<ws_lon<<"ws_lat.."<<ws_lat<<endl;
          cout<<"inside binIntersectsPix4corn.."<<"wn_lon.."<<wn_lon<<"wn_lat.."<<wn_lat<<endl;
          cout<<"inside binIntersectsPix4corn.."<<"en_lon.."<<en_lon<<"en_lat.."<<en_lat<<endl;
          cout<<"inside binIntersectsPix4corn.."<<"es_lon.."<<es_lon<<"es_lat.."<<es_lat<<endl;
        */
        //  if(binAreagrid<0.000001)cout<<"binAreagrid<0.000001.[1][1]."<<endl;
 
        if (ingeom > 0) { //pixel fully inside the grid cell
            intersectArea = binAreapix;
            result = true;
            areaFracBox[1][1] = intersectArea / binAreagrid;
            //       cout<<"pixel fully inside gricell [1][1].."<<endl;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                std::deque<Polygon_t> output;//this is a list
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[1][1] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[1][1] = 0.0;
                            pc++;
                        }
                    }
                }
            }
        }//end else
 
        ingeom = 0, binAreagrid = 0., binAreapix = 0, intersectArea = 0., pc = 1;
 
        //left center bin
        ws_lat = lat_cgd[rowc - 1][colc - 2];
        ws_lon = lon_cgd[rowc - 1][colc - 2];
        wn_lat = lat_cgd[rowc][colc - 2];
        wn_lon = lon_cgd[rowc][colc - 2];
        en_lat = lat_cgd[rowc][colc - 1];
        en_lon = lon_cgd[rowc][colc - 1];
        es_lat = lat_cgd[rowc - 1][colc - 1];
        es_lon = lon_cgd[rowc - 1][colc - 1];
 
 
        ws_lon_str = std::to_string(ws_lon);
        ws_lat_str = std::to_string(ws_lat);
        wn_lon_str = std::to_string(wn_lon);
        wn_lat_str = std::to_string(wn_lat);
        en_lon_str = std::to_string(en_lon);
        en_lat_str = std::to_string(en_lat);
        es_lon_str = std::to_string(es_lon);
        es_lat_str = std::to_string(es_lat);
        gridstr = "POLYGON((" + ws_lon_str + " " + ws_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + en_lon_str + " " + en_lat_str + "," + es_lon_str + " " + es_lat_str + "," + ws_lon_str + " " + ws_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2 
        if (binAreagrid < 0.000001)areabinBox[1][0] = 0.0;else areabinBox[1][0] = binAreagrid;
        /*   cout<<"inside binIntersectsPix4corn.."<<"ws_lon.."<<ws_lon<<"ws_lat.."<<ws_lat<<endl;
           cout<<"inside binIntersectsPix4corn.."<<"wn_lon.."<<wn_lon<<"wn_lat.."<<wn_lat<<endl;
           cout<<"inside binIntersectsPix4corn.."<<"en_lon.."<<en_lon<<"en_lat.."<<en_lat<<endl;
           cout<<"inside binIntersectsPix4corn.."<<"es_lon.."<<es_lon<<"es_lat.."<<es_lat<<endl;*/
           //    if(binAreagrid<0.000001)cout<<"binAreagrid<0.000001..[1][0]"<<endl;
 
 
        if (ingeom > 0) { //pixel fully inside the grid cell
            intersectArea = binAreapix;
            result = true;
            areaFracBox[1][0] = intersectArea / binAreagrid;
            //       cout<<"pixel fully inside gricell [1][0].."<<endl;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                std::deque<Polygon_t> output;
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[1][0] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[1][0] = 0.0;
                            binAreapix = bg::area(pixelPoly);
                            pc++;
                        }
                    }
                }
            }
        }//end else
 
        ingeom = 0, binAreagrid = 0., binAreapix = 0, intersectArea = 0.;
        //right center bin
        ws_lat = lat_cgd[rowc - 1][colc];
        ws_lon = lon_cgd[rowc - 1][colc];
        wn_lat = lat_cgd[rowc][colc];
        wn_lon = lon_cgd[rowc][colc];
        en_lat = lat_cgd[rowc][colc + 1];
        en_lon = lon_cgd[rowc][colc + 1];
        es_lat = lat_cgd[rowc - 1][colc + 1];
        es_lon = lon_cgd[rowc - 1][colc + 1];
        //**********************************************************************
        ws_lon_str = std::to_string(ws_lon);
        ws_lat_str = std::to_string(ws_lat);
        wn_lon_str = std::to_string(wn_lon);
        wn_lat_str = std::to_string(wn_lat);
        en_lon_str = std::to_string(en_lon);
        en_lat_str = std::to_string(en_lat);
        es_lon_str = std::to_string(es_lon);
        es_lat_str = std::to_string(es_lat);
        gridstr = "POLYGON((" + ws_lon_str + " " + ws_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + en_lon_str + " " + en_lat_str + "," + es_lon_str + " " + es_lat_str + "," + ws_lon_str + " " + ws_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2
        if (binAreagrid < 0.000001)areabinBox[1][2] = 0.0;else areabinBox[1][2] = binAreagrid;
        /*   cout<<"inside binIntersectsPix4corn.."<<"ws_lon.."<<ws_lon<<"ws_lat.."<<ws_lat<<endl;
           cout<<"inside binIntersectsPix4corn.."<<"wn_lon.."<<wn_lon<<"wn_lat.."<<wn_lat<<endl;
           cout<<"inside binIntersectsPix4corn.."<<"en_lon.."<<en_lon<<"en_lat.."<<en_lat<<endl;
           cout<<"inside binIntersectsPix4corn.."<<"es_lon.."<<es_lon<<"es_lat.."<<es_lat<<endl;*/
           //    if(binAreagrid<0.000001)          cout<<"binAreagrid<0.000001.[1][2]."<<endl;
 
        if (ingeom > 0) { //pixel fully inside the grid cell
            intersectArea = binAreapix;
            result = true;
            areaFracBox[1][2] = intersectArea / binAreagrid;
            //       cout<<"pixel fully inside gricell [1][2].."<<endl;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0.) {
                std::deque<Polygon_t> output;
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[1][2] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[1][2] = 0.0;
                            pc++;
                        }
                    }
                }
            }
        }//end else
        ingeom = 0, binAreagrid = 0., binAreapix = 0, intersectArea = 0., pc = 1;
        //upper center bin
        ws_lat = lat_cgd[rowc][colc - 1];
        ws_lon = lon_cgd[rowc][colc - 1];
        wn_lat = lat_cgd[rowc + 1][colc - 1];
        wn_lon = lon_cgd[rowc + 1][colc - 1];
        en_lat = lat_cgd[rowc + 1][colc];
        en_lon = lon_cgd[rowc + 1][colc];
        es_lat = lat_cgd[rowc][colc];
        es_lon = lon_cgd[rowc][colc];
 
 
        ws_lon_str = std::to_string(ws_lon);
        ws_lat_str = std::to_string(ws_lat);
        wn_lon_str = std::to_string(wn_lon);
        wn_lat_str = std::to_string(wn_lat);
        en_lon_str = std::to_string(en_lon);
        en_lat_str = std::to_string(en_lat);
        es_lon_str = std::to_string(es_lon);
        es_lat_str = std::to_string(es_lat);
        gridstr = "POLYGON((" + ws_lon_str + " " + ws_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + en_lon_str + " " + en_lat_str + "," + es_lon_str + " " + es_lat_str + "," + ws_lon_str + " " + ws_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2 
        if (binAreagrid < 0.000001)areabinBox[2][1] = 0.0;else areabinBox[2][1] = binAreagrid;
        /*     cout<<"inside binIntersectsPix4corn.."<<"ws_lon.."<<ws_lon<<"ws_lat.."<<ws_lat<<endl;
             cout<<"inside binIntersectsPix4corn.."<<"wn_lon.."<<wn_lon<<"wn_lat.."<<wn_lat<<endl;
             cout<<"inside binIntersectsPix4corn.."<<"en_lon.."<<en_lon<<"en_lat.."<<en_lat<<endl;
             cout<<"inside binIntersectsPix4corn.."<<"es_lon.."<<es_lon<<"es_lat.."<<es_lat<<endl;*/
             //    if(binAreagrid<0.000001)            cout<<"binAreagrid<0.000001..[2][1]"<<endl;
 
        if (ingeom > 0) { //pixel fully inside the grid cell
            intersectArea = binAreapix;
            result = true;
            areaFracBox[2][1] = intersectArea / binAreagrid;
            //        cout<<"pixel fully inside gricell [2][1].."<<endl;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                std::deque<Polygon_t> output;
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[2][1] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[2][1] = 0.0;
                            pc++;
                        }
                    }
                }
            }
        }//end else
 
        ingeom = 0, binAreagrid = 0., binAreapix = 0, intersectArea = 0., pc = 1;
        //upper left  bin
        ws_lat = lat_cgd[rowc][colc - 2];
        ws_lon = lon_cgd[rowc][colc - 2];
        wn_lat = lat_cgd[rowc + 1][colc - 2];
        wn_lon = lon_cgd[rowc + 1][colc - 2];
        en_lat = lat_cgd[rowc + 1][colc - 1];
        en_lon = lon_cgd[rowc + 1][colc - 1];
        es_lat = lat_cgd[rowc][colc - 1];
        es_lon = lon_cgd[rowc][colc - 1];
 
 
        ws_lon_str = std::to_string(ws_lon);
        ws_lat_str = std::to_string(ws_lat);
        wn_lon_str = std::to_string(wn_lon);
        wn_lat_str = std::to_string(wn_lat);
        en_lon_str = std::to_string(en_lon);
        en_lat_str = std::to_string(en_lat);
        es_lon_str = std::to_string(es_lon);
        es_lat_str = std::to_string(es_lat);
        gridstr = "POLYGON((" + ws_lon_str + " " + ws_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + en_lon_str + " " + en_lat_str + "," + es_lon_str + " " + es_lat_str + "," + ws_lon_str + " " + ws_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2 
    //    if(binAreagrid<0.000001)areabinBox[2][0]=0.0;else areabinBox[2][0]= binAreagrid;
     /*    cout<<"inside binIntersectsPix4corn.."<<"ws_lon.."<<ws_lon<<"ws_lat.."<<ws_lat<<endl;
         cout<<"inside binIntersectsPix4corn.."<<"wn_lon.."<<wn_lon<<"wn_lat.."<<wn_lat<<endl;
         cout<<"inside binIntersectsPix4corn.."<<"en_lon.."<<en_lon<<"en_lat.."<<en_lat<<endl;
         cout<<"inside binIntersectsPix4corn.."<<"es_lon.."<<es_lon<<"es_lat.."<<es_lat<<endl;*/
        if (binAreagrid < 0.000001)        cout << "binAreagrid<0.000001..[2][0]" << endl;
 
        if (ingeom > 0) { //pixel fully inside the grid cell
            intersectArea = binAreapix;
            result = true;
            areaFracBox[2][0] = intersectArea / binAreagrid;
            //        cout<<"pixel fully inside gricell [2][0].."<<endl;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                std::deque<Polygon_t> output;
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[2][0] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[2][0] = 0.0;
                            pc++;
                        }
                    }
                }
            }
        }//end else
        ingeom = 0, binAreagrid = 0., binAreapix = 0, intersectArea = 0., pc = 1;
        //upper right bin
        ws_lat = lat_cgd[rowc][colc];
        ws_lon = lon_cgd[rowc][colc];
        wn_lat = lat_cgd[rowc + 1][colc];
        wn_lon = lon_cgd[rowc + 1][colc];
        en_lat = lat_cgd[rowc + 1][colc + 1];
        en_lon = lon_cgd[rowc + 1][colc + 1];
        es_lat = lat_cgd[rowc][colc + 1];
        es_lon = lon_cgd[rowc][colc + 1];
 
        ws_lon_str = std::to_string(ws_lon);
        ws_lat_str = std::to_string(ws_lat);
        wn_lon_str = std::to_string(wn_lon);
        wn_lat_str = std::to_string(wn_lat);
        en_lon_str = std::to_string(en_lon);
        en_lat_str = std::to_string(en_lat);
        es_lon_str = std::to_string(es_lon);
        es_lat_str = std::to_string(es_lat);
        gridstr = "POLYGON((" + ws_lon_str + " " + ws_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + en_lon_str + " " + en_lat_str + "," + es_lon_str + " " + es_lat_str + "," + ws_lon_str + " " + ws_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2 
        if (binAreagrid < 0.000001)areabinBox[2][2] = 0.0;else areabinBox[2][2] = binAreagrid;
        /*   cout<<"inside binIntersectsPix4corn.."<<"ws_lon.."<<ws_lon<<"ws_lat.."<<ws_lat<<endl;
           cout<<"inside binIntersectsPix4corn.."<<"wn_lon.."<<wn_lon<<"wn_lat.."<<wn_lat<<endl;
           cout<<"inside binIntersectsPix4corn.."<<"en_lon.."<<en_lon<<"en_lat.."<<en_lat<<endl;
           cout<<"inside binIntersectsPix4corn.."<<"es_lon.."<<es_lon<<"es_lat.."<<es_lat<<endl;*/
           //    if(binAreagrid<0.000001)         cout<<"binAreagrid<0.000001..[2][2]"<<endl;
 
        if (ingeom > 0) { //pixel fully inside the grid cell
            intersectArea = binAreapix;
            result = true;
            areaFracBox[2][2] = intersectArea / binAreagrid;
            //        cout<<"pixel fully inside gricell [2][2].."<<endl;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                std::deque<Polygon_t> output;
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[2][2] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[2][2] = 0.0;
                            pc++;
                        }
                    }
                }
            }
        }//end else
 
        ingeom = 0, binAreagrid = 0., binAreapix = 0, intersectArea = 0., pc = 1;
        //lower center  bin
        ws_lat = lat_cgd[rowc - 2][colc - 1];
        ws_lon = lon_cgd[rowc - 2][colc - 1];
        wn_lat = lat_cgd[rowc - 1][colc - 1];
        wn_lon = lon_cgd[rowc - 1][colc - 1];
        en_lat = lat_cgd[rowc - 1][colc];
        en_lon = lon_cgd[rowc - 1][colc];
        es_lat = lat_cgd[rowc - 2][colc];
        es_lon = lon_cgd[rowc - 2][colc];
 
        ws_lon_str = std::to_string(ws_lon);
        ws_lat_str = std::to_string(ws_lat);
        wn_lon_str = std::to_string(wn_lon);
        wn_lat_str = std::to_string(wn_lat);
        en_lon_str = std::to_string(en_lon);
        en_lat_str = std::to_string(en_lat);
        es_lon_str = std::to_string(es_lon);
        es_lat_str = std::to_string(es_lat);
        gridstr = "POLYGON((" + ws_lon_str + " " + ws_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + en_lon_str + " " + en_lat_str + "," + es_lon_str + " " + es_lat_str + "," + ws_lon_str + " " + ws_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2 
        if (binAreagrid < 0.000001)areabinBox[0][1] = 0.0;else areabinBox[0][1] = binAreagrid;
        /*     cout<<"inside binIntersectsPix4corn.."<<"ws_lon.."<<ws_lon<<"ws_lat.."<<ws_lat<<endl;
             cout<<"inside binIntersectsPix4corn.."<<"wn_lon.."<<wn_lon<<"wn_lat.."<<wn_lat<<endl;
             cout<<"inside binIntersectsPix4corn.."<<"en_lon.."<<en_lon<<"en_lat.."<<en_lat<<endl;
             cout<<"inside binIntersectsPix4corn.."<<"es_lon.."<<es_lon<<"es_lat.."<<es_lat<<endl;*/
             //    if(binAreagrid<0.000001)       cout<<"binAreagrid<0.000001..[0][1]"<<endl;
 
        if (ingeom > 0) { //pixel fully inside the grid cell
            intersectArea = binAreapix;
            result = true;
            areaFracBox[0][1] = intersectArea / binAreagrid;
            //        cout<<"pixel fully inside gricell [0][1].."<<endl;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                std::deque<Polygon_t> output;
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[0][1] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[0][1] = 0.0;
                            pc++;
                        }
                    }
                }
            }
        }//end else
        ingeom = 0, binAreagrid = 0., binAreapix = 0, intersectArea = 0., pc = 1;
        //lower left bin
        ws_lat = lat_cgd[rowc - 2][colc - 2];
        ws_lon = lon_cgd[rowc - 2][colc - 2];
        wn_lat = lat_cgd[rowc - 1][colc - 2];
        wn_lon = lon_cgd[rowc - 1][colc - 2];
        en_lat = lat_cgd[rowc - 1][colc - 1];
        en_lon = lon_cgd[rowc - 1][colc - 1];
        es_lat = lat_cgd[rowc - 2][colc - 1];
        es_lon = lon_cgd[rowc - 2][colc - 1];
 
 
        ws_lon_str = std::to_string(ws_lon);
        ws_lat_str = std::to_string(ws_lat);
        wn_lon_str = std::to_string(wn_lon);
        wn_lat_str = std::to_string(wn_lat);
        en_lon_str = std::to_string(en_lon);
        en_lat_str = std::to_string(en_lat);
        es_lon_str = std::to_string(es_lon);
        es_lat_str = std::to_string(es_lat);
        gridstr = "POLYGON((" + ws_lon_str + " " + ws_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + en_lon_str + " " + en_lat_str + "," + es_lon_str + " " + es_lat_str + "," + ws_lon_str + " " + ws_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2 
        if (binAreagrid < 0.000001)areabinBox[0][0] = 0.0;else areabinBox[0][0] = binAreagrid;
        /*     cout<<"inside binIntersectsPix4corn.."<<"ws_lon.."<<ws_lon<<"ws_lat.."<<ws_lat<<endl;
             cout<<"inside binIntersectsPix4corn.."<<"wn_lon.."<<wn_lon<<"wn_lat.."<<wn_lat<<endl;
             cout<<"inside binIntersectsPix4corn.."<<"en_lon.."<<en_lon<<"en_lat.."<<en_lat<<endl;
             cout<<"inside binIntersectsPix4corn.."<<"es_lon.."<<es_lon<<"es_lat.."<<es_lat<<endl;*/
             //    if(binAreagrid<0.000001)        cout<<"binAreagrid<0.000001..[0][0]"<<endl;
 
        if (ingeom > 0) { //pixel fully inside the grid cell
            intersectArea = binAreapix;
            result = true;
            areaFracBox[0][0] = intersectArea / binAreagrid;
            //        cout<<"pixel fully inside gricell [0][0].."<<endl;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                std::deque<Polygon_t> output;
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[0][0] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[0][0] = 0.0;
                            pc++;
                        }
                    }
                }
            }
        }//end else
        ingeom = 0, binAreagrid = 0, binAreapix = 0, intersectArea = 0., pc = 1;
        //lower right bin
        ws_lat = lat_cgd[rowc - 2][colc];
        ws_lon = lon_cgd[rowc - 2][colc];
        wn_lat = lat_cgd[rowc - 1][colc];
        wn_lon = lon_cgd[rowc - 1][colc];
        en_lat = lat_cgd[rowc - 1][colc + 1];
        en_lon = lon_cgd[rowc - 1][colc + 1];
        es_lat = lat_cgd[rowc - 2][colc + 1];
        es_lon = lon_cgd[rowc - 2][colc + 1];
 
        ws_lon_str = std::to_string(ws_lon);
        ws_lat_str = std::to_string(ws_lat);
        wn_lon_str = std::to_string(wn_lon);
        wn_lat_str = std::to_string(wn_lat);
        en_lon_str = std::to_string(en_lon);
        en_lat_str = std::to_string(en_lat);
        es_lon_str = std::to_string(es_lon);
        es_lat_str = std::to_string(es_lat);
        gridstr = "POLYGON((" + ws_lon_str + " " + ws_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + en_lon_str + " " + en_lat_str + "," + es_lon_str + " " + es_lat_str + "," + ws_lon_str + " " + ws_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2 
        if (binAreagrid < 0.000001)areabinBox[0][2] = 0.0;else areabinBox[0][2] = binAreagrid;
        /*  cout<<"inside binIntersectsPix4corn.."<<"ws_lon.."<<ws_lon<<"ws_lat.."<<ws_lat<<endl;
          cout<<"inside binIntersectsPix4corn.."<<"wn_lon.."<<wn_lon<<"wn_lat.."<<wn_lat<<endl;
          cout<<"inside binIntersectsPix4corn.."<<"en_lon.."<<en_lon<<"en_lat.."<<en_lat<<endl;
          cout<<"inside binIntersectsPix4corn.."<<"es_lon.."<<es_lon<<"es_lat.."<<es_lat<<endl;*/
          //  if(binAreagrid<0.000001)        cout<<"binAreagrid<0.000001..[0][2]"<<endl;
 
        if (ingeom > 0) { //pixel fully inside the grid cell
            intersectArea = binAreapix;
            result = true;
            areaFracBox[0][2] = intersectArea / binAreagrid;
            //        cout<<"pixel fully inside gricell [0][2].."<<endl;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                std::deque<Polygon_t> output;
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[0][2] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[0][2] = 0.0;
                            pc++;
                        }
                    }
                }
            }
        }//end else
 
 
        return result;
 
    }
 
 
    //modified method from l2bin-----
    //4 bounds in pixel--- polygon intersection
    bool L1C::binIntersectsPix4corn2(int32_t row, int32_t col, double** lat_cgd, double** lon_cgd, Polygon_t& pixelPoly, double areaFracBox[3][3]) {
        bool result = false;
        double  ws_lat, wn_lat, es_lat, en_lat, ws_lon, wn_lon, es_lon, en_lon;
        bool ingeom = false;
        //   shape->rowcol2bounds(row, col, n, s, e, w);
        int32_t rowc = 0, colc = 0;
        int pc = 1;
        double intersectArea = 0, binAreapix = 0, binAreagrid = 0.;
        std::string ws_lon_str, ws_lat_str, wn_lon_str, wn_lat_str, en_lon_str, en_lat_str, es_lon_str, es_lat_str, gridstr;
 
        rowc = row + 1;
        colc = col + 1;
 
        if (rowc < 0 || colc < 0) {
            cout << "ERROR ON binIntersectsPix4corn2...rowc or colc are negative for cornerlines.." << endl;
            exit(1);        
}
 
        ingeom = 0, binAreagrid = 0., binAreapix = 0, intersectArea = 0., pc = 1;
        //center center bin
        ws_lat = lat_cgd[rowc][colc];
        ws_lon = lon_cgd[rowc][colc];
        wn_lat = lat_cgd[rowc + 1][colc];
        wn_lon = lon_cgd[rowc + 1][colc];
        en_lat = lat_cgd[rowc + 1][colc + 1];
        en_lon = lon_cgd[rowc + 1][colc + 1];
        es_lat = lat_cgd[rowc][colc + 1];
        es_lon = lon_cgd[rowc][colc + 1];
 
 
        Polygon_t gridPoly;
 
        ws_lon_str = std::to_string(ws_lon);
        ws_lat_str = std::to_string(ws_lat);
        wn_lon_str = std::to_string(wn_lon);
        wn_lat_str = std::to_string(wn_lat);
        en_lon_str = std::to_string(en_lon);
        en_lat_str = std::to_string(en_lat);
        es_lon_str = std::to_string(es_lon);
        es_lat_str = std::to_string(es_lat);
        gridstr = "POLYGON((" + ws_lon_str + " " + ws_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + en_lon_str + " " + en_lat_str + "," + es_lon_str + " " + es_lat_str + "," + ws_lon_str + " " + ws_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        //    cout<<"ingeom..center center."<<ingeom<<endl;
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2 
    //    cout<<"binAreagrid.."<<binAreagrid<<"binAreagrid.."<<binAreagrid<<endl;
 
        if (ingeom > 0) { //pixel fully inside the grid cell
      //     cout<<"pixel full inside gridcell-- binarea.."<<binArea<<endl;
            intersectArea = binAreapix;
            result = true;
            areaFracBox[1][1] = intersectArea / binAreagrid;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                std::deque<Polygon_t> output;//this is a list
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    //          cout<<"partial pixel inside gridcell--binarea.."<<binAreagrid<<endl;
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[1][1] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[1][1] = 0.0;
                            /*    cout<<"binAreapix..."<<binAreapix<<"binAreagrid..."<<binAreagrid<<endl;
                                cout<<"partial pixel inside gridcell--areaFracBox[1][1].."<<areaFracBox[1][1]<<endl;
                                cout<<"inside binIntersectsPix4corn.."<<"ws_lon.."<<ws_lon<<"ws_lat.."<<ws_lat<<endl;
                                cout<<"inside binIntersectsPix4corn.."<<"wn_lon.."<<wn_lon<<"wn_lat.."<<wn_lat<<endl;
                                cout<<"inside binIntersectsPix4corn.."<<"en_lon.."<<en_lon<<"en_lat.."<<en_lat<<endl;
                                cout<<"inside binIntersectsPix4corn.."<<"es_lon.."<<es_lon<<"es_lat.."<<es_lat<<endl;*/
                            pc++;
                        }
                    }
                }
            }
        }//end else
 
        ingeom = 0, binAreagrid = 0., binAreapix = 0, intersectArea = 0., pc = 1;
 
        //left center bin
        ws_lat = lat_cgd[rowc][colc - 1];
        ws_lon = lon_cgd[rowc][colc - 1];
        wn_lat = lat_cgd[rowc + 1][colc - 1];
        wn_lon = lon_cgd[rowc + 1][colc - 1];
        en_lat = lat_cgd[rowc + 1][colc];
        en_lon = lon_cgd[rowc + 1][colc];
        es_lat = lat_cgd[rowc][colc];
        es_lon = lon_cgd[rowc][colc];
 
        ws_lon_str = std::to_string(ws_lon);
        ws_lat_str = std::to_string(ws_lat);
        wn_lon_str = std::to_string(wn_lon);
        wn_lat_str = std::to_string(wn_lat);
        en_lon_str = std::to_string(en_lon);
        en_lat_str = std::to_string(en_lat);
        es_lon_str = std::to_string(es_lon);
        es_lat_str = std::to_string(es_lat);
        gridstr = "POLYGON((" + ws_lon_str + " " + ws_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + en_lon_str + " " + en_lat_str + "," + es_lon_str + " " + es_lat_str + "," + ws_lon_str + " " + ws_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        //    cout<<"ingeom..center.left "<<ingeom<<endl;
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2 
    //    cout<<"binAreagrid.."<<binAreagrid<<"binAreagrid.."<<binAreagrid<<endl;
 
        if (ingeom > 0) { //pixel fully inside the grid cell
    //       cout<<"pixel full inside gridcell-- binarea.."<<binArea<<endl;
            intersectArea = binAreapix;
            result = true;
            areaFracBox[1][0] = intersectArea / binAreagrid;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                std::deque<Polygon_t> output;
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    //       cout<<"partial pixel inside gridcell--binarea.."<<binArea<<endl;
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[1][0] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[1][0] = 0.0;
                            /*  cout<<"binAreapix..."<<binAreapix<<"binAreagrid..."<<binAreagrid<<endl;
                              cout<<"partial pixel inside gridcell--areaFracBox[1][0].."<<areaFracBox[1][0]<<endl;
                              cout<<"inside binIntersectsPix4corn.."<<"ws_lon.."<<ws_lon<<"ws_lat.."<<ws_lat<<endl;
                              cout<<"inside binIntersectsPix4corn.."<<"wn_lon.."<<wn_lon<<"wn_lat.."<<wn_lat<<endl;
                              cout<<"inside binIntersectsPix4corn.."<<"en_lon.."<<en_lon<<"en_lat.."<<en_lat<<endl;
                              cout<<"inside binIntersectsPix4corn.."<<"es_lon.."<<es_lon<<"es_lat.."<<es_lat<<endl;*/
                            pc++;
                        }
                    }
                }
            }
        }//end else
 
        ingeom = 0, binAreagrid = 0., binAreapix = 0, intersectArea = 0.;
        //right center bin
        ws_lat = lat_cgd[rowc][colc + 1];
        ws_lon = lon_cgd[rowc][colc + 1];
        wn_lat = lat_cgd[rowc + 1][colc + 1];
        wn_lon = lon_cgd[rowc + 1][colc + 1];
        en_lat = lat_cgd[rowc + 1][colc + 2];
        en_lon = lon_cgd[rowc + 1][colc + 2];
        es_lat = lat_cgd[rowc][colc + 2];
        es_lon = lon_cgd[rowc][colc + 2];
 
        ws_lon_str = std::to_string(ws_lon);
        ws_lat_str = std::to_string(ws_lat);
        wn_lon_str = std::to_string(wn_lon);
        wn_lat_str = std::to_string(wn_lat);
        en_lon_str = std::to_string(en_lon);
        en_lat_str = std::to_string(en_lat);
        es_lon_str = std::to_string(es_lon);
        es_lat_str = std::to_string(es_lat);
        gridstr = "POLYGON((" + ws_lon_str + " " + ws_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + en_lon_str + " " + en_lat_str + "," + es_lon_str + " " + es_lat_str + "," + ws_lon_str + " " + ws_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        //    cout<<"ingeom..center.right "<<ingeom<<endl;
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2 
    //    cout<<"binAreagrid.."<<binAreagrid<<"binAreagrid.."<<binAreagrid<<endl;
 
        if (ingeom > 0) { //pixel fully inside the grid cell
    //       cout<<"pixel full inside gridcell-- binarea.."<<binArea<<endl;
            intersectArea = binAreapix;
            result = true;
            areaFracBox[1][2] = intersectArea / binAreagrid;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0.) {
                std::deque<Polygon_t> output;
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    //             cout<<"partial pixel inside gridcell--binarea.."<<binArea<<endl;
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[1][2] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[1][2] = 0.0;
                            /*    cout<<"binAreapix..."<<binAreapix<<"binAreagrid..."<<binAreagrid<<endl;
                                cout<<"partial pixel inside gridcell--areaFracBox[1][2].."<<areaFracBox[1][2]<<endl;
                                cout<<"inside binIntersectsPix4corn.."<<"ws_lon.."<<ws_lon<<"ws_lat.."<<ws_lat<<endl;
                                cout<<"inside binIntersectsPix4corn.."<<"wn_lon.."<<wn_lon<<"wn_lat.."<<wn_lat<<endl;
                                cout<<"inside binIntersectsPix4corn.."<<"en_lon.."<<en_lon<<"en_lat.."<<en_lat<<endl;
                                cout<<"inside binIntersectsPix4corn.."<<"es_lon.."<<es_lon<<"es_lat.."<<es_lat<<endl;*/
                            pc++;
                        }
                    }
                }
            }
        }//end else
        ingeom = 0, binAreagrid = 0., binAreapix = 0, intersectArea = 0., pc = 1;
        //upper center bin
        ws_lat = lat_cgd[rowc + 1][colc];
        ws_lon = lon_cgd[rowc + 1][colc];
        wn_lat = lat_cgd[rowc + 2][colc];
        wn_lon = lon_cgd[rowc + 2][colc];
        en_lat = lat_cgd[rowc + 2][colc + 1];
        en_lon = lon_cgd[rowc + 2][colc + 1];
        es_lat = lat_cgd[rowc + 1][colc + 1];
        es_lon = lon_cgd[rowc + 1][colc + 1];
 
        ws_lon_str = std::to_string(ws_lon);
        ws_lat_str = std::to_string(ws_lat);
        wn_lon_str = std::to_string(wn_lon);
        wn_lat_str = std::to_string(wn_lat);
        en_lon_str = std::to_string(en_lon);
        en_lat_str = std::to_string(en_lat);
        es_lon_str = std::to_string(es_lon);
        es_lat_str = std::to_string(es_lat);
        gridstr = "POLYGON((" + ws_lon_str + " " + ws_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + en_lon_str + " " + en_lat_str + "," + es_lon_str + " " + es_lat_str + "," + ws_lon_str + " " + ws_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        //    cout<<"ingeom..upper .center"<<ingeom<<endl;
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2 
    //    cout<<"binAreagrid.."<<binAreagrid<<"binAreagrid.."<<binAreagrid<<endl;
 
        if (ingeom > 0) { //pixel fully inside the grid cell
    //       cout<<"pixel full inside gridcell-- binarea.."<<binArea<<endl;
            intersectArea = binAreapix;
            result = true;
            areaFracBox[2][1] = intersectArea / binAreagrid;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                std::deque<Polygon_t> output;
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    //             cout<<"partial pixel inside gridcell--binarea.."<<binArea<<endl;
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[2][1] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[2][1] = 0.0;
                            /*   cout<<"binAreapix..."<<binAreapix<<"binAreagrid..."<<binAreagrid<<endl;
                               cout<<"partial pixel inside gridcell--areaFracBox[2][1].."<<areaFracBox[2][1]<<endl;
                               cout<<"inside binIntersectsPix4corn.."<<"ws_lon.."<<ws_lon<<"ws_lat.."<<ws_lat<<endl;
                               cout<<"inside binIntersectsPix4corn.."<<"wn_lon.."<<wn_lon<<"wn_lat.."<<wn_lat<<endl;
                               cout<<"inside binIntersectsPix4corn.."<<"en_lon.."<<en_lon<<"en_lat.."<<en_lat<<endl;
                               cout<<"inside binIntersectsPix4corn.."<<"es_lon.."<<es_lon<<"es_lat.."<<es_lat<<endl;*/
                            pc++;
                        }
                    }
                }
            }
        }//end else
 
        ingeom = 0, binAreagrid = 0., binAreapix = 0, intersectArea = 0., pc = 1;
        //upper left  bin
        ws_lat = lat_cgd[rowc + 1][colc - 1];
        ws_lon = lon_cgd[rowc + 1][colc - 1];
        wn_lat = lat_cgd[rowc + 2][colc - 1];
        wn_lon = lon_cgd[rowc + 2][colc - 1];
        en_lat = lat_cgd[rowc + 2][colc];
        en_lon = lon_cgd[rowc + 2][colc];
        es_lat = lat_cgd[rowc + 1][colc];
        es_lon = lon_cgd[rowc + 1][colc];
 
        ws_lon_str = std::to_string(ws_lon);
        ws_lat_str = std::to_string(ws_lat);
        wn_lon_str = std::to_string(wn_lon);
        wn_lat_str = std::to_string(wn_lat);
        en_lon_str = std::to_string(en_lon);
        en_lat_str = std::to_string(en_lat);
        es_lon_str = std::to_string(es_lon);
        es_lat_str = std::to_string(es_lat);
        gridstr = "POLYGON((" + ws_lon_str + " " + ws_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + en_lon_str + " " + en_lat_str + "," + es_lon_str + " " + es_lat_str + "," + ws_lon_str + " " + ws_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        //    cout<<"ingeom..upper left "<<ingeom<<endl;
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2 
    //    cout<<"binAreagrid.."<<binAreagrid<<"binAreagrid.."<<binAreagrid<<endl;
 
        if (ingeom > 0) { //pixel fully inside the grid cell
    //       cout<<"pixel full inside gridcell-- binarea.."<<binArea<<endl;
            intersectArea = binAreapix;
            result = true;
            areaFracBox[2][0] = intersectArea / binAreagrid;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                std::deque<Polygon_t> output;
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    //             cout<<"partial pixel inside gridcell--binarea.."<<binArea<<endl;
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[2][0] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[2][0] = 0.0;
 
                            /*   cout<<"binAreapix..."<<binAreapix<<"binAreagrid..."<<binAreagrid<<endl;
                               cout<<"partial pixel inside gridcell--areaFracBox[2][0].."<<areaFracBox[2][0]<<endl;
                               cout<<"inside binIntersectsPix4corn.."<<"ws_lon.."<<ws_lon<<"ws_lat.."<<ws_lat<<endl;
                               cout<<"inside binIntersectsPix4corn.."<<"wn_lon.."<<wn_lon<<"wn_lat.."<<wn_lat<<endl;
                               cout<<"inside binIntersectsPix4corn.."<<"en_lon.."<<en_lon<<"en_lat.."<<en_lat<<endl;
                               cout<<"inside binIntersectsPix4corn.."<<"es_lon.."<<es_lon<<"es_lat.."<<es_lat<<endl;*/
                            pc++;
                        }
                    }
                }
            }
        }//end else
        ingeom = 0, binAreagrid = 0., binAreapix = 0, intersectArea = 0., pc = 1;
        //upper right bin
        ws_lat = lat_cgd[rowc + 1][colc + 1];
        ws_lon = lon_cgd[rowc + 1][colc + 1];
        wn_lat = lat_cgd[rowc + 2][colc + 1];
        wn_lon = lon_cgd[rowc + 2][colc + 1];
        en_lat = lat_cgd[rowc + 2][colc + 2];
        en_lon = lon_cgd[rowc + 2][colc + 2];
        es_lat = lat_cgd[rowc + 1][colc + 2];
        es_lon = lon_cgd[rowc + 1][colc + 2];
 
        ws_lon_str = std::to_string(ws_lon);
        ws_lat_str = std::to_string(ws_lat);
        wn_lon_str = std::to_string(wn_lon);
        wn_lat_str = std::to_string(wn_lat);
        en_lon_str = std::to_string(en_lon);
        en_lat_str = std::to_string(en_lat);
        es_lon_str = std::to_string(es_lon);
        es_lat_str = std::to_string(es_lat);
        gridstr = "POLYGON((" + ws_lon_str + " " + ws_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + en_lon_str + " " + en_lat_str + "," + es_lon_str + " " + es_lat_str + "," + ws_lon_str + " " + ws_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        //    cout<<"ingeom..upper.right"<<ingeom<<endl;
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2 
    //    cout<<"binAreagrid.."<<binAreagrid<<"binAreagrid.."<<binAreagrid<<endl;
 
        if (ingeom > 0) { //pixel fully inside the grid cell
    //       cout<<"pixel full inside gridcell-- binarea.."<<binArea<<endl;
            intersectArea = binAreapix;
            result = true;
            areaFracBox[2][2] = intersectArea / binAreagrid;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                std::deque<Polygon_t> output;
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    //             cout<<"partial pixel inside gridcell--binarea.."<<binArea<<endl;
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[2][2] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[2][2] = 0.0;
 
                            /*   cout<<"binAreapix..."<<binAreapix<<"binAreagrid..."<<binAreagrid<<endl;
                               cout<<"partial pixel inside gridcell--areaFracBox[2][2].."<<areaFracBox[2][2]<<endl;
                               cout<<"inside binIntersectsPix4corn.."<<"ws_lon.."<<ws_lon<<"ws_lat.."<<ws_lat<<endl;
                               cout<<"inside binIntersectsPix4corn.."<<"wn_lon.."<<wn_lon<<"wn_lat.."<<wn_lat<<endl;
                               cout<<"inside binIntersectsPix4corn.."<<"en_lon.."<<en_lon<<"en_lat.."<<en_lat<<endl;
                               cout<<"inside binIntersectsPix4corn.."<<"es_lon.."<<es_lon<<"es_lat.."<<es_lat<<endl;*/
                            pc++;
                        }
                    }
                }
            }
        }//end else
 
        ingeom = 0, binAreagrid = 0., binAreapix = 0, intersectArea = 0., pc = 1;
        //lower center  bin
        ws_lat = lat_cgd[rowc - 1][colc];
        ws_lon = lon_cgd[rowc - 1][colc];
        wn_lat = lat_cgd[rowc][colc];
        wn_lon = lon_cgd[rowc][colc];
        en_lat = lat_cgd[rowc][colc + 1];
        en_lon = lon_cgd[rowc][colc + 1];
        es_lat = lat_cgd[rowc - 1][colc + 1];
        es_lon = lon_cgd[rowc - 1][colc + 1];
 
        ws_lon_str = std::to_string(ws_lon);
        ws_lat_str = std::to_string(ws_lat);
        wn_lon_str = std::to_string(wn_lon);
        wn_lat_str = std::to_string(wn_lat);
        en_lon_str = std::to_string(en_lon);
        en_lat_str = std::to_string(en_lat);
        es_lon_str = std::to_string(es_lon);
        es_lat_str = std::to_string(es_lat);
        gridstr = "POLYGON((" + ws_lon_str + " " + ws_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + en_lon_str + " " + en_lat_str + "," + es_lon_str + " " + es_lat_str + "," + ws_lon_str + " " + ws_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        //    cout<<"ingeom..lower. center"<<ingeom<<endl;
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2 
    //    cout<<"binAreagrid.."<<binAreagrid<<"binAreapix.."<<binAreapix<<endl;
 
    /*    cout<<"inside binIntersectsPix4corn.."<<"ws_lon.."<<ws_lon<<"ws_lat.."<<ws_lat<<endl;
        cout<<"inside binIntersectsPix4corn.."<<"wn_lon.."<<wn_lon<<"wn_lat.."<<wn_lat<<endl;
        cout<<"inside binIntersectsPix4corn.."<<"en_lon.."<<en_lon<<"en_lat.."<<en_lat<<endl;
        cout<<"inside binIntersectsPix4corn.."<<"es_lon.."<<es_lon<<"es_lat.."<<es_lat<<endl;
    */
 
        if (ingeom > 0) { //pixel fully inside the grid cell
    //       cout<<"pixel full inside gridcell-- binarea.."<<binArea<<endl;
            intersectArea = binAreapix;
            result = true;
            areaFracBox[0][1] = intersectArea / binAreagrid;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                std::deque<Polygon_t> output;
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    //             cout<<"partial pixel inside gridcell--binarea.."<<binArea<<endl;
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[0][1] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[0][1] = 0.0;
 
                            /*    cout<<"binAreapix..."<<binAreapix<<"binAreagrid..."<<binAreagrid<<endl;
                                cout<<"partial pixel inside gridcell--areaFracBox[0][1].."<<areaFracBox[0][1]<<endl;
                                cout<<"inside binIntersectsPix4corn.."<<"ws_lon.."<<ws_lon<<"ws_lat.."<<ws_lat<<endl;
                                cout<<"inside binIntersectsPix4corn.."<<"wn_lon.."<<wn_lon<<"wn_lat.."<<wn_lat<<endl;
                                cout<<"inside binIntersectsPix4corn.."<<"en_lon.."<<en_lon<<"en_lat.."<<en_lat<<endl;
                                cout<<"inside binIntersectsPix4corn.."<<"es_lon.."<<es_lon<<"es_lat.."<<es_lat<<endl;*/
                            pc++;
                        }
                    }
                }
            }
        }//end else
        ingeom = 0, binAreagrid = 0., binAreapix = 0, intersectArea = 0., pc = 1;
        //lower left bin
        ws_lat = lat_cgd[rowc - 1][colc - 1];
        ws_lon = lon_cgd[rowc - 1][colc - 1];
        wn_lat = lat_cgd[rowc][colc - 1];
        wn_lon = lon_cgd[rowc][colc - 1];
        en_lat = lat_cgd[rowc][colc];
        en_lon = lon_cgd[rowc][colc];
        es_lat = lat_cgd[rowc - 1][colc];
        es_lon = lon_cgd[rowc - 1][colc];
 
        ws_lon_str = std::to_string(ws_lon);
        ws_lat_str = std::to_string(ws_lat);
        wn_lon_str = std::to_string(wn_lon);
        wn_lat_str = std::to_string(wn_lat);
        en_lon_str = std::to_string(en_lon);
        en_lat_str = std::to_string(en_lat);
        es_lon_str = std::to_string(es_lon);
        es_lat_str = std::to_string(es_lat);
        gridstr = "POLYGON((" + ws_lon_str + " " + ws_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + en_lon_str + " " + en_lat_str + "," + es_lon_str + " " + es_lat_str + "," + ws_lon_str + " " + ws_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
 
        ingeom = within(pixelPoly, gridPoly);
        //    cout<<"ingeom..lower.left"<<ingeom<<endl;
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2 
    //    cout<<"binAreagrid.."<<binAreagrid<<"binAreapix.."<<binAreapix<<endl;
 
        if (ingeom > 0) { //pixel fully inside the grid cell
    //       cout<<"pixel full inside gridcell-- binarea.."<<binArea<<endl;
            intersectArea = binAreapix;
            result = true;
            areaFracBox[0][0] = intersectArea / binAreagrid;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                std::deque<Polygon_t> output;
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    //             cout<<"partial pixel inside gridcell--binarea.."<<binArea<<endl;
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[0][0] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[0][0] = 0.0;
 
                            /*   cout<<"binAreapix..."<<binAreapix<<"binAreagrid..."<<binAreagrid<<endl;
                               cout<<"partial pixel inside gridcell--areaFracBox[0][0].."<<areaFracBox[0][0]<<endl;
                               cout<<"inside binIntersectsPix4corn.."<<"ws_lon.."<<ws_lon<<"ws_lat.."<<ws_lat<<endl;
                               cout<<"inside binIntersectsPix4corn.."<<"wn_lon.."<<wn_lon<<"wn_lat.."<<wn_lat<<endl;
                               cout<<"inside binIntersectsPix4corn.."<<"en_lon.."<<en_lon<<"en_lat.."<<en_lat<<endl;
                               cout<<"inside binIntersectsPix4corn.."<<"es_lon.."<<es_lon<<"es_lat.."<<es_lat<<endl;*/
                            pc++;
                        }
                    }
                }
            }
        }//end else
        ingeom = 0, binAreagrid = 0, binAreapix = 0, intersectArea = 0., pc = 1;
        //lower right bin
        ws_lat = lat_cgd[rowc - 1][colc + 1];
        ws_lon = lon_cgd[rowc - 1][colc + 1];
        wn_lat = lat_cgd[rowc][colc + 1];
        wn_lon = lon_cgd[rowc][colc + 1];
        en_lat = lat_cgd[rowc][colc + 2];
        en_lon = lon_cgd[rowc][colc + 2];
        es_lat = lat_cgd[rowc - 1][colc + 2];
        es_lon = lon_cgd[rowc - 1][colc + 2];
 
        ws_lon_str = std::to_string(ws_lon);
        ws_lat_str = std::to_string(ws_lat);
        wn_lon_str = std::to_string(wn_lon);
        wn_lat_str = std::to_string(wn_lat);
        en_lon_str = std::to_string(en_lon);
        en_lat_str = std::to_string(en_lat);
        es_lon_str = std::to_string(es_lon);
        es_lat_str = std::to_string(es_lat);
        gridstr = "POLYGON((" + ws_lon_str + " " + ws_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + en_lon_str + " " + en_lat_str + "," + es_lon_str + " " + es_lat_str + "," + ws_lon_str + " " + ws_lat_str + "))";
        bg::read_wkt(gridstr, gridPoly);
 
        ingeom = within(pixelPoly, gridPoly);
        //    cout<<"ingeom..lower.right "<<ingeom<<endl;
        binAreagrid = bg::area(gridPoly);
        binAreapix = bg::area(pixelPoly);//area in m2 --Andoyer method --- DIVIDE BY 10^6 FOR KM2 
    //    cout<<"binAreagrid.."<<binAreagrid<<"binAreapix.."<<binAreapix<<endl;
 
        if (ingeom > 0) { //pixel fully inside the grid cell
    //       cout<<"pixel full inside gridcell-- binarea.."<<binArea<<endl;
            intersectArea = binAreapix;
            result = true;
            areaFracBox[0][2] = intersectArea / binAreagrid;
        }
        else {
            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                std::deque<Polygon_t> output;
                if (bg::intersection(pixelPoly, gridPoly, output)) {
                    //             cout<<"partial pixel inside gridcell--binarea.."<<binArea<<endl;
                    BOOST_FOREACH(Polygon_t const& p, output)
                    {
                        intersectArea = bg::area(p);
                        if (intersectArea > 0.0 && pc == 1) {
                            result = true;
                            areaFracBox[0][2] = intersectArea / binAreagrid;
                            if (intersectArea / binAreagrid < 0.000001) areaFracBox[0][2] = 0.0;
 
                            /*      cout<<"binAreapix..."<<binAreapix<<"binAreagrid..."<<binAreagrid<<endl;
                                  cout<<"partial pixel inside gridcell--areaFracBox[0][2].."<<areaFracBox[0][2]<<endl;
                                  cout<<"inside binIntersectsPix4corn.."<<"ws_lon.."<<ws_lon<<"ws_lat.."<<ws_lat<<endl;
                                  cout<<"inside binIntersectsPix4corn.."<<"wn_lon.."<<wn_lon<<"wn_lat.."<<wn_lat<<endl;
                                  cout<<"inside binIntersectsPix4corn.."<<"en_lon.."<<en_lon<<"en_lat.."<<en_lat<<endl;
                                  cout<<"inside binIntersectsPix4corn.."<<"es_lon.."<<es_lon<<"es_lat.."<<es_lat<<endl;*/
                            pc++;
                        }
                    }
                }
            }
        }//end else
 
 
        return result;
    }
 
 
 
    bool L1C::binIntersectsPix4corn(int32_t row, int32_t col, double** lat_cgd, double** lon_cgd, Polygon_t& pixelPoly, double& areaFrac) {
        bool result = false;
        float ws_lat, wn_lat, es_lat, en_lat, ws_lon, wn_lon, es_lon, en_lon;
        //   shape->rowcol2bounds(row, col, n, s, e, w);
        ws_lat = lat_cgd[row][col];
        ws_lon = lon_cgd[row][col];
        wn_lat = lat_cgd[row + 1][col];
        wn_lon = lon_cgd[row + 1][col];
        en_lat = lat_cgd[row + 1][col + 1];
        en_lon = lon_cgd[row + 1][col + 1];
        es_lat = lat_cgd[row][col + 1];
        es_lon = lon_cgd[row][col + 1];
 
        //    Box_t box(Point_t(w,s), Point_t(e,n));
        Polygon_t gridPoly;
        bg::append(gridPoly.outer(), Point_t(ws_lon, ws_lat));
        bg::append(gridPoly.outer(), Point_t(wn_lon, wn_lat));
        bg::append(gridPoly.outer(), Point_t(en_lon, en_lat));
        bg::append(gridPoly.outer(), Point_t(es_lon, es_lat));
        bg::append(gridPoly.outer(), Point_t(ws_lon, ws_lat));
 
        cout << "inside binIntersectsPix4corn.." << "ws_lon.." << ws_lon << "ws_lat.." << ws_lat << endl;
        cout << "inside binIntersectsPix4corn.." << "wn_lon.." << wn_lon << "wn_lat.." << wn_lat << endl;
        cout << "inside binIntersectsPix4corn.." << "en_lon.." << en_lon << "en_lat.." << en_lat << endl;
        cout << "inside binIntersectsPix4corn.." << "es_lon.." << es_lon << "es_lat.." << es_lat << endl;
 
        areaFrac = 0;
 
        if (!bg::disjoint(gridPoly, pixelPoly)) {
            std::deque<Polygon_t> output;
            if (bg::intersection(pixelPoly, gridPoly, output)) {
                //    double binArea = (n-s) * (e-w);
                double binArea = bg::area(gridPoly);
                cout << "binarea.." << binArea << endl;
 
                BOOST_FOREACH(Polygon_t const& p, output)
                {
                    double intersectArea = bg::area(p);
                    if (intersectArea > 0.0) {
                        result = true;
                        areaFrac += intersectArea / binArea;
                    }
                }
            }
        }
        return result;
    }
 
    //modified method from l2bin-----
    //2 bounds in pixel
    //original modified nIntersectsPixelbinIntersectsPixel with grid L1C mask of 3x3 bins
 
    bool L1C::binIntersectsPix2corn2(int32_t row, int32_t col, double** lat_cgd, double** lon_cgd, Box_t& pixelBox, double areaFracBox[3][3]) {
        bool result = false;
        double n, s, e, w;
        int ar = 0, ac = 0;
 
        Box_t gridBox;
        bool ingeom;
 
   //TEST
        s = -75.8635;
        w = -132.772;
        n = -75.8245;
        e = -132.616;
 
        pixelBox.min_corner().set<0>(w);
        pixelBox.min_corner().set<1>(s);
        pixelBox.max_corner().set<0>(e);
        pixelBox.max_corner().set<1>(n);
        //center
        s = lat_cgd[row][col];
        n = lat_cgd[row + 1][col + 1];
        w = lon_cgd[row][col];
        e = lon_cgd[row + 1][col + 1];
 
        gridBox.min_corner().set<0>(w);
        gridBox.min_corner().set<1>(s);
        gridBox.max_corner().set<0>(e);
        gridBox.max_corner().set<1>(n);
 
        ingeom = within(pixelBox, gridBox);
        cout << "ingeom..center." << ingeom << "n.." << n << "s.." << s << "w.." << w << "e.." << e << endl;
 
        if (!bg::disjoint(pixelBox, gridBox)) {
            Box_t output;
            if (bg::intersection(pixelBox, gridBox, output)) {
                double intersectArea = bg::area(output);
                if (intersectArea > 0) {
                    result = true;
                    double binArea = (n - s) * (e - w);
                    areaFracBox[1][1] = intersectArea / binArea;
                    if (intersectArea / binArea < 0.000001) areaFracBox[ar][ac] = 0.0;
                }
            }
        }
 
 
        //left
        s = lat_cgd[row][col - 1];
        n = lat_cgd[row + 1][col];
        w = lon_cgd[row][col - 1];
        e = lon_cgd[row + 1][col];
 
        gridBox.min_corner().set<0>(w);
        gridBox.min_corner().set<1>(s);
        gridBox.max_corner().set<0>(e);
        gridBox.max_corner().set<1>(n);
 
        ingeom = within(pixelBox, gridBox);
        cout << "ingeom..left." << ingeom << "n.." << n << "s.." << s << "w.." << w << "e.." << e << endl;
 
        if (!bg::disjoint(pixelBox, gridBox)) {
            Box_t output;
            if (bg::intersection(pixelBox, gridBox, output)) {
                double intersectArea = bg::area(output);
                if (intersectArea > 0) {
                    result = true;
                    double binArea = (n - s) * (e - w);
                    areaFracBox[1][0] = intersectArea / binArea;
                    if (intersectArea / binArea < 0.000001) areaFracBox[ar][ac] = 0.0;
                }
            }
        }
        //right 
        s = lat_cgd[row][col + 1];
        n = lat_cgd[row + 1][col + 2];
        w = lon_cgd[row][col + 1];
        e = lon_cgd[row + 1][col + 2];
 
        gridBox.min_corner().set<0>(w);
        gridBox.min_corner().set<1>(s);
        gridBox.max_corner().set<0>(e);
        gridBox.max_corner().set<1>(n);
 
        ingeom = within(pixelBox, gridBox);
        cout << "ingeom..right." << ingeom << "n.." << n << "s.." << s << "w.." << w << "e.." << e << endl;
        if (!bg::disjoint(pixelBox, gridBox)) {
            Box_t output;
            if (bg::intersection(pixelBox, gridBox, output)) {
                double intersectArea = bg::area(output);
                if (intersectArea > 0) {
                    result = true;
                    double binArea = (n - s) * (e - w);
                    areaFracBox[1][2] = intersectArea / binArea;
                    if (intersectArea / binArea < 0.000001) areaFracBox[ar][ac] = 0.0;
                }
            }
        }
 
        //up center
        s = lat_cgd[row + 1][col];
        n = lat_cgd[row + 2][col + 1];
        w = lon_cgd[row + 1][col];
        e = lon_cgd[row + 2][col + 1];
 
        gridBox.min_corner().set<0>(w);
        gridBox.min_corner().set<1>(s);
        gridBox.max_corner().set<0>(e);
        gridBox.max_corner().set<1>(n);
 
        ingeom = within(pixelBox, gridBox);
        cout << "ingeom..upcenter." << ingeom << "n.." << n << "s.." << s << "w.." << w << "e.." << e << endl;
        if (!bg::disjoint(pixelBox, gridBox)) {
            Box_t output;
            if (bg::intersection(pixelBox, gridBox, output)) {
                double intersectArea = bg::area(output);
                if (intersectArea > 0) {
                    result = true;
                    double binArea = (n - s) * (e - w);
                    areaFracBox[2][1] = intersectArea / binArea;
                    if (intersectArea / binArea < 0.000001) areaFracBox[ar][ac] = 0.0;
                }
            }
        }
 
        //up left
        s = lat_cgd[row + 1][col - 1];
        n = lat_cgd[row + 2][col];
        w = lon_cgd[row + 1][col - 1];
        e = lon_cgd[row + 2][col];
        gridBox.min_corner().set<0>(w);
        gridBox.min_corner().set<1>(s);
        gridBox.max_corner().set<0>(e);
        gridBox.max_corner().set<1>(n);
 
        ingeom = within(pixelBox, gridBox);
        cout << "ingeom..upleft." << ingeom << "n.." << n << "s.." << s << "w.." << w << "e.." << e << endl;
        if (!bg::disjoint(pixelBox, gridBox)) {
            Box_t output;
            if (bg::intersection(pixelBox, gridBox, output)) {
                double intersectArea = bg::area(output);
                if (intersectArea > 0) {
                    result = true;
                    double binArea = (n - s) * (e - w);
                    areaFracBox[2][0] = intersectArea / binArea;
                    if (intersectArea / binArea < 0.000001) areaFracBox[ar][ac] = 0.0;
                }
            }
        }
 
        //upright
        s = lat_cgd[row + 1][col + 1];
        n = lat_cgd[row + 2][col + 2];
        w = lon_cgd[row + 1][col + 1];
        e = lon_cgd[row + 2][col + 2];
        gridBox.min_corner().set<0>(w);
        gridBox.min_corner().set<1>(s);
        gridBox.max_corner().set<0>(e);
        gridBox.max_corner().set<1>(n);
 
        ingeom = within(pixelBox, gridBox);
        cout << "ingeom..upright." << ingeom << "n.." << n << "s.." << s << "w.." << w << "e.." << e << endl;
        if (!bg::disjoint(pixelBox, gridBox)) {
            Box_t output;
            if (bg::intersection(pixelBox, gridBox, output)) {
                double intersectArea = bg::area(output);
                if (intersectArea > 0) {
                    result = true;
                    double binArea = (n - s) * (e - w);
                    areaFracBox[2][2] = intersectArea / binArea;
                    if (intersectArea / binArea < 0.000001) areaFracBox[ar][ac] = 0.0;
                }
            }
        }
 
 
        //down center
        s = lat_cgd[row - 1][col];
        n = lat_cgd[row][col + 1];
        w = lon_cgd[row - 1][col];
        e = lon_cgd[row][col + 1];
 
        gridBox.min_corner().set<0>(w);
        gridBox.min_corner().set<1>(s);
        gridBox.max_corner().set<0>(e);
        gridBox.max_corner().set<1>(n);
        ingeom = within(pixelBox, gridBox);
        cout << "ingeom..downcenter." << ingeom << "n.." << n << "s.." << s << "w.." << w << "e.." << e << endl;
        if (!bg::disjoint(pixelBox, gridBox)) {
            Box_t output;
            if (bg::intersection(pixelBox, gridBox, output)) {
                double intersectArea = bg::area(output);
                if (intersectArea > 0) {
                    result = true;
                    double binArea = (n - s) * (e - w);
                    areaFracBox[0][1] = intersectArea / binArea;
                    if (intersectArea / binArea < 0.000001) areaFracBox[ar][ac] = 0.0;
                }
            }
        }
 
        //down left
        s = lat_cgd[row - 1][col - 1];
        n = lat_cgd[row][col];
        w = lon_cgd[row - 1][col - 1];
        e = lon_cgd[row][col];
        gridBox.min_corner().set<0>(w);
        gridBox.min_corner().set<1>(s);
        gridBox.max_corner().set<0>(e);
        gridBox.max_corner().set<1>(n);
 
        ingeom = within(pixelBox, gridBox);
        cout << "ingeom..downleft." << ingeom << "n.." << n << "s.." << s << "w.." << w << "e.." << e << endl;
        if (!bg::disjoint(pixelBox, gridBox)) {
            Box_t output;
            if (bg::intersection(pixelBox, gridBox, output)) {
                double intersectArea = bg::area(output);
                if (intersectArea > 0) {
                    result = true;
                    double binArea = (n - s) * (e - w);
                    areaFracBox[0][0] = intersectArea / binArea;
                    if (intersectArea / binArea < 0.000001) areaFracBox[ar][ac] = 0.0;
                }
            }
        }
        //down right
        s = lat_cgd[row - 1][col + 1];
        n = lat_cgd[row][col + 2];
        w = lon_cgd[row - 1][col + 1];
        e = lon_cgd[row][col + 2];
 
        gridBox.min_corner().set<0>(w);
        gridBox.min_corner().set<1>(s);
        gridBox.max_corner().set<0>(e);
        gridBox.max_corner().set<1>(n);
        ingeom = within(pixelBox, gridBox);
        cout << "ingeom..downright." << ingeom << "n.." << n << "s.." << s << "w.." << w << "e.." << e << endl;
        if (!bg::disjoint(pixelBox, gridBox)) {
            Box_t output;
            if (bg::intersection(pixelBox, gridBox, output)) {
                double intersectArea = bg::area(output);
                if (intersectArea > 0) {
                    result = true;
                    double binArea = (n - s) * (e - w);
                    areaFracBox[0][2] = intersectArea / binArea;
                    if (intersectArea / binArea < 0.000001) areaFracBox[ar][ac] = 0.0;
                }
            }
        }
 
        if (n < s) {  //this is happening in right side terminal pixels such as pixel 1254
            n = lat_cgd[row][col];
            s = lat_cgd[row + 1][col + 1];
        }
        if (e < w) {
            e = lon_cgd[row][col];
            w = lon_cgd[row + 1][col + 1];
        }
 
        return result;
    }
 
    //2 bounds in pixel
    //original nIntersectsPixelbinIntersectsPixel
    bool L1C::binIntersectsPix2corn(int32_t row, int32_t col, double** lat_cgd, double** lon_cgd, Box_t& pixelBox, double& areaFrac) {
        bool result = false;
        float n, s, e, w;
 
        s = lat_cgd[row][col];
        n = lat_cgd[row + 1][col + 1];
        w = lon_cgd[row][col];
        e = lon_cgd[row + 1][col + 1];
 
        if (n < s) {  //this is happening in right side terminal pixels such as pixel 1254
            n = lat_cgd[row][col];
            s = lat_cgd[row + 1][col + 1];
        }
        if (e < w) {
            e = lon_cgd[row][col];
            w = lon_cgd[row + 1][col + 1];
        }
 
        cout << "south gridcorn.." << s << "north gridcorn.." << n << "west gridcorn.." << w << "east gridcorn" << e << endl;
 
        Box_t box(Point_t(w, s), Point_t(e, n));//x = longitude, y = latitude
        areaFrac = 0;
 
        if (!bg::disjoint(box, pixelBox)) {
            Box_t output;
            if (bg::intersection(box, pixelBox, output)) {
                double intersectArea = bg::area(output);
                if (intersectArea > 0) {
                    result = true;
                    double binArea = (n - s) * (e - w);
                    areaFrac = intersectArea / binArea;
                }
            }
        }
        return result;
    }
 
 
 
 
 
int L1C::create_SOCEA(int swtd,L1C_input* l1cinput, l1c_filehandle* l1cfile,float** lat_gd, float **lon_gd){
 
    int32_t num_gridlines, nbinx;
        int  ncid_out,x_dimid, y_dimid, varid1, varid2, status;
        int NDIMS=2;
        int dimids[NDIMS];
        int32_t NX, NY;
        int16_t selyear = -1, selmon = -1, selday = -1;
        int grp_coor;
        const char* filename_lt;
 
//        float **lt_out=nullptr;
        int NVIEWS, NBANDS,v_dimid,b_dimid,asc_mode=-1;
        string senstr,tswt_ini,tswt_end,tswt_ini_file;
 
        if(l1cinput->sensor==1){
             senstr="SPEXone";
             l1cfile->nbinx=20;
              }
        else if (l1cinput->sensor==2){
            senstr="OCI";
            l1cfile->nbinx=514;
             }
        else if (l1cinput->sensor==3){
            senstr="HARP2";
            l1cfile->nbinx=452;
            }
        else{cout<<"sensor by default is OCI option 2....."<<endl;
            senstr="OCI"; 
             l1cfile->nbinx=514;
          }
 
 
 
 
 
        //compute azimuth angle for each along-track position (nadir pixel or centered swath pixel) of the swath
        //azimuth angle in rads
        //lon+540/360-180 is a normalization factor for -180 to 180 degrees   
        num_gridlines = l1cfile->num_gridlines;
        num_pixels = l1cfile->npix;
        nbinx = l1cfile->nbinx;
 
        cout<<"# gridlines.."<<num_gridlines<<endl;
 
        tswt_ini=l1cfile->tswt_ini;
        tswt_end=l1cfile->tswt_end;
        tswt_ini_file=l1cfile->tswt_ini_file;
 
      //big loop
 
 
        asc_mode=l1cfile->orb_dir;
 
 
//---- writing results -------------------------------------------
//--------------------------------------------------------------
        
        selday = l1cinput->selday;
        selmon = l1cinput->selmon;
        selyear = l1cinput->selyear;
 
        std::string timestr,missionstr,fname_out, pathstr,monstr, daystr, yearstr, prodstr, gdstr, swtstr, swtnum, extstr,ofilestr,dirstr;
 
        if(asc_mode==1) dirstr="Ascending";
        else if(asc_mode==0) dirstr="Descending";
 
 
 
        pathstr = "out/";
        missionstr="PACE";       
        monstr = std::to_string(selmon);
        daystr = std::to_string(selday);
        yearstr = std::to_string(selyear);
        timestr="T00:00:00Z";
        prodstr = "L1Cgrid_";        
        swtstr = "_swt";
        swtnum = std::to_string(swtd);
        extstr = ".nc";
        ofilestr=std::string(l1cinput->ofile);
 
//        fname_out = pathstr + ofilestr+"_"+ prodstr+senstr+swtstr+swtnum+extstr;
        fname_out=pathstr+"PACE_"+senstr+"."+tswt_ini_file+".L1C.5.2km.nc";
     //   string datestr=date;
 
        auto t = std::time(nullptr);
        auto tm = *std::localtime(&t);
        std::ostringstream oss,oss2;
        oss << std::put_time(&tm, "%d-%m-%Y %H-%M-%S") << std::endl;
      //  cout<<"current datetime.n UTC."<<datestr<<endl;
        auto datestr = oss.str();
        cout<<"date.."<<datestr.substr(0,2)<<endl;
 
       time_t rawtime;
       time (&rawtime);
       string datestr2=ctime (&rawtime);
 
 
//        oss2<<system("date")<<endl;
//        string datestr2=oss2.str();
        cout<<"date.."<<datestr2.substr(0,10)<<endl;
//        exit(1);
 
 
 
 
        string  ATT_NAME="Units", ATT_VAL="degrees",GATT_NAME1="Title",GATT_VAL1="PACE OCI Level-1C Data",GATT_NAME2="instrument",GATT_VAL2="OCI",GATT_NAME3="processing_version",GATT_VAL3="V1.0",GATT_NAME4="Conventions",GATT_VAL4="CF-1.6";
        string GATT_NAME5="institution",GATT_VAL5="NASA Goddard Space Flight Center, Ocean Biology Processing Group",GATT_NAME6="license",GATT_VAL6="http://science.nasa.gov/earth-science/earth-science-data/data-information-policy/";
        string GATT_NAME7="naming_authority",GATT_VAL7="gov.nasa.gsfc.sci.oceancolor",GATT_NAME8="keywords_vocabulary",GATT_VAL8="NASA Global Change Master Directory (GCMD) Science Keywords";
        string GATT_NAME9="stdname_vocabulary",GATT_VAL9="NetCDF Climate and Forecast (CF) Metadata Convention",GATT_NAME10="creator_name",GATT_VAL10="NASA/GSFC",GATT_NAME11="creator_email",GATT_VAL11="data@oceancolor.gsfc.nasa.gov";
        string GATT_NAME12="creator_url",GATT_VAL12="http://oceancolor.gsfc.nasa.gov",GATT_NAME13="project",GATT_VAL13="PACE Project",GATT_NAME14="publisher_name",GATT_VAL14="NASA/GSFC";
        string GATT_NAME15="publisher_email",GATT_VAL15="data@oceancolor.gsfc.nasa.gov",GATT_NAME16="publisher_url",GATT_VAL16="http://oceancolor.gsfc.nasa.gov",GATT_NAME17="processing_level",GATT_VAL17="L1C";
        string GATT_NAME18="cdm_data_type",GATT_VAL18="swath",GATT_NAME19="orbit_number",GATT_VAL19="xxx",GATT_NAME20="history",GATT_VAL20="",GATT_NAME21="CDL_version_date",GATT_VAL21="2021-09-10",GATT_NAME22="product_name",GATT_VAL22=fname_out;
        string GATT_NAME23="startDirection",GATT_VAL23=dirstr,GATT_NAME24="endDirection",GATT_VAL24=dirstr,GATT_NAME25="time_coverage_start",GATT_VAL25=tswt_ini,GATT_NAME26="time_coverage_end",GATT_VAL26=tswt_end,GATT_NAME27="date_created",GATT_VAL27="2022-03-25T15:12:41Z",GATT_NAME28="sun_earth_distance",GATT_VAL28="0.990849042172323",GATT_NAME29="terrain_data_source",GATT_VAL29="",GATT_NAME30="spectral_response_function",GATT_VAL30="",GATT_NAME31="systematic_uncertainty_model",GATT_VAL31="",GATT_NAME32="nadir_bin",GATT_VAL32="12345",GATT_NAME33="bin_size_at_nadir",GATT_VAL33="5.2km2";
 
 
        l1cfile->gridname = fname_out.c_str();
        filename_lt = fname_out.c_str();
 
        cout<<"creating file for L1C coor..."<<filename_lt<<endl;
 
       
        if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
            check_err(status, __LINE__, __FILE__);
        //define dims
     // Define the dimensions,vars and attributes at the root level
        NY = num_gridlines;
        NX = nbinx;
 
        if(l1cinput->sensor==1){
            senstr="SPEXone";
            GATT_VAL2="SPEXone";
            GATT_VAL32="3567";
            NVIEWS=5;
            NBANDS=400;
             }
        else if (l1cinput->sensor==2){
            senstr="OCI";
            GATT_VAL2="OCI";
            GATT_VAL32="635";
            NVIEWS=2;
            NBANDS=249;
             }
        else if (l1cinput->sensor==3){
            senstr="HARP2";
            GATT_VAL2="HARP2";
            GATT_VAL32="127";
            NVIEWS=90;
            NBANDS=1;
              }
        else{
            cout<<"sensor by default is OCI option 2....."<<endl;
            senstr="OCI";
            GATT_VAL2="OCI";
            GATT_VAL32="635";
            NVIEWS=2;
            NBANDS=249;
             }
 
//        lt_out = allocate2d_float(NY, NX);
  //DEF DIMENSIONS
        if ((status = nc_def_dim(ncid_out, "bins_across_track", NX, &x_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "bins_along_track", NY, &y_dimid)))
            check_err(status, __LINE__, __FILE__);
        //dims for output var
        dimids[0] = y_dimid;
        dimids[1] = x_dimid;
        NDIMS=2;
        if ((status = nc_def_dim(ncid_out, "number_of_views", NVIEWS, &v_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "intensity_bands_per_view", NBANDS, &b_dimid)))
            check_err(status, __LINE__, __FILE__);
        //define attributes
//       if (nc_put_att_text(ncid_out, varid1, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
//           check_err(status, __LINE__, __FILE__);
//       if (nc_put_att_text(ncid_out, varid2, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
//           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME1.c_str(), strlen(GATT_VAL1.c_str()),
          GATT_VAL1.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME2.c_str(), strlen(GATT_VAL2.c_str()),
          GATT_VAL2.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME3.c_str(), strlen(GATT_VAL3.c_str()),
          GATT_VAL3.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME4.c_str(), strlen(GATT_VAL4.c_str()),
          GATT_VAL4.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME5.c_str(), strlen(GATT_VAL5.c_str()),
          GATT_VAL5.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME6.c_str(), strlen(GATT_VAL6.c_str()),
          GATT_VAL6.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME7.c_str(), strlen(GATT_VAL7.c_str()),
          GATT_VAL7.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME8.c_str(), strlen(GATT_VAL8.c_str()),
          GATT_VAL8.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME9.c_str(), strlen(GATT_VAL9.c_str()),
          GATT_VAL9.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME10.c_str(), strlen(GATT_VAL10.c_str()),
          GATT_VAL10.c_str()))
           check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME11.c_str(), strlen(GATT_VAL11.c_str()),
          GATT_VAL11.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME12.c_str(), strlen(GATT_VAL12.c_str()),
          GATT_VAL12.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME13.c_str(), strlen(GATT_VAL13.c_str()),
          GATT_VAL13.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME14.c_str(), strlen(GATT_VAL14.c_str()),
          GATT_VAL14.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME15.c_str(), strlen(GATT_VAL15.c_str()),
          GATT_VAL15.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME16.c_str(), strlen(GATT_VAL16.c_str()),
          GATT_VAL16.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME17.c_str(), strlen(GATT_VAL17.c_str()),
          GATT_VAL17.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME18.c_str(), strlen(GATT_VAL18.c_str()),
          GATT_VAL18.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME19.c_str(), strlen(GATT_VAL19.c_str()),
          GATT_VAL19.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME20.c_str(), strlen(GATT_VAL20.c_str()),
          GATT_VAL20.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME21.c_str(), strlen(GATT_VAL21.c_str()),
          GATT_VAL21.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME22.c_str(), strlen(GATT_VAL22.c_str()),
          GATT_VAL22.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME23.c_str(), strlen(GATT_VAL23.c_str()),
          GATT_VAL23.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME24.c_str(), strlen(GATT_VAL24.c_str()),
          GATT_VAL24.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME25.c_str(), strlen(GATT_VAL25.c_str()),
          GATT_VAL25.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME26.c_str(), strlen(GATT_VAL26.c_str()),
          GATT_VAL26.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME27.c_str(), strlen(GATT_VAL27.c_str()),
          GATT_VAL27.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME28.c_str(), strlen(GATT_VAL28.c_str()),
          GATT_VAL28.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME29.c_str(), strlen(GATT_VAL29.c_str()),
          GATT_VAL29.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME30.c_str(), strlen(GATT_VAL30.c_str()),
          GATT_VAL30.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME31.c_str(), strlen(GATT_VAL31.c_str()),
          GATT_VAL31.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME32.c_str(), strlen(GATT_VAL32.c_str()),
          GATT_VAL32.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME33.c_str(), strlen(GATT_VAL33.c_str()),
          GATT_VAL33.c_str()))
          check_err(status, __LINE__, __FILE__);
 
      //define groups                  check_err(status, __LINE__, __FILE__);
       if ((status = nc_def_grp(ncid_out, "geolocation_data", &grp_coor)))  //netcdf-4
          check_err(status, __LINE__, __FILE__);
        //def var
        if ((status = nc_def_var(grp_coor, "latitude", NC_FLOAT, NDIMS,
                dimids, &varid1)))
                check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_var(grp_coor, "longitude", NC_FLOAT, NDIMS,
                dimids, &varid2)))
                check_err(status, __LINE__, __FILE__);
    //leave define mode-----------------------
        if ((status = nc_enddef(grp_coor))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
 
 
        //writing the whole thing
        if ((status = nc_put_var_float(grp_coor, varid1, &lat_gd[0][0])))
            check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_put_var_float(grp_coor, varid2, &lon_gd[0][0])))
            check_err(status, __LINE__, __FILE__);
 
 
 
//define attributes of vars in groups
//UNITS in degrees ----
        if (nc_put_att_text(grp_coor, varid1, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
         check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(grp_coor, varid2, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
 
 
//close file
        if ((status = nc_close(ncid_out)))
           check_err(status, __LINE__, __FILE__);
 
 
 
 
 
 return 0;   
}
 
 
 
 
 
 
int L1C::search_SOCEA(L1C_input* l1cinput, l1c_filehandle* l1cfile, float** lat, float **lon, double *time_mgv, float ect,float loncross) {
int32_t irow=-1,icol=-1;
float binsize=5.2, rem=6371,oang,xmm=0.001065,omeg=2 * M_PI / 86400,xinc=98.1111,rom=7054.5;
float senview=20,oview;//viewing angle of the sensor, OCI, -20 degrees south, +20 degrees north
double delt;
float lonet,yaws=3.84,xinct,ata,cp;
 
 
//OCI Nrow=4000, Ncol=514
 
//ect is equatorial crossing time
  delt=time_mgv[0]-ect;//first gridline
  oview= asin(rom*sin(senview*M_PI/180.)/rem) - senview*M_PI/180.; // Along-track orbit angle for view
  oang=xmm-omeg*cos(xinc*M_PI/180.)*delt + oview; //orbit angle from equator
  irow = round(oang*rem/binsize);
 
cout<<"row number..."<<irow+1<<endl;
 
// Orbit normal
  lonet = (loncross + yaws*sin(2*oang)/2)*M_PI/180. - delt*omeg;
  xinct = (xinc + yaws*(1+cos(2*oang))/2)*M_PI/180.;
  float on[3];
  on[0] = sin(xinct)*sin(lonet);
  on[1] = -sin(xinct)*cos(lonet);
  on[2] = cos(xinct);
 
  
// Compute lat/lon to subsatellite track angle and column number
  float xll[3];
  xll[0] = cos(lon[0][0]*M_PI/180.)*cos(lat[0][0]*M_PI/180.);
  xll[1] = sin(lon[0][0]*M_PI/180.)*cos(lat[0][0]*M_PI/180.);
  xll[2] = sin(lat[0][0]*M_PI/180.);
 
  cp = on[0]*xll[0]  + on[1]*xll[1] + on[2]*xll[2];//dot product of vectors position and orbit normal L and N respectively
  ata = acos(cp) - M_PI/2.;
  icol = round(ata*rem/binsize);
 
cout<<"col number..."<<icol+1<<endl;
 
 
return 0;    
}
 
 
 
 
    //this is the Fred method for finding row/col of L1C grid for specific location
    //this works pixel by pixel---
    void L1C::search_rc_l1c(L1C_input* l1cinput, l1c_filehandle* l1cfile, float lat_pix, float lon_pix, double dtime_pix, float lon_eqc, short* rowindex, short* colindex, short Nneg) {
 
        //dtime = time offset with respect to the equator in seconds---
        float wo = 0.001065, oangle, oangler, we = 2 * M_PI / 86400, incli = 98.111; //woin radians/second PACE orbit mean motion, we= earth rotation, 460 m/s or 1 rotation in in 86400 s, orbit inclination is in degrees  
        float binres, all, all2, Ro = 7054.5, va;//Ro is the orbit radius in km, Re is the earth radius in km, va is the view angle
        short Nr, Nc;
        float gamma, dlon, sva, LcpN, dincli, phi_yaw = 3.83 * M_PI / 180;//phiyaw is the amplitude yaw steering angle, theta is the orbit angle from the equatorial crossing
        double n11, n12, n13, l11, l12, l13;
 
        incli = incli * M_PI / 180;
        binres = (l1cinput->gres);//grid resolution in km
 
        //estimating row number---
 
        //computing orbit angle
        oangle = wo * dtime_pix;
        //adjustment by earth rotation
        oangler = oangle - we * cos(incli) * dtime_pix;
 
        //cout<<"search_rc_l1c.."<<"dtime_pix..."<<dtime_pix<<"oangler.."<<oangler<<endl;
 
 
        //sensor along-track view angle in radians
        //O-P O-S angle
        dlon = (lon_eqc - lon_pix) * M_PI / 180;
        lon_eqc = lon_eqc * M_PI / 180;
 
        gamma = acos((lat_pix * M_PI / 180) * cos(dlon));
        all2 = Ro * sqrt(1 + (Re / Ro) * (Re / Ro) - 2 * (Re / Ro) * cos(gamma));
 
        //from soler et al.  ISSN0733-9453/94/0003-0115/$2.00+ $.25per page.PaperNo. 7382.ournalofSurveyingEngineering,Vol. 120,No. 3, August,1994.
        sva = acos((Ro / all2) * sin(gamma));
        va = 180 - sva * 180 / M_PI - gamma * 180 / M_PI;
        va = va * M_PI / 180.;
 
 
        //computing along-track length
        all = asin(Ro * sin(va) / Re) - va;
 
        //relative row number---
        Nr = (oangler + all) * Re / binres;
        //Nr=Nr+round(num_gridlines/2);
        Nr = Nr + Nneg;
 
        *rowindex = Nr;
 
        //column estimation
        //HARP-SPEX-one are push-broom, OCI is whisk-broom so small time difference between pixels which is ignored
 
        //position vector L
        //N vector normal to position and velocity, this is orbit normal vector
 
        //computing N
        dincli = phi_yaw * cos(oangle) * cos(oangle);
 
        n11 = sin(incli + dincli) * sin(lon_eqc - we * dtime_pix + dlon);
        n12 = -sin(incli + dincli) * cos(lon_eqc - we * dtime_pix + dlon);
        n13 = cos(incli + dincli);
 
        //computing L
        l11 = cos(lon_pix * M_PI / 180) * cos(lat_pix * M_PI / 180);
        l12 = sin(lon_pix * M_PI / 180) * cos(lat_pix * M_PI / 180);
        l13 = sin(lat_pix * M_PI / 180);
 
        //column number estimation
        LcpN = n11 * l11 + n12 * l12 + n13 * l13;//cross product of vectors position and orbit normal L and N respectively
        Nc = (acos(LcpN) - 0.5 * M_PI) * Re / binres;
        *colindex = Nc;
 
        //cout<<"row..#.."<<Nr<<"col...#.."<<Nc<<endl;
        //cout<<"search_rc_l1c.."<<"gamma..."<<gamma<<"va.."<<va<<"all...."<<all<<"all2..."<<all2<<endl;
 
    }
 
 
 
    void L1C::sbs2_sort_latgd(l1c_filehandle* l1cfile, float** lat_gd, float** lat_asort, short** index_xy) {
 
        int32_t NY1 = -1, NY2 = -1,nbinx;
 
        nbinx = l1cfile->nbinx;
        NY1 = l1cfile->NY1;
        NY2 = l1cfile->NY2;
 
        cout << "NY1.." << NY1 << "NY2.." << NY2 << endl;
 
 
        //define 1-D vector to sort 1 col L1C grid at the time---
        vector<pair<float, int> > vp;
 
        //fill vector with lat_gd column--
        cout << "*********** SORTING LAT/LON GRIDPOINTS AND TRACKING INDEXES ********************" << endl;
 
        for (int col = 0;col < nbinx;col++) {
            for (int row = NY1;row < NY2 + 1;row++) {
                vp.push_back(make_pair(lat_gd[row][col] + 90., row));
            }//ading 90 degrees so it is 0-180 degrees always positive latitude
//sort 
            stable_sort(vp.begin(), vp.end());
            //display lat in order along with its gridpoint index--
              //   cout << "Lat value\t"
              //         << "index" << endl; 
            for (unsigned int i = 0; i < vp.size(); i++) {
                //   cout << vp[i].first << "\t "<< vp[i].second << endl;
 
                lat_asort[i][col] = vp[i].first;
                index_xy[i][col] = vp[i].second;
            }
            vp.clear();//clear col
        }
 
 
    }
 
 
 
 
    //saddleback search algo improved 
    //this approach is actually based on a radius search distance rather than a polygon pixel shape. This must be improved 
    bool L1C::sbs2_l1c(L1C_input* l1cinput, int32_t ydim, int32_t xdim, float** alat, short** alat_index, float latpix, float lonpix, float** lon_gd, short* rowindex, short* colindex)
    {
        //pixval can be latpix or lonpix
        //flag_coor 0 latitude, 1 longitude
         //mat is is the sorted matrix in ascending order
         //mat_index IS THE ORIGINAL INDEX of lat or lon values L1C gridpoint 
         //this INDEXING MAY CHANGE BETWEEN COLUMNS OR ACROSS GRIDLINES!!! 
 
        short i = ydim - 1, j = 0, erow, ecol;  //set indexes for bottom left element 
        float diflon, diflat, diflat2, dtogd, dtogd2, binres, londegkm;
        float latpos, lonpos, lonpos_gd;
 
 
        binres = (l1cinput->gres) * 1000; //L1C grid resolution in meters
 
        while ((i - 1) >= 0 && j < xdim)
        {
            latpos = latpix + 90;//convert -90,+90 to lat 0-180
 
            if (latpos >= alat[i - 1][j] && latpos <= alat[i][j]) {
                     //check coor difference with respect to center gridpoint--
                diflat = abs(latpos - alat[i][j]);
                diflat2 = abs(latpos - alat[i - 1][j]);
                //check lat distance to gridpoint-
                dtogd = diflat * 111.321 * 1000;
                dtogd2 = diflat2 * 111.321 * 1000;
 
                if (dtogd < dtogd2 && dtogd <= binres / 2) {
                    erow = alat_index[i][j];                
}
                else if (dtogd2 < dtogd && dtogd2 <= binres / 2) {
                    erow = alat_index[i - 1][j];                
}
 
                //check longitude estimate
                if (lonpix < 0.) lonpos = lonpix + 180;else lonpos = lonpix;//longitude between 0 and 360
                if (lon_gd[erow][j] < 0.) lonpos_gd = lon_gd[erow][j] + 180;else lonpos_gd = lon_gd[erow][j];
 
                diflon = abs(lonpos - lonpos_gd);
                londegkm = cos(latpix * degrad) * 111.321;
                dtogd = diflon * londegkm * 1000;
 
                if (dtogd <= binres / 2) {
                    ecol = j;
                    *rowindex = erow;
                    *colindex = ecol;
                    return true;
                }
                else j++;//go to next col
 
            } //end if lat bracket  
 
            if (alat[i][j] > latpos && alat[i - 1][j] > latpos) { //pixval < mat
                i--;
 
            }
            if (i == 0) return false;
 
            if (alat[i][j] < latpos && alat[i - 1][j] < latpos) {
                j++;
 
                if (j == xdim) return false;
            }
            if (i == 0 | j == xdim) return false;
 
            //the sorting is done over the rows for each column so row order is actually changing!!
 
        }//end while
 
        return false;
    }
 
    double L1C::binL1C_pixelpoly(l1c_filehandle* l1cfile, L1C_input* l1cinput, l1c_str* l1cstr, short gd_row, short gd_col, int32_t pix) {
        int32_t inpix = 0;
        string str, pathstr, senstr, monstr, daystr, yearstr, prodstr, swtstr, granstr, swtnum, extstr, fname_out;
        float Re = 6378;
        float aterm = 0.;
        string gridname, azeast_name;
        float azpix, azpixc;
        float deltaphi, deltalam, bterm, dist_u, dist_v;
        double lat_cnw, lat_cne, lat_csw, lat_cse, lon_cnw, lon_cne, lon_csw, lon_cse;
        float theta, thetares, dist_corn, thetagrad;
        string ws_lon_str, ws_lat_str, wn_lon_str, wn_lat_str, en_lon_str, en_lat_str, es_lon_str, es_lat_str, pixstr;
        double bintemp = 0;
 
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
 
 
        //************ BINNING ***************************
     //assign identified pixel to Lt and bin stat arrays-----         
 
        Polygon_t pixelPoly;
        Polygon_t gridPoly;
 
        inpix++;
        deltaphi = (l1cstr->latpix[pix] - l1cstr->latpix[pix + 1]) * degrad;
        deltalam = (l1cstr->lonpix[pix] - l1cstr->lonpix[pix + 1]) * degrad;
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(l1cstr->latpix[pix] * degrad) * cos(l1cstr->latpix[pix + 1] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_u = Re * bterm;         //horizontal distance Harversine in km
    //along-track distance
        deltaphi = (l1cstr->latpix[pix] - l1cstr->latpix2[pix]) * degrad;
        deltalam = (l1cstr->lonpix[pix] - l1cstr->lonpix2[pix]) * degrad;
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(l1cstr->latpix[pix] * degrad) * cos(l1cstr->latpix2[pix] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_v = Re * bterm;
        //pixel azimuth
        azpix = atan2(sin(deltalam) * cos(l1cstr->latpix2[pix] * degrad), cos(l1cstr->latpix[pix] * degrad) * sin(l1cstr->latpix2[pix] * degrad) - sin(l1cstr->latpix[pix] * degrad) * cos(l1cstr->latpix2[pix] * degrad) * cos(deltaphi));
        if (azpix > M_PI || azpix < -M_PI) {
            cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "azpixc in degrees.." << azpix * 180 / M_PI << endl;
            exit(1);
        }
        azpix = azpix * 180. / M_PI;
 
        //      cout<<"line.."<<sline+1<<"pix #:.."<<pix+1<<"pix size.U in km."<<dist_u<<"pixsize.V in km."<<dist_v<<"azpix before  pix_corners4_l1c....in degrees."<<azpix<<endl;
       //       cout<<"FOUND grid cell!!-----row.."<<gd_row<<"col.."<<gd_col<<"latpix.."<<l1cstr->latpix[pix]<<"lonpix.."<<l1cstr->lonpix[pix]<<"latpix2.."<<l1cstr->latpix2[pix]<<"lonpix2.."<<l1cstr->lonpix2[pix]<<endl;                             
 
        //******* M_PIXEL CORNERS ***********************************************************************************************
        dist_corn = 0.5 * (sqrt(dist_u * dist_u + dist_v * dist_v)) * 1000;//distane center to corner in meters
        theta = atan2(dist_v, dist_u);
        thetagrad = 2 * theta * 180 / M_PI;
        thetares = (M_PI / 2 - theta) * 180 / M_PI;
        //nw corner 
        azpixc = (azpix - thetares) * degrad;//pixel bearing
        if (azpixc<-M_PI || azpixc>M_PI) { cout << "error in nw corner..azpixc" << azpixc << endl;exit(1); }
        azpixc = azpixc * 180 / M_PI;
        //      cout<<"azpixc nw...."<<azpixc<<endl;
        geod.Direct(l1cstr->latpix[pix], l1cstr->lonpix[pix], azpixc, dist_corn, lat_cnw, lon_cnw);
        //ne corner (sw-180)
        azpixc = (azpix + thetares) * degrad;//pixel bearing
        if (azpixc<-M_PI || azpixc>M_PI) { cout << "error in ne corner..azpixc" << azpixc << endl;exit(1); }
        azpixc = azpixc * 180 / M_PI;
        //      cout<<"azpixc ne...."<<azpixc<<endl;
        geod.Direct(l1cstr->latpix[pix], l1cstr->lonpix[pix], azpixc, dist_corn, lat_cne, lon_cne);
        //sw corner               
        azpixc = (azpix - thetares - thetagrad) * degrad;//pixel bearing
        if (azpixc<-M_PI || azpixc>M_PI) { cout << "error in sw corner..azpixc" << azpixc << endl;exit(1); }
        azpixc = azpixc * 180 / M_PI;
        //       cout<<"azpixc sw....."<<azpixc<<endl;
        geod.Direct(l1cstr->latpix[pix], l1cstr->lonpix[pix], azpixc, dist_corn, lat_csw, lon_csw);
        //se corner (nw-180)
        azpixc = (azpix + thetares + thetagrad) * degrad;//pixel bearingi
        if (azpixc<-M_PI || azpixc>M_PI) { cout << "error in se corner..azpixc" << azpixc << endl;exit(1); }
        azpixc = (azpix + 45 + 90) * degrad;//pixel bearing
        azpixc = azpixc * 180 / M_PI;
        //       cout<<"azpix se...."<<azpixc<<endl;
        geod.Direct(l1cstr->latpix[pix], l1cstr->lonpix[pix], azpixc, dist_corn, lat_cse, lon_cse);
 
 
        bg::append(pixelPoly.outer(), Point_t(lon_csw, lat_csw));
        bg::append(pixelPoly.outer(), Point_t(lon_cnw, lat_cnw));
        bg::append(pixelPoly.outer(), Point_t(lon_cne, lat_cne));
        bg::append(pixelPoly.outer(), Point_t(lon_cse, lat_cse));
        bg::append(pixelPoly.outer(), Point_t(lon_csw, lat_csw));
        // make sure the polygon is defined properly
        bg::correct(pixelPoly);
 
        try {
            bintemp = bg::area(pixelPoly);
            if (bintemp <= 0)
                throw(bintemp);
        }
        catch (double binareapix) {
 
            cout << "we have an exception  calculating pixel polygon area!!!!!!!!!!" << binareapix << endl;
        }
 
        return bintemp;
 
    }
 
//OPEN L1C grid
   int32_t L1C::openL1Cgrid(int swtd,l1c_str *l1cstr,l1c_filehandle *l1cfile,L1C_input *l1cinput,int16_t* swtd_id,int16_t* file_id, int16_t* nfiles_swt,float **lat_gd, float **lon_gd,float *az_east,float **lat_asort,short **index_xy){       
        size_t ybins,xbins;
        int32_t num_gridlines, nbinx;//number of gridlines to be processed     
        std::string str;
        const char* ptstr;
        int status,ncid_az,ncid_grid,x_dimid,y_dimid,azId;   
        int32_t NY = -1, NX = -1, NY1 = -1, NY2 = -1,c1 = 1;
        char* ifile_char;
        std::string ifile_str;
        float mean_az_east;
        int16_t selyear = -1, selmon = -1, selday = -1;
        string gridname, azeast_name;
        int geoGrp;    
        float sum=0,tot=0;
        char tmp[256];  
 
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
     
     //random seed
        srand((unsigned int)time(NULL));
    
 
 
 
        num_gridlines = 4000;
        num_pixels = l1cfile->npix;
        num_scans=l1cfile->nscan;
 
    //    num_frames=l1cfile->nframes;
 
        cout<<"Opening L1C grid........................................................................."<<endl;
 
                    //allocate mem for lat/lon/azeast pointers---
        selday = l1cinput->selday;
        selmon = l1cinput->selmon;
        selyear = l1cinput->selyear;
 
        std::string fname_out, pathstr, senstr, monstr, daystr, yearstr, prodstr, gdstr, swtstr, swtnum, extstr, granstr,timestr,azstr,missionstr,ofilestr;
 
        missionstr="PACE";
        senstr = "OCIS";
        monstr = std::to_string(selmon);
        daystr = std::to_string(selday);
        yearstr = std::to_string(selyear);
        timestr="T00:00:00Z";
        prodstr = "L1Cgrid";
        swtstr = "_swt";
        extstr = ".nc";
 
        if (l1cfile->l1c_pflag >= 3) {
            swtd = l1cfile->swtnum;
            swtnum = std::to_string(swtd);
            cout << "swtnum.." << swtnum << endl;
        }
        else swtnum = std::to_string(swtd);
 
 
        getcwd(tmp, 256);
        pathstr=tmp;
 
//open lat/lon L1C grid --------------------------------------
    //PACE_OCIS.2019321T00:00:00ZL1Cgrid.nc
        ofilestr=std::string(l1cinput->ofile);
        gridname = pathstr + "/out/" +ofilestr + "_"+prodstr+extstr;        
 
        cout<<"gridname.."<<gridname<<endl;
 
    //open file
        ifile_str = l1cinput->files[0];
        ifile_char = &ifile_str[0];
        file_format format = getFormat(ifile_char);
  //      format.type=FT_HARP;
 
        if(format.type==FT_SPEXONE || format.type==FT_HARP){
            ptstr="/accounts/mamontes/images/OCIS/sean/out/PACE_OCIS.2019321T00:00:00ZL1Cgrid.nc";
            cout<<"ptstr..."<<ptstr<<endl;            
            }
        else {//legacy sensors
        ptstr = gridname.c_str();
         }
 
        status = nc_open(ptstr, NC_NOWRITE, &ncid_grid);
          if (status != NC_NOERR) {
              fprintf(stderr, "nc_open error.\n");
               exit(EXIT_FAILURE);
          }
       //groups
        status = nc_inq_grp_ncid(ncid_grid, "geolocation_data", &geoGrp);
        check_err(status, __LINE__, __FILE__);
       
        status = nc_inq_dimid(ncid_grid, "bins_along_track", &y_dimid);
            check_err(status, __LINE__, __FILE__);
        nc_inq_dimlen(ncid_grid, y_dimid, &ybins);
        status = nc_inq_dimid(ncid_grid, "bins_across_track", &x_dimid);
            check_err(status, __LINE__, __FILE__);
 
        nc_inq_dimlen(ncid_grid, x_dimid, &xbins);
        nc_inq_dimlen(ncid_grid, y_dimid, &ybins);
 
         //************************************************************
        //mem allocation for geolocation pointers---
        num_gridlines=ybins;
        nbinx=xbins;
 
        cout<<"num_gridlines"<<num_gridlines<<"nbinx"<<nbinx<<endl;
 
        status = nc_inq_varid(geoGrp, "latitude", &latId);//scans x velements
                check_err(status, __LINE__, __FILE__);
        status = nc_inq_varid(geoGrp, "longitude", &lonId);//scans x velements
                check_err(status, __LINE__, __FILE__);
        status = nc_get_var_float(geoGrp, latId, &lat_gd[0][0]);
                check_err(status, __LINE__, __FILE__);
        status = nc_get_var_float(geoGrp, lonId, &lon_gd[0][0]);
                check_err(status, __LINE__, __FILE__);
//close file
        if ((status = nc_close(ncid_grid)))
           check_err(status, __LINE__, __FILE__);
 
 
     //open az_east ------
     //PACE_OCIS.2019321T00:00:00Zaz_east.nc
        prodstr = "az_east";
//        cout << "Current working directory: " << tmp << endl;
//        azstr= pathstr + "/out/"+missionstr + "_" + senstr + "." + yearstr + monstr + daystr + timestr + prodstr+extstr;
        azstr= pathstr + "/out/"+ofilestr +"_"+ prodstr+extstr;  
 
        if(format.type==FT_SPEXONE || format.type==FT_HARP){       
            ptstr="/accounts/mamontes/images/OCIS/sean/out/PACE_OCIS.2019321T00:00:00Zaz_east.nc";
            }
        else{
        ptstr = azstr.c_str();
        }
        cout <<"Opening file with azimuth east values in degrees............" << ptstr << endl;
    //    ptstr="/accounts/mamontes/images/OCIS/sean/out/PACE_OCIS.2019321T00:00:00Zaz_east.nc";
 
        status = nc_open(ptstr, NC_NOWRITE, &ncid_az);
          if (status != NC_NOERR) {
              fprintf(stderr, "nc_open error.\n");
               exit(EXIT_FAILURE);
          } 
        status = nc_inq_dimid(ncid_az, "bins_along_track", &y_dimid);
            check_err(status, __LINE__, __FILE__);
        nc_inq_dimlen(ncid_az, y_dimid, &ybins);
 
        status = nc_inq_varid(ncid_az, "az_east", &azId);//scans x velements
                check_err(status, __LINE__, __FILE__);
        status = nc_get_var_float(ncid_az, azId, &az_east[0]);
                check_err(status, __LINE__, __FILE__);
 
        for(size_t i=0;i<ybins;i++){ 
             sum = az_east[i];
             tot += sum;
              }
//close file
        if ((status = nc_close(ncid_az)))
           check_err(status, __LINE__, __FILE__);
        
        //using swath-averaged az_east for nadir pixels rather than along-track az_east pixel-by-pixel
        mean_az_east = tot / (ybins);
 
        l1cfile->mean_az_east=mean_az_east; //in degrees
        cout<<"mean_az_east in degrees...."<<mean_az_east<<endl;
   
 
 
        //recompute number of gridlines based on lat limits -80 to 80 degrees  
       //asc orbit goes from negative to positive latitude....
        NY = num_gridlines;
        NX = nbinx;
        for (int i = 0; i < NY; i++) {
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= -80.) c1++;
                if (c1 == nbinx) {
                    NY1 = i;
                }
            }
            if (NY1 >= 0) break;
            c1 = 1;
        }
 
 
        for (int i = 0;i < NY; i++) {
            //   cout<<"i.."<<i<<"lat_gd[i][j]..."<<lat_gd[i][nadpix]<<endl;
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= 80.) {
                    NY2 = i - 1;
                }
            }
 
            if (NY2 >= 0) break;
        }
 
        // cout<<"gridlines limited to -80 to 80 degrees of latitutde.."<<"gdline ini.."<<NY1<<"gdline end.."<<NY2<<endl;
 
        l1cfile->NY1 = NY1;
        l1cfile->NY2 = NY2;
 
        cout << "NY.." << NY << "NY1.." << NY1 << "NY2.." << NY2 << endl;
 
        num_gridlines = NY2 - NY1 + 1;//this is the # gridlines after -80 to 80 lat constraint---
 
        cout<<"numgridlines after restriction lat"<<num_gridlines<<endl;
        l1cfile->num_gridlines=num_gridlines;
 
 
        //*********** SORTING LAT/LON ASCENDING AND TRACK INDEXES ****************************
        //***********************************************************************************
 
        //Create index matrix for i and j of each lat and lon L1C grid (-80 to 80)
        //num_gridlines x nbinx
 
        //define 1-D vector to sort 1 col L1C grid at the time---
        vector<pair<float, int> > vp;
 
        //fill vector with lat_gd column--
        cout << "*********** SORTING LAT/LON GRIDPOINTS AND TRACKING INDEXES ********************" << endl;
        
 
        for (int col = 0;col < nbinx;col++) {
            for (int row = NY1;row < NY2 + 1;row++) {
                vp.push_back(make_pair(lat_gd[row][col] + 90., row));
            }
            //sort 
            stable_sort(vp.begin(), vp.end());
 
            for (unsigned int i = 0; i < vp.size(); i++) {
                lat_asort[i][col] = vp[i].first;
                index_xy[i][col] = vp[i].second;
                 }
            vp.clear();
        }
       
        cout<<"ok after sorting.............................."<<endl;
   return 0;
   }
 
 
 
int32_t L1C::binL1C_sbs_line_l2(int swtd,L1C *l1c,l2_str *l2str,l1c_filehandle *l1cfile,L1C_input *l1cinput,int16_t* swtd_id,int16_t* file_id, int16_t* nfiles_swt,float **lat_gd, float **lon_gd,float *az_east,float **lat_asort,short **index_xy,float ****binmean_prod,int ****bincount,size_t sline,int granid){
 
      int32_t num_gridlines, nbinx;//number of gridlines to be processed
        std::string str,ofilestr;
        int status, ncid_out,p_dimid,v_dimid,x_dimid,y_dimid,varid1,varid2, varid_count,varid_prod,NDIMS,NDIMS3;
        int32_t bin_xpix, bin_ypix;
        int dimids[2],dimids3[4];
        const char* filename_lt;
        int32_t NY = -1, NX = -1, NY1 = -1, NY2 = -1;
        float****data_out2=nullptr,** lat_out=nullptr, ** lon_out=nullptr;
        int ****data_out=nullptr;
        int flag_inpix;//first index file id, second index line #
        bool boolbin1;
        char* ifile_char;
        std::string ifile_str;
        int16_t selyear = -1, selmon = -1, selday = -1;
        string gridname, azeast_name;
        int grp_obs,grp_coor;
        size_t  NVIEWS=-1,NL2PRODS=-1;
        int view=0;
        short gd_row, gd_col;
        std::string fname_out, pathstr, senstr, monstr, daystr, yearstr, prodstr, gdstr, swtstr, swtnum, extstr, granstr,timestr,azstr,missionstr;
        size_t  iprod;
 
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
 
     //random seed
        srand((unsigned int)time(NULL));
 
        num_gridlines = l1cfile->num_gridlines;
        nbinx = l1cfile->nbinx;
        num_pixels = l1cfile->npix;
        num_scans=l1cfile->nscan;
        num_pixels=l1cfile->npix;
 
        ifile_str = l1cinput->files[0];
        ifile_char = &ifile_str[0];
        file_format format = getFormat(ifile_char);
 
 
                    //allocate mem for lat/lon/azeast pointers---
        //determine # of gd groups to be processede
        //gdlines_group=num_gridlines;//ONE BIG GROUP
 
        //--NORMALIZED  gridline longitude is -180 to 180 degrees before comparison with longitude extracted from image pixels---
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lon_gd[i][j] < -180.)lon_gd[i][j] += 360.;
                if (lon_gd[i][j] > 180.)lon_gd[i][j] -= 360.;
            }
            }
 
//********* LOOP FILES ************************************
 
                //radiance variables
                if(format.type==FT_SPEXONE){
                   NVIEWS= 5;//should be 5 but only provided 1
                }
                else if(format.type==FT_HARP){
                   NVIEWS= 1;//HARP-2 10 but 60 for 669 nm
                }
                else{//OCIS
                   NVIEWS= l1cfile->n_views;//for OCI
                   NL2PRODS=l2str->nl2prod;                                             
                }
 
            
 
//BIG SCANLINE LOOP----------------------------------
                //********************************************************************************
                 //-----reading line by line-----------------------------------                  
 
   //*********** BIG LOOP M_PIXEL *****************************************************************
                     for (unsigned int pix = 0;pix < num_pixels;pix++) {                       
                            gd_row=0,gd_col=0;
                            flag_inpix = 0;
                            iprod=0;
 
                       //     cout<<"pix..."<<pix+1<<"latpix..."<<l1cstr->latpix[pix]<<"lonpix..."<<l1cstr->lonpix[pix]<<"sensor azimuth.."<<l1cstr->senazpix[pix]/100<<endl;
                       
                            boolbin1 = sbs2_l1c(l1cinput, num_gridlines, nbinx, lat_asort, index_xy, l2str->latpix[pix], l2str->lonpix[pix], lon_gd, &gd_row, &gd_col);
 
                            bin_ypix = gd_row + 1;
                            bin_xpix = gd_col + 1;
                   //         cout<<"boolbin1.."<<boolbin1<<"bin_ypix............................."<<bin_ypix<<"bin_xpix........................."<<bin_xpix<<endl;
 
                            if (boolbin1 == 1) flag_inpix = 1;
                            //************ BINNING ***************************
                         //assign identified pixel to Lt and bin stat arrays-----
 
        
                            if (flag_inpix == 1 && bin_xpix >= 1 && bin_ypix >= 1 && bin_xpix <= nbinx && bin_ypix <= num_gridlines && l2str->latpix[pix]>=l1cinput->binlatmin && l2str->latpix[pix]<=l1cinput->binlatmax && l2str->lonpix[pix]>=l1cinput->binlonmin && l2str->lonpix[pix]<=l1cinput->binlonmax) {
                                INPIX++;
                              if(format.type==FT_SPEXONE){
                                  view=0;
                               /*    while (sb<NBANDS) {
                                      if (l1cstr->Lt[pix][ib] > 0.) {
                                              binmean_Lt[view][ib][bin_ypix - 1][bin_xpix - 1] = binmean_Lt[view][ib][bin_ypix - 1][bin_xpix - 1] + l1cstr->Lt[pix][ib];
                                              bincount[view][ib][bin_ypix - 1][bin_xpix - 1] += 1;
                                           }
                                    ib++;
                                    sb++;
                                     }//end while intensity bands
                                  */     
                                 }
                              
                               else if(format.type==FT_HARP){
                                  view=0;
                            /*      if (l1cstr->Lt[pix][ib] > 0.) {
                                              binmean_Lt[view][ib][bin_ypix - 1][bin_xpix - 1] = binmean_Lt[view][ib][bin_ypix - 1][bin_xpix - 1] + l1cstr->Lt[pix][ib];
                                              bincount[view][ib][bin_ypix - 1][bin_xpix - 1] += 1;
                                           }
                                    ib++;
                                    sb++;*/
                                 }
                               else{ //OCIS
                                                          
                               if(l2str->tilt[sline]<=0) view=0; else view=1;
                                 while (iprod<NL2PRODS) {
                       //                  cout<<"binning OCIS L2 products........................................................................................................."<<endl;
                         //                cout<<"l2str->l2prod[iprod][pix]..."<<l2str->l2prod[iprod][pix]<<endl;
                                      if (l2str->l2prod[iprod][pix] > 0.) {
                                              cout<<"**********************************************************************************************************************************************************"<<endl;                                          
                                              cout<<"l2str->l2prod[iprod][pix]..."<<l2str->l2prod[iprod][pix]*l2str->slopeprod[iprod]+l2str->offsetprod[iprod]<<"bin_ypix.."<<bin_ypix<<"bin_xpix.."<<bin_xpix<<endl;
                                              cout<<"pix..."<<pix+1<<"latpix..."<<l2str->latpix[pix]<<"lonpix..."<<l2str->lonpix[pix]<<endl;
                                               cout<<"**********************************************************************************************************************************************************"<<endl;
 
                                              binmean_prod[view][iprod][bin_ypix - 1][bin_xpix - 1] = binmean_prod[view][iprod][bin_ypix - 1][bin_xpix - 1] + l2str->l2prod[iprod][pix]*l2str->slopeprod[iprod]+l2str->offsetprod[iprod];
                                              bincount[view][iprod][bin_ypix - 1][bin_xpix - 1] += 1;
                                           }
                                    iprod++;
                                    
                                }//end products
 
                             }
 
                            }//end if INPIX==1
 
 
 
    //********** pixel AREA WEIGHTING ************************
                            if (flag_inpix == 0) OUTPIX++;
 
                            TOTPIX++;
 
                         }//end pixels loop
 
                  
                        //END OF FILE--****** reset starting sline index if last line processed and within k box
                        //go for another granule if it is not the last one---------------
              
         //***** skip lines and files if sline is not within k group ********
              //increase k and screen files and lines again starting from the last binning
 
 
                //**********************************************************************************************************************************
                //writing each granule ---------------------------------
                //*****************************************************************************
 
                if (sline==num_scans-1) {
                    cout << "writing file #....................................................................................................................."  <<l1cfile->l1b_name<< endl;
                    //write mean Lt as nc file---
                   //**********************************************************************
                   //**********************************************************************8
                   //create Lt file
                    pathstr = "out/";
                    missionstr="PACE";
                    senstr = "OCIS_";
                    timestr="T00:00:00Z";
                     selday = l1cinput->selday;
                    selmon = l1cinput->selmon;
                    selyear = l1cinput->selyear;
                    monstr = std::to_string(selmon);
                    daystr = std::to_string(selday);
                    yearstr = std::to_string(selyear);
                    prodstr = "binL2_sbs_LINEBYLINE";
                    swtstr = "_swt";          
                    granstr = "_" + std::to_string(granid);                 
 
 
                    if (l1cfile->l1c_pflag >= 3) {
                        swtd = l1cfile->swtnum;
                        swtnum = std::to_string(swtd);
                        cout << "swtnum.." << swtnum << endl;
                    }
                    else swtnum = std::to_string(swtd);
 
                    extstr = ".nc";
                    string GATT_NAME1,GATT_VAL1,GATT_NAME2,GATT_VAL2;
 
                     if(format.type==FT_SPEXONE){
                         senstr = "SPEXONE";
                         GATT_NAME1="Title",GATT_VAL1="PACE SPEXone Level-1C Data",GATT_NAME2="instrument",GATT_VAL2="SPEXone";
                     }
                     else//OCIS
                     {
                         senstr = "OCI";
                         GATT_NAME1="Title",GATT_VAL1="PACE OCI Level-1C Data",GATT_NAME2="instrument",GATT_VAL2="OCI";
                     }
 
            //        fname_out = pathstr + missionstr + "_" + senstr + "." + yearstr + monstr + daystr + timestr + prodstr+granstr+extstr;
                    ofilestr=std::string(l1cinput->ofile);
                    fname_out = pathstr + ofilestr+"_"+ prodstr+granstr+extstr;
 
                    string  ATT_NAME="Units", ATT_VAL="degrees",GATT_NAME3="processing_version",GATT_VAL3="V1.0",GATT_NAME4="Conventions",GATT_VAL4="CF-1.6";
                    string GATT_NAME5="institution",GATT_VAL5="NASA Goddard Space Flight Center, Ocean Biology Processing Group",GATT_NAME6="license",GATT_VAL6="http://science.nasa.gov/earth-science/earth-science-data/data-information-policy/";
                    string GATT_NAME7="naming_authority",GATT_VAL7="gov.nasa.gsfc.sci.oceancolor",GATT_NAME8="keywords_vocabulary",GATT_VAL8="NASA Global Change Master Directory (GCMD) Science Keywords";
                    string GATT_NAME9="stdname_vocabulary",GATT_VAL9="NetCDF Climate and Forecast (CF) Metadata Convention",GATT_NAME10="creator_name",GATT_VAL10="NASA/GSFC",GATT_NAME11="creator_email",GATT_VAL11="data@oceancolor.gsfc.nasa.gov";
                    string GATT_NAME12="creator_url",GATT_VAL12="http://oceancolor.gsfc.nasa.gov",GATT_NAME13="project",GATT_VAL13="PACE Project",GATT_NAME14="publisher_name",GATT_VAL14="NASA/GSFC";
                    string GATT_NAME15="publisher_email",GATT_VAL15="data@oceancolor.gsfc.nasa.gov",GATT_NAME16="publisher_url",GATT_VAL16="http://oceancolor.gsfc.nasa.gov",GATT_NAME17="processing_level",GATT_VAL17="L1C";
                    string GATT_NAME18="cdm_data_type",GATT_VAL18="swath",GATT_NAME19="orbit_number",GATT_VAL19="12345",GATT_NAME20="history",GATT_VAL20="",GATT_NAME21="CDL_version_date",GATT_VAL21="2021-09-10",GATT_NAME22="product_name",GATT_VAL22=fname_out;
                    string GATT_NAME23="startDirection",GATT_VAL23="Ascending",GATT_NAME24="endDirection",GATT_VAL24="Ascending",GATT_NAME25="time_coverage_start",GATT_VAL25=yearstr+"-"+monstr+"-"+daystr+"-"+timestr,GATT_NAME26="time_coverage_end",GATT_VAL26=yearstr+"-"+monstr+"-"+daystr+"-"+timestr,GATT_NAME27="date{_created",GATT_VAL27="2021-09-10T15:12:41Z",GATT_NAME28="sun_earth_distance",GATT_VAL28="0.990849042172323",GATT_NAME29="terrain_data_source",GATT_VAL29="",GATT_NAME30="spectral_response_function",GATT_VAL30="",GATT_NAME31="systematic_uncertainty_model",GATT_VAL31="",GATT_NAME32="nadir_bin",GATT_VAL32="12345",GATT_NAME33="bin_size_at_nadir",GATT_VAL33="5.2km2",GATT_NAME34="L2_products",GATT_VAL34=l1cinput->l2prod;
 
                    l1cfile->gridname = fname_out.c_str();
                    filename_lt = fname_out.c_str();
                    cout<<"filename_lt.."<<filename_lt<<endl;
 
                    if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
                        check_err(status, __LINE__, __FILE__);
                     //define dims
                     // Define the dimensions,vars and attributes at the root level
                    NDIMS=2;                 
                    NDIMS3=4;
                    NY = num_gridlines;
                    NX = nbinx;
                    //NVIEWS= 2;//for OCI
                   // NBANDS=249;//for OCI
 
                    NY1 = l1cfile->NY1;//these are indexes not line #!!!!!!!!!!!!!!!!!
                    NY2 = l1cfile->NY2;
                    cout << "rowgrid ini.." << NY1 << "rowgrid end.." << NY2 << endl;
                    NY = NY2 - NY1 + 1;
                    cout << "NY.." << NY << "NX.." << NX << "NY1.."<<NY1<<"NY2.."<<NY2<<endl;
 
  //DEF DIMENSIONS
                    if ((status = nc_def_dim(ncid_out, "bins_across_track", NX, &x_dimid)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_dim(ncid_out, "bins_along_track", NY, &y_dimid)))
                           check_err(status, __LINE__, __FILE__);
                    //dims for output var
                    dimids[0] = y_dimid;
                    dimids[1] = x_dimid;
 
                    if ((status = nc_def_dim(ncid_out, "number_of_views", NVIEWS, &v_dimid)))
                       check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_dim(ncid_out, "l2_products", NL2PRODS, &p_dimid)))
                      check_err(status, __LINE__, __FILE__);
 
                    dimids3[0] = y_dimid;
                    dimids3[1] = x_dimid;
                    dimids3[2] = v_dimid;//
                    dimids3[3] = p_dimid;
 
                    //define attributes
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME1.c_str(), strlen(GATT_VAL1.c_str()),
                        GATT_VAL1.c_str()))
                       check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME2.c_str(), strlen(GATT_VAL2.c_str()),
                         GATT_VAL2.c_str()))
                       check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME3.c_str(), strlen(GATT_VAL3.c_str()),
                         GATT_VAL3.c_str()))
                          check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME4.c_str(), strlen(GATT_VAL4.c_str()),
                            GATT_VAL4.c_str()))
                           check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME5.c_str(), strlen(GATT_VAL5.c_str()),
                         GATT_VAL5.c_str()))
                          check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME6.c_str(), strlen(GATT_VAL6.c_str()),
                          GATT_VAL6.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME7.c_str(), strlen(GATT_VAL7.c_str()),
                          GATT_VAL7.c_str()))
                           check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME8.c_str(), strlen(GATT_VAL8.c_str()),
                          GATT_VAL8.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME9.c_str(), strlen(GATT_VAL9.c_str()),
                          GATT_VAL9.c_str()))
                         check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME10.c_str(), strlen(GATT_VAL10.c_str()),
                          GATT_VAL10.c_str()))
                          check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME11.c_str(), strlen(GATT_VAL11.c_str()),
                           GATT_VAL11.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME12.c_str(), strlen(GATT_VAL12.c_str()),
                            GATT_VAL12.c_str()))
                           check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME13.c_str(), strlen(GATT_VAL13.c_str()),
                             GATT_VAL13.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME14.c_str(), strlen(GATT_VAL14.c_str()),
                             GATT_VAL14.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME15.c_str(), strlen(GATT_VAL15.c_str()),
                                 GATT_VAL15.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME16.c_str(), strlen(GATT_VAL16.c_str()),
                             GATT_VAL16.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME17.c_str(), strlen(GATT_VAL17.c_str()),
                             GATT_VAL17.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME18.c_str(), strlen(GATT_VAL18.c_str()),
                             GATT_VAL18.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME19.c_str(), strlen(GATT_VAL19.c_str()),
                             GATT_VAL19.c_str()))
                          check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME20.c_str(), strlen(GATT_VAL20.c_str()),
                             GATT_VAL20.c_str()))
                              check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME21.c_str(), strlen(GATT_VAL21.c_str()),
                             GATT_VAL21.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME22.c_str(), strlen(GATT_VAL22.c_str()),
                             GATT_VAL22.c_str()))
                           check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME23.c_str(), strlen(GATT_VAL23.c_str()),
                              GATT_VAL23.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME24.c_str(), strlen(GATT_VAL24.c_str()),
                              GATT_VAL24.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME25.c_str(), strlen(GATT_VAL25.c_str()),
                           GATT_VAL25.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME26.c_str(), strlen(GATT_VAL26.c_str()),
                           GATT_VAL26.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME27.c_str(), strlen(GATT_VAL27.c_str()),
                             GATT_VAL27.c_str()))
                              check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME28.c_str(), strlen(GATT_VAL28.c_str()),
                             GATT_VAL28.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME29.c_str(), strlen(GATT_VAL29.c_str()),
                             GATT_VAL29.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME30.c_str(), strlen(GATT_VAL30.c_str()),
                             GATT_VAL30.c_str()))
                              check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME31.c_str(), strlen(GATT_VAL31.c_str()),
                             GATT_VAL31.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME32.c_str(), strlen(GATT_VAL32.c_str()),
                              GATT_VAL32.c_str()))
                                check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME33.c_str(), strlen(GATT_VAL33.c_str()),
                                GATT_VAL33.c_str()))
                                check_err(status, __LINE__, __FILE__);
                     if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME34.c_str(), strlen(GATT_VAL34.c_str()),
                                GATT_VAL34.c_str()))
                                check_err(status, __LINE__, __FILE__);
 
                    //define groups                  check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_grp(ncid_out, "geolocation_data", &grp_coor)))  //netcdf-4
                         check_err(status, __LINE__, __FILE__);
                     //def var grp1
                    if ((status = nc_def_var(grp_coor, "latitude", NC_FLOAT, NDIMS,
                         dimids, &varid1)))
                          check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_var(grp_coor, "longitude", NC_FLOAT, NDIMS,
                            dimids, &varid2)))
                          check_err(status, __LINE__, __FILE__);
 
                    //leave define mode-----------------------
                    if ((status = nc_enddef(grp_coor))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
 
 
                    if ((status = nc_def_grp(ncid_out, "observation_data", &grp_obs)))  //netcdf-4
                        check_err(status, __LINE__, __FILE__);
                    //def var grp2
                        //counts and Lt
                    if ((status = nc_def_var(grp_obs, "obs_per_view", NC_INT, NDIMS3,
                        dimids3, &varid_count)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_var(grp_obs, "l2_product", NC_FLOAT, NDIMS3,
                        dimids3, &varid_prod)))
                        check_err(status, __LINE__, __FILE__);
 
                    //leave define mode-----------------------
                    if ((status = nc_enddef(grp_obs))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
 
 
                    lat_out = allocate2d_float(NY, NX);
                    lon_out = allocate2d_float(NY, NX);
 
                    int c = 0;
 
                    for (int i = NY1; i < NY2 + 1; i++) {
                        for (int j = 0; j < NX; j++) {
                            lat_out[NY - 1 - c][NX - 1 - j] = lat_gd[i][j];
                            lon_out[NY - 1 - c][j] = lon_gd[i][j];
                        }
                        c++;
                    }
 
                    if ((status = nc_put_var_float(grp_coor, varid1, &lat_out[0][0])))
                        check_err(status, __LINE__, __FILE__);
 
                    if ((status = nc_put_var_float(grp_coor, varid2, &lon_out[0][0])))
                        check_err(status, __LINE__, __FILE__);
 
 
           //alloc mem for output variables obs_per_view and I as part of the observation_data group
                    data_out = allocate4d_int(NY, NX,NVIEWS,NL2PRODS);
                    data_out2 = allocate4d_float(NY, NX,NVIEWS,NL2PRODS);
 
            //BINCOUNT ARRAY
 
                   c = 0;
                   for (size_t v = 0; v < NVIEWS; v++) {
                      for (size_t p = 0;p <NL2PRODS;p++) {
                        for (int i = NY1; i < NY2 + 1; i++) {
                            for (int j = 0; j < NX; j++) {                          
                                    if(bincount[v][p][i][j]>0)
                                         data_out[NY - 1 - c][NX - 1 - j][v][p]+=bincount[v][p][i][j];
                                    else
                                         data_out[NY - 1 - c][NX - 1 - j][v][p]+=0;
                                }
                            }
                            c++;
                        }
                        c=0;
                      }
 
 
                        cout << "writing countbin for all L2 products ."<< endl;
                       if ((status = nc_put_var_int(grp_obs, varid_count, &data_out[0][0][0][0])))
                            check_err(status, __LINE__, __FILE__);
 
            // l2 products ARRAYS
                    c=0;
                    for (size_t v = 0;v <NVIEWS;v++) {
                      for (size_t p = 0; p <NL2PRODS; p++) {
                        for (int i = NY1; i < NY2 + 1; i++) {
                             for (int j = 0; j < NX; j++) {
                                if (bincount[v][p][i][j] > 0)
                                    data_out2[NY - 1 - c][NX - 1 - j][v][p] = binmean_prod[v][p][i][j] / bincount[v][p][i][j];
                                else         data_out2[NY - 1 - c][NX - 1 - j][v][p] = NAN;
                            }
                            c++;
                        }
                        c=0;
                       }//end views
                     }//end for bands
 
                         cout << "writing L2 products .."<< endl;
                        if ((status = nc_put_var_float(grp_obs, varid_prod, &data_out2[0][0][0][0])))
                            check_err(status, __LINE__, __FILE__);
 
                    delete [] (data_out);
                    delete [] (data_out2);
                    delete[](lat_out);
                    delete[](lon_out);
 
                    if ((status = nc_close(ncid_out)))
                        check_err(status, __LINE__, __FILE__);
 
                    lat_out = nullptr;;
                    lon_out = nullptr;
                    data_out = nullptr;
                    data_out2 = nullptr;
 
                    cout << "number of files per swath.." << nfiles_swt[swtd - 1] << "for swath.." << swtd << endl;
                    cout << "total inpix.." << INPIX << "total pix.." << TOTPIX << endl;
                    printf("*** SUCCESS writing bincount and binLt rasters as nc..!\n");
                    cout<<"LINE-BY-LINE sbs binning method....."<<endl;
                }//end writing file
 
 
return 0;    
}
 
 
 
int32_t L1C::binL1C_sbs_line(int swtd,L1C *l1c,l1c_str *l1cstr,l1c_filehandle *l1cfile,L1C_input *l1cinput,int16_t* swtd_id,int16_t* file_id, int16_t* nfiles_swt,float **lat_gd, float **lon_gd,float *az_east,float **lat_asort,short **index_xy,float ****binmean_Lt,int ****bincount,size_t sline,int granid){ 
 
        int32_t num_gridlines, nbinx;//number of gridlines to be processed
        std::string str,ofilestr;
        int status, ncid_out,b_dimid,v_dimid,x_dimid,y_dimid,varid1,varid2, varid_count,varid_lt,NDIMS,NDIMS2,NDIMS3;
        int32_t bin_xpix, bin_ypix;
        int dimids[2],dimids2[3],dimids3[4];
        const char* filename_lt;
        int32_t NY = -1, NX = -1, NY1 = -1, NY2 = -1;
        float****data_out2=nullptr,** lat_out=nullptr, ** lon_out=nullptr;
        int ***data_out=nullptr;
        int flag_inpix;//first index file id, second index line #
        bool boolbin1;
        char* ifile_char;
        std::string ifile_str;
        int16_t selyear = -1, selmon = -1, selday = -1;
        string gridname, azeast_name;
        int grp_obs,grp_coor;
        size_t  sb=0,bb = 0, rb = 0, swb = 0,ib=0, NVIEWS=-1,NBANDS=-1,NBANDS_POL=-1;
        int view=0;
        short gd_row, gd_col;
        std::string fname_out, pathstr, senstr, monstr, daystr, yearstr, prodstr, gdstr, swtstr, swtnum, extstr, granstr,timestr,azstr,missionstr;
 
 
 
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
 
     //random seed
        srand((unsigned int)time(NULL));
        //nadir pixel ofr OCI        
        int nadpix = l1cfile->nadpix;        
  //      cout<<"nadpix index......"<<nadpix<<endl;
 
        num_gridlines = l1cfile->num_gridlines;
        nbinx = l1cfile->nbinx;
        num_pixels = l1cfile->npix;
        num_scans=l1cfile->nscan;
        num_pixels=l1cfile->npix;
 
        ifile_str = l1cinput->files[0];
        ifile_char = &ifile_str[0];
        file_format format = getFormat(ifile_char);
    //    num_frames=l1cfile->nframes;
 
 
//        cout<<"binning Lt using sbs2 method and composite indexes for arrays..................................................................."<<endl;
 
                    //allocate mem for lat/lon/azeast pointers---
        //determine # of gd groups to be processede
        //gdlines_group=num_gridlines;//ONE BIG GROUP
 
        //--NORMALIZED  gridline longitude is -180 to 180 degrees before comparison with longitude extracted from image pixels---
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lon_gd[i][j] < -180.)lon_gd[i][j] += 360.;
                if (lon_gd[i][j] > 180.)lon_gd[i][j] -= 360.;
            }
            }
 
//********* LOOP FILES ************************************
 
                //radiance variables
                if(format.type==FT_SPEXONE){
                   NVIEWS= 1;//should be 5 but only provided 1
                   NBANDS=400;
                   NBANDS_POL=50;
                   cout << "#total number of Intensity bands per view.." << NBANDS << endl;
                   cout << "#total number of Polarization bands per view.." << NBANDS_POL << endl;
                }
                else if(format.type==FT_HARP){
                   NVIEWS= 1;//HARP-2 10 but 60 for 669 nm
                   NBANDS=1;//
                   NBANDS_POL=1;
                   cout << "#total number of Intensity bands per view.." << NBANDS << endl;
                   cout << "#total number of Polarization bands per view.." << NBANDS_POL << endl;
                }
                else{//OCIS
                   NVIEWS= l1cfile->n_views;//for OCI
                   NBANDS=l1cfile->nbands;//for OCI
                   num_blue_bands=l1cfile->nband_blue;
                   num_red_bands=l1cfile->nband_red;
                   num_SWIR_bands=l1cfile->nband_swir;
                }
 
//BIG SCANLINE LOOP----------------------------------
                //********************************************************************************
                 //-----reading line by line-----------------------------------                  
 
   //*********** BIG LOOP M_PIXEL *****************************************************************
                     for (unsigned int pix = 0;pix < num_pixels;pix++) {
                            sb=0,bb=0,rb=0,swb=0,ib=0;
                            gd_row=0,gd_col=0;
                            flag_inpix = 0;
 
                       //     cout<<"pix..."<<pix+1<<"latpix..."<<l1cstr->latpix[pix]<<"lonpix..."<<l1cstr->lonpix[pix]<<"sensor azimuth.."<<l1cstr->senazpix[pix]/100<<endl;
                       
                            boolbin1 = sbs2_l1c(l1cinput, num_gridlines, nbinx, lat_asort, index_xy, l1cstr->latpix[pix], l1cstr->lonpix[pix], lon_gd, &gd_row, &gd_col);
 
                            bin_ypix = gd_row + 1;
                            bin_xpix = gd_col + 1;
               //             cout<<"boolbin1.."<<boolbin1<<"bin_ypix.."<<bin_ypix<<"bin_xpix.."<<bin_xpix<<endl;
 
                            if (boolbin1 == 1) flag_inpix = 1;
                            //************ BINNING ***************************
                         //assign identified pixel to Lt and bin stat arrays-----
 
        
                            if (flag_inpix == 1 && bin_xpix >= 1 && bin_ypix >= 1 && bin_xpix <= nbinx && bin_ypix <= num_gridlines && l1cstr->latpix[pix]>=l1cinput->binlatmin && l1cstr->latpix[pix]<=l1cinput->binlatmax && l1cstr->lonpix[pix]>=l1cinput->binlonmin && l1cstr->lonpix[pix]<=l1cinput->binlonmax) {
                                INPIX++;
                              if(format.type==FT_SPEXONE){
                                  view=0;
                                   while (sb<NBANDS) {
                                      if (l1cstr->Lt[pix][ib] > 0.) {
                                              binmean_Lt[view][ib][bin_ypix - 1][bin_xpix - 1] = binmean_Lt[view][ib][bin_ypix - 1][bin_xpix - 1] + l1cstr->Lt[pix][ib];
                                              bincount[view][ib][bin_ypix - 1][bin_xpix - 1] += 1;
                                           }
                                    ib++;
                                    sb++;
                                     }//end while intensity bands
 
 
 
/*                                    while (sb<num_blue_bands) {
                                      if (Lt_pix2[bb][pix] > 0.) {
                                              binmean_Lt[view][sb][bin_ypix - 1][bin_xpix - 1] = binmean_Lt[view][sb][bin_ypix - 1][bin_xpix - 1] + Lt_pix2[bb][pix];
                                              bincount[view][sb][bin_ypix - 1][bin_xpix - 1] += 1;
                                           }
                                    bb++;
                                    sb++;
                                }//end while polarization bands
*/
 
                                 }
                              
                               else if(format.type==FT_HARP){
                                  view=0,sb=0;
                                  if (l1cstr->Lt[pix][ib] > 0.) {
                                              binmean_Lt[view][ib][bin_ypix - 1][bin_xpix - 1] = binmean_Lt[view][ib][bin_ypix - 1][bin_xpix - 1] + l1cstr->Lt[pix][ib];
                                              bincount[view][ib][bin_ypix - 1][bin_xpix - 1] += 1;
                                           }
                                    ib++;
                                    sb++;
                                 }
                               else{ //OCIS
          //BLUE---                                                 
                               if(l1cstr->senazpix[nadpix]/100<0) view=0; else view=1;
                                while (sb<num_blue_bands) {
                                      if (l1cstr->Lt_blue[bb][pix] > 0.) {
                         //                     cout<<"Lt_pix[pix][ib]..."<<l1cstr->Lt_blue[bb][pix]<<"bin_ypix.."<<bin_ypix<<"bin_xpix.."<<bin_xpix<<endl;
                         //                     cout<<"pix..."<<pix+1<<"latpix..."<<l1cstr->latpix[pix]<<"lonpix..."<<l1cstr->lonpix[pix]<<"sensor azimuth pixel.."<<l1cstr->senazpix[pix]/100<<endl;
 
                                              binmean_Lt[view][sb][bin_ypix - 1][bin_xpix - 1] = binmean_Lt[view][sb][bin_ypix - 1][bin_xpix - 1] + l1cstr->Lt_blue[bb][pix];
                                              bincount[view][sb][bin_ypix - 1][bin_xpix - 1] += 1;
                                           }
                                    bb++;
                                    sb++;
                                }//end while blue band band
 
        //RED---
                                while (sb <num_blue_bands+num_red_bands) {
                                    if (l1cstr->Lt_red[rb][pix] > 0.) {
                                        binmean_Lt[view][sb][bin_ypix - 1][bin_xpix - 1] = binmean_Lt[view][sb][bin_ypix - 1][bin_xpix - 1] + l1cstr->Lt_red[rb][pix];
                                        bincount[view][sb][bin_ypix - 1][bin_xpix - 1] += 1;
                                    }
                                    rb++;
                                    sb++;
                                }//end red bands
 
       //SWIR----
                                while (sb <num_blue_bands + num_red_bands + num_SWIR_bands) {
                                    if (l1cstr->Lt_SWIR[swb][pix] > 0.) {
                                        binmean_Lt[view][sb][bin_ypix - 1][bin_xpix - 1] = binmean_Lt[view][sb][bin_ypix - 1][bin_xpix - 1] + l1cstr->Lt_SWIR[swb][pix];
                                        bincount[view][sb][bin_ypix - 1][bin_xpix - 1] += 1;
                                    }
                                    swb++;
                                    sb++;
                                }//end swir bands
                             }
 
                            }//end if INPIX==1
 
 
 
    //********** pixel AREA WEIGHTING ************************
                            if (flag_inpix == 0) OUTPIX++;
 
                            TOTPIX++;
 
                         }//end pixels loop
 
                  
                        //END OF FILE--****** reset starting sline index if last line processed and within k box
                        //go for another granule if it is not the last one---------------
              
         //***** skip lines and files if sline is not within k group ********
              //increase k and screen files and lines again starting from the last binning
 
 
                //**********************************************************************************************************************************
                //writing each granule ---------------------------------
                //*****************************************************************************
 
                if (sline==num_scans-1) {
                    cout << "writing file #....................................................................................................................."  <<l1cfile->l1b_name<< endl;
                    //write mean Lt as nc file---
                   //**********************************************************************
                   //**********************************************************************8
                   //create Lt file
                    pathstr = "out/";
                    missionstr="PACE";
                    senstr = "OCIS_";
                    timestr="T00:00:00Z";
                     selday = l1cinput->selday;
                    selmon = l1cinput->selmon;
                    selyear = l1cinput->selyear;
                    monstr = std::to_string(selmon);
                    daystr = std::to_string(selday);
                    yearstr = std::to_string(selyear);
                    prodstr = "binLt_sbs_LINEBYLINE";
                    swtstr = "_swt";          
                    granstr = "_" + std::to_string(granid);                 
 
 
                    if (l1cfile->l1c_pflag >= 3) {
                        swtd = l1cfile->swtnum;
                        swtnum = std::to_string(swtd);
                        cout << "swtnum.." << swtnum << endl;
                    }
                    else swtnum = std::to_string(swtd);
 
                    extstr = ".nc";
                    string GATT_NAME1,GATT_VAL1,GATT_NAME2,GATT_VAL2;
 
                     if(format.type==FT_SPEXONE){
                         senstr = "SPEXONE";
                         GATT_NAME1="Title",GATT_VAL1="PACE SPEXone Level-1C Data",GATT_NAME2="instrument",GATT_VAL2="SPEXone";
                     }
                     else//OCIS
                     {
                         senstr = "OCI";
                         GATT_NAME1="Title",GATT_VAL1="PACE OCI Level-1C Data",GATT_NAME2="instrument",GATT_VAL2="OCI";
                     }
 
            //        fname_out = pathstr + missionstr + "_" + senstr + "." + yearstr + monstr + daystr + timestr + prodstr+granstr+extstr;
                    ofilestr=std::string(l1cinput->ofile);
                    fname_out = pathstr + ofilestr+"_"+ prodstr+granstr+extstr;
 
                    string  ATT_NAME="Units", ATT_VAL="degrees",GATT_NAME3="processing_version",GATT_VAL3="V1.0",GATT_NAME4="Conventions",GATT_VAL4="CF-1.6";
                    string GATT_NAME5="institution",GATT_VAL5="NASA Goddard Space Flight Center, Ocean Biology Processing Group",GATT_NAME6="license",GATT_VAL6="http://science.nasa.gov/earth-science/earth-science-data/data-information-policy/";
                    string GATT_NAME7="naming_authority",GATT_VAL7="gov.nasa.gsfc.sci.oceancolor",GATT_NAME8="keywords_vocabulary",GATT_VAL8="NASA Global Change Master Directory (GCMD) Science Keywords";
                    string GATT_NAME9="stdname_vocabulary",GATT_VAL9="NetCDF Climate and Forecast (CF) Metadata Convention",GATT_NAME10="creator_name",GATT_VAL10="NASA/GSFC",GATT_NAME11="creator_email",GATT_VAL11="data@oceancolor.gsfc.nasa.gov";
                    string GATT_NAME12="creator_url",GATT_VAL12="http://oceancolor.gsfc.nasa.gov",GATT_NAME13="project",GATT_VAL13="PACE Project",GATT_NAME14="publisher_name",GATT_VAL14="NASA/GSFC";
                    string GATT_NAME15="publisher_email",GATT_VAL15="data@oceancolor.gsfc.nasa.gov",GATT_NAME16="publisher_url",GATT_VAL16="http://oceancolor.gsfc.nasa.gov",GATT_NAME17="processing_level",GATT_VAL17="L1C";
                    string GATT_NAME18="cdm_data_type",GATT_VAL18="swath",GATT_NAME19="orbit_number",GATT_VAL19="12345",GATT_NAME20="history",GATT_VAL20="",GATT_NAME21="CDL_version_date",GATT_VAL21="2021-09-10",GATT_NAME22="product_name",GATT_VAL22=fname_out;
                    string GATT_NAME23="startDirection",GATT_VAL23="Ascending",GATT_NAME24="endDirection",GATT_VAL24="Ascending",GATT_NAME25="time_coverage_start",GATT_VAL25=yearstr+"-"+monstr+"-"+daystr+"-"+timestr,GATT_NAME26="time_coverage_end",GATT_VAL26=yearstr+"-"+monstr+"-"+daystr+"-"+timestr,GATT_NAME27="date{_created",GATT_VAL27="2021-09-10T15:12:41Z",GATT_NAME28="sun_earth_distance",GATT_VAL28="0.990849042172323",GATT_NAME29="terrain_data_source",GATT_VAL29="",GATT_NAME30="spectral_response_function",GATT_VAL30="",GATT_NAME31="systematic_uncertainty_model",GATT_VAL31="",GATT_NAME32="nadir_bin",GATT_VAL32="12345",GATT_NAME33="bin_size_at_nadir",GATT_VAL33="5.2km2";
 
                    l1cfile->gridname = fname_out.c_str();
                    filename_lt = fname_out.c_str();
                    cout<<"filename_lt.."<<filename_lt<<endl;
 
                    if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
                        check_err(status, __LINE__, __FILE__);
                     //define dims
                     // Define the dimensions,vars and attributes at the root level
                    NDIMS=2;
                    NDIMS2=3;
                    NDIMS3=4;
                    NY = num_gridlines;
                    NX = nbinx;
                    //NVIEWS= 2;//for OCI
                   // NBANDS=249;//for OCI
 
                    NY1 = l1cfile->NY1;//these are indexes not line #!!!!!!!!!!!!!!!!!
                    NY2 = l1cfile->NY2;
                    cout << "rowgrid ini.." << NY1 << "rowgrid end.." << NY2 << endl;
                    NY = NY2 - NY1 + 1;
                    cout << "NY.." << NY << "NX.." << NX << "NY1.."<<NY1<<"NY2.."<<NY2<<endl;
 
  //DEF DIMENSIONS
                    if ((status = nc_def_dim(ncid_out, "bins_across_track", NX, &x_dimid)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_dim(ncid_out, "bins_along_track", NY, &y_dimid)))
                           check_err(status, __LINE__, __FILE__);
                    //dims for output var
                    dimids[0] = y_dimid;
                    dimids[1] = x_dimid;
 
                    if ((status = nc_def_dim(ncid_out, "number_of_views", NVIEWS, &v_dimid)))
                       check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_dim(ncid_out, "intensity_bands_per_view", NBANDS, &b_dimid)))
                      check_err(status, __LINE__, __FILE__);
 
                    dimids2[0] = y_dimid;
                    dimids2[1] = x_dimid;
                    dimids2[2] = v_dimid;//#o
 
                    dimids3[0] = y_dimid;
                    dimids3[1] = x_dimid;
                    dimids3[2] = v_dimid;//
                    dimids3[3] = b_dimid;
 
                    //define attributes
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME1.c_str(), strlen(GATT_VAL1.c_str()),
                        GATT_VAL1.c_str()))
                       check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME2.c_str(), strlen(GATT_VAL2.c_str()),
                         GATT_VAL2.c_str()))
                       check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME3.c_str(), strlen(GATT_VAL3.c_str()),
                         GATT_VAL3.c_str()))
                          check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME4.c_str(), strlen(GATT_VAL4.c_str()),
                            GATT_VAL4.c_str()))
                           check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME5.c_str(), strlen(GATT_VAL5.c_str()),
                         GATT_VAL5.c_str()))
                          check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME6.c_str(), strlen(GATT_VAL6.c_str()),
                          GATT_VAL6.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME7.c_str(), strlen(GATT_VAL7.c_str()),
                          GATT_VAL7.c_str()))
                           check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME8.c_str(), strlen(GATT_VAL8.c_str()),
                          GATT_VAL8.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME9.c_str(), strlen(GATT_VAL9.c_str()),
                          GATT_VAL9.c_str()))
                         check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME10.c_str(), strlen(GATT_VAL10.c_str()),
                          GATT_VAL10.c_str()))
                          check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME11.c_str(), strlen(GATT_VAL11.c_str()),
                           GATT_VAL11.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME12.c_str(), strlen(GATT_VAL12.c_str()),
                            GATT_VAL12.c_str()))
                           check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME13.c_str(), strlen(GATT_VAL13.c_str()),
                             GATT_VAL13.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME14.c_str(), strlen(GATT_VAL14.c_str()),
                             GATT_VAL14.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME15.c_str(), strlen(GATT_VAL15.c_str()),
                                 GATT_VAL15.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME16.c_str(), strlen(GATT_VAL16.c_str()),
                             GATT_VAL16.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME17.c_str(), strlen(GATT_VAL17.c_str()),
                             GATT_VAL17.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME18.c_str(), strlen(GATT_VAL18.c_str()),
                             GATT_VAL18.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME19.c_str(), strlen(GATT_VAL19.c_str()),
                             GATT_VAL19.c_str()))
                          check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME20.c_str(), strlen(GATT_VAL20.c_str()),
                             GATT_VAL20.c_str()))
                              check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME21.c_str(), strlen(GATT_VAL21.c_str()),
                             GATT_VAL21.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME22.c_str(), strlen(GATT_VAL22.c_str()),
                             GATT_VAL22.c_str()))
                           check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME23.c_str(), strlen(GATT_VAL23.c_str()),
                              GATT_VAL23.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME24.c_str(), strlen(GATT_VAL24.c_str()),
                              GATT_VAL24.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME25.c_str(), strlen(GATT_VAL25.c_str()),
                           GATT_VAL25.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME26.c_str(), strlen(GATT_VAL26.c_str()),
                           GATT_VAL26.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME27.c_str(), strlen(GATT_VAL27.c_str()),
                             GATT_VAL27.c_str()))
                              check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME28.c_str(), strlen(GATT_VAL28.c_str()),
                             GATT_VAL28.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME29.c_str(), strlen(GATT_VAL29.c_str()),
                             GATT_VAL29.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME30.c_str(), strlen(GATT_VAL30.c_str()),
                             GATT_VAL30.c_str()))
                              check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME31.c_str(), strlen(GATT_VAL31.c_str()),
                             GATT_VAL31.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME32.c_str(), strlen(GATT_VAL32.c_str()),
                              GATT_VAL32.c_str()))
                                check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME33.c_str(), strlen(GATT_VAL33.c_str()),
                                GATT_VAL33.c_str()))
                                check_err(status, __LINE__, __FILE__);
 
                    //define groups                  check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_grp(ncid_out, "geolocation_data", &grp_coor)))  //netcdf-4
                         check_err(status, __LINE__, __FILE__);
                     //def var grp1
                    if ((status = nc_def_var(grp_coor, "latitude", NC_FLOAT, NDIMS,
                         dimids, &varid1)))
                          check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_var(grp_coor, "longitude", NC_FLOAT, NDIMS,
                            dimids, &varid2)))
                          check_err(status, __LINE__, __FILE__);
 
                    //leave define mode-----------------------
                    if ((status = nc_enddef(grp_coor))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
 
 
                    if ((status = nc_def_grp(ncid_out, "observation_data", &grp_obs)))  //netcdf-4
                        check_err(status, __LINE__, __FILE__);
                    //def var grp2
                        //counts and Lt
                    if ((status = nc_def_var(grp_obs, "obs_per_view", NC_INT, NDIMS2,
                        dimids2, &varid_count)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_var(grp_obs, "I", NC_FLOAT, NDIMS3,
                        dimids3, &varid_lt)))
                        check_err(status, __LINE__, __FILE__);
 
                    //leave define mode-----------------------
                    if ((status = nc_enddef(grp_obs))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
 
 
                    lat_out = allocate2d_float(NY, NX);
                    lon_out = allocate2d_float(NY, NX);
 
                    int c = 0;
 
                    for (int i = NY1; i < NY2 + 1; i++) {
                        for (int j = 0; j < NX; j++) {
                            lat_out[NY - 1 - c][NX - 1 - j] = lat_gd[i][j];
                            lon_out[NY - 1 - c][j] = lon_gd[i][j];
                        }
                        c++;
                    }
 
 
                    if ((status = nc_put_var_float(grp_coor, varid1, &lat_out[0][0])))
                        check_err(status, __LINE__, __FILE__);
 
                    if ((status = nc_put_var_float(grp_coor, varid2, &lon_out[0][0])))
                        check_err(status, __LINE__, __FILE__);
 
 
           //alloc mem for output variables obs_per_view and I as part of the observation_data group
                    data_out = allocate3d_int(NY, NX,NVIEWS);
                    data_out2 = allocate4d_float(NY, NX,NVIEWS,NBANDS);
 
            //BINCOUNT ARRAY
               for (size_t v = 0; v < NVIEWS; v++) {
                        for (int i = NY1; i < NY2 + 1; i++) {
                            for (int j = 0; j < NX; j++) {
                                 data_out[i][j][v]=0;
                            }}}
 
 
 
                   c = 0;
                   for (size_t v = 0; v < NVIEWS; v++) {
                        for (int i = NY1; i < NY2 + 1; i++) {
                            for (int j = 0; j < NX; j++) {
                                for (sb = 0;sb < NBANDS;sb++) {
                                    if(bincount[v][sb][i][j]>0)
                                         data_out[NY - 1 - c][NX - 1 - j][v]+=bincount[v][sb][i][j];
                                    else
                                         data_out[NY - 1 - c][NX - 1 - j][v]+=0;
                                }
                            }
                            c++;
                        }
                        c=0;
                      }
 
 
 
                        cout << "writing countbin for all band ."<< endl;
                       if ((status = nc_put_var_int(grp_obs, varid_count, &data_out[0][0][0])))
                            check_err(status, __LINE__, __FILE__);
 
            // LT ARRAYS
                    c=0;
                    for (size_t b = 0;b <NBANDS;b++) {
                      for (size_t v = 0; v < NVIEWS; v++) {
                        for (int i = NY1; i < NY2 + 1; i++) {
                             for (int j = 0; j < NX; j++) {
                                if (bincount[v][b][i][j] > 0)
                                    data_out2[NY - 1 - c][NX - 1 - j][v][b] = binmean_Lt[v][b][i][j] / bincount[v][b][i][j];
                                else         data_out2[NY - 1 - c][NX - 1 - j][v][b] = NAN;
                            }
                            c++;
                        }
                        c=0;
                       }//end views
                     }//end for bands
 
                         cout << "writing Lt for all bands.."<< endl;
                        if ((status = nc_put_var_float(grp_obs, varid_lt, &data_out2[0][0][0][0])))
                            check_err(status, __LINE__, __FILE__);
 
                    delete [] (data_out);
                    delete [] (data_out2);
                    delete[](lat_out);
                    delete[](lon_out);
 
                    if ((status = nc_close(ncid_out)))
                        check_err(status, __LINE__, __FILE__);
 
                    lat_out = nullptr;;
                    lon_out = nullptr;
                    data_out = nullptr;
                    data_out2 = nullptr;
 
                    cout << "number of files per swath.." << nfiles_swt[swtd - 1] << "for swath.." << swtd << endl;
                    cout << "total inpix.." << INPIX << "total pix.." << TOTPIX << endl;
                    printf("*** SUCCESS writing bincount and binLt rasters as nc..!\n");
                    cout<<"LINE-BY-LINE sbs binning method....."<<endl;
                }//end writing file
 
 
    cout<<"number of binned pixels..."<<INPIX<<endl;            
    return 0;
      }
                    
    int32_t L1C::binL1C_wgranule_aw2(int swtd, l1c_filehandle* l1cfile, L1C_input* l1cinput, l1c_str* l1cstr, float** lat_gd, float** lon_gd, float* az_east, float** Ltfracsum, float** areabinsum, float** nobs_perbin, size_t sline) {
        size_t num_scans;
        int32_t num_gridlines, nbinx, n_files, inpix = 0, outpix = 0, totpix = 0;
        float minv = 0., maxv = 0.; 
        int16_t fi = 0;
        string str, pathstr, senstr, monstr, daystr, yearstr, prodstr, swtstr, granstr, swtnum, extstr, fname_out;
        int status, ncid_out, x_dimid, y_dimid, varid, varid2, varid3,NDIMS;
        float Re = 6378;
        float latmin_swt = 100, latmax_swt = 0, lonmin_swt = 0, lonmax_swt = 0;
        int dimids[2];
        const char* filename_lt;
        int32_t NY = -1, NX = -1, NY1 = -1, NY2 = -1, c1 = 1;
        float** lat_out, ** lon_out;
        float aterm = 0.;
        short** index_xy;
        float** lat_asort;
        bool boolbin1;
        int num_pixels;
        int16_t selyear = -1, selmon = -1, selday = -1;
        string gridname, azeast_name;
        float azpix, azpixc;
        double** latcornBox = nullptr, ** loncornBox = nullptr;
        float deltaphi, deltalam, bterm, dist_u, dist_v;
        double lat_cnw, lat_cne, lat_csw, lat_cse, lon_cnw, lon_cne, lon_csw, lon_cse;
        float theta, thetares, dist_corn, thetagrad;
        double intersectArea = 0, binAreapix = 0, binAreagrid = 0.;
        bool ingeom = false;
        int pc;
        short  gd_row = 0, gd_col = 0;
        int findex = 0;
        int bb = 0, rb = 0, swb = 0;
        int grp_root, grp_blue, grp_red, grp_swir, grp_coor, pix;
        float **data_out,**data_out2,**data_out3;
        int flag_inpix;
        string ws_lon_str, ws_lat_str, wn_lon_str, wn_lat_str, en_lon_str, en_lat_str, es_lon_str, es_lat_str, pixstr;
   
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
                  
        srand((unsigned int)time(NULL));
 
        num_gridlines = l1cfile->num_gridlines;
        num_scans = l1cfile->nscan;
        nbinx = l1cfile->nbinx;
        num_pixels = l1cfile->npix;
        n_files = l1cfile->ifiles.size();
        size_t sfiles = 0;
 
        latcornBox = allocate2d_double(4, 9);//4 corners, 9 grid cells
        loncornBox = allocate2d_double(4, 9);
 
 
        if (l1cfile->selgran[0] < 0)//process all granules
        {
            for (unsigned int j = 0;j < sfiles;j++) l1cfile->selgran[j] = j + 1;
        }
        else {
            while (l1cfile->selgran[sfiles] >0) {
                cout << "selected granule #..........................." << l1cfile->selgran[sfiles] << endl;
                sfiles++;
            }
        }
 
        //determine crossing time of the swath
        cout << "nfiles.for the swath." << n_files << endl;
 
        //determine # of gd groups to be processede  
        //gdlines_group=num_gridlines;//ONE BIG GROUP
        //--NORMALIZED  gridline longitude is -180 to 180 degrees before comparison with longitude extracted from image pixels---
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lon_gd[i][j] < -180.)lon_gd[i][j] += 360.;
                if (lon_gd[i][j] > 180.)lon_gd[i][j] -= 360.;
            }        
      }  
        //get min/max lat/lon of the swath
        // Assume first element as maximum and minimum
        maxv = lat_gd[0][0];
        minv = lat_gd[0][0];
 
        //Find maximum and minimum in all array elements.
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lat_gd[i][j] > maxv)
                    maxv = lat_gd[i][j];
                if (lat_gd[i][j] < minv)
                    minv = lat_gd[i][j];
            }        
      }      
        latmin_swt = minv;
        latmax_swt = maxv;
        maxv = lon_gd[0][0];
        minv = lon_gd[0][0];
        //Find maximum and minimum in all array elements.
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lon_gd[i][j] > maxv)
                    maxv = lon_gd[i][j];
                if (lon_gd[i][j] < minv)
                    minv = lon_gd[i][j];
            }
        }
        lonmin_swt = minv;
        lonmax_swt = maxv;
 
        //check lat bound min/max of each gd group---
        int k = 0;
 
         //recompute number of gridlines based on lat limits -80 to 80 degrees  
        //asc orbit goes from negative to positive latitude....
        NY = num_gridlines;
        NX = nbinx;
        for (int i = 0; i < NY; i++) {
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= -80.) c1++;
                if (c1 == nbinx) {
                    NY1 = i;
                }
            }
            if (NY1 >= 0) break;
            c1 = 1;
        }
 
 
        for (int i = 0;i < NY; i++) {
            //   cout<<"i.."<<i<<"lat_gd[i][j]..."<<lat_gd[i][nadpix]<<endl;
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= 80.) {
                    NY2 = i - 1;
                }
            }
 
            if (NY2 >= 0) break;
        }
 
        // cout<<"gridlines limited to -80 to 80 degrees of latitutde.."<<"gdline ini.."<<NY1<<"gdline end.."<<NY2<<endl;
 
        l1cfile->NY1 = NY1;
        l1cfile->NY2 = NY2;
 
        cout << "NY.." << NY << "NY1.." << NY1 << "NY2.." << NY2 << endl;
 
 
        num_gridlines = NY2 - NY1 + 1;//this is the # gridlines after -80 to 80 lat constraint---
 
        num_blue_bands = l1cfile->nband_blue;//this includes uv + visible bands
        num_red_bands = l1cfile->nband_red;
        num_SWIR_bands = l1cfile->nband_swir;
 
        //*********** SORTING LAT/LON ASCENDING AND TRACK INDEXES ****************************
        //***********************************************************************************
 
        //Create index matrix for i and j of each lat and lon L1C grid (-80 to 80)
        //num_gridlines x nbinx
        index_xy = allocate2d_short(num_gridlines, nbinx);
        lat_asort = allocate2d_float(num_gridlines, nbinx);
        //  lon_asort=allocate2d_float(num_gridlines,nbinx);
             //fill indexe
 
        //define 1-D vector to sort 1 col L1C grid at the time---
        vector<pair<float, int> > vp;
 
        //fill vector with lat_gd column--
        cout << "*********** SORTING LAT/LON GRIDPOINTS AND TRACKING INDEXES ********************" << endl;
 
        for (int col = 0;col < nbinx;col++) {
            for (int row = NY1;row < NY2 + 1;row++) {
                vp.push_back(make_pair(lat_gd[row][col] + 90., row));
            }
            //sort 
            stable_sort(vp.begin(), vp.end());
            //display lat in order along with its gridpoint index--
              //   cout << "Lat value\t"
              //         << "index" << endl; 
            for (unsigned int i = 0; i < vp.size(); i++) {
                lat_asort[i][col] = vp[i].first;
                index_xy[i][col] = vp[i].second;
            }
            vp.clear();
        }
 
 
        fi = l1cfile->selgran[0];
        str = l1cfile->ifiles[fi - 1];
 
 
        for (pix = 0;pix < num_pixels;pix++) {
            if (l1cstr->latpix[pix] < latmin_swt) latmin_swt = l1cstr->latpix[pix];
            if (l1cstr->latpix[pix] > latmax_swt) latmax_swt = l1cstr->latpix[pix];
            if (l1cstr->lonpix[pix] < lonmin_swt) lonmin_swt = l1cstr->lonpix[pix];
            if (l1cstr->lonpix[pix] > lonmax_swt) lonmax_swt = l1cstr->lonpix[pix];
        }
 
 
       //      cout<<"Processing line #..."<<sline+1<<endl;
 
//*********** BIG LOOP M_PIXEL *****************************************************************
        for (pix = 0;pix < num_pixels;pix++) {
 
            bb = 0, rb = 0, swb = 0, gd_row = 0, gd_col = 0;
            flag_inpix = 0;
 
            latcornBox = allocate2d_double(4, 9);//4 corners, 9 grid cells
            loncornBox = allocate2d_double(4, 9);
 
            for (int i = 0;i < 4;i++) {
                for (int j = 0;j < 9;j++) {
                    latcornBox[i][j] = 0.;
                    loncornBox[i][j] = 0.;
                }            
}
 
//            cout << "sline.aw2." << sline + 1 << "pix.." << pix + 1 << endl;
            boolbin1 = sbs2_l1c(l1cinput, num_gridlines, nbinx, lat_asort, index_xy, l1cstr->latpix[pix], l1cstr->lonpix[pix], lon_gd, &gd_row, &gd_col);
 
            //           if (sline % 1 == 0){     cout<<"LINE NUMBER------------------------------------------------------------------------------------------------------------------------#"<<sline+1<<"pix #........"<<pix+1<<endl;
//            cout << "boolbin1..." << boolbin1 << "row.." << gd_row << "col..." << gd_col << "latpix..." << l1cstr->latpix[pix] << "lonpix..." << l1cstr->lonpix[pix] << endl;
//            cout << "latasort.." << lat_asort[0][0] << "index_xy.." << index_xy[0][0] << endl;
 
 
     
            if (boolbin1 == 1) flag_inpix = 1;
            //************ BINNING ***************************
         //assign identified pixel to Lt and bin stat arrays-----         
 
 
            if (flag_inpix == 1 && gd_row >= 2 && gd_col >= 2 && gd_row <= nbinx - 3 && gd_col <= num_gridlines - 3) {
                Polygon_t pixelPoly;
                Polygon_t gridPoly;
 
                inpix++;
                deltaphi = (l1cstr->latpix[pix] - l1cstr->latpix[pix + 1]) * degrad;
                deltalam = (l1cstr->lonpix[pix] - l1cstr->lonpix[pix + 1]) * degrad;
                aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(l1cstr->latpix[pix] * degrad) * cos(l1cstr->latpix[pix + 1] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
                bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
                dist_u = Re * bterm;         //horizontal distance Harversine in km
            //along-track distance
                deltaphi = (l1cstr->latpix[pix] - l1cstr->latpix2[pix]) * degrad;
                deltalam = (l1cstr->lonpix[pix] - l1cstr->lonpix2[pix]) * degrad;
                aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(l1cstr->latpix[pix] * degrad) * cos(l1cstr->latpix2[pix] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
                bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
                dist_v = Re * bterm;
                //pixel azimuth
                azpix = atan2(sin(deltalam) * cos(l1cstr->latpix2[pix] * degrad), cos(l1cstr->latpix[pix] * degrad) * sin(l1cstr->latpix2[pix] * degrad) - sin(l1cstr->latpix[pix] * degrad) * cos(l1cstr->latpix2[pix] * degrad) * cos(deltaphi));
                if (azpix > M_PI || azpix < -M_PI) {
                    cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "azpixc in degrees.." << azpix * 180 / M_PI << endl;
                    exit(1);
                }
                azpix = azpix * 180. / M_PI;
 
                //      cout<<"line.."<<sline+1<<"pix #:.."<<pix+1<<"pix size.U in km."<<dist_u<<"pixsize.V in km."<<dist_v<<"azpix before  pix_corners4_l1c....in degrees."<<azpix<<endl;
               //       cout<<"FOUND grid cell!!-----row.."<<gd_row<<"col.."<<gd_col<<"latpix.."<<l1cstr->latpix[pix]<<"lonpix.."<<l1cstr->lonpix[pix]<<"latpix2.."<<l1cstr->latpix2[pix]<<"lonpix2.."<<l1cstr->lonpix2[pix]<<endl;                             
 
                //******* M_PIXEL CORNERS ***********************************************************************************************
                dist_corn = 0.5 * (sqrt(dist_u * dist_u + dist_v * dist_v)) * 1000;//distane center to corner in meters
                theta = atan2(dist_v, dist_u);
                thetagrad = 2 * theta * 180 / M_PI;
                thetares = (M_PI / 2 - theta) * 180 / M_PI;
                //nw corner 
                azpixc = (azpix - thetares) * degrad;//pixel bearing
                if (azpixc<-M_PI || azpixc>M_PI) { cout << "error in nw corner..azpixc" << azpixc << endl;exit(1); }
                azpixc = azpixc * 180 / M_PI;
                //      cout<<"azpixc nw...."<<azpixc<<endl;
                geod.Direct(l1cstr->latpix[pix], l1cstr->lonpix[pix], azpixc, dist_corn, lat_cnw, lon_cnw);
                //ne corner (sw-180)
                azpixc = (azpix + thetares) * degrad;//pixel bearing
                if (azpixc<-M_PI || azpixc>M_PI) { cout << "error in ne corner..azpixc" << azpixc << endl;exit(1); }
                azpixc = azpixc * 180 / M_PI;
                //      cout<<"azpixc ne...."<<azpixc<<endl;
                geod.Direct(l1cstr->latpix[pix], l1cstr->lonpix[pix], azpixc, dist_corn, lat_cne, lon_cne);
                //sw corner               
                azpixc = (azpix - thetares - thetagrad) * degrad;//pixel bearing
                if (azpixc<-M_PI || azpixc>M_PI) { cout << "error in sw corner..azpixc" << azpixc << endl;exit(1); }
                azpixc = azpixc * 180 / M_PI;
                //       cout<<"azpixc sw....."<<azpixc<<endl;
                geod.Direct(l1cstr->latpix[pix], l1cstr->lonpix[pix], azpixc, dist_corn, lat_csw, lon_csw);
                //se corner (nw-180)
                azpixc = (azpix + thetares + thetagrad) * degrad;//pixel bearingi
                if (azpixc<-M_PI || azpixc>M_PI) { cout << "error in se corner..azpixc" << azpixc << endl;exit(1); }
                azpixc = (azpix + 45 + 90) * degrad;//pixel bearing
                azpixc = azpixc * 180 / M_PI;
                //       cout<<"azpix se...."<<azpixc<<endl;
                geod.Direct(l1cstr->latpix[pix], l1cstr->lonpix[pix], azpixc, dist_corn, lat_cse, lon_cse);
 
 
 
                //                            cout<<"sline................................................................................................................"<<sline+1<<endl;
                                       //     cout<<"sline.."<<sline+1<<"dist_corn.."<<dist_corn<<"lat_cnw.."<<lat_cnw<<"lon_cnw.."<<lon_cnw<<"lat_cne.."<<lat_cne<<"lon_cne.."<<lon_cne<<"lat_csw.."<<lat_csw<<"lon_csw.."<<lon_csw<<"lat_cse.."<<lat_cse<<"lon_cse.."<<lon_cse<<endl;
 
                                     //       ws_lon_str=std::to_string(lon_csw);
                                     //       ws_lat_str=std::to_string(lat_csw);
                                     //       wn_lon_str=std::to_string(lon_cnw);
                                     //       wn_lat_str=std::to_string(lat_cnw);
                                     //       en_lon_str=std::to_string(lon_cne);
                                     //       en_lat_str=std::to_string(lat_cne);
                                     //       es_lon_str=std::to_string(lon_cse);
                                     //       es_lat_str=std::to_string(lat_cse);
 
                                     //       pixstr="POLYGON(("+ws_lon_str+" "+ws_lat_str+","+wn_lon_str+" "+wn_lat_str+","+en_lon_str+" "+en_lat_str+","+es_lon_str+" "+es_lat_str+","+ws_lon_str+" "+ws_lat_str+"))";
                                     //       bg::read_wkt(pixstr,pixelPoly);
 
                bg::append(pixelPoly.outer(), Point_t(lon_csw, lat_csw));
                bg::append(pixelPoly.outer(), Point_t(lon_cnw, lat_cnw));
                bg::append(pixelPoly.outer(), Point_t(lon_cne, lat_cne));
                bg::append(pixelPoly.outer(), Point_t(lon_cse, lat_cse));
                bg::append(pixelPoly.outer(), Point_t(lon_csw, lat_csw));
 
 
 
                // make sure the polygon is defined properly
                bg::correct(pixelPoly);
 
                if (lon_csw > lon_cse || lon_cnw > lon_cne || lat_csw > lat_cnw || lat_cse > lat_cne) {
                    cout << "lon_csw>lon_cse | lon_cnw>lon_cne | lat_csw>lat_cnw | lat_cse>lat_cne//" << lon_csw << lon_cse << lon_cnw << lon_cne << lat_csw << lat_cnw << lat_cse << lat_cne << endl;
                    cout << "corners are switched for pixel.." << pix + 1 << endl;
                }
 
 
                lon_csw = 0, lat_csw = 0, lon_cnw = 0, lat_cnw = 0, lon_cne = 0, lat_cne = 0, lon_cse = 0, lat_cse = 0;
                //    cout<<"azpixc nw...."<<azpixc<<"lat.."<<l1cstr->latpix[pix]<<"lon.."<<l1cstr->lonpix[pix]<<"dist_corn.."<<dist_corn<<"lat_cnw.."<<lat_cnw<<"lon_cnw.."<<lon_cnw<<endl;
 
 
                if (gd_row >= 1 && gd_col >= 1 && gd_row < num_gridlines - 1 && gd_col < nbinx - 1) {
 
                    //           cout<<"sline.."<<sline<<"gd_row.."<<gd_row<<"gd_col.."<<gd_col<<"bb.."<<bb<<endl;
                    gwindowTopix_l1c(l1cfile, l1cinput, gd_row, gd_col, lat_gd, lon_gd, latcornBox, loncornBox);
 
 
                    for (int i = 0;i < 9;i++) { //for each intersection
              //          corn1_lon_str=std::to_string(loncornBox[0][i]);
              //          corn1_lat_str=std::to_string(latcornBox[0][i]);
              //          corn2_lon_str=std::to_string(loncornBox[1][i]);
              //          corn2_lat_str=std::to_string(latcornBox[1][i]);
              //          corn3_lon_str=std::to_string(loncornBox[2][i]);
              //          corn3_lat_str=std::to_string(latcornBox[2][i]);
             //           corn4_lon_str=std::to_string(loncornBox[3][i]);
              //          corn4_lat_str=std::to_string(latcornBox[3][i]);
             //           gridstr="POLYGON(("+corn1_lon_str+" "+corn1_lat_str+","+corn2_lon_str+" "+corn2_lat_str+","+corn3_lon_str+" "+corn3_lat_str+","+corn4_lon_str+" "+corn4_lat_str+","+corn1_lon_str+" "+corn1_lat_str+"))";
              //          bg::read_wkt(gridstr,gridPoly);
 
 
                        bg::append(gridPoly.outer(), Point_t(loncornBox[0][i], latcornBox[0][i]));
                        bg::append(gridPoly.outer(), Point_t(loncornBox[1][i], latcornBox[1][i]));
                        bg::append(gridPoly.outer(), Point_t(loncornBox[2][i], latcornBox[2][i]));
                        bg::append(gridPoly.outer(), Point_t(loncornBox[3][i], latcornBox[3][i]));
                        bg::append(gridPoly.outer(), Point_t(loncornBox[0][i], latcornBox[0][i]));
                        bg::correct(gridPoly);
 
                        ingeom = within(pixelPoly, gridPoly);
                        binAreagrid = bg::area(gridPoly);
                        binAreapix = bg::area(pixelPoly);//         
 
             //           if (sline % 10 == 0 & binAreagrid>10000000)            cout<<"sline.."<<sline+1<<"pix.."<<pix+1<<"gridcell#.."<<i<<"fully inside????.."<<ingeom<<"binAreagrid..."<<binAreagrid<<"binAreapix..."<<binAreapix<<endl;        
                  //compute intersections-----
//                   
                        intersectArea = 0., pc = 1;
                        if (ingeom > 0) { //pixel fully inside the grid cell                        
                            intersectArea = binAreapix;
 
                            if (l1cstr->Lt_blue[bb][pix] > 0.) {
                                Ltfracsum[gd_row][gd_col] += l1cstr->Lt_blue[bb][pix] * (intersectArea / binAreagrid);
                                areabinsum[gd_row][gd_col] += (intersectArea / binAreagrid);
                                nobs_perbin[gd_row][gd_col] += 1;
                            }
                        }
                        else {
                            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                                std::deque<Polygon_t> output;//this is a list
                                if (bg::intersection(pixelPoly, gridPoly, output)) {
                                    BOOST_FOREACH(Polygon_t const& p, output)
                                    {
                                        intersectArea = bg::area(p);
                                        if (intersectArea > 0.0 && pc == 1) {
 
                                            if (l1cstr->Lt_blue[bb][pix] > 0.) {
                                                Ltfracsum[gd_row][gd_col] += l1cstr->Lt_blue[bb][pix] * (intersectArea / binAreagrid);
                                                areabinsum[gd_row][gd_col] += (intersectArea / binAreagrid);
                                                nobs_perbin[gd_row][gd_col] += 1;
                                            }
 
 
                                            if (intersectArea / binAreagrid < 0.000001) {
                                                Ltfracsum[gd_row][gd_col] += 0.;
                                                areabinsum[gd_row][gd_col] += 0.;
                                                nobs_perbin[gd_row][gd_col] += 0.;
                                            }
                                            pc++;
                                        }
                                    }
                                }
                            }
                        }//end else
 
//                                       cout<<"gridcell#.."<<i<<"fully inside????.."<<ingeom<<"areafrac..."<<intersectArea / binAreagrid<<"Ltfrac..."<<Ltfracsum[gd_row][gd_col]<<"areabinsum.."<<areabinsum[gd_row][gd_col]<<"nobsperbin.."<<nobs_perbin[gd_row][gd_col]<<endl;
               //              cout<<"sline........"<<sline+1<<"pix#.........................."<<pix+1<<"gridcell#.."<<i<<endl;
                    }//end for intersections
 
 
                }//end if gdrow and gdcol are ok
 
 
 
 
 
/*
                         while (bb<num_blue_bands){
                          if(l1cstr->Lt_blue[bb][pix]>0.){
                            binmean_Lt[bb][bin_ypix-1][bin_xpix-1]=binmean_Lt[bb][bin_ypix-1][bin_xpix-1]+l1cstr->Lt_blue[bb][pix];
                            bincount_Lt[bb][bin_ypix-1][bin_xpix-1]+=1;
                           }
                        bb++;
                        }//end while blue band band
//RED---
                         while (rb<num_red_bands){
                          if(l1cstr->Lt_red[rb][pix]>0.){
                            binmean_Lt2[rb][bin_ypix-1][bin_xpix-1]=binmean_Lt2[rb][bin_ypix-1][bin_xpix-1]+l1cstr->Lt_red[rb][pix];
                            bincount_Lt2[rb][bin_ypix-1][bin_xpix-1]+=1;
                           }
                         rb++;
                         }//end red bands
 
//SWIR----
                        while (swb<num_SWIR_bands){
                          if(l1cstr->Lt_SWIR[swb][pix]>0.){
                            binmean_Lt3[swb][bin_ypix-1][bin_xpix-1]=binmean_Lt3[swb][bin_ypix-1][bin_xpix-1]+l1cstr->Lt_SWIR[swb][pix];
                            bincount_Lt3[swb][bin_ypix-1][bin_xpix-1]+=1;
                           }
                         swb++;
                         }//end swir bands
 
*/
 
            }//end if flag_inpix
 
 
 
//********** pixel AREA WEIGHTING ************************
            if (flag_inpix == 0) outpix++;
 
            totpix++;
 
            delete[](latcornBox);
            delete[](loncornBox);
            latcornBox = nullptr;
            loncornBox = nullptr;
        }//end pixels loop
 
//**********************************************************************************************************************************
//**********************************************************************************************************************************
//writing each granule ---------------------------------
//*****************************************************************************
        if (sline == num_scans - 1) {
            //          if(sline==num_scans-1 flag_donefile==1 | (flag_donefile==0 & k==ngroups-1)){
            cout << "writing file #.............................................." << l1cfile->selgran[findex] << "based on group #.." << k + 1 << endl;
            //write mean Lt as nc file---
           //**********************************************************************
           //**********************************************************************8
           //create Lt file
            pathstr = "out/";
            senstr = "OCIS_";
            monstr = std::to_string(selmon);
            daystr = std::to_string(selday);
            yearstr = std::to_string(selyear);
            prodstr = "binLt_aw2";
            swtstr = "_swt";
            granstr = "";
            granstr = "_" + std::to_string(l1cfile->selgran[findex]);
 
            if (l1cfile->l1c_pflag >= 3) {
                swtd = l1cfile->swtnum;
                swtnum = std::to_string(swtd);
                cout << "swtnum.." << swtnum << endl;
            }
            else swtnum = std::to_string(swtd);
            extstr = ".nc";
            NDIMS = 2;
            fname_out = pathstr + senstr + monstr + daystr + yearstr + prodstr + swtstr + swtnum + granstr + extstr;
            filename_lt = fname_out.c_str();
 
            if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
                check_err(status, __LINE__, __FILE__);
            //define dims
            // Define the dimensions. NetCDF will hand back an ID for each. 
            NY = num_gridlines;
            NX = nbinx;
            NY1 = l1cfile->NY1;//these are indexes not line #!!!!!!!!!!!!!!!!!
            NY2 = l1cfile->NY2;
            cout << "rowgrid ini.." << NY1 << "rowgrid end.." << NY2 << endl;
            NY = NY2 - NY1 + 1;
            cout << "NY.." << NY << "NX.." << NX << endl;
            //alloc mem for data_out and assign values from lat_gdI
//alloc mem for data_out and assign values from lat_gdI
            lat_out = allocate2d_float(NY, NX);
            lon_out = allocate2d_float(NY, NX);
 
            int c = 0;
 
            for (int i = NY1; i < NY2 + 1; i++) {
                for (int j = 0; j < NX; j++) {
                    lat_out[NY - 1 - c][NX - 1 - j] = lat_gd[i][j];
                    lon_out[NY - 1 - c][j] = lon_gd[i][j];
                }
                c++;
            }
 
            if ((status = nc_def_dim(ncid_out, "x", NX, &x_dimid)))
                check_err(status, __LINE__, __FILE__);
            if ((status = nc_def_dim(ncid_out, "y", NY, &y_dimid)))
                check_err(status, __LINE__, __FILE__);
            //dims for output var
            dimids[0] = y_dimid;
            dimids[1] = x_dimid;
 
            //define groups-----
                     //    status = nc_def_grp( *ncid, line.c_str(), &gid[ngrps]);
            if ((status = nc_def_grp(ncid_out, "data", &grp_root)))  //netcdf-4
                check_err(status, __LINE__, __FILE__);
            if ((status = nc_def_grp(grp_root, "geo_coordinates", &grp_coor)))  //netcdf-4
                check_err(status, __LINE__, __FILE__);
            if ((status = nc_def_grp(grp_root, "blue_bands", &grp_blue)))  //netcdf-4
                check_err(status, __LINE__, __FILE__);
            if ((status = nc_def_grp(grp_root, "red_bands", &grp_red)))  //netcdf-4
                check_err(status, __LINE__, __FILE__);
            if ((status = nc_def_grp(grp_root, "swir_bands", &grp_swir)))  //netcdf-4
                check_err(status, __LINE__, __FILE__);
 
            //def var--------------------
 
                     //loop blue channels-----
 
            string bb_num, rb_num, swb_num, bb_str = "binLt_blue_ch", rb_str = "binLt_red_ch", swb_str = "binLt_swir_ch";
 
            int varid_bb[1], varid_rb[1], varid_swb[1];
 
            for (int bb = 0;bb < 1;bb++) {
                bb_num = std::to_string(bb + 1);
                bb_num = bb_str + bb_num;
                if ((status = nc_def_var(grp_blue, bb_num.c_str(), NC_FLOAT, NDIMS, dimids, &varid))) check_err(status, __LINE__, __FILE__);
                varid_bb[bb] = varid;
            }
 
            for (int rb = 0;rb < 1;rb++) {
                rb_num = std::to_string(rb + 1);
                rb_num = rb_str + rb_num;
                if ((status = nc_def_var(grp_red, rb_num.c_str(), NC_FLOAT, NDIMS, dimids, &varid))) check_err(status, __LINE__, __FILE__);
                varid_rb[rb] = varid;
            }
 
            for (int swb = 0;swb < 1;swb++) {
                swb_num = std::to_string(swb + 1);
                swb_num = swb_str + swb_num;
                if ((status = nc_def_var(grp_swir, swb_num.c_str(), NC_FLOAT, NDIMS, dimids, &varid))) check_err(status, __LINE__, __FILE__);
                varid_swb[swb] = varid;
            }
            //lat/lon
            if ((status = nc_def_var(grp_coor, "lat_gd", NC_FLOAT, NDIMS,
                dimids, &varid2)))
                check_err(status, __LINE__, __FILE__);
            if ((status = nc_def_var(grp_coor, "lon_gd", NC_FLOAT, NDIMS,
                dimids, &varid3)))
                check_err(status, __LINE__, __FILE__);
            //leave define mode-----------------------
            if ((status = nc_enddef(ncid_out))) //done def vars etc
                check_err(status, __LINE__, __FILE__);
 
            //assign variable data------------------------
            if ((status = nc_put_var_float(grp_coor, varid2, &lat_out[0][0])))
                check_err(status, __LINE__, __FILE__);
 
            if ((status = nc_put_var_float(grp_coor, varid3, &lon_out[0][0])))
                check_err(status, __LINE__, __FILE__);
            //blue
 
   //              for(bb=0;bb<num_blue_bands;bb++){
            bb = 0;
            data_out = allocate2d_float(NY, NX);
            c = 0;
            for (int i = NY1; i < NY2 + 1; i++) {
                for (int j = 0; j < NX; j++) {
                    data_out[NY - 1 - c][NX - 1 - j] = 0.;
                }
                c++;
            }
            c = 0;
            for (int i = NY1; i < NY2 + 1; i++) {
                for (int j = 0; j < NX; j++) {
                    if (nobs_perbin[i][j] > 0)
                        data_out[NY - 1 - c][NX - 1 - j] = Ltfracsum[i][j] / nobs_perbin[i][j];
                    else         data_out[NY - 1 - c][NX - 1 - j] = NAN;
                }
                c++;
            }
            cout << "writing blue band#.." << bb + 1 << endl;
            if ((status = nc_put_var_float(grp_blue, varid_bb[bb], &data_out[0][0])))
                check_err(status, __LINE__, __FILE__);
 
 
            delete[](data_out);
            //               }//end blue bands
          //red
          //             for(rb=0;rb<num_red_bands;rb++){
            rb = 0;
            data_out2 = allocate2d_float(NY, NX);
            c = 0;
            for (int i = NY1; i < NY2 + 1; i++) {
                for (int j = 0; j < NX; j++) {
                    data_out2[NY - 1 - c][NX - 1 - j] = 0.;
                }
                c++;
            }
            c = 0;
            for (int i = NY1; i < NY2 + 1; i++) {
                for (int j = 0; j < NX; j++) {
                    if (nobs_perbin[i][j] > 0)
                        data_out2[NY - 1 - c][NX - 1 - j] = Ltfracsum[i][j] / nobs_perbin[i][j];
                    else         data_out2[NY - 1 - c][NX - 1 - j] = NAN;
                }
                c++;
            }
            cout << "writing red band#.." << rb + 1 << endl;
            if ((status = nc_put_var_float(grp_red, varid_rb[rb], &data_out2[0][0])))
                check_err(status, __LINE__, __FILE__);
 
            delete[](data_out2);
            //      }//end red bands
 
 
         //swir
 //             for(swb=0;swb<num_SWIR_bands;swb++){
            swb = 0;
            data_out3 = allocate2d_float(NY, NX);
            c = 0;
            for (int i = NY1; i < NY2 + 1; i++) {
                for (int j = 0; j < NX; j++) {
                    data_out3[NY - 1 - c][NX - 1 - j] = 0.;
                }
                c++;
            }
            c = 0;
            for (int i = NY1; i < NY2 + 1; i++) {
                for (int j = 0; j < NX; j++) {
                    if (nobs_perbin[i][j] > 0)
                        data_out3[NY - 1 - c][NX - 1 - j] = Ltfracsum[i][j] / nobs_perbin[i][j];
                    else         data_out3[NY - 1 - c][NX - 1 - j] = NAN;
                }
                c++;
            }
            cout << "writing SWIR band#.." << swb + 1 << endl;
            if ((status = nc_put_var_float(grp_swir, varid_swb[swb], &data_out3[0][0])))
                check_err(status, __LINE__, __FILE__);
 
            delete[](data_out3);
            //         }//end swir bands
 
            if ((status = nc_close(ncid_out)))
                check_err(status, __LINE__, __FILE__);
 
            delete[](lat_out);
            delete[](lon_out);
 
            lat_out = nullptr;;
            lon_out = nullptr;
            data_out = nullptr;
            data_out2 = nullptr;
            data_out3 = nullptr;
 
            printf("*** SUCCESS writing bincount and binLt rasters as nc..!\n");
            cout << "finish processing swath eq crossing day..." << swtd << endl;
            cout << "done writing Lt to nc file.." << endl;
        }//end writing file
 
 
//     cout<<"group k at the end of big loop"<<k+1<<endl;
//     }//groups
 
//    cout<<"number of files per swath.."<<nfiles_swt[swtd-1]<<"for swath.."<<swtd<<endl;
        cout << "total inpix.." << inpix << "total pix.." << totpix << endl;
        //  cout<<"binned pixels.."<<inpix<<"as %.."<<(inpix/(num_pixels*num_scans*n_files*nfiles_swt[swtd-1]))*100<<endl;
        delete[](lat_asort);
        delete[](index_xy);
 
        lat_asort = nullptr;
        index_xy = nullptr;
 
 
 
        return 0;
    }
 
 
 
 
 
 
 
    int32_t L1C::binL1C_wgranule_aw(int swtd, l1c_filehandle* l1cfile, L1C_input* l1cinput, int16_t* swtd_id, int16_t* odir, int16_t* file_id, int16_t* nfiles_swt) {
        int32_t gdlines_group,ngroups = 0,num_gridlines, nbinx, inpix = 0, outpix = 0, totpix = 0, n_gdlines;//number of gridlines to be processed
        float minv = 0., maxv = 0.;
        int16_t fi = 0;
 
        std::string str;
        const char* ptstr;
        int dimid, status, ncid_out, x_dimid, y_dimid, varid, varid2, varid3, varid4, varid5, varid6, varid7, varid8, NDIMS;
        size_t start[] = { 0, 0 }, start2[] = { 0, 0, 0 }, start3[] = { 0, 0 };
        size_t count[] = { 1, 1 }, count2[] = { 1, 1, 1 }, count3[] = { 1, 1, 1 }, count4[] = { 1, 1, 1 };
 
        float* latpix, * lonpix, * latpix2, * lonpix2, ** Lt_pix, ** Lt_pix2, ** Lt_pix3;
        float Re = 6378;
        float latmin_swt = 100, latmax_swt = 0, lonmin_swt = 0, lonmax_swt = 0;
        int dimids[2];
        const char* filename_lt;
        int32_t NY = -1, NX = -1, NY1 = -1, NY2 = -1, c1 = 1;
        float** lat_out, ** lon_out;
 
       ;
        float aterm = 0.;
        int last_file, last_sline, flag_inpix, flag_donefile;;//first index file id, second index line #
        short** index_xy;
        float** lat_asort;
        bool boolbin1;
        int16_t selyear = -1, selmon = -1, selday = -1;
        float** lat_gd, ** lon_gd, * az_east;
        string gridname, azeast_name;
 
        double gres = (l1cinput->gres) * 1000, dlamin, dlamax, dlomin, dlomax;
        float azpix, azpixc, ** nobs_perbin;
        double** Ltfracsum, ** areabinsum;
        double** latcornBox, ** loncornBox;
        float deltaphi, deltalam, bterm, dist_u, dist_v;
        double lat_cnw, lat_cne, lat_csw, lat_cse, lon_cnw, lon_cne, lon_csw, lon_cse;
        float theta, thetares, dist_corn, thetagrad;
        string corn1_lon_str, corn2_lon_str, corn3_lon_str, corn4_lon_str, corn1_lat_str, corn2_lat_str, corn3_lat_str, corn4_lat_str, gridstr;
 
        double intersectArea = 0, binAreapix = 0, binAreagrid = 0.;
        bool ingeom = false;
        int pc;
        short gd_row, gd_col;
        float **dlatb_g=nullptr,**dlonb_g=nullptr;
 
        Polygon_t pixelPoly;
        Polygon_t gridPoly;
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
 
     //random seed
        srand((unsigned int)time(NULL));
        //nadir pixel ofr OCI
        int nadpix = l1cfile->nadpix;
 
        num_gridlines = l1cfile->num_gridlines;
        nbinx = l1cfile->nbinx;
        num_pixels = l1cfile->npix;
 
        size_t sfiles = 0;
 
        if (l1cfile->selgran[0] < 0)//process all granules
        {
            sfiles = nfiles_swt[swtd - 1];
            for (unsigned int j = 0;j < sfiles;j++) l1cfile->selgran[j] = j + 1;
        }
        else {
            while (l1cfile->selgran[sfiles] > 0) {
                cout << "selected granule #..........................." << l1cfile->selgran[sfiles] << endl;
                sfiles++;
            }
        }
 
        //allocate mem for lat/lon/azeast pointers---
        selday = l1cinput->selday;
        selmon = l1cinput->selmon;
        selyear = l1cinput->selyear;
 
        std::string fname_out, pathstr, senstr, monstr, daystr, yearstr, prodstr, gdstr, swtstr, swtnum, extstr, granstr;
 
        pathstr = "out/";
        senstr = "OCIS_";
        monstr = std::to_string(selmon);
        daystr = std::to_string(selday);
        yearstr = std::to_string(selyear);
        prodstr = "L1Cgrid";
        swtstr = "_swt";
        extstr = ".csv";
 
        if (l1cfile->l1c_pflag >= 3) {
            swtd = l1cfile->swtnum;
            swtnum = std::to_string(swtd);
            cout << "swtnum.." << swtnum << endl;
        }
        else swtnum = std::to_string(swtd);
 
        gridname = pathstr + senstr + monstr + daystr + yearstr + prodstr + swtstr + swtnum + extstr;
 
        prodstr = "az_east";
        azeast_name = pathstr + senstr + monstr + daystr + yearstr + prodstr + swtstr + swtnum + extstr;
        cout << "gridname.." << gridname << "azeast-name.." << azeast_name << endl;
 
        //************ OPENING **************************************
        //*** AZ_EAST *****************
        std::string line;
        stringstream ss;
        std::string temp;
        std::vector<std::string> parts;
        ifstream fin(azeast_name);
        int cline = 0;
        while (getline(fin, line))
        {
            // load line in stringstream
            ss << line;
            getline(ss, temp, ',');
            parts.push_back(temp);
            //   cout<<parts[cline]<<endl;
            ss.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            ss.clear();
            cline++;
        }
        //minus -1 cause the header
        cout << "size of azeast minus heading row..= num_gridlines." << parts.size() - 1 << "nbinx.." << nbinx << endl;
        num_gridlines = parts.size() - 1;
        //**LAT_GD *******************
        ifstream fin2(gridname);
        std::vector<std::string> tokens_lon, tokens_lat;
        std::string token;
        cline = 0;
        int fcol = 0;
        while (getline(fin2, line))
        {
            // load line in stringstream
            istringstream iss(line);
            while (getline(iss, token, ','))
            {
                cline++;
                if (fcol == 0 && cline > 2) {
                    tokens_lon.push_back(token);fcol++;                
}
                else if (fcol == 1 && cline > 2)
                    tokens_lat.push_back(token);
 
            }
            fcol = 0;
        }
 
 
//here the num gridlines is 1 less cause the rounding of nbinx
        cout << "size of gridline minus heading row..= num_gridlines." << (tokens_lon.size() - 1) / nbinx << "nbinx.." << nbinx << endl;
 
        //************************************************************
        //mem allocation for geolocation pointers and binning pointers---
        az_east = (float*)calloc(num_gridlines , sizeof(float));
        lat_gd = allocate2d_float(num_gridlines, nbinx);
        lon_gd = allocate2d_float(num_gridlines, nbinx);
 
        //Initialize pointers-----
        for (int i = 0;i < num_gridlines;i++) {
            for (int j = 0;j < nbinx;j++) {
                lat_gd[i][j] = 0.;
                lon_gd[i][j] = 0.;               
            }
            az_east[i] = 0.;
        }
 
 
        float sum = 0, tot = 0;
        for (int j = 0;j < num_gridlines;j++) {
            //     cout<<"j.."<<j<<"az_east"<<std::stof(parts[j+1])<<endl;
            az_east[j] = std::stof(parts[j + 1]);//first line is the header
            sum = az_east[j];
            tot += sum;
        }
        parts.clear();
 
 
 
        //using swath-averaged az_east for nadir pixels rather than along-track az_east pixel-by-pixel
        float mean_az_east = tot / (num_gridlines - 1);
        cout << "mean_az_east..." << mean_az_east << "numgridlines.." << num_gridlines << endl;
        //   exit(1); 
        for (int j = 0;j < num_gridlines;j++) {
            az_east[j] = mean_az_east;
        }
 
        l1cfile->mean_az_east = mean_az_east;
 
        int ip = 0;
        for (int j = 0;j < num_gridlines;j++) {
            for (int k = 0;k < nbinx;k++) {
                lat_gd[j][k] = std::stof(tokens_lat[ip]);
                lon_gd[j][k] = std::stof(tokens_lon[ip]);
                ip++;
            }        
}
        tokens_lon.clear();
        tokens_lat.clear();
 
        //determine # of gd groups to be processede  
        //gdlines_group=num_gridlines;//ONE BIG GROUP
        gdlines_group = 250;
 
        if (num_gridlines <= gdlines_group) {
            gdlines_group = num_gridlines;
            cout << "WARNING********************* number_gridlines<=gdlines_group THEN gdlines_group=num_gridlines **************" << endl;
        }
        ngroups = floor(num_gridlines / gdlines_group);
        cout << "TOTAL # of gd groups.(ALL LATs...." << ngroups << endl;
 
        //--NORMALIZED  gridline longitude is -180 to 180 degrees before comparison with longitude extracted from image pixels---
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lon_gd[i][j] < -180.)lon_gd[i][j] += 360.;
                if (lon_gd[i][j] > 180.)lon_gd[i][j] -= 360.;
            }        
}
        //get min/max lat/lon of the swath
        // Assume first element as maximum and minimum
        maxv = lat_gd[0][0];
        minv = lat_gd[0][0];
 
        //Find maximum and minimum in all array elements.
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lat_gd[i][j] > maxv)
                    maxv = lat_gd[i][j];
                if (lat_gd[i][j] < minv)
                    minv = lat_gd[i][j];
            }        
}
 
 
        maxv = lon_gd[0][0];
        minv = lon_gd[0][0];
        //Find maximum and minimum in all array elements.
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lon_gd[i][j] > maxv)
                    maxv = lon_gd[i][j];
                if (lon_gd[i][j] < minv)
                    minv = lon_gd[i][j];
            }
        }
 
 
 
        cout << "swath #.." << swtd << endl;
 
        //check lat bound min/max of each gd group---
        int k = 0, i = 0;
 
        dlatb_g = allocate2d_float(ngroups + 1, 2);
        dlonb_g = allocate2d_float(ngroups + 1, 2);
 
        //recompute number of gridlines based on lat limits -80 to 80 degrees  
       //asc orbit goes from negative to positive latitude....
        NY = num_gridlines;
        NX = nbinx;
        for (int i = 0; i < NY; i++) {
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= -80.) c1++;
                if (c1 == nbinx) {
                    NY1 = i;
                }
            }
            if (NY1 >= 0) break;
            c1 = 1;
        }
 
 
        for (int i = 0;i < NY; i++) {
            //   cout<<"i.."<<i<<"lat_gd[i][j]..."<<lat_gd[i][nadpix]<<endl;
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= 80.) {
                    NY2 = i - 1;
                }
            }
 
            if (NY2 >= 0) break;
        }
 
        // cout<<"gridlines limited to -80 to 80 degrees of latitutde.."<<"gdline ini.."<<NY1<<"gdline end.."<<NY2<<endl;
 
        l1cfile->NY1 = NY1;
        l1cfile->NY2 = NY2;
 
        cout << "NY.." << NY << "NY1.." << NY1 << "NY2.." << NY2 << endl;
 
 
 
        num_gridlines = NY2 - NY1 + 1;//this is the # gridlines after -80 to 80 lat constraint---
        cout<<"num_gridlines after restriction for sbs2 search.."<<num_gridlines<<endl;
        ngroups = floor(num_gridlines / gdlines_group);
        cout << "gdlines will start in gline.." << i + 1 << "ROUNDED ngroups after adjusting beginning.for constraint lat (-80 to 80)" << ngroups << endl;
 
 
 
 
        //for each 'grid' group scan the swath files to see if there are scanlines within--
        //if that is case check the across-bin number position (0 to binx-1) based on latnad and lonnad values--- 
        last_file = 0;
        last_sline = 0;
        flag_donefile = 0;
 
        num_blue_bands = 120;
        num_red_bands = 120;
        num_SWIR_bands = 9;
 
        if (num_gridlines > ngroups * gdlines_group) ngroups += 1;
 
 
        //*********** SORTING LAT/LON ASCENDING AND TRACK INDEXES ****************************
        //***********************************************************************************
 
        //Create index matrix for i and j of each lat and lon L1C grid (-80 to 80)
        //num_gridlines x nbinx
        index_xy = allocate2d_short(num_gridlines, nbinx);
        lat_asort = allocate2d_float(num_gridlines, nbinx);
 
        //fill indexe
 
   //define 1-D vector to sort 1 col L1C grid at the time---
        vector<pair<float, int> > vp;
 
        //fill vector with lat_gd column--
        cout << "*********** SORTING LAT/LON GRIDPOINTS AND TRACKING INDEXES ********************" << endl;
 
        for (int col = 0;col < nbinx;col++) {
            for (int row = NY1;row < NY2 + 1;row++) {
                vp.push_back(make_pair(lat_gd[row][col] + 90., row));
            }
            //sort 
            stable_sort(vp.begin(), vp.end());
            //display lat in order along with its gridpoint index--
              //   cout << "Lat value\t"
              //         << "index" << endl; 
            for (unsigned int i = 0; i < vp.size(); i++) {
                //    cout << vp[i].first << "\t"
                //            << vp[i].second << endl;
                lat_asort[i][col] = vp[i].first;
                index_xy[i][col] = vp[i].second;
            }
            vp.clear();
        }
 
        //saddleback search
 
        cout << "num_gridlines...." << num_gridlines << "ngroups.." << ngroups << endl;
 
 
        //****************************************************************************************************
           //************* BIG LOOP GROUPS ***************************************
        cout << "Number of granules to be L1C processed........................................." << sfiles << endl;
 
 
        for (k = 0;k < ngroups;k++) {
 
            //total gridlines for k groups-----
            n_gdlines = (k + 1) * gdlines_group;
            cout << "screening k group.." << k + 1 << "last_file.." << last_file << "last_line.." << last_sline << endl;
            cout << "number of gridlines so far..." << n_gdlines << endl;
            //***** compute deltas for lat_gd index 256 and 257 *******************
 
             //compute delta_lat and delta_lon based on binres/2 for lower and upper corners of 'nadir' gridpoints of 256 and 257 indexes -----------------
               //we need nadir 256 and 257 lat/lon coordinates to compute -delta and +delta, respectively
               //we need azimuth and backazimuth and binres/2 to compute deltas ---
 
                //index 256
            geod.Direct(lat_gd[n_gdlines - gdlines_group][256], lon_gd[n_gdlines - gdlines_group][256], az_east[n_gdlines - gdlines_group], gres, dlamin, dlomin);
            geod.Direct(lat_gd[n_gdlines - 1][257], lon_gd[n_gdlines - 1][257], az_east[n_gdlines - 1], gres, dlamax, dlomax);
 
            cout << "dlamin.." << dlamin << "dlomin.." << dlomin << "dlamax.." << dlamax << "dlomax.." << dlomax << endl;
 
            dlatb_g[k][0] = dlamin;//in DEGREES!!
            dlatb_g[k][1] = dlamax;
            dlonb_g[k][0] = dlomin;
            dlonb_g[k][1] = dlomax;
 
            //********* LOOP FILES ************************************
            for (unsigned int findex = last_file;findex < sfiles;findex++) {
 
                cout << "Scanning lines in file.. for crossing swath..." << swtd << "selected granule #.." << l1cfile->selgran[findex] << "swt_id.." << swtd_id[findex] << "grid group.." << k + 1 << endl;
 
                if (last_sline == 0) { // binmean_Lt==NULL | bincount==NULL | binmean_Lt2==NULL | bincount2==NULL | binmean_Lt3==NULL | bincount3==NULL){
 
                    cout << "first allocation of memory for grid bins of file #..." << l1cfile->selgran[findex] << endl;
 
 
                    Ltfracsum = allocate2d_double(num_gridlines, nbinx);
                    areabinsum = allocate2d_double(num_gridlines, nbinx);
                    nobs_perbin = allocate2d_float(num_gridlines, nbinx);
                     
                }//end f last line allocating bin arrays
 
 
                fi = l1cfile->selgran[findex];
                str = l1cfile->ifiles[fi - 1];
                ptstr = str.c_str();
                cout << "opening filename............" << ptstr << endl;
                status = nc_open(ptstr, NC_NOWRITE, &ncid_L1B);
                if (status != NC_NOERR) {
                     fprintf(stderr, "-E- Error nc_open.\n");
                    exit(EXIT_FAILURE);
                 } 
                //Open dimensions
                status = nc_inq_dimid(ncid_L1B, "number_of_scans", &dimid);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading number_of_scans.\n");
                    exit(EXIT_FAILURE);
                }
                nc_inq_dimlen(ncid_L1B, dimid, &num_scans);
 
                //read line-by-line lat/lon/Lt
                status = nc_inq_grp_ncid(ncid_L1B, "geolocation_data", &geoGrp);
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_grp_ncid(ncid_L1B, "observation_data", &obsGrp);
                check_err(status, __LINE__, __FILE__);
                //open geo data 
                status = nc_inq_varid(geoGrp, "latitude", &latId);//scans x velements
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(geoGrp, "longitude", &lonId);//scans x velements
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(obsGrp, "Lt_blue", &Lt_blueId);
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(obsGrp, "Lt_red", &Lt_redId);
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(obsGrp, "Lt_SWIR", &Lt_SWIRId);
                check_err(status, __LINE__, __FILE__);
 
 
                // num_blue_bands
                status = nc_inq_dimid(ncid_L1B, "blue_bands", &dimid);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading num_blue_bands.\n");
                    exit(EXIT_FAILURE);
                }
                nc_inq_dimlen(ncid_L1B, dimid, &num_blue_bands);
 
                // num_red_bands
                status = nc_inq_dimid(ncid_L1B, "red_bands", &dimid);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading num_red_bands.\n");
                    exit(EXIT_FAILURE);
                }
                nc_inq_dimlen(ncid_L1B, dimid, &num_red_bands);
 
                // num_SWIR_bands
                status = nc_inq_dimid(ncid_L1B, "SWIR_bands", &dimid);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading num_SWIR_bands.\n");
                    exit(EXIT_FAILURE);
                }
                nc_inq_dimlen(ncid_L1B, dimid, &num_SWIR_bands);
 
                //assigning mem for Lt of different bands **********************
                latpix = (float*)calloc(num_pixels , sizeof(float));
                lonpix = (float*)calloc(num_pixels , sizeof(float));
                latpix2 = (float*)calloc(num_pixels , sizeof(float));
                lonpix2 = (float*)calloc(num_pixels , sizeof(float));
 
                Lt_pix = allocate2d_float(num_blue_bands, num_pixels);//blue bands
                Lt_pix2 = allocate2d_float(num_red_bands, num_pixels);//red bands
                Lt_pix3 = allocate2d_float(num_SWIR_bands, num_pixels);//SWIR bands
 
                cout << "#blue bands.." << num_blue_bands << endl;
                cout << "#red bands.." << num_red_bands << endl;
                cout << "#swir bands.." << num_SWIR_bands << endl;
 
                //********************************************************************************
                 //-----reading line by line-----------------------------------           
                for (unsigned int sline = last_sline;sline < num_scans;sline++) {
                    //lat and lon--
                    start[0] = sline;
                    start[1] = 0;
                    start3[0] = sline + 1;
                    start3[1] = 0;
 
                    count[0] = 1;
                    count[1] = num_pixels;               // 1 line at a time
 
                    status = nc_get_vara_float(geoGrp, latId, start, count, latpix);
                    status = nc_get_vara_float(geoGrp, lonId, start, count, lonpix);
                    status = nc_get_vara_float(geoGrp, latId, start3, count, latpix2);
                    status = nc_get_vara_float(geoGrp, lonId, start3, count, lonpix2);
 
                    //Lt
                    start2[0] = 0;
                    start2[1] = sline;
                    start2[2] = 0;
 
                    count2[0] = num_blue_bands;
                    count2[1] = 1;               // 1 line at a time
                    count2[2] = num_pixels;
 
                    count3[0] = num_red_bands;
                    count3[1] = 1;               // 1 line at a time
                    count3[2] = num_pixels;
                    count4[0] = num_SWIR_bands;
                    count4[1] = 1;               // 1 line at a time
                    count4[2] = num_pixels;
 
                    status = nc_get_vara_float(obsGrp, Lt_blueId, start2, count2, Lt_pix[0]);
                    status = nc_get_vara_float(obsGrp, Lt_redId, start2, count3, Lt_pix2[0]);
                    status = nc_get_vara_float(obsGrp, Lt_SWIRId, start2, count4, Lt_pix3[0]);
 
                    for (unsigned int pix = 0;pix < num_pixels;pix++) {
                        if (latpix[pix] < latmin_swt) latmin_swt = latpix[pix];
                        if (latpix[pix] > latmax_swt) latmax_swt = latpix[pix];
                        if (lonpix[pix] < lonmin_swt) lonmin_swt = lonpix[pix];
                        if (lonpix[pix] > lonmax_swt) lonmax_swt = lonpix[pix];
                    }
      //              int band = 0;
                    dlamin = 0.;dlamax = 0.;
                    //inside the 'k' box??----- ascending ----------
                    if (latpix[nadpix] >= dlatb_g[k][0] && latpix[nadpix] <= dlatb_g[k][1]) {
 
                        if (sline % 100 == 0) cout << "EVERY 100 gds..for k group.." << k + 1 << "file number #.." << l1cfile->selgran[findex] << "sline..." << sline + 1 << "# of binned pix.." << inpix << "outpix.." << outpix << endl;
 
                        //*********** BIG LOOP M_PIXEL *****************************************************************
                        for (unsigned int pix = 0;pix < num_pixels;pix++) {
 
 
                            flag_inpix = 0;
 
                            boolbin1 = sbs2_l1c(l1cinput, num_gridlines, nbinx, lat_asort, index_xy, latpix[pix], lonpix[pix], lon_gd, &gd_row, &gd_col);
                          
                         
 
                            //  cout<<"ok after sbs2_l1c"<<"boolbin1.."<<boolbin1<<"pix.."<<pix+1<<endl;
 
                            if (boolbin1 == 1) flag_inpix = 1;
                            //************ BINNING ***************************
                         //assign identified pixel to Lt and bin stat arrays-----         
         //                     if(flag_inpix==1 & bin_xpix>=1 & bin_ypix>=1 & bin_xpix<=nbinx & bin_ypix<=num_gridlines){
                            if (flag_inpix == 1 && gd_row >= 2 && gd_col >= 2 && gd_row <= nbinx - 3 && gd_col <= num_gridlines - 3) {
                                                                                                                                               
                                inpix++;
          
                                deltaphi = (latpix[pix] - latpix[pix + 1]) * degrad;
                                deltalam = (lonpix[pix] - lonpix[pix + 1]) * degrad;
                                aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(latpix[pix] * degrad) * cos(latpix[pix + 1] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
                                bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
                                dist_u = Re * bterm;         //horizontal distance Harversine in km
                            //along-track distance
                                deltaphi = (latpix[pix] - latpix2[pix]) * degrad;
                                deltalam = (lonpix[pix] - lonpix2[pix]) * degrad;
                                aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(latpix[pix] * degrad) * cos(latpix2[pix] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
                                bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
                                dist_v = Re * bterm;
                                //pixel azimuth
                                azpix = atan2(sin(deltalam) * cos(latpix2[pix] * degrad), cos(latpix[pix] * degrad) * sin(latpix2[pix] * degrad) - sin(latpix[pix] * degrad) * cos(latpix2[pix] * degrad) * cos(deltaphi));
                                if (azpix > M_PI || azpix < -M_PI) {
                                    cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "azpixc in degrees.." << azpix * 180 / M_PI << endl;
                                    exit(1);
                                }
                                azpix = azpix * 180. / M_PI;
 
                                //    cout<<"line.."<<sline+1<<"pix #:.."<<pix+1<<"pix size.U in km."<<dist_u<<"pixsize.V in km."<<dist_v<<"azpix before  pix_corners4_l1c....in degrees."<<azpix<<endl;
 
 
                              //******* M_PIXEL CORNERS ***********************************************************************************************
                                dist_corn = 0.5 * (sqrt(dist_u * dist_u + dist_v * dist_v)) * 1000;//distane center to corner in meters
                                theta = atan2(dist_v, dist_u);
                                thetagrad = 2 * theta * 180 / M_PI;
                                thetares = (M_PI / 2 - theta) * 180 / M_PI;
                                //nw corner 
                                azpixc = (azpix - thetares) * degrad;//pixel bearing
                                if (azpixc<-M_PI || azpixc>M_PI) { cout << "error in nw corner..azpixc" << azpixc << endl;exit(1); }
                                azpixc = azpixc * 180 / M_PI;
                                geod.Direct(latpix[pix], lonpix[pix], azpixc, dist_corn, lat_cnw, lon_cnw);
                                //ne corner (sw-180)
                                azpixc = (azpix + thetares) * degrad;//pixel bearing
                                if (azpixc<-M_PI || azpixc>M_PI) { cout << "error in ne corner..azpixc" << azpixc << endl;exit(1); }
                                azpixc = azpixc * 180 / M_PI;
                                // cout<<"azpixc ne...."<<azpixc<<endl;
                                geod.Direct(latpix[pix], lonpix[pix], azpixc, dist_corn, lat_cne, lon_cne);
                                //sw corner               
                                azpixc = (azpix - thetares - thetagrad) * degrad;//pixel bearing
                                if (azpixc<-M_PI || azpixc>M_PI) { cout << "error in sw corner..azpixc" << azpixc << endl;exit(1); }
                                azpixc = azpixc * 180 / M_PI;
                                // cout<<"azpixc sw....."<<azpixc<<endl;
                                geod.Direct(latpix[pix], lonpix[pix], azpixc, dist_corn, lat_csw, lon_csw);
                                //se corner (nw-180)
                                azpixc = (azpix + thetares + thetagrad) * degrad;//pixel bearingi
                                if (azpixc<-M_PI || azpixc>M_PI) { cout << "error in se corner..azpixc" << azpixc << endl;exit(1); }
                                // azpixc=(azpix+45+90)*degrad;//pixel bearing
                                azpixc = azpixc * 180 / M_PI;
                                // cout<<"azpix se...."<<azpixc<<endl;
                                geod.Direct(latpix[pix], lonpix[pix], azpixc, dist_corn, lat_cse, lon_cse);
 
                                std::string ws_lon_str, ws_lat_str, wn_lon_str, wn_lat_str, en_lon_str, en_lat_str, es_lon_str, es_lat_str, pixstr;
 
                                ws_lon_str = std::to_string(lon_csw);
                                ws_lat_str = std::to_string(lat_csw);
                                wn_lon_str = std::to_string(lon_cnw);
                                wn_lat_str = std::to_string(lat_cnw);
                                en_lon_str = std::to_string(lon_cne);
                                en_lat_str = std::to_string(lat_cne);
                                es_lon_str = std::to_string(lon_cse);
                                es_lat_str = std::to_string(lat_cse);
 
                                pixstr = "POLYGON((" + ws_lon_str + " " + ws_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + en_lon_str + " " + en_lat_str + "," + es_lon_str + " " + es_lat_str + "," + ws_lon_str + " " + ws_lat_str + "))";
                                bg::read_wkt(pixstr, pixelPoly);
                                cout<<"pixelpoly created"<<endl;
 
                                if (lon_csw > lon_cse || lon_cnw > lon_cne || lat_csw > lat_cnw || lat_cse > lat_cne) {
                                    cout << "lon_csw>lon_cse | lon_cnw>lon_cne | lat_csw>lat_cnw | lat_cse>lat_cne//" << lon_csw << lon_cse << lon_cnw << lon_cne << lat_csw << lat_cnw << lat_cse << lat_cne << endl;
                                    cout << "corners are switched for pixel.." << pix + 1 << endl;
                                }
 
                                //                            cout<<"azpixc nw...."<<azpixc<<"lat.."<<latpix[pix]<<"lon.."<<lonpix[pix]<<"dist_corn.."<<dist_corn<<"lat_cnw.."<<lat_cnw<<"lon_cnw.."<<lon_cnw<<endl;
 
                                if (gd_row >= 1 && gd_col >= 1 && gd_row < num_gridlines - 1 && gd_col < nbinx - 1) {
                                    latcornBox = allocate2d_double(4, 9);//4 corners, 9 grid cells
                                    loncornBox = allocate2d_double(4, 9);
                                    
                                    cout<<"before gwindowTopix_l1c(.."<<"pix.."<<pix<<endl;
                                    gwindowTopix_l1c(l1cfile, l1cinput, gd_row, gd_col, lat_gd, lon_gd, latcornBox, loncornBox);
                                    cout<<"after gwindowTopix_l1c(.."<<endl;
                                    for (int i = 0;i < 9;i++) {
                                        corn1_lon_str = std::to_string(loncornBox[0][i]);
                                        corn1_lat_str = std::to_string(latcornBox[0][i]);
                                        corn2_lon_str = std::to_string(loncornBox[1][i]);
                                        corn2_lat_str = std::to_string(latcornBox[1][i]);
                                        corn3_lon_str = std::to_string(loncornBox[2][i]);
                                        corn3_lat_str = std::to_string(latcornBox[2][i]);
                                        corn4_lon_str = std::to_string(loncornBox[3][i]);
                                        corn4_lat_str = std::to_string(latcornBox[3][i]);
                                        gridstr = "POLYGON((" + corn1_lon_str + " " + corn1_lat_str + "," + corn2_lon_str + " " + corn2_lat_str + "," + corn3_lon_str + " " + corn3_lat_str + "," + corn4_lon_str + " " + corn4_lat_str + "," + corn1_lon_str + " " + corn1_lat_str + "))";
                                        bg::read_wkt(gridstr, gridPoly);
                                         cout<<"gridpoly created"<<endl;
                                        ingeom = within(pixelPoly, gridPoly);
                                        binAreagrid = bg::area(gridPoly);
                                        binAreapix = bg::area(pixelPoly);//                             
                                        cout<<"gridcell#.."<<i<<"fully inside????.."<<ingeom<<"binAreagrid..."<<binAreagrid<<"binAreapix..."<<binAreapix<<endl;         
 
 
 
 
                                  //compute intersections-----
         //                             areabinBox[1][0]= binAreagrid;
                                        intersectArea = 0., pc = 1;
                                        if (ingeom > 0) { //pixel fully inside the grid cell
                                        
                                            intersectArea = binAreapix;
                                       
                                            if (Lt_pix[0][pix] > 0.) {
                                                Ltfracsum[gd_row][gd_col] += Lt_pix[0][pix] * (intersectArea / binAreagrid);
                                                areabinsum[gd_row][gd_col] += (intersectArea / binAreagrid);
                                                nobs_perbin[gd_row][gd_col] += 1;
                                            }
 
                                        }
                                        else {
                                            if (!bg::disjoint(pixelPoly, gridPoly) && binAreagrid > 0) {
                                                std::deque<Polygon_t> output;//this is a list
                                                if (bg::intersection(pixelPoly, gridPoly, output)) {
                                                    BOOST_FOREACH(Polygon_t const& p, output)
                                                    {
                                                        intersectArea = bg::area(p);
                                                        if (intersectArea > 0.0 && pc == 1) {
                                        
                                                            if (Lt_pix[0][pix] > 0.) {
                                                                Ltfracsum[gd_row][gd_col] += Lt_pix[0][pix] * (intersectArea / binAreagrid);
                                                                areabinsum[gd_row][gd_col] += (intersectArea / binAreagrid);
                                                                //   nobs_perbin[gd_row][gd_col]+=1;
                                                            }
 
 
                                                            if (intersectArea / binAreagrid < 0.000001)  Ltfracsum[gd_row][gd_col] += 0.;
                                                            pc++;
                                                        }
                                                    }
                                                }
                                            }
                                        }//end else
 
 
                                    }//end for
 
                                    delete [](latcornBox);
                                    delete [](loncornBox);
                                    latcornBox = nullptr;
                                    loncornBox = nullptr;
                                }//end gdrow gdcol
                                //***************************************************
                                                        //    exit(1);
                            }//end if flaf_inpix
 
                            //********** pixel AREA WEIGHTING ************************
                            if (flag_inpix == 0) outpix++;
                            totpix++;
 
                        }//end pixels loop
 
                        //END OF FILE--****** reset starting sline index if last line processed and within k box
                        //go for another granule if it is not the last one---------------
                        if (sline == num_scans - 1) {
                            flag_donefile = 1;
                            cout << "end of file..." << l1cfile->selgran[findex] << endl;
                            last_sline = 0;
                            if (findex >= sfiles - 1) {
                                cout << "done with last granule of the input list........................." << endl;
                                k = ngroups;
                                break;
                            }
 
                        }//end of file/last file? sliine=num_scans-1
                        else flag_donefile = 0;
 
                    }//end latpix nadir of line x inside grid group?
 
         //***** skip lines and files if sline is not within k group ********
              //increase k and screen files and lines again starting from the last binning
 
                    if (latpix[nadpix] > lat_gd[n_gdlines - 1][257] && k < ngroups - 1) { //else limits 
                        cout << "moving to the next k group...scanning again files/slines.." << endl;
                        cout << "file index.." << findex << "last sline index.." << sline << endl;
                        last_file = findex;
                        last_sline = sline;
                        findex = sfiles;
                        sline = num_scans - 1;
                    }//end if lat >grid lat--IF outside the box
 
                    if (sline + 1 % 100 == 0) cout << "for k group.." << k + 1 << "selected granule #.." << l1cfile->selgran[findex] << "sline..." << sline + 1 << "# of binned pix.." << inpix << "totpix.." << totpix << "outpix.." << outpix << endl;
                    cout << "sline.." << sline + 1 << endl;
 
 
                    //       exit(1);
 
                }//end for scanlines
 
                cout << "closing L1B file......." << ptstr << endl;
                status = nc_close(ncid_L1B);
                check_err(status, __LINE__, __FILE__);
 
                delete [](latpix);
                delete [](lonpix);
                delete [](latpix2);
                delete [](lonpix2);
                delete [](Lt_pix);
                delete [](Lt_pix2);
                delete [](Lt_pix3);
 
 
 
                //writing each granule ---------------------------------
                if (flag_donefile == 1 || (flag_donefile == 0 && k == ngroups - 1)) { //if file completed and last group to be processed
                    cout << "writing file #.............................................." << l1cfile->selgran[findex] << "based on group #.." << k + 1 << endl;
                    //write mean Lt as nc file---
                   //**********************************************************************
                   //**********************************************************************8
                   //create Lt file
                    pathstr = "out/";
                    senstr = "OCIS_";
                    monstr = std::to_string(selmon);
                    daystr = std::to_string(selday);
                    yearstr = std::to_string(selyear);
                    prodstr = "binLt_aw";
                    swtstr = "_swt";
                    granstr = "";
                    granstr = "_" + std::to_string(l1cfile->selgran[findex]);
 
                    if (l1cfile->l1c_pflag >= 3) {
                        swtd = l1cfile->swtnum;
                        swtnum = std::to_string(swtd);
                        cout << "swtnum.." << swtnum << endl;
                    }
                    else swtnum = std::to_string(swtd);
                    extstr = ".nc";
                    NDIMS = 2;
                    fname_out = pathstr + senstr + monstr + daystr + yearstr + prodstr + swtstr + swtnum + granstr + extstr;
                    filename_lt = fname_out.c_str();
                    if ((status = nc_create(filename_lt, NC_CLOBBER, &ncid_out)))
                        check_err(status, __LINE__, __FILE__);
                    //define dims
                    // Define the dimensions. NetCDF will hand back an ID for each. 
                    NY = num_gridlines;
                    NX = nbinx;
                    NY1 = l1cfile->NY1;//these are indexes not line #!!!!!!!!!!!!!!!!!
                    NY2 = l1cfile->NY2;
                    cout << "rowgrid ini.." << NY1 << "rowgrid end.." << NY2 << endl;
                    NY = NY2 - NY1 + 1;
                    cout << "NY.." << NY << "NX.." << NX << endl;
                    //alloc mem for data_out and assign values from lat_gdI
                    //NX AND NY are inverted for visualization in SeaDAS
               //     data_out = allocate2d_float(NY,NX);
               //     data_out2 = allocate2d_float(NY,NX);
               //     data_out3 = allocate2d_float(NY,NX);
               //     data_out4 = allocate2d_float(NY,NX);
               //     data_out5 = allocate2d_float(NY,NX);
               //     data_out6 = allocate2d_float(NY,NX);
                    lat_out = allocate2d_float(NY, NX);
                    lon_out = allocate2d_float(NY, NX);
 
                    int c = 0;
                    for (int i = NY1; i < NY2 + 1; i++) {
                        for (int j = 0; j < NX; j++) {
                            lat_out[NY - 1 - c][NX - 1 - j] = lat_gd[i][j];
                            lon_out[NY - 1 - c][j] = lon_gd[i][j];
                            //blue
                                         //         if (nobs_perbin[i][j]>0)
                                         //           data_out[NY-1-c][NX-1-j]=Ltfracsum[i][j]/areabinsum[i][j];
                                         //         else
                                         //           data_out[NY-1-c][NX-1-j]=NAN;
                            //blue      
                                         /*         if (nobs_perbin[i][j]>0)
                                                    data_out3[NY-1-c][NX-1-j]=areabinsum[i][j];
                                                  else
                                                    data_out3[NY-1-c][NX-1-j]=NAN;*/
 
 
                                                    //swir
 
                                                                    /*      if (bincount3[i][j]>0)
                                                                              data_out5[NY-1-c][NX-1-j]=binmean_Lt3[i][j]/bincount3[i][j];
                                                                          else
                                                                              data_out5[NY-1-c][NX-1-j]=NAN;
                                                                     */
 
                                                                     //nobs pointers
                                                                     //         data_out2[NY-1-c][NX-1-j]=nobs_perbin[i][j];
                                                                     //        data_out4[NY-1-c][NX-1-j]=bincount2[i][j];
                                                                     //        data_out6[NY-1-c][NX-1-j]=bincount3[i][j];
                        }
                        c++;
                    }
 
 
 
                    if ((status = nc_def_dim(ncid_out, "x", NX, &x_dimid)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_dim(ncid_out, "y", NY, &y_dimid)))
                        check_err(status, __LINE__, __FILE__);
                    //dims for output var
                    dimids[0] = y_dimid;
                    dimids[1] = x_dimid;
                    //def var
                    //blue
                    if ((status = nc_def_var(ncid_out, "binLt_blue", NC_FLOAT, NDIMS,
                        dimids, &varid)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_var(ncid_out, "bincount_blue", NC_FLOAT, NDIMS,
                        dimids, &varid4)))
                        check_err(status, __LINE__, __FILE__);
                    //red 
                    if ((status = nc_def_var(ncid_out, "binLt_red", NC_FLOAT, NDIMS,
                        dimids, &varid5)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_var(ncid_out, "bincount_red", NC_FLOAT, NDIMS,
                        dimids, &varid6)))
                        check_err(status, __LINE__, __FILE__);
                    //swir
                    if ((status = nc_def_var(ncid_out, "binLt_swir", NC_FLOAT, NDIMS,
                        dimids, &varid7)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_var(ncid_out, "bincount_swir", NC_FLOAT, NDIMS,
                        dimids, &varid8)))
                        check_err(status, __LINE__, __FILE__);
                    //lat/lon
                    if ((status = nc_def_var(ncid_out, "lat_gd", NC_FLOAT, NDIMS,
                        dimids, &varid2)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_var(ncid_out, "lon_gd", NC_FLOAT, NDIMS,
                        dimids, &varid3)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_enddef(ncid_out))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
                    //writing the whole thing
                    if ((status = nc_put_var_float(ncid_out, varid2, &lat_out[0][0])))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_put_var_float(ncid_out, varid3, &lon_out[0][0])))
                        check_err(status, __LINE__, __FILE__);
 
                    //blue
                       /*
                          if ((status = nc_put_var_float(ncid_out, varid, &data_out[0][0])))
                              check_err(status, __LINE__, __FILE__);
                          if ((status = nc_put_var_float(ncid_out, varid4, &data_out2[0][0])))
                              check_err(status, __LINE__, __FILE__);
                       */
                       //red
                       //   if ((status = nc_put_var_float(ncid_out, varid5, &data_out3[0][0])))
                       //       check_err(status, __LINE__, __FILE__);
           /*
                          if ((status = nc_put_var_float(ncid_out, varid6, &data_out4[0][0])))
                                check_err(status, __LINE__, __FILE__);
                       //swir
                          if ((status = nc_put_var_float(ncid_out, varid7, &data_out5[0][0])))
                                check_err(status, __LINE__, __FILE__);
                          if ((status = nc_put_var_float(ncid_out, varid8, &data_out6[0][0])))
                                check_err(status, __LINE__, __FILE__);
           */
 
                    if ((status = nc_close(ncid_out)))
                        check_err(status, __LINE__, __FILE__);
 
                    delete[](lat_out);
                    delete[](lon_out);
 
                    //    delete [] (data_out);
                    //    delete [] (data_out2);
                    //    delete [] (data_out3);
 
         /*               delete [] (data_out4);
                        delete [] (data_out5);
                        delete [] (data_out6);
 
                        delete [] (bincount);
                        delete [] (binmean_Lt);
                        delete [] (bincount2);
                        delete [] (binmean_Lt2);
                        delete [] (bincount3);
                        delete [] (binmean_Lt3);
                     */
 
                    delete[](Ltfracsum);
                    delete[](areabinsum);
                    delete[](nobs_perbin);
 
 
                    lat_out = nullptr;;
                    lon_out = nullptr;
                    //    data_out=nullptr;
                    //    data_out2=nullptr;
                    //    data_out3=nullptr;
 
            /*            data_out4=nullptr;
                        data_out5=nullptr;
                        data_out6=nullptr;
 
                        bincount=nullptr;
                        binmean_Lt=nullptr;
                        bincount2=nullptr;
                        binmean_Lt2=nullptr;
                        bincount3=nullptr;
                        binmean_Lt3=nullptr;
                      */
 
                    Ltfracsum = nullptr;
                    areabinsum = nullptr;
                    nobs_perbin = nullptr;
 
                    flag_donefile = 0;
                }//end writing file
            }//end for files
 
            cout << "group k at the end of big loop" << k + 1 << endl;
 
        }//groups
 
        cout << "number of files per swath.." << nfiles_swt[swtd - 1] << "for swath.." << swtd << endl;
        cout << "total inpix.." << inpix << "total pix.." << totpix << endl;
 
        delete [](dlatb_g);
        delete [](dlonb_g);
        delete [](lat_asort);
        delete [](index_xy);
        delete [](az_east);
        delete [](lat_gd);
        delete [](lon_gd);
 
 
        printf("*** SUCCESS writing AW bincount and binLt rasters as nc..!\n");
 
        return(0);
    }
 
 
 
 
 
 
    //similar to w2 version byt hyperspectral-including FRED search L1C row/col algo
    int32_t L1C::binL1C_wgranule4(int swtd, l1c_filehandle* l1cfile, L1C_input* l1cinput, int16_t* swtd_id, int16_t* odir, int16_t* file_id, int16_t* nfiles_swt) {
        int32_t gdlines_group,ngroups = 0, num_gridlines, nbinx, n_files, inpix = 0, outpix = 0, totpix = 0, n_gdlines;//number of gridlines to be processed
        float minv = 0., maxv = 0.;
        int16_t fi = 0;
        std::string str;
        const char* ptstr;
        int dimid, status, ncid_out, x_dimid, y_dimid, varid, varid2, varid3,NDIMS;
        size_t start[] = { 0, 0 };
        size_t count[] = { 1, 1 };
        size_t start2[] = { 0, 0, 0 };
        size_t count2[] = { 1, 1, 1 }, count3[] = { 1, 1, 1 }, count4[] = { 1, 1, 1 };
        int32_t bin_xpix, bin_ypix;
        float* latpix, * lonpix, ** Lt_pix, ** Lt_pix2, ** Lt_pix3;
     
        float latmin_swt = 100, latmax_swt = 0, lonmin_swt = 0, lonmax_swt = 0;
        int dimids[2];
        const char* filename_lt;
        int32_t NY = -1, NX = -1, NY1 = -1, NY2 = -1, c1 = 1;
        float** data_out, ** data_out2, ** data_out3,  ** lat_out, ** lon_out;
     
        int last_file, last_sline, flag_inpix,flag_donefile;;//first index file id, second index line #
        short** index_xy;
        float** lat_asort;
        bool boolbin1=0;
        int16_t selyear = -1, selmon = -1, selday = -1;
        float** lat_gd, ** lon_gd, * az_east;
        string gridname, azeast_name;
        float*** bincount = NULL, *** bincount2 = NULL, *** bincount3 = NULL, *** binmean_Lt = nullptr, *** binmean_Lt2 = nullptr, *** binmean_Lt3 = nullptr;
        double gres = (l1cinput->gres) * 1000, dlamin, dlamax, dlomin, dlomax;
        int grp_root, grp_blue, grp_red, grp_swir, grp_coor, scGrp;
        unsigned int bb = 0, rb = 0, swb = 0;
        float lon_eqc = -1;
        double time_eqc = -1, toffset_pix = -999.;
        short Nneg = -1;
        unsigned int sline;
        float **dlonb_g,**dlatb_g;
 
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
     
 
 
     //random seed
        srand((unsigned int)time(NULL));
        //nadir pixel ofr OCI
        int nadpix = l1cfile->nadpix;
 
 
        num_gridlines = 4000;
 
        nbinx = l1cfile->nbinx;
        num_pixels = l1cfile->npix;
        n_files = l1cfile->ifiles.size();
        size_t sfiles = 0;
 
        if (l1cfile->selgran[0] < 0)//process all granules
        {
            sfiles = nfiles_swt[swtd - 1];
            for (unsigned int j = 0;j < sfiles;j++) l1cfile->selgran[j] = j + 1;
        }
        else {
            while (l1cfile->selgran[sfiles] > 0) {
                cout << "selected granule #..........................." << l1cfile->selgran[sfiles] << endl;
                sfiles++;
            }
        }
 
 
 
 
        //determine crossing time of the swath
        cout << "nfiles.for the swath." << n_files << endl;
        for (int i = 0;i < n_files;i++) {
            str = l1cfile->ifiles[i];
            ptstr = str.c_str();
            cout << "checking crossing time for file...." << ptstr << endl;
 
            //computation of equatorial crossing time
            if (status = ect_sf(ptstr, l1cfile,l1cinput) > 1) {
                cout << "problems checking crossing time...for file.." << ptstr << endl;
                exit(1);            
}
 
            if (l1cfile->orbit_node_lon > -999. | l1cfile->eqt > 0.) {
                lon_eqc = l1cfile->orbit_node_lon;
                time_eqc = l1cfile->eqt;
                break;
            }
        }
 
        cout << "time equat crossing..." << time_eqc << "longitude at crossing time..." << lon_eqc << endl;
 
 
        // exit(1);
 
 
 
 
 
        //allocate mem for lat/lon/azeast pointers---
        selday = l1cinput->selday;
        selmon = l1cinput->selmon;
        selyear = l1cinput->selyear;
 
        std::string fname_out, pathstr, senstr, monstr, daystr, yearstr, prodstr, gdstr, swtstr, swtnum, extstr, granstr;
 
        pathstr = "out/";
        senstr = "OCIS_";
        monstr = std::to_string(selmon);
        daystr = std::to_string(selday);
        yearstr = std::to_string(selyear);
        prodstr = "L1Cgrid";
        swtstr = "_swt";
        extstr = ".csv";
 
        if (l1cfile->l1c_pflag >= 3) {
            swtd = l1cfile->swtnum;
            swtnum = std::to_string(swtd);
            cout << "swtnum.." << swtnum << endl;
        }
        else swtnum = std::to_string(swtd);
 
        gridname = pathstr + senstr + monstr + daystr + yearstr + prodstr + swtstr + swtnum + extstr;
 
        prodstr = "az_east";
        azeast_name = pathstr + senstr + monstr + daystr + yearstr + prodstr + swtstr + swtnum + extstr;
        cout << "gridname.." << gridname << "azeast-name.." << azeast_name << endl;
 
        //************ OPENING **************************************
        //*** AZ_EAST *****************
        //*** AZ_EAST *****************
        std::string line;
        stringstream ss;
        std::string temp;
        std::vector<std::string> parts;
        ifstream fin(azeast_name);
        int cline = 0;
        while (getline(fin, line))
        {
            // load line in stringstream
            ss << line;
            getline(ss, temp, ',');
            parts.push_back(temp);
            ss.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            ss.clear();
            cline++;
        }
        //minus -1 cause the header
        cout << "size of azeast minus heading row..= num_gridlines." << parts.size() - 1 << "nbinx.." << nbinx << endl;
        num_gridlines = parts.size() - 1;
 
 
        //**LAT_GD *******************
        ifstream fin2(gridname);
        std::vector<std::string> tokens_lon, tokens_lat;
        std::string token;
        cline = 0;
        int fcol = 0;
        while (getline(fin2, line))
        {
            // load line in stringstream
            istringstream iss(line);
            while (getline(iss, token, ','))
            {
                cline++;
                if (fcol == 0 && cline > 2) {
                    tokens_lon.push_back(token);fcol++;                
}
                else if (fcol == 1 && cline > 2)
                    tokens_lat.push_back(token);
 
            }
            fcol = 0;
        }
 
 
     
 
        cout << "size of gridline minus heading row..= num_gridlines." << (tokens_lon.size() - 1) / nbinx << "nbinx.." << nbinx << endl;
 
 
        //************************************************************
        //mem allocation for geolcoation pointers---
        az_east = (float*)malloc(num_gridlines * sizeof(float));
        lat_gd = allocate2d_float(num_gridlines, nbinx);
        lon_gd = allocate2d_float(num_gridlines, nbinx);
 
        float sum = 0, tot = 0;
        for (int j = 0;j < num_gridlines;j++) {
            //     cout<<"j.."<<j<<"az_east"<<std::stof(parts[j+1])<<endl;
            az_east[j] = std::stof(parts[j + 1]);//first line is the header
            sum = az_east[j];
            tot += sum;
        }
        parts.clear();
 
 
 
        //using swath-averaged az_east for nadir pixels rather than along-track az_east pixel-by-pixel
        float mean_az_east = tot / (num_gridlines - 1);
        cout << "mean_az_east..." << mean_az_east << "numgridlines.." << num_gridlines << endl;
        //   exit(1); 
        for (int j = 0;j < num_gridlines;j++) {
            az_east[j] = mean_az_east;
        }
        int ip = 0;
        for (int j = 0;j < num_gridlines;j++) {
            for (int k = 0;k < nbinx;k++) {
                lat_gd[j][k] = std::stof(tokens_lat[ip]);
                lon_gd[j][k] = std::stof(tokens_lon[ip]);
                //   if(ip % nbinx == 0) cout<<"ip.."<<ip<<"gdline.."<<j+1<<"binx.."<<k+1<<"latgd.."<<std::stof(tokens_lat[ip])<<"longd.."<<std::stof(tokens_lon[ip])<<endl;
                ip++;
 
                //compute Nneg
                if (odir[0] > 0 && lat_gd[j][k] > 0 && Nneg < 0) {//ascending orbit                
                    if (k > 0) Nneg = j + 1;
                    else Nneg = j;
                    cout << "number of lines with negative latitude...." << Nneg << "for orbit direction..." << odir[0] << "latitude..." << lat_gd[j][k] << endl;
                    //    exit(1);
                }
 
            }
        }
        tokens_lon.clear();
        tokens_lat.clear();
 
        //determine # of gd groups to be processede  
        //gdlines_group=num_gridlines;//ONE BIG GROUP
        gdlines_group = 250;
 
        if (num_gridlines <= gdlines_group) {
            gdlines_group = num_gridlines;
            cout << "WARNING********************* number_gridlines<=gdlines_group THEN gdlines_group=num_gridlines **************" << endl;
        }
 
        ngroups = floor(num_gridlines / gdlines_group);
        cout << "TOTAL # of gd groups.(ALL LATs...." << ngroups << endl;
 
        //--NORMALIZED  gridline longitude is -180 to 180 degrees before comparison with longitude extracted from image pixels---
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lon_gd[i][j] < -180.)lon_gd[i][j] += 360.;
                if (lon_gd[i][j] > 180.)lon_gd[i][j] -= 360.;
            }        
}
        //get min/max lat/lon of the swath
        // Assume first element as maximum and minimum
        maxv = lat_gd[0][0];
        minv = lat_gd[0][0];
 
        //Find maximum and minimum in all array elements.
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lat_gd[i][j] > maxv)
                    maxv = lat_gd[i][j];
                if (lat_gd[i][j] < minv)
                    minv = lat_gd[i][j];
            }        
}
 
 
        maxv = lon_gd[0][0];
        minv = lon_gd[0][0];
        //Find maximum and minimum in all array elements.
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lon_gd[i][j] > maxv)
                    maxv = lon_gd[i][j];
                if (lon_gd[i][j] < minv)
                    minv = lon_gd[i][j];
            }
        }
 
 
 
        cout << "swath #.." << swtd << endl;
 
        //check lat bound min/max of each gd group---
        int k = 0, i = 0;
 
        dlatb_g = allocate2d_float(ngroups + 1, 2);
        dlonb_g = allocate2d_float(ngroups + 1, 2);
 
        //recompute number of gridlines based on lat limits -80 to 80 degrees  
       //asc orbit goes from negative to positive latitude....
        NY = num_gridlines;
        NX = nbinx;
        for (int i = 0; i < NY; i++) {
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= -80.) c1++;
                if (c1 == nbinx) {
                    NY1 = i;
                }
            }
            if (NY1 >= 0) break;
            c1 = 1;
        }
 
 
        for (int i = 0;i < NY; i++) {
            //   cout<<"i.."<<i<<"lat_gd[i][j]..."<<lat_gd[i][nadpix]<<endl;
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= 80.) {
                    NY2 = i - 1;
                }
            }
 
            if (NY2 >= 0) break;
        }
 
        // cout<<"gridlines limited to -80 to 80 degrees of latitutde.."<<"gdline ini.."<<NY1<<"gdline end.."<<NY2<<endl;
 
        l1cfile->NY1 = NY1;
        l1cfile->NY2 = NY2;
 
        cout << "NY.." << NY << "NY1.." << NY1 << "NY2.." << NY2 << endl;
 
 
 
        num_gridlines = NY2 - NY1 + 1;//this is the # gridlines after -80 to 80 lat constraint---
        ngroups = floor(num_gridlines / gdlines_group);
        cout << "gdlines will start in gline.." << i + 1 << "ROUNDED ngroups after adjusting beginning.for constraint lat (-80 to 80)" << ngroups << endl;
 
        //for each 'grid' group scan the swath files to see if there are scanlines within--
        //if that is case check the across-bin number position (0 to binx-1) based on latnad and lonnad values--- 
        last_file = 0;
        last_sline = 0;
        flag_donefile = 0;
 
        num_blue_bands = 120;
        num_red_bands = 120;
        num_SWIR_bands = 9;
 
        if (num_gridlines > ngroups * gdlines_group) ngroups += 1;
 
 
        //*********** SORTING LAT/LON ASCENDING AND TRACK INDEXES ****************************
        //***********************************************************************************
 
        //Create index matrix for i and j of each lat and lon L1C grid (-80 to 80)
        //num_gridlines x nbinx
        index_xy = allocate2d_short(num_gridlines, nbinx);
        lat_asort = allocate2d_float(num_gridlines, nbinx);
        //  lon_asort=allocate2d_float(num_gridlines,nbinx);
             //fill indexe
 
        //define 1-D vector to sort 1 col L1C grid at the time---
        vector<pair<float, int> > vp;
 
        //fill vector with lat_gd column--
        cout << "*********** SORTING LAT/LON GRIDPOINTS AND TRACKING INDEXES ********************" << endl;
 
        for (int col = 0;col < nbinx;col++) {
            for (int row = NY1;row < NY2 + 1;row++) {
                vp.push_back(make_pair(lat_gd[row][col] + 90., row));
            }
            //sort 
            stable_sort(vp.begin(), vp.end());
            //display lat in order along with its gridpoint index--
              //   cout << "Lat value\t"
              //         << "index" << endl; 
            for (unsigned int i = 0; i < vp.size(); i++) {
                lat_asort[i][col] = vp[i].first;
                index_xy[i][col] = vp[i].second;
            }
            vp.clear();
        }
 
        //saddleback search
        short gd_row, gd_col;
 
        cout << "num_gridlines...." << num_gridlines << "ngroups.." << ngroups << endl;
 
 
        //****************************************************************************************************
           //************* BIG LOOP GROUPS ***************************************
        cout << "Number of granules to be L1C processed........................................." << sfiles << endl;
 
        for (k = 0;k < ngroups;k++) {
 
            //total gridlines for k groups-----
            n_gdlines = (k + 1) * gdlines_group;
            cout << "screening k group.." << k + 1 << "last_file.." << last_file << "last_line.." << last_sline << endl;
            cout << "number of gridlines so far..." << n_gdlines << endl;
            //***** compute deltas for lat_gd index 256 and 257 *******************
 
             //compute delta_lat and delta_lon based on binres/2 for lower and upper corners of 'nadir' gridpoints of 256 and 257 indexes -----------------
               //we need nadir 256 and 257 lat/lon coordinates to compute -delta and +delta, respectively
               //we need azimuth and backazimuth and binres/2 to compute deltas ---
 
                //index 256
            geod.Direct(lat_gd[n_gdlines - gdlines_group][256], lon_gd[n_gdlines - gdlines_group][256], az_east[n_gdlines - gdlines_group], gres, dlamin, dlomin);
            geod.Direct(lat_gd[n_gdlines - 1][257], lon_gd[n_gdlines - 1][257], az_east[n_gdlines - 1], gres, dlamax, dlomax);
 
            cout << "dlamin.." << dlamin << "dlomin.." << dlomin << "dlamax.." << dlamax << "dlomax.." << dlomax << endl;
 
            dlatb_g[k][0] = dlamin;//in DEGREES!!
            dlatb_g[k][1] = dlamax;
            dlonb_g[k][0] = dlomin;
            dlonb_g[k][1] = dlomax;
 
            //********* LOOP FILES ************************************
            for (unsigned int findex = last_file;findex < sfiles;findex++) {
 
                cout << "Scanning lines in file.. for crossing swath..." << swtd << "selected granule #.." << l1cfile->selgran[findex] << "swt_id.." << swtd_id[findex] << "grid group.." << k + 1 << endl;
 
 
                if (last_sline == 0 && binmean_Lt == nullptr && binmean_Lt2 == nullptr && binmean_Lt3 == nullptr) { // binmean_Lt==NULL | bincount==NULL | binmean_Lt2==NULL | bincount2==NULL | binmean_Lt3==NULL | bincount3==NULL){
 
                    cout << "first allocation of memory for grid bins of file #..." << l1cfile->selgran[findex] << endl;
 
                    //            cout<<"findex.."<<findex<<"blue bands"<<num_blue_bands<<"red bands.."<<num_red_bands<<"swir bands..."<<num_SWIR_bands<<"nbinx.."<<nbinx<<endl;
 
                    binmean_Lt = allocate3d_float(num_blue_bands, num_gridlines, nbinx);
                    bincount = allocate3d_float(num_blue_bands, num_gridlines, nbinx);
                    binmean_Lt2 = allocate3d_float(num_red_bands, num_gridlines, nbinx);
                    bincount2 = allocate3d_float(num_red_bands, num_gridlines, nbinx);
                    binmean_Lt3 = allocate3d_float(num_SWIR_bands, num_gridlines, nbinx);
                    bincount3 = allocate3d_float(num_SWIR_bands, num_gridlines, nbinx);
 
                    for (unsigned int k = 0;k < num_blue_bands;k++) {
                        for (int i = 0; i < num_gridlines; i++) {
                            for (int j = 0; j < nbinx; j++) {
                                bincount[k][i][j] = 0.;
                                binmean_Lt[k][i][j] = 0.;
                            }                        
}                    
}
 
                    for (unsigned int k = 0;k < num_red_bands;k++) {
                        for (int i = 0; i < num_gridlines; i++) {
                            for (int j = 0; j < nbinx; j++) {
                                bincount2[k][i][j] = 0.;
                                binmean_Lt2[k][i][j] = 0.;
                            }                        
}                    
}
 
                    for (unsigned int k = 0;k < num_SWIR_bands;k++) {
                        for (int i = 0; i < num_gridlines; i++) {
                            for (int j = 0; j < nbinx; j++) {
                                bincount3[k][i][j] = 0.;
                                binmean_Lt3[k][i][j] = 0.;
                            }                        
}                    
}
                }//end allocating bin arrays
 
 
                fi = l1cfile->selgran[findex];
                str = l1cfile->ifiles[fi - 1];
                ptstr = str.c_str();
 
                cout << "opening filename............" << ptstr << endl;
 
                status = nc_open(ptstr, NC_NOWRITE, &ncid_L1B);
                if (status != NC_NOERR) {
                 fprintf(stderr, "nc_open.\n");
                    exit(EXIT_FAILURE);
}
                //Open dimensions
                status = nc_inq_dimid(ncid_L1B, "number_of_scans", &dimid);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading number_of_scans.\n");
                    exit(EXIT_FAILURE);
                }
                nc_inq_dimlen(ncid_L1B, dimid, &num_scans);
 
                //read line-by-line lat/lon/Lt
                status = nc_inq_grp_ncid(ncid_L1B, "geolocation_data", &geoGrp);
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_grp_ncid(ncid_L1B, "observation_data", &obsGrp);
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_grp_ncid(ncid_L1B, "scan_line_attributes", &scGrp);
                check_err(status, __LINE__, __FILE__);
 
                //open time
                status = nc_inq_varid(scGrp, "time", &otId);
                check_err(status, __LINE__, __FILE__);
                //open geo data 
                status = nc_inq_varid(geoGrp, "latitude", &latId);//scans x velements
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(geoGrp, "longitude", &lonId);//scans x velements
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(obsGrp, "Lt_blue", &Lt_blueId);
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(obsGrp, "Lt_red", &Lt_redId);
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(obsGrp, "Lt_SWIR", &Lt_SWIRId);
                check_err(status, __LINE__, __FILE__);
 
                // num_blue_bands
                status = nc_inq_dimid(ncid_L1B, "blue_bands", &dimid);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading num_blue_bands.\n");
                    exit(EXIT_FAILURE);
                }
                nc_inq_dimlen(ncid_L1B, dimid, &num_blue_bands);
 
                // num_red_bands
                status = nc_inq_dimid(ncid_L1B, "red_bands", &dimid);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading num_red_bands.\n");
                    exit(EXIT_FAILURE);
                }
                nc_inq_dimlen(ncid_L1B, dimid, &num_red_bands);
 
                // num_SWIR_bands
                status = nc_inq_dimid(ncid_L1B, "SWIR_bands", &dimid);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading num_SWIR_bands.\n");
                    exit(EXIT_FAILURE);
                }
                nc_inq_dimlen(ncid_L1B, dimid, &num_SWIR_bands);
                //assigning mem for Lt of different bands **********************
 
                double* orb_time = new double[num_scans]();
                status = nc_get_var_double(scGrp, otId, orb_time);
 
                /*         for(int s=0;s<num_scans;s++)
                              cout<<"orb time..."<<orb_time[s]<<"for scanline..."<<s+1<<endl;
                         exit(1);
             */
 
 
                latpix = (float*)malloc(num_pixels * sizeof(float));
                lonpix = (float*)malloc(num_pixels * sizeof(float));
                Lt_pix = allocate2d_float(num_blue_bands, num_pixels);//blue bands
                Lt_pix2 = allocate2d_float(num_red_bands, num_pixels);//red bands
                Lt_pix3 = allocate2d_float(num_SWIR_bands, num_pixels);//SWIR bands
 
                cout << "#blue bands.." << num_blue_bands << endl;
                cout << "#red bands.." << num_red_bands << endl;
                cout << "#swir bands.." << num_SWIR_bands << endl;
                //********************************************************************************
                 //-----reading line by line-----------------------------------           
                for (sline = last_sline;sline < num_scans;sline++) {
 
 
                    //compute time offset for each pixel of that line--assuming all pixels across-track have the same nadir time (along-track)
                    toffset_pix = orb_time[sline] - time_eqc;
 
 
 
                    //lat and lon--
                    start[0] = sline;
                    start[1] = 0;
                    count[0] = 1;
                    count[1] = num_pixels;               // 1 line at a time
 
                    status = nc_get_vara_float(geoGrp, latId, start, count, latpix);
                    status = nc_get_vara_float(geoGrp, lonId, start, count, lonpix);
 
                    //****************************blue bands *********************************************************************
                           //loop blue bands------------    
                    //*************************************************************************************************************
                                 //Lt
 
                    start2[0] = 0;
                    start2[1] = sline;
                    start2[2] = 0;
 
                    count2[0] = num_blue_bands;
                    count2[1] = 1;               // 1 line at a time
                    count2[2] = num_pixels;
 
                    count3[0] = num_red_bands;
                    count3[1] = 1;               // 1 line at a time
                    count3[2] = num_pixels;
 
                    count4[0] = num_SWIR_bands;
                    count4[1] = 1;               // 1 line at a time
                    count4[2] = num_pixels;
 
                    status = nc_get_vara_float(obsGrp, Lt_blueId, start2, count2, Lt_pix[0]);
                    status = nc_get_vara_float(obsGrp, Lt_redId, start2, count3, Lt_pix2[0]);
                    status = nc_get_vara_float(obsGrp, Lt_SWIRId, start2, count4, Lt_pix3[0]);
 
                    /*      for(int bb=0;bb<num_blue_bands;bb++){
                               cout<<"processing blue band #.........................................................................."<<bb+1<<"of total blue bands #.."<<num_blue_bands<<endl;
                               cout<<"Lt_pix at pix =0..."<<Lt_pix[bb][0]<<"Lt_pix at pix =1..."<<Lt_pix[bb][1]<<endl;
                              }
                           exit(1);
                   */
 
                    for (unsigned int pix = 0;pix < num_pixels;pix++) {
                        if (latpix[pix] < latmin_swt) latmin_swt = latpix[pix];
                        if (latpix[pix] > latmax_swt) latmax_swt = latpix[pix];
                        if (lonpix[pix] < lonmin_swt) lonmin_swt = lonpix[pix];
                        if (lonpix[pix] > lonmax_swt) lonmax_swt = lonpix[pix];
                    }
 
                    //cout<<"latpix[nadpix]..."<<latpix[nadpix]<<"lonpix[nadpix]..."<<lonpix[nadpix]<<endl;         
                   //   cout<<"dlatb_g[k][0]...."<<dlatb_g[k][0]<<"dlatb_g[k][1]...."<<dlatb_g[k][1]<<endl;
 
                    dlamin = 0.;dlamax = 0.;
 
 
                    //inside the 'k' box??----- ascending ----------
                    if (latpix[nadpix] >= dlatb_g[k][0] && latpix[nadpix] <= dlatb_g[k][1]) {
 
                        if (sline % 100 == 0) cout << "EVERY 100 gds..for k group.." << k + 1 << "file number #.." << l1cfile->selgran[findex] << "sline..." << sline + 1 << "# of binned pix.." << inpix << "outpix.." << outpix << endl;
 
                        //*********** BIG LOOP M_PIXEL *****************************************************************
                        for (unsigned int pix = 0;pix < num_pixels;pix++) {
 
                            bb = 0, rb = 0, swb = 0;
                           flag_inpix = 0, bin_xpix = -1, bin_ypix = -1;
 
                            //           cout<<"LINE NUMBER------------------------------------------------------------------------------------------------------------------------#"<<sline+1<<"pix #........"<<pix+1<<endl;
                            search_rc_l1c(l1cinput, l1cfile, latpix[pix], lonpix[pix], toffset_pix, lon_eqc, &gd_row, &gd_col, Nneg);
 
                            //      boolbin1=sbs2_l1c(l1cinput,num_gridlines,nbinx,lat_asort,index_xy,latpix[pix],lonpix[pix],lon_gd,&gd_row, &gd_col);
                            if(gd_row>=0 && gd_col>=0) boolbin1=1;
 
                            bin_ypix = gd_row + 1;
                            bin_xpix = gd_col + 1;
 
                            //                   cout<<"pix..."<<pix+1<<"latpix..."<<latpix[pix]<<"lonpix..."<<lonpix[pix]<<endl;
 
                            if (boolbin1 == 1) flag_inpix = 1;
                            //************ BINNING ***************************
                         //assign identified pixel to Lt and bin stat arrays-----         
         //BLUE---
                            if (flag_inpix == 1 && bin_xpix >= 1 && bin_ypix >= 1 && bin_xpix <= nbinx && bin_ypix <= num_gridlines) {
                                inpix++;
                                while (bb < num_blue_bands) {
                                    if (Lt_pix[bb][pix] > 0.) {
                                        binmean_Lt[bb][bin_ypix - 1][bin_xpix - 1] = binmean_Lt[bb][bin_ypix - 1][bin_xpix - 1] + Lt_pix[bb][pix];
                                        bincount[bb][bin_ypix - 1][bin_xpix - 1] += 1;
                                    }
                                    bb++;
                                }//end while blue band band 
        //RED---
                                while (rb < num_red_bands) {
                                    if (Lt_pix2[rb][pix] > 0.) {
                                        binmean_Lt2[rb][bin_ypix - 1][bin_xpix - 1] = binmean_Lt2[rb][bin_ypix - 1][bin_xpix - 1] + Lt_pix2[rb][pix];
                                        bincount2[rb][bin_ypix - 1][bin_xpix - 1] += 1;
                                    }
                                    rb++;
                                }//end red bands
 
       //SWIR----
                                while (swb < num_SWIR_bands) {
                                    if (Lt_pix3[swb][pix] > 0.) {
                                        binmean_Lt3[swb][bin_ypix - 1][bin_xpix - 1] = binmean_Lt3[swb][bin_ypix - 1][bin_xpix - 1] + Lt_pix3[swb][pix];
                                        bincount3[swb][bin_ypix - 1][bin_xpix - 1] += 1;
                                    }
                                    swb++;
                                }//end swir bands
 
                            }//end if inpix
 
    //********** pixel AREA WEIGHTING ************************
                            if (flag_inpix == 0) outpix++;
 
                            totpix++;
 
                        }//end pixels loop
 
 
 
 
                        //END OF FILE--****** reset starting sline index if last line processed and within k box
                        //go for another granule if it is not the last one---------------
                        if (sline == num_scans - 1) {
                            flag_donefile = 1;
                            cout << "end of file..." << l1cfile->selgran[findex] << endl;
                            last_sline = 0;
                            if (findex >= sfiles - 1) {
                                cout << "done with last granule of the input list........................." << endl;
                                //   findex=sfiles;
                                k = ngroups;
                                break;
                            }
 
                        }//end of file/last file? sliine=num_scans-1
                        else flag_donefile = 0;
 
                    }//end latpix nadir of line x inside grid group?
 
         //***** skip lines and files if sline is not within k group ********
              //increase k and screen files and lines again starting from the last binning
 
                    if (latpix[nadpix] > lat_gd[n_gdlines - 1][257] && k < ngroups - 1) { //else limits 
                        cout << "moving to the next k group...scanning again files/slines.." << endl;
                        cout << "file index.." << findex << "last sline index.." << sline << endl;
                        last_file = findex;
                        last_sline = sline;
                        findex = sfiles;
                        sline = num_scans - 1;
                    }//end if lat >grid lat--IF outside the box
                    if (sline + 1 % 100 == 0) cout << "for k group.." << k + 1 << "selected granule #.." << l1cfile->selgran[findex] << "sline..." << sline + 1 << "# of binned pix.." << inpix << "totpix.." << totpix << "outpix.." << outpix << endl;
                }//end for scanlines
 
                cout << "closing L1B file......." << ptstr << endl;
                status = nc_close(ncid_L1B);
                check_err(status, __LINE__, __FILE__);
 
                delete[](latpix);
                delete[](lonpix);
                delete[](Lt_pix);
                delete[](Lt_pix2);
                delete[](Lt_pix3);
                delete[](orb_time);
 
 
 
 
                //**********************************************************************************************************************************
                //**********************************************************************************************************************************
                //writing each granule ---------------------------------
                //*****************************************************************************
 
                if (flag_donefile == 1 | (flag_donefile == 0 && k == ngroups - 1)) {
                    cout << "writing file #.............................................." << l1cfile->selgran[findex] << "based on group #.." << k + 1 << endl;
                    //write mean Lt as nc file---
                   //**********************************************************************
                   //**********************************************************************8
                   //create Lt file
                    pathstr = "out/";
                    senstr = "OCIS_";
                    monstr = std::to_string(selmon);
                    daystr = std::to_string(selday);
                    yearstr = std::to_string(selyear);
                    prodstr = "binLt_orb";
                    swtstr = "_swt";
                    granstr = "";
                    granstr = "_" + std::to_string(l1cfile->selgran[findex]);
 
                    if (l1cfile->l1c_pflag >= 3) {
                        swtd = l1cfile->swtnum;
                        swtnum = std::to_string(swtd);
                        cout << "swtnum.." << swtnum << endl;
                    }
                    else swtnum = std::to_string(swtd);
                    extstr = ".nc";
                    NDIMS = 2;
                    fname_out = pathstr + senstr + monstr + daystr + yearstr + prodstr + swtstr + swtnum + granstr + extstr;
                    filename_lt = fname_out.c_str();
 
                    /*     try
                           {
                            cout<<"Opening file \"firstFile.nc\" with NcFile::replace"<<endl;
                            NcFile ncFile("firstFile.nc",NcFile::replace);
                            NcGroup groupA(ncFile.addGroup("groupA"));
                            }
 
                         catch (NcException& e)
                             {
                               cout << "unknown error"<<endl;
                                e.what();
                                 }
                         exit(1);
                        */
 
                    if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
                        check_err(status, __LINE__, __FILE__);
                    //define dims
                    // Define the dimensions. NetCDF will hand back an ID for each. 
                    NY = num_gridlines;
                    NX = nbinx;
                    NY1 = l1cfile->NY1;//these are indexes not line #!!!!!!!!!!!!!!!!!
                    NY2 = l1cfile->NY2;
                    cout << "rowgrid ini.." << NY1 << "rowgrid end.." << NY2 << endl;
                    NY = NY2 - NY1 + 1;
                    cout << "NY.." << NY << "NX.." << NX << endl;
                    //alloc mem for data_out and assign values from lat_gdI
      //alloc mem for data_out and assign values from lat_gdI
                    //NX AND NY are inverted for visualization in SeaDAS
 
     //               data_out=allocate2d_float(NY,NX);
 
               /*     data_out2 = allocate2d_float(NY,NX);
                    data_out3 = allocate2d_float(NY,NX);
                    dcfrossata_out4 = allocate2d_float(NY,NX);
                    data_out5 = allocate2d_float(NY,NX);
                    data_out6 = allocate2d_float(NY,NX);
               */
                    lat_out = allocate2d_float(NY, NX);
                    lon_out = allocate2d_float(NY, NX);
 
                    int c = 0;
 
                    for (int i = NY1; i < NY2 + 1; i++) {
                        for (int j = 0; j < NX; j++) {
                            lat_out[NY - 1 - c][NX - 1 - j] = lat_gd[i][j];
                            lon_out[NY - 1 - c][j] = lon_gd[i][j];
                        }
                        c++;
                    }
 
                    //blue
                        /*           c=0;
                                   for(bb=0;bb<num_blue_bands;bb++){
                                     for(int i=NY1; i<NY2+1; i++){
                                       for(int j=0; j<NX; j++){
                                         if (bincount[bb][i][j]>0)
                                           data_out[NY-1-c][NX-1-j]=binmean_Lt[bb][i][j]/bincount[bb][i][j];
                                         else         data_out[NY-1-c][NX-1-j]=NAN;
                                           }
                                        c++;
                                      }
                                     }//end bands
                    */
 
 
                    //red      
                          /*         if (bincount2[i][j]>0)
                                        data_out3[NY-1-c][NX-1-j]=binmean_Lt2[i][j]/bincount2[i][j];
                                   else
                                        data_out3[NY-1-c][NX-1-j]=NAN;
                    //swir
                                   if (bincount3[i][j]>0)
                                        data_out5[NY-1-c][NX-1-j]=binmean_Lt3[i][j]/bincount3[i][j];
                                   else
                                        data_out5[NY-1-c][NX-1-j]=NAN;
 
                                           data_out2[NY-1-c][NX-1-j]=bincount[i][j];
                                           data_out4[NY-1-c][NX-1-j]=bincount2[i][j];
                                           data_out6[NY-1-c][NX-1-j]=bincount3[i][j];
                             */
 
                             //              }
                             //       c++;
                           //            }
                            //        }//end bands
 
                    if ((status = nc_def_dim(ncid_out, "x", NX, &x_dimid)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_dim(ncid_out, "y", NY, &y_dimid)))
                        check_err(status, __LINE__, __FILE__);
                    //dims for output var
                    dimids[0] = y_dimid;
                    dimids[1] = x_dimid;
 
                    //define groups-----
                             //    status = nc_def_grp( *ncid, line.c_str(), &gid[ngrps]);
                    if ((status = nc_def_grp(ncid_out, "data", &grp_root)))  //netcdf-4
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_grp(grp_root, "geo_coordinates", &grp_coor)))  //netcdf-4
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_grp(grp_root, "blue_bands", &grp_blue)))  //netcdf-4
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_grp(grp_root, "red_bands", &grp_red)))  //netcdf-4
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_grp(grp_root, "swir_bands", &grp_swir)))  //netcdf-4
                        check_err(status, __LINE__, __FILE__);
 
                    //def var--------------------
 
                             //loop blue channels-----
 
                    string bb_num, rb_num, swb_num, bb_str = "binLt_blue_ch", rb_str = "binLt_red_ch", swb_str = "binLt_swir_ch";
 
                    int varid_bb[num_blue_bands], varid_rb[num_red_bands], varid_swb[num_SWIR_bands];
 
                    for (bb = 0;bb < num_blue_bands;bb++) {
                        bb_num = std::to_string(bb + 1);
                        bb_num = bb_str + bb_num;
                        if ((status = nc_def_var(grp_blue, bb_num.c_str(), NC_FLOAT, NDIMS, dimids, &varid))) check_err(status, __LINE__, __FILE__);
                        varid_bb[bb] = varid;
                    }
 
                    for (rb = 0;rb < num_red_bands;rb++) {
                        rb_num = std::to_string(rb + 1);
                        rb_num = rb_str + rb_num;
                        if ((status = nc_def_var(grp_red, rb_num.c_str(), NC_FLOAT, NDIMS, dimids, &varid))) check_err(status, __LINE__, __FILE__);
                        varid_rb[rb] = varid;
                    }
 
                    for (swb = 0;swb < num_SWIR_bands;swb++) {
                        swb_num = std::to_string(swb + 1);
                        swb_num = swb_str + swb_num;
                        if ((status = nc_def_var(grp_swir, swb_num.c_str(), NC_FLOAT, NDIMS, dimids, &varid))) check_err(status, __LINE__, __FILE__);
                        varid_swb[swb] = varid;
                    }
 
                    //       if ((status = nc_def_var(grp_blue,"whatever", NC_FLOAT, NDIMS,
                    //           dimids, &varid)))
 
 
 
            //               if ((status = nc_def_var(ncid_out, "bincount_blue", NC_FLOAT, NDIMS,
            //                  dimids, &varid4)))
            //                  check_err(status, __LINE__, __FILE__);
                    //red 
            /*               if ((status = nc_def_var(ncid_out, "binLt_red", NC_FLOAT, NDIMS,
                              dimids, &varid5)))
                              check_err(status, __LINE__, __FILE__);
                           if ((status = nc_def_var(ncid_out, "bincount_red", NC_FLOAT, NDIMS,
                              dimids, &varid6)))
                              check_err(status, __LINE__, __FILE__);
                    //swir
                           if ((status = nc_def_var(ncid_out, "binLt_swir", NC_FLOAT, NDIMS,
                               dimids, &varid7)))
                              check_err(status, __LINE__, __FILE__);
                           if ((status = nc_def_var(ncid_out, "bincount_swir", NC_FLOAT, NDIMS,
                               dimids, &varid8)))
                               check_err(status, __LINE__, __FILE__);
            */
 
            //lat/lon
                    if ((status = nc_def_var(grp_coor, "lat_gd", NC_FLOAT, NDIMS,
                        dimids, &varid2)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_var(grp_coor, "lon_gd", NC_FLOAT, NDIMS,
                        dimids, &varid3)))
                        check_err(status, __LINE__, __FILE__);
                    //leave define mode-----------------------
                    if ((status = nc_enddef(ncid_out))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
 
                    //assign variable data------------------------
                     /*        start2[0]=0;
                                     start2[1]=0;
                                     start2[2]=0;
 
                                     count2[0]=1;
                                     count2[1]=NY;
                                     count2[2]=NX;
 
 
                                     float lat_data[NY][NX];
 
                                     for (int i=0;i<NY;i++){
                                       for (int j=0;j<NX;j++){
                                      lat_data[i][j]=lat_out[i][j];
                                   }}
 
                    */
                    //                 if((status = nc_put_vara_float(ncid_out,varid2,start2,count2,&lat_out[0][0])))
                    //                 check_err(status, __LINE__, __FILE__);
                    //                 if((status = nc_put_vara(grp_coor,varid3,start,count,lon_out)));
                    //                 check_err(status, __LINE__, __FILE__);
                    //                 if((status = nc_put_vara(grp_blue,varid,start,count,data_out)));
                    //                 check_err(status, __LINE__, __FILE__);
 
                    if ((status = nc_put_var_float(grp_coor, varid2, &lat_out[0][0])))
                        check_err(status, __LINE__, __FILE__);
 
                    if ((status = nc_put_var_float(grp_coor, varid3, &lon_out[0][0])))
                        check_err(status, __LINE__, __FILE__);
                    //blue
 
                    for (bb = 0;bb < num_blue_bands;bb++) {
                        data_out = allocate2d_float(NY, NX);
                        c = 0;
                        for (int i = NY1; i < NY2 + 1; i++) {
                            for (int j = 0; j < NX; j++) {
                                data_out[NY - 1 - c][NX - 1 - j] = 0.;
                            }
                            c++;
                        }
                        c = 0;
                        for (int i = NY1; i < NY2 + 1; i++) {
                            for (int j = 0; j < NX; j++) {
                                if (bincount[bb][i][j] > 0)
                                    data_out[NY - 1 - c][NX - 1 - j] = binmean_Lt[bb][i][j] / bincount[bb][i][j];
                                else         data_out[NY - 1 - c][NX - 1 - j] = NAN;
                            }
                            c++;
                        }
                        cout << "writing blue band#.." << bb + 1 << endl;
                        if ((status = nc_put_var_float(grp_blue, varid_bb[bb], &data_out[0][0])))
                            check_err(status, __LINE__, __FILE__);
 
 
                        delete[](data_out);
                    }//end blue bands
 
 
           //red
                    for (rb = 0;rb < num_red_bands;rb++) {
                        data_out2 = allocate2d_float(NY, NX);
                        c = 0;
                        for (int i = NY1; i < NY2 + 1; i++) {
                            for (int j = 0; j < NX; j++) {
                                data_out2[NY - 1 - c][NX - 1 - j] = 0.;
                            }
                            c++;
                        }
                        c = 0;
                        for (int i = NY1; i < NY2 + 1; i++) {
                            for (int j = 0; j < NX; j++) {
                                if (bincount2[rb][i][j] > 0)
                                    data_out2[NY - 1 - c][NX - 1 - j] = binmean_Lt2[rb][i][j] / bincount2[rb][i][j];
                                else         data_out2[NY - 1 - c][NX - 1 - j] = NAN;
                            }
                            c++;
                        }
                        cout << "writing red band#.." << rb + 1 << endl;
                        if ((status = nc_put_var_float(grp_red, varid_rb[rb], &data_out2[0][0])))
                            check_err(status, __LINE__, __FILE__);
 
                        delete[](data_out2);
                    }//end red bands
 
 
           //swir
                    for (swb = 0;swb < num_SWIR_bands;swb++) {
                        data_out3 = allocate2d_float(NY, NX);
                        c = 0;
                        for (int i = NY1; i < NY2 + 1; i++) {
                            for (int j = 0; j < NX; j++) {
                                data_out3[NY - 1 - c][NX - 1 - j] = 0.;
                            }
                            c++;
                        }
                        c = 0;
                        for (int i = NY1; i < NY2 + 1; i++) {
                            for (int j = 0; j < NX; j++) {
                                if (bincount3[swb][i][j] > 0)
                                    data_out3[NY - 1 - c][NX - 1 - j] = binmean_Lt3[swb][i][j] / bincount3[swb][i][j];
                                else         data_out3[NY - 1 - c][NX - 1 - j] = NAN;
                            }
                            c++;
                        }
                        cout << "writing SWIR band#.." << swb + 1 << endl;
                        if ((status = nc_put_var_float(grp_swir, varid_swb[swb], &data_out3[0][0])))
                            check_err(status, __LINE__, __FILE__);
 
                        delete[](data_out3);
                    }//end red bands
 
 
   /*               if ((status = nc_put_var_float(ncid_out, varid4, &data_out2[0][0])))
                      check_err(status, __LINE__, __FILE__);
               //red
                  if ((status = nc_put_var_float(ncid_out, varid5, &data_out3[0][0])))
                      check_err(status, __LINE__, __FILE__);
                  if ((status = nc_put_var_float(ncid_out, varid6, &data_out4[0][0])))
                      check_err(status, __LINE__, __FILE__);
               //swir
                  if ((status = nc_put_var_float(ncid_out, varid7, &data_out5[0][0])))
                      check_err(status, __LINE__, __FILE__);
                  if ((status = nc_put_var_float(ncid_out, varid8, &data_out6[0][0])))
                      check_err(status, __LINE__, __FILE__);
   */
 
                    if ((status = nc_close(ncid_out)))
                        check_err(status, __LINE__, __FILE__);
 
                    delete[](lat_out);
                    delete[](lon_out);
                    //               delete [] (data_out);
 
 
                             /*      delete [] (data_out2);
                                   delete [] (data_out3);
                                   delete [] (data_out4);
                                   delete [] (data_out5);
                                   delete [] (data_out6);
                             */
                    delete[](bincount);
                    delete[](binmean_Lt);
                    delete[](bincount2);
                    delete[](binmean_Lt2);
                    delete[](bincount3);
                    delete[](binmean_Lt3);
 
                    lat_out = nullptr;;
                    lon_out = nullptr;
                    data_out = nullptr;
                    data_out2 = nullptr;
                    data_out3 = nullptr;
                  
                 
                
 
                    bincount = nullptr;
                    binmean_Lt = nullptr;
                    bincount2 = nullptr;
                    binmean_Lt2 = nullptr;
                    bincount3 = nullptr;
                    binmean_Lt3 = nullptr;
 
                    flag_donefile = 0;
                }//end writing file
            }//end for files
 
            cout << "group k at the end of big loop" << k + 1 << endl;
 
        }//groups
 
        cout << "number of files per swath.." << nfiles_swt[swtd - 1] << "for swath.." << swtd << endl;
        cout << "total inpix.." << inpix << "total pix.." << totpix << endl;
        //  cout<<"binned pixels.."<<inpix<<"as %.."<<(inpix/(num_pixels*num_scans*n_files*nfiles_swt[swtd-1]))*100<<endl;
        delete[](lat_asort);
        //   delete [] (lon_asort);
        delete[](index_xy);
        //   delete [] (index_xy2);
        delete[](dlatb_g);
        delete[](dlonb_g);
 
        delete[](lat_gd);
        delete[](lon_gd);
        delete[](az_east);
 
        printf("*** SUCCESS writing bincount and binLt rasters as nc..!\n");
        cout << "finish processing swath eq crossing day..." << swtd << endl;
        cout << "done writing Lt to nc file.." << endl;
 
        return (0);
    }
 
 
  //similar to version 6 but including HARP 
    int32_t L1C::binL1C_wgranule7(int swtd, l1c_filehandle* l1cfile, L1C_input* l1cinput, int16_t* swtd_id, int16_t* odir, int16_t* file_id, int16_t* nfiles_swt) {
        size_t ybins,xbins;
        int32_t gdlines_group, ngroups = 0, num_gridlines,nbinx2, nbinx, inpix = 0, outpix = 0, totpix = 0, n_gdlines;//number of gridlines to be processed
        float minv = 0., maxv = 0., ** dlatb_g, ** dlonb_g;
        int16_t fi = 0;
        std::string str;
        const char* ptstr;
        int dimid, dimid2,dimid3,status, ncid_out,ncid_az,ncid_grid,b_dimid,v_dimid,x_dimid,y_dimid,varid1,varid2, varid_count,varid_lt,azId,NDIMS,NDIMS2,NDIMS3,senazId;
        int blueGrp,v1Grp,dimidv,dimidx,dimidy,dimidf;
        size_t start[] = { 0, 0 };
        size_t count[] = { 1, 1 };
        size_t start2[] = { 0, 0, 0 };
        size_t count2[] = { 1, 1, 1 }, count3[] = { 1, 1, 1 }, count4[] = { 1, 1, 1 };
        int32_t bin_xpix, bin_ypix;
        float* latpix=nullptr, * lonpix=nullptr, ** Lt_pix=nullptr, ** Lt_pix2=nullptr, ** Lt_pix3=nullptr,*Lt_pix4=nullptr,mean_az_east,*senazpix=nullptr;
 
     
        float latmin_swt = 100, latmax_swt = 0, lonmin_swt = 0, lonmax_swt = 0;
        int dimids[2],dimids2[3],dimids3[4];
        const char* filename_lt;
        int32_t NY = -1, NX = -1, NY1 = -1, NY2 = -1,c1 = 1;
        float****data_out2=nullptr,** lat_out, ** lon_out;
        int ***data_out=nullptr;
        int last_file, last_sline, flag_inpix, flag_donefile;;//first index file id, second index line #
        short** index_xy;
        float** lat_asort;
        bool boolbin1;
        char* ifile_char;
        std::string ifile_str;
 
        int16_t selyear = -1, selmon = -1, selday = -1;
        float** lat_gd, ** lon_gd, * az_east;
        string gridname, azeast_name;
        float**** binmean_Lt = nullptr;
        int ****bincount=nullptr;
        double gres = (l1cinput->gres) * 1000, dlamin, dlamax, dlomin, dlomax;
        int grp_obs,grp_coor,geoGrp,obsGrp,navGrp;            ;
        size_t  sb=0,bb = 0, rb = 0, swb = 0,ib=0, NVIEWS=-1,NBANDS=-1,NBANDS_POL=-1;
        int view;
        float sum=0,tot=0;
        char tmp[256];
        short gd_row, gd_col;
        float ***latframe1=nullptr,***latframe2=nullptr,***latframe3=nullptr,***lonframe1=nullptr,***lonframe2=nullptr,***lonframe3=nullptr;
        int ibin_ini=-1,ibin_end=-1;
 
 
 
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
     
     //random seed
        srand((unsigned int)time(NULL));
        //nadir pixel ofr OCI
        int nadpix = l1cfile->nadpix;
 
 
        num_gridlines = 4000;
        nbinx2 = l1cfile->nbinx;
        num_pixels = l1cfile->npix;
        num_scans=l1cfile->nscan;
        num_pixels=l1cfile->npix;
 
 
        size_t sfiles = 0;
 
        if (l1cfile->selgran[0] < 0)//process all granules
        {
            sfiles = nfiles_swt[swtd - 1];
            for (unsigned int j = 0;j < sfiles;j++) l1cfile->selgran[j] = j + 1;
        }
        else {
            while (l1cfile->selgran[sfiles] > 0) {
                cout << "selected granule #..........................." << l1cfile->selgran[sfiles] << endl;
                sfiles++;
            }
        }
 
       cout<<"binning Lt using sbs2 method and composite indexes for arrays..................................................................."<<endl;
 
 
              //allocate mem for lat/lon/azeast pointers---
        selday = l1cinput->selday;
        selmon = l1cinput->selmon;
        selyear = l1cinput->selyear;
 
        std::string fname_out, pathstr, senstr, monstr, daystr, yearstr, prodstr, gdstr, swtstr, swtnum, extstr, granstr,timestr,azstr,missionstr;
 
        missionstr="PACE";
        senstr = "OCIS";
        monstr = std::to_string(selmon);
        daystr = std::to_string(selday);
        yearstr = std::to_string(selyear);
        timestr="T00:00:00Z";
        prodstr = "L1Cgrid";
        swtstr = "_swt";
        extstr = ".nc";
 
        if (l1cfile->l1c_pflag >= 3) {
            swtd = l1cfile->swtnum;
            swtnum = std::to_string(swtd);
            cout << "swtnum.." << swtnum << endl;
        }
        else swtnum = std::to_string(swtd);
 
 
        getcwd(tmp, 256);
        pathstr=tmp;
 
//open lat/lon L1C grid --------------------------------------
    //PACE_OCIS.2019321T00:00:00ZL1Cgrid.nc
        prodstr = "L1Cgrid";
        gridname = pathstr + "/out/"+missionstr + "_" + senstr + "." + yearstr + monstr + daystr + timestr + prodstr+extstr;
 
    //open file
        ifile_str = l1cinput->files[0];
        ifile_char = &ifile_str[0];
        file_format format = getFormat(ifile_char);
  //      format.type=FT_HARP;
 
        cout<<"forma type.."<<format.type<<endl;
 
        if(format.type==FT_SPEXONE | format.type==FT_HARP){
            ptstr="/accounts/mamontes/images/OCIS/sean/out/PACE_OCIS.2019321T00:00:00ZL1Cgrid.nc";
            cout<<"ptstr..."<<ptstr<<endl;
            }
        else {//legacy sensors
        ptstr = gridname.c_str();
         }
 
        status = nc_open(ptstr, NC_NOWRITE, &ncid_grid);
          if (status != NC_NOERR) {
              fprintf(stderr, "nc_open error.\n");
               exit(EXIT_FAILURE);
          }
       //groups
        status = nc_inq_grp_ncid(ncid_grid, "geolocation_data", &geoGrp);
        check_err(status, __LINE__, __FILE__);
       
        status = nc_inq_dimid(ncid_grid, "bins_along_track", &y_dimid);
            check_err(status, __LINE__, __FILE__);
        nc_inq_dimlen(ncid_grid, y_dimid, &ybins);
        status = nc_inq_dimid(ncid_grid, "bins_across_track", &x_dimid);
            check_err(status, __LINE__, __FILE__);
 
        nc_inq_dimlen(ncid_grid, x_dimid, &xbins);
        nc_inq_dimlen(ncid_grid, y_dimid, &ybins);
 
         //************************************************************
        //mem allocation for geolocation pointers---
        num_gridlines=ybins;
        nbinx=xbins;
 
        cout<<"num_gridlines"<<num_gridlines<<"nbinx"<<nbinx<<endl;
        az_east = (float*)calloc(num_gridlines , sizeof(float));
        lat_gd = allocate2d_float(num_gridlines, nbinx);
        lon_gd = allocate2d_float(num_gridlines, nbinx);
 
        status = nc_inq_varid(geoGrp, "latitude", &latId);//scans x velements
                check_err(status, __LINE__, __FILE__);
        status = nc_inq_varid(geoGrp, "longitude", &lonId);//scans x velements
                check_err(status, __LINE__, __FILE__);
        status = nc_get_var_float(geoGrp, latId, &lat_gd[0][0]);
                check_err(status, __LINE__, __FILE__);
        status = nc_get_var_float(geoGrp, lonId, &lon_gd[0][0]);
                check_err(status, __LINE__, __FILE__);
//close file
        if ((status = nc_close(ncid_grid)))
           check_err(status, __LINE__, __FILE__);
 
 
     //open az_east ------
     //PACE_OCIS.2019321T00:00:00Zaz_east.nc
        prodstr = "az_east";
//        cout << "Current working directory: " << tmp << endl;
        azstr= pathstr + "/out/"+missionstr + "_" + senstr + "." + yearstr + monstr + daystr + timestr + prodstr+extstr;
 
        if(format.type==FT_SPEXONE| format.type==FT_HARP){       
            ptstr="/accounts/mamontes/images/OCIS/sean/out/PACE_OCIS.2019321T00:00:00Zaz_east.nc";
            }
        else{
        ptstr = azstr.c_str();
        }
        cout <<"Opening file with azimuth east values in degrees............" << ptstr << endl;
    //    ptstr="/accounts/mamontes/images/OCIS/sean/out/PACE_OCIS.2019321T00:00:00Zaz_east.nc";
 
        status = nc_open(ptstr, NC_NOWRITE, &ncid_az);
          if (status != NC_NOERR) {
              fprintf(stderr, "nc_open error.\n");
               exit(EXIT_FAILURE);
          } 
        status = nc_inq_dimid(ncid_az, "bins_along_track", &y_dimid);
            check_err(status, __LINE__, __FILE__);
        nc_inq_dimlen(ncid_az, y_dimid, &ybins);
 
        status = nc_inq_varid(ncid_az, "az_east", &azId);//scans x velements
                check_err(status, __LINE__, __FILE__);
        status = nc_get_var_float(ncid_az, azId, &az_east[0]);
                check_err(status, __LINE__, __FILE__);
 
        for(size_t i=0;i<ybins;i++){ 
             sum = az_east[i];
             tot += sum;
              }
//close file
        if ((status = nc_close(ncid_az)))
           check_err(status, __LINE__, __FILE__);
        
        //using swath-averaged az_east for nadir pixels rather than along-track az_east pixel-by-pixel
        mean_az_east = tot / (ybins);
 
        l1cfile->mean_az_east=mean_az_east; //in degrees
        cout<<"mean_az_east in degrees...."<<mean_az_east<<endl;
   
 
 
        //determine # of gd groups to be processede  
        //gdlines_group=num_gridlines;//ONE BIG GROUP
        gdlines_group = 250;
 
        if (num_gridlines <= gdlines_group) {
            gdlines_group = num_gridlines;
            cout << "WARNING********************* number_gridlines<=gdlines_group THEN gdlines_group=num_gridlines **************" << endl;
        }
 
        ngroups = floor(num_gridlines / gdlines_group);
        cout << "TOTAL # of gd groups.(ALL LATs...." << ngroups << endl;
 
        //--NORMALIZED  gridline longitude is -180 to 180 degrees before comparison with longitude extracted from image pixels---
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lon_gd[i][j] < -180.)lon_gd[i][j] += 360.;
                if (lon_gd[i][j] > 180.)lon_gd[i][j] -= 360.;
            }        
            }
        //get min/max lat/lon of the swath
        // Assume first element as maximum and minimum
        maxv = lat_gd[0][0];
        minv = lat_gd[0][0];
 
        //Find maximum and minimum in all array elements.
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lat_gd[i][j] > maxv)
                    maxv = lat_gd[i][j];
                if (lat_gd[i][j] < minv)
                    minv = lat_gd[i][j];
            }        
               }
     
    
        maxv = lon_gd[0][0];
        minv = lon_gd[0][0];
        //Find maximum and minimum in all array elements.
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lon_gd[i][j] > maxv)
                    maxv = lon_gd[i][j];
                if (lon_gd[i][j] < minv)
                    minv = lon_gd[i][j];
            }
        }
   
  
 
        cout << "swath #.." << swtd << endl;
 
        //check lat bound min/max of each gd group---
        int k = 0, i = 0;
 
        dlatb_g = allocate2d_float(ngroups + 1, 2);
        dlonb_g = allocate2d_float(ngroups + 1, 2);
 
        //recompute number of gridlines based on lat limits -80 to 80 degrees  
       //asc orbit goes from negative to positive latitude....
        NY = num_gridlines;
        NX = nbinx;
        for (int i = 0; i < NY; i++) {
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= -80.) c1++;
                if (c1 == nbinx) {
                    NY1 = i;
                }
            }
            if (NY1 >= 0) break;
            c1 = 1;
        }
 
 
        for (int i = 0;i < NY; i++) {
            //   cout<<"i.."<<i<<"lat_gd[i][j]..."<<lat_gd[i][nadpix]<<endl;
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= 80.) {
                    NY2 = i - 1;
                }
            }
 
            if (NY2 >= 0) break;
        }
 
        // cout<<"gridlines limited to -80 to 80 degrees of latitutde.."<<"gdline ini.."<<NY1<<"gdline end.."<<NY2<<endl;
 
        l1cfile->NY1 = NY1;
        l1cfile->NY2 = NY2;
 
        cout << "NY.." << NY << "NY1.." << NY1 << "NY2.." << NY2 << endl;
 
 
 
        num_gridlines = NY2 - NY1 + 1;//this is the # gridlines after -80 to 80 lat constraint---
 
        cout<<"numgridlines after restriction lat"<<num_gridlines<<endl;
 
        ngroups = floor(num_gridlines / gdlines_group);
        cout << "gdlines will start in gline.." << i + 1 << "ROUNDED ngroups after adjusting beginning.for constraint lat (-80 to 80)" << ngroups << endl;
 
        //for each 'grid' group scan the swath files to see if there are scanlines within--
        //if that is case check the across-bin number position (0 to binx-1) based on latnad and lonnad values--- 
        last_file = 0;
        last_sline = 0;
        flag_donefile = 0;
 
        if (num_gridlines > ngroups * gdlines_group) ngroups += 1;
 
 
        //*********** SORTING LAT/LON ASCENDING AND TRACK INDEXES ****************************
        //***********************************************************************************
 
        //Create index matrix for i and j of each lat and lon L1C grid (-80 to 80)
        //num_gridlines x nbinx
        index_xy = allocate2d_short(num_gridlines, nbinx);
        lat_asort = allocate2d_float(num_gridlines, nbinx);
        //  lon_asort=allocate2d_float(num_gridlines,nbinx);
             //fill indexe
 
        //define 1-D vector to sort 1 col L1C grid at the time---
        vector<pair<float, int> > vp;
 
        //fill vector with lat_gd column--
        cout << "*********** SORTING LAT/LON GRIDPOINTS AND TRACKING INDEXES ********************" << endl;
 
        for (int col = 0;col < nbinx;col++) {
            for (int row = NY1;row < NY2 + 1;row++) {
                vp.push_back(make_pair(lat_gd[row][col] + 90., row));
            }
            //sort 
            stable_sort(vp.begin(), vp.end());
            //display lat in order along with its gridpoint index--
              //   cout << "Lat value\t"
              //         << "index" << endl; 
            for (unsigned int i = 0; i < vp.size(); i++) {
                lat_asort[i][col] = vp[i].first;
                index_xy[i][col] = vp[i].second;
            }
            vp.clear();
        }
 
        cout << "num_gridlines...." << num_gridlines << "ngroups.." << ngroups << endl;
 
 
        //****************************************************************************************************
           //************* BIG LOOP GROUPS ***************************************
        cout << "Number of granules to be L1C processed........................................." << sfiles << endl;
 
//**********BIG LOOP GROUPS ********************
        for (k = 0;k < ngroups;k++) {
            
            //total gridlines for k groups-----
            n_gdlines = (k + 1) * gdlines_group;
            cout << "screening k group.." << k + 1 << "last_file.." << last_file << "last_line.." << last_sline << endl;
            cout << "number of gridlines so far..." << n_gdlines << endl;
            //***** compute deltas for lat_gd index 256 and 257 *******************
 
             //compute delta_lat and delta_lon based on binres/2 for lower and upper corners of 'nadir' gridpoints of 256 and 257 indexes -----------------
               //we need nadir 256 and 257 lat/lon coordinates to compute -delta and +delta, respectively
               //we need azimuth and backazimuth and binres/2 to compute deltas ---
 
                //index 256
            geod.Direct(lat_gd[n_gdlines - gdlines_group][256], lon_gd[n_gdlines - gdlines_group][256], az_east[n_gdlines - gdlines_group], gres, dlamin, dlomin);
            geod.Direct(lat_gd[n_gdlines - 1][257], lon_gd[n_gdlines - 1][257], az_east[n_gdlines - 1], gres, dlamax, dlomax);
 
            cout << "dlamin.." << dlamin << "dlomin.." << dlomin << "dlamax.." << dlamax << "dlomax.." << dlomax << endl;
 
            dlatb_g[k][0] = dlamin;//in DEGREES!!
            dlatb_g[k][1] = dlamax;
            dlonb_g[k][0] = dlomin;
            dlonb_g[k][1] = dlomax;
 
//********* LOOP FILES ************************************
            for (unsigned int findex = last_file;findex < sfiles;findex++) {
 
                cout << "Scanning lines in file.. for crossing swath..." << swtd << "selected granule #.." << l1cfile->selgran[findex] << "swt_id.." << swtd_id[findex] << "grid group.." << k + 1 << endl;
 
                fi = l1cfile->selgran[findex];
                str = l1cfile->ifiles[fi - 1];
                ptstr = str.c_str();
 
                cout << "opening filename............" << ptstr << endl;
 
                status = nc_open(ptstr, NC_NOWRITE, &ncid_L1B);
                if (status != NC_NOERR) {
                   fprintf(stderr, "nc_open error.\n");
                    exit(EXIT_FAILURE);
                }
                //Open dimensions
                
                if(format.type==FT_SPEXONE){
                      status = nc_inq_dimid(ncid_L1B, "bins_along_track", &dimid);
                        if (status != NC_NOERR) {
                          fprintf(stderr, "-E- Error reading number_of_scans.\n");
                            exit(EXIT_FAILURE);                }
                          status = nc_inq_dimid(ncid_L1B, "spatial_samples_per_image", &dimid2);
                        if (status != NC_NOERR) {
                          fprintf(stderr, "-E- Error reading spatial_samples_per_image.\n");
                            exit(EXIT_FAILURE);                }
                          status = nc_inq_dimid(ncid_L1B, "intensity_bands_per_view", &dimid3);
                        if (status != NC_NOERR) {
                          fprintf(stderr, "-E- Error reading intensity_bands_per_view.\n");
                            exit(EXIT_FAILURE);                }
         //           spatial_samples_per_image, intensity_bands_per_view
         //
                 nc_inq_dimlen(ncid_L1B, dimid, &num_scans);
                }
                else if(format.type==FT_HARP){
                  status = nc_inq_grp_ncid(ncid_L1B, "blue", &blueGrp);
                      if (status != NC_NOERR) {
                         fprintf(stderr, "-E- Error reading group blue.\n");
                             exit(EXIT_FAILURE);
                                            }
                   status = nc_inq_dimid(blueGrp,"Views", &dimidv);
                      if (status != NC_NOERR) {
                        fprintf(stderr, "-E- Error reading dimensions number_of views.\n");
                           exit(EXIT_FAILURE);
                                   }
      //reading subgroup view1
                   status = nc_inq_grp_ncid(blueGrp, "View01", &v1Grp);
                    if (status != NC_NOERR) {
                          fprintf(stderr, "-E- Error reading subgroup view 1 --blue.\n");
                          exit(EXIT_FAILURE);
                        }
        //lines and pixels    
                   status = nc_inq_dimid(v1Grp,"Swath_Pixels", &dimidx);
                   if (status != NC_NOERR) {
                         fprintf(stderr, "-E- Error reading # pixel dimensions view01.\n");
                        exit(EXIT_FAILURE);
                       }
                   status = nc_inq_dimid(v1Grp,"Swath_Lines", &dimidy);
                      if (status != NC_NOERR) {
                        fprintf(stderr, "-E- Error reading # lines dimensions view01.\n");
                           exit(EXIT_FAILURE);
                       }
                   status = nc_inq_grp_ncid(ncid_L1B, "navigation", &navGrp);
                      if (status != NC_NOERR) {
                         fprintf(stderr, "-E- Error reading group navigation.\n");
                             exit(EXIT_FAILURE);
                                            }
                   status = nc_inq_dimid(navGrp,"Vector_Elements", &dimidf);
                      if (status != NC_NOERR) {
                        fprintf(stderr, "-E- Error reading # frames dimensions view01.\n");
                           exit(EXIT_FAILURE);
                       }
 
                   nc_inq_dimlen(v1Grp, dimidv, &nviews);
                   nc_inq_dimlen(v1Grp, dimidy, &num_scans);
                   nc_inq_dimlen(v1Grp, dimidx, &num_pixels); 
                   nc_inq_dimlen(navGrp, dimidf, &num_frames);
 
                   cout<<"# views.."<<nviews<<"# scans.."<<num_scans<<"# pixels.."<<num_pixels<<"num_frames..."<<num_frames<<endl;    
                }
                else{//OCIS    
                      status = nc_inq_dimid(ncid_L1B, "number_of_scans", &dimid);
                       if (status != NC_NOERR) {
                                fprintf(stderr, "-E- Error reading number_of_scans.\n");
                            exit(EXIT_FAILURE);
                    }
                 nc_inq_dimlen(ncid_L1B, dimid, &num_scans);
                
                }
 
               
 
                //read line-by-line lat/lon/Lt
                if(format.type==FT_SPEXONE){
                   status = nc_inq_grp_ncid(ncid_L1B, "GEOLOCATION_DATA", &geoGrp);
                   check_err(status, __LINE__, __FILE__);
                   status = nc_inq_grp_ncid(ncid_L1B, "OBSERVATION_DATA", &obsGrp);
                   check_err(status, __LINE__, __FILE__);
                   status = nc_inq_varid(geoGrp, "sensor_azimuth", &senazId);
                   check_err(status, __LINE__, __FILE__);
                   status = nc_inq_varid(geoGrp, "latitude", &latId);
                   check_err(status, __LINE__, __FILE__);
                   status = nc_inq_varid(geoGrp, "longitude", &lonId);
                   check_err(status, __LINE__, __FILE__);
                }
                else if(format.type==FT_HARP){
      //get latitude and longitude          
                   status = nc_inq_varid(v1Grp, "Latitude", &latId);
                   check_err(status, __LINE__, __FILE__);
                   status = nc_inq_varid(v1Grp, "Longitude", &lonId);
                   check_err(status, __LINE__, __FILE__);
                   status = nc_inq_varid(navGrp, "FrameID", &frameId);
                   check_err(status, __LINE__, __FILE__);
 
                 /*   
                  latframe1 = allocate3d_float(num_frames,num_scans, num_pixels);
                  lonframe1 = allocate3d_float(num_frames,num_scans, num_pixels);
                  latframe2 = allocate3d_float(num_frames,num_scans, num_pixels);
                  lonframe2 = allocate3d_float(num_frames,num_scans, num_pixels);
                  latframe3 = allocate3d_float(num_frames,num_scans, num_pixels);
                  lonframe3 = allocate3d_float(num_frames,num_scans, num_pixels);
 
                   //sensor1--0 degrees polariz
                  status = nc_inq_grp_ncid(ncid_L1B, "Sensor1", &sen1Grp);
                  check_err(status, __LINE__, __FILE__);
                  status = nc_inq_varid(sen1Grp, "Latitude", &latId1);//scans x velements
                  check_err(status, __LINE__, __FILE__);
                  status = nc_get_var_float(sen1Grp, latId1, &latframe1[0][0][0]);
                  check_err(status, __LINE__, __FILE__);
                  status = nc_inq_varid(sen1Grp, "Longitude", &lonId1);
                  check_err(status, __LINE__, __FILE__);
                  status = nc_get_var_float(sen1Grp, lonId1, &lonframe1[0][0][0]);
                  check_err(status, __LINE__, __FILE__);
 
 
                   //sensor2--45 degrees poilar
                  status = nc_inq_grp_ncid(ncid_L1B, "Sensor2", &sen2Grp);
                  check_err(status, __LINE__, __FILE__);
                  status = nc_inq_varid(sen2Grp, "Latitude", &latId2);//scans x velements
                  check_err(status, __LINE__, __FILE__);
                  status = nc_get_var_float(sen2Grp, latId2, &latframe2[0][0][0]);
                  check_err(status, __LINE__, __FILE__);
                  status = nc_inq_varid(sen2Grp, "Longitude", &lonId2);
                  check_err(status, __LINE__, __FILE__);
                  status = nc_get_var_float(sen2Grp, lonId2, &lonframe2[0][0][0]);
                  check_err(status, __LINE__, __FILE__);
 
                 //sensor3--90 degrees pola
                  status = nc_inq_grp_ncid(ncid_L1B, "Sensor3", &sen3Grp);
                  check_err(status, __LINE__, __FILE__);
                  status = nc_inq_varid(sen3Grp, "Latitude", &latId3);//scans x velements
                  check_err(status, __LINE__, __FILE__);
                  status = nc_get_var_float(sen3Grp, latId3, &latframe3[0][0][0]);
                  check_err(status, __LINE__, __FILE__);
                  status = nc_inq_varid(sen3Grp, "Longitude", &lonId3);
                  check_err(status, __LINE__, __FILE__);
                  status = nc_get_var_float(sen3Grp, lonId3, &lonframe3[0][0][0]);
                  check_err(status, __LINE__, __FILE__);
 
 
                 */ 
                }
                else{//legacy sensors
                   status = nc_inq_grp_ncid(ncid_L1B, "geolocation_data", &geoGrp);
                   check_err(status, __LINE__, __FILE__);
                   status = nc_inq_grp_ncid(ncid_L1B, "observation_data", &obsGrp);
                   check_err(status, __LINE__, __FILE__);
                   status = nc_inq_varid(geoGrp, "sensor_azimuth", &senazId);
                   check_err(status, __LINE__, __FILE__);
                   status = nc_inq_varid(geoGrp, "latitude", &latId);
                   check_err(status, __LINE__, __FILE__);
                   status = nc_inq_varid(geoGrp, "longitude", &lonId);
                   check_err(status, __LINE__, __FILE__);
                }  
 
                //radiance variables
                if(format.type==FT_SPEXONE){
                   NVIEWS= 1;//should be 5 but only provided 1
                   NBANDS=400;
                   NBANDS_POL=50;
                   status = nc_inq_varid(obsGrp, "I", &I_Id);
                   check_err(status, __LINE__, __FILE__);
                    status = nc_inq_varid(obsGrp, "I_polsample", &Ipol_Id);
                   check_err(status, __LINE__, __FILE__);
                   
                   cout << "#total number of Intensity bands per view.." << NBANDS << endl;
                   cout << "#total number of Polarization bands per view.." << NBANDS_POL << endl;
                } 
                else if(format.type==FT_HARP){
                   NVIEWS= 1;//HARP-2 10 but 60 for 669 nm
                   NBANDS=1;//
                   NBANDS_POL=1;
                   status = nc_inq_varid(v1Grp, "I", &I_Id);
                   check_err(status, __LINE__, __FILE__);
                   /*
                   status = nc_inq_varid(obsGrp, "I", &I_Id);
                   check_err(status, __LINE__, __FILE__);
                    status = nc_inq_varid(obsGrp, "I_polsample", &Ipol_Id);
                   check_err(status, __LINE__, __FILE__);
                   */
                   cout << "#total number of Intensity bands per view.." << NBANDS << endl;
                   cout << "#total number of Polarization bands per view.." << NBANDS_POL << endl;
                }    
                else{//OCIS                  
                   NVIEWS= 2;//for OCI
                   NBANDS=249;//for OCI       
                   status = nc_inq_varid(obsGrp, "Lt_blue", &Lt_blueId);
                   check_err(status, __LINE__, __FILE__);
                   status = nc_inq_varid(obsGrp, "Lt_red", &Lt_redId);
                   check_err(status, __LINE__, __FILE__);
                   status = nc_inq_varid(obsGrp, "Lt_SWIR", &Lt_SWIRId);
                   check_err(status, __LINE__, __FILE__);
                // num_blue_bands
                 status = nc_inq_dimid(ncid_L1B, "blue_bands", &dimid);
                   if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading num_blue_bands.\n");
                    exit(EXIT_FAILURE);
                   }
                 nc_inq_dimlen(ncid_L1B, dimid, &num_blue_bands);
 
                // num_red_bands
                 status = nc_inq_dimid(ncid_L1B, "red_bands", &dimid);
                   if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading num_red_bands.\n");
                    exit(EXIT_FAILURE);
                   }
                 nc_inq_dimlen(ncid_L1B, dimid, &num_red_bands);
 
                // num_SWIR_bands
                 status = nc_inq_dimid(ncid_L1B, "SWIR_bands", &dimid);
                   if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading num_SWIR_bands.\n");
                    exit(EXIT_FAILURE);
                   }
                 nc_inq_dimlen(ncid_L1B, dimid, &num_SWIR_bands);
                 cout << "#blue bands.." << num_blue_bands << endl;
                 cout << "#red bands.." << num_red_bands << endl;
                 cout << "#swir bands.." << num_SWIR_bands << endl;
                 nbands=num_blue_bands+num_red_bands+num_SWIR_bands;
                 cout << "#total number of bands.." << nbands << endl;
                 }
 
                cout<<"#gridlines.."<<num_gridlines<<"# binx2.."<<nbinx2<<"number of scans.."<<num_scans<<"# pixels.."<<num_pixels<<endl;
                cout<<"num of views.."<<NVIEWS<<"number of bands.."<<NBANDS<<endl;
 
 
 
 
                 if (last_sline == 0 && binmean_Lt == nullptr) { // binmean_Lt==NULL | bincount==NULL | binmean_Lt2==NULL | bincount2==NULL | binmean_Lt3==NULL | bincount3==NULL){
 
                    cout << "first allocation of memory for grid bins of file #..." << l1cfile->selgran[findex] << endl;
 
                    //            cout<<"findex.."<<findex<<"blue bands"<<num_blue_bands<<"red bands.."<<num_red_bands<<"swir bands..."<<num_SWIR_bands<<"nbinx.."<<nbinx<<endl;
                     binmean_Lt = allocate4d_float(NVIEWS,NBANDS,num_gridlines,nbinx2);     
                     bincount = allocate4d_int(NVIEWS,NBANDS,num_gridlines,nbinx2);//all bands together, only 1 view for OCI
 
                  //  binmean_Lt = allocate3d_float(num_gridlines,nbinx,nbands);
                  //  bincount = allocate3d_int(num_gridlines,nbinx,nbands);//all bands together, only 1 view for OCI
                  for(size_t v=0;v<NVIEWS;v++){
                    for(size_t b=0;b<NBANDS;b++){
                         for(int j=0;j<num_gridlines;j++){
                              for(int  i=0;i<nbinx2;i++){
                                   binmean_Lt[v][b][j][i]=0.;
                                   bincount[v][b][j][i]=0;
                             }}}}
 
                            }//end if first time allocating mem for binning arrays
 
               if(format.type==FT_SPEXONE){
                //assigning mem for Lt of different bands **********************
                latpix = (float*)calloc(num_pixels , sizeof(float));
                lonpix = (float*)calloc(num_pixels , sizeof(float));
                Lt_pix = allocate2d_float(num_pixels,NBANDS);//blue bands
                Lt_pix2 = allocate2d_float(num_pixels,NBANDS_POL);//red bands
                    }
               else if(format.type==FT_HARP){
                latpix = (float*)calloc(num_pixels , sizeof(float));
                lonpix = (float*)calloc(num_pixels , sizeof(float));
                Lt_pix4 = (float*)calloc(num_pixels , sizeof(float));
               }    
               else{
                senazpix=(float*)calloc(num_pixels , sizeof(float));
                latpix = (float*)calloc(num_pixels , sizeof(float));
                lonpix = (float*)calloc(num_pixels , sizeof(float));
                Lt_pix = allocate2d_float(num_blue_bands, num_pixels);//blue bands
                Lt_pix2 = allocate2d_float(num_red_bands, num_pixels);//red bands
                Lt_pix3 = allocate2d_float(num_SWIR_bands, num_pixels);//S
               }
 
//BIG SCANLINE LOOP----------------------------------
                //********************************************************************************
                 //-----reading line by line-----------------------------------           
 
                for (unsigned int sline = last_sline;sline < num_scans;sline++) {
 
        //lat and lon--
                    start[0] = sline;
                    start[1] = 0;
                    count[0] = 1;
                    count[1] = num_pixels;               // 1 line at a time
                   if(format.type==FT_SPEXONE){
                      status = nc_get_vara_float(geoGrp, latId, start, count, latpix);
                      status = nc_get_vara_float(geoGrp, lonId, start, count, lonpix);
                     }
                   else if(format.type==FT_HARP){
                      status = nc_get_vara_float(v1Grp, latId, start, count, latpix);
                      status = nc_get_vara_float(v1Grp, lonId, start, count, lonpix);
                    }    
                   else{ //OCIS 
                    status = nc_get_vara_float(geoGrp, senazId, start, count, senazpix);//-1800 to + 1800 s means s as scaled
                    status = nc_get_vara_float(geoGrp, latId, start, count, latpix);
                    status = nc_get_vara_float(geoGrp, lonId, start, count, lonpix);
                   }
 
        //Lt
 
                   if(format.type==FT_SPEXONE){
                    start2[0] = sline;
                    start2[1] = 0;
                    start2[2] = 0;
 
                    count2[0] = 1;
                    count2[1] = num_pixels;               // 1 line at a time
                    count2[2] = NBANDS;
 
                    count3[0] = 1;
                    count3[1] = num_pixels;               // 1 line at a time
                    count3[2] = NBANDS_POL;
 
                    status = nc_get_vara_float(obsGrp, Lt_blueId, start2, count2, Lt_pix[0]);//all intensity bands
                    status = nc_get_vara_float(obsGrp, Lt_redId, start2, count3, Lt_pix2[0]);//all poalrized bands
                      }
                   //Lt_pix4
                   else if (format.type==FT_HARP){
                    status = nc_get_vara_float(v1Grp, I_Id, start, count, Lt_pix4);//blue band
                   }    
                   else{ //OCIS
                    start2[0] = 0;
                    start2[1] = sline;
                    start2[2] = 0;
 
                    count2[0] = num_blue_bands;
                    count2[1] = 1;               // 1 line at a time
                    count2[2] = num_pixels;
 
                    count3[0] = num_red_bands;
                    count3[1] = 1;               // 1 line at a time
                    count3[2] = num_pixels;
 
                    count4[0] = num_SWIR_bands;
                    count4[1] = 1;               // 1 line at a time
                    count4[2] = num_pixels;
 
                    status = nc_get_vara_float(obsGrp, Lt_blueId, start2, count2, Lt_pix[0]);
                    status = nc_get_vara_float(obsGrp, Lt_redId, start2, count3, Lt_pix2[0]);
                    status = nc_get_vara_float(obsGrp, Lt_SWIRId, start2, count4, Lt_pix3[0]);
                   }
 
 
                    /*      for(int bb=0;bb<num_blue_bands;bb++){
                               cout<<"processing blue band #.........................................................................."<<bb+1<<"of total blue bands #.."<<num_blue_bands<<endl;
                               cout<<"Lt_pix at pix =0..."<<Lt_pix[bb][0]<<"Lt_pix at pix =1..."<<Lt_pix[bb][1]<<endl;
                              }
                           exit(1);
                   */
 
                    for (unsigned int pix = 0;pix < num_pixels;pix++) {
                        if (latpix[pix] < latmin_swt) latmin_swt = latpix[pix];
                        if (latpix[pix] > latmax_swt) latmax_swt = latpix[pix];
                        if (lonpix[pix] < lonmin_swt) lonmin_swt = lonpix[pix];
                        if (lonpix[pix] > lonmax_swt) lonmax_swt = lonpix[pix];
 
                  //       cout<<"senazpix (sensor azimuth)...in degrees."<<senazpix[pix]/100<<"at pix #..."<<pix+1<<"latpix.."<<latpix[pix]<<endl;                        
                    }
 
                  
 
              //        cout<<"nadpix..."<<nadpix<<"latpix[nadpix]..."<<latpix[nadpix]<<"lonpix[nadpix]..."<<lonpix[nadpix]<<endl;         
             //         cout<<"dlatb_g[k][0]...."<<dlatb_g[k][0]<<"dlatb_g[k][1]...."<<dlatb_g[k][1]<<endl;
             //        cout<<"senazpix (sensor azimuth)...in degrees."<<senazpix[nadpix]/100<<"at line #..."<<sline+1<<"latpix[nadpix].."<<latpix[nadpix]<<endl;
 
                    dlamin = 0.;dlamax = 0.;
 
                    //inside the 'k' box??----- ascending ----------                   
                    if (latpix[nadpix] >= dlatb_g[k][0] && latpix[nadpix] <= dlatb_g[k][1]) {
 
                        if (sline % 100 == 0) cout << "EVERY 100 gds..for k group.." << k + 1 << "file number #.." << l1cfile->selgran[findex] << "sline..." << sline + 1 << "# of binned pix.." << inpix << "outpix.." << outpix << endl;
 
   //*********** BIG LOOP M_PIXEL *****************************************************************
                        for (unsigned int pix = 0;pix < num_pixels;pix++) {
 
                            sb=0,bb=0,rb=0,swb=0,ib=0;
                            gd_row=0,gd_col=0;
                            flag_inpix = 0;
 
                            boolbin1 = sbs2_l1c(l1cinput, num_gridlines, nbinx, lat_asort, index_xy, latpix[pix], lonpix[pix], lon_gd, &gd_row, &gd_col);
 
                            bin_ypix = gd_row + 1;
                            bin_xpix = gd_col + 1;
 
                     //       cout<<"pix..."<<pix+1<<"latpix..."<<latpix[pix]<<"lonpix..."<<lonpix[pix]<<endl;
 
                            if (boolbin1 == 1) flag_inpix = 1;
                            //************ BINNING ***************************
                         //assign identified pixel to Lt and bin stat arrays-----         
                        
         //BLUE---         
                            if (flag_inpix == 1 && bin_xpix >= 1 && bin_ypix >= 1 && bin_xpix <= nbinx && bin_ypix <= num_gridlines) {
                                inpix++;
                              if(format.type==FT_SPEXONE){
                                  view=0;   
                                   while (sb<NBANDS) {
                                      if (Lt_pix[pix][ib] > 0.) {
                                         //     cout<<"Lt_pix[pix][ib]..."<<Lt_pix[pix][ib]<<"bin_ypix.."<<bin_ypix<<"bin_xpix.."<<bin_xpix<<endl;
                                              binmean_Lt[view][ib][bin_ypix - 1][bin_xpix - 1] = binmean_Lt[view][ib][bin_ypix - 1][bin_xpix - 1] + Lt_pix[pix][ib];
                                              bincount[view][ib][bin_ypix - 1][bin_xpix - 1] += 1;
                                           }
                                    ib++;
                                    sb++;
                                }//end while intensity bands
 
/*                                    while (sb<num_blue_bands) {
                                      if (Lt_pix2[bb][pix] > 0.) {
                                              binmean_Lt[view][sb][bin_ypix - 1][bin_xpix - 1] = binmean_Lt[view][sb][bin_ypix - 1][bin_xpix - 1] + Lt_pix2[bb][pix];
                                              bincount[view][sb][bin_ypix - 1][bin_xpix - 1] += 1;
                                           }
                                    bb++;
                                    sb++;
                                }//end while polarization bands
*/
                              }
                              if(format.type==FT_HARP){
                                  view=0,sb=0;
                                  if (Lt_pix4[pix] > 0.) {
                                         //     cout<<"Lt_pix[pix][ib]..."<<Lt_pix[pix][ib]<<"bin_ypix.."<<bin_ypix<<"bin_xpix.."<<bin_xpix<<endl;
                                              binmean_Lt[view][ib][bin_ypix - 1][bin_xpix - 1] = binmean_Lt[view][ib][bin_ypix - 1][bin_xpix - 1] + Lt_pix4[pix];
                                              bincount[view][ib][bin_ypix - 1][bin_xpix - 1] += 1;
                                           }
                                    ib++;
                                    sb++;
                                 }
                              else{ //OCIS 
                                if(senazpix[nadpix]/100<0) view=0; else view=1;
                                while (sb<num_blue_bands) {
                                      if (Lt_pix[bb][pix] > 0.) {
                                              binmean_Lt[view][sb][bin_ypix - 1][bin_xpix - 1] = binmean_Lt[view][sb][bin_ypix - 1][bin_xpix - 1] + Lt_pix[bb][pix];
                                              bincount[view][sb][bin_ypix - 1][bin_xpix - 1] += 1;                                                                                       
                                           }
                                    bb++;
                                    sb++;
                                }//end while blue band band 
                                
        //RED---
                                while (sb <num_blue_bands+num_red_bands) {
                                    if (Lt_pix2[rb][pix] > 0.) {
                                        binmean_Lt[view][sb][bin_ypix - 1][bin_xpix - 1] = binmean_Lt[view][sb][bin_ypix - 1][bin_xpix - 1] + Lt_pix2[rb][pix];
                                        bincount[view][sb][bin_ypix - 1][bin_xpix - 1] += 1;
                                    }
                                    rb++;
                                    sb++;
                                }//end red bands
 
       //SWIR----
                                while (sb <num_blue_bands + num_red_bands + num_SWIR_bands) {
                                    if (Lt_pix3[swb][pix] > 0.) {
                                        binmean_Lt[view][sb][bin_ypix - 1][bin_xpix - 1] = binmean_Lt[view][sb][bin_ypix - 1][bin_xpix - 1] + Lt_pix3[swb][pix];
                                        bincount[view][sb][bin_ypix - 1][bin_xpix - 1] += 1;
                                    }
                                    swb++;
                                    sb++;
                                }//end swir bands
                             }
 
                            }//end if inpix==1
                       
 
 
    //********** pixel AREA WEIGHTING ************************
                            if (flag_inpix == 0) outpix++;
 
                            totpix++;
 
                        }//end pixels loop
 
                    
                        //END OF FILE--****** reset starting sline index if last line processed and within k box
                        //go for another granule if it is not the last one---------------
                        if (sline == num_scans - 1) {
                            flag_donefile = 1;
                            cout << "end of file..." << l1cfile->selgran[findex] << endl;
                            last_sline = 0;
                            if (findex >= sfiles - 1) {
                                cout << "done with last granule of the input list........................." << endl;
                                //   findex=sfiles;
                                k = ngroups;
                                break;
                            }
 
                        }//end of file/last file? sliine=num_scans-1
                        else flag_donefile = 0;
 
                    }//end latpix nadir of line x inside grid group?
 
         //***** skip lines and files if sline is not within k group ********
              //increase k and screen files and lines again starting from the last binning
 
                    if (latpix[nadpix] > lat_gd[n_gdlines - 1][257] && k < ngroups - 1) { //else limits 
                       if(format.type==FT_SPEXONE){
                        cout << "moving to the next k group...scanning again files/slines.." << endl;
                        cout << "group #.."<<k+1<<"file index.." << findex << "sline index.." << sline << endl;
                        last_file = findex;
                        last_sline = sline;
                        findex = sfiles;
                        sline = num_scans - 1;
                          }
                       else{ //OCIS  
                        cout << "moving to the next k group...scanning again files/slines.." << endl;
                        cout << "file index.." << findex << "last sline index.." << sline << endl;
                        last_file = findex;
                        last_sline = sline;
                        findex = sfiles;
                        sline = num_scans - 1;
                       }
                    }//end if lat >grid lat--IF outside the box
 
                    if (sline + 1 % 100 == 0) cout << "for k group.." << k + 1 << "selected granule #.." << l1cfile->selgran[findex] << "sline..." << sline + 1 << "# of binned pix.." << inpix << "totpix.." << totpix << "outpix.." << outpix << endl;
                }//end for scanlines
 
                cout << "closing L1B file......." << ptstr << endl;
                status = nc_close(ncid_L1B);
                check_err(status, __LINE__, __FILE__);
 
                if (latpix != nullptr)
                   delete[](latpix);
                if (lonpix != nullptr)
                   delete[](lonpix);
                if (Lt_pix != nullptr)
                   delete[](Lt_pix);
                if (Lt_pix2 != nullptr)
                   delete[](Lt_pix2);
                if (Lt_pix3 != nullptr)
                   delete[](Lt_pix3);
                if (senazpix != nullptr)
                   delete [](senazpix);
 
                if(latframe1!=nullptr)
                  delete [](latframe1);
                if(latframe2!=nullptr)
                    delete [](latframe2);
                if(latframe3!=nullptr)
                  delete [](latframe3);
                if(lonframe1!=nullptr)
                  delete [](lonframe1);
                if(lonframe2!=nullptr)
                  delete [](lonframe2);
                if(lonframe3!=nullptr)
                  delete [](lonframe3);
                 if (Lt_pix4 != nullptr)
                   delete[](Lt_pix4);
 
                //**********************************************************************************************************************************
                //**********************************************************************************************************************************
                //writing each granule ---------------------------------
                //*****************************************************************************
 
                if (flag_donefile == 1 | (flag_donefile == 0 && k == ngroups - 1)) {
                    cout << "writing file #....................................................................................................................." << l1cfile->selgran[findex] << "based on group #.." << k + 1 << endl;
 
         //           exit(1);
                    
                    //write mean Lt as nc file---
                   //**********************************************************************
                   //**********************************************************************8
                   //create Lt file
                    pathstr = "out/";
                    senstr = "OCIS_";
                    monstr = std::to_string(selmon);
                    daystr = std::to_string(selday);
                    yearstr = std::to_string(selyear);
                    prodstr = "binLt_sbs";
                    swtstr = "_swt";
                    granstr = "";
                    granstr = "_" + std::to_string(l1cfile->selgran[findex]);
 
                    if (l1cfile->l1c_pflag >= 3) {
                        swtd = l1cfile->swtnum;
                        swtnum = std::to_string(swtd);
                        cout << "swtnum.." << swtnum << endl;
                    }
                    else swtnum = std::to_string(swtd);
 
                    extstr = ".nc";
                    string GATT_NAME1,GATT_VAL1,GATT_NAME2,GATT_VAL2;
 
                     if(format.type==FT_SPEXONE){                         
                         senstr = "SPEXONE";
                         GATT_NAME1="Title",GATT_VAL1="PACE SPEXone Level-1C Data",GATT_NAME2="instrument",GATT_VAL2="SPEXone";
                         ibin_ini=279;//initial index gridlines
                         ibin_end=319;//initial index gridlines                         
                     }
                     if(format.type==FT_HARP){
                         senstr = "HARP2";
                         GATT_NAME1="Title",GATT_VAL1="PACE HARP Level-1C Data",GATT_NAME2="instrument",GATT_VAL2="HARP";
                         ibin_ini=0;//initial index gridlines
                         ibin_end=599;//initial index gridlines
                     }
                     else//OCIS
                     {
                         senstr = "OCI";
                         GATT_NAME1="Title",GATT_VAL1="PACE OCI Level-1C Data",GATT_NAME2="instrument",GATT_VAL2="OCI";
                         ibin_ini=92;//initial index gridlines 
                         ibin_end=506;//initial index gridlines
                     }
 
 
 
                    fname_out = pathstr + missionstr + "_" + senstr + "." + yearstr + monstr + daystr + timestr + prodstr+granstr+extstr;
 
                    string  ATT_NAME="Units", ATT_VAL="degrees",GATT_NAME3="processing_version",GATT_VAL3="V1.0",GATT_NAME4="Conventions",GATT_VAL4="CF-1.6";
                    string GATT_NAME5="institution",GATT_VAL5="NASA Goddard Space Flight Center, Ocean Biology Processing Group",GATT_NAME6="license",GATT_VAL6="http://science.nasa.gov/earth-science/earth-science-data/data-information-policy/";
                    string GATT_NAME7="naming_authority",GATT_VAL7="gov.nasa.gsfc.sci.oceancolor",GATT_NAME8="keywords_vocabulary",GATT_VAL8="NASA Global Change Master Directory (GCMD) Science Keywords";
                    string GATT_NAME9="stdname_vocabulary",GATT_VAL9="NetCDF Climate and Forecast (CF) Metadata Convention",GATT_NAME10="creator_name",GATT_VAL10="NASA/GSFC",GATT_NAME11="creator_email",GATT_VAL11="data@oceancolor.gsfc.nasa.gov";
                    string GATT_NAME12="creator_url",GATT_VAL12="http://oceancolor.gsfc.nasa.gov",GATT_NAME13="project",GATT_VAL13="PACE Project",GATT_NAME14="publisher_name",GATT_VAL14="NASA/GSFC";
                    string GATT_NAME15="publisher_email",GATT_VAL15="data@oceancolor.gsfc.nasa.gov",GATT_NAME16="publisher_url",GATT_VAL16="http://oceancolor.gsfc.nasa.gov",GATT_NAME17="processing_level",GATT_VAL17="L1C";
                    string GATT_NAME18="cdm_data_type",GATT_VAL18="swath",GATT_NAME19="orbit_number",GATT_VAL19="12345",GATT_NAME20="history",GATT_VAL20="",GATT_NAME21="CDL_version_date",GATT_VAL21="2021-09-10",GATT_NAME22="product_name",GATT_VAL22=fname_out;
                    string GATT_NAME23="startDirection",GATT_VAL23="Ascending",GATT_NAME24="endDirection",GATT_VAL24="Ascending",GATT_NAME25="time_coverage_start",GATT_VAL25=yearstr+"-"+monstr+"-"+daystr+"-"+timestr,GATT_NAME26="time_coverage_end",GATT_VAL26=yearstr+"-"+monstr+"-"+daystr+"-"+timestr,GATT_NAME27="date{_created",GATT_VAL27="2021-09-10T15:12:41Z",GATT_NAME28="sun_earth_distance",GATT_VAL28="0.990849042172323",GATT_NAME29="terrain_data_source",GATT_VAL29="",GATT_NAME30="spectral_response_function",GATT_VAL30="",GATT_NAME31="systematic_uncertainty_model",GATT_VAL31="",GATT_NAME32="nadir_bin",GATT_VAL32="12345",GATT_NAME33="bin_size_at_nadir",GATT_VAL33="5.2km2";
 
                    l1cfile->gridname = fname_out.c_str();
                    filename_lt = fname_out.c_str();                       
  
                    if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
                        check_err(status, __LINE__, __FILE__);
                 //define dims
                     // Define the dimensions,vars and attributes at the root level
                    NDIMS=2;
                    NDIMS2=3;
                    NDIMS3=4;
                    NY = num_gridlines;
 
 
                    if(format.type==FT_SPEXONE){
                     NX = 40;                                                   
                      }
                    else if(format.type==FT_HARP){
                     NX = 600;
                      }
                    else{//legacy such OCI
                     NX=514;
                      }
 
                    //NVIEWS= 2;//for OCI
                   // NBANDS=249;//for OCI
 
                    NY1 = l1cfile->NY1;//these are indexes not line #!!!!!!!!!!!!!!!!!
                    NY2 = l1cfile->NY2;
                    cout << "rowgrid ini.." << NY1 << "rowgrid end.." << NY2 << endl;
                    NY = NY2 - NY1 + 1;
                    cout << "NY.." << NY << "NX.." << NX << "NY1.."<<NY1<<"NY2.."<<NY2<<endl;
 
  //DEF DIMENSIONS
                    if ((status = nc_def_dim(ncid_out, "bins_across_track", NX, &x_dimid)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_dim(ncid_out, "bins_along_track", NY, &y_dimid)))
                           check_err(status, __LINE__, __FILE__);
                   //dims for output var
                    dimids[0] = y_dimid;
                    dimids[1] = x_dimid;
                  
                    if ((status = nc_def_dim(ncid_out, "number_of_views", NVIEWS, &v_dimid)))
                       check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_dim(ncid_out, "intensity_bands_per_view", NBANDS, &b_dimid)))
                      check_err(status, __LINE__, __FILE__);
 
                    dimids2[0] = y_dimid;
                    dimids2[1] = x_dimid;
                    dimids2[2] = v_dimid;//#o
 
                    dimids3[0] = y_dimid;
                    dimids3[1] = x_dimid;
                    dimids3[2] = v_dimid;//
                    dimids3[3] = b_dimid;
 
                    /*     try
                           {
                            cout<<"Opening file \"firstFile.nc\" with NcFile::replace"<<endl;
                            NcFile ncFile("firstFile.nc",NcFile::replace);
                            NcGroup groupA(ncFile.addGroup("groupA"));
                            }
 
                         catch (NcException& e)
                             {
                               cout << "unknown error"<<endl;
                                e.what();
                                 }
                         exit(1);
                        */
                    //define attributes
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME1.c_str(), strlen(GATT_VAL1.c_str()),
                        GATT_VAL1.c_str()))
                       check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME2.c_str(), strlen(GATT_VAL2.c_str()),
                         GATT_VAL2.c_str()))
                       check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME3.c_str(), strlen(GATT_VAL3.c_str()),
                         GATT_VAL3.c_str()))
                          check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME4.c_str(), strlen(GATT_VAL4.c_str()),
                            GATT_VAL4.c_str()))
                           check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME5.c_str(), strlen(GATT_VAL5.c_str()),
                         GATT_VAL5.c_str()))
                          check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME6.c_str(), strlen(GATT_VAL6.c_str()),
                          GATT_VAL6.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME7.c_str(), strlen(GATT_VAL7.c_str()),
                           GATT_VAL7.c_str()))
                           check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME8.c_str(), strlen(GATT_VAL8.c_str()),
                          GATT_VAL8.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME9.c_str(), strlen(GATT_VAL9.c_str()),
                          GATT_VAL9.c_str()))
                         check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME10.c_str(), strlen(GATT_VAL10.c_str()),
                          GATT_VAL10.c_str()))
                          check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME11.c_str(), strlen(GATT_VAL11.c_str()),
                           GATT_VAL11.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME12.c_str(), strlen(GATT_VAL12.c_str()),
                            GATT_VAL12.c_str()))
                           check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME13.c_str(), strlen(GATT_VAL13.c_str()),
                             GATT_VAL13.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME14.c_str(), strlen(GATT_VAL14.c_str()),
                             GATT_VAL14.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME15.c_str(), strlen(GATT_VAL15.c_str()),
                             GATT_VAL15.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME16.c_str(), strlen(GATT_VAL16.c_str()),
                             GATT_VAL16.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME17.c_str(), strlen(GATT_VAL17.c_str()),
                             GATT_VAL17.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME18.c_str(), strlen(GATT_VAL18.c_str()),
                             GATT_VAL18.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME19.c_str(), strlen(GATT_VAL19.c_str()),
                             GATT_VAL19.c_str()))
                          check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME20.c_str(), strlen(GATT_VAL20.c_str()),
                             GATT_VAL20.c_str()))
                              check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME21.c_str(), strlen(GATT_VAL21.c_str()),
                             GATT_VAL21.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME22.c_str(), strlen(GATT_VAL22.c_str()),
                             GATT_VAL22.c_str()))
                           check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME23.c_str(), strlen(GATT_VAL23.c_str()),
                              GATT_VAL23.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME24.c_str(), strlen(GATT_VAL24.c_str()),
                              GATT_VAL24.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME25.c_str(), strlen(GATT_VAL25.c_str()),
                           GATT_VAL25.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME26.c_str(), strlen(GATT_VAL26.c_str()),
                           GATT_VAL26.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME27.c_str(), strlen(GATT_VAL27.c_str()),
                             GATT_VAL27.c_str()))
                              check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME28.c_str(), strlen(GATT_VAL28.c_str()),
                             GATT_VAL28.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME29.c_str(), strlen(GATT_VAL29.c_str()),
                             GATT_VAL29.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME30.c_str(), strlen(GATT_VAL30.c_str()),
                             GATT_VAL30.c_str()))
                              check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME31.c_str(), strlen(GATT_VAL31.c_str()),
                             GATT_VAL31.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME32.c_str(), strlen(GATT_VAL32.c_str()),
                              GATT_VAL32.c_str()))
                                check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME33.c_str(), strlen(GATT_VAL33.c_str()),
                                GATT_VAL33.c_str()))
                                check_err(status, __LINE__, __FILE__);
 
                    //define groups                  check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_grp(ncid_out, "geolocation_data", &grp_coor)))  //netcdf-4
                         check_err(status, __LINE__, __FILE__);
                     //def var grp1
                    if ((status = nc_def_var(grp_coor, "latitude", NC_FLOAT, NDIMS,
                         dimids, &varid1)))
                          check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_var(grp_coor, "longitude", NC_FLOAT, NDIMS,
                            dimids, &varid2)))
                          check_err(status, __LINE__, __FILE__);
 
                    //leave define mode-----------------------
                    if ((status = nc_enddef(grp_coor))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
 
 
                    if ((status = nc_def_grp(ncid_out, "observation_data", &grp_obs)))  //netcdf-4
                        check_err(status, __LINE__, __FILE__);
 
                    //def var grp2
                        //counts and Lt
                    if ((status = nc_def_var(grp_obs, "obs_per_view", NC_INT, NDIMS2,
                        dimids2, &varid_count)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_var(grp_obs, "I", NC_FLOAT, NDIMS3,
                        dimids3, &varid_lt)))
                        check_err(status, __LINE__, __FILE__);
 
                    //leave define mode-----------------------
                    if ((status = nc_enddef(grp_obs))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
                   
 
                    lat_out = allocate2d_float(NY, NX);
                    lon_out = allocate2d_float(NY, NX);
 
                    int c = 0;
 
                    for (int i = NY1; i < NY2 + 1; i++) {
                //        for (int j = 0; j < NX; j++) {
                        for (int j = ibin_ini; j < ibin_end; j++) {
                            lat_out[NY - 1 - c][NX - 1 - j] = lat_gd[i][j];
                            lon_out[NY - 1 - c][j] = lon_gd[i][j];
                        }
                        c++;
                    }
 
 
                    if ((status = nc_put_var_float(grp_coor, varid1, &lat_out[0][0])))
                        check_err(status, __LINE__, __FILE__);
 
                    if ((status = nc_put_var_float(grp_coor, varid2, &lon_out[0][0])))
                        check_err(status, __LINE__, __FILE__);
 
                    
           //alloc mem for output variables obs_per_view and I as part of the observation_data group
                    data_out = allocate3d_int(NY, NX,NVIEWS);
                    data_out2 = allocate4d_float(NY, NX,NVIEWS,NBANDS);
                                    
            //BINCOUNT ARRAY            
               for (size_t v = 0; v < NVIEWS; v++) {
                        for (int i = NY1; i < NY2 + 1; i++) {
                             for (int j = ibin_ini; j < ibin_end; j++) {
        //                    for (int j = 0; j < NX; j++) {
                                 data_out[i][j][v]=0;
                            }}}
            
            
 
                   c = 0;
 
                      for (size_t v = 0; v < NVIEWS; v++) {
                        for (int i = NY1; i < NY2 + 1; i++) {
                             for (int j = ibin_ini; j < ibin_end; j++) {
//                            for (int j = 0; j < NX; j++) {
                                for (sb = 0;sb < nbands;sb++) {
                                    if(bincount[v][sb][i][j]>0)                                   
                                         data_out[NY - 1 - c][NX - 1 - j][v]+=bincount[v][sb][i][j]; 
                                    else
                                         data_out[NY - 1 - c][NX - 1 - j][v]+=0;
                                }                                    
                            }                                              
                            c++;
                        }
                        c=0;
                      }
 
 
 
                        cout << "writing countbin for all band ."<< endl;
                       if ((status = nc_put_var_int(grp_obs, varid_count, &data_out[0][0][0])))
                            check_err(status, __LINE__, __FILE__);
 
            // LT ARRAYS
                    c=0;
                    for (size_t b = 0;b <NBANDS;b++) {
                      for (size_t v = 0; v < NVIEWS; v++) {
                        for (int i = NY1; i < NY2 + 1; i++) {
                             for (int j = ibin_ini; j < ibin_end; j++) {
//                            for (int j = 0; j < NX; j++) {
                                if (bincount[v][b][i][j] > 0)
                                    data_out2[NY - 1 - c][NX - 1 - j][v][b] = binmean_Lt[v][b][i][j] / bincount[v][b][i][j];
                                else         data_out2[NY - 1 - c][NX - 1 - j][v][b] = NAN;
                            }
                            c++;
                        }
                        c=0;
                       }//end views                 
                     }//end for bands
 
 
 
                         cout << "writing Lt for all bands.."<< endl;
                        if ((status = nc_put_var_float(grp_obs, varid_lt, &data_out2[0][0][0][0])))
                            check_err(status, __LINE__, __FILE__);
 
                            
                    delete [] (data_out);
                    delete [] (data_out2);
 
                    delete[](lat_out);
                    delete[](lon_out);
 
                    delete[](bincount);
                    delete[](binmean_Lt);
 
                    if ((status = nc_close(ncid_out)))
                        check_err(status, __LINE__, __FILE__);
                                              
                    lat_out = nullptr;;
                    lon_out = nullptr;
                    data_out = nullptr;
                    data_out2 = nullptr;                                              
                    bincount = nullptr;
                    binmean_Lt = nullptr;
             
                    flag_donefile = 0;
                }//end writing file
            }//end for files loop
 
            cout << "group k at the end of big loop" << k + 1 << endl;
 
            
        }//groups
 
        cout << "number of files per swath.." << nfiles_swt[swtd - 1] << "for swath.." << swtd << endl;
        cout << "total inpix.." << inpix << "total pix.." << totpix << endl;
        //  cout<<"binned pixels.."<<inpix<<"as %.."<<(inpix/(num_pixels*num_scans*n_files*nfiles_swt[swtd-1]))*100<<endl;
        delete[](lat_asort);
        //   delete [] (lon_asort);
        delete[](index_xy);
        //   delete [] (index_xy2);
        delete[](dlatb_g);
        delete[](dlonb_g);
 
        delete[](lat_gd);
        delete[](lon_gd);
        delete[](az_east);
 
        printf("*** SUCCESS writing bincount and binLt rasters as nc..!\n");
        cout << "finish processing swath eq crossing day..." << swtd << endl;
        cout << "done writing Lt to nc file.." << endl;
 
        return(0);
    }
 
 
 
   //similar to version 6 but including HARP 
    int32_t L1C::binL1C_wgranule6(int swtd, l1c_filehandle* l1cfile, L1C_input* l1cinput, int16_t* swtd_id, int16_t* odir, int16_t* file_id, int16_t* nfiles_swt) {
        size_t ybins,xbins;
        int32_t gdlines_group, ngroups = 0, num_gridlines,nbinx2, nbinx, inpix = 0, outpix = 0, totpix = 0, n_gdlines;//number of gridlines to be processed
        float minv = 0., maxv = 0., ** dlatb_g, ** dlonb_g;
        int16_t fi = 0;
        std::string str;
        const char* ptstr;
        int dimid, dimid2,dimid3,status, ncid_out,ncid_az,ncid_grid,b_dimid,v_dimid,x_dimid,y_dimid,varid1,varid2,varid_count,varid_lt,azId,NDIMS,NDIMS2,NDIMS3,senazId;
        size_t start[] = { 0, 0 };
        size_t count[] = { 1, 1 };
        size_t start2[] = { 0, 0, 0 };
        size_t count2[] = { 1, 1, 1 }, count3[] = { 1, 1, 1 }, count4[] = { 1, 1, 1 };
        int32_t bin_xpix, bin_ypix;
        float* latpix=nullptr, * lonpix=nullptr, ** Lt_pix=nullptr, ** Lt_pix2=nullptr, ** Lt_pix3=nullptr,mean_az_east,*senazpix=nullptr;
     
        float latmin_swt = 100, latmax_swt = 0, lonmin_swt = 0, lonmax_swt = 0;
        int dimids[2],dimids2[3],dimids3[4];
        const char* filename_lt;
        int32_t NY = -1, NX = -1, NY1 = -1, NY2 = -1,c1 = 1;
        float****data_out2=nullptr,** lat_out, ** lon_out;
        int ***data_out=nullptr;
        int last_file, last_sline, flag_inpix, flag_donefile;;//first index file id, second index line #
        short** index_xy;
        float** lat_asort;
        bool boolbin1;
        char* ifile_char;
        std::string ifile_str;
 
        int16_t selyear = -1, selmon = -1, selday = -1;
        float** lat_gd, ** lon_gd, * az_east;
        string gridname, azeast_name;
        float**** binmean_Lt = nullptr;
        int ****bincount=nullptr;
        double gres = (l1cinput->gres) * 1000, dlamin, dlamax, dlomin, dlomax;
        int grp_obs,grp_coor,geoGrp,obsGrp;
        size_t sb=0,bb = 0, rb = 0, swb = 0,ib=0, NVIEWS=-1,NBANDS=-1,NBANDS_POL=-1;
        int view;
        float sum=0,tot=0;
        char tmp[256];
        short gd_row, gd_col;
 
 
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
     
     //random seed
        srand((unsigned int)time(NULL));
        //nadir pixel ofr OCI
        int nadpix = l1cfile->nadpix;
 
 
        num_gridlines = 4000;
        nbinx2 = l1cfile->nbinx;
        num_pixels = l1cfile->npix;
 
        size_t sfiles = 0;
 
        if (l1cfile->selgran[0] < 0)//process all granules
        {
            sfiles = nfiles_swt[swtd - 1];
            for (unsigned int j = 0;j < sfiles;j++) l1cfile->selgran[j] = j + 1;
        }
        else {
            while (l1cfile->selgran[sfiles] > 0) {
                cout << "selected granule #..........................." << l1cfile->selgran[sfiles] << endl;
                sfiles++;
            }
        }
 
       cout<<"binning Lt using sbs2 method and composite indexes for arrays..................................................................."<<endl;
 
 
              //allocate mem for lat/lon/azeast pointers---
        selday = l1cinput->selday;
        selmon = l1cinput->selmon;
        selyear = l1cinput->selyear;
 
        std::string fname_out, pathstr, senstr, monstr, daystr, yearstr, prodstr, gdstr, swtstr, swtnum, extstr, granstr,timestr,azstr,missionstr;
 
        pathstr = "out/";
        missionstr="PACE";
        senstr = "OCIS";
        monstr = std::to_string(selmon);
        daystr = std::to_string(selday);
        yearstr = std::to_string(selyear);
        timestr="T00:00:00Z";
        prodstr = "L1Cgrid";
        swtstr = "_swt";
        extstr = ".nc";
 
        if (l1cfile->l1c_pflag >= 3) {
            swtd = l1cfile->swtnum;
            swtnum = std::to_string(swtd);
            cout << "swtnum.." << swtnum << endl;
        }
        else swtnum = std::to_string(swtd);
 
 
        getcwd(tmp, 256);
        pathstr=tmp;
 
//open lat/lon L1C grid --------------------------------------
    //PACE_OCIS.2019321T00:00:00ZL1Cgrid.nc
        prodstr = "L1Cgrid";
        gridname = pathstr + "/out/"+missionstr + "_" + senstr + "." + yearstr + monstr + daystr + timestr + prodstr+extstr;
 
    //open file
        ifile_str = l1cinput->files[0];
        ifile_char = &ifile_str[0];
        file_format format = getFormat(ifile_char);
 
        if(format.type==FT_SPEXONE){
            senstr = "SPEXONE";
            ptstr="/accounts/mamontes/images/OCIS/sean/out/PACE_OCIS.2019321T00:00:00ZL1Cgrid.nc";
            }
        else{
        ptstr = gridname.c_str();
         }
 
        status = nc_open(ptstr, NC_NOWRITE, &ncid_grid);
          if (status != NC_NOERR) {
              fprintf(stderr, "nc_open error.\n");
               exit(EXIT_FAILURE);
          }
       //groups
        if(format.type==FT_SPEXONE){
     //     status = nc_inq_grp_ncid(ncid_grid, "GEOLOCATION_DATA", &geoGrp);
    //            check_err(status, __LINE__, __FILE__);
                status = nc_inq_grp_ncid(ncid_grid, "geolocation_data", &geoGrp);//using OCIS L1C grid file..
                check_err(status, __LINE__, __FILE__);            
          }
        else{  
                status = nc_inq_grp_ncid(ncid_grid, "geolocation_data", &geoGrp);
                check_err(status, __LINE__, __FILE__);
               }
 
        status = nc_inq_dimid(ncid_grid, "bins_along_track", &y_dimid);
            check_err(status, __LINE__, __FILE__);
        nc_inq_dimlen(ncid_grid, y_dimid, &ybins);
        status = nc_inq_dimid(ncid_grid, "bins_across_track", &x_dimid);
            check_err(status, __LINE__, __FILE__);
 
        nc_inq_dimlen(ncid_grid, x_dimid, &xbins);
        nc_inq_dimlen(ncid_grid, y_dimid, &ybins);
 
         //************************************************************
        //mem allocation for geolocation pointers---
        num_gridlines=ybins;
        nbinx=xbins;
 
        cout<<"num_gridlines"<<num_gridlines<<"nbinx"<<nbinx<<endl;
        az_east = (float*)calloc(num_gridlines , sizeof(float));
        lat_gd = allocate2d_float(num_gridlines, nbinx);
        lon_gd = allocate2d_float(num_gridlines, nbinx);
 
        status = nc_inq_varid(geoGrp, "latitude", &latId);//scans x velements
                check_err(status, __LINE__, __FILE__);
        status = nc_inq_varid(geoGrp, "longitude", &lonId);//scans x velements
                check_err(status, __LINE__, __FILE__);
        status = nc_get_var_float(geoGrp, latId, &lat_gd[0][0]);
                check_err(status, __LINE__, __FILE__);
        status = nc_get_var_float(geoGrp, lonId, &lon_gd[0][0]);
                check_err(status, __LINE__, __FILE__);
//close file
        if ((status = nc_close(ncid_grid)))
           check_err(status, __LINE__, __FILE__);
 
 
     //open az_east ------
     //PACE_OCIS.2019321T00:00:00Zaz_east.nc
        prodstr = "az_east";
//        cout << "Current working directory: " << tmp << endl;
        azstr= pathstr + "/out/"+missionstr + "_" + senstr + "." + yearstr + monstr + daystr + timestr + prodstr+extstr;
 
        if(format.type==FT_SPEXONE){       
            ptstr="/accounts/mamontes/images/OCIS/sean/out/PACE_OCIS.2019321T00:00:00Zaz_east.nc";
            }
        else{
        ptstr = azstr.c_str();
        }
        cout <<"Opening file with azimuth east values in degrees............" << ptstr << endl;
    //    ptstr="/accounts/mamontes/images/OCIS/sean/out/PACE_OCIS.2019321T00:00:00Zaz_east.nc";
 
        status = nc_open(ptstr, NC_NOWRITE, &ncid_az);
          if (status != NC_NOERR) {
              fprintf(stderr, "nc_open error.\n");
               exit(EXIT_FAILURE);
          } 
        status = nc_inq_dimid(ncid_az, "bins_along_track", &y_dimid);
            check_err(status, __LINE__, __FILE__);
        nc_inq_dimlen(ncid_az, y_dimid, &ybins);
 
        status = nc_inq_varid(ncid_az, "az_east", &azId);//scans x velements
                check_err(status, __LINE__, __FILE__);
        status = nc_get_var_float(ncid_az, azId, &az_east[0]);
                check_err(status, __LINE__, __FILE__);
 
        for(size_t i=0;i<ybins;i++){ 
             sum = az_east[i];
             tot += sum;
              }
//close file
        if ((status = nc_close(ncid_az)))
           check_err(status, __LINE__, __FILE__);
        
        //using swath-averaged az_east for nadir pixels rather than along-track az_east pixel-by-pixel
        mean_az_east = tot / (ybins);
 
        l1cfile->mean_az_east=mean_az_east; //in degrees
        cout<<"mean_az_east in degrees...."<<mean_az_east<<endl;
   
 
 
        //determine # of gd groups to be processede  
        //gdlines_group=num_gridlines;//ONE BIG GROUP
        gdlines_group = 250;
 
        if (num_gridlines <= gdlines_group) {
            gdlines_group = num_gridlines;
            cout << "WARNING********************* number_gridlines<=gdlines_group THEN gdlines_group=num_gridlines **************" << endl;
        }
 
        ngroups = floor(num_gridlines / gdlines_group);
        cout << "TOTAL # of gd groups.(ALL LATs...." << ngroups << endl;
 
        //--NORMALIZED  gridline longitude is -180 to 180 degrees before comparison with longitude extracted from image pixels---
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lon_gd[i][j] < -180.)lon_gd[i][j] += 360.;
                if (lon_gd[i][j] > 180.)lon_gd[i][j] -= 360.;
            }        
            }
        //get min/max lat/lon of the swath
        // Assume first element as maximum and minimum
        maxv = lat_gd[0][0];
        minv = lat_gd[0][0];
 
        //Find maximum and minimum in all array elements.
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lat_gd[i][j] > maxv)
                    maxv = lat_gd[i][j];
                if (lat_gd[i][j] < minv)
                    minv = lat_gd[i][j];
            }        
               }
     
    
        maxv = lon_gd[0][0];
        minv = lon_gd[0][0];
        //Find maximum and minimum in all array elements.
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lon_gd[i][j] > maxv)
                    maxv = lon_gd[i][j];
                if (lon_gd[i][j] < minv)
                    minv = lon_gd[i][j];
            }
        }
   
  
 
        cout << "swath #.." << swtd << endl;
 
        //check lat bound min/max of each gd group---
        int k = 0, i = 0;
 
        dlatb_g = allocate2d_float(ngroups + 1, 2);
        dlonb_g = allocate2d_float(ngroups + 1, 2);
 
        //recompute number of gridlines based on lat limits -80 to 80 degrees  
       //asc orbit goes from negative to positive latitude....
        NY = num_gridlines;
        NX = nbinx;
        for (int i = 0; i < NY; i++) {
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= -80.) c1++;
                if (c1 == nbinx) {
                    NY1 = i;
                }
            }
            if (NY1 >= 0) break;
            c1 = 1;
        }
 
 
        for (int i = 0;i < NY; i++) {
            //   cout<<"i.."<<i<<"lat_gd[i][j]..."<<lat_gd[i][nadpix]<<endl;
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= 80.) {
                    NY2 = i - 1;
                }
            }
 
            if (NY2 >= 0) break;
        }
 
        // cout<<"gridlines limited to -80 to 80 degrees of latitutde.."<<"gdline ini.."<<NY1<<"gdline end.."<<NY2<<endl;
 
        l1cfile->NY1 = NY1;
        l1cfile->NY2 = NY2;
 
        cout << "NY.." << NY << "NY1.." << NY1 << "NY2.." << NY2 << endl;
 
 
 
        num_gridlines = NY2 - NY1 + 1;//this is the # gridlines after -80 to 80 lat constraint---
 
        cout<<"numgridlines after restriction lat"<<num_gridlines<<endl;
 
        ngroups = floor(num_gridlines / gdlines_group);
        cout << "gdlines will start in gline.." << i + 1 << "ROUNDED ngroups after adjusting beginning.for constraint lat (-80 to 80)" << ngroups << endl;
 
        //for each 'grid' group scan the swath files to see if there are scanlines within--
        //if that is case check the across-bin number position (0 to binx-1) based on latnad and lonnad values--- 
        last_file = 0;
        last_sline = 0;
        flag_donefile = 0;
 
        if (num_gridlines > ngroups * gdlines_group) ngroups += 1;
 
 
        //*********** SORTING LAT/LON ASCENDING AND TRACK INDEXES ****************************
        //***********************************************************************************
 
        //Create index matrix for i and j of each lat and lon L1C grid (-80 to 80)
        //num_gridlines x nbinx
        index_xy = allocate2d_short(num_gridlines, nbinx);
        lat_asort = allocate2d_float(num_gridlines, nbinx);
        //  lon_asort=allocate2d_float(num_gridlines,nbinx);
             //fill indexe
 
        //define 1-D vector to sort 1 col L1C grid at the time---
        vector<pair<float, int> > vp;
 
        //fill vector with lat_gd column--
        cout << "*********** SORTING LAT/LON GRIDPOINTS AND TRACKING INDEXES ********************" << endl;
 
        for (int col = 0;col < nbinx;col++) {
            for (int row = NY1;row < NY2 + 1;row++) {
                vp.push_back(make_pair(lat_gd[row][col] + 90., row));
            }
            //sort 
            stable_sort(vp.begin(), vp.end());
            //display lat in order along with its gridpoint index--
              //   cout << "Lat value\t"
              //         << "index" << endl; 
            for (unsigned int i = 0; i < vp.size(); i++) {
                lat_asort[i][col] = vp[i].first;
                index_xy[i][col] = vp[i].second;
            }
            vp.clear();
        }
 
        cout << "num_gridlines...." << num_gridlines << "ngroups.." << ngroups << endl;
 
 
        //****************************************************************************************************
           //************* BIG LOOP GROUPS ***************************************
        cout << "Number of granules to be L1C processed........................................." << sfiles << endl;
 
//**********BIG LOOP GROUPS ********************
        for (k = 0;k < ngroups;k++) {
            
            //total gridlines for k groups-----
            n_gdlines = (k + 1) * gdlines_group;
            cout << "screening k group.." << k + 1 << "last_file.." << last_file << "last_line.." << last_sline << endl;
            cout << "number of gridlines so far..." << n_gdlines << endl;
            //***** compute deltas for lat_gd index 256 and 257 *******************
 
             //compute delta_lat and delta_lon based on binres/2 for lower and upper corners of 'nadir' gridpoints of 256 and 257 indexes -----------------
               //we need nadir 256 and 257 lat/lon coordinates to compute -delta and +delta, respectively
               //we need azimuth and backazimuth and binres/2 to compute deltas ---
 
                //index 256
            geod.Direct(lat_gd[n_gdlines - gdlines_group][256], lon_gd[n_gdlines - gdlines_group][256], az_east[n_gdlines - gdlines_group], gres, dlamin, dlomin);
            geod.Direct(lat_gd[n_gdlines - 1][257], lon_gd[n_gdlines - 1][257], az_east[n_gdlines - 1], gres, dlamax, dlomax);
 
            cout << "dlamin.." << dlamin << "dlomin.." << dlomin << "dlamax.." << dlamax << "dlomax.." << dlomax << endl;
 
            dlatb_g[k][0] = dlamin;//in DEGREES!!
            dlatb_g[k][1] = dlamax;
            dlonb_g[k][0] = dlomin;
            dlonb_g[k][1] = dlomax;
 
//********* LOOP FILES ************************************
            for (unsigned int findex = last_file;findex < sfiles;findex++) {
 
                cout << "Scanning lines in file.. for crossing swath..." << swtd << "selected granule #.." << l1cfile->selgran[findex] << "swt_id.." << swtd_id[findex] << "grid group.." << k + 1 << endl;
 
                fi = l1cfile->selgran[findex];
                str = l1cfile->ifiles[fi - 1];
                ptstr = str.c_str();
 
                cout << "opening filename............" << ptstr << endl;
 
                status = nc_open(ptstr, NC_NOWRITE, &ncid_L1B);
                if (status != NC_NOERR) {
                   fprintf(stderr, "nc_open error.\n");
                    exit(EXIT_FAILURE);
                }
                //Open dimensions
                
                if(format.type==FT_SPEXONE){
                      status = nc_inq_dimid(ncid_L1B, "bins_along_track", &dimid);
                        if (status != NC_NOERR) {
                          fprintf(stderr, "-E- Error reading number_of_scans.\n");
                            exit(EXIT_FAILURE);                }
                          status = nc_inq_dimid(ncid_L1B, "spatial_samples_per_image", &dimid2);
                        if (status != NC_NOERR) {
                          fprintf(stderr, "-E- Error reading spatial_samples_per_image.\n");
                            exit(EXIT_FAILURE);                }
                          status = nc_inq_dimid(ncid_L1B, "intensity_bands_per_view", &dimid3);
                        if (status != NC_NOERR) {
                          fprintf(stderr, "-E- Error reading intensity_bands_per_view.\n");
                            exit(EXIT_FAILURE);                }
         //           spatial_samples_per_image, intensity_bands_per_view
         //
                }
                else{    
                      status = nc_inq_dimid(ncid_L1B, "number_of_scans", &dimid);
                       if (status != NC_NOERR) {
                                fprintf(stderr, "-E- Error reading number_of_scans.\n");
                            exit(EXIT_FAILURE);
                }}
 
                nc_inq_dimlen(ncid_L1B, dimid, &num_scans);
 
                //read line-by-line lat/lon/Lt
                if(format.type==FT_SPEXONE){
                   status = nc_inq_grp_ncid(ncid_L1B, "GEOLOCATION_DATA", &geoGrp);
                   check_err(status, __LINE__, __FILE__);
                   status = nc_inq_grp_ncid(ncid_L1B, "OBSERVATION_DATA", &obsGrp);
                   check_err(status, __LINE__, __FILE__);
                }
                else{
                   status = nc_inq_grp_ncid(ncid_L1B, "geolocation_data", &geoGrp);
                   check_err(status, __LINE__, __FILE__);
                   status = nc_inq_grp_ncid(ncid_L1B, "observation_data", &obsGrp);
                   check_err(status, __LINE__, __FILE__);
                }  
 
 
                //open geo data
                status = nc_inq_varid(geoGrp, "sensor_azimuth", &senazId);
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(geoGrp, "latitude", &latId);
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(geoGrp, "longitude", &lonId);
                check_err(status, __LINE__, __FILE__);
 
                //radiance variables
                if(format.type==FT_SPEXONE){
                   NVIEWS= 1;//should be 5 but only provided 1
                   NBANDS=400;
                   NBANDS_POL=50;
                   status = nc_inq_varid(obsGrp, "I", &I_Id);
                   check_err(status, __LINE__, __FILE__);
                    status = nc_inq_varid(obsGrp, "I_polsample", &Ipol_Id);
                   check_err(status, __LINE__, __FILE__);
                   cout << "#total number of Intensity bands per view.." << NBANDS << endl;
                   cout << "#total number of Polarization bands per view.." << NBANDS_POL << endl;
 
                }    
                else{//OCIS                  
                   NVIEWS= 2;//for OCI
                   NBANDS=249;//for OCI       
                   status = nc_inq_varid(obsGrp, "Lt_blue", &Lt_blueId);
                   check_err(status, __LINE__, __FILE__);
                   status = nc_inq_varid(obsGrp, "Lt_red", &Lt_redId);
                   check_err(status, __LINE__, __FILE__);
                   status = nc_inq_varid(obsGrp, "Lt_SWIR", &Lt_SWIRId);
                   check_err(status, __LINE__, __FILE__);
                // num_blue_bands
                 status = nc_inq_dimid(ncid_L1B, "blue_bands", &dimid);
                   if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading num_blue_bands.\n");
                    exit(EXIT_FAILURE);
                   }
                 nc_inq_dimlen(ncid_L1B, dimid, &num_blue_bands);
 
                // num_red_bands
                 status = nc_inq_dimid(ncid_L1B, "red_bands", &dimid);
                   if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading num_red_bands.\n");
                    exit(EXIT_FAILURE);
                   }
                 nc_inq_dimlen(ncid_L1B, dimid, &num_red_bands);
 
                // num_SWIR_bands
                 status = nc_inq_dimid(ncid_L1B, "SWIR_bands", &dimid);
                   if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading num_SWIR_bands.\n");
                    exit(EXIT_FAILURE);
                   }
                 nc_inq_dimlen(ncid_L1B, dimid, &num_SWIR_bands);
                 cout << "#blue bands.." << num_blue_bands << endl;
                 cout << "#red bands.." << num_red_bands << endl;
                 cout << "#swir bands.." << num_SWIR_bands << endl;
                 nbands=num_blue_bands+num_red_bands+num_SWIR_bands;
                 cout << "#total number of bands.." << nbands << endl;
                 }
 
                cout<<"#gridlines.."<<num_gridlines<<"# binx.."<<nbinx2<<"number of scans.."<<num_scans<<"# pixels..or spatial_samples_per_image in SPEXone"<<num_pixels<<endl;
 
 
 
 
                 if (last_sline == 0 && binmean_Lt == nullptr) { // binmean_Lt==NULL | bincount==NULL | binmean_Lt2==NULL | bincount2==NULL | binmean_Lt3==NULL | bincount3==NULL){
 
                    cout << "first allocation of memory for grid bins of file #..." << l1cfile->selgran[findex] << endl;
 
                    //            cout<<"findex.."<<findex<<"blue bands"<<num_blue_bands<<"red bands.."<<num_red_bands<<"swir bands..."<<num_SWIR_bands<<"nbinx.."<<nbinx<<endl;
                     binmean_Lt = allocate4d_float(NVIEWS,NBANDS,num_gridlines,nbinx2);     
                     bincount = allocate4d_int(NVIEWS,NBANDS,num_gridlines,nbinx2);//all bands together, only 1 view for OCI
 
                  //  binmean_Lt = allocate3d_float(num_gridlines,nbinx,nbands);
                  //  bincount = allocate3d_int(num_gridlines,nbinx,nbands);//all bands together, only 1 view for OCI
                  for(size_t v=0;v<NVIEWS;v++){
                    for(size_t b=0;b<NBANDS;b++){
                         for(int j=0;j<num_gridlines;j++){
                              for(int  i=0;i<nbinx2;i++){
                                   binmean_Lt[v][b][j][i]=0.;
                                   bincount[v][b][j][i]=0.;
                             }}}}
 
                            }//end if first time allocating mem for binning arrays
 
               if(format.type==FT_SPEXONE){
                //assigning mem for Lt of different bands **********************
                latpix = (float*)calloc(num_pixels , sizeof(float));
                lonpix = (float*)calloc(num_pixels , sizeof(float));
                Lt_pix = allocate2d_float(num_pixels,NBANDS);//blue bands
                Lt_pix2 = allocate2d_float(num_pixels,NBANDS_POL);//red bands
                    }
               else{
                senazpix=(float*)calloc(num_pixels , sizeof(float));
                latpix = (float*)calloc(num_pixels , sizeof(float));
                lonpix = (float*)calloc(num_pixels , sizeof(float));
                Lt_pix = allocate2d_float(num_blue_bands, num_pixels);//blue bands
                Lt_pix2 = allocate2d_float(num_red_bands, num_pixels);//red bands
                Lt_pix3 = allocate2d_float(num_SWIR_bands, num_pixels);//S
               }
 
//BIG SCANLINE LOOP----------------------------------
                //********************************************************************************
                 //-----reading line by line-----------------------------------           
                for (unsigned int sline = last_sline;sline < num_scans;sline++) {
 
                    //lat and lon--
                    start[0] = sline;
                    start[1] = 0;
                    count[0] = 1;
                    count[1] = num_pixels;               // 1 line at a time
                   if(format.type==FT_SPEXONE){
                      status = nc_get_vara_float(geoGrp, latId, start, count, latpix);
                      status = nc_get_vara_float(geoGrp, lonId, start, count, lonpix);
                     }
                   else{ //OCIS 
                    status = nc_get_vara_float(geoGrp, senazId, start, count, senazpix);//-1800 to + 1800 s means s as scaled
                    status = nc_get_vara_float(geoGrp, latId, start, count, latpix);
                    status = nc_get_vara_float(geoGrp, lonId, start, count, lonpix);
                   }
 
                                 //Lt
                   if(format.type==FT_SPEXONE){
                    start2[0] = sline;
                    start2[1] = 0;
                    start2[2] = 0;
 
                    count2[0] = 1;
                    count2[1] = num_pixels;               // 1 line at a time
                    count2[2] = NBANDS;
 
                    count3[0] = 1;
                    count3[1] = num_pixels;               // 1 line at a time
                    count3[2] = NBANDS_POL;
 
                    status = nc_get_vara_float(obsGrp, Lt_blueId, start2, count2, Lt_pix[0]);//all intensity bands
                    status = nc_get_vara_float(obsGrp, Lt_redId, start2, count3, Lt_pix2[0]);//all poalrized bands
                   }
                   else{ //OCIS
                    start2[0] = 0;
                    start2[1] = sline;
                    start2[2] = 0;
 
                    count2[0] = num_blue_bands;
                    count2[1] = 1;               // 1 line at a time
                    count2[2] = num_pixels;
 
                    count3[0] = num_red_bands;
                    count3[1] = 1;               // 1 line at a time
                    count3[2] = num_pixels;
 
                    count4[0] = num_SWIR_bands;
                    count4[1] = 1;               // 1 line at a time
                    count4[2] = num_pixels;
 
                    status = nc_get_vara_float(obsGrp, Lt_blueId, start2, count2, Lt_pix[0]);
                    status = nc_get_vara_float(obsGrp, Lt_redId, start2, count3, Lt_pix2[0]);
                    status = nc_get_vara_float(obsGrp, Lt_SWIRId, start2, count4, Lt_pix3[0]);
                   }
 
 
                    /*      for(int bb=0;bb<num_blue_bands;bb++){
                               cout<<"processing blue band #.........................................................................."<<bb+1<<"of total blue bands #.."<<num_blue_bands<<endl;
                               cout<<"Lt_pix at pix =0..."<<Lt_pix[bb][0]<<"Lt_pix at pix =1..."<<Lt_pix[bb][1]<<endl;
                              }
                           exit(1);
                   */
 
                    for (unsigned int pix = 0;pix < num_pixels;pix++) {
                        if (latpix[pix] < latmin_swt) latmin_swt = latpix[pix];
                        if (latpix[pix] > latmax_swt) latmax_swt = latpix[pix];
                        if (lonpix[pix] < lonmin_swt) lonmin_swt = lonpix[pix];
                        if (lonpix[pix] > lonmax_swt) lonmax_swt = lonpix[pix];
 
                  //       cout<<"senazpix (sensor azimuth)...in degrees."<<senazpix[pix]/100<<"at pix #..."<<pix+1<<"latpix.."<<latpix[pix]<<endl;                        
                    }
 
                  
 
              //        cout<<"nadpix..."<<nadpix<<"latpix[nadpix]..."<<latpix[nadpix]<<"lonpix[nadpix]..."<<lonpix[nadpix]<<endl;         
             //         cout<<"dlatb_g[k][0]...."<<dlatb_g[k][0]<<"dlatb_g[k][1]...."<<dlatb_g[k][1]<<endl;
             //        cout<<"senazpix (sensor azimuth)...in degrees."<<senazpix[nadpix]/100<<"at line #..."<<sline+1<<"latpix[nadpix].."<<latpix[nadpix]<<endl;
 
                    dlamin = 0.;dlamax = 0.;
 
                    //inside the 'k' box??----- ascending ----------                   
                    if (latpix[nadpix] >= dlatb_g[k][0] && latpix[nadpix] <= dlatb_g[k][1]) {
 
                        if (sline % 100 == 0) cout << "EVERY 100 gds..for k group.." << k + 1 << "file number #.." << l1cfile->selgran[findex] << "sline..." << sline + 1 << "# of binned pix.." << inpix << "outpix.." << outpix << endl;
 
   //*********** BIG LOOP M_PIXEL *****************************************************************
                        for (unsigned int pix = 0;pix < num_pixels;pix++) {
 
                            sb=0,bb=0,rb=0,swb=0,ib=0;
                            gd_row=0,gd_col=0;
                            flag_inpix = 0;
 
                            boolbin1 = sbs2_l1c(l1cinput, num_gridlines, nbinx, lat_asort, index_xy, latpix[pix], lonpix[pix], lon_gd, &gd_row, &gd_col);
 
                            bin_ypix = gd_row + 1;
                            bin_xpix = gd_col + 1;
 
                     //       cout<<"pix..."<<pix+1<<"latpix..."<<latpix[pix]<<"lonpix..."<<lonpix[pix]<<endl;
 
                            if (boolbin1 == 1) flag_inpix = 1;
                            //************ BINNING ***************************
                         //assign identified pixel to Lt and bin stat arrays-----         
                        
         //BLUE---         
                            if (flag_inpix == 1 && bin_xpix >= 1 && bin_ypix >= 1 && bin_xpix <= nbinx && bin_ypix <= num_gridlines) {
                                inpix++;
                              if(format.type==FT_SPEXONE){
                                  view=0;
                                   while (sb<NBANDS) {
                                      if (Lt_pix[pix][ib] > 0.) {
                                         //     cout<<"Lt_pix[pix][ib]..."<<Lt_pix[pix][ib]<<"bin_ypix.."<<bin_ypix<<"bin_xpix.."<<bin_xpix<<endl;
                                              binmean_Lt[view][ib][bin_ypix - 1][bin_xpix - 1] = binmean_Lt[view][ib][bin_ypix - 1][bin_xpix - 1] + Lt_pix[pix][ib];
                                              bincount[view][ib][bin_ypix - 1][bin_xpix - 1] += 1;
                                           }
                                    ib++;
                                    sb++;
                                }//end while intensity bands
 
/*                                    while (sb<num_blue_bands) {
                                      if (Lt_pix2[bb][pix] > 0.) {
                                              binmean_Lt[view][sb][bin_ypix - 1][bin_xpix - 1] = binmean_Lt[view][sb][bin_ypix - 1][bin_xpix - 1] + Lt_pix2[bb][pix];
                                              bincount[view][sb][bin_ypix - 1][bin_xpix - 1] += 1;
                                           }
                                    bb++;
                                    sb++;
                                }//end while polarization bands
*/
                              }
                              else{ //OCIS 
                                if(senazpix[nadpix]/100<0) view=0; else view=1;
                                while (sb<num_blue_bands) {
                                      if (Lt_pix[bb][pix] > 0.) {
                                              binmean_Lt[view][sb][bin_ypix - 1][bin_xpix - 1] = binmean_Lt[view][sb][bin_ypix - 1][bin_xpix - 1] + Lt_pix[bb][pix];
                                              bincount[view][sb][bin_ypix - 1][bin_xpix - 1] += 1;                                                                                       
                                           }
                                    bb++;
                                    sb++;
                                }//end while blue band band 
                                
        //RED---
                                while (sb <num_blue_bands+num_red_bands) {
                                    if (Lt_pix2[rb][pix] > 0.) {
                                        binmean_Lt[view][sb][bin_ypix - 1][bin_xpix - 1] = binmean_Lt[view][sb][bin_ypix - 1][bin_xpix - 1] + Lt_pix2[rb][pix];
                                        bincount[view][sb][bin_ypix - 1][bin_xpix - 1] += 1;
                                    }
                                    rb++;
                                    sb++;
                                }//end red bands
 
       //SWIR----
                                while (sb <num_blue_bands + num_red_bands + num_SWIR_bands) {
                                    if (Lt_pix3[swb][pix] > 0.) {
                                        binmean_Lt[view][sb][bin_ypix - 1][bin_xpix - 1] = binmean_Lt[view][sb][bin_ypix - 1][bin_xpix - 1] + Lt_pix3[swb][pix];
                                        bincount[view][sb][bin_ypix - 1][bin_xpix - 1] += 1;
                                    }
                                    swb++;
                                    sb++;
                                }//end swir bands
                             }
 
                            }//end if inpix==1
                       
 
 
    //********** pixel AREA WEIGHTING ************************
                            if (flag_inpix == 0) outpix++;
 
                            totpix++;
 
                        }//end pixels loop
 
                    
 
 
                        //END OF FILE--****** reset starting sline index if last line processed and within k box
                        //go for another granule if it is not the last one---------------
                        if (sline == num_scans - 1) {
                            flag_donefile = 1;
                            cout << "end of file..." << l1cfile->selgran[findex] << endl;
                            last_sline = 0;
                            if (findex >= sfiles - 1) {
                                cout << "done with last granule of the input list........................." << endl;
                                //   findex=sfiles;
                                k = ngroups;
                                break;
                            }
 
                        }//end of file/last file? sliine=num_scans-1
                        else flag_donefile = 0;
 
                    }//end latpix nadir of line x inside grid group?
 
         //***** skip lines and files if sline is not within k group ********
              //increase k and screen files and lines again starting from the last binning
 
                    if (latpix[nadpix] > lat_gd[n_gdlines - 1][257] && k < ngroups - 1) { //else limits 
                       if(format.type==FT_SPEXONE){
                        cout << "moving to the next k group...scanning again files/slines.." << endl;
                        cout << "group #.."<<k+1<<"file index.." << findex << "sline index.." << sline << endl;
                        last_file = findex;
                        last_sline = sline;
                        findex = sfiles;
                        sline = num_scans - 1;
                          }
                       else{ //OCIS  
                        cout << "moving to the next k group...scanning again files/slines.." << endl;
                        cout << "file index.." << findex << "last sline index.." << sline << endl;
                        last_file = findex;
                        last_sline = sline;
                        findex = sfiles;
                        sline = num_scans - 1;
                       }
                    }//end if lat >grid lat--IF outside the box
 
                    if (sline + 1 % 100 == 0) cout << "for k group.." << k + 1 << "selected granule #.." << l1cfile->selgran[findex] << "sline..." << sline + 1 << "# of binned pix.." << inpix << "totpix.." << totpix << "outpix.." << outpix << endl;
                }//end for scanlines
 
                cout << "closing L1B file......." << ptstr << endl;
                status = nc_close(ncid_L1B);
                check_err(status, __LINE__, __FILE__);
                if (latpix != nullptr)
                   delete[](latpix);
                if (lonpix != nullptr)
                   delete[](lonpix);
                if (Lt_pix != nullptr)
                   delete[](Lt_pix);
                if (Lt_pix2 != nullptr)
                   delete[](Lt_pix2);
                if (Lt_pix3 != nullptr)
                   delete[](Lt_pix3);
                if (senazpix != nullptr)
                   delete [](senazpix);
 
                //**********************************************************************************************************************************
                //**********************************************************************************************************************************
                //writing each granule ---------------------------------
                //*****************************************************************************
 
                if (flag_donefile == 1 | (flag_donefile == 0 && k == ngroups - 1)) {
                    cout << "writing file #....................................................................................................................." << l1cfile->selgran[findex] << "based on group #.." << k + 1 << endl;
                    //write mean Lt as nc file---
                   //**********************************************************************
                   //**********************************************************************8
                   //create Lt file
                    pathstr = "out/";
                    senstr = "OCIS_";
                    monstr = std::to_string(selmon);
                    daystr = std::to_string(selday);
                    yearstr = std::to_string(selyear);
                    prodstr = "binLt_sbs";
                    swtstr = "_swt";
                    granstr = "";
                    granstr = "_" + std::to_string(l1cfile->selgran[findex]);
 
                    if (l1cfile->l1c_pflag >= 3) {
                        swtd = l1cfile->swtnum;
                        swtnum = std::to_string(swtd);
                        cout << "swtnum.." << swtnum << endl;
                    }
                    else swtnum = std::to_string(swtd);
 
                    extstr = ".nc";
                    string GATT_NAME1,GATT_VAL1,GATT_NAME2,GATT_VAL2;
 
                     if(format.type==FT_SPEXONE){                         
                         senstr = "SPEXONE";
                         GATT_NAME1="Title",GATT_VAL1="PACE SPEXone Level-1C Data",GATT_NAME2="instrument",GATT_VAL2="SPEXone";                     
                     }
                     else if(format.type==FT_HARP){
                         senstr = "HARP2";
                         GATT_NAME1="Title",GATT_VAL1="PACE HARP Level-1C Data",GATT_NAME2="instrument",GATT_VAL2="HARP";
                     }    
                     else//OCIS
                     {
                         senstr = "OCI";
                         GATT_NAME1="Title",GATT_VAL1="PACE OCI Level-1C Data",GATT_NAME2="instrument",GATT_VAL2="OCI";
                     }
 
 
 
                    fname_out = pathstr + missionstr + "_" + senstr + "." + yearstr + monstr + daystr + timestr + prodstr+granstr+extstr;
 
                    string  ATT_NAME="Units", ATT_VAL="degrees",GATT_NAME3="processing_version",GATT_VAL3="V1.0",GATT_NAME4="Conventions",GATT_VAL4="CF-1.6";
                    string GATT_NAME5="institution",GATT_VAL5="NASA Goddard Space Flight Center, Ocean Biology Processing Group",GATT_NAME6="license",GATT_VAL6="http://science.nasa.gov/earth-science/earth-science-data/data-information-policy/";
                    string GATT_NAME7="naming_authority",GATT_VAL7="gov.nasa.gsfc.sci.oceancolor",GATT_NAME8="keywords_vocabulary",GATT_VAL8="NASA Global Change Master Directory (GCMD) Science Keywords";
                    string GATT_NAME9="stdname_vocabulary",GATT_VAL9="NetCDF Climate and Forecast (CF) Metadata Convention",GATT_NAME10="creator_name",GATT_VAL10="NASA/GSFC",GATT_NAME11="creator_email",GATT_VAL11="data@oceancolor.gsfc.nasa.gov";
                    string GATT_NAME12="creator_url",GATT_VAL12="http://oceancolor.gsfc.nasa.gov",GATT_NAME13="project",GATT_VAL13="PACE Project",GATT_NAME14="publisher_name",GATT_VAL14="NASA/GSFC";
                    string GATT_NAME15="publisher_email",GATT_VAL15="data@oceancolor.gsfc.nasa.gov",GATT_NAME16="publisher_url",GATT_VAL16="http://oceancolor.gsfc.nasa.gov",GATT_NAME17="processing_level",GATT_VAL17="L1C";
                    string GATT_NAME18="cdm_data_type",GATT_VAL18="swath",GATT_NAME19="orbit_number",GATT_VAL19="12345",GATT_NAME20="history",GATT_VAL20="",GATT_NAME21="CDL_version_date",GATT_VAL21="2021-09-10",GATT_NAME22="product_name",GATT_VAL22=fname_out;
                    string GATT_NAME23="startDirection",GATT_VAL23="Ascending",GATT_NAME24="endDirection",GATT_VAL24="Ascending",GATT_NAME25="time_coverage_start",GATT_VAL25=yearstr+"-"+monstr+"-"+daystr+"-"+timestr,GATT_NAME26="time_coverage_end",GATT_VAL26=yearstr+"-"+monstr+"-"+daystr+"-"+timestr,GATT_NAME27="date{_created",GATT_VAL27="2021-09-10T15:12:41Z",GATT_NAME28="sun_earth_distance",GATT_VAL28="0.990849042172323",GATT_NAME29="terrain_data_source",GATT_VAL29="",GATT_NAME30="spectral_response_function",GATT_VAL30="",GATT_NAME31="systematic_uncertainty_model",GATT_VAL31="",GATT_NAME32="nadir_bin",GATT_VAL32="12345",GATT_NAME33="bin_size_at_nadir",GATT_VAL33="5.2km2";
 
                    l1cfile->gridname = fname_out.c_str();
                    filename_lt = fname_out.c_str();                       
  
                    if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
                        check_err(status, __LINE__, __FILE__);
                 //define dims
                     // Define the dimensions,vars and attributes at the root level
                    NDIMS=2;
                    NDIMS2=3;
                    NDIMS3=4;
                    NY = num_gridlines;
                    NX = nbinx;
                    //NVIEWS= 2;//for OCI
                   // NBANDS=249;//for OCI
 
                    NY1 = l1cfile->NY1;//these are indexes not line #!!!!!!!!!!!!!!!!!
                    NY2 = l1cfile->NY2;
                    cout << "rowgrid ini.." << NY1 << "rowgrid end.." << NY2 << endl;
                    NY = NY2 - NY1 + 1;
                    cout << "NY.." << NY << "NX.." << NX << "NY1.."<<NY1<<"NY2.."<<NY2<<endl;
 
  //DEF DIMENSIONS
                    if ((status = nc_def_dim(ncid_out, "bins_across_track", NX, &x_dimid)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_dim(ncid_out, "bins_along_track", NY, &y_dimid)))
                           check_err(status, __LINE__, __FILE__);
                   //dims for output var
                    dimids[0] = y_dimid;
                    dimids[1] = x_dimid;
                  
                    if ((status = nc_def_dim(ncid_out, "number_of_views", NVIEWS, &v_dimid)))
                       check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_dim(ncid_out, "intensity_bands_per_view", NBANDS, &b_dimid)))
                      check_err(status, __LINE__, __FILE__);
 
                    dimids2[0] = y_dimid;
                    dimids2[1] = x_dimid;
                    dimids2[2] = v_dimid;//#o
 
                    dimids3[0] = y_dimid;
                    dimids3[1] = x_dimid;
                    dimids3[2] = v_dimid;//
                    dimids3[3] = b_dimid;
 
                    /*     try
                           {
                            cout<<"Opening file \"firstFile.nc\" with NcFile::replace"<<endl;
                            NcFile ncFile("firstFile.nc",NcFile::replace);
                            NcGroup groupA(ncFile.addGroup("groupA"));
                            }
 
                         catch (NcException& e)
                             {
                               cout << "unknown error"<<endl;
                                e.what();
                                 }
                         exit(1);
                        */
                    //define attributes
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME1.c_str(), strlen(GATT_VAL1.c_str()),
                        GATT_VAL1.c_str()))
                       check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME2.c_str(), strlen(GATT_VAL2.c_str()),
                         GATT_VAL2.c_str()))
                       check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME3.c_str(), strlen(GATT_VAL3.c_str()),
                         GATT_VAL3.c_str()))
                          check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME4.c_str(), strlen(GATT_VAL4.c_str()),
                            GATT_VAL4.c_str()))
                           check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME5.c_str(), strlen(GATT_VAL5.c_str()),
                         GATT_VAL5.c_str()))
                          check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME6.c_str(), strlen(GATT_VAL6.c_str()),
                          GATT_VAL6.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME7.c_str(), strlen(GATT_VAL7.c_str()),
                           GATT_VAL7.c_str()))
                           check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME8.c_str(), strlen(GATT_VAL8.c_str()),
                          GATT_VAL8.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME9.c_str(), strlen(GATT_VAL9.c_str()),
                          GATT_VAL9.c_str()))
                         check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME10.c_str(), strlen(GATT_VAL10.c_str()),
                          GATT_VAL10.c_str()))
                          check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME11.c_str(), strlen(GATT_VAL11.c_str()),
                           GATT_VAL11.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME12.c_str(), strlen(GATT_VAL12.c_str()),
                            GATT_VAL12.c_str()))
                           check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME13.c_str(), strlen(GATT_VAL13.c_str()),
                             GATT_VAL13.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME14.c_str(), strlen(GATT_VAL14.c_str()),
                             GATT_VAL14.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME15.c_str(), strlen(GATT_VAL15.c_str()),
                             GATT_VAL15.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME16.c_str(), strlen(GATT_VAL16.c_str()),
                             GATT_VAL16.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME17.c_str(), strlen(GATT_VAL17.c_str()),
                             GATT_VAL17.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME18.c_str(), strlen(GATT_VAL18.c_str()),
                             GATT_VAL18.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME19.c_str(), strlen(GATT_VAL19.c_str()),
                             GATT_VAL19.c_str()))
                          check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME20.c_str(), strlen(GATT_VAL20.c_str()),
                             GATT_VAL20.c_str()))
                              check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME21.c_str(), strlen(GATT_VAL21.c_str()),
                             GATT_VAL21.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME22.c_str(), strlen(GATT_VAL22.c_str()),
                             GATT_VAL22.c_str()))
                           check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME23.c_str(), strlen(GATT_VAL23.c_str()),
                              GATT_VAL23.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME24.c_str(), strlen(GATT_VAL24.c_str()),
                              GATT_VAL24.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME25.c_str(), strlen(GATT_VAL25.c_str()),
                           GATT_VAL25.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME26.c_str(), strlen(GATT_VAL26.c_str()),
                           GATT_VAL26.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME27.c_str(), strlen(GATT_VAL27.c_str()),
                             GATT_VAL27.c_str()))
                              check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME28.c_str(), strlen(GATT_VAL28.c_str()),
                             GATT_VAL28.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME29.c_str(), strlen(GATT_VAL29.c_str()),
                             GATT_VAL29.c_str()))
                             check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME30.c_str(), strlen(GATT_VAL30.c_str()),
                             GATT_VAL30.c_str()))
                              check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME31.c_str(), strlen(GATT_VAL31.c_str()),
                             GATT_VAL31.c_str()))
                            check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME32.c_str(), strlen(GATT_VAL32.c_str()),
                              GATT_VAL32.c_str()))
                                check_err(status, __LINE__, __FILE__);
                    if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME33.c_str(), strlen(GATT_VAL33.c_str()),
                                GATT_VAL33.c_str()))
                                check_err(status, __LINE__, __FILE__);
 
      //define group1            
                    if ((status = nc_def_grp(ncid_out, "geolocation_data", &grp_coor)))  //netcdf-4
                         check_err(status, __LINE__, __FILE__);
        //def var grp1
                    if ((status = nc_def_var(grp_coor, "latitude", NC_FLOAT, NDIMS,
                         dimids, &varid1)))
                          check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_var(grp_coor, "longitude", NC_FLOAT, NDIMS,
                            dimids, &varid2)))
                          check_err(status, __LINE__, __FILE__);
 
       //leave define mode-----------------------
                    if ((status = nc_enddef(grp_coor))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
 
      //define group2
                    if ((status = nc_def_grp(ncid_out, "observation_data", &grp_obs)))  //netcdf-4
                        check_err(status, __LINE__, __FILE__);
 
      //def var grp2
                        //counts and Lt
                    if ((status = nc_def_var(grp_obs, "obs_per_view", NC_INT, NDIMS2,
                        dimids2, &varid_count)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_var(grp_obs, "I", NC_FLOAT, NDIMS3,
                        dimids3, &varid_lt)))
                        check_err(status, __LINE__, __FILE__);
 
/*
                     if ((status = nc_def_var(grp_obs, "Igeo", NC_FLOAT, NDIMS,   //first band, geolocated I for OCI test
                        dimids, &varid3)))
                        check_err(status, __LINE__, __FILE__);
                     if((status = nc_put_att_text (grp_obs,varid3, "coordinates",
                          strlen("lat lon"), "lat lon")))
                        check_err(status, __LINE__, __FILE__);
*/
 
                     //    _CoordinateAxisType = "GeoY";_CoordinateAxisType = "GeoX";
                     //
                    //leave define mode-----------------------
                    if ((status = nc_enddef(grp_obs))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
                   
 
                    lat_out = allocate2d_float(NY, NX);
                    lon_out = allocate2d_float(NY, NX);
         //           Igeo_out = allocate2d_float(NY, NX);
 
                    int c = 0;
 
                    for (int i = NY1; i < NY2 + 1; i++) {
                        for (int j = 0; j < NX; j++) {
                            lat_out[NY - 1 - c][NX - 1 - j] = lat_gd[i][j];
                            lon_out[NY - 1 - c][j] = lon_gd[i][j];                        
                         //   Igeo_out[i][j]=NAN;
                        }
                        c++;
                    }
 
 
                    if ((status = nc_put_var_float(grp_coor, varid1, &lat_out[0][0])))
                        check_err(status, __LINE__, __FILE__);
 
                    if ((status = nc_put_var_float(grp_coor, varid2, &lon_out[0][0])))
                        check_err(status, __LINE__, __FILE__);
 
                    
           //alloc mem for output variables obs_per_view and I as part of the observation_data group
                    data_out = allocate3d_int(NY, NX,NVIEWS);
                    data_out2 = allocate4d_float(NY, NX,NVIEWS,NBANDS);
                                    
            //BINCOUNT ARRAY            
               for (size_t v = 0; v < NVIEWS; v++) {
                        for (int i = NY1; i < NY2 + 1; i++) {
                            for (int j = 0; j < NX; j++) {
                                 data_out[i][j][v]=0;
                           //      if(v==0  & bincount[v][0][i][j]>0) Igeo_out[NY - 1 - c][NX - 1 - j]+=binmean_Lt[v][0][i][j] / bincount[v][0][i][j];
                            }}}
            
                 cout << "writing Lt for all bands.."<< endl;
               //         if ((status = nc_put_var_float(grp_obs, varid3, &Igeo_out[0][0])))
               //             check_err(status, __LINE__, __FILE__);
 
 
                   c = 0;
 
                      for (size_t v = 0; v < NVIEWS; v++) {
                        for (int i = NY1; i < NY2 + 1; i++) {
                            for (int j = 0; j < NX; j++) {
                                for (sb = 0;sb < nbands;sb++) {
                                    if(bincount[v][sb][i][j]>0)                                   
                                         data_out[NY - 1 - c][NX - 1 - j][v]+=bincount[v][sb][i][j]; 
                                    else
                                         data_out[NY - 1 - c][NX - 1 - j][v]+=0;
                                }                                    
                            }                                              
                            c++;
                        }
                        c=0;
                      }
 
 
 
                        cout << "writing countbin for all band ."<< endl;
                       if ((status = nc_put_var_int(grp_obs, varid_count, &data_out[0][0][0])))
                            check_err(status, __LINE__, __FILE__);
 
            // LT ARRAYS
                    c=0;
                    for (size_t b = 0;b <NBANDS;b++) {
                      for (size_t v = 0; v < NVIEWS; v++) {
                        for (int i = NY1; i < NY2 + 1; i++) {
                            for (int j = 0; j < NX; j++) {
                                if (bincount[v][b][i][j] > 0)
                                    data_out2[NY - 1 - c][NX - 1 - j][v][b] = binmean_Lt[v][b][i][j] / bincount[v][b][i][j];
                                else         data_out2[NY - 1 - c][NX - 1 - j][v][b] = NAN;
                            }
                            c++;
                        }
                        c=0;
                       }//end views                 
                     }//end for bands
 
 
 
                         cout << "writing Lt for all bands.."<< endl;
                        if ((status = nc_put_var_float(grp_obs, varid_lt, &data_out2[0][0][0][0])))
                            check_err(status, __LINE__, __FILE__);
 
            //        delete [] (Igeo_out);             
                    if(data_out!=nullptr)
                       delete [] (data_out);
                    if(data_out2!=nullptr)
                       delete [] (data_out2);
                    if(lat_out!=nullptr)
                       delete[](lat_out);
                    if(lon_out!=nullptr)
                       delete[](lon_out);
                    if(bincount!=nullptr)
                       delete[](bincount);
                    if(binmean_Lt!=nullptr)
                       delete[](binmean_Lt);
 
                    if ((status = nc_close(ncid_out)))
                        check_err(status, __LINE__, __FILE__);
                                         
                  
                    lat_out = nullptr;;
                    lon_out = nullptr;
                    data_out = nullptr;
                    data_out2 = nullptr;                                              
                    bincount = nullptr;
                    binmean_Lt = nullptr;
             
                    flag_donefile = 0;
                }//end writing file
            }//end for files loop
 
            cout << "group k at the end of big loop" << k + 1 << endl;
 
            
        }//groups
 
        cout << "number of files per swath.." << nfiles_swt[swtd - 1] << "for swath.." << swtd << endl;
        cout << "total inpix.." << inpix << "total pix.." << totpix << endl;
        //  cout<<"binned pixels.."<<inpix<<"as %.."<<(inpix/(num_pixels*num_scans*n_files*nfiles_swt[swtd-1]))*100<<endl;
        delete[](lat_asort);
        //   delete [] (lon_asort);
        delete[](index_xy);
        //   delete [] (index_xy2);
        delete[](dlatb_g);
        delete[](dlonb_g);
 
        delete[](lat_gd);
        delete[](lon_gd);
        delete[](az_east);
 
        printf("*** SUCCESS writing bincount and binLt rasters as nc..!\n");
        cout << "finish processing swath eq crossing day..." << swtd << endl;
        cout << "done writing Lt to nc file.." << endl;
 
        return(0);
    }
 
 
   //similar to w3 version but band groups merged in one array with indexes following Don l1b_ocis.c convention  
    int32_t L1C::binL1C_wgranule5(int swtd, l1c_filehandle* l1cfile, L1C_input* l1cinput, int16_t* swtd_id, int16_t* odir, int16_t* file_id, int16_t* nfiles_swt) {
        size_t ybins,xbins;
        int32_t gdlines_group, ngroups = 0, num_gridlines, nbinx, inpix = 0, outpix = 0, totpix = 0, n_gdlines;//number of gridlines to be processed
        float minv = 0., maxv = 0., ** dlatb_g, ** dlonb_g;
        int16_t fi = 0;
        std::string str;
        const char* ptstr;
        int dimid, status, ncid_out,ncid_az,ncid_grid,x_dimid,y_dimid, varid, varid2, varid3, azId,NDIMS;
        size_t start[] = { 0, 0 };
        size_t count[] = { 1, 1 };
        size_t start2[] = { 0, 0, 0 };
        size_t count2[] = { 1, 1, 1 }, count3[] = { 1, 1, 1 }, count4[] = { 1, 1, 1 };
        int32_t bin_xpix, bin_ypix;
        float* latpix, * lonpix, ** Lt_pix, ** Lt_pix2, ** Lt_pix3,mean_az_east;
     
        float latmin_swt = 100, latmax_swt = 0, lonmin_swt = 0, lonmax_swt = 0;
        int dimids[2];
        const char* filename_lt;
        int32_t NY = -1, NX = -1, NY1 = -1, NY2 = -1, c1 = 1;
        float** data_out, ** data_out2, ** data_out3, ** lat_out, ** lon_out;
        int last_file, last_sline, flag_inpix, flag_donefile;;//first index file id, second index line #
        short** index_xy;
        float** lat_asort;
        bool boolbin1;
 
        int16_t selyear = -1, selmon = -1, selday = -1;
        float** lat_gd, ** lon_gd, * az_east;
        string gridname, azeast_name;
        float*** bincount = NULL, *** bincount2 = NULL, *** bincount3 = NULL, *** binmean_Lt = nullptr, *** binmean_Lt2 = nullptr, *** binmean_Lt3 = nullptr;
        double gres = (l1cinput->gres) * 1000, dlamin, dlamax, dlomin, dlomax;
        int grp_root, grp_blue, grp_red, grp_swir, grp_coor,geoGrp;
        unsigned int bb = 0, rb = 0, swb = 0;
        float sum=0,tot=0;
        char tmp[256];
 
 
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
     
     
    
     //random seed
        srand((unsigned int)time(NULL));
        //nadir pixel ofr OCI
        int nadpix = l1cfile->nadpix;
 
 
        num_gridlines = 4000;
        nbinx = l1cfile->nbinx;
        num_pixels = l1cfile->npix;
 
        size_t sfiles = 0;
 
        if (l1cfile->selgran[0] < 0)//process all granules
        {
            sfiles = nfiles_swt[swtd - 1];
            for (unsigned int j = 0;j < sfiles;j++) l1cfile->selgran[j] = j + 1;
        }
        else {
            while (l1cfile->selgran[sfiles] > 0) {
                cout << "selected granule #..........................." << l1cfile->selgran[sfiles] << endl;
                sfiles++;
            }
        }
 
       cout<<"binning Lt using sbs2 method and composite indexes for arrays..................................................................."<<endl;
 
 
              //allocate mem for lat/lon/azeast pointers---
        selday = l1cinput->selday;
        selmon = l1cinput->selmon;
        selyear = l1cinput->selyear;
 
        std::string fname_out, pathstr, senstr, monstr, daystr, yearstr, prodstr, gdstr, swtstr, swtnum, extstr, granstr,timestr,azstr,missionstr;
 
        pathstr = "out/";
        missionstr="PACE";
        senstr = "OCIS";
        monstr = std::to_string(selmon);
        daystr = std::to_string(selday);
        yearstr = std::to_string(selyear);
        timestr="T00:00:00Z";
        prodstr = "L1Cgrid";
        swtstr = "_swt";
        extstr = ".nc";
 
        if (l1cfile->l1c_pflag >= 3) {
            swtd = l1cfile->swtnum;
            swtnum = std::to_string(swtd);
            cout << "swtnum.." << swtnum << endl;
        }
        else swtnum = std::to_string(swtd);
 
 
         //************************************************************
        //mem allocation for geolcoation pointers---
        az_east = (float*)calloc(num_gridlines , sizeof(float));
        lat_gd = allocate2d_float(num_gridlines, nbinx);
        lon_gd = allocate2d_float(num_gridlines, nbinx);
 
        getcwd(tmp, 256);
        pathstr=tmp;
 
//open lat/lon L1C grid --------------------------------------
    //PACE_OCIS.2019321T00:00:00ZL1Cgrid.nc
        prodstr = "L1Cgrid";
        gridname = pathstr + "/out/"+missionstr + "_" + senstr + "." + yearstr + monstr + daystr + timestr + prodstr+extstr;
 
    //open file
        ptstr = gridname.c_str();
        status = nc_open(ptstr, NC_NOWRITE, &ncid_grid);
          if (status != NC_NOERR) {
              fprintf(stderr, "nc_open error.\n");
               exit(EXIT_FAILURE);
          }
       //groups
        status = nc_inq_grp_ncid(ncid_grid, "geolocation_data", &geoGrp);
                check_err(status, __LINE__, __FILE__);
 
        status = nc_inq_dimid(ncid_grid, "bins_along_track", &y_dimid);
            check_err(status, __LINE__, __FILE__);
        nc_inq_dimlen(ncid_grid, y_dimid, &ybins);
        status = nc_inq_dimid(ncid_grid, "bins_across_track", &x_dimid);
            check_err(status, __LINE__, __FILE__);
 
        nc_inq_dimlen(ncid_grid, x_dimid, &xbins);
        nc_inq_dimlen(ncid_grid, y_dimid, &ybins);
 
        status = nc_inq_varid(geoGrp, "latitude", &latId);//scans x velements
                check_err(status, __LINE__, __FILE__);
        status = nc_inq_varid(geoGrp, "longitude", &lonId);//scans x velements
                check_err(status, __LINE__, __FILE__);
        status = nc_get_var_float(geoGrp, latId, &lat_gd[0][0]);
                check_err(status, __LINE__, __FILE__);
        status = nc_get_var_float(geoGrp, lonId, &lon_gd[0][0]);
                check_err(status, __LINE__, __FILE__);
//close file
        if ((status = nc_close(ncid_grid)))
           check_err(status, __LINE__, __FILE__);
 
 
     //open az_east ------
     //PACE_OCIS.2019321T00:00:00Zaz_east.nc
        prodstr = "az_east";
//        cout << "Current working directory: " << tmp << endl;
        azstr= pathstr + "/out/"+missionstr + "_" + senstr + "." + yearstr + monstr + daystr + timestr + prodstr+extstr;
        ptstr = azstr.c_str();
        cout <<"Opening file with azimuth east values in degrees............" << ptstr << endl;
    //    ptstr="/accounts/mamontes/images/OCIS/sean/out/PACE_OCIS.2019321T00:00:00Zaz_east.nc";
 
        status = nc_open(ptstr, NC_NOWRITE, &ncid_az);
          if (status != NC_NOERR) {
              fprintf(stderr, "nc_open error.\n");
               exit(EXIT_FAILURE);
          } 
        status = nc_inq_dimid(ncid_az, "bins_along_track", &y_dimid);
            check_err(status, __LINE__, __FILE__);
        nc_inq_dimlen(ncid_az, y_dimid, &ybins);
 
        status = nc_inq_varid(ncid_az, "az_east", &azId);//scans x velements
                check_err(status, __LINE__, __FILE__);
        status = nc_get_var_float(ncid_az, azId, &az_east[0]);
                check_err(status, __LINE__, __FILE__);
        for(size_t i=0;i<ybins;i++){ 
             sum = az_east[i];
             tot += sum;
              }
//close file
        if ((status = nc_close(ncid_az)))
           check_err(status, __LINE__, __FILE__);
        
        //using swath-averaged az_east for nadir pixels rather than along-track az_east pixel-by-pixel
        mean_az_east = tot / (ybins);
 
        l1cfile->mean_az_east=mean_az_east; //in degrees
        cout<<"mean_az_east in degrees...."<<mean_az_east<<endl;
   
 
 
        //determine # of gd groups to be processede  
        //gdlines_group=num_gridlines;//ONE BIG GROUP
        gdlines_group = 250;
 
        if (num_gridlines <= gdlines_group) {
            gdlines_group = num_gridlines;
            cout << "WARNING********************* number_gridlines<=gdlines_group THEN gdlines_group=num_gridlines **************" << endl;
        }
 
        ngroups = floor(num_gridlines / gdlines_group);
        cout << "TOTAL # of gd groups.(ALL LATs...." << ngroups << endl;
 
        //--NORMALIZED  gridline longitude is -180 to 180 degrees before comparison with longitude extracted from image pixels---
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lon_gd[i][j] < -180.)lon_gd[i][j] += 360.;
                if (lon_gd[i][j] > 180.)lon_gd[i][j] -= 360.;
            }        
            }
        //get min/max lat/lon of the swath
        // Assume first element as maximum and minimum
        maxv = lat_gd[0][0];
        minv = lat_gd[0][0];
 
        //Find maximum and minimum in all array elements.
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lat_gd[i][j] > maxv)
                    maxv = lat_gd[i][j];
                if (lat_gd[i][j] < minv)
                    minv = lat_gd[i][j];
            }        
               }
     
    
        maxv = lon_gd[0][0];
        minv = lon_gd[0][0];
        //Find maximum and minimum in all array elements.
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lon_gd[i][j] > maxv)
                    maxv = lon_gd[i][j];
                if (lon_gd[i][j] < minv)
                    minv = lon_gd[i][j];
            }
        }
   
  
 
        cout << "swath #.." << swtd << endl;
 
        //check lat bound min/max of each gd group---
        int k = 0, i = 0;
 
        dlatb_g = allocate2d_float(ngroups + 1, 2);
        dlonb_g = allocate2d_float(ngroups + 1, 2);
 
        //recompute number of gridlines based on lat limits -80 to 80 degrees  
       //asc orbit goes from negative to positive latitude....
        NY = num_gridlines;
        NX = nbinx;
        for (int i = 0; i < NY; i++) {
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= -80.) c1++;
                if (c1 == nbinx) {
                    NY1 = i;
                }
            }
            if (NY1 >= 0) break;
            c1 = 1;
        }
 
 
        for (int i = 0;i < NY; i++) {
            //   cout<<"i.."<<i<<"lat_gd[i][j]..."<<lat_gd[i][nadpix]<<endl;
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= 80.) {
                    NY2 = i - 1;
                }
            }
 
            if (NY2 >= 0) break;
        }
 
        // cout<<"gridlines limited to -80 to 80 degrees of latitutde.."<<"gdline ini.."<<NY1<<"gdline end.."<<NY2<<endl;
 
        l1cfile->NY1 = NY1;
        l1cfile->NY2 = NY2;
 
        cout << "NY.." << NY << "NY1.." << NY1 << "NY2.." << NY2 << endl;
 
 
 
        num_gridlines = NY2 - NY1 + 1;//this is the # gridlines after -80 to 80 lat constraint---
        ngroups = floor(num_gridlines / gdlines_group);
        cout << "gdlines will start in gline.." << i + 1 << "ROUNDED ngroups after adjusting beginning.for constraint lat (-80 to 80)" << ngroups << endl;
 
        //for each 'grid' group scan the swath files to see if there are scanlines within--
        //if that is case check the across-bin number position (0 to binx-1) based on latnad and lonnad values--- 
        last_file = 0;
        last_sline = 0;
        flag_donefile = 0;
 
        if (num_gridlines > ngroups * gdlines_group) ngroups += 1;
 
 
        //*********** SORTING LAT/LON ASCENDING AND TRACK INDEXES ****************************
        //***********************************************************************************
 
        //Create index matrix for i and j of each lat and lon L1C grid (-80 to 80)
        //num_gridlines x nbinx
        index_xy = allocate2d_short(num_gridlines, nbinx);
        lat_asort = allocate2d_float(num_gridlines, nbinx);
        //  lon_asort=allocate2d_float(num_gridlines,nbinx);
             //fill indexe
 
        //define 1-D vector to sort 1 col L1C grid at the time---
        vector<pair<float, int> > vp;
 
        //fill vector with lat_gd column--
        cout << "*********** SORTING LAT/LON GRIDPOINTS AND TRACKING INDEXES ********************" << endl;
 
        for (int col = 0;col < nbinx;col++) {
            for (int row = NY1;row < NY2 + 1;row++) {
                vp.push_back(make_pair(lat_gd[row][col] + 90., row));
            }
            //sort 
            stable_sort(vp.begin(), vp.end());
            //display lat in order along with its gridpoint index--
              //   cout << "Lat value\t"
              //         << "index" << endl; 
            for (unsigned int i = 0; i < vp.size(); i++) {
                lat_asort[i][col] = vp[i].first;
                index_xy[i][col] = vp[i].second;
            }
            vp.clear();
        }
 
        //saddleback search
        short gd_row, gd_col;
 
        cout << "num_gridlines...." << num_gridlines << "ngroups.." << ngroups << endl;
 
 
        //****************************************************************************************************
           //************* BIG LOOP GROUPS ***************************************
        cout << "Number of granules to be L1C processed........................................." << sfiles << endl;
 
 
        for (k = 0;k < ngroups;k++) {
 
            //total gridlines for k groups-----
            n_gdlines = (k + 1) * gdlines_group;
            cout << "screening k group.." << k + 1 << "last_file.." << last_file << "last_line.." << last_sline << endl;
            cout << "number of gridlines so far..." << n_gdlines << endl;
            //***** compute deltas for lat_gd index 256 and 257 *******************
 
             //compute delta_lat and delta_lon based on binres/2 for lower and upper corners of 'nadir' gridpoints of 256 and 257 indexes -----------------
               //we need nadir 256 and 257 lat/lon coordinates to compute -delta and +delta, respectively
               //we need azimuth and backazimuth and binres/2 to compute deltas ---
 
                //index 256
            geod.Direct(lat_gd[n_gdlines - gdlines_group][256], lon_gd[n_gdlines - gdlines_group][256], az_east[n_gdlines - gdlines_group], gres, dlamin, dlomin);
            geod.Direct(lat_gd[n_gdlines - 1][257], lon_gd[n_gdlines - 1][257], az_east[n_gdlines - 1], gres, dlamax, dlomax);
 
            cout << "dlamin.." << dlamin << "dlomin.." << dlomin << "dlamax.." << dlamax << "dlomax.." << dlomax << endl;
 
            dlatb_g[k][0] = dlamin;//in DEGREES!!
            dlatb_g[k][1] = dlamax;
            dlonb_g[k][0] = dlomin;
            dlonb_g[k][1] = dlomax;
 
            //********* LOOP FILES ************************************
            for (unsigned int findex = last_file;findex < sfiles;findex++) {
 
                cout << "Scanning lines in file.. for crossing swath..." << swtd << "selected granule #.." << l1cfile->selgran[findex] << "swt_id.." << swtd_id[findex] << "grid group.." << k + 1 << endl;
 
                fi = l1cfile->selgran[findex];
                str = l1cfile->ifiles[fi - 1];
                ptstr = str.c_str();
 
                cout << "opening filename............" << ptstr << endl;
 
                status = nc_open(ptstr, NC_NOWRITE, &ncid_L1B);
                if (status != NC_NOERR) {
                   fprintf(stderr, "nc_open error.\n");
                    exit(EXIT_FAILURE);
                }
                //Open dimensions
                status = nc_inq_dimid(ncid_L1B, "number_of_scans", &dimid);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading number_of_scans.\n");
                    exit(EXIT_FAILURE);
                }
                nc_inq_dimlen(ncid_L1B, dimid, &num_scans);
 
                //read line-by-line lat/lon/Lt
                status = nc_inq_grp_ncid(ncid_L1B, "geolocation_data", &geoGrp);
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_grp_ncid(ncid_L1B, "observation_data", &obsGrp);
                check_err(status, __LINE__, __FILE__);
                //open geo data 
                status = nc_inq_varid(geoGrp, "latitude", &latId);//scans x velements
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(geoGrp, "longitude", &lonId);//scans x velements
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(obsGrp, "Lt_blue", &Lt_blueId);
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(obsGrp, "Lt_red", &Lt_redId);
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(obsGrp, "Lt_SWIR", &Lt_SWIRId);
                check_err(status, __LINE__, __FILE__);
 
 
                // num_blue_bands
                status = nc_inq_dimid(ncid_L1B, "blue_bands", &dimid);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading num_blue_bands.\n");
                    exit(EXIT_FAILURE);
                }
                nc_inq_dimlen(ncid_L1B, dimid, &num_blue_bands);
 
                // num_red_bands
                status = nc_inq_dimid(ncid_L1B, "red_bands", &dimid);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading num_red_bands.\n");
                    exit(EXIT_FAILURE);
                }
                nc_inq_dimlen(ncid_L1B, dimid, &num_red_bands);
 
                // num_SWIR_bands
                status = nc_inq_dimid(ncid_L1B, "SWIR_bands", &dimid);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading num_SWIR_bands.\n");
                    exit(EXIT_FAILURE);
                }
                nc_inq_dimlen(ncid_L1B, dimid, &num_SWIR_bands);
 
 
                 if (last_sline == 0 && binmean_Lt == nullptr && binmean_Lt2 == nullptr && binmean_Lt3 == nullptr) { // binmean_Lt==NULL | bincount==NULL | binmean_Lt2==NULL | bincount2==NULL | binmean_Lt3==NULL | bincount3==NULL){
 
                    cout << "first allocation of memory for grid bins of file #..." << l1cfile->selgran[findex] << endl;
 
                    //            cout<<"findex.."<<findex<<"blue bands"<<num_blue_bands<<"red bands.."<<num_red_bands<<"swir bands..."<<num_SWIR_bands<<"nbinx.."<<nbinx<<endl;
 
                    binmean_Lt = allocate3d_float(num_blue_bands, num_gridlines, nbinx);
                    bincount = allocate3d_float(num_blue_bands, num_gridlines, nbinx);
                    binmean_Lt2 = allocate3d_float(num_red_bands, num_gridlines, nbinx);
                    bincount2 = allocate3d_float(num_red_bands, num_gridlines, nbinx);
                    binmean_Lt3 = allocate3d_float(num_SWIR_bands, num_gridlines, nbinx);
                    bincount3 = allocate3d_float(num_SWIR_bands, num_gridlines, nbinx);
 
                    for (unsigned int k = 0;k < num_blue_bands;k++) {
                        for (int i = 0; i < num_gridlines; i++) {
                            for (int j = 0; j < nbinx; j++) {
                                bincount[k][i][j] = 0.;
                                binmean_Lt[k][i][j] = 0.;
                            }
                        }
                      }
 
                    for (unsigned int k = 0;k < num_red_bands;k++) {
                        for (int i = 0; i < num_gridlines; i++) {
                            for (int j = 0; j < nbinx; j++) {
                                bincount2[k][i][j] = 0.;
                                binmean_Lt2[k][i][j] = 0.;
                            }
                         }
                     }
 
                    for (unsigned int k = 0;k < num_SWIR_bands;k++) {
                        for (int i = 0; i < num_gridlines; i++) {
                            for (int j = 0; j < nbinx; j++) {
                                bincount3[k][i][j] = 0.;
                                binmean_Lt3[k][i][j] = 0.;
                            }
                      }
                  }
 
                }//end if first time allocating mem for binning arrays
 
 
                //assigning mem for Lt of different bands **********************
                latpix = (float*)calloc(num_pixels , sizeof(float));
                lonpix = (float*)calloc(num_pixels , sizeof(float));
                Lt_pix = allocate2d_float(num_blue_bands, num_pixels);//blue bands
                Lt_pix2 = allocate2d_float(num_red_bands, num_pixels);//red bands
                Lt_pix3 = allocate2d_float(num_SWIR_bands, num_pixels);//SWIR bands
 
                cout << "#blue bands.." << num_blue_bands << endl;
                cout << "#red bands.." << num_red_bands << endl;
                cout << "#swir bands.." << num_SWIR_bands << endl;
 
 
 
                //********************************************************************************
                 //-----reading line by line-----------------------------------           
                for (unsigned int sline = last_sline;sline < num_scans;sline++) {
 
                    //lat and lon--
                    start[0] = sline;
                    start[1] = 0;
                    count[0] = 1;
                    count[1] = num_pixels;               // 1 line at a time
 
                    status = nc_get_vara_float(geoGrp, latId, start, count, latpix);
                    status = nc_get_vara_float(geoGrp, lonId, start, count, lonpix);
 
                    //****************************blue bands *********************************************************************
                           //loop blue bands------------    
                    //*************************************************************************************************************
                                 //Lt
 
                    start2[0] = 0;
                    start2[1] = sline;
                    start2[2] = 0;
 
                    count2[0] = num_blue_bands;
                    count2[1] = 1;               // 1 line at a time
                    count2[2] = num_pixels;
 
                    count3[0] = num_red_bands;
                    count3[1] = 1;               // 1 line at a time
                    count3[2] = num_pixels;
 
                    count4[0] = num_SWIR_bands;
                    count4[1] = 1;               // 1 line at a time
                    count4[2] = num_pixels;
 
                    status = nc_get_vara_float(obsGrp, Lt_blueId, start2, count2, Lt_pix[0]);
                    status = nc_get_vara_float(obsGrp, Lt_redId, start2, count3, Lt_pix2[0]);
                    status = nc_get_vara_float(obsGrp, Lt_SWIRId, start2, count4, Lt_pix3[0]);
 
 
                    /*      for(int bb=0;bb<num_blue_bands;bb++){
                               cout<<"processing blue band #.........................................................................."<<bb+1<<"of total blue bands #.."<<num_blue_bands<<endl;
                               cout<<"Lt_pix at pix =0..."<<Lt_pix[bb][0]<<"Lt_pix at pix =1..."<<Lt_pix[bb][1]<<endl;
                              }
                           exit(1);
                   */
 
                    for (unsigned int pix = 0;pix < num_pixels;pix++) {
                        if (latpix[pix] < latmin_swt) latmin_swt = latpix[pix];
                        if (latpix[pix] > latmax_swt) latmax_swt = latpix[pix];
                        if (lonpix[pix] < lonmin_swt) lonmin_swt = lonpix[pix];
                        if (lonpix[pix] > lonmax_swt) lonmax_swt = lonpix[pix];
                    }
 
 
                    //cout<<"latpix[nadpix]..."<<latpix[nadpix]<<"lonpix[nadpix]..."<<lonpix[nadpix]<<endl;         
                 //   cout<<"dlatb_g[k][0]...."<<dlatb_g[k][0]<<"dlatb_g[k][1]...."<<dlatb_g[k][1]<<endl;
 
 
                    dlamin = 0.;dlamax = 0.;
                    //inside the 'k' box??----- ascending ----------
                    if (latpix[nadpix] >= dlatb_g[k][0] && latpix[nadpix] <= dlatb_g[k][1]) {
 
                        if (sline % 100 == 0) cout << "EVERY 100 gds..for k group.." << k + 1 << "file number #.." << l1cfile->selgran[findex] << "sline..." << sline + 1 << "# of binned pix.." << inpix << "outpix.." << outpix << endl;
 
                        //*********** BIG LOOP M_PIXEL *****************************************************************
                        for (unsigned int pix = 0;pix < num_pixels;pix++) {
 
                            bb = 0, rb = 0, swb = 0;
                            flag_inpix = 0;
 
                            boolbin1 = sbs2_l1c(l1cinput, num_gridlines, nbinx, lat_asort, index_xy, latpix[pix], lonpix[pix], lon_gd, &gd_row, &gd_col);
 
                            bin_ypix = gd_row + 1;
                            bin_xpix = gd_col + 1;
 
                            //                   cout<<"pix..."<<pix+1<<"latpix..."<<latpix[pix]<<"lonpix..."<<lonpix[pix]<<endl;
 
                            if (boolbin1 == 1) flag_inpix = 1;
                            //************ BINNING ***************************
                         //assign identified pixel to Lt and bin stat arrays-----         
         //BLUE---
                            if (flag_inpix == 1 && bin_xpix >= 1 && bin_ypix >= 1 && bin_xpix <= nbinx && bin_ypix <= num_gridlines) {
                                inpix++;
                                while (bb < num_blue_bands) {
                                    if (Lt_pix[bb][pix] > 0.) {
                                        binmean_Lt[bb][bin_ypix - 1][bin_xpix - 1] = binmean_Lt[bb][bin_ypix - 1][bin_xpix - 1] + Lt_pix[bb][pix];
                                        bincount[bb][bin_ypix - 1][bin_xpix - 1] += 1;
                                    }
                                    bb++;
                                }//end while blue band band 
        //RED---
                                while (rb < num_red_bands) {
                                    if (Lt_pix2[rb][pix] > 0.) {
                                        binmean_Lt2[rb][bin_ypix - 1][bin_xpix - 1] = binmean_Lt2[rb][bin_ypix - 1][bin_xpix - 1] + Lt_pix2[rb][pix];
                                        bincount2[rb][bin_ypix - 1][bin_xpix - 1] += 1;
                                    }
                                    rb++;
                                }//end red bands
 
       //SWIR----
                                while (swb < num_SWIR_bands) {
                                    if (Lt_pix3[swb][pix] > 0.) {
                                        binmean_Lt3[swb][bin_ypix - 1][bin_xpix - 1] = binmean_Lt3[swb][bin_ypix - 1][bin_xpix - 1] + Lt_pix3[swb][pix];
                                        bincount3[swb][bin_ypix - 1][bin_xpix - 1] += 1;
                                    }
                                    swb++;
                                }//end swir bands
 
                            }//end if inpix
 
    //********** pixel AREA WEIGHTING ************************
                            if (flag_inpix == 0) outpix++;
 
                            totpix++;
 
                        }//end pixels loop
 
 
 
 
                        //END OF FILE--****** reset starting sline index if last line processed and within k box
                        //go for another granule if it is not the last one---------------
                        if (sline == num_scans - 1) {
                            flag_donefile = 1;
                            cout << "end of file..." << l1cfile->selgran[findex] << endl;
                            last_sline = 0;
                            if (findex >= sfiles - 1) {
                                cout << "done with last granule of the input list........................." << endl;
                                //   findex=sfiles;
                                k = ngroups;
                                break;
                            }
 
                        }//end of file/last file? sliine=num_scans-1
                        else flag_donefile = 0;
 
                    }//end latpix nadir of line x inside grid group?
 
         //***** skip lines and files if sline is not within k group ********
              //increase k and screen files and lines again starting from the last binning
 
                    if (latpix[nadpix] > lat_gd[n_gdlines - 1][257] && k < ngroups - 1) { //else limits                      
                        cout << "moving to the next k group...scanning again files/slines.." << endl;
                        cout << "file index.." << findex << "last sline index.." << sline << endl;
                        last_file = findex;
                        last_sline = sline;
                        findex = sfiles;
                        sline = num_scans - 1;                       
                    }//end if lat >grid lat--IF outside the box
 
                    if (sline + 1 % 100 == 0) cout << "for k group.." << k + 1 << "selected granule #.." << l1cfile->selgran[findex] << "sline..." << sline + 1 << "# of binned pix.." << inpix << "totpix.." << totpix << "outpix.." << outpix << endl;
                }//end for scanlines
 
                cout << "closing L1B file......." << ptstr << endl;
                status = nc_close(ncid_L1B);
                check_err(status, __LINE__, __FILE__);
 
                delete[](latpix);
                delete[](lonpix);
                delete[](Lt_pix);
                delete[](Lt_pix2);
                delete[](Lt_pix3);
 
 
 
 
                //**********************************************************************************************************************************
                //**********************************************************************************************************************************
                //writing each granule ---------------------------------
                //*****************************************************************************
 
                if (flag_donefile == 1 | (flag_donefile == 0 && k == ngroups - 1)) {
                    cout << "writing file #.............................................." << l1cfile->selgran[findex] << "based on group #.." << k + 1 << endl;
                    //write mean Lt as nc file---
                   //**********************************************************************
                   //**********************************************************************8
                   //create Lt file
                    pathstr = "out/";
                    senstr = "OCIS_";
                    monstr = std::to_string(selmon);
                    daystr = std::to_string(selday);
                    yearstr = std::to_string(selyear);
                    prodstr = "binLt_sbs";
                    swtstr = "_swt";
                    granstr = "";
                    granstr = "_" + std::to_string(l1cfile->selgran[findex]);
 
                    if (l1cfile->l1c_pflag >= 3) {
                        swtd = l1cfile->swtnum;
                        swtnum = std::to_string(swtd);
                        cout << "swtnum.." << swtnum << endl;
                    }
                    else swtnum = std::to_string(swtd);
                    extstr = ".nc";
                    NDIMS = 2;
                    fname_out = pathstr + senstr + monstr + daystr + yearstr + prodstr + swtstr + swtnum + granstr + extstr;
                    filename_lt = fname_out.c_str();
 
                    /*     try
                           {
                            cout<<"Opening file \"firstFile.nc\" with NcFile::replace"<<endl;
                            NcFile ncFile("firstFile.nc",NcFile::replace);
                            NcGroup groupA(ncFile.addGroup("groupA"));
                            }
 
                         catch (NcException& e)
                             {
                               cout << "unknown error"<<endl;
                                e.what();
                                 }
                         exit(1);
                        */
 
                    if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
                        check_err(status, __LINE__, __FILE__);
                    //define dims
                    // Define the dimensions. NetCDF will hand back an ID for each. 
                    NY = num_gridlines;
                    NX = nbinx;
                    NY1 = l1cfile->NY1;//these are indexes not line #!!!!!!!!!!!!!!!!!
                    NY2 = l1cfile->NY2;
                    cout << "rowgrid ini.." << NY1 << "rowgrid end.." << NY2 << endl;
                    NY = NY2 - NY1 + 1;
                    cout << "NY.." << NY << "NX.." << NX << endl;
                    //alloc mem for data_out and assign values from lat_gdI
                    //NX AND NY are inverted for visualization in SeaDAS
 
     //               data_out=allocate2d_float(NY,NX);
 
               /*     data_out2 = allocate2d_float(NY,NX);
                    data_out3 = allocate2d_float(NY,NX);
                    data_out4 = allocate2d_float(NY,NX);
                    data_out5 = allocate2d_float(NY,NX);
                    data_out6 = allocate2d_float(NY,NX);
               */
                    lat_out = allocate2d_float(NY, NX);
                    lon_out = allocate2d_float(NY, NX);
 
                    int c = 0;
 
                    for (int i = NY1; i < NY2 + 1; i++) {
                        for (int j = 0; j < NX; j++) {
                            lat_out[NY - 1 - c][NX - 1 - j] = lat_gd[i][j];
                            lon_out[NY - 1 - c][j] = lon_gd[i][j];
                        }
                        c++;
                    }
 
                    //blue
                        /*           c=0;
                                   for(bb=0;bb<num_blue_bands;bb++){
                                     for(int i=NY1; i<NY2+1; i++){
                                       for(int j=0; j<NX; j++){
                                         if (bincount[bb][i][j]>0)
                                           data_out[NY-1-c][NX-1-j]=binmean_Lt[bb][i][j]/bincount[bb][i][j];
                                         else         data_out[NY-1-c][NX-1-j]=NAN;
                                           }
                                        c++;
                                      }
                                     }//end bands
                    */
 
 
                    //red      
                          /*         if (bincount2[i][j]>0)
                                        data_out3[NY-1-c][NX-1-j]=binmean_Lt2[i][j]/bincount2[i][j];
                                   else
                                        data_out3[NY-1-c][NX-1-j]=NAN;
                    //swir
                                   if (bincount3[i][j]>0)
                                        data_out5[NY-1-c][NX-1-j]=binmean_Lt3[i][j]/bincount3[i][j];
                                   else
                                        data_out5[NY-1-c][NX-1-j]=NAN;
 
                                           data_out2[NY-1-c][NX-1-j]=bincount[i][j];
                                           data_out4[NY-1-c][NX-1-j]=bincount2[i][j];
                                           data_out6[NY-1-c][NX-1-j]=bincount3[i][j];
                             */
 
                             //              }
                             //       c++;
                           //            }
                            //        }//end bands
 
                    if ((status = nc_def_dim(ncid_out, "x", NX, &x_dimid)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_dim(ncid_out, "y", NY, &y_dimid)))
                        check_err(status, __LINE__, __FILE__);
                    //dims for output var
                    dimids[0] = y_dimid;
                    dimids[1] = x_dimid;
 
                    //define groups-----
                             //    status = nc_def_grp( *ncid, line.c_str(), &gid[ngrps]);
                    if ((status = nc_def_grp(ncid_out, "data", &grp_root)))  //netcdf-4
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_grp(grp_root, "geo_coordinates", &grp_coor)))  //netcdf-4
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_grp(grp_root, "blue_bands", &grp_blue)))  //netcdf-4
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_grp(grp_root, "red_bands", &grp_red)))  //netcdf-4
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_grp(grp_root, "swir_bands", &grp_swir)))  //netcdf-4
                        check_err(status, __LINE__, __FILE__);
 
                    //def var--------------------
 
                             //loop blue channels-----
 
                    string bb_num, rb_num, swb_num, bb_str = "binLt_blue_ch", rb_str = "binLt_red_ch", swb_str = "binLt_swir_ch";
 
                    int varid_bb[num_blue_bands], varid_rb[num_red_bands], varid_swb[num_SWIR_bands];
 
                    for (bb = 0;bb < num_blue_bands;bb++) {
                        bb_num = std::to_string(bb + 1);
                        bb_num = bb_str + bb_num;
                        if ((status = nc_def_var(grp_blue, bb_num.c_str(), NC_FLOAT, NDIMS, dimids, &varid))) check_err(status, __LINE__, __FILE__);
                        varid_bb[bb] = varid;
                    }
 
                    for (rb = 0;rb < num_red_bands;rb++) {
                        rb_num = std::to_string(rb + 1);
                        rb_num = rb_str + rb_num;
                        if ((status = nc_def_var(grp_red, rb_num.c_str(), NC_FLOAT, NDIMS, dimids, &varid))) check_err(status, __LINE__, __FILE__);
                        varid_rb[rb] = varid;
                    }
 
                    for (swb = 0;swb < num_SWIR_bands;swb++) {
                        swb_num = std::to_string(swb + 1);
                        swb_num = swb_str + swb_num;
                        if ((status = nc_def_var(grp_swir, swb_num.c_str(), NC_FLOAT, NDIMS, dimids, &varid))) check_err(status, __LINE__, __FILE__);
                        varid_swb[swb] = varid;
                    }
 
                    //       if ((status = nc_def_var(grp_blue,"whatever", NC_FLOAT, NDIMS,
                    //           dimids, &varid)))
 
 
 
            //               if ((status = nc_def_var(ncid_out, "bincount_blue", NC_FLOAT, NDIMS,
            //                  dimids, &varid4)))
            //                  check_err(status, __LINE__, __FILE__);
                    //red 
            /*               if ((status = nc_def_var(ncid_out, "binLt_red", NC_FLOAT, NDIMS,
                              dimids, &varid5)))
                              check_err(status, __LINE__, __FILE__);
                           if ((status = nc_def_var(ncid_out, "bincount_red", NC_FLOAT, NDIMS,
                              dimids, &varid6)))
                              check_err(status, __LINE__, __FILE__);
                    //swir
                           if ((status = nc_def_var(ncid_out, "binLt_swir", NC_FLOAT, NDIMS,
                               dimids, &varid7)))
                              check_err(status, __LINE__, __FILE__);
                           if ((status = nc_def_var(ncid_out, "bincount_swir", NC_FLOAT, NDIMS,
                               dimids, &varid8)))
                               check_err(status, __LINE__, __FILE__);
            */
 
            //lat/lon
                    if ((status = nc_def_var(grp_coor, "lat_gd", NC_FLOAT, NDIMS,
                        dimids, &varid2)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_var(grp_coor, "lon_gd", NC_FLOAT, NDIMS,
                        dimids, &varid3)))
                        check_err(status, __LINE__, __FILE__);
                    //leave define mode-----------------------
                    if ((status = nc_enddef(ncid_out))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
 
                    //assign variable data------------------------
                             /*        start2[0]=0;
                                     start2[1]=0;
                                     start2[2]=0;
 
                                     count2[0]=1;
                                     count2[1]=NY;
                                     count2[2]=NX;
 
 
                                     float lat_data[NY][NX];
 
                                     for (int i=0;i<NY;i++){
                                       for (int j=0;j<NX;j++){
                                      lat_data[i][j]=lat_out[i][j];
                                   }}
 
                    */
                    //                 if((status = nc_put_vara_float(ncid_out,varid2,start2,count2,&lat_out[0][0])))
                    //                 check_err(status, __LINE__, __FILE__);
                    //                 if((status = nc_put_vara(grp_coor,varid3,start,count,lon_out)));
                    //                 check_err(status, __LINE__, __FILE__);
                    //                 if((status = nc_put_vara(grp_blue,varid,start,count,data_out)));
                    //                 check_err(status, __LINE__, __FILE__);
 
                    if ((status = nc_put_var_float(grp_coor, varid2, &lat_out[0][0])))
                        check_err(status, __LINE__, __FILE__);
 
                    if ((status = nc_put_var_float(grp_coor, varid3, &lon_out[0][0])))
                        check_err(status, __LINE__, __FILE__);
                    //blue
 
                    for (bb = 0;bb < num_blue_bands;bb++) {
                        data_out = allocate2d_float(NY, NX);
                        c = 0;
                        for (int i = NY1; i < NY2 + 1; i++) {
                            for (int j = 0; j < NX; j++) {
                                data_out[NY - 1 - c][NX - 1 - j] = 0.;
                            }
                            c++;
                        }
                        c = 0;
                        for (int i = NY1; i < NY2 + 1; i++) {
                            for (int j = 0; j < NX; j++) {
                                if (bincount[bb][i][j] > 0)
                                    data_out[NY - 1 - c][NX - 1 - j] = binmean_Lt[bb][i][j] / bincount[bb][i][j];
                                else         data_out[NY - 1 - c][NX - 1 - j] = NAN;
                            }
                            c++;
                        }
                        cout << "writing blue band#.." << bb + 1 << endl;
                        if ((status = nc_put_var_float(grp_blue, varid_bb[bb], &data_out[0][0])))
                            check_err(status, __LINE__, __FILE__);
 
 
                        delete[](data_out);
                    }//end blue bands
 
 
           //red
                    for (rb = 0;rb < num_red_bands;rb++) {
                        data_out2 = allocate2d_float(NY, NX);
                        c = 0;
                        for (int i = NY1; i < NY2 + 1; i++) {
                            for (int j = 0; j < NX; j++) {
                                data_out2[NY - 1 - c][NX - 1 - j] = 0.;
                            }
                            c++;
                        }
                        c = 0;
                        for (int i = NY1; i < NY2 + 1; i++) {
                            for (int j = 0; j < NX; j++) {
                                if (bincount2[rb][i][j] > 0)
                                    data_out2[NY - 1 - c][NX - 1 - j] = binmean_Lt2[rb][i][j] / bincount2[rb][i][j];
                                else         data_out2[NY - 1 - c][NX - 1 - j] = NAN;
                            }
                            c++;
                        }
                        cout << "writing red band#.." << rb + 1 << endl;
                        if ((status = nc_put_var_float(grp_red, varid_rb[rb], &data_out2[0][0])))
                            check_err(status, __LINE__, __FILE__);
 
                        delete[](data_out2);
                    }//end red bands
 
 
           //swir
                    for (swb = 0;swb < num_SWIR_bands;swb++) {
                        data_out3 = allocate2d_float(NY, NX);
                        c = 0;
                        for (int i = NY1; i < NY2 + 1; i++) {
                            for (int j = 0; j < NX; j++) {
                                data_out3[NY - 1 - c][NX - 1 - j] = 0.;
                            }
                            c++;
                        }
                        c = 0;
                        for (int i = NY1; i < NY2 + 1; i++) {
                            for (int j = 0; j < NX; j++) {
                                if (bincount3[swb][i][j] > 0)
                                    data_out3[NY - 1 - c][NX - 1 - j] = binmean_Lt3[swb][i][j] / bincount3[swb][i][j];
                                else         data_out3[NY - 1 - c][NX - 1 - j] = NAN;
                            }
                            c++;
                        }
                        cout << "writing SWIR band#.." << swb + 1 << endl;
                        if ((status = nc_put_var_float(grp_swir, varid_swb[swb], &data_out3[0][0])))
                            check_err(status, __LINE__, __FILE__);
 
                        delete[](data_out3);
                    }//end red bands
 
 
   /*               if ((status = nc_put_var_float(ncid_out, varid4, &data_out2[0][0])))
                      check_err(status, __LINE__, __FILE__);
               //red
                  if ((status = nc_put_var_float(ncid_out, varid5, &data_out3[0][0])))
                      check_err(status, __LINE__, __FILE__);
                  if ((status = nc_put_var_float(ncid_out, varid6, &data_out4[0][0])))
                      check_err(status, __LINE__, __FILE__);
               //swir
                  if ((status = nc_put_var_float(ncid_out, varid7, &data_out5[0][0])))
                      check_err(status, __LINE__, __FILE__);
                  if ((status = nc_put_var_float(ncid_out, varid8, &data_out6[0][0])))
                      check_err(status, __LINE__, __FILE__);
   */
 
                    if ((status = nc_close(ncid_out)))
                        check_err(status, __LINE__, __FILE__);
 
                    delete[](lat_out);
                    delete[](lon_out);
                    //               delete [] (data_out);
 
 
                             /*      delete [] (data_out2);
                                   delete [] (data_out3);
                                   delete [] (data_out4);
                                   delete [] (data_out5);
                                   delete [] (data_out6);
                             */
                    delete[](bincount);
                    delete[](binmean_Lt);
                    delete[](bincount2);
                    delete[](binmean_Lt2);
                    delete[](bincount3);
                    delete[](binmean_Lt3);
 
 
                    lat_out = nullptr;;
                    lon_out = nullptr;
                    data_out = nullptr;
                    data_out2 = nullptr;
                    data_out3 = nullptr;
                 
                
               
 
                    bincount = nullptr;
                    binmean_Lt = nullptr;
                    bincount2 = nullptr;
                    binmean_Lt2 = nullptr;
                    bincount3 = nullptr;
                    binmean_Lt3 = nullptr;
 
                    flag_donefile = 0;
                }//end writing file
            }//end for files
 
            cout << "group k at the end of big loop" << k + 1 << endl;
 
        }//groups
 
        cout << "number of files per swath.." << nfiles_swt[swtd - 1] << "for swath.." << swtd << endl;
        cout << "total inpix.." << inpix << "total pix.." << totpix << endl;
        //  cout<<"binned pixels.."<<inpix<<"as %.."<<(inpix/(num_pixels*num_scans*n_files*nfiles_swt[swtd-1]))*100<<endl;
        delete[](lat_asort);
        //   delete [] (lon_asort);
        delete[](index_xy);
        //   delete [] (index_xy2);
        delete[](dlatb_g);
        delete[](dlonb_g);
 
        delete[](lat_gd);
        delete[](lon_gd);
        delete[](az_east);
 
        printf("*** SUCCESS writing bincount and binLt rasters as nc..!\n");
        cout << "finish processing swath eq crossing day..." << swtd << endl;
        cout << "done writing Lt to nc file.." << endl;
 
        return(0);
    }
 
 
 
 
 
    //similar to w2 version byt hyperspectral
    int32_t L1C::binL1C_wgranule3(int swtd, l1c_filehandle* l1cfile, L1C_input* l1cinput, int16_t* swtd_id, int16_t* odir, int16_t* file_id, int16_t* nfiles_swt) {
        int32_t gdlines_group, ngroups = 0, num_gridlines, nbinx, inpix = 0, outpix = 0, totpix = 0, n_gdlines;//number of gridlines to be processed
        float minv = 0., maxv = 0., ** dlatb_g, ** dlonb_g;
        int16_t fi = 0;
        std::string str;
        const char* ptstr;
        int dimid, status, ncid_out, x_dimid, y_dimid, varid, varid2, varid3, NDIMS;
        size_t start[] = { 0, 0 };
        size_t count[] = { 1, 1 };
        size_t start2[] = { 0, 0, 0 };
        size_t count2[] = { 1, 1, 1 }, count3[] = { 1, 1, 1 }, count4[] = { 1, 1, 1 };
        int32_t bin_xpix, bin_ypix;
        float* latpix, * lonpix, ** Lt_pix, ** Lt_pix2, ** Lt_pix3;
     
        float latmin_swt = 100, latmax_swt = 0, lonmin_swt = 0, lonmax_swt = 0;
        int dimids[2];
        const char* filename_lt;
        int32_t NY = -1, NX = -1, NY1 = -1, NY2 = -1, c1 = 1;
        float** data_out, ** data_out2, ** data_out3, ** lat_out, ** lon_out;
    
        int last_file, last_sline, flag_inpix, flag_donefile;;//first index file id, second index line #
        short** index_xy;
        float** lat_asort;
        bool boolbin1;
 
        int16_t selyear = -1, selmon = -1, selday = -1;
        float** lat_gd, ** lon_gd, * az_east;
        string gridname, azeast_name;
        float*** bincount = NULL, *** bincount2 = NULL, *** bincount3 = NULL, *** binmean_Lt = nullptr, *** binmean_Lt2 = nullptr, *** binmean_Lt3 = nullptr;
        double gres = (l1cinput->gres) * 1000, dlamin, dlamax, dlomin, dlomax;
        int grp_root, grp_blue, grp_red, grp_swir, grp_coor;
        unsigned int bb = 0, rb = 0, swb = 0;
        char tmp[256]; 
 
 
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
     
     
    
     //random seed
        srand((unsigned int)time(NULL));
        //nadir pixel ofr OCI
        int nadpix = l1cfile->nadpix;
 
 
        num_gridlines = 4000;
        nbinx = l1cfile->nbinx;
        num_pixels = l1cfile->npix;
 
        size_t sfiles = 0;
 
        if (l1cfile->selgran[0] < 0)//process all granules
        {
            sfiles = nfiles_swt[swtd - 1];
            for (unsigned int j = 0;j < sfiles;j++) l1cfile->selgran[j] = j + 1;
        }
        else {
            while (l1cfile->selgran[sfiles] > 0) {
                cout << "selected granule #..........................." << l1cfile->selgran[sfiles] << endl;
                sfiles++;
            }
        }
 
        cout<<"binning Lt using sbs2 method and hyperspectral arrays..........................................................................."<<endl;
        //allocate mem for lat/lon/azeast pointers---
        selday = l1cinput->selday;
        selmon = l1cinput->selmon;
        selyear = l1cinput->selyear;
 
        std::string fname_out, pathstr, senstr, monstr, daystr, yearstr, prodstr, gdstr, swtstr, swtnum, extstr, granstr;
 
//        pathstr = "out/";
        senstr = "OCIS_";
        monstr = std::to_string(selmon);
        daystr = std::to_string(selday);
        yearstr = std::to_string(selyear);
        prodstr = "L1Cgrid";
        swtstr = "_swt";
        extstr = ".csv";
 
        if (l1cfile->l1c_pflag >= 3) {
            swtd = l1cfile->swtnum;
            swtnum = std::to_string(swtd);
            cout << "swtnum.." << swtnum << endl;
        }
        else swtnum = std::to_string(swtd);
     
        getcwd(tmp, 256);
        pathstr=tmp;
        gridname = pathstr + "/out/"+senstr + monstr + daystr + yearstr + prodstr + swtstr + swtnum + extstr;
 
        prodstr = "az_east";
        azeast_name = pathstr + "/out/"+senstr + monstr + daystr + yearstr + prodstr + swtstr + swtnum + extstr;
        cout << "gridname.." << gridname << "azeast-name.." << azeast_name << endl;
 
        //************ OPENING **************************************
        //*** AZ_EAST *****************
        //*** AZ_EAST *****************
        std::string line;
        stringstream ss;
        std::string temp;
        std::vector<std::string> parts;
        ifstream fin(azeast_name);
        int cline = 0;
        while (getline(fin, line))
        {
            // load line in stringstream
            ss << line;
            getline(ss, temp, ',');
            parts.push_back(temp);
            ss.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            ss.clear();
            cline++;
        }
        //minus -1 cause the header
        cout << "size of azeast minus heading row..= num_gridlines." << parts.size() - 1 << "nbinx.." << nbinx << endl;
        num_gridlines = parts.size() - 1;
 
 
        //**LAT_GD *******************
        ifstream fin2(gridname);
        std::vector<std::string> tokens_lon, tokens_lat;
        std::string token;
        cline = 0;
        int fcol = 0;
        while (getline(fin2, line))
        {
            // load line in stringstream
            istringstream iss(line);
            while (getline(iss, token, ','))
            {
                cline++;
                if (fcol == 0 & cline > 2) {
                    tokens_lon.push_back(token);fcol++;                
}
                else if (fcol == 1 & cline > 2)
                    tokens_lat.push_back(token);
 
            }
            fcol = 0;
        }
 
 
      
 
        cout << "size of gridline minus heading row..= num_gridlines." << (tokens_lon.size() - 1) / nbinx << "nbinx.." << nbinx << endl;
 
 
        //************************************************************
        //mem allocation for geolcoation pointers---
        az_east = (float*)calloc(num_gridlines , sizeof(float));
        lat_gd = allocate2d_float(num_gridlines, nbinx);
        lon_gd = allocate2d_float(num_gridlines, nbinx);
 
        float sum = 0, tot = 0;
        for (int j = 0;j < num_gridlines;j++) {
            //     cout<<"j.."<<j<<"az_east"<<std::stof(parts[j+1])<<endl;
            az_east[j] = std::stof(parts[j + 1]);//first line is the header
            sum = az_east[j];
            tot += sum;
        }
        parts.clear();
 
 
 
        //using swath-averaged az_east for nadir pixels rather than along-track az_east pixel-by-pixel
        float mean_az_east = tot / (num_gridlines - 1);
        cout << "mean_az_east..." << mean_az_east << "numgridlines.." << num_gridlines << endl;
        //   exit(1); 
        for (int j = 0;j < num_gridlines;j++) {
            az_east[j] = mean_az_east;
        }
 
 
        int ip = 0;
        for (int j = 0;j < num_gridlines;j++) {
            for (int k = 0;k < nbinx;k++) {
                lat_gd[j][k] = std::stof(tokens_lat[ip]);
                lon_gd[j][k] = std::stof(tokens_lon[ip]);
                //   if(ip % nbinx == 0) cout<<"ip.."<<ip<<"gdline.."<<j+1<<"binx.."<<k+1<<"latgd.."<<std::stof(tokens_lat[ip])<<"longd.."<<std::stof(tokens_lon[ip])<<endl;
                ip++;
            }        
}
        tokens_lon.clear();
        tokens_lat.clear();
 
        //determine # of gd groups to be processede  
        //gdlines_group=num_gridlines;//ONE BIG GROUP
        gdlines_group = 250;
 
        if (num_gridlines <= gdlines_group) {
            gdlines_group = num_gridlines;
            cout << "WARNING********************* number_gridlines<=gdlines_group THEN gdlines_group=num_gridlines **************" << endl;
        }
 
        ngroups = floor(num_gridlines / gdlines_group);
        cout << "TOTAL # of gd groups.(ALL LATs...." << ngroups << endl;
 
        //--NORMALIZED  gridline longitude is -180 to 180 degrees before comparison with longitude extracted from image pixels---
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lon_gd[i][j] < -180.)lon_gd[i][j] += 360.;
                if (lon_gd[i][j] > 180.)lon_gd[i][j] -= 360.;
            }        
}
        //get min/max lat/lon of the swath
        // Assume first element as maximum and minimum
        maxv = lat_gd[0][0];
        minv = lat_gd[0][0];
 
        //Find maximum and minimum in all array elements.
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lat_gd[i][j] > maxv)
                    maxv = lat_gd[i][j];
                if (lat_gd[i][j] < minv)
                    minv = lat_gd[i][j];
            }        
}
     
    
        maxv = lon_gd[0][0];
        minv = lon_gd[0][0];
        //Find maximum and minimum in all array elements.
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lon_gd[i][j] > maxv)
                    maxv = lon_gd[i][j];
                if (lon_gd[i][j] < minv)
                    minv = lon_gd[i][j];
            }
        }
   
  
 
        cout << "swath #.." << swtd << endl;
 
        //check lat bound min/max of each gd group---
        int k = 0, i = 0;
 
        dlatb_g = allocate2d_float(ngroups + 1, 2);
        dlonb_g = allocate2d_float(ngroups + 1, 2);
 
        //recompute number of gridlines based on lat limits -80 to 80 degrees  
       //asc orbit goes from negative to positive latitude....
        NY = num_gridlines;
        NX = nbinx;
        for (int i = 0; i < NY; i++) {
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= -80.) c1++;
                if (c1 == nbinx) {
                    NY1 = i;
                }
            }
            if (NY1 >= 0) break;
            c1 = 1;
        }
 
 
        for (int i = 0;i < NY; i++) {
            //   cout<<"i.."<<i<<"lat_gd[i][j]..."<<lat_gd[i][nadpix]<<endl;
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= 80.) {
                    NY2 = i - 1;
                }
            }
 
            if (NY2 >= 0) break;
        }
 
        // cout<<"gridlines limited to -80 to 80 degrees of latitutde.."<<"gdline ini.."<<NY1<<"gdline end.."<<NY2<<endl;
 
        l1cfile->NY1 = NY1;
        l1cfile->NY2 = NY2;
 
        cout << "NY.." << NY << "NY1.." << NY1 << "NY2.." << NY2 << endl;
 
 
 
        num_gridlines = NY2 - NY1 + 1;//this is the # gridlines after -80 to 80 lat constraint---
        ngroups = floor(num_gridlines / gdlines_group);
        cout << "gdlines will start in gline.." << i + 1 << "ROUNDED ngroups after adjusting beginning.for constraint lat (-80 to 80)" << ngroups << endl;
 
        //for each 'grid' group scan the swath files to see if there are scanlines within--
        //if that is case check the across-bin number position (0 to binx-1) based on latnad and lonnad values--- 
        last_file = 0;
        last_sline = 0;
        flag_donefile = 0;
 
        num_blue_bands = 120;
        num_red_bands = 120;
        num_SWIR_bands = 9;
 
        if (num_gridlines > ngroups * gdlines_group) ngroups += 1;
 
 
        //*********** SORTING LAT/LON ASCENDING AND TRACK INDEXES ****************************
        //***********************************************************************************
 
        //Create index matrix for i and j of each lat and lon L1C grid (-80 to 80)
        //num_gridlines x nbinx
        index_xy = allocate2d_short(num_gridlines, nbinx);
        lat_asort = allocate2d_float(num_gridlines, nbinx);
        //  lon_asort=allocate2d_float(num_gridlines,nbinx);
             //fill indexe
 
        //define 1-D vector to sort 1 col L1C grid at the time---
        vector<pair<float, int> > vp;
 
        //fill vector with lat_gd column--
        cout << "*********** SORTING LAT/LON GRIDPOINTS AND TRACKING INDEXES ********************" << endl;
 
        for (int col = 0;col < nbinx;col++) {
            for (int row = NY1;row < NY2 + 1;row++) {
                vp.push_back(make_pair(lat_gd[row][col] + 90., row));
            }
            //sort 
            stable_sort(vp.begin(), vp.end());
            //display lat in order along with its gridpoint index--
              //   cout << "Lat value\t"
              //         << "index" << endl; 
            for (unsigned int i = 0; i < vp.size(); i++) {
                lat_asort[i][col] = vp[i].first;
                index_xy[i][col] = vp[i].second;
            }
            vp.clear();
        }
 
        //saddleback search
        short gd_row, gd_col;
 
        cout << "num_gridlines...." << num_gridlines << "ngroups.." << ngroups << endl;
 
 
        //****************************************************************************************************
           //************* BIG LOOP GROUPS ***************************************
        cout << "Number of granules to be L1C processed........................................." << sfiles << endl;
        num_blue_bands = 120;
 
 
 
 
        for (k = 0;k < ngroups;k++) {
 
            //total gridlines for k groups-----
            n_gdlines = (k + 1) * gdlines_group;
            cout << "screening k group.." << k + 1 << "last_file.." << last_file << "last_line.." << last_sline << endl;
            cout << "number of gridlines so far..." << n_gdlines << endl;
            //***** compute deltas for lat_gd index 256 and 257 *******************
 
             //compute delta_lat and delta_lon based on binres/2 for lower and upper corners of 'nadir' gridpoints of 256 and 257 indexes -----------------
               //we need nadir 256 and 257 lat/lon coordinates to compute -delta and +delta, respectively
               //we need azimuth and backazimuth and binres/2 to compute deltas ---
 
                //index 256
            geod.Direct(lat_gd[n_gdlines - gdlines_group][256], lon_gd[n_gdlines - gdlines_group][256], az_east[n_gdlines - gdlines_group], gres, dlamin, dlomin);
            geod.Direct(lat_gd[n_gdlines - 1][257], lon_gd[n_gdlines - 1][257], az_east[n_gdlines - 1], gres, dlamax, dlomax);
 
            cout << "dlamin.." << dlamin << "dlomin.." << dlomin << "dlamax.." << dlamax << "dlomax.." << dlomax << endl;
 
            dlatb_g[k][0] = dlamin;//in DEGREES!!
            dlatb_g[k][1] = dlamax;
            dlonb_g[k][0] = dlomin;
            dlonb_g[k][1] = dlomax;
 
            //********* LOOP FILES ************************************
            for (unsigned int findex = last_file;findex < sfiles;findex++) {
 
                cout << "Scanning lines in file.. for crossing swath..." << swtd << "selected granule #.." << l1cfile->selgran[findex] << "swt_id.." << swtd_id[findex] << "grid group.." << k + 1 << endl;
 
 
                if (last_sline == 0 && binmean_Lt == nullptr && binmean_Lt2 == nullptr && binmean_Lt3 == nullptr) { // binmean_Lt==NULL | bincount==NULL | binmean_Lt2==NULL | bincount2==NULL | binmean_Lt3==NULL | bincount3==NULL){
 
                    cout << "first allocation of memory for grid bins of file #..." << l1cfile->selgran[findex] << endl;
 
                    //            cout<<"findex.."<<findex<<"blue bands"<<num_blue_bands<<"red bands.."<<num_red_bands<<"swir bands..."<<num_SWIR_bands<<"nbinx.."<<nbinx<<endl;
 
                    binmean_Lt = allocate3d_float(num_blue_bands, num_gridlines, nbinx);
                    bincount = allocate3d_float(num_blue_bands, num_gridlines, nbinx);
                    binmean_Lt2 = allocate3d_float(num_red_bands, num_gridlines, nbinx);
                    bincount2 = allocate3d_float(num_red_bands, num_gridlines, nbinx);
                    binmean_Lt3 = allocate3d_float(num_SWIR_bands, num_gridlines, nbinx);
                    bincount3 = allocate3d_float(num_SWIR_bands, num_gridlines, nbinx);
 
                    for (unsigned int k = 0;k < num_blue_bands;k++) {
                        for (int i = 0; i < num_gridlines; i++) {
                            for (int j = 0; j < nbinx; j++) {
                                bincount[k][i][j] = 0.;
                                binmean_Lt[k][i][j] = 0.;
                            }                        
}                    
}
 
                    for (unsigned int k = 0;k < num_red_bands;k++) {
                        for (int i = 0; i < num_gridlines; i++) {
                            for (int j = 0; j < nbinx; j++) {
                                bincount2[k][i][j] = 0.;
                                binmean_Lt2[k][i][j] = 0.;
                            }                        
}                    
}
 
                    for (unsigned int k = 0;k < num_SWIR_bands;k++) {
                        for (int i = 0; i < num_gridlines; i++) {
                            for (int j = 0; j < nbinx; j++) {
                                bincount3[k][i][j] = 0.;
                                binmean_Lt3[k][i][j] = 0.;
                            }                        
}                    
}
 
                }//end allocating bin arrays
 
 
                fi = l1cfile->selgran[findex];
                str = l1cfile->ifiles[fi - 1];
                ptstr = str.c_str();
 
                cout << "opening filename............" << ptstr << endl;
 
                status = nc_open(ptstr, NC_NOWRITE, &ncid_L1B);
                if (status != NC_NOERR) {
                   fprintf(stderr, "nc_open error.\n");
                    exit(EXIT_FAILURE);
}
                //Open dimensions
                status = nc_inq_dimid(ncid_L1B, "number_of_scans", &dimid);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading number_of_scans.\n");
                    exit(EXIT_FAILURE);
                }
                nc_inq_dimlen(ncid_L1B, dimid, &num_scans);
 
                //read line-by-line lat/lon/Lt
                status = nc_inq_grp_ncid(ncid_L1B, "geolocation_data", &geoGrp);
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_grp_ncid(ncid_L1B, "observation_data", &obsGrp);
                check_err(status, __LINE__, __FILE__);
                //open geo data 
                status = nc_inq_varid(geoGrp, "latitude", &latId);//scans x velements
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(geoGrp, "longitude", &lonId);//scans x velements
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(obsGrp, "Lt_blue", &Lt_blueId);
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(obsGrp, "Lt_red", &Lt_redId);
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(obsGrp, "Lt_SWIR", &Lt_SWIRId);
                check_err(status, __LINE__, __FILE__);
 
 
                // num_blue_bands
                status = nc_inq_dimid(ncid_L1B, "blue_bands", &dimid);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading num_blue_bands.\n");
                    exit(EXIT_FAILURE);
                }
                nc_inq_dimlen(ncid_L1B, dimid, &num_blue_bands);
 
                // num_red_bands
                status = nc_inq_dimid(ncid_L1B, "red_bands", &dimid);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading num_red_bands.\n");
                    exit(EXIT_FAILURE);
                }
                nc_inq_dimlen(ncid_L1B, dimid, &num_red_bands);
 
                // num_SWIR_bands
                status = nc_inq_dimid(ncid_L1B, "SWIR_bands", &dimid);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading num_SWIR_bands.\n");
                    exit(EXIT_FAILURE);
                }
                nc_inq_dimlen(ncid_L1B, dimid, &num_SWIR_bands);
                //assigning mem for Lt of different bands **********************
                latpix = (float*)calloc(num_pixels , sizeof(float));
                lonpix = (float*)calloc(num_pixels , sizeof(float));
                Lt_pix = allocate2d_float(num_blue_bands, num_pixels);//blue bands
                Lt_pix2 = allocate2d_float(num_red_bands, num_pixels);//red bands
                Lt_pix3 = allocate2d_float(num_SWIR_bands, num_pixels);//SWIR bands
 
                cout << "#blue bands.." << num_blue_bands << endl;
                cout << "#red bands.." << num_red_bands << endl;
                cout << "#swir bands.." << num_SWIR_bands << endl;
 
 
 
                //********************************************************************************
                 //-----reading line by line-----------------------------------           
                for (unsigned int sline = last_sline;sline < num_scans;sline++) {
 
                    //lat and lon--
                    start[0] = sline;
                    start[1] = 0;
                    count[0] = 1;
                    count[1] = num_pixels;               // 1 line at a time
 
                    status = nc_get_vara_float(geoGrp, latId, start, count, latpix);
                    status = nc_get_vara_float(geoGrp, lonId, start, count, lonpix);
 
                    //****************************blue bands *********************************************************************
                           //loop blue bands------------    
                    //*************************************************************************************************************
                                 //Lt
 
                    start2[0] = 0;
                    start2[1] = sline;
                    start2[2] = 0;
 
                    count2[0] = num_blue_bands;
                    count2[1] = 1;               // 1 line at a time
                    count2[2] = num_pixels;
 
                    count3[0] = num_red_bands;
                    count3[1] = 1;               // 1 line at a time
                    count3[2] = num_pixels;
 
                    count4[0] = num_SWIR_bands;
                    count4[1] = 1;               // 1 line at a time
                    count4[2] = num_pixels;
 
                    status = nc_get_vara_float(obsGrp, Lt_blueId, start2, count2, Lt_pix[0]);
                    status = nc_get_vara_float(obsGrp, Lt_redId, start2, count3, Lt_pix2[0]);
                    status = nc_get_vara_float(obsGrp, Lt_SWIRId, start2, count4, Lt_pix3[0]);
 
 
                    /*      for(int bb=0;bb<num_blue_bands;bb++){
                               cout<<"processing blue band #.........................................................................."<<bb+1<<"of total blue bands #.."<<num_blue_bands<<endl;
                               cout<<"Lt_pix at pix =0..."<<Lt_pix[bb][0]<<"Lt_pix at pix =1..."<<Lt_pix[bb][1]<<endl;
                              }
                           exit(1);
                   */
 
                    for (unsigned int pix = 0;pix < num_pixels;pix++) {
                        if (latpix[pix] < latmin_swt) latmin_swt = latpix[pix];
                        if (latpix[pix] > latmax_swt) latmax_swt = latpix[pix];
                        if (lonpix[pix] < lonmin_swt) lonmin_swt = lonpix[pix];
                        if (lonpix[pix] > lonmax_swt) lonmax_swt = lonpix[pix];
                    }
 
 
                    //cout<<"latpix[nadpix]..."<<latpix[nadpix]<<"lonpix[nadpix]..."<<lonpix[nadpix]<<endl;         
                 //   cout<<"dlatb_g[k][0]...."<<dlatb_g[k][0]<<"dlatb_g[k][1]...."<<dlatb_g[k][1]<<endl;
 
                    dlamin = 0.;dlamax = 0.;
                    //inside the 'k' box??----- ascending ----------
                    if (latpix[nadpix] >= dlatb_g[k][0] && latpix[nadpix] <= dlatb_g[k][1]) {
 
                        if (sline % 100 == 0) cout << "EVERY 100 gds..for k group.." << k + 1 << "file number #.." << l1cfile->selgran[findex] << "sline..." << sline + 1 << "# of binned pix.." << inpix << "outpix.." << outpix << endl;
 
                        //*********** BIG LOOP M_PIXEL *****************************************************************
                        for (unsigned int pix = 0;pix < num_pixels;pix++) {
 
                            bb = 0, rb = 0, swb = 0;
                            flag_inpix = 0;
 
                            boolbin1 = sbs2_l1c(l1cinput, num_gridlines, nbinx, lat_asort, index_xy, latpix[pix], lonpix[pix], lon_gd, &gd_row, &gd_col);
 
                            bin_ypix = gd_row + 1;
                            bin_xpix = gd_col + 1;
 
                            //                   cout<<"pix..."<<pix+1<<"latpix..."<<latpix[pix]<<"lonpix..."<<lonpix[pix]<<endl;
 
                            if (boolbin1 == 1) flag_inpix = 1;
                            //************ BINNING ***************************
                         //assign identified pixel to Lt and bin stat arrays-----         
         //BLUE---
                            if (flag_inpix == 1 && bin_xpix >= 1 && bin_ypix >= 1 && bin_xpix <= nbinx && bin_ypix <= num_gridlines) {
                                inpix++;
                                while (bb < num_blue_bands) {
                                    if (Lt_pix[bb][pix] > 0.) {
                                        binmean_Lt[bb][bin_ypix - 1][bin_xpix - 1] = binmean_Lt[bb][bin_ypix - 1][bin_xpix - 1] + Lt_pix[bb][pix];
                                        bincount[bb][bin_ypix - 1][bin_xpix - 1] += 1;
                                    }
                                    bb++;
                                }//end while blue band band 
        //RED---
                                while (rb < num_red_bands) {
                                    if (Lt_pix2[rb][pix] > 0.) {
                                        binmean_Lt2[rb][bin_ypix - 1][bin_xpix - 1] = binmean_Lt2[rb][bin_ypix - 1][bin_xpix - 1] + Lt_pix2[rb][pix];
                                        bincount2[rb][bin_ypix - 1][bin_xpix - 1] += 1;
                                    }
                                    rb++;
                                }//end red bands
 
       //SWIR----
                                while (swb < num_SWIR_bands) {
                                    if (Lt_pix3[swb][pix] > 0.) {
                                        binmean_Lt3[swb][bin_ypix - 1][bin_xpix - 1] = binmean_Lt3[swb][bin_ypix - 1][bin_xpix - 1] + Lt_pix3[swb][pix];
                                        bincount3[swb][bin_ypix - 1][bin_xpix - 1] += 1;
                                    }
                                    swb++;
                                }//end swir bands
 
                            }//end if inpix
 
    //********** pixel AREA WEIGHTING ************************
                            if (flag_inpix == 0) outpix++;
 
                            totpix++;
 
                        }//end pixels loop
 
 
 
 
                        //END OF FILE--****** reset starting sline index if last line processed and within k box
                        //go for another granule if it is not the last one---------------
                        if (sline == num_scans - 1) {
                            flag_donefile = 1;
                            cout << "end of file..." << l1cfile->selgran[findex] << endl;
                            last_sline = 0;
                            if (findex >= sfiles - 1) {
                                cout << "done with last granule of the input list........................." << endl;
                                //   findex=sfiles;
                                k = ngroups;
                                break;
                            }
 
                        }//end of file/last file? sliine=num_scans-1
                        else flag_donefile = 0;
 
                    }//end latpix nadir of line x inside grid group?
 
         //***** skip lines and files if sline is not within k group ********
              //increase k and screen files and lines again starting from the last binning
 
                    if (latpix[nadpix] > lat_gd[n_gdlines - 1][257] && k < ngroups - 1) { //else limits 
                        cout << "moving to the next k group...scanning again files/slines.." << endl;
                        cout << "file index.." << findex << "last sline index.." << sline << endl;
                        last_file = findex;
                        last_sline = sline;
                        findex = sfiles;
                        sline = num_scans - 1;
                    }//end if lat >grid lat--IF outside the box
 
                    if (sline + 1 % 100 == 0) cout << "for k group.." << k + 1 << "selected granule #.." << l1cfile->selgran[findex] << "sline..." << sline + 1 << "# of binned pix.." << inpix << "totpix.." << totpix << "outpix.." << outpix << endl;
                }//end for scanlines
 
                cout << "closing L1B file......." << ptstr << endl;
                status = nc_close(ncid_L1B);
                check_err(status, __LINE__, __FILE__);
 
                delete[](latpix);
                delete[](lonpix);
                delete[](Lt_pix);
                delete[](Lt_pix2);
                delete[](Lt_pix3);
 
 
 
 
                //**********************************************************************************************************************************
                //**********************************************************************************************************************************
                //writing each granule ---------------------------------
                //*****************************************************************************
 
                if (flag_donefile == 1 | (flag_donefile == 0 && k == ngroups - 1)) {
                    cout << "writing file #.............................................." << l1cfile->selgran[findex] << "based on group #.." << k + 1 << endl;
                    //write mean Lt as nc file---
                   //**********************************************************************
                   //**********************************************************************8
                   //create Lt file
                    pathstr = "out/";
                    senstr = "OCIS_";
                    monstr = std::to_string(selmon);
                    daystr = std::to_string(selday);
                    yearstr = std::to_string(selyear);
                    prodstr = "binLt_sbs";
                    swtstr = "_swt";
                    granstr = "";
                    granstr = "_" + std::to_string(l1cfile->selgran[findex]);
 
                    if (l1cfile->l1c_pflag >= 3) {
                        swtd = l1cfile->swtnum;
                        swtnum = std::to_string(swtd);
                        cout << "swtnum.." << swtnum << endl;
                    }
                    else swtnum = std::to_string(swtd);
                    extstr = ".nc";
                    NDIMS = 2;
                    fname_out = pathstr + senstr + monstr + daystr + yearstr + prodstr + swtstr + swtnum + granstr + extstr;
                    filename_lt = fname_out.c_str();
 
                    /*     try
                           {
                            cout<<"Opening file \"firstFile.nc\" with NcFile::replace"<<endl;
                            NcFile ncFile("firstFile.nc",NcFile::replace);
                            NcGroup groupA(ncFile.addGroup("groupA"));
                            }
 
                         catch (NcException& e)
                             {
                               cout << "unknown error"<<endl;
                                e.what();
                                 }
                         exit(1);
                        */
 
                    if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
                        check_err(status, __LINE__, __FILE__);
                    //define dims
                    // Define the dimensions. NetCDF will hand back an ID for each. 
                    NY = num_gridlines;
                    NX = nbinx;
                    NY1 = l1cfile->NY1;//these are indexes not line #!!!!!!!!!!!!!!!!!
                    NY2 = l1cfile->NY2;
                    cout << "rowgrid ini.." << NY1 << "rowgrid end.." << NY2 << endl;
                    NY = NY2 - NY1 + 1;
                    cout << "NY.." << NY << "NX.." << NX << endl;
                    //alloc mem for data_out and assign values from lat_gdI
                    //NX AND NY are inverted for visualization in SeaDAS
 
     //               data_out=allocate2d_float(NY,NX);
 
               /*     data_out2 = allocate2d_float(NY,NX);
                    data_out3 = allocate2d_float(NY,NX);
                    data_out4 = allocate2d_float(NY,NX);
                    data_out5 = allocate2d_float(NY,NX);
                    data_out6 = allocate2d_float(NY,NX);
               */
                    lat_out = allocate2d_float(NY, NX);
                    lon_out = allocate2d_float(NY, NX);
 
                    int c = 0;
 
                    for (int i = NY1; i < NY2 + 1; i++) {
                        for (int j = 0; j < NX; j++) {
                            lat_out[NY - 1 - c][NX - 1 - j] = lat_gd[i][j];
                            lon_out[NY - 1 - c][j] = lon_gd[i][j];
                        }
                        c++;
                    }
 
                    //blue
                        /*           c=0;
                                   for(bb=0;bb<num_blue_bands;bb++){
                                     for(int i=NY1; i<NY2+1; i++){
                                       for(int j=0; j<NX; j++){
                                         if (bincount[bb][i][j]>0)
                                           data_out[NY-1-c][NX-1-j]=binmean_Lt[bb][i][j]/bincount[bb][i][j];
                                         else         data_out[NY-1-c][NX-1-j]=NAN;
                                           }
                                        c++;
                                      }
                                     }//end bands
                    */
 
 
                    //red      
                          /*         if (bincount2[i][j]>0)
                                        data_out3[NY-1-c][NX-1-j]=binmean_Lt2[i][j]/bincount2[i][j];
                                   else
                                        data_out3[NY-1-c][NX-1-j]=NAN;
                    //swir
                                   if (bincount3[i][j]>0)
                                        data_out5[NY-1-c][NX-1-j]=binmean_Lt3[i][j]/bincount3[i][j];
                                   else
                                        data_out5[NY-1-c][NX-1-j]=NAN;
 
                                           data_out2[NY-1-c][NX-1-j]=bincount[i][j];
                                           data_out4[NY-1-c][NX-1-j]=bincount2[i][j];
                                           data_out6[NY-1-c][NX-1-j]=bincount3[i][j];
                             */
 
                             //              }
                             //       c++;
                           //            }
                            //        }//end bands
 
                    if ((status = nc_def_dim(ncid_out, "x", NX, &x_dimid)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_dim(ncid_out, "y", NY, &y_dimid)))
                        check_err(status, __LINE__, __FILE__);
                    //dims for output var
                    dimids[0] = y_dimid;
                    dimids[1] = x_dimid;
 
                    //define groups-----
                             //    status = nc_def_grp( *ncid, line.c_str(), &gid[ngrps]);
                    if ((status = nc_def_grp(ncid_out, "data", &grp_root)))  //netcdf-4
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_grp(grp_root, "geo_coordinates", &grp_coor)))  //netcdf-4
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_grp(grp_root, "blue_bands", &grp_blue)))  //netcdf-4
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_grp(grp_root, "red_bands", &grp_red)))  //netcdf-4
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_grp(grp_root, "swir_bands", &grp_swir)))  //netcdf-4
                        check_err(status, __LINE__, __FILE__);
 
                    //def var--------------------
 
                             //loop blue channels-----
 
                    string bb_num, rb_num, swb_num, bb_str = "binLt_blue_ch", rb_str = "binLt_red_ch", swb_str = "binLt_swir_ch";
 
                    int varid_bb[num_blue_bands], varid_rb[num_red_bands], varid_swb[num_SWIR_bands];
 
                    for (bb = 0;bb < num_blue_bands;bb++) {
                        bb_num = std::to_string(bb + 1);
                        bb_num = bb_str + bb_num;
                        if ((status = nc_def_var(grp_blue, bb_num.c_str(), NC_FLOAT, NDIMS, dimids, &varid))) check_err(status, __LINE__, __FILE__);
                        varid_bb[bb] = varid;
                    }
 
                    for (rb = 0;rb < num_red_bands;rb++) {
                        rb_num = std::to_string(rb + 1);
                        rb_num = rb_str + rb_num;
                        if ((status = nc_def_var(grp_red, rb_num.c_str(), NC_FLOAT, NDIMS, dimids, &varid))) check_err(status, __LINE__, __FILE__);
                        varid_rb[rb] = varid;
                    }
 
                    for (swb = 0;swb < num_SWIR_bands;swb++) {
                        swb_num = std::to_string(swb + 1);
                        swb_num = swb_str + swb_num;
                        if ((status = nc_def_var(grp_swir, swb_num.c_str(), NC_FLOAT, NDIMS, dimids, &varid))) check_err(status, __LINE__, __FILE__);
                        varid_swb[swb] = varid;
                    }
 
                    //       if ((status = nc_def_var(grp_blue,"whatever", NC_FLOAT, NDIMS,
                    //           dimids, &varid)))
 
 
 
            //               if ((status = nc_def_var(ncid_out, "bincount_blue", NC_FLOAT, NDIMS,
            //                  dimids, &varid4)))
            //                  check_err(status, __LINE__, __FILE__);
                    //red 
            /*               if ((status = nc_def_var(ncid_out, "binLt_red", NC_FLOAT, NDIMS,
                              dimids, &varid5)))
                              check_err(status, __LINE__, __FILE__);
                           if ((status = nc_def_var(ncid_out, "bincount_red", NC_FLOAT, NDIMS,
                              dimids, &varid6)))
                              check_err(status, __LINE__, __FILE__);
                    //swir
                           if ((status = nc_def_var(ncid_out, "binLt_swir", NC_FLOAT, NDIMS,
                               dimids, &varid7)))
                              check_err(status, __LINE__, __FILE__);
                           if ((status = nc_def_var(ncid_out, "bincount_swir", NC_FLOAT, NDIMS,
                               dimids, &varid8)))
                               check_err(status, __LINE__, __FILE__);
            */
 
            //lat/lon
                    if ((status = nc_def_var(grp_coor, "lat_gd", NC_FLOAT, NDIMS,
                        dimids, &varid2)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_var(grp_coor, "lon_gd", NC_FLOAT, NDIMS,
                        dimids, &varid3)))
                        check_err(status, __LINE__, __FILE__);
                    //leave define mode-----------------------
                    if ((status = nc_enddef(ncid_out))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
 
                    //assign variable data------------------------
                             /*        start2[0]=0;
                                     start2[1]=0;
                                     start2[2]=0;
 
                                     count2[0]=1;
                                     count2[1]=NY;
                                     count2[2]=NX;
 
 
                                     float lat_data[NY][NX];
 
                                     for (int i=0;i<NY;i++){
                                       for (int j=0;j<NX;j++){
                                      lat_data[i][j]=lat_out[i][j];
                                   }}
 
                    */
                    //                 if((status = nc_put_vara_float(ncid_out,varid2,start2,count2,&lat_out[0][0])))
                    //                 check_err(status, __LINE__, __FILE__);
                    //                 if((status = nc_put_vara(grp_coor,varid3,start,count,lon_out)));
                    //                 check_err(status, __LINE__, __FILE__);
                    //                 if((status = nc_put_vara(grp_blue,varid,start,count,data_out)));
                    //                 check_err(status, __LINE__, __FILE__);
 
                    if ((status = nc_put_var_float(grp_coor, varid2, &lat_out[0][0])))
                        check_err(status, __LINE__, __FILE__);
 
                    if ((status = nc_put_var_float(grp_coor, varid3, &lon_out[0][0])))
                        check_err(status, __LINE__, __FILE__);
                    //blue
 
                    for (bb = 0;bb < num_blue_bands;bb++) {
                        data_out = allocate2d_float(NY, NX);
                        c = 0;
                        for (int i = NY1; i < NY2 + 1; i++) {
                            for (int j = 0; j < NX; j++) {
                                data_out[NY - 1 - c][NX - 1 - j] = 0.;
                            }
                            c++;
                        }
                        c = 0;
                        for (int i = NY1; i < NY2 + 1; i++) {
                            for (int j = 0; j < NX; j++) {
                                if (bincount[bb][i][j] > 0)
                                    data_out[NY - 1 - c][NX - 1 - j] = binmean_Lt[bb][i][j] / bincount[bb][i][j];
                                else         data_out[NY - 1 - c][NX - 1 - j] = NAN;
                            }
                            c++;
                        }
                        cout << "writing blue band#.." << bb + 1 << endl;
                        if ((status = nc_put_var_float(grp_blue, varid_bb[bb], &data_out[0][0])))
                            check_err(status, __LINE__, __FILE__);
 
 
                        delete[](data_out);
                    }//end blue bands
 
 
           //red
                    for (rb = 0;rb < num_red_bands;rb++) {
                        data_out2 = allocate2d_float(NY, NX);
                        c = 0;
                        for (int i = NY1; i < NY2 + 1; i++) {
                            for (int j = 0; j < NX; j++) {
                                data_out2[NY - 1 - c][NX - 1 - j] = 0.;
                            }
                            c++;
                        }
                        c = 0;
                        for (int i = NY1; i < NY2 + 1; i++) {
                            for (int j = 0; j < NX; j++) {
                                if (bincount2[rb][i][j] > 0)
                                    data_out2[NY - 1 - c][NX - 1 - j] = binmean_Lt2[rb][i][j] / bincount2[rb][i][j];
                                else         data_out2[NY - 1 - c][NX - 1 - j] = NAN;
                            }
                            c++;
                        }
                        cout << "writing red band#.." << rb + 1 << endl;
                        if ((status = nc_put_var_float(grp_red, varid_rb[rb], &data_out2[0][0])))
                            check_err(status, __LINE__, __FILE__);
 
                        delete[](data_out2);
                    }//end red bands
 
 
           //swir
                    for (swb = 0;swb < num_SWIR_bands;swb++) {
                        data_out3 = allocate2d_float(NY, NX);
                        c = 0;
                        for (int i = NY1; i < NY2 + 1; i++) {
                            for (int j = 0; j < NX; j++) {
                                data_out3[NY - 1 - c][NX - 1 - j] = 0.;
                            }
                            c++;
                        }
                        c = 0;
                        for (int i = NY1; i < NY2 + 1; i++) {
                            for (int j = 0; j < NX; j++) {
                                if (bincount3[swb][i][j] > 0)
                                    data_out3[NY - 1 - c][NX - 1 - j] = binmean_Lt3[swb][i][j] / bincount3[swb][i][j];
                                else         data_out3[NY - 1 - c][NX - 1 - j] = NAN;
                            }
                            c++;
                        }
                        cout << "writing SWIR band#.." << swb + 1 << endl;
                        if ((status = nc_put_var_float(grp_swir, varid_swb[swb], &data_out3[0][0])))
                            check_err(status, __LINE__, __FILE__);
 
                        delete[](data_out3);
                    }//end red bands
 
 
   /*               if ((status = nc_put_var_float(ncid_out, varid4, &data_out2[0][0])))
                      check_err(status, __LINE__, __FILE__);
               //red
                  if ((status = nc_put_var_float(ncid_out, varid5, &data_out3[0][0])))
                      check_err(status, __LINE__, __FILE__);
                  if ((status = nc_put_var_float(ncid_out, varid6, &data_out4[0][0])))
                      check_err(status, __LINE__, __FILE__);
               //swir
                  if ((status = nc_put_var_float(ncid_out, varid7, &data_out5[0][0])))
                      check_err(status, __LINE__, __FILE__);
                  if ((status = nc_put_var_float(ncid_out, varid8, &data_out6[0][0])))
                      check_err(status, __LINE__, __FILE__);
   */
 
                    if ((status = nc_close(ncid_out)))
                        check_err(status, __LINE__, __FILE__);
 
                    delete[](lat_out);
                    delete[](lon_out);
                    //               delete [] (data_out);
 
 
                             /*      delete [] (data_out2);
                                   delete [] (data_out3);
                                   delete [] (data_out4);
                                   delete [] (data_out5);
                                   delete [] (data_out6);
                             */
                    delete[](bincount);
                    delete[](binmean_Lt);
                    delete[](bincount2);
                    delete[](binmean_Lt2);
                    delete[](bincount3);
                    delete[](binmean_Lt3);
 
 
                    lat_out = nullptr;;
                    lon_out = nullptr;
                    data_out = nullptr;
                    data_out2 = nullptr;
                    data_out3 = nullptr;
                 
                
               
 
                    bincount = nullptr;
                    binmean_Lt = nullptr;
                    bincount2 = nullptr;
                    binmean_Lt2 = nullptr;
                    bincount3 = nullptr;
                    binmean_Lt3 = nullptr;
 
                    flag_donefile = 0;
                }//end writing file
            }//end for files
 
            cout << "group k at the end of big loop" << k + 1 << endl;
 
        }//groups
 
        cout << "number of files per swath.." << nfiles_swt[swtd - 1] << "for swath.." << swtd << endl;
        cout << "total inpix.." << inpix << "total pix.." << totpix << endl;
        //  cout<<"binned pixels.."<<inpix<<"as %.."<<(inpix/(num_pixels*num_scans*n_files*nfiles_swt[swtd-1]))*100<<endl;
        delete[](lat_asort);
        //   delete [] (lon_asort);
        delete[](index_xy);
        //   delete [] (index_xy2);
        delete[](dlatb_g);
        delete[](dlonb_g);
 
        delete[](lat_gd);
        delete[](lon_gd);
        delete[](az_east);
 
        printf("*** SUCCESS writing bincount and binLt rasters as nc..!\n");
        cout << "finish processing swath eq crossing day..." << swtd << endl;
        cout << "done writing Lt to nc file.." << endl;
 
        return(0);
    }
 
 
 
    //similar to v1 but saving 1 file at the time----
    int32_t L1C::binL1C_wgranule2(int swtd, l1c_filehandle* l1cfile, L1C_input* l1cinput, int16_t* swtd_id, int16_t* odir, int16_t* file_id, int16_t* nfiles_swt) {
        int32_t gdlines_group,ngroups = 0, num_gridlines, nbinx, inpix = 0, outpix = 0, totpix = 0, n_gdlines;//number of gridlines to be processed
        float minv = 0., maxv = 0.,** dlatb_g, ** dlonb_g;
        int16_t fi = 0;
        std::string str;
        const char* ptstr;
        int dimid, status, ncid_out, x_dimid, y_dimid, varid, varid2, varid3, varid4, varid5, varid6, varid7, varid8, NDIMS;
        size_t start[] = { 0, 0 };
        size_t count[] = { 1, 1 };
        size_t start2[] = { 0, 0, 0 };
        size_t count2[] = { 1, 1, 1 }, count3[] = { 1, 1, 1 }, count4[] = { 1, 1, 1 };
 
        int32_t bin_xpix, bin_ypix;
        float* latpix, * lonpix, ** Lt_pix, ** Lt_pix2, ** Lt_pix3;
 
        float latmin_swt = 100, latmax_swt = 0, lonmin_swt = 0, lonmax_swt = 0;
        int  dimids[2];
        const char* filename_lt;
        int32_t NY = -1, NX = -1, NY1 = -1, NY2 = -1, c1 = 1;
        float** data_out, ** data_out2, ** data_out3, ** data_out4, ** data_out5, ** data_out6, ** lat_out, ** lon_out;
 
 
        int last_file, last_sline, flag_inpix,flag_donefile;;//first index file id, second index line #
 
        short** index_xy;
        float** lat_asort;
        bool boolbin1;
 
        int16_t selyear = -1, selmon = -1, selday = -1;
        float** lat_gd, ** lon_gd, * az_east;
        string gridname, azeast_name;
        float** bincount = NULL, ** bincount2 = NULL, ** bincount3 = NULL, ** binmean_Lt = NULL, ** binmean_Lt2 = NULL, ** binmean_Lt3 = NULL;
        double gres = (l1cinput->gres) * 1000, dlamin, dlamax, dlomin, dlomax;
 
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
    
     //random seed
        srand((unsigned int)time(NULL));
        //nadir pixel ofr OCI
        int nadpix = l1cfile->nadpix;
        num_gridlines = 4000;
        nbinx = l1cfile->nbinx;
        num_pixels = l1cfile->npix;
 
        cout<<"computing binning of Lt using sbs2 and some wavelengths......................................................for swtd#.."<<swtd<<endl; 
        size_t sfiles = 0;
 
        if (l1cfile->selgran[0] < 0)//process all granules
        {
            sfiles = nfiles_swt[swtd - 1];
            for (unsigned int j = 0;j < sfiles;j++) l1cfile->selgran[j] = j + 1;
        }
        else {
            while (l1cfile->selgran[sfiles] > 0) {
                cout << "selected granule #..........................." << l1cfile->selgran[sfiles] << endl;
                sfiles++;
            }
        }
 
 
        
        //allocate mem for lat/lon/azeast pointers---
        selday = l1cinput->selday;
        selmon = l1cinput->selmon;
        selyear = l1cinput->selyear;
 
        std::string fname_out, pathstr, senstr, monstr, daystr, yearstr, prodstr, gdstr, swtstr, swtnum, extstr, granstr;
 
        pathstr = "out/";
        senstr = "OCIS_";
        monstr = std::to_string(selmon);
        daystr = std::to_string(selday);
        yearstr = std::to_string(selyear);
        prodstr = "L1Cgrid";
        swtstr = "_swt";
        extstr = ".csv";
 
        if (l1cfile->l1c_pflag >= 3) {
            swtd = l1cfile->swtnum;
            swtnum = std::to_string(swtd);
            cout << "swtnum.." << swtnum << endl;
        }
        else swtnum = std::to_string(swtd);
 
        gridname = pathstr + senstr + monstr + daystr + yearstr + prodstr + swtstr + swtnum + extstr;
 
        prodstr = "az_east";
        azeast_name = pathstr + senstr + monstr + daystr + yearstr + prodstr + swtstr + swtnum + extstr;
        cout << "gridname.." << gridname << "azeast-name.." << azeast_name << endl;
 
        //************ OPENING **************************************
        //*** AZ_EAST *****************
        //*** AZ_EAST *****************
        std::string line;
        stringstream ss;
        std::string temp;
        std::vector<std::string> parts;
        ifstream fin(azeast_name);
        int cline = 0;
        while (getline(fin, line))
        {
            // load line in stringstream
            ss << line;
            getline(ss, temp, ',');
            parts.push_back(temp);
            //   cout<<parts[cline]<<endl;
            ss.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            ss.clear();
            cline++;
        }
        //minus -1 cause the header
        cout << "size of azeast minus heading row..= num_gridlines." << parts.size() - 1 << "nbinx.." << nbinx << endl;
        num_gridlines = parts.size() - 1;
 
 
        //**LAT_GD *******************
        ifstream fin2(gridname);
        std::vector<std::string> tokens_lon, tokens_lat;
        std::string token;
        cline = 0;
        int fcol = 0;
        while (getline(fin2, line))
        {
            // load line in stringstream
            istringstream iss(line);
            while (getline(iss, token, ','))
            {
                cline++;
                if (fcol == 0 && cline > 2) {
                    tokens_lon.push_back(token);fcol++;                
}
                else if (fcol == 1 && cline > 2)
                    tokens_lat.push_back(token);
 
            }
            fcol = 0;
        }
 
 
     
 
        cout << "size of gridline minus heading row..= num_gridlines." << (tokens_lon.size() - 1) / nbinx << "nbinx.." << nbinx << endl;
 
 
        //************************************************************
        //mem allocation for geolcoation pointers---
        az_east = (float*)malloc(num_gridlines * sizeof(float));
        lat_gd = allocate2d_float(num_gridlines, nbinx);
        lon_gd = allocate2d_float(num_gridlines, nbinx);
 
        float sum = 0, tot = 0;
        for (int j = 0;j < num_gridlines;j++) {
            //     cout<<"j.."<<j<<"az_east"<<std::stof(parts[j+1])<<endl;
            az_east[j] = std::stof(parts[j + 1]);//first line is the header
            sum = az_east[j];
            tot += sum;
        }
        parts.clear();
 
 
 
        //using swath-averaged az_east for nadir pixels rather than along-track az_east pixel-by-pixel
        float mean_az_east = tot / (num_gridlines - 1);
        cout << "mean_az_east..." << mean_az_east << "numgridlines.." << num_gridlines << endl;
        //   exit(1); 
        for (int j = 0;j < num_gridlines;j++) {
            az_east[j] = mean_az_east;
        }
 
 
        int ip = 0;
        for (int j = 0;j < num_gridlines;j++) {
            for (int k = 0;k < nbinx;k++) {
                lat_gd[j][k] = std::stof(tokens_lat[ip]);
                lon_gd[j][k] = std::stof(tokens_lon[ip]);
                //   if(ip % nbinx == 0) cout<<"ip.."<<ip<<"gdline.."<<j+1<<"binx.."<<k+1<<"latgd.."<<std::stof(tokens_lat[ip])<<"longd.."<<std::stof(tokens_lon[ip])<<endl;
                ip++;
            }        
}
        tokens_lon.clear();
        tokens_lat.clear();
 
        //determine # of gd groups to be processede  
        //gdlines_group=num_gridlines;//ONE BIG GROUP
        gdlines_group = 250;
 
        if (num_gridlines <= gdlines_group) {
            gdlines_group = num_gridlines;
            cout << "WARNING********************* number_gridlines<=gdlines_group THEN gdlines_group=num_gridlines **************" << endl;
        }
 
        ngroups = floor(num_gridlines / gdlines_group);
        cout << "TOTAL # of gd groups.(ALL LATs...." << ngroups << endl;
 
        //--NORMALIZED  gridline longitude is -180 to 180 degrees before comparison with longitude extracted from image pixels---
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lon_gd[i][j] < -180.)lon_gd[i][j] += 360.;
                if (lon_gd[i][j] > 180.)lon_gd[i][j] -= 360.;
            }        
}
        //get min/max lat/lon of the swath
        // Assume first element as maximum and minimum
        maxv = lat_gd[0][0];
        minv = lat_gd[0][0];
 
        //Find maximum and minimum in all array elements.
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lat_gd[i][j] > maxv)
                    maxv = lat_gd[i][j];
                if (lat_gd[i][j] < minv)
                    minv = lat_gd[i][j];
            }        
}
    
   
        maxv = lon_gd[0][0];
        minv = lon_gd[0][0];
        //Find maximum and minimum in all array elements.
        for (int i = 0; i < num_gridlines; i++) {
            for (int j = 0; j < nbinx; j++) {
                if (lon_gd[i][j] > maxv)
                    maxv = lon_gd[i][j];
                if (lon_gd[i][j] < minv)
                    minv = lon_gd[i][j];
            }
        }
  
 
 
        cout << "swath #.." << swtd << endl;
 
        //check lat bound min/max of each gd group---
        int k = 0, i = 0;
 
        dlatb_g = allocate2d_float(ngroups + 1, 2);
        dlonb_g = allocate2d_float(ngroups + 1, 2);
 
        //recompute number of gridlines based on lat limits -80 to 80 degrees  
       //asc orbit goes from negative to positive latitude....
        NY = num_gridlines;
        NX = nbinx;
        for (int i = 0; i < NY; i++) {
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= -80.) c1++;
                if (c1 == nbinx) {
                    NY1 = i;
                }
            }
            if (NY1 >= 0) break;
            c1 = 1;
        }
 
 
        for (int i = 0;i < NY; i++) {
            //   cout<<"i.."<<i<<"lat_gd[i][j]..."<<lat_gd[i][nadpix]<<endl;
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= 80.) {
                    NY2 = i - 1;
                }
            }
 
            if (NY2 >= 0) break;
        }
 
        // cout<<"gridlines limited to -80 to 80 degrees of latitutde.."<<"gdline ini.."<<NY1<<"gdline end.."<<NY2<<endl;
 
        l1cfile->NY1 = NY1;
        l1cfile->NY2 = NY2;
 
        cout << "NY.." << NY << "NY1.." << NY1 << "NY2.." << NY2 << endl;
 
 
 
        num_gridlines = NY2 - NY1 + 1;//this is the # gridlines after -80 to 80 lat constraint---
        ngroups = floor(num_gridlines / gdlines_group);
        cout << "gdlines will start in gline.." << i + 1 << "ROUNDED ngroups after adjusting beginning.for constraint lat (-80 to 80)" << ngroups << endl;
 
        //for each 'grid' group scan the swath files to see if there are scanlines within--
        //if that is case check the across-bin number position (0 to binx-1) based on latnad and lonnad values--- 
        last_file = 0;
        last_sline = 0;
        flag_donefile = 0;
 
        num_blue_bands = 120;
        num_red_bands = 120;
        num_SWIR_bands = 9;
 
        if (num_gridlines > ngroups * gdlines_group) ngroups += 1;
 
 
        //*********** SORTING LAT/LON ASCENDING AND TRACK INDEXES ****************************
        //***********************************************************************************
 
        //Create index matrix for i and j of each lat and lon L1C grid (-80 to 80)
        //num_gridlines x nbinx
        index_xy = allocate2d_short(num_gridlines, nbinx);
        lat_asort = allocate2d_float(num_gridlines, nbinx);
        //  lon_asort=allocate2d_float(num_gridlines,nbinx);
             //fill indexe
 
        //define 1-D vector to sort 1 col L1C grid at the time---
        vector<pair<float, int> > vp;
 
        //fill vector with lat_gd column--
        cout << "*********** SORTING LAT/LON GRIDPOINTS AND TRACKING INDEXES ********************" << endl;
 
        for (int col = 0;col < nbinx;col++) {
            for (int row = NY1;row < NY2 + 1;row++) {
                vp.push_back(make_pair(lat_gd[row][col] + 90., row));
            }
            //sort 
            stable_sort(vp.begin(), vp.end());
            //display lat in order along with its gridpoint index--
              //   cout << "Lat value\t"
              //         << "index" << endl; 
            for (unsigned int i = 0; i < vp.size(); i++) {
                //    cout << vp[i].first << "\t"
                //            << vp[i].second << endl;
                lat_asort[i][col] = vp[i].first;
                index_xy[i][col] = vp[i].second;
            }
            vp.clear();
        }
 
        //saddleback search
        short gd_row, gd_col;
 
        cout << "num_gridlines...." << num_gridlines << "ngroups.." << ngroups << endl;
 
 
        //****************************************************************************************************
           //************* BIG LOOP GROUPS ***************************************
        cout << "Number of granules to be L1C processed........................................." << sfiles << endl;
 
        for (k = 0;k < ngroups;k++) {
 
            //total gridlines for k groups-----
            n_gdlines = (k + 1) * gdlines_group;
            cout << "screening k group.." << k + 1 << "last_file.." << last_file << "last_line.." << last_sline << endl;
            cout << "number of gridlines so far..." << n_gdlines << endl;
            //***** compute deltas for lat_gd index 256 and 257 *******************
 
             //compute delta_lat and delta_lon based on binres/2 for lower and upper corners of 'nadir' gridpoints of 256 and 257 indexes -----------------
               //we need nadir 256 and 257 lat/lon coordinates to compute -delta and +delta, respectively
               //we need azimuth and backazimuth and binres/2 to compute deltas ---
 
                //index 256
            geod.Direct(lat_gd[n_gdlines - gdlines_group][256], lon_gd[n_gdlines - gdlines_group][256], az_east[n_gdlines - gdlines_group], gres, dlamin, dlomin);
            geod.Direct(lat_gd[n_gdlines - 1][257], lon_gd[n_gdlines - 1][257], az_east[n_gdlines - 1], gres, dlamax, dlomax);
 
            cout << "dlamin.." << dlamin << "dlomin.." << dlomin << "dlamax.." << dlamax << "dlomax.." << dlomax << endl;
 
            dlatb_g[k][0] = dlamin;//in DEGREES!!
            dlatb_g[k][1] = dlamax;
            dlonb_g[k][0] = dlomin;
            dlonb_g[k][1] = dlomax;
 
            //********* LOOP FILES ************************************
            for (unsigned int findex = last_file;findex < sfiles;findex++) {
 
                cout << "Scanning lines in file.. for crossing swath..." << swtd << "selected granule #.." << l1cfile->selgran[findex] << "swt_id.." << swtd_id[findex] << "grid group.." << k + 1 << endl;
 
                if (last_sline == 0) { // binmean_Lt==NULL | bincount==NULL | binmean_Lt2==NULL | bincount2==NULL | binmean_Lt3==NULL | bincount3==NULL){
 
                    cout << "first allocation of memory for grid bins of file #..." << l1cfile->selgran[findex] << endl;
 
                    binmean_Lt = allocate2d_float(num_gridlines, nbinx);
                    bincount = allocate2d_float(num_gridlines, nbinx);
                    binmean_Lt2 = allocate2d_float(num_gridlines, nbinx);
                    bincount2 = allocate2d_float(num_gridlines, nbinx);
                    binmean_Lt3 = allocate2d_float(num_gridlines, nbinx);
                    bincount3 = allocate2d_float(num_gridlines, nbinx);
 
                    for (int i = 0; i < num_gridlines; i++) {
                        for (int j = 0; j < nbinx; j++) {
                            bincount[i][j] = 0.;
                            binmean_Lt[i][j] = 0.;
                            bincount2[i][j] = 0.;
                            binmean_Lt2[i][j] = 0.;
                            bincount3[i][j] = 0.;
                            binmean_Lt3[i][j] = 0.;
                        }                    
}
                }//end allocating bin arrays
 
 
                fi = l1cfile->selgran[findex];
                str = l1cfile->ifiles[fi - 1];
                ptstr = str.c_str();
                cout << "opening filename............" << ptstr << endl;
                status = nc_open(ptstr, NC_NOWRITE, &ncid_L1B);
                if (status != NC_NOERR) {
                     fprintf(stderr, "nc_open.\n");
                    exit(EXIT_FAILURE);
}
                //Open dimensions
                status = nc_inq_dimid(ncid_L1B, "number_of_scans", &dimid);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading number_of_scans.\n");
                    exit(EXIT_FAILURE);
                }
                nc_inq_dimlen(ncid_L1B, dimid, &num_scans);
 
                //read line-by-line lat/lon/Lt
                status = nc_inq_grp_ncid(ncid_L1B, "geolocation_data", &geoGrp);
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_grp_ncid(ncid_L1B, "observation_data", &obsGrp);
                check_err(status, __LINE__, __FILE__);
                //open geo data 
                status = nc_inq_varid(geoGrp, "latitude", &latId);//scans x velements
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(geoGrp, "longitude", &lonId);//scans x velements
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(obsGrp, "Lt_blue", &Lt_blueId);
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(obsGrp, "Lt_red", &Lt_redId);
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(obsGrp, "Lt_SWIR", &Lt_SWIRId);
                check_err(status, __LINE__, __FILE__);
 
 
                // num_blue_bands
                status = nc_inq_dimid(ncid_L1B, "blue_bands", &dimid);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading num_blue_bands.\n");
                    exit(EXIT_FAILURE);
                }
                nc_inq_dimlen(ncid_L1B, dimid, &num_blue_bands);
 
                // num_red_bands
                status = nc_inq_dimid(ncid_L1B, "red_bands", &dimid);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading num_red_bands.\n");
                    exit(EXIT_FAILURE);
                }
                nc_inq_dimlen(ncid_L1B, dimid, &num_red_bands);
 
                // num_SWIR_bands
                status = nc_inq_dimid(ncid_L1B, "SWIR_bands", &dimid);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading num_SWIR_bands.\n");
                    exit(EXIT_FAILURE);
                }
                nc_inq_dimlen(ncid_L1B, dimid, &num_SWIR_bands);
 
                //assigning mem for Lt of different bands **********************
                latpix = (float*)malloc(num_pixels * sizeof(float));
                lonpix = (float*)malloc(num_pixels * sizeof(float));
                Lt_pix = allocate2d_float(num_blue_bands, num_pixels);//blue bands
                Lt_pix2 = allocate2d_float(num_red_bands, num_pixels);//red bands
                Lt_pix3 = allocate2d_float(num_SWIR_bands, num_pixels);//SWIR bands
 
                cout << "#blue bands.." << num_blue_bands << endl;
                cout << "#red bands.." << num_red_bands << endl;
                cout << "#swir bands.." << num_SWIR_bands << endl;
 
                //********************************************************************************
                 //-----reading line by line-----------------------------------           
                for (unsigned int sline = last_sline;sline < num_scans;sline++) {
                    //lat and lon--
                    start[0] = sline;
                    start[1] = 0;
                    count[0] = 1;
                    count[1] = num_pixels;               // 1 line at a time
 
                    status = nc_get_vara_float(geoGrp, latId, start, count, latpix);
                    status = nc_get_vara_float(geoGrp, lonId, start, count, lonpix);
 
                    //Lt
                    start2[0] = 0;
                    start2[1] = sline;
                    start2[2] = 0;
 
                    count2[0] = num_blue_bands;
                    count2[1] = 1;               // 1 line at a time
                    count2[2] = num_pixels;
 
                    count3[0] = num_red_bands;
                    count3[1] = 1;               // 1 line at a time
                    count3[2] = num_pixels;
 
                    count4[0] = num_SWIR_bands;
                    count4[1] = 1;               // 1 line at a time
                    count4[2] = num_pixels;
 
                    status = nc_get_vara_float(obsGrp, Lt_blueId, start2, count2, Lt_pix[0]);
                    status = nc_get_vara_float(obsGrp, Lt_redId, start2, count3, Lt_pix2[0]);
                    status = nc_get_vara_float(obsGrp, Lt_SWIRId, start2, count4, Lt_pix3[0]);
 
                    for (unsigned int pix = 0;pix < num_pixels;pix++) {
                        if (latpix[pix] < latmin_swt) latmin_swt = latpix[pix];
                        if (latpix[pix] > latmax_swt) latmax_swt = latpix[pix];
                        if (lonpix[pix] < lonmin_swt) lonmin_swt = lonpix[pix];
                        if (lonpix[pix] > lonmax_swt) lonmax_swt = lonpix[pix];
                    }
                
                    dlamin = 0.;dlamax = 0.;
                    //inside the 'k' box??----- ascending ----------
                    if (latpix[nadpix] >= dlatb_g[k][0] && latpix[nadpix] <= dlatb_g[k][1]) {
 
                        if (sline % 100 == 0) cout << "EVERY 100 gds..for k group.." << k + 1 << "file number #.." << l1cfile->selgran[findex] << "sline..." << sline + 1 << "# of binned pix.." << inpix << "outpix.." << outpix << endl;
 
                        //*********** BIG LOOP M_PIXEL *****************************************************************
                        for (unsigned int pix = 0;pix < num_pixels;pix++) {
 
                            flag_inpix = 0,  bin_xpix = -1, bin_ypix = -1;
 
                            boolbin1 = sbs2_l1c(l1cinput, num_gridlines, nbinx, lat_asort, index_xy, latpix[pix], lonpix[pix], lon_gd, &gd_row, &gd_col);
                            bin_ypix = gd_row + 1;
                            bin_xpix = gd_col + 1;
 
                            //  cout<<"ok after sbs2_l1c"<<"boolbin1.."<<boolbin1<<"pix.."<<pix+1<<endl;
 
                            if (boolbin1 == 1) flag_inpix = 1;
                            //************ BINNING ***************************
                         //assign identified pixel to Lt and bin stat arrays-----         
                            if (flag_inpix == 1 && bin_xpix >= 1 && bin_ypix >= 1 && bin_xpix <= nbinx && bin_ypix <= num_gridlines) {
                                inpix++;
                                if (Lt_pix[0][pix] > 0.) {
                                    binmean_Lt[bin_ypix - 1][bin_xpix - 1] = binmean_Lt[bin_ypix - 1][bin_xpix - 1] + Lt_pix[0][pix];
                                    bincount[bin_ypix - 1][bin_xpix - 1] += 1;                                
                                          }        
 
                                if (Lt_pix2[0][pix] > 0.) {
                                    binmean_Lt2[bin_ypix - 1][bin_xpix - 1] = binmean_Lt2[bin_ypix - 1][bin_xpix - 1] + Lt_pix2[0][pix];
                                    bincount2[bin_ypix - 1][bin_xpix - 1] += 1;                                
                                    }                                      
 
                                if (Lt_pix3[0][pix] > 0.) {
                                    binmean_Lt3[bin_ypix - 1][bin_xpix - 1] = binmean_Lt3[bin_ypix - 1][bin_xpix - 1] + Lt_pix3[0][pix];
                                    bincount3[bin_ypix - 1][bin_xpix - 1] += 1;                                
                                 }
                            }
 
                            //********** pixel AREA WEIGHTING ************************
                            if (flag_inpix == 0) outpix++;
 
                            totpix++;
 
                        }//end pixels loop
 
                        //END OF FILE--****** reset starting sline index if last line processed and within k box
                        //go for another granule if it is not the last one---------------
                        if (sline == num_scans - 1) {
                            flag_donefile = 1;
                            cout << "end of file..." << l1cfile->selgran[findex] << endl;
                            last_sline = 0;
                            if (findex >= sfiles - 1) {
                                cout << "done with last granule of the input list........................." << endl;
                                //   findex=sfiles;
                                k = ngroups;
                                break;
                            }
 
                        }//end of file/last file? sliine=num_scans-1
                        else flag_donefile = 0;
 
                    }//end latpix nadir of line x inside grid group?
 
         //***** skip lines and files if sline is not within k group ********
              //increase k and screen files and lines again starting from the last binning
 
                    if (latpix[nadpix] > lat_gd[n_gdlines - 1][257] && k < ngroups - 1) { //else limits 
                        cout << "moving to the next k group...scanning again files/slines.." << endl;
                        cout << "file index.." << findex << "last sline index.." << sline << endl;
                        last_file = findex;
                        last_sline = sline;
                        findex = sfiles;
                        sline = num_scans - 1;
                    }//end if lat >grid lat--IF outside the box
 
                    if (sline + 1 % 100 == 0) cout << "for k group.." << k + 1 << "selected granule #.." << l1cfile->selgran[findex] << "sline..." << sline + 1 << "# of binned pix.." << inpix << "totpix.." << totpix << "outpix.." << outpix << endl;
                    //            cout<<"sline.."<<sline+1<<endl;
                }//end for scanlines
 
                cout << "closing L1B file......." << ptstr << endl;
                status = nc_close(ncid_L1B);
                check_err(status, __LINE__, __FILE__);
 
                delete[](latpix);
                delete[](lonpix);
                delete[](Lt_pix);
                delete[](Lt_pix2);
                delete[](Lt_pix3);
 
 
 
                //writing each granule ---------------------------------
                if (flag_donefile == 1 | (flag_donefile == 0 && k == ngroups - 1)) {
                    cout << "writing file #.............................................." << l1cfile->selgran[findex] << "based on group #.." << k + 1 << endl;
                    //write mean Lt as nc file---
                   //**********************************************************************
                   //**********************************************************************8
                   //create Lt file
                    pathstr = "out/";
                    senstr = "OCIS_";
                    monstr = std::to_string(selmon);
                    daystr = std::to_string(selday);
                    yearstr = std::to_string(selyear);
                    prodstr = "binLt_blue1";
                    swtstr = "_swt";
                    granstr = "";
                    granstr = "_" + std::to_string(l1cfile->selgran[findex]);
 
                    if (l1cfile->l1c_pflag >= 3) {
                        swtd = l1cfile->swtnum;
                        swtnum = std::to_string(swtd);
                        cout << "swtnum.." << swtnum << endl;
                    }
                    else swtnum = std::to_string(swtd);
                    extstr = ".nc";
                    NDIMS = 2;
                    fname_out = pathstr + senstr + monstr + daystr + yearstr + prodstr + swtstr + swtnum + granstr + extstr;
                    filename_lt = fname_out.c_str();
                    if ((status = nc_create(filename_lt, NC_CLOBBER, &ncid_out)))
                        check_err(status, __LINE__, __FILE__);
                    //define dims
                    // Define the dimensions. NetCDF will hand back an ID for each. 
                    NY = num_gridlines;
                    NX = nbinx;
                    NY1 = l1cfile->NY1;//these are indexes not line #!!!!!!!!!!!!!!!!!
                    NY2 = l1cfile->NY2;
                    cout << "rowgrid ini.." << NY1 << "rowgrid end.." << NY2 << endl;
                    NY = NY2 - NY1 + 1;
                    cout << "NY.." << NY << "NX.." << NX << endl;
                    //alloc mem for data_out and assign values from lat_gdI
                    //NX AND NY are inverted for visualization in SeaDAS
                    data_out = allocate2d_float(NY, NX);
                    data_out2 = allocate2d_float(NY, NX);
                    data_out3 = allocate2d_float(NY, NX);
                    data_out4 = allocate2d_float(NY, NX);
                    data_out5 = allocate2d_float(NY, NX);
                    data_out6 = allocate2d_float(NY, NX);
                    lat_out = allocate2d_float(NY, NX);
                    lon_out = allocate2d_float(NY, NX);
 
                    int c = 0;
                    for (int i = NY1; i < NY2 + 1; i++) {
                        for (int j = 0; j < NX; j++) {
                            lat_out[NY - 1 - c][NX - 1 - j] = lat_gd[i][j];
                            lon_out[NY - 1 - c][j] = lon_gd[i][j];
                            //blue
                            if (bincount[i][j] > 0)
                                data_out[NY - 1 - c][NX - 1 - j] = binmean_Lt[i][j] / bincount[i][j];
                            else
                                data_out[NY - 1 - c][NX - 1 - j] = NAN;
                            //red      
                            if (bincount2[i][j] > 0)
                                data_out3[NY - 1 - c][NX - 1 - j] = binmean_Lt2[i][j] / bincount2[i][j];
                            else
                                data_out3[NY - 1 - c][NX - 1 - j] = NAN;
                            //swir
                            if (bincount3[i][j] > 0)
                                data_out5[NY - 1 - c][NX - 1 - j] = binmean_Lt3[i][j] / bincount3[i][j];
                            else
                                data_out5[NY - 1 - c][NX - 1 - j] = NAN;
                            data_out2[NY - 1 - c][NX - 1 - j] = bincount[i][j];
                            data_out4[NY - 1 - c][NX - 1 - j] = bincount2[i][j];
                            data_out6[NY - 1 - c][NX - 1 - j] = bincount3[i][j];
                        }
                        c++;
                    }
 
                    if ((status = nc_def_dim(ncid_out, "x", NX, &x_dimid)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_dim(ncid_out, "y", NY, &y_dimid)))
                        check_err(status, __LINE__, __FILE__);
                    //dims for output var
                    dimids[0] = y_dimid;
                    dimids[1] = x_dimid;
                    //def var
                    //blue
                    if ((status = nc_def_var(ncid_out, "binLt_blue", NC_FLOAT, NDIMS,
                        dimids, &varid)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_var(ncid_out, "bincount_blue", NC_FLOAT, NDIMS,
                        dimids, &varid4)))
                        check_err(status, __LINE__, __FILE__);
                    //red 
                    if ((status = nc_def_var(ncid_out, "binLt_red", NC_FLOAT, NDIMS,
                        dimids, &varid5)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_var(ncid_out, "bincount_red", NC_FLOAT, NDIMS,
                        dimids, &varid6)))
                        check_err(status, __LINE__, __FILE__);
                    //swir
                    if ((status = nc_def_var(ncid_out, "binLt_swir", NC_FLOAT, NDIMS,
                        dimids, &varid7)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_var(ncid_out, "bincount_swir", NC_FLOAT, NDIMS,
                        dimids, &varid8)))
                        check_err(status, __LINE__, __FILE__);
                    //lat/lon
                    if ((status = nc_def_var(ncid_out, "lat_gd", NC_FLOAT, NDIMS,
                        dimids, &varid2)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_def_var(ncid_out, "lon_gd", NC_FLOAT, NDIMS,
                        dimids, &varid3)))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_enddef(ncid_out))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
                    //writing the whole thing
                    if ((status = nc_put_var_float(ncid_out, varid2, &lat_out[0][0])))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_put_var_float(ncid_out, varid3, &lon_out[0][0])))
                        check_err(status, __LINE__, __FILE__);
                    //blue
                    if ((status = nc_put_var_float(ncid_out, varid, &data_out[0][0])))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_put_var_float(ncid_out, varid4, &data_out2[0][0])))
                        check_err(status, __LINE__, __FILE__);
                    //red
                    if ((status = nc_put_var_float(ncid_out, varid5, &data_out3[0][0])))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_put_var_float(ncid_out, varid6, &data_out4[0][0])))
                        check_err(status, __LINE__, __FILE__);
                    //swir
                    if ((status = nc_put_var_float(ncid_out, varid7, &data_out5[0][0])))
                        check_err(status, __LINE__, __FILE__);
                    if ((status = nc_put_var_float(ncid_out, varid8, &data_out6[0][0])))
                        check_err(status, __LINE__, __FILE__);
 
 
                    if ((status = nc_close(ncid_out)))
                        check_err(status, __LINE__, __FILE__);
 
                    delete[](lat_out);
                    delete[](lon_out);
                    delete[](data_out);
                    delete[](data_out2);
                    delete[](data_out3);
                    delete[](data_out4);
                    delete[](data_out5);
                    delete[](data_out6);
 
                    delete[](bincount);
                    delete[](binmean_Lt);
                    delete[](bincount2);
                    delete[](binmean_Lt2);
                    delete[](bincount3);
                    delete[](binmean_Lt3);
 
                    lat_out = nullptr;;
                    lon_out = nullptr;
                    data_out = nullptr;
                    data_out2 = nullptr;
                    data_out3 = nullptr;
                    data_out4 = nullptr;
                    data_out5 = nullptr;
                    data_out6 = nullptr;
 
                    bincount = nullptr;
                    binmean_Lt = nullptr;
                    bincount2 = nullptr;
                    binmean_Lt2 = nullptr;
                    bincount3 = nullptr;
                    binmean_Lt3 = nullptr;
 
                    flag_donefile = 0;
                }//end writing file
            }//end for files
 
            cout << "group k at the end of big loop" << k + 1 << endl;
 
        }//groups
 
        cout << "number of files per swath.." << nfiles_swt[swtd - 1] << "for swath.." << swtd << endl;
        cout << "total inpix.." << inpix << "total pix.." << totpix << endl;
        //  cout<<"binned pixels.."<<inpix<<"as %.."<<(inpix/(num_pixels*num_scans*n_files*nfiles_swt[swtd-1]))*100<<endl;
        delete[](lat_asort);
        //   delete [] (lon_asort);
        delete[](index_xy);
        //   delete [] (index_xy2);
        delete[](dlatb_g);
        delete[](dlonb_g);
 
        delete[](lat_gd);
        delete[](lon_gd);
        delete[](az_east);
 
        printf("*** SUCCESS writing bincount and binLt rasters as nc..!\n");
        cout << "finish processing swath eq crossing day..." << swtd << endl;
        cout << "done writing Lt to nc file.." << endl;
 
        return(0);
    }
 
 
 
 
    int32_t L1C::pix_corners4_l1c(l1c_filehandle* l1cfile, L1C_input* l1cinput, float dist_u, float dist_v, float azpix, int32_t scanline, int32_t pix, float pixlat, float pixlon, float pixLt, float** lat_asort, short** index_xy, float** lat_gd, float** lon_gd, double** lat_cgd, double** lon_cgd, double areaFracBox[3][3], float** Ltfracsum, float** areafracsum, float** nobs_perbin) { //compute pixel corners for a specific line,pixel and file
 
        double lat_cnw, lat_cne, lat_csw, lat_cse, lon_cnw, lon_cne, lon_csw, lon_cse;
        float  azpixc;
        short gd_row, gd_col;
        int32_t num_gridlines, nbinx;
 
        double areabinBox[3][3];
        float theta, thetares, dist_corn, thetagrad;
        double res1, res2, res3, res4;//pixel resolution in meters
 
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
 
        //using namespace bg;
        Polygon_t pixelPoly;
        // Box_t pixelBox;
        // Point_t pixelPoint;
 
        num_gridlines = l1cfile->num_gridlines;
        nbinx = l1cfile->nbinx;
   
  
 
 
//        cout<<"in pix_corners4_l1c.........NY1.."<<NY1<<"NY2..."<<NY2<<"NY..."<<NY<<"numgridlines.."<<num_gridlines<<"number of binx.."<<nbinx<<endl;
 
        //******* M_PIXEL CORNERS *****************************
        //***************************************************
 
        // ad=0.5*(sqrt(dist_u*dist_u+dist_v*dist_v)/Re);
        dist_corn = 0.5 * (sqrt(dist_u * dist_u + dist_v * dist_v)) * 1000;//distane center to corner in meters
 
 
        theta = atan2(dist_v, dist_u);
        thetagrad = 2 * theta * 180 / M_PI;
        thetares = (M_PI / 2 - theta) * 180 / M_PI;
 
        //nw corner 
        azpixc = (azpix - thetares) * degrad;//pixel bearing
        if (azpixc<-M_PI | azpixc>M_PI) { cout << "error in nw corner..azpixc" << azpixc << endl;exit(1); }
        azpixc = azpixc * 180 / M_PI;
    //    cout << "azpixc nw...." << azpixc << endl;
        geod.Direct(pixlat, pixlon, azpixc, dist_corn, lat_cnw, lon_cnw);
        geod.Inverse(pixlat, pixlon, lat_cnw, lon_cnw, res1);
        // lat_cne=asin(sin(pixlat*degrad)*cos(ad)+cos(pixlat*degrad)*sin(ad)*cos(azpixc*degrad))*180./M_PI;
        // lon_cne=pixlon+atan2(sin(azpixc*degrad)*sin(ad)*cos(pixlat*degrad),cos(ad)-sin(pixlat*degrad)*sin(lat_cne*degrad))*180./M_PI;
 
 
        //ne corner (sw-180)
        azpixc = (azpix + thetares) * degrad;//pixel bearing
        if (azpixc<-M_PI | azpixc>M_PI) { cout << "error in ne corner..azpixc" << azpixc << endl;exit(1); }
        // azpixc=(azpix+45)*degrad;//pixel bearing
        /* if(azpixc>M_PI | azpixc<-M_PI){
              }
         if(azpixc<0.){
                  azpixc=360+azpixc*180/M_PI;
                     }
         else azpixc=azpixc*180/M_PI;
        */
 
        azpixc = azpixc * 180 / M_PI;
   //     cout << "azpixc ne...." << azpixc << endl;
 
    //    cout << "azpixc nw...." << azpixc << endl;
        geod.Direct(pixlat, pixlon, azpixc, dist_corn, lat_cne, lon_cne);
        geod.Inverse(pixlat, pixlon, lat_cne, lon_cne, res2);
 
 
 
        //sw corner 
        // azpixc=(azpix-45-90)*degrad;//pixel bearing
        azpixc = (azpix - thetares - thetagrad) * degrad;//pixel bearing
        if (azpixc<-M_PI | azpixc>M_PI) { cout << "error in sw corner..azpixc" << azpixc << endl;exit(1); }
        /* if(azpixc>M_PI | azpixc<-M_PI){
              //      cout<<"problem with BEARING in across-gridline method...az<-180 or >180...."<<"SW azpixc in degrees.."<<azpixc*180/M_PI<<endl;
                     }
         if(azpixc<0.){
                  azpixc=360+azpixc*180/M_PI;
                     }
         else azpixc=azpixc*180/M_PI;
         */
 
        azpixc = azpixc * 180 / M_PI;
    //    cout << "azpixc sw....." << azpixc << endl;
        geod.Direct(pixlat, pixlon, azpixc, dist_corn, lat_csw, lon_csw);
        geod.Inverse(pixlat, pixlon, lat_csw, lon_csw, res3);
        //lat_csw=asin(sin(pixlat*degrad)*cos(ad)+cos(pixlat*degrad)*sin(ad)*cos(azpixc*degrad))*180./M_PI;
        // lon_csw=pixlon+atan2(sin(azpixc*degrad)*sin(ad)*cos(pixlat*degrad),cos(ad)-sin(pixlat*degrad)*sin(lat_csw*degrad))*180./M_PI;
 
        //se corner (nw-180)
        azpixc = (azpix + thetares + thetagrad) * degrad;//pixel bearingi
        if (azpixc<-M_PI | azpixc>M_PI) { cout << "error in se corner..azpixc" << azpixc << endl;exit(1); }
        // azpixc=(azpix+45+90)*degrad;//pixel bearing
        /* if(azpixc>M_PI | azpixc<-M_PI){
              //      cout<<"problem with BEARING in across-gridline method...az<-180 or >180...."<<"SE azpixc in degrees.."<<azpixc*180/M_PI<<endl;
                     }
         if(azpixc<0.){
                  azpixc=360+azpixc*180/M_PI;
                     }
         else azpixc=azpixc*180/M_PI;
        */
        azpixc = azpixc * 180 / M_PI;
    //    cout << "azpix se...." << azpixc << endl;
        geod.Direct(pixlat, pixlon, azpixc, dist_corn, lat_cse, lon_cse);
        geod.Inverse(pixlat, pixlon, lat_cse, lon_cse, res4);
        // lat_cse=asin(sin(pixlat*degrad)*cos(ad)+cos(pixlat*degrad)*sin(ad)*cos(azpixc*degrad))*180./M_PI;
        // lon_cse=pixlon+atan2(sin(azpixc*degrad)*sin(ad)*cos(pixlat*degrad),cos(ad)-sin(pixlat*degrad)*sin(lat_cse*degrad))*180./M_PI;
/*
        cout << "pix.." << pix + 1 << "azpix.." << azpix << "theta.." << thetagrad << "thetares.." << thetares << endl;
        cout << "dist_u.." << dist_u << "dist_v.." << dist_v << endl;
        cout << "res1." << res1 << "res2." << res2 << "res3.." << res3 << "res4.." << res4 << endl;
        cout << "pix sw corner..lat." << lat_csw << "sw corner lon.." << lon_csw << endl;
        cout << "pix nw corner..lat." << lat_cnw << "nw corner lon.." << lon_cnw << endl;
        cout << "pix ne corner..lat." << lat_cne << "ne corner lon.." << lon_cne << endl;
        cout << "pix se corner..lat." << lat_cse << "se corner lon.." << lon_cse << endl;
*/
        std::string ws_lon_str, ws_lat_str, wn_lon_str, wn_lat_str, en_lon_str, en_lat_str, es_lon_str, es_lat_str, pixstr;
        ws_lon_str = std::to_string(lon_csw);
        ws_lat_str = std::to_string(lat_csw);
        wn_lon_str = std::to_string(lon_cnw);
        wn_lat_str = std::to_string(lat_cnw);
        en_lon_str = std::to_string(lon_cne);
        en_lat_str = std::to_string(lat_cne);
        es_lon_str = std::to_string(lon_cse);
        es_lat_str = std::to_string(lat_cse);
 
 
        pixstr = "POLYGON((" + ws_lon_str + " " + ws_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + en_lon_str + " " + en_lat_str + "," + es_lon_str + " " + es_lat_str + "," + ws_lon_str + " " + ws_lat_str + "))";
        bg::read_wkt(pixstr, pixelPoly);
 
        if (lon_csw > lon_cse | lon_cnw > lon_cne | lat_csw > lat_cnw | lat_cse > lat_cne) {
    //        cout << "lon_csw>lon_cse | lon_cnw>lon_cne | lat_csw>lat_cnw | lat_cse>lat_cne//" << lon_csw << lon_cse << lon_cnw << lon_cne << lat_csw << lat_cnw << lat_cse << lat_cne << endl;
    //        cout << "corners are switched for pixel due to the change of longitude from +180 to -180...." << pix + 1 << endl;
        }
 
        // exit(1);
        //*** L1C grid cell *******************************************************************************
 
        bool boolbin1 = 0;
 
        boolbin1 = sbs2_l1c(l1cinput, num_gridlines, nbinx, lat_asort, index_xy, pixlat, pixlon, lon_gd, &gd_row, &gd_col);
       
 
 
        //Ini areaBinbox
        for (int ar = 0;ar < 3;ar++) {
            for (int ac = 0;ac < 3;ac++) {
                areabinBox[ar][ac] = 0.;
                areaFracBox[ar][ac] = 0.;
                ac++;
            }
            ar++;
        }
 
        if (boolbin1 == 1 && gd_row >= 1 && gd_col >= 1 && gd_row < num_gridlines - 1 && gd_col < nbinx - 1) {
 
            binIntersectsPix4corn4_l1c(l1cfile, l1cinput, gd_row, gd_col, lat_gd, lon_gd, pixelPoly, areaFracBox, areabinBox);
 
            int ar = 0, ac = 0;
            for (int gr = gd_row - 1;gr < gd_row + 2;gr++) {
                for (int gc = gd_col - 1;gc < gd_col + 2;gc++) {
                    if (pixLt > 0.0) {
                        Ltfracsum[gr][gc] += pixLt * areaFracBox[ar][ac];
                        areafracsum[gr][gc] += areaFracBox[ar][ac];
                        nobs_perbin[gr][gc] += 1;
 
               //     cout<<"Ltfracsum[gr][gc].."<<Ltfracsum[gr][gc]<<"areafracsum[gr][gc].."<<areafracsum[gr][gc]<<"nobs_perbin[gr][gc].."<<nobs_perbin[gr][gc]<<endl;
                    }
                    else {
                        Ltfracsum[gr][gc] += 0.0;
                        areafracsum[gr][gc] += 0.0;
                        nobs_perbin[gr][gc] += 0;
                    }
 
                    ac++;
                }
                ac = 0;
                ar++;
            }
 
        }
        else {
            //  cout<<"pix out of the L1Cgrid.........................."<<"pix#..."<<pix+1<<"pixlat.."<<pixlat<<"pixlon..."<<pixlon<<endl;
        }
 
 
        return 0;
    }
 
 
 
 
 
    int32_t L1C::gwindowTopix_l1c(l1c_filehandle* l1cfile, L1C_input* l1cinput, short row, short col, float** lat_gd, float** lon_gd, double** latcornBox, double** loncornBox) {
        double  ws_lat, wn_lat, es_lat, en_lat, ws_lon, wn_lon, es_lon, en_lon;
        double ws_lat2, wn_lat2, es_lat2, en_lat2, ws_lon2, wn_lon2, es_lon2, en_lon2;
        double ws_lat3, wn_lat3, es_lat3, en_lat3, ws_lon3, wn_lon3, es_lon3, en_lon3;
        double ws_lat4, wn_lat4, es_lat4, en_lat4, ws_lon4, wn_lon4, es_lon4, en_lon4;
        double ws_lat5, wn_lat5, es_lat5, en_lat5, ws_lon5, wn_lon5, es_lon5, en_lon5;
        double ws_lat6, wn_lat6, es_lat6, en_lat6, ws_lon6, wn_lon6, es_lon6, en_lon6;
        double ws_lat7, wn_lat7, es_lat7, en_lat7, ws_lon7, wn_lon7, es_lon7, en_lon7;
        double ws_lat8, wn_lat8, es_lat8, en_lat8, ws_lon8, wn_lon8, es_lon8, en_lon8;
        double ws_lat9, wn_lat9, es_lat9, en_lat9, ws_lon9, wn_lon9, es_lon9, en_lon9;
        //   shape->rowcol2bounds(row, col, n, s, e, w);
        float binres = 0, azgc, deltaphi, deltalam, azpixc;
    
        float aterm, bterm, dist_u, dist_v, theta, thetares, thetagrad, dist_corn2, mean_az_east;
        float az1, az2, az3, az4;
 
 
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
 
 
        mean_az_east = l1cfile->mean_az_east; //in degrees
 
    //    cout<<"mean az east.for L1C grid................. in degrees..."<<mean_az_east<<endl;
        binres = (l1cinput->gres);//in km
 
    //    cout<<"gwindowTopix_l1c...........................gd_row......"<<row<<"gd_col...."<<col<<endl;
 
    //*******************************************************************************************
    //center center bin
    //********************************************************************************************************
 
        deltaphi = (lat_gd[row][col] - lat_gd[row][col + 1]) * degrad;
        deltalam = (lon_gd[row][col] - lon_gd[row][col + 1]) * degrad;
        //across-track grid size
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row][col] * degrad) * cos(lat_gd[row][col + 1] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_u = Re * bterm;         //horizontal distance Harversine in km
 
        deltaphi = (lat_gd[row][col] - lat_gd[row + 1][col]) * degrad;
        deltalam = (lon_gd[row][col] - lon_gd[row + 1][col]) * degrad;
        //along-track distance
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row][col] * degrad) * cos(lat_gd[row + 1][col] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_v = Re * bterm;
 
        //    ad=0.5*(sqrt(dist_u*dist_u+dist_v*dist_v)/Re);   
    
        dist_corn2 = 0.5 * sqrt(binres * binres + binres * binres) * 1000;
 
        azgc = (mean_az_east - 90) * degrad;//this is the bearing
 
        if (azgc > M_PI | azgc < -M_PI){cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "azpixc in degrees.." << azgc * 180 / M_PI << endl;exit(1);}
 
        theta = atan2(dist_v, dist_u);
        thetagrad = 2 * theta * 180 / M_PI;
        thetares = (M_PI / 2 - theta) * 180 / M_PI;
        azgc = azgc * 180 / M_PI;
 
        //nw corner 
        azpixc = (azgc - thetares) * degrad;//pixel bearing
        if (azpixc > M_PI | azpixc < -M_PI) {
            cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "NW azpixc in degrees.." << azpixc * 180 / M_PI << endl;
            exit(1);
        }
 
        azpixc = azpixc * 180 / M_PI;
        az1 = azpixc;
        geod.Direct(lat_gd[row][col], lon_gd[row][col], azpixc, dist_corn2, wn_lat, wn_lon);
 
        //    cout<<"azgc.Center-Center."<<azgc<<"azpixc.."<<azpixc<<"dist_corn.."<<dist_corn<<"dist_corn2.."<<dist_corn2<<endl;
        //    cout<<"res1..nw."<<res1<<endl;
 
        //ne corner 
        azpixc = (azgc + thetares) * degrad;//pixel bearing
        if (azpixc > M_PI | azpixc < -M_PI) {
            cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "NE azpixc in degrees.." << azpixc * 180 / M_PI << endl;
            exit(1);
        }
 
        azpixc = azpixc * 180 / M_PI;
        az2 = azpixc;
        geod.Direct(lat_gd[row][col], lon_gd[row][col], azpixc, dist_corn2, en_lat, en_lon);
 
        //  cout<<"azpixc.."<<azpixc<<"res2 ne.."<<res2<<endl;
      //sw corner 
        azpixc = (azgc - thetares - thetagrad) * degrad;//pixel bearing
        if (azpixc > M_PI | azpixc < -M_PI) {
            cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "SW azpixc in degrees.." << azpixc * 180 / M_PI << endl;
            exit(1);
        }
 
        azpixc = azpixc * 180 / M_PI;
        az3 = azpixc;
        geod.Direct(lat_gd[row][col], lon_gd[row][col], azpixc, dist_corn2, ws_lat, ws_lon);
 
        //   cout<<"azpixc.."<<azpixc<<"res3..sw.."<<res3<<endl;
 
       //se corner 
        azpixc = (azgc + thetares + thetagrad) * degrad;//pixel bearing
        if (azpixc > M_PI | azpixc < -M_PI) {
            cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "SE azpixc in degrees.." << azpixc * 180 / M_PI << endl;
            exit(1);
        }
 
        azpixc = azpixc * 180 / M_PI;
        az4 = azpixc;
        geod.Direct(lat_gd[row][col], lon_gd[row][col], azpixc, dist_corn2, es_lat, es_lon);
        //   geod.Inverse(lat_gd[row][col],lon_gd[row][col],es_lat,es_lon,res4);
 
        latcornBox[0][0] = ws_lat;
        latcornBox[1][0] = wn_lat;
        latcornBox[2][0] = en_lat;
        latcornBox[3][0] = es_lat;
        loncornBox[0][0] = ws_lon;
        loncornBox[1][0] = wn_lon;
        loncornBox[2][0] = en_lon;
        loncornBox[3][0] = es_lon;
 
        //***********************************************************************************************************
           //left center bin
            //********************************************************************************************************
 
 
        deltaphi = (lat_gd[row][col - 1] - lat_gd[row][col]) * degrad;
        deltalam = (lon_gd[row][col - 1] - lon_gd[row][col]) * degrad;
        //across-track grid size
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row][col - 1] * degrad) * cos(lat_gd[row][col] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_u = Re * bterm;         //horizontal distance Harversine in km
 
        deltaphi = (lat_gd[row][col - 1] - lat_gd[row + 1][col - 1]) * degrad;
        deltalam = (lon_gd[row][col - 1] - lon_gd[row + 1][col - 1]) * degrad;
        //along-track distance
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row][col - 1] * degrad) * cos(lat_gd[row + 1][col - 1] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_v = Re * bterm;
 
        theta = atan2(dist_v, dist_u);
        thetagrad = 2 * theta * 180 / M_PI;
        thetares = (M_PI / 2 - theta) * 180 / M_PI;
 
 
        //nw corner
        azpixc = az1;
        geod.Direct(lat_gd[row][col - 1], lon_gd[row][col - 1], azpixc, dist_corn2, wn_lat2, wn_lon2);
 
        //   cout<<"azgc..CENTER-LEFT"<<azgc<<"azpixc.."<<azpixc<<"dist_corn.."<<dist_corn<<"dist_corn2.."<<dist_corn2<<endl;
        //   cout<<"res1..nw."<<res1<<endl;
       //ne corner 
        azpixc = az2;
        geod.Direct(lat_gd[row][col - 1], lon_gd[row][col - 1], azpixc, dist_corn2, en_lat2, en_lon2);
 
        //   cout<<"azpixc.."<<azpixc<<"res2 ne.."<<res2<<endl;
       //sw corner 
        azpixc = az3;
        geod.Direct(lat_gd[row][col - 1], lon_gd[row][col - 1], azpixc, dist_corn2, ws_lat2, ws_lon2);
 
        //   cout<<"azpixc.."<<azpixc<<"res3..sw.."<<res3<<endl;
       //se corner 
        azpixc = az4;
        geod.Direct(lat_gd[row][col - 1], lon_gd[row][col - 1], azpixc, dist_corn2, es_lat2, es_lon2);
 
        //   cout<<"azpixc.."<<azpixc<<"res4...se.."<<res4<<endl;
 
 
        latcornBox[0][1] = ws_lat2;
        latcornBox[1][1] = wn_lat2;
        latcornBox[2][1] = wn_lat;
        latcornBox[3][1] = ws_lat;
        loncornBox[0][1] = ws_lon2;
        loncornBox[1][1] = wn_lon2;
        loncornBox[2][1] = wn_lon;
        loncornBox[3][1] = ws_lon;
 
 
        //******************************************************************************************************************************
        //right center bin 
        //*******************************************************************************************************************************
        //***************************************************************************
         //right center bin
        //**************************************************************************8
 
 
        deltaphi = (lat_gd[row][col + 1] - lat_gd[row][col + 2]) * degrad;
        deltalam = (lon_gd[row][col + 1] - lon_gd[row][col + 2]) * degrad;
        //across-track grid size
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row][col + 1] * degrad) * cos(lat_gd[row][col + 2] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_u = Re * bterm;         //horizontal distance Harversine in km
 
        deltaphi = (lat_gd[row][col + 1] - lat_gd[row + 1][col + 1]) * degrad;
        deltalam = (lon_gd[row][col + 1] - lon_gd[row + 1][col + 1]) * degrad;
        //along-track distance
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row][col + 1] * degrad) * cos(lat_gd[row + 1][col + 1] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_v = Re * bterm;
 
        theta = atan2(dist_v, dist_u);
        thetagrad = 2 * theta * 180 / M_PI;
        thetares = (M_PI / 2 - theta) * 180 / M_PI;
 
        //nw corner
        azpixc = az1;
        geod.Direct(lat_gd[row][col + 1], lon_gd[row][col + 1], azpixc, dist_corn2, wn_lat3, wn_lon3);
        //   cout<<"azgc..CENTER-RIGHT..."<<azgc<<"azpixc.."<<azpixc<<"dist_corn.."<<dist_corn<<"dist_corn2.."<<dist_corn2<<endl;
        //   cout<<"res1..nw."<<res1<<endl;
 
       //ne corner 
        azpixc = az2;
        geod.Direct(lat_gd[row][col + 1], lon_gd[row][col + 1], azpixc, dist_corn2, en_lat3, en_lon3);
        //   cout<<"azpixc.."<<azpixc<<"res2 ne.."<<res2<<endl;
       //sw corner 
        azpixc = az3;
        geod.Direct(lat_gd[row][col + 1], lon_gd[row][col + 1], azpixc, dist_corn2, ws_lat3, ws_lon3);
        //   cout<<"azpixc.."<<azpixc<<"res3..sw.."<<res3<<endl;
       //se corner 
        azpixc = az4;
        geod.Direct(lat_gd[row][col + 1], lon_gd[row][col + 1], azpixc, dist_corn2, es_lat3, es_lon3);
        //   cout<<"azpixc.."<<azpixc<<"res4...se.."<<res4<<endl;
 
        latcornBox[0][2] = es_lat;
        latcornBox[1][2] = en_lat;
        latcornBox[2][2] = en_lat3;
        latcornBox[3][2] = es_lat3;
        loncornBox[0][2] = es_lon;
        loncornBox[1][2] = en_lon;
        loncornBox[2][2] = en_lon3;
        loncornBox[3][2] = es_lon3;
 
        //******************************************************************************************************
         //upper center bin
        //*****************************************************************************************************
 
 
        deltaphi = (lat_gd[row + 1][col] - lat_gd[row + 1][col + 1]) * degrad;
        deltalam = (lon_gd[row + 1][col] - lon_gd[row + 1][col + 1]) * degrad;
        //across-track grid size
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row + 1][col] * degrad) * cos(lat_gd[row + 1][col + 1] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_u = Re * bterm;         //horizontal distance Harversine in km
 
        deltaphi = (lat_gd[row + 2][col] - lat_gd[row + 1][col]) * degrad;
        deltalam = (lon_gd[row + 2][col] - lon_gd[row + 1][col]) * degrad;
        //along-track distance
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row + 1][col] * degrad) * cos(lat_gd[row + 2][col] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_v = Re * bterm;
 
        theta = atan2(dist_v, dist_u);
        thetagrad = 2 * theta * 180 / M_PI;
        thetares = (M_PI / 2 - theta) * 180 / M_PI;
        //nw corner
        azpixc = az1;
        geod.Direct(lat_gd[row + 1][col], lon_gd[row + 1][col], azpixc, dist_corn2, wn_lat4, wn_lon4);
        //   cout<<"azgc..CENTER-UPPER..."<<azgc<<"azpixc.."<<azpixc<<"dist_corn.."<<dist_corn<<"dist_corn2.."<<dist_corn2<<endl;
        //   cout<<"res1..nw."<<res1<<endl;
       //ne corner 
        azpixc = az2;
        geod.Direct(lat_gd[row + 1][col], lon_gd[row + 1][col], azpixc, dist_corn2, en_lat4, en_lon4);
        //   cout<<"azpixc.."<<azpixc<<"res2 ne.."<<res2<<endl;
       //sw corner 
        azpixc = az3;
        geod.Direct(lat_gd[row + 1][col], lon_gd[row + 1][col], azpixc, dist_corn2, ws_lat4, ws_lon4);
        //   cout<<"azpixc.."<<azpixc<<"res3..sw.."<<res3<<endl;
       //se corner 
        azpixc = az4;
        geod.Direct(lat_gd[row + 1][col], lon_gd[row + 1][col], azpixc, dist_corn2, es_lat4, es_lon4);
 
        latcornBox[0][3] = wn_lat;
        latcornBox[1][3] = wn_lat4;
        latcornBox[2][3] = en_lat4;
        latcornBox[3][3] = en_lat;
        loncornBox[0][3] = wn_lon;
        loncornBox[1][3] = wn_lon4;
        loncornBox[2][3] = en_lon4;
        loncornBox[3][3] = en_lon;
 
        //********************************************************
        //upper left  bin
        //*******************************************************
     
 
        deltaphi = (lat_gd[row + 1][col - 1] - lat_gd[row + 1][col]) * degrad;
        deltalam = (lon_gd[row + 1][col - 1] - lon_gd[row + 1][col]) * degrad;
        //across-track grid size
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row + 1][col - 1] * degrad) * cos(lat_gd[row + 1][col] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_u = Re * bterm;         //horizontal distance Harversine in km
 
        deltaphi = (lat_gd[row + 2][col - 1] - lat_gd[row + 1][col - 1]) * degrad;
        deltalam = (lon_gd[row + 2][col - 1] - lon_gd[row + 1][col - 1]) * degrad;
        //along-track distance
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row + 1][col - 1] * degrad) * cos(lat_gd[row + 2][col - 1] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_v = Re * bterm;
 
        theta = atan2(dist_v, dist_u);
        thetagrad = 2 * theta * 180 / M_PI;
        thetares = (M_PI / 2 - theta) * 180 / M_PI;
 
        //nw corner
        azpixc = az1;
        geod.Direct(lat_gd[row + 1][col - 1], lon_gd[row + 1][col - 1], azpixc, dist_corn2, wn_lat5, wn_lon5);
        //   cout<<"azgc..LEFT-UPPER..."<<azgc<<"azpixc.."<<azpixc<<"dist_corn.."<<dist_corn<<"dist_corn2.."<<dist_corn2<<endl;
        //   cout<<"res1..nw."<<res1<<endl;
       //ne corner 
        azpixc = az2;
        geod.Direct(lat_gd[row + 1][col - 1], lon_gd[row + 1][col - 1], azpixc, dist_corn2, en_lat5, en_lon5);
        //   cout<<"azpixc.."<<azpixc<<"res2 ne.."<<res2<<endl;
       //sw corner 
        azpixc = az3;
        geod.Direct(lat_gd[row + 1][col - 1], lon_gd[row + 1][col - 1], azpixc, dist_corn2, ws_lat5, ws_lon5);
        //   cout<<"azpixc.."<<azpixc<<"res3..sw.."<<res3<<endl;
       //se corner 
        azpixc = az4;
        geod.Direct(lat_gd[row + 1][col - 1], lon_gd[row + 1][col - 1], azpixc, dist_corn2, es_lat5, es_lon5);
        //  cout<<"azpixc.."<<azpixc<<"res4...se.."<<res4<<endl;
 
        latcornBox[0][4] = wn_lat2;
        latcornBox[1][4] = wn_lat5;
        latcornBox[2][4] = wn_lat4;
        latcornBox[3][4] = wn_lat;
        loncornBox[0][4] = wn_lon2;
        loncornBox[1][4] = wn_lon5;
        loncornBox[2][4] = wn_lon4;
        loncornBox[3][4] = wn_lon;
 
        //**************************************************************************************
        //upper right bin
        //**************************************************************************************
     
        deltaphi = (lat_gd[row + 1][col + 1] - lat_gd[row + 1][col + 2]) * degrad;
        deltalam = (lon_gd[row + 1][col + 1] - lon_gd[row + 1][col + 2]) * degrad;
        //across-track grid size
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row + 1][col + 1] * degrad) * cos(lat_gd[row + 1][col + 2] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_u = Re * bterm;         //horizontal distance Harversine in km
 
        deltaphi = (lat_gd[row + 2][col + 1] - lat_gd[row + 1][col + 1]) * degrad;
        deltalam = (lon_gd[row + 2][col + 1] - lon_gd[row + 1][col + 1]) * degrad;
        //along-track distance
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row + 1][col + 1] * degrad) * cos(lat_gd[row + 2][col + 1] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_v = Re * bterm;
 
        theta = atan2(dist_v, dist_u);
        thetagrad = 2 * theta * 180 / M_PI;
        thetares = (M_PI / 2 - theta) * 180 / M_PI;
 
        //nw corner
        azpixc = az1;
        geod.Direct(lat_gd[row + 1][col + 1], lon_gd[row + 1][col + 1], azpixc, dist_corn2, wn_lat6, wn_lon6);
 
        //  cout<<"azgc..RIGHT-UPPER..."<<azgc<<"azpixc.."<<azpixc<<"dist_corn.."<<dist_corn<<"dist_corn2.."<<dist_corn2<<endl;
       //   cout<<"res1..nw."<<res1<<endl;
      //ne corner 
        azpixc = az2;
        geod.Direct(lat_gd[row + 1][col + 1], lon_gd[row + 1][col + 1], azpixc, dist_corn2, en_lat6, en_lon6);
 
        //   cout<<"azpixc.."<<azpixc<<"res2 ne.."<<res2<<endl;
       //sw corner 
        azpixc = az3;
        geod.Direct(lat_gd[row + 1][col + 1], lon_gd[row + 1][col + 1], azpixc, dist_corn2, ws_lat6, ws_lon6);
 
        //  cout<<"azpixc.."<<azpixc<<"res3..sw.."<<res3<<endl;
      //se corner 
        azpixc = az4;
        geod.Direct(lat_gd[row + 1][col + 1], lon_gd[row + 1][col + 1], azpixc, dist_corn2, es_lat6, es_lon6);
 
        //  cout<<"azpixc.."<<azpixc<<"res4...se.."<<res4<<endl;
        latcornBox[0][5] = en_lat;
        latcornBox[1][5] = en_lat4;
        latcornBox[2][5] = en_lat6;
        latcornBox[3][5] = en_lat3;
        loncornBox[0][5] = en_lon;
        loncornBox[1][5] = en_lon4;
        loncornBox[2][5] = en_lon6;
        loncornBox[3][5] = en_lon3;
 
        //************************************************************
        //lower center  bin
        //*************************************************************
 
     
 
        deltaphi = (lat_gd[row - 1][col] - lat_gd[row - 1][col + 1]) * degrad;
        deltalam = (lon_gd[row - 1][col] - lon_gd[row - 1][col + 1]) * degrad;
        //across-track grid size
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row - 1][col] * degrad) * cos(lat_gd[row - 1][col + 1] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_u = Re * bterm;         //horizontal distance Harversine in km
 
        deltaphi = (lat_gd[row - 1][col] - lat_gd[row][col]) * degrad;
        deltalam = (lon_gd[row - 1][col] - lon_gd[row][col]) * degrad;
        //along-track distance
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row - 1][col] * degrad) * cos(lat_gd[row][col] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_v = Re * bterm;
 
        theta = atan2(dist_v, dist_u);
        thetagrad = 2 * theta * 180 / M_PI;
        thetares = (M_PI / 2 - theta) * 180 / M_PI;
 
        //nw corner
        azpixc = az1;
        geod.Direct(lat_gd[row - 1][col], lon_gd[row - 1][col], azpixc, dist_corn2, wn_lat7, wn_lon7);
        //   cout<<"azgc..LOWER CENTER..."<<azgc<<"azpixc.."<<azpixc<<"dist_corn.."<<dist_corn<<"dist_corn2.."<<dist_corn2<<endl;
        //   cout<<"res1..nw."<<res1<<endl;
       //ne corner 
        azpixc = az2;
        geod.Direct(lat_gd[row - 1][col], lon_gd[row - 1][col], azpixc, dist_corn2, en_lat7, en_lon7);
        //   cout<<"azpixc.."<<azpixc<<"res2 ne.."<<res2<<endl;
       //sw corner 
        azpixc = az3;
        geod.Direct(lat_gd[row - 1][col], lon_gd[row - 1][col], azpixc, dist_corn2, ws_lat7, ws_lon7);
 
        //   cout<<"azpixc.."<<azpixc<<"res3..sw.."<<res3<<endl;
       //se corner 
        azpixc = az4;
        geod.Direct(lat_gd[row - 1][col], lon_gd[row - 1][col], azpixc, dist_corn2, es_lat7, es_lon7);
 
        //   cout<<"azpixc.."<<azpixc<<"res4...se.."<<res4<<endl;
        latcornBox[0][6] = ws_lat7;
        latcornBox[1][6] = ws_lat;
        latcornBox[2][6] = es_lat;
        latcornBox[3][6] = es_lat7;
        loncornBox[0][6] = ws_lon7;
        loncornBox[1][6] = ws_lon;
        loncornBox[2][6] = es_lon;
        loncornBox[3][6] = es_lon7;
 
        //******************************************************************
        //lower left bin
        //****************************************************************
    
 
        deltaphi = (lat_gd[row - 1][col - 1] - lat_gd[row - 1][col]) * degrad;
        deltalam = (lon_gd[row - 1][col - 1] - lon_gd[row - 1][col]) * degrad;
        //across-track grid size
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row - 1][col - 1] * degrad) * cos(lat_gd[row - 1][col] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_u = Re * bterm;         //horizontal distance Harversine in km
 
        deltaphi = (lat_gd[row - 1][col - 1] - lat_gd[row][col - 1]) * degrad;
        deltalam = (lon_gd[row - 1][col - 1] - lon_gd[row][col - 1]) * degrad;
        //along-track distance
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row - 1][col - 1] * degrad) * cos(lat_gd[row][col - 1] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_v = Re * bterm;
 
        theta = atan2(dist_v, dist_u);
        thetagrad = 2 * theta * 180 / M_PI;
        thetares = (M_PI / 2 - theta) * 180 / M_PI;
 
        //nw corner
        azpixc = az1;
        geod.Direct(lat_gd[row - 1][col - 1], lon_gd[row - 1][col - 1], azpixc, dist_corn2, wn_lat8, wn_lon8);
        //   cout<<"azgc..LOWER LEFT..."<<azgc<<"azpixc.."<<azpixc<<"dist_corn.."<<dist_corn<<"dist_corn2.."<<dist_corn2<<endl;
        //   cout<<"res1..nw."<<res1<<endl;
       //ne corner 
        azpixc = az2;
        geod.Direct(lat_gd[row - 1][col - 1], lon_gd[row - 1][col - 1], azpixc, dist_corn2, en_lat8, en_lon8);
        //   cout<<"azpixc.."<<azpixc<<"res2 ne.."<<res2<<endl;
       //sw corner 
        azpixc = az3;
        geod.Direct(lat_gd[row - 1][col - 1], lon_gd[row - 1][col - 1], azpixc, dist_corn2, ws_lat8, ws_lon8);
        //   cout<<"azpixc.."<<azpixc<<"res3..sw.."<<res3<<endl;
       //se corner 
        azpixc = az4;
        geod.Direct(lat_gd[row - 1][col - 1], lon_gd[row - 1][col - 1], azpixc, dist_corn2, es_lat8, es_lon8);
 
        //  cout<<"azpixc.."<<azpixc<<"res4...se.."<<res4<<endl;
        latcornBox[0][7] = ws_lat8;
        latcornBox[1][7] = ws_lat2;
        latcornBox[2][7] = ws_lat;
        latcornBox[3][7] = ws_lat7;
        loncornBox[0][7] = ws_lon8;
        loncornBox[1][7] = ws_lon2;
        loncornBox[2][7] = ws_lon;
        loncornBox[3][7] = ws_lon7;
 
        //******************************************************************
        //lower right bin
        //****************************************************************
 
        deltaphi = (lat_gd[row - 1][col + 1] - lat_gd[row - 1][col + 2]) * degrad;
        deltalam = (lon_gd[row - 1][col + 1] - lon_gd[row - 1][col + 2]) * degrad;
        //across-track grid size
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row - 1][col + 1] * degrad) * cos(lat_gd[row - 1][col + 2] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_u = Re * bterm;         //horizontal distance Harversine in km
 
        deltaphi = (lat_gd[row - 1][col + 1] - lat_gd[row][col + 1]) * degrad;
        deltalam = (lon_gd[row - 1][col + 1] - lon_gd[row][col + 1]) * degrad;
        //along-track distance
        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(lat_gd[row - 1][col + 1] * degrad) * cos(lat_gd[row][col + 1] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
        dist_v = Re * bterm;
 
        theta = atan2(dist_v, dist_u);
        thetagrad = 2 * theta * 180 / M_PI;
        thetares = (M_PI / 2 - theta) * 180 / M_PI;
 
        //nw corner
        azpixc = az1;
        geod.Direct(lat_gd[row - 1][col + 1], lon_gd[row - 1][col + 1], azpixc, dist_corn2, wn_lat9, wn_lon9);
        //  cout<<"azgc..LOWER RIGHT..."<<azgc<<"azpixc.."<<azpixc<<"dist_corn.."<<dist_corn<<"dist_corn2.."<<dist_corn2<<endl;
        //  cout<<"res1..nw."<<res1<<endl;
      //ne corner 
        azpixc = az2;
        geod.Direct(lat_gd[row - 1][col + 1], lon_gd[row - 1][col + 1], azpixc, dist_corn2, en_lat9, en_lon9);
        //  cout<<"azpixc.."<<azpixc<<"res2 ne.."<<res2<<endl;
      //sw corner 
        azpixc = az3;
        geod.Direct(lat_gd[row - 1][col + 1], lon_gd[row - 1][col + 1], azpixc, dist_corn2, ws_lat9, ws_lon9);
        //  cout<<"azpixc.."<<azpixc<<"res3..sw.."<<res3<<endl;
      //se corner 
        azpixc = az4;
        geod.Direct(lat_gd[row - 1][col + 1], lon_gd[row - 1][col + 1], azpixc, dist_corn2, es_lat9, es_lon9);
        //   cout<<"azpixc.."<<azpixc<<"res4...se.."<<res4<<endl;
        latcornBox[0][8] = es_lat7;
        latcornBox[1][8] = es_lat;
        latcornBox[2][8] = es_lat3;
        latcornBox[3][8] = es_lat9;
        loncornBox[0][8] = es_lon7;
        loncornBox[1][8] = es_lon;
        loncornBox[2][8] = es_lon3;
        loncornBox[3][8] = es_lon9;
 
 
 
        return 0;
    }
 
 
 
 
    int32_t L1C::pixcornBox(l1c_filehandle* l1cfile, L1C_input* l1cinput, float dist_u, float dist_v, float azpix, int32_t scanline, int32_t pix, float pixlat, float pixlon, float pixLt, short gd_row, short gd_col, float** lat_gd, float** lon_gd, Polygon_t& pixelPoly) {
 
        double lat_cnw, lat_cne, lat_csw, lat_cse, lon_cnw, lon_cne, lon_csw, lon_cse;
        float azpixc;
        float theta, thetares, dist_corn, thetagrad;
 
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
 
        //using namespace bg;
       // Polygon_t pixelPoly;
       // Box_t pixelBox;
       // Point_t pixelPoint;
 
 
 
        //******* M_PIXEL CORNERS *****************************
        //***************************************************
        dist_corn = 0.5 * (sqrt(dist_u * dist_u + dist_v * dist_v)) * 1000;//distane center to corner in meters
 
        theta = atan2(dist_v, dist_u);
        thetagrad = 2 * theta * 180 / M_PI;
        thetares = (M_PI / 2 - theta) * 180 / M_PI;
 
        //nw corner 
        azpixc = (azpix - thetares) * degrad;//pixel bearing
        if (azpixc<-M_PI | azpixc>M_PI) { cout << "error in nw corner..azpixc" << azpixc << endl;exit(1); }
        azpixc = azpixc * 180 / M_PI;
        // cout<<"azpixc nw...."<<azpixc<<endl;
        geod.Direct(pixlat, pixlon, azpixc, dist_corn, lat_cnw, lon_cnw);
        // geod.Inverse(pixlat,pixlon,lat_cnw,lon_cnw,res1);
        //ne corner (sw-180)
        azpixc = (azpix + thetares) * degrad;//pixel bearing
        if (azpixc<-M_PI | azpixc>M_PI) { cout << "error in ne corner..azpixc" << azpixc << endl;exit(1); }
        azpixc = azpixc * 180 / M_PI;
        // cout<<"azpixc ne...."<<azpixc<<endl;
        geod.Direct(pixlat, pixlon, azpixc, dist_corn, lat_cne, lon_cne);
        // geod.Inverse(pixlat,pixlon,lat_cne,lon_cne,res2);
        //sw corner 
        // azpixc=(azpix-45-90)*degrad;//pixel bearing
        azpixc = (azpix - thetares - thetagrad) * degrad;//pixel bearing
        if (azpixc<-M_PI | azpixc>M_PI) { cout << "error in sw corner..azpixc" << azpixc << endl;exit(1); }
        azpixc = azpixc * 180 / M_PI;
        // cout<<"azpixc sw....."<<azpixc<<endl;
        geod.Direct(pixlat, pixlon, azpixc, dist_corn, lat_csw, lon_csw);
        //geod.Inverse(pixlat,pixlon,lat_csw,lon_csw,res3);
 
       //se corner (nw-180)
        azpixc = (azpix + thetares + thetagrad) * degrad;//pixel bearingi
        if (azpixc<-M_PI | azpixc>M_PI) { cout << "error in se corner..azpixc" << azpixc << endl;exit(1); }
        // azpixc=(azpix+45+90)*degrad;//pixel bearing
        azpixc = azpixc * 180 / M_PI;
        // cout<<"azpix se...."<<azpixc<<endl;
        geod.Direct(pixlat, pixlon, azpixc, dist_corn, lat_cse, lon_cse);
 
        std::string ws_lon_str, ws_lat_str, wn_lon_str, wn_lat_str, en_lon_str, en_lat_str, es_lon_str, es_lat_str, pixstr;
 
        ws_lon_str = std::to_string(lon_csw);
        ws_lat_str = std::to_string(lat_csw);
        wn_lon_str = std::to_string(lon_cnw);
        wn_lat_str = std::to_string(lat_cnw);
        en_lon_str = std::to_string(lon_cne);
        en_lat_str = std::to_string(lat_cne);
        es_lon_str = std::to_string(lon_cse);
        es_lat_str = std::to_string(lat_cse);
 
 
        pixstr = "POLYGON((" + ws_lon_str + " " + ws_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + en_lon_str + " " + en_lat_str + "," + es_lon_str + " " + es_lat_str + "," + ws_lon_str + " " + ws_lat_str + "))";
        bg::read_wkt(pixstr, pixelPoly);
 
        if (lon_csw > lon_cse | lon_cnw > lon_cne | lat_csw > lat_cnw | lat_cse > lat_cne) {
            cout << "lon_csw>lon_cse | lon_cnw>lon_cne | lat_csw>lat_cnw | lat_cse>lat_cne//" << lon_csw << lon_cse << lon_cnw << lon_cne << lat_csw << lat_cnw << lat_cse << lat_cne << endl;
            cout << "corners are switched for pixel.." << pix + 1 << endl;
        }
 
 
 
        return 0;
    }
 
 
 
 
    int32_t L1C::pix_corners4_l1c3(l1c_filehandle* l1cfile, L1C_input* l1cinput, float dist_u, float dist_v, float azpix, int32_t scanline, int32_t pix, float pixlat, float pixlon, float pixLt, short gd_row, short gd_col, float** lat_gd, float** lon_gd, double areaFracBox[3][3], double areabinBox[3][3]) {
 
        double lat_cnw, lat_cne, lat_csw, lat_cse, lon_cnw, lon_cne, lon_csw, lon_cse;
        float azpixc;
        int32_t num_gridlines, nbinx;
        float theta, thetares, dist_corn, thetagrad;
 
 
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
 
        //using namespace bg;
        Polygon_t pixelPoly;
 
        num_gridlines = l1cfile->num_gridlines;
        nbinx = l1cfile->nbinx;
 
        //******* M_PIXEL CORNERS *****************************
        //***************************************************
        dist_corn = 0.5 * (sqrt(dist_u * dist_u + dist_v * dist_v)) * 1000;//distane center to corner in meters
 
        theta = atan2(dist_v, dist_u);
        thetagrad = 2 * theta * 180 / M_PI;
        thetares = (M_PI / 2 - theta) * 180 / M_PI;
 
        //nw corner 
        azpixc = (azpix - thetares) * degrad;//pixel bearing
        if (azpixc<-M_PI | azpixc>M_PI) { cout << "error in nw corner..azpixc" << azpixc << endl;exit(1); }
        azpixc = azpixc * 180 / M_PI;
        // cout<<"azpixc nw...."<<azpixc<<endl;
        geod.Direct(pixlat, pixlon, azpixc, dist_corn, lat_cnw, lon_cnw);
        // geod.Inverse(pixlat,pixlon,lat_cnw,lon_cnw,res1);
        //ne corner (sw-180)
        azpixc = (azpix + thetares) * degrad;//pixel bearing
        if (azpixc<-M_PI | azpixc>M_PI) { cout << "error in ne corner..azpixc" << azpixc << endl;exit(1); }
        azpixc = azpixc * 180 / M_PI;
        // cout<<"azpixc ne...."<<azpixc<<endl;
        geod.Direct(pixlat, pixlon, azpixc, dist_corn, lat_cne, lon_cne);
        // geod.Inverse(pixlat,pixlon,lat_cne,lon_cne,res2);
        //sw corner 
        // azpixc=(azpix-45-90)*degrad;//pixel bearing
        azpixc = (azpix - thetares - thetagrad) * degrad;//pixel bearing
        if (azpixc<-M_PI | azpixc>M_PI) { cout << "error in sw corner..azpixc" << azpixc << endl;exit(1); }
        azpixc = azpixc * 180 / M_PI;
        // cout<<"azpixc sw....."<<azpixc<<endl;
        geod.Direct(pixlat, pixlon, azpixc, dist_corn, lat_csw, lon_csw);
        //geod.Inverse(pixlat,pixlon,lat_csw,lon_csw,res3);
 
       //se corner (nw-180)
        azpixc = (azpix + thetares + thetagrad) * degrad;//pixel bearingi
        if (azpixc<-M_PI | azpixc>M_PI) { cout << "error in se corner..azpixc" << azpixc << endl;exit(1); }
        // azpixc=(azpix+45+90)*degrad;//pixel bearing
        azpixc = azpixc * 180 / M_PI;
        // cout<<"azpix se...."<<azpixc<<endl;
        geod.Direct(pixlat, pixlon, azpixc, dist_corn, lat_cse, lon_cse);
        //geod.Inverse(pixlat,pixlon,lat_cse,lon_cse,res4);
 
       /* cout<<"pix.."<<pix+1<<"azpix.."<<azpix<<"theta.."<<thetagrad<<"thetares.."<<thetares<<endl;
        cout<<"res1."<<res1<<"res2."<<res2<<"res3.."<<res3<<"res4.."<<res4<<endl;
        cout<<"pix sw corner..lat."<<lat_csw<<"sw corner lon.."<<lon_csw<<endl;
        cout<<"pix nw corner..lat."<<lat_cnw<<"nw corner lon.."<<lon_cnw<<endl;
        cout<<"pix ne corner..lat."<<lat_cne<<"ne corner lon.."<<lon_cne<<endl;
        cout<<"pix se corner..lat."<<lat_cse<<"se corner lon.."<<lon_cse<<endl;
       */
 
 
        std::string ws_lon_str, ws_lat_str, wn_lon_str, wn_lat_str, en_lon_str, en_lat_str, es_lon_str, es_lat_str, pixstr;
 
        ws_lon_str = std::to_string(lon_csw);
        ws_lat_str = std::to_string(lat_csw);
        wn_lon_str = std::to_string(lon_cnw);
        wn_lat_str = std::to_string(lat_cnw);
        en_lon_str = std::to_string(lon_cne);
        en_lat_str = std::to_string(lat_cne);
        es_lon_str = std::to_string(lon_cse);
        es_lat_str = std::to_string(lat_cse);
 
 
        pixstr = "POLYGON((" + ws_lon_str + " " + ws_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + en_lon_str + " " + en_lat_str + "," + es_lon_str + " " + es_lat_str + "," + ws_lon_str + " " + ws_lat_str + "))";
        bg::read_wkt(pixstr, pixelPoly);
 
        if (lon_csw > lon_cse | lon_cnw > lon_cne | lat_csw > lat_cnw | lat_cse > lat_cne) {
            cout << "lon_csw>lon_cse | lon_cnw>lon_cne | lat_csw>lat_cnw | lat_cse>lat_cne//" << lon_csw << lon_cse << lon_cnw << lon_cne << lat_csw << lat_cnw << lat_cse << lat_cne << endl;
            cout << "corners are switched for pixel.." << pix + 1 << endl;
        }
 
 
        if (gd_row >= 1 && gd_col >= 1 && gd_row < num_gridlines - 1 && gd_col < nbinx - 1) {
            /*
                 latcornBox=allocate2d_double(4,9);//4 corners, 9 grid cells
                 loncornBox=allocate2d_double(4,9);
 
                 for(int i=0;i<4;i++){
                   for(int j=0;j<9;j++){
                      latcornBox[i][j]=0.;
                       loncornBox[i][j]=0.;
                             }}
                    gwindowTopix_l1c(l1cfile,l1cinput,gd_row, gd_col,lat_gd,lon_gd,latcornBox,loncornBox);
 
 
                 for(int i=0;i<4;i++){
                   for(int j=0;j<9;j++){
                      cout<<"corner#..."<<i<<"gridcell#..."<<j<<"latcorn.."<<latcornBox[i][j]<<"loncorn.."<<loncornBox[i][j]<<endl;
                             }}
 
 
 
 
            //    binIntersectsPix4corn4_l1c(l1cfile,l1cinput,gd_row, gd_col,lat_gd,lon_gd,pixelPoly,areaFracBox,areabinBox);
              //  exit(1);
 
 
             delete [] (latcornBox);
             delete [] (loncornBox);
 
             latcornBox=nullptr;
             loncornBox=nullptr;
            */
 
            /*
             int ar=0,ac=0;
             size_t fracells=0;
 
               for(int gr=gd_row-1;gr<gd_row+2;gr++){
                  for(int gc=gd_col-1;gc<gd_col+2;gc++){
               //      cout<<"ar.."<<ar<<"ac.."<<ac<<"areafracbox.."<<areaFracBox[ar][ac]<<"areabin.."<<areabinBox[ar][ac]<<endl;
                     if(areaFracBox[ar][ac]>0) fracells++;
 
                   if(pixLt>0.0){
                     Ltfracsum[gr][gc]+=pixLt*areaFracBox[ar][ac];
                     areafracsum[gr][gc]+=areaFracBox[ar][ac];
                     nobs_perbin[gr][gc]+=1;
                     }
                   else{
                     Ltfracsum[gr][gc]+=0.0;
                     areafracsum[gr][gc]+=0.0;
                     nobs_perbin[gr][gc]+=0;
                    }
                  ac++;
                  }
                 ac=0;
                 ar++;
                 }
 
              if(fracells>5){
                     cout<<"Number of gridcells with pixel fractions CANNOT be greater than 5!!!...................fracells = ......."<<fracells<<endl;
                     exit(1);
                   }
            */
 
        }//if gd_row gd_col
 
 
       //exit(1);
 
        return 0;
    }
 
 
 
 
    int32_t L1C::pix_corners4_l1c2(l1c_filehandle* l1cfile, L1C_input* l1cinput, float dist_u, float dist_v, float azpix, int32_t scanline, int32_t pix, float pixlat, float pixlon, float pixLt, short gd_row, short gd_col, float** lat_gd, float** lon_gd, double areaFracBox[3][3], double** Ltfracsum, double** areafracsum, float** nobs_perbin) { //compute pixel corners for a specific line,pixel and file
 
        double lat_cnw, lat_cne, lat_csw, lat_cse, lon_cnw, lon_cne, lon_csw, lon_cse;
        float azpixc;
        int32_t num_gridlines, nbinx;
        double areabinBox[3][3];
        float theta, thetares, dist_corn, thetagrad;
        double res1, res2, res3, res4;//pixel resolution in meters
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
 
        //using namespace bg;
        Polygon_t pixelPoly;
        num_gridlines = l1cfile->num_gridlines;
        nbinx = l1cfile->nbinx;
 
 
        //******* M_PIXEL CORNERS *****************************
        //***************************************************
 
        // ad=0.5*(sqrt(dist_u*dist_u+dist_v*dist_v)/Re);
        dist_corn = 0.5 * (sqrt(dist_u * dist_u + dist_v * dist_v)) * 1000;//distane center to corner in meters
 
 
        theta = atan2(dist_v, dist_u);
        thetagrad = 2 * theta * 180 / M_PI;
        thetares = (M_PI / 2 - theta) * 180 / M_PI;
 
        //nw corner 
        azpixc = (azpix - thetares) * degrad;//pixel bearing
        if (azpixc<-M_PI | azpixc>M_PI) { cout << "error in nw corner..azpixc" << azpixc << endl;exit(1); }
        azpixc = azpixc * 180 / M_PI;
        // cout<<"azpixc nw...."<<azpixc<<endl;
        geod.Direct(pixlat, pixlon, azpixc, dist_corn, lat_cnw, lon_cnw);
        geod.Inverse(pixlat, pixlon, lat_cnw, lon_cnw, res1);
        // lat_cne=asin(sin(pixlat*degrad)*cos(ad)+cos(pixlat*degrad)*sin(ad)*cos(azpixc*degrad))*180./M_PI;
        // lon_cne=pixlon+atan2(sin(azpixc*degrad)*sin(ad)*cos(pixlat*degrad),cos(ad)-sin(pixlat*degrad)*sin(lat_cne*degrad))*180./M_PI;
 
 
        //ne corner (sw-180)
        azpixc = (azpix + thetares) * degrad;//pixel bearing
        if (azpixc<-M_PI | azpixc>M_PI) { cout << "error in ne corner..azpixc" << azpixc << endl;exit(1); }
        // azpixc=(azpix+45)*degrad;//pixel bearing
        /* if(azpixc>M_PI | azpixc<-M_PI){
              }
         if(azpixc<0.){
                  azpixc=360+azpixc*180/M_PI;
                     }
         else azpixc=azpixc*180/M_PI;
        */
 
        azpixc = azpixc * 180 / M_PI;
        // cout<<"azpixc ne...."<<azpixc<<endl;
        geod.Direct(pixlat, pixlon, azpixc, dist_corn, lat_cne, lon_cne);
        geod.Inverse(pixlat, pixlon, lat_cne, lon_cne, res2);
 
 
        //sw corner 
        // azpixc=(azpix-45-90)*degrad;//pixel bearing
        azpixc = (azpix - thetares - thetagrad) * degrad;//pixel bearing
        if (azpixc<-M_PI | azpixc>M_PI) { cout << "error in sw corner..azpixc" << azpixc << endl;exit(1); }
        /* if(azpixc>M_PI | azpixc<-M_PI){
              //      cout<<"problem with BEARING in across-gridline method...az<-180 or >180...."<<"SW azpixc in degrees.."<<azpixc*180/M_PI<<endl;
                     }
         if(azpixc<0.){
                  azpixc=360+azpixc*180/M_PI;
                     }
         else azpixc=azpixc*180/M_PI;
         */
 
        azpixc = azpixc * 180 / M_PI;
        // cout<<"azpixc sw....."<<azpixc<<endl;
        geod.Direct(pixlat, pixlon, azpixc, dist_corn, lat_csw, lon_csw);
        geod.Inverse(pixlat, pixlon, lat_csw, lon_csw, res3);
        //lat_csw=asin(sin(pixlat*degrad)*cos(ad)+cos(pixlat*degrad)*sin(ad)*cos(azpixc*degrad))*180./M_PI;
        // lon_csw=pixlon+atan2(sin(azpixc*degrad)*sin(ad)*cos(pixlat*degrad),cos(ad)-sin(pixlat*degrad)*sin(lat_csw*degrad))*180./M_PI;
 
        //se corner (nw-180)
        azpixc = (azpix + thetares + thetagrad) * degrad;//pixel bearingi
        if (azpixc<-M_PI | azpixc>M_PI) { cout << "error in se corner..azpixc" << azpixc << endl;exit(1); }
        // azpixc=(azpix+45+90)*degrad;//pixel bearing
        /* if(azpixc>M_PI | azpixc<-M_PI){
              //      cout<<"problem with BEARING in across-gridline method...az<-180 or >180...."<<"SE azpixc in degrees.."<<azpixc*180/M_PI<<endl;
                     }
         if(azpixc<0.){
                  azpixc=360+azpixc*180/M_PI;
                     }
         else azpixc=azpixc*180/M_PI;
        */
        azpixc = azpixc * 180 / M_PI;
        // cout<<"azpix se...."<<azpixc<<endl;
        geod.Direct(pixlat, pixlon, azpixc, dist_corn, lat_cse, lon_cse);
        geod.Inverse(pixlat, pixlon, lat_cse, lon_cse, res4);
        // lat_cse=asin(sin(pixlat*degrad)*cos(ad)+cos(pixlat*degrad)*sin(ad)*cos(azpixc*degrad))*180./M_PI;
        // lon_cse=pixlon+atan2(sin(azpixc*degrad)*sin(ad)*cos(pixlat*degrad),cos(ad)-sin(pixlat*degrad)*sin(lat_cse*degrad))*180./M_PI;
 
        /*
         cout<<"pix.."<<pix+1<<"azpix.."<<azpix<<"theta.."<<thetagrad<<"thetares.."<<thetares<<endl;
         cout<<"res1."<<res1<<"res2."<<res2<<"res3.."<<res3<<"res4.."<<res4<<endl;
         cout<<"pix sw corner..lat."<<lat_csw<<"sw corner lon.."<<lon_csw<<endl;
         cout<<"pix nw corner..lat."<<lat_cnw<<"nw corner lon.."<<lon_cnw<<endl;
         cout<<"pix ne corner..lat."<<lat_cne<<"ne corner lon.."<<lon_cne<<endl;
         cout<<"pix se corner..lat."<<lat_cse<<"se corner lon.."<<lon_cse<<endl;
        */
 
 
 
        std::string ws_lon_str, ws_lat_str, wn_lon_str, wn_lat_str, en_lon_str, en_lat_str, es_lon_str, es_lat_str, pixstr;
        ws_lon_str = std::to_string(lon_csw);
        ws_lat_str = std::to_string(lat_csw);
        wn_lon_str = std::to_string(lon_cnw);
        wn_lat_str = std::to_string(lat_cnw);
        en_lon_str = std::to_string(lon_cne);
        en_lat_str = std::to_string(lat_cne);
        es_lon_str = std::to_string(lon_cse);
        es_lat_str = std::to_string(lat_cse);
 
 
        pixstr = "POLYGON((" + ws_lon_str + " " + ws_lat_str + "," + wn_lon_str + " " + wn_lat_str + "," + en_lon_str + " " + en_lat_str + "," + es_lon_str + " " + es_lat_str + "," + ws_lon_str + " " + ws_lat_str + "))";
        bg::read_wkt(pixstr, pixelPoly);
 
        if (lon_csw > lon_cse | lon_cnw > lon_cne | lat_csw > lat_cnw | lat_cse > lat_cne) {
            cout << "lon_csw>lon_cse | lon_cnw>lon_cne | lat_csw>lat_cnw | lat_cse>lat_cne//" << lon_csw << lon_cse << lon_cnw << lon_cne << lat_csw << lat_cnw << lat_cse << lat_cne << endl;
            cout << "corners are switched for pixel.." << pix + 1 << endl;
        }
 
        // exit(1);
 
        //*** L1C grid cell *******************************************************************************
        for (int ar = 0;ar < 3;ar++) {
            for (int ac = 0;ac < 3;ac++) {
                areaFracBox[ar][ac] = 0.;
                areabinBox[ar][ac] = 0.;
                ac++;
            }
            ar++;
        }
 
 
 
        if (gd_row >= 1 && gd_col >= 1 && gd_row < num_gridlines - 1 && gd_col < nbinx - 1) {
 
            binIntersectsPix4corn4_l1c(l1cfile, l1cinput, gd_row, gd_col, lat_gd, lon_gd, pixelPoly, areaFracBox, areabinBox);
            //  exit(1);
 
            int ar = 0, ac = 0;
            size_t fracells = 0;
            for (int gr = gd_row - 1;gr < gd_row + 2;gr++) {
                for (int gc = gd_col - 1;gc < gd_col + 2;gc++) {
 
                    //      cout<<"ar.."<<ar<<"ac.."<<ac<<"areafracbox.."<<areaFracBox[ar][ac]<<"areabin.."<<areabinBox[ar][ac]<<endl;
                    if (areaFracBox[ar][ac] > 0) fracells++;
 
                    if (pixLt > 0.0) {
                        Ltfracsum[gr][gc] += pixLt * areaFracBox[ar][ac];
                        areafracsum[gr][gc] += areaFracBox[ar][ac];
                        nobs_perbin[gr][gc] += 1;
                    }
                    else {
                        Ltfracsum[gr][gc] += 0.0;
                        areafracsum[gr][gc] += 0.0;
                        nobs_perbin[gr][gc] += 0;
                    }
                    ac++;
                }
                ac = 0;
                ar++;
            }
 
            if (fracells > 5) {
                cout << "Number of gridcells with pixel fractions CANNOT be greater than 5!!!...................fracells = ......." << fracells << endl;
                exit(1);
            }
        }
        else {
            //  cout<<"pix out of the L1Cgrid.........................."<<"pix#..."<<pix+1<<"pixlat.."<<pixlat<<"pixlon..."<<pixlon<<endl;
        }
 
 
        return 0;
    }
 
 
 
  int32_t L1C::xy_pixsize_sf3(const char* filename, l1c_filehandle* l1cfile, L1C_input* l1cinput, float** pix_size_u, float** pix_size_v, float** lat_gd, float** lon_gd, double** lat_cgd, double** lon_cgd, float** Ltfracsum, float** areabinsum, float** nobs_perbin,float **lat_asort,short **index_xy){
 
        int dimid, status;
        size_t start[] = { 0, 0 }, start2[] = { 0,0 };
        size_t count[] = { 1, 1 };
        size_t start3[] = { 0,0,0 }, count3[] = { 1, 1, 1 };
        float* latpix, * lonpix, * latpix2, * lonpix2, ** Lt_pix;
        float Re = 6378;
        float deltaphi = 0., deltalam = 0., aterm = 0., bterm, dist_u = 0., dist_v = 0., azpix = 0.;
        double areaFracBox[3][3];
//        short gd_row = 0, gd_col = 0;
 
        for (int ar = 0;ar < 3;ar++) {
            for (int ac = 0;ac < 3;ac++) {
                areaFracBox[ar][ac] = 0.;
                ac++;
            }
            ar++;
        }
 
        num_pixels = l1cfile->npix;
 
        //recompute number of gridlines based on lat limits -80 to 80 degrees  
     //asc orbit goes from negative to positive latitude....
 
        latpix = (float*)calloc(num_pixels , sizeof(float));
        lonpix = (float*)calloc(num_pixels , sizeof(float));
        latpix2 = (float*)calloc(num_pixels , sizeof(float));
        lonpix2 = (float*)calloc(num_pixels , sizeof(float));
 
 
 
        /*  for(int gd=0;gd<2;gd++){
           for(int k=0;k<nbinx;k++){
                 cout<<"gd.."<<gd+1<<"binx.."<<k+1<<"latgd..."<<lat_gd[gd][k]<<"longd..."<<lon_gd[gd][k]<<"latgd..."<<lat_cgd[gd][k]<<"longd..."<<lon_cgd[gd][k]<<endl;
             }}
          exit(1);
       */
      cout << "inside....xy_pixsize_sf3!!.." << endl;
 
 //       sbs2_sort_latgd(l1cfile, lat_gd, lat_asort, index_xy);
 
        cout << "filename..." << filename << endl;
        status = nc_open(filename, NC_NOWRITE, &ncid_L1B);
        if (status != NC_NOERR) {
            fprintf(stderr, "-nc_open fails.\n");
            exit(EXIT_FAILURE);
           }
 
        //Open dimensions
        status = nc_inq_dimid(ncid_L1B, "number_of_scans", &dimid);
        if (status != NC_NOERR) {
            fprintf(stderr, "-E- Error reading number_of_scans.\n");
            exit(EXIT_FAILURE);
        }
        nc_inq_dimlen(ncid_L1B, dimid, &num_scans);
 
        //read line-by-line lat/lon/Lt
        status = nc_inq_grp_ncid(ncid_L1B, "geolocation_data", &geoGrp);
        check_err(status, __LINE__, __FILE__);
        status = nc_inq_grp_ncid(ncid_L1B, "observation_data", &obsGrp);
        check_err(status, __LINE__, __FILE__);
        //open geo data 
        status = nc_inq_varid(geoGrp, "latitude", &latId);//scans x velements
        check_err(status, __LINE__, __FILE__);
        status = nc_inq_varid(geoGrp, "longitude", &lonId);//scans x velements
        check_err(status, __LINE__, __FILE__);
 
        // num_blue_bands
        status = nc_inq_dimid(ncid_L1B, "blue_bands", &dimid);
        if (status != NC_NOERR) {
            fprintf(stderr, "-E- Error reading num_blue_bands.\n");
            exit(EXIT_FAILURE);
        }
        nc_inq_dimlen(ncid_L1B, dimid, &num_blue_bands);
 
        status = nc_inq_varid(obsGrp, "Lt_blue", &Lt_blueId);
        check_err(status, __LINE__, __FILE__);
 
        Lt_pix = allocate2d_float(num_blue_bands, num_pixels);
 
        //-----reading line by line-----------------------------------           
        for (unsigned int sline = 0;sline < num_scans - 1;sline++) {
 
            //lat and lon--
            start[0] = sline;
            start[1] = 0;
            start2[0] = sline + 1;
            start2[1] = 0;
            count[0] = 1;
            count[1] = num_pixels;               // 1 line at a time
 
            start3[0] = 0;
            start3[1] = sline;
            start3[2] = 0;
 
            count3[0] = num_blue_bands;
            count3[1] = 1;               // 1 line at a time
            count3[2] = num_pixels;
 
            status = nc_get_vara_float(geoGrp, latId, start, count, latpix);
            status = nc_get_vara_float(geoGrp, lonId, start, count, lonpix);
            status = nc_get_vara_float(geoGrp, latId, start2, count, latpix2);
            status = nc_get_vara_float(geoGrp, lonId, start2, count, lonpix2);
            status = nc_get_vara_float(obsGrp, Lt_blueId, start3, count3, Lt_pix[0]);
 
            if (sline % 100 == 1)  cout << "weight-binning sline..." << sline + 1 << endl;
 
            for (unsigned int pix = 0;pix < num_pixels - 1;pix++) {
 
                //across-track distance
                deltaphi = (latpix[pix] - latpix[pix + 1]) * degrad;
                deltalam = (lonpix[pix] - lonpix[pix + 1]) * degrad;
                aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(latpix[pix] * degrad) * cos(latpix[pix + 1] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
                bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
                dist_u = Re * bterm;         //horizontal distance Harversine in km
            //along-track distance
                deltaphi = (latpix[pix] - latpix2[pix]) * degrad;
                deltalam = (lonpix[pix] - lonpix2[pix]) * degrad;
                aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(latpix[pix] * degrad) * cos(latpix2[pix] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
                bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
                dist_v = Re * bterm;
 
                pix_size_u[sline][pix] = dist_u;
                pix_size_v[sline][pix] = dist_v;
 
                //pixel azimuth
                azpix = atan2(sin(deltalam) * cos(latpix2[pix] * degrad), cos(latpix[pix] * degrad) * sin(latpix2[pix] * degrad) - sin(latpix[pix] * degrad) * cos(latpix2[pix] * degrad) * cos(deltaphi));
                if (azpix > M_PI | azpix < -M_PI) {
                    cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "azpixc in degrees.." << azpix * 180 / M_PI << endl;
                    exit(1);
                }
                //  cout<<"azpix.."<<azpix*180/M_PI<<endl;
 
                /*  if(azpix<0.){
                        azpix=360+azpix*180/M_PI;
                    }
                  else azpix=azpix*180./M_PI;
                 */
                azpix = azpix * 180. / M_PI;
 
//                cout << "line.." << sline + 1 << "pix #:.." << pix + 1 << "pix size.U in km." << pix_size_u[sline][pix] << "pixsize.V in km." << pix_size_v[sline][pix] << "azpix before corners4.." << azpix << endl;
                //      pix_corners(dist_u,dist_v,azpix, sline,pix,latpix[pix],lonpix[pix]);   
//                            pix_corners3(l1cfile,dist_u,dist_v,azpix, sline,pix,latpix[pix],lonpix[pix],Lt_pix[0][pix],lat_asort,index_xy,lat_gd,lon_gd,lat_cgd,lon_cgd,areaFracBox,Ltfracsum,areabinsum,nobs_perbin);
                pix_corners4_l1c(l1cfile, l1cinput, dist_u, dist_v, azpix, sline, pix, latpix[pix], lonpix[pix], Lt_pix[0][pix], lat_asort, index_xy, lat_gd, lon_gd, lat_cgd, lon_cgd, areaFracBox, Ltfracsum, areabinsum, nobs_perbin);
//                pix_corners4_l1c2(l1cfile,l1cinput, dist_u, dist_v, azpix,  sline, pix,latpix[pix], lonpix[pix], Lt_pix[0][pix], gd_row, gd_col,lat_gd,lon_gd,areaFracBox,Ltfracsum,areafracsum,nobs_perbin) {
//                cout<<"Lt_pix[pix].."<<Lt_pix[0][pix]<<endl;//first blue channel
 
 
       //         exit(1);
            }//end pixels
    //     exit(1);
 
        }//end lines
 
//   exit(1);
        status = nc_close(ncid_L1B);
        check_err(status, __LINE__, __FILE__);
 
        delete[](latpix);
        delete[](lonpix);
        delete[](latpix2);
        delete[](lonpix2);
        delete[](Lt_pix);
 
 
        return 0;
    }
 
 
 
 
    int32_t L1C::xy_pixsize_sf2(const char* filename, l1c_filehandle* l1cfile, L1C_input* l1cinput, float** pix_size_u, float** pix_size_v, float** lat_gd, float** lon_gd, double** lat_cgd, double** lon_cgd, float** Ltfracsum, float** areabinsum, float** nobs_perbin)
    { //single file pixel size
        int32_t nbinx, num_gridlines;//number of gridlines to be processed
        int dimid, status;
        size_t start[] = { 0, 0 }, start2[] = { 0,0 };
        size_t count[] = { 1, 1 };
        size_t start3[] = { 0,0,0 }, count3[] = { 1, 1, 1 };
        float* latpix, * lonpix, * latpix2, * lonpix2, ** Lt_pix;
        float Re = 6378;
        int32_t NY = -1, NX = -1, NY1 = -1, NY2 = -1, c1 = 1;
        float deltaphi = 0., deltalam = 0., aterm = 0., bterm, dist_u = 0., dist_v = 0., azpix = 0.;
        float** lat_asort;
        short** index_xy;
        double areaFracBox[3][3];
 
        for (int ar = 0;ar < 3;ar++) {
            for (int ac = 0;ac < 3;ac++) {
                areaFracBox[ar][ac] = 0.;
                ac++;
            }
            ar++;
        }
 
        num_gridlines = l1cfile->num_gridlines;
        nbinx = l1cfile->nbinx;
        num_pixels = l1cfile->npix;
 
 
 
        //recompute number of gridlines based on lat limits -80 to 80 degrees  
     //asc orbit goes from negative to positive latitude....
        NY = num_gridlines;
        NX = nbinx;
 
        for (int i = 0; i < NY; i++) {
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= -80.) c1++;
                if (c1 == nbinx) {
                    NY1 = i;
                }
            }
            if (NY1 >= 0) break;
            c1 = 1;
        }
 
        for (int i = 0;i < NY; i++) {
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= 80.) {
                    NY2 = i - 1;
                }
            }
            if (NY2 >= 0) break;
        }
 
        l1cfile->NY1 = NY1;
        l1cfile->NY2 = NY2;
 
        NY = NY2 - NY1 + 1;
 
 
        latpix = (float*)calloc(num_pixels , sizeof(float));
        lonpix = (float*)calloc(num_pixels , sizeof(float));
        latpix2 = (float*)calloc(num_pixels , sizeof(float));
        lonpix2 = (float*)calloc(num_pixels , sizeof(float));
        index_xy = allocate2d_short(num_gridlines, nbinx);
        lat_asort = allocate2d_float(num_gridlines, nbinx);
 
        /*  for(int gd=0;gd<2;gd++){
           for(int k=0;k<nbinx;k++){
                 cout<<"gd.."<<gd+1<<"binx.."<<k+1<<"latgd..."<<lat_gd[gd][k]<<"longd..."<<lon_gd[gd][k]<<"latgd..."<<lat_cgd[gd][k]<<"longd..."<<lon_cgd[gd][k]<<endl;
             }}
          exit(1);
       */
        cout << "inside....xy_pixsize_sf2.." << "NY1.." << NY1 << "NY2.." << NY2 << endl;
 
        sbs2_sort_latgd(l1cfile, lat_gd, lat_asort, index_xy);
 
        cout << "filename..." << filename << endl;
        status = nc_open(filename, NC_NOWRITE, &ncid_L1B);
        if (status != NC_NOERR) {
             fprintf(stderr, "-fail nc_open.\n");
            exit(EXIT_FAILURE);            
        }
 
        //Open dimensions
        status = nc_inq_dimid(ncid_L1B, "number_of_scans", &dimid);
        if (status != NC_NOERR) {
            fprintf(stderr, "-E- Error reading number_of_scans.\n");
            exit(EXIT_FAILURE);
        }
        nc_inq_dimlen(ncid_L1B, dimid, &num_scans);
 
        //read line-by-line lat/lon/Lt
        status = nc_inq_grp_ncid(ncid_L1B, "geolocation_data", &geoGrp);
        check_err(status, __LINE__, __FILE__);
        status = nc_inq_grp_ncid(ncid_L1B, "observation_data", &obsGrp);
        check_err(status, __LINE__, __FILE__);
        //open geo data 
        status = nc_inq_varid(geoGrp, "latitude", &latId);//scans x velements
        check_err(status, __LINE__, __FILE__);
        status = nc_inq_varid(geoGrp, "longitude", &lonId);//scans x velements
        check_err(status, __LINE__, __FILE__);
 
        // num_blue_bands
        status = nc_inq_dimid(ncid_L1B, "blue_bands", &dimid);
        if (status != NC_NOERR) {
            fprintf(stderr, "-E- Error reading num_blue_bands.\n");
            exit(EXIT_FAILURE);
        }
        nc_inq_dimlen(ncid_L1B, dimid, &num_blue_bands);
 
        status = nc_inq_varid(obsGrp, "Lt_blue", &Lt_blueId);
        check_err(status, __LINE__, __FILE__);
 
        Lt_pix = allocate2d_float(num_blue_bands, num_pixels);
 
        //-----reading line by line-----------------------------------           
        for (unsigned int sline = 0;sline < num_scans - 1;sline++) {
            //lat and lon--
            start[0] = sline;
            start[1] = 0;
            start2[0] = sline + 1;
            start2[1] = 0;
            count[0] = 1;
            count[1] = num_pixels;               // 1 line at a time
 
            start3[0] = 0;
            start3[1] = sline;
            start3[2] = 0;
 
            count3[0] = num_blue_bands;
            count3[1] = 1;               // 1 line at a time
            count3[2] = num_pixels;
 
            status = nc_get_vara_float(geoGrp, latId, start, count, latpix);
            status = nc_get_vara_float(geoGrp, lonId, start, count, lonpix);
            status = nc_get_vara_float(geoGrp, latId, start2, count, latpix2);
            status = nc_get_vara_float(geoGrp, lonId, start2, count, lonpix2);
            status = nc_get_vara_float(obsGrp, Lt_blueId, start3, count3, Lt_pix[0]);
 
            if (sline % 100 == 1)  cout << "weight-binning sline..." << sline + 1 << endl;
 
            for (unsigned int pix = 0;pix < num_pixels - 1;pix++) {
 
                //across-track distance
                deltaphi = (latpix[pix] - latpix[pix + 1]) * degrad;
                deltalam = (lonpix[pix] - lonpix[pix + 1]) * degrad;
                aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(latpix[pix] * degrad) * cos(latpix[pix + 1] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
                bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
                dist_u = Re * bterm;         //horizontal distance Harversine in km
            //along-track distance
                deltaphi = (latpix[pix] - latpix2[pix]) * degrad;
                deltalam = (lonpix[pix] - lonpix2[pix]) * degrad;
                aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(latpix[pix] * degrad) * cos(latpix2[pix] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
                bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
                dist_v = Re * bterm;
 
                pix_size_u[sline][pix] = dist_u;
                pix_size_v[sline][pix] = dist_v;
 
                //pixel azimuth
                azpix = atan2(sin(deltalam) * cos(latpix2[pix] * degrad), cos(latpix[pix] * degrad) * sin(latpix2[pix] * degrad) - sin(latpix[pix] * degrad) * cos(latpix2[pix] * degrad) * cos(deltaphi));
                if (azpix > M_PI | azpix < -M_PI) {
                    cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "azpixc in degrees.." << azpix * 180 / M_PI << endl;
                    exit(1);
                }
                //  cout<<"azpix.."<<azpix*180/M_PI<<endl;
 
                /*  if(azpix<0.){
                        azpix=360+azpix*180/M_PI;
                    }
                  else azpix=azpix*180./M_PI;
                 */
                azpix = azpix * 180. / M_PI;
 
//                cout << "line.." << sline + 1 << "pix #:.." << pix + 1 << "pix size.U in km." << pix_size_u[sline][pix] << "pixsize.V in km." << pix_size_v[sline][pix] << "azpix before corners4.." << azpix << endl;
                //      pix_corners(dist_u,dist_v,azpix, sline,pix,latpix[pix],lonpix[pix]);   
//                            pix_corners3(l1cfile,dist_u,dist_v,azpix, sline,pix,latpix[pix],lonpix[pix],Lt_pix[0][pix],lat_asort,index_xy,lat_gd,lon_gd,lat_cgd,lon_cgd,areaFracBox,Ltfracsum,areabinsum,nobs_perbin);
                pix_corners4_l1c(l1cfile, l1cinput, dist_u, dist_v, azpix, sline, pix, latpix[pix], lonpix[pix], Lt_pix[0][pix], lat_asort, index_xy, lat_gd, lon_gd, lat_cgd, lon_cgd, areaFracBox, Ltfracsum, areabinsum, nobs_perbin);
//                pix_corners4_l1c2(l1cfile,l1cinput, dist_u, dist_v, azpix,  sline, pix,latpix[pix], lonpix[pix], Lt_pix[0][pix], gd_row, gd_col,lat_gd,lon_gd,areaFracBox,Ltfracsum,areafracsum,nobs_perbin) {
//                cout<<"Lt_pix[pix].."<<Lt_pix[0][pix]<<endl;//first blue channel
 
 
       //         exit(1);
            }//end pixels
    //     exit(1);
 
        }//end lines
 
//   exit(1);
        status = nc_close(ncid_L1B);
        check_err(status, __LINE__, __FILE__);
 
        delete[](latpix);
        delete[](lonpix);
        delete[](latpix2);
        delete[](lonpix2);
        delete[](index_xy);
        delete[](lat_asort);
        delete[](Lt_pix);
 
 
        return 0;
    }
 
 
 
 
    int32_t L1C::xy_pixsize(int swtd, l1c_filehandle* l1cfile, int16_t* swtd_id, int16_t* odir, int16_t* file_id, int16_t* nfiles_swt, float** binx_size_u, float** binx_size_v) {
        int16_t fi = 0;
        std::string str;
        const char* ptstr;
        int dimid, status;
        size_t start[] = { 0, 0 }, start2[] = { 0,0 };
        size_t count[] = { 1, 1 };
        float* latpix, * lonpix, * latpix2, * lonpix2;
        float Re = 6378;
        float deltaphi = 0., deltalam = 0., aterm = 0., bterm, dist_u = 0., dist_v = 0.;
        int32_t n_files = l1cfile->ifiles.size();
        num_pixels = l1cfile->npix;
 
        latpix = (float*)malloc(num_pixels * sizeof(float));
        lonpix = (float*)malloc(num_pixels * sizeof(float));
        latpix2 = (float*)malloc(num_pixels * sizeof(float));
        lonpix2 = (float*)malloc(num_pixels * sizeof(float));
 
        for (int findex = 0;findex < n_files;findex++) {
 
            //opening swath files----
            if (swtd == swtd_id[findex]) {
                cout << "Scanning lines in file.. for crossing swath..." << swtd << "file_id.." << file_id[findex] << "swt_id.." << swtd_id[findex] << endl;
                fi = file_id[findex];
                str = l1cfile->ifiles[fi - 1];
                ptstr = str.c_str();
                cout << "filename..." << ptstr << endl;
                status = nc_open(ptstr, NC_NOWRITE, &ncid_L1B);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- failed nc_open.\n");
                    exit(EXIT_FAILURE);
}
                //Open dimensions
                status = nc_inq_dimid(ncid_L1B, "number_of_scans", &dimid);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading number_of_scans.\n");
                    exit(EXIT_FAILURE);
                }
                nc_inq_dimlen(ncid_L1B, dimid, &num_scans);
 
                //read line-by-line lat/lon/Lt
                status = nc_inq_grp_ncid(ncid_L1B, "geolocation_data", &geoGrp);
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_grp_ncid(ncid_L1B, "observation_data", &obsGrp);
                check_err(status, __LINE__, __FILE__);
                //open geo data 
                status = nc_inq_varid(geoGrp, "latitude", &latId);//scans x velements
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(geoGrp, "longitude", &lonId);//scans x velements
                check_err(status, __LINE__, __FILE__);
 
                //-----reading line by line-----------------------------------           
                for (unsigned int sline = 0;sline < num_scans - 1;sline++) {
                    //lat and lon--
                    start[0] = sline;
                    start[1] = 0;
                    start2[0] = sline + 1;
                    start2[1] = 0;
                    count[0] = 1;
                    count[1] = num_pixels;               // 1 line at a time
 
                    status = nc_get_vara_float(geoGrp, latId, start, count, latpix);
                    status = nc_get_vara_float(geoGrp, lonId, start, count, lonpix);
                    status = nc_get_vara_float(geoGrp, latId, start2, count, latpix2);
                    status = nc_get_vara_float(geoGrp, lonId, start2, count, lonpix2);
 
 
 
                    for (unsigned int pix = 0;pix < num_pixels - 1;pix++) {
                        //across-track distance
                        deltaphi = (latpix[pix] - latpix[pix + 1]) * degrad;
                        deltalam = (lonpix[pix] - lonpix[pix + 1]) * degrad;
                        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(latpix[pix] * degrad) * cos(latpix[pix + 1] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
                        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
                        dist_u = Re * bterm;         //horizontal distance Harversine in km
                    //along-track distance
                        deltaphi = (latpix[pix] - latpix2[pix]) * degrad;
                        deltalam = (lonpix[pix] - lonpix2[pix]) * degrad;
                        aterm = sin(deltaphi / 2) * sin(deltaphi / 2) + cos(latpix[pix] * degrad) * cos(latpix2[pix] * degrad) * sin(deltalam / 2) * sin(deltalam / 2);
                        bterm = 2 * atan2(sqrt(aterm), sqrt(1 - aterm));
                        dist_v = Re * bterm;
 
                        binx_size_u[sline][pix] = dist_u;
                        binx_size_v[sline][pix] = dist_v;
                        //     cout<<"pix #:.."<<pix+1<<"binxsize.U in km."<<binx_size_u[sline][pix]<<"binxsize.V in km."<<binx_size_v[sline][pix]<<endl;
                          //   cout<<"pix #:.."<<pix+1<<"latpix1.."<<latpix[pix]<<"latpix2.."<<latpix2[pix]<<endl;        
                    }//end pixels
                    exit(1);
                }//end scanlines
                status = nc_close(ncid_L1B);
                check_err(status, __LINE__, __FILE__);
            }//end if swtd
        }//end for files
 
        delete[](latpix);
        delete[](lonpix);
        delete[](latpix2);
        delete[](lonpix2);
 
        //   exit(1);
 
        return 0;
    }
 
 
 
 
 
int32_t L1C::write_L1C_granule(int swtd, l1c_filehandle* l1cfile, L1C_input* l1cinput,double *tmgv,float** lat_gd, float** lon_gd){
        int32_t num_gridlines, nbinx, NY1 = -1, NY2 = -1;
        int  ncid_out,x_dimid, y_dimid, varid1, varid2, status;
        int NDIMS=2;
        int dimids[NDIMS];
        int32_t NX, NY;
        int grp_coor;
        const char* filename_lt;
        float **lat_out=nullptr,**lon_out=nullptr;
//        float **lt_out=nullptr;
        int NVIEWS, NBANDS,v_dimid,b_dimid,asc_mode=-1;
        string senstr;
        double tg_ini,tg_end;
        int numgran;
        double tgridline,tfile_ini_sec;
        int16_t *granid=nullptr;
        int32_t gransize;
        short **gdindex=nullptr;
        double **gdtime=nullptr;
        int16_t y_ini,mo_ini,d_ini,h_ini,mi_ini,y_end,mo_end,d_end,h_end,mi_end;
        double sec_ini,sec_end;
        string tswt_ini,tswt_end,tswt_ini_file;
        int logoff=-1;
//        int gd_per_gran=-1;
 
 
 
        if(l1cinput->sensor==1){
             senstr="SPEXone";
             l1cfile->nbinx=20;
              }
        else if (l1cinput->sensor==2){
            senstr="OCI";
            l1cfile->nbinx=514;
             }
        else if (l1cinput->sensor==3){
            senstr="HARP2";
            l1cfile->nbinx=452;
            }
        else{cout<<"sensor by default is OCI option 2....."<<endl;
            senstr="OCI";
             l1cfile->nbinx=514;      
          }
 
 
        //this is swath stuff, create_socea function
/*
        tswt_ini=l1cfile->tswt_ini;
        tswt_end=l1cfile->tswt_end;
        tswt_ini_file=l1cfile->tswt_ini_file;
*/
 
        cout<<"tswt_ini..."<<tswt_ini<<endl;
        cout<<"tswt_end..."<<tswt_end<<endl;
 
 
        asc_mode=l1cfile->orb_dir;
        gransize=l1cfile->gransize;
        num_gridlines = l1cfile->num_gridlines;
        cout<<"# gridlines...."<<num_gridlines<<"gransize.."<<gransize<<endl;
 
        granid=(int16_t*)calloc(num_gridlines,sizeof(int16_t));
 
        numgran=l1cfile->numgran;
    //    gd_per_gran=l1cfile->gd_per_gran;
        nbinx = l1cfile->nbinx;
        tfile_ini_sec=l1cfile->tfile_ini_sec;
 
        gdtime = allocate2d_double(numgran,2);
        gdindex= allocate2d_short(numgran,2);
 
        //first granule----
        tg_ini=tfile_ini_sec;//always unix time
        tg_end=tg_ini+gransize*60;
 
 
        for(int i=0;i<num_gridlines-1;i++){   
          granid[i]=-1;  
          }
 
        for(int i=0;i<numgran;i++){
             for(size_t j=0;j<2;j++){
            gdtime[i][j]=-1;
            gdindex[i][j]=-1;
        }}
 
        
       int neg=0,gmin=-1,c=0;
       for(int gran=0;gran<numgran;gran++){
        for(int i=0;i<num_gridlines-1;i++){
            tgridline=tfile_ini_sec+tmgv[i];
          if(tgridline>=tg_ini && tgridline<=tg_end){
               granid[i]=gran+1;
               if(gmin<0){//first index
                  gdtime[c][0]=tg_ini;
                  gdtime[c][1]=tg_end;
                  gdindex[c][0]=i;
                  gmin=1;
//                  cout<<"c.."<<c<<"i.."<<i<<endl;
                         }
                  gdindex[c][1]=i;                                 
                          
         //    cout<<"gd#."<<i+1<<"tgridline..."<<tgridline<<"gran#.."<<gran+1<<endl;
   /*           
             unix2ymdhms(tg_ini,&y_ini,&mo_ini,&d_ini, &h_ini, &mi_ini, &sec_ini);                         
             unix2ymdhms(tg_end,&y_end,&mo_end,&d_end, &h_end, &mi_end, &sec_end);
             cout<<"year ini"<<y_ini<<"month ini.."<<mo_ini<<"day ini"<<d_ini<<"hour ini"<<h_ini<<"min ini"<<mi_ini<<"sec ini"<<sec_ini<<endl;
             cout<<"year end"<<y_end<<"month end.."<<mo_end<<"day end"<<d_end<<"hour end"<<h_end<<"min end"<<mi_end<<"sec end"<<sec_end<<endl;             
  */           
               }
 
 
          if(tmgv[i]<0 && gran==0){
                 neg++;
          //       cout<<"neg time at gd#"<<i+1<<endl;
                  }
          }
        tg_ini=tg_end;
        tg_end=tg_ini+gransize*60;
        gmin=-1;
        c++;       
 
 
        if(tg_ini>tgridline){
            cout<<"gridlines with negative time..."<<neg<<endl;
            break;}
 
       }
 
//-------------------------------------------------------------
/*
        for(size_t gd=0;gd<num_gridlines-1;gd++){
               cout<<"gd#.."<<gd+1<<"granid..#"<<granid[gd]<<endl;       
      }
 
        for(size_t i=0;i<numgran;i++){
             for(size_t j=0;j<2;j++){
           cout<<"gran#.."<<i+1<<"gdindex.."<<gdindex[i][j]<<endl;       
           cout<<"time bounds..."<<j+1<<"gdtime.."<<gdtime[i][j]<<endl;
        }}
 
*/
 
//exit(1);
 
 
 
/*
//--------- COUNT GDLINES PER GRANULE ----------
 
  size_t granule=1,g=0;
  size_t i=0,gdline=0,tot=0;
 
  while(g<numgran-1){
 
 
   while(i<num_gridlines-1){
 
    if (granule==granid[i]){
        gdline++;
        tot++;
    //    cout<<"granid..#.."<<granid[i]<<"for gridline #.."<<i+1<<endl;       
         }
    
      if(i==num_gridlines-2){
        cout<<"done with granule #..."<<granule<<"# gridlines = "<<gdline<<"tot.."<<tot<<endl;
        granule++;
        g++;
        i=num_gridlines;
        gdline=0;
         }              
     i++;
   }
  i=0;
  }//end while
 
*/
 
int16_t ngridlines,totlines=0;
//write files with granid>0 ---------------------
    for(int gran=0;gran<numgran;gran++){
       if(gdtime[gran][0]>0){
           cout<<"gran #..."<<gran+1<<endl;
 
        tg_ini=gdtime[gran][0];
        tg_end=gdtime[gran][1];
 
        unix2ymdhms(tg_ini,&y_ini,&mo_ini,&d_ini, &h_ini, &mi_ini, &sec_ini);
        unix2ymdhms(tg_end,&y_end,&mo_end,&d_end, &h_end, &mi_end, &sec_end);
 
        //# gridlines per granule
        //gridline index 0-num_gridlines
        ngridlines=gdindex[gran][1]-gdindex[gran][0]+1;
        totlines+=ngridlines;
        cout<<"ngridlines..."<<ngridlines<<"tot gridlines..."<<totlines<<endl;
 
        
        std::string timestr,missionstr,fname_out, pathstr,monstr, daystr, yearstr, secstr,mistr,hstr,prodstr, gdstr, swtstr, swtnum, extstr,ofilestr,dirstr,datetimestr1,datetimestr2,fdatetimestr1;
 
        if(asc_mode==1) dirstr="Ascending";
        else if(asc_mode==0) dirstr="Descending";
 
//time coverage start----
        pathstr = "out/";
        missionstr="PACE";
        extstr = ".nc";       
 
        secstr = std::to_string(sec_ini);
        mistr = std::to_string(mi_ini);
        hstr = std::to_string(h_ini);
        daystr = std::to_string(d_ini);
        monstr = std::to_string(mo_ini);    
        yearstr = std::to_string(y_ini);
 
        int length = (int) floor( log10 (mo_ini) ) + 1;
        if(length==1) monstr="0"+monstr;
        length = (int) floor( log10 (d_ini) ) + 1;
        if(length==1) daystr="0"+daystr;
 
 
 
        if(h_ini==0) logoff=1; else logoff=0;
        length = (int) floor( log10 (h_ini+logoff)) + 1;
        if(length==1) hstr="0"+hstr;
        if(mi_ini==0) logoff=1; else logoff=0;
        length = (int) floor( log10 (mi_ini+logoff)) + 1;
        if(length==1) mistr="0"+mistr;
        if(sec_ini==0) logoff=1; else logoff=0;
        length = (int) floor( log10 (round(sec_ini+logoff))) + 1;
        if(length==1) secstr="0"+secstr;
 
 
        fdatetimestr1=yearstr+monstr+daystr+"T"+hstr+mistr+secstr.substr(0,2)+"Z";
        datetimestr1=yearstr+"-"+monstr+"-"+daystr+"T"+hstr+":"+mistr+":"+secstr.substr(0,2)+"Z";
//time coevrage end----
//
        secstr = std::to_string(sec_end);
        mistr = std::to_string(mi_end);
        hstr = std::to_string(h_end);
        daystr = std::to_string(d_end);
        monstr = std::to_string(mo_end);
        yearstr = std::to_string(y_end);
 
        length = (int) floor( log10 (mo_end) ) + 1;
        if(length==1) monstr="0"+monstr;
        length = (int) floor( log10 (d_end) ) + 1;
        if(length==1) daystr="0"+daystr;
 
         if(h_end==0) logoff=1; else logoff=0;
        length = (int) floor( log10 (h_end+logoff)) + 1;
        if(length==1) hstr="0"+hstr;
        if(mi_end==0) logoff=1; else logoff=0;
        length = (int) floor( log10 (mi_end+logoff)) + 1;
        if(length==1) mistr="0"+mistr;
        if(sec_end==0) logoff=1; else logoff=0;
        length = (int) floor( log10 (round(sec_end+logoff))) + 1;
        if(length==1) secstr="0"+secstr;
 
 
        datetimestr2=yearstr+"-"+monstr+"-"+daystr+"T"+hstr+":"+mistr+":"+secstr.substr(0,2)+"Z";
      
        fname_out=pathstr+"PACE_"+senstr+"."+fdatetimestr1+".L1C.5.2km.nc";
   
  //      tswt_ini=y_swt+"-"+mo_swt+"-"+d_swt+"T"+h_swt+":"+mi_swt+":"+s_swt2.substr(0,2)+"Z";
 
 
 
        cout<<"granule filename.."<<fname_out<<endl;
 
 
 
 
  /*     
     //   string datestr=date;
 
        auto t = std::time(nullptr);
        auto tm = *std::localtime(&t);
        std::ostringstream oss,oss2;
        oss << std::put_time(&tm, "%d-%m-%Y %H-%M-%S") << std::endl;
      //  cout<<"current datetime.n UTC."<<datestr<<endl;
        auto datestr = oss.str();
        cout<<"date.."<<datestr.substr(0,2)<<endl;
 
       time_t rawtime;
       time (&rawtime);
       string datestr2=ctime (&rawtime);
 
 
//        oss2<<system("date")<<endl;
//        string datestr2=oss2.str();
        cout<<"date.."<<datestr2.substr(0,10)<<endl;
//        exit(1);
*/
 
        
        string  ATT_NAME="Units", ATT_VAL="degrees",GATT_NAME1="Title",GATT_VAL1="PACE OCI Level-1C Data",GATT_NAME2="instrument",GATT_VAL2="OCI",GATT_NAME3="processing_version",GATT_VAL3="V1.0",GATT_NAME4="Conventions",GATT_VAL4="CF-1.6";
        string GATT_NAME5="institution",GATT_VAL5="NASA Goddard Space Flight Center, Ocean Biology Processing Group",GATT_NAME6="license",GATT_VAL6="http://science.nasa.gov/earth-science/earth-science-data/data-information-policy/";
        string GATT_NAME7="naming_authority",GATT_VAL7="gov.nasa.gsfc.sci.oceancolor",GATT_NAME8="keywords_vocabulary",GATT_VAL8="NASA Global Change Master Directory (GCMD) Science Keywords";
        string GATT_NAME9="stdname_vocabulary",GATT_VAL9="NetCDF Climate and Forecast (CF) Metadata Convention",GATT_NAME10="creator_name",GATT_VAL10="NASA/GSFC",GATT_NAME11="creator_email",GATT_VAL11="data@oceancolor.gsfc.nasa.gov";
        string GATT_NAME12="creator_url",GATT_VAL12="http://oceancolor.gsfc.nasa.gov",GATT_NAME13="project",GATT_VAL13="PACE Project",GATT_NAME14="publisher_name",GATT_VAL14="NASA/GSFC";
        string GATT_NAME15="publisher_email",GATT_VAL15="data@oceancolor.gsfc.nasa.gov",GATT_NAME16="publisher_url",GATT_VAL16="http://oceancolor.gsfc.nasa.gov",GATT_NAME17="processing_level",GATT_VAL17="L1C";
        string GATT_NAME18="cdm_data_type",GATT_VAL18="swath",GATT_NAME19="orbit_number",GATT_VAL19="xxx",GATT_NAME20="history",GATT_VAL20="",GATT_NAME21="CDL_version_date",GATT_VAL21="2021-09-10",GATT_NAME22="product_name",GATT_VAL22=fname_out;
        string GATT_NAME23="startDirection",GATT_VAL23=dirstr,GATT_NAME24="endDirection",GATT_VAL24=dirstr,GATT_NAME25="time_coverage_start",GATT_VAL25=datetimestr1,GATT_NAME26="time_coverage_end",GATT_VAL26=datetimestr2,GATT_NAME27="date_created",GATT_VAL27="2022-03-25T15:12:41Z",GATT_NAME28="sun_earth_distance",GATT_VAL28="0.990849042172323",GATT_NAME29="terrain_data_source",GATT_VAL29="",GATT_NAME30="spectral_response_function",GATT_VAL30="",GATT_NAME31="systematic_uncertainty_model",GATT_VAL31="",GATT_NAME32="nadir_bin",GATT_VAL32="12345",GATT_NAME33="bin_size_at_nadir",GATT_VAL33="5.2km2";
 
 
        l1cfile->gridname = fname_out.c_str();
        filename_lt = fname_out.c_str();
 
        cout<<"creating file for L1C coor..."<<filename_lt<<endl;
 
       
        if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
            check_err(status, __LINE__, __FILE__);
        //define dims
     // Define the dimensions,vars and attributes at the root level
        NY = ngridlines;
        NX = nbinx;
        //subset lat and lon arrays
        NY1=gdindex[gran][0];
        NY2=gdindex[gran][1];
 
        lat_out = allocate2d_float(NY, NX);
        lon_out = allocate2d_float(NY, NX);
 
       int cc=0;
        for (int i = NY1; i < NY2 + 1; i++) {
            for (int j = 0; j < NX; j++) {
                lat_out[cc][j] = lat_gd[i][j];
                lon_out[cc][j] = lon_gd[i][j];
            }
            cc++;
        }
 
        if(l1cinput->sensor==1){
            senstr="SPEXone";
            GATT_VAL2="SPEXone";
            GATT_VAL32="3567";
            NVIEWS=5;
            NBANDS=400;
             }
        else if (l1cinput->sensor==2){
            senstr="OCI";
            GATT_VAL2="OCI";
            GATT_VAL32="635";
            NVIEWS=2;
            NBANDS=249;
             }
        else if (l1cinput->sensor==3){
            senstr="HARP2";
            GATT_VAL2="HARP";
            GATT_VAL32="127";
            NVIEWS=90;
            NBANDS=1;
              }
        else{
            cout<<"sensor by default is OCI option 2....."<<endl;
            senstr="OCI";
            GATT_VAL2="OCI";
            GATT_VAL32="635";
            NVIEWS=2;
            NBANDS=249;
             }
 
//        lt_out = allocate2d_float(NY, NX);
  //DEF DIMENSIONS
        if ((status = nc_def_dim(ncid_out, "bins_across_track", NX, &x_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "bins_along_track", NY, &y_dimid)))
            check_err(status, __LINE__, __FILE__);
        //dims for output var
        dimids[0] = y_dimid;
        dimids[1] = x_dimid;
        NDIMS=2;
        if ((status = nc_def_dim(ncid_out, "number_of_views", NVIEWS, &v_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "intensity_bands_per_view", NBANDS, &b_dimid)))
            check_err(status, __LINE__, __FILE__);
        //define attributes
//       if (nc_put_att_text(ncid_out, varid1, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
//           check_err(status, __LINE__, __FILE__);
//       if (nc_put_att_text(ncid_out, varid2, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
//           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME1.c_str(), strlen(GATT_VAL1.c_str()),
          GATT_VAL1.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME2.c_str(), strlen(GATT_VAL2.c_str()),
          GATT_VAL2.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME3.c_str(), strlen(GATT_VAL3.c_str()),
          GATT_VAL3.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME4.c_str(), strlen(GATT_VAL4.c_str()),
          GATT_VAL4.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME5.c_str(), strlen(GATT_VAL5.c_str()),
          GATT_VAL5.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME6.c_str(), strlen(GATT_VAL6.c_str()),
          GATT_VAL6.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME7.c_str(), strlen(GATT_VAL7.c_str()),
          GATT_VAL7.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME8.c_str(), strlen(GATT_VAL8.c_str()),
          GATT_VAL8.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME9.c_str(), strlen(GATT_VAL9.c_str()),
          GATT_VAL9.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME10.c_str(), strlen(GATT_VAL10.c_str()),
          GATT_VAL10.c_str()))
           check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME11.c_str(), strlen(GATT_VAL11.c_str()),
          GATT_VAL11.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME12.c_str(), strlen(GATT_VAL12.c_str()),
          GATT_VAL12.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME13.c_str(), strlen(GATT_VAL13.c_str()),
          GATT_VAL13.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME14.c_str(), strlen(GATT_VAL14.c_str()),
          GATT_VAL14.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME15.c_str(), strlen(GATT_VAL15.c_str()),
          GATT_VAL15.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME16.c_str(), strlen(GATT_VAL16.c_str()),
          GATT_VAL16.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME17.c_str(), strlen(GATT_VAL17.c_str()),
          GATT_VAL17.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME18.c_str(), strlen(GATT_VAL18.c_str()),
          GATT_VAL18.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME19.c_str(), strlen(GATT_VAL19.c_str()),
          GATT_VAL19.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME20.c_str(), strlen(GATT_VAL20.c_str()),
          GATT_VAL20.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME21.c_str(), strlen(GATT_VAL21.c_str()),
          GATT_VAL21.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME22.c_str(), strlen(GATT_VAL22.c_str()),
          GATT_VAL22.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME23.c_str(), strlen(GATT_VAL23.c_str()),
          GATT_VAL23.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME24.c_str(), strlen(GATT_VAL24.c_str()),
          GATT_VAL24.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME25.c_str(), strlen(GATT_VAL25.c_str()),
          GATT_VAL25.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME26.c_str(), strlen(GATT_VAL26.c_str()),
          GATT_VAL26.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME27.c_str(), strlen(GATT_VAL27.c_str()),
          GATT_VAL27.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME28.c_str(), strlen(GATT_VAL28.c_str()),
          GATT_VAL28.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME29.c_str(), strlen(GATT_VAL29.c_str()),
          GATT_VAL29.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME30.c_str(), strlen(GATT_VAL30.c_str()),
          GATT_VAL30.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME31.c_str(), strlen(GATT_VAL31.c_str()),
          GATT_VAL31.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME32.c_str(), strlen(GATT_VAL32.c_str()),
          GATT_VAL32.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME33.c_str(), strlen(GATT_VAL33.c_str()),
          GATT_VAL33.c_str()))
          check_err(status, __LINE__, __FILE__);
 
      //define groups                  check_err(status, __LINE__, __FILE__);
       if ((status = nc_def_grp(ncid_out, "geolocation_data", &grp_coor)))  //netcdf-4
          check_err(status, __LINE__, __FILE__);
        //def var
        if ((status = nc_def_var(grp_coor, "latitude", NC_FLOAT, NDIMS,
                dimids, &varid1)))
                check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_var(grp_coor, "longitude", NC_FLOAT, NDIMS,
                dimids, &varid2)))
                check_err(status, __LINE__, __FILE__);
    //leave define mode-----------------------
        if ((status = nc_enddef(grp_coor))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
 
 
        //writing the whole thing
        if ((status = nc_put_var_float(grp_coor, varid1, &lat_out[0][0])))
            check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_put_var_float(grp_coor, varid2, &lon_out[0][0])))
            check_err(status, __LINE__, __FILE__);
 
 
 
//define attributes of vars in groups
//UNITS in degrees ----
        if (nc_put_att_text(grp_coor, varid1, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
         check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(grp_coor, varid2, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
 
 
//close file
        if ((status = nc_close(ncid_out)))
           check_err(status, __LINE__, __FILE__);
 
   
 
       }//granule >0
      }//end granule loop
 
 
 
 
 
 
 
 
     if(gdtime!=nullptr)
         delete[] (gdtime);
     gdtime=nullptr;
 
      if(gdindex!=nullptr)
         delete[] (gdindex);
     gdindex=nullptr;
 
     if(granid!=nullptr)
         delete[] (granid);
     granid=nullptr;
 
     
return 0;
}    
 
 
 
//granules processing
int32_t L1C::across_gridlines_l1c_vec3(int swtd, l1c_filehandle* l1cfile, L1C_input* l1cinput,float* lati2, float* loni2, float** lat_gd, float** lon_gd, float* az_east) {
        int32_t num_gridlines, nbinx, NY1 = -1, NY2 = -1, c1 = 1;
        float lat1_l, lat1_r, lon1_l, lon1_r, lat2, lon2, dlambda, az_r, az_l, h,  *lati_l, *loni_l, *lati_r, *loni_r, htot = 0.,az=0.;
        int  ncid_out,x_dimid, y_dimid, varid1, varid2, status;
        int NDIMS=2;
        int dimids[NDIMS];
        int32_t NX, NY;
        int16_t selyear = -1, selmon = -1, selday = -1;
        double  latih, lonih, latih2, lonih2, res1, res2;
        float gres;
        int fnan1=0, fnan2=0, fnan3=0, fnan4=0;
        float latfirst = -999;
        int badline = 0;
        int grp_coor;
        const char* filename_lt;
        float **lat_out=nullptr,**lon_out=nullptr;
//        float **lt_out=nullptr;
        int NVIEWS, NBANDS,v_dimid,b_dimid,asc_mode=-1;
        string senstr,tswt_ini,tswt_end;
        
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
 
 
        if(l1cinput->sensor==1) senstr="SPEXone";
        else if (l1cinput->sensor==2) senstr="OCI";
        else if (l1cinput->sensor==3) senstr="HARP";
        else{cout<<"sensor by default is OCI option 2....."<<endl;
            senstr="OCI"; }
 
        //compute azimuth angle for each along-track position (nadir pixel or centered swath pixel) of the swath
        //azimuth angle in rads
        //lon+540/360-180 is a normalization factor for -180 to 180 degrees   
        num_gridlines = l1cfile->num_gridlines;
        num_pixels = l1cfile->npix;
        nbinx = l1cfile->nbinx;
 
        tswt_ini=l1cfile->tswt_ini;
        tswt_end=l1cfile->tswt_end;
 
 
        lati_l = (float*)calloc(nbinx / 2 , sizeof(float));
        lati_r = (float*)calloc(nbinx / 2 , sizeof(float));
        loni_l = (float*)calloc(nbinx / 2 , sizeof(float));
        loni_r = (float*)calloc(nbinx / 2 , sizeof(float));
 
      //big loop
 
        int gd = 0;
        asc_mode=l1cfile->orb_dir;
 
 
        //compute mean az_east---
        float sum = 0., tot = 0.;
        size_t azc = 0;
        for (int i = 0;i < num_gridlines - 2;i++) {
 
        //    cout<<"gd#.."<<i+1<<"lati2[i].."<<lati2[i]<<endl;
 
            //assign central positions---
            lat1_l = lati2[i] * M_PI / 180.;
            lat1_r = lati2[i] * M_PI / 180.;
            lat2 = lati2[i + 1] * M_PI / 180.;
            lon1_l = loni2[i] * M_PI / 180.;
            lon1_r = loni2[i] * M_PI / 180.;
            lon2 = loni2[i + 1] * M_PI / 180.;
 
            dlambda = (lon2 - lon1_l);
            //bearing---
            //make sure there are not NAN values ----------
            az = atan2(sin(dlambda) * cos(lat2), cos(lat1_l) * sin(lat2) - sin(lat1_l) * cos(lat2) * cos(dlambda));
 
            //     cout<<lat2<<"..."<<lat1_l<<".."<<dlambda<<az*180/M_PI<<endl;
            if (az > M_PI || az < -M_PI) {
                cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "az in degrees.." << az * 180 / M_PI << endl;
                exit(1);
            }
            if (isnan(az) < 1) {
                //       cout<<"az.."<<az<<"azcount"<<azc<<endl;
                az_r = (az + M_PI / 2.);
                az_east[i] = az_r * 180. / M_PI;
                if (az_east[i] < 0.0001 && az_east[i]>0) az_east[i] = 0.0;
                sum = az_east[i];
                tot += sum;
                azc++;
            }
            else {
                az_east[i] = NAN;
                 }
        }
        float mean_az_east = tot / (azc);
 
        cout << "recomputing mean_az_east..(based on second interp rather than first interp)" << mean_az_east << "num_gridlines.." << num_gridlines-2 << endl;
 
 
        for (int j = 0;j < num_gridlines - 2;j++) {
            az_east[j] = mean_az_east;
        }
 
        l1cfile->mean_az_east = mean_az_east;
 
        for (int i = 0;i < num_gridlines - 2;i++) {
 
            if (i % 1 == 0) {
                //assign central positions---
                lat1_l = lati2[i] * M_PI / 180.;
                lat1_r = lati2[i] * M_PI / 180.;
                lat2 = lati2[i + 1] * M_PI / 180.;
                lon1_l = loni2[i] * M_PI / 180.;
                lon1_r = loni2[i] * M_PI / 180.;
                lon2 = loni2[i + 1] * M_PI / 180.;
 
                dlambda = (lon2 - lon1_l);
 
 
                gres = (l1cinput->gres) * 1000; //grid resolution in meters
 
               //bearing---
               //this is Harverside--law f cosines is more accurate---
                az = atan2(sin(dlambda) * cos(lat2), cos(lat1_l) * sin(lat2) - sin(lat1_l) * cos(lat2) * cos(dlambda));
                if (az > M_PI || az < -M_PI) {
                    cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "az in degrees.." << az * 180 / M_PI << endl;
                    exit(1);
                }
 
                //compute RIGHT across-gridline pixels---
                for (int k = 0;k < (nbinx / 2);k++) {
                    h = (l1cinput->gres);//distance between along positions in km, must be 5.2 k m for L1C
                    if (k == 0) h /= 2;//if nadpix
                    htot += h;
 
                    //right pixels---
                    az_r = mean_az_east * degrad;
 
                    //left pixels---
                    az_l = az_r - M_PI;
 
                         //bearing should be always positive (clockwise) before pixel location calculation based on Harverside---
                    if (az_r < 0.) {
                        az_r = 360 + az_r * 180 / M_PI;
                        az_r = az_r * M_PI / 180;
                    }
 
                    if (az_l < 0.) {
                        az_l = 360 + az_l * 180 / M_PI;
                        az_l = az_l * M_PI / 180;
                    }
 
                    geod.Direct(lat1_r * 180 / M_PI, lon1_r * 180 / M_PI, az_r * 180 / M_PI, gres, latih, lonih);
                    geod.Inverse(lat1_r * 180 / M_PI, lon1_r * 180 / M_PI, latih, lonih, res1);
 
                
                    fnan1 = isnan(latih);
                    fnan2 = isnan(lonih);
                    lati_r[k] = latih;
                    loni_r[k] = lonih;
                    //     cout<<"righside.."<<latih<<"..."<<lonih<<"res1"<<res1<<endl;
 
                    lat1_r = lati_r[k] * M_PI / 180;
                    lon1_r = loni_r[k] * M_PI / 180;
 
                    geod.Direct(lat1_l * 180 / M_PI, lon1_l * 180 / M_PI, az_l * 180 / M_PI, gres, latih2, lonih2);
                    geod.Inverse(lat1_l * 180 / M_PI, lon1_l * 180 / M_PI, latih2, lonih2, res2);
 
           /*          if(i==500){
                       cout<<"gd#..."<<i+1<<"az_r.."<<az_r* 180 / M_PI<<"az_l.."<<az_l* 180 / M_PI<<endl;
                       cout<<"lat1_r.."<<lat1_r<<"lon1_r.."<<lon1_r<<"latih.."<<latih<<"lonih.."<<lonih<<"res1.."<<res1<<endl;
                       cout<<"lat1_l.."<<lat1_l<<"lon1_l.."<<lon1_l<<"latih2.."<<latih2<<"lonih2.."<<lonih2<<"res2.."<<res2<<endl;
                    }
                  */  
 
                    fnan3 = isnan(latih2);
                    fnan4 = isnan(lonih2);
                    lati_l[k] = latih2;
                    loni_l[k] = lonih2;
                    //     cout<<"leftside.."<<latih2<<"..."<<lonih2<<"res2"<<res2<<endl;
 
                    lat1_l = lati_l[k] * M_PI / 180;
                    lon1_l = loni_l[k] * M_PI / 180;
 
                      //right swath side------------- //we tolerate +- 6 m error
                    if (asc_mode==1 && lati2[i]>lati2[i+1] || asc_mode==0 && lati2[i]<lati2[i+1] || fnan1 > 0 || fnan2 > 0 || res1 > (gres + 6) || res1 < (gres - 6)) { //nan values
                        badline++;
                        if (badline == 1) {
                            latfirst = lati2[i];
                        }
 
                        cout << "bad interpolation - missing orbital data at near nadir grid cell..NAN right side of line.." << i + 1 << "corresponding to lat..."<<latfirst <<"lati2[i].."<<lati2[i]<<endl;
                        cout<<"gd.."<<gd+1<<"XBIN.."<<k+1<<"lati_l[k]"<<lati_l[k]<<"loni_l[k]"<<loni_l[k]<<"lati_r[k]"<<lati_r[k]<<"loni_r[k]"<<loni_r[k]<<endl;
                        
                        lati2[i] = NAN;
                        loni2[i] = NAN;
 
                        for (int k = 0;k < (nbinx / 2);k++) {
                            lat_gd[gd][k + nbinx / 2] = NAN;
                            lon_gd[gd][k + nbinx / 2] = NAN;
                        }
                        //       cout<<"nan value.right.."<<endl;
                    }
                    else {
                        lat_gd[gd][k + nbinx / 2] = latih;
                        lon_gd[gd][k + nbinx / 2] = lonih;
                }
 
                    //left side
                    if (asc_mode==1 && lati2[i]>lati2[i+1] || asc_mode==0 && lati2[i]<lati2[i+1] || fnan3 > 0 || fnan4 > 0 || res2 > (gres + 6) || res2 < (gres - 6)) {
                        //     if(fnan3>0 | fnan4>0 |  res2>(gres+6) | res2<(gres-6)){
                        cout << "bad interpolation - missing orbital data at near nadir grid cell..NAN left side of line.." << i + 1 << endl;
                        cout<<"gd.."<<gd+1<<"XBIN.."<<k+1<<"lati_l[k]"<<lati_l[k]<<"loni_l[k]"<<loni_l[k]<<"lati_r[k]"<<lati_r[k]<<"loni_r[k]"<<loni_r[k]<<"lati2[i].."<<lati2[i]<<endl;
                        
                        lati2[i] = NAN;
                        loni2[i] = NAN;
                        for (int k = 0;k < (nbinx / 2);k++) {
                            lat_gd[gd][nbinx / 2 - 1 - k] = NAN;//as k increases we are farther away from nadpix or along-track position---
                            lon_gd[gd][nbinx / 2 - 1 - k] = NAN;
                         }
                        //       cout<<"nan value.left.."<<endl;
                    }
                    else {
                        lat_gd[gd][nbinx / 2 - 1 - k] = latih2;//as k increases we are farther away from nadpix or along-track position---
                        lon_gd[gd][nbinx / 2 - 1 - k] = lonih2;
                       }
                fnan1=0;
                fnan2=0;
                fnan3=0;
                fnan4=0;
 
                }//end pixel loop
 
 
                htot = 0;
                gd++;
            }//end if every 100 gd
        }//end gridlines loop
        cout << "`L1C gridding successful!......................................." << endl;
 
 
 //        granid=1;
 //        write_L1C_granule(swtd, granid,l1cfile,l1cinput,lat_gd, lon_gd);
 //        exit(1);
 
//---- writing results -------------------------------------------
//--------------------------------------------------------------
        
         float lontemp = 0.;
        selday = l1cinput->selday;
        selmon = l1cinput->selmon;
        selyear = l1cinput->selyear;
 
        std::string timestr,missionstr,fname_out, pathstr,monstr, daystr, yearstr, prodstr, gdstr, swtstr, swtnum, extstr,ofilestr,dirstr;
 
        if(asc_mode==1) dirstr="Ascending";
        else if(asc_mode==0) dirstr="Descending";
 
 
 
        pathstr = "out/";
        missionstr="PACE";       
        monstr = std::to_string(selmon);
        daystr = std::to_string(selday);
        yearstr = std::to_string(selyear);
        timestr="T00:00:00Z";
        prodstr = "L1Cgrid_";        
        swtstr = "_swt";
        swtnum = std::to_string(swtd);
        extstr = ".nc";
        ofilestr=std::string(l1cinput->ofile);
 
        fname_out = pathstr + ofilestr+"_"+ prodstr+senstr+swtstr+swtnum+extstr;
 
 
 
        string  ATT_NAME="Units", ATT_VAL="degrees",GATT_NAME1="Title",GATT_VAL1="PACE OCI Level-1C Data",GATT_NAME2="instrument",GATT_VAL2="OCI",GATT_NAME3="processing_version",GATT_VAL3="V1.0",GATT_NAME4="Conventions",GATT_VAL4="CF-1.6";
        string GATT_NAME5="institution",GATT_VAL5="NASA Goddard Space Flight Center, Ocean Biology Processing Group",GATT_NAME6="license",GATT_VAL6="http://science.nasa.gov/earth-science/earth-science-data/data-information-policy/";
        string GATT_NAME7="naming_authority",GATT_VAL7="gov.nasa.gsfc.sci.oceancolor",GATT_NAME8="keywords_vocabulary",GATT_VAL8="NASA Global Change Master Directory (GCMD) Science Keywords";
        string GATT_NAME9="stdname_vocabulary",GATT_VAL9="NetCDF Climate and Forecast (CF) Metadata Convention",GATT_NAME10="creator_name",GATT_VAL10="NASA/GSFC",GATT_NAME11="creator_email",GATT_VAL11="data@oceancolor.gsfc.nasa.gov";
        string GATT_NAME12="creator_url",GATT_VAL12="http://oceancolor.gsfc.nasa.gov",GATT_NAME13="project",GATT_VAL13="PACE Project",GATT_NAME14="publisher_name",GATT_VAL14="NASA/GSFC";
        string GATT_NAME15="publisher_email",GATT_VAL15="data@oceancolor.gsfc.nasa.gov",GATT_NAME16="publisher_url",GATT_VAL16="http://oceancolor.gsfc.nasa.gov",GATT_NAME17="processing_level",GATT_VAL17="L1C";
        string GATT_NAME18="cdm_data_type",GATT_VAL18="swath",GATT_NAME19="orbit_number",GATT_VAL19="xxx",GATT_NAME20="history",GATT_VAL20="",GATT_NAME21="CDL_version_date",GATT_VAL21="2021-09-10",GATT_NAME22="product_name",GATT_VAL22=fname_out;
        string GATT_NAME23="startDirection",GATT_VAL23=dirstr,GATT_NAME24="endDirection",GATT_VAL24=dirstr,GATT_NAME25="time_coverage_start",GATT_VAL25=tswt_ini,GATT_NAME26="time_coverage_end",GATT_VAL26=tswt_end,GATT_NAME27="date_created",GATT_VAL27="2022-03-25T15:12:41Z",GATT_NAME28="sun_earth_distance",GATT_VAL28="0.990849042172323",GATT_NAME29="terrain_data_source",GATT_VAL29="",GATT_NAME30="spectral_response_function",GATT_VAL30="",GATT_NAME31="systematic_uncertainty_model",GATT_VAL31="",GATT_NAME32="nadir_bin",GATT_VAL32="12345",GATT_NAME33="bin_size_at_nadir",GATT_VAL33="5.2km2";
 
 
        l1cfile->gridname = fname_out.c_str();
        filename_lt = fname_out.c_str();
 
        cout<<"creating file for L1C coor..."<<filename_lt<<endl;
 
       
        if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
            check_err(status, __LINE__, __FILE__);
        //define dims
     // Define the dimensions,vars and attributes at the root level
        NY = num_gridlines-2;
        NX = nbinx;
 
        if(l1cinput->sensor==1){
            senstr="SPEXone";
            GATT_VAL2="SPEXone";
            GATT_VAL32="3567";
            NVIEWS=5;
            NBANDS=400;
             }
        else if (l1cinput->sensor==2){
            senstr="OCI";
            GATT_VAL2="OCI";
            GATT_VAL32="635";
            NVIEWS=2;
            NBANDS=249;
             }
        else if (l1cinput->sensor==3){
            senstr="HARP2";
            GATT_VAL2="HARP";
            GATT_VAL32="127";
            NVIEWS=90;
            NBANDS=1;
              }
        else{
            cout<<"sensor by default is OCI option 2....."<<endl;
            senstr="OCI";
            GATT_VAL2="OCI";
            GATT_VAL32="635";
            NVIEWS=2;
            NBANDS=249;
             }
 
//        lt_out = allocate2d_float(NY, NX);
  //DEF DIMENSIONS
        if ((status = nc_def_dim(ncid_out, "bins_across_track", NX, &x_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "bins_along_track", NY, &y_dimid)))
            check_err(status, __LINE__, __FILE__);
        //dims for output var
        dimids[0] = y_dimid;
        dimids[1] = x_dimid;
        NDIMS=2;
        if ((status = nc_def_dim(ncid_out, "number_of_views", NVIEWS, &v_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "intensity_bands_per_view", NBANDS, &b_dimid)))
            check_err(status, __LINE__, __FILE__);
        //define attributes
//       if (nc_put_att_text(ncid_out, varid1, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
//           check_err(status, __LINE__, __FILE__);
//       if (nc_put_att_text(ncid_out, varid2, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
//           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME1.c_str(), strlen(GATT_VAL1.c_str()),
          GATT_VAL1.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME2.c_str(), strlen(GATT_VAL2.c_str()),
          GATT_VAL2.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME3.c_str(), strlen(GATT_VAL3.c_str()),
          GATT_VAL3.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME4.c_str(), strlen(GATT_VAL4.c_str()),
          GATT_VAL4.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME5.c_str(), strlen(GATT_VAL5.c_str()),
          GATT_VAL5.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME6.c_str(), strlen(GATT_VAL6.c_str()),
          GATT_VAL6.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME7.c_str(), strlen(GATT_VAL7.c_str()),
          GATT_VAL7.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME8.c_str(), strlen(GATT_VAL8.c_str()),
          GATT_VAL8.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME9.c_str(), strlen(GATT_VAL9.c_str()),
          GATT_VAL9.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME10.c_str(), strlen(GATT_VAL10.c_str()),
          GATT_VAL10.c_str()))
           check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME11.c_str(), strlen(GATT_VAL11.c_str()),
          GATT_VAL11.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME12.c_str(), strlen(GATT_VAL12.c_str()),
          GATT_VAL12.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME13.c_str(), strlen(GATT_VAL13.c_str()),
          GATT_VAL13.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME14.c_str(), strlen(GATT_VAL14.c_str()),
          GATT_VAL14.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME15.c_str(), strlen(GATT_VAL15.c_str()),
          GATT_VAL15.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME16.c_str(), strlen(GATT_VAL16.c_str()),
          GATT_VAL16.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME17.c_str(), strlen(GATT_VAL17.c_str()),
          GATT_VAL17.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME18.c_str(), strlen(GATT_VAL18.c_str()),
          GATT_VAL18.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME19.c_str(), strlen(GATT_VAL19.c_str()),
          GATT_VAL19.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME20.c_str(), strlen(GATT_VAL20.c_str()),
          GATT_VAL20.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME21.c_str(), strlen(GATT_VAL21.c_str()),
          GATT_VAL21.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME22.c_str(), strlen(GATT_VAL22.c_str()),
          GATT_VAL22.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME23.c_str(), strlen(GATT_VAL23.c_str()),
          GATT_VAL23.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME24.c_str(), strlen(GATT_VAL24.c_str()),
          GATT_VAL24.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME25.c_str(), strlen(GATT_VAL25.c_str()),
          GATT_VAL25.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME26.c_str(), strlen(GATT_VAL26.c_str()),
          GATT_VAL26.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME27.c_str(), strlen(GATT_VAL27.c_str()),
          GATT_VAL27.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME28.c_str(), strlen(GATT_VAL28.c_str()),
          GATT_VAL28.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME29.c_str(), strlen(GATT_VAL29.c_str()),
          GATT_VAL29.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME30.c_str(), strlen(GATT_VAL30.c_str()),
          GATT_VAL30.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME31.c_str(), strlen(GATT_VAL31.c_str()),
          GATT_VAL31.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME32.c_str(), strlen(GATT_VAL32.c_str()),
          GATT_VAL32.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME33.c_str(), strlen(GATT_VAL33.c_str()),
          GATT_VAL33.c_str()))
          check_err(status, __LINE__, __FILE__);
 
      //define groups                  check_err(status, __LINE__, __FILE__);
       if ((status = nc_def_grp(ncid_out, "geolocation_data", &grp_coor)))  //netcdf-4
          check_err(status, __LINE__, __FILE__);
        //def var
        if ((status = nc_def_var(grp_coor, "latitude", NC_FLOAT, NDIMS,
                dimids, &varid1)))
                check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_var(grp_coor, "longitude", NC_FLOAT, NDIMS,
                dimids, &varid2)))
                check_err(status, __LINE__, __FILE__);
    //leave define mode-----------------------
        if ((status = nc_enddef(grp_coor))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
 
 
        //writing the whole thing
        if ((status = nc_put_var_float(grp_coor, varid1, &lat_gd[0][0])))
            check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_put_var_float(grp_coor, varid2, &lon_gd[0][0])))
            check_err(status, __LINE__, __FILE__);
 
 
 
//define attributes of vars in groups
//UNITS in degrees ----
        if (nc_put_att_text(grp_coor, varid1, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
         check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(grp_coor, varid2, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
 
 
//close file
        if ((status = nc_close(ncid_out)))
           check_err(status, __LINE__, __FILE__);
 
//        delete [] (lt_out);
 
//CASE ONLY LON POS VALUES***************************************************************************
 
        //Only positive longitude 0-360 degrees for visualization ****************************************************************
        //lat lon grid for visualization--
        prodstr = "L1Cgrid_lonpos_";
        //   gdstr="_gdFULL_";
        //recompute number of gridlines based on lat limits -80 to 80 degrees
        //asc orbit goes from negative to positive latitude....
 
        NY = num_gridlines-2;
        NX = nbinx;
 
        cout<<"NY before geographic constraint."<<NY<<"NY1.initial lat index ."<<NY1<<"NY2..final lat index."<<NY2<<"NX.."<<NX<<endl;
 
        for (int i = 0; i < NY; i++) {
            for (int j = 0; j < NX; j++) {
              if (lat_gd[i][j] >= -80.) c1++;
                if (c1 == nbinx) {
                    NY1 = i;
                }
            }
            if (NY1 >= 0) break;
            c1 = 1;
        }
 
        for (int i = 0;i < NY; i++) {
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= 80.) {
                    NY2 = i - 1;
                }
            }
            if (NY2 >= 0) break;
        }
 
        l1cfile->NY1 = NY1;
        l1cfile->NY2 = NY2;
 
       NY = NY2 - NY1 + 1;
       cout<<"NY.after geographic constraint."<<NY<<"NY1.initial lat index ."<<NY1<<"NY2..final lat index."<<NY2<<"NX.."<<NX<<endl;
 
       lat_out = allocate2d_float(NY, NX);
       lon_out = allocate2d_float(NY, NX);
 
       int c=0;
        for (int i = NY1; i < NY2 + 1; i++) {
            for (int j = 0; j < NX; j++) {
                if(lon_gd[i][j]<0) lon_out[c][j]=lon_gd[i][j]+360;
                else lon_out[c][j]=lon_gd[i][j];
                lat_out[c][j] = lat_gd[i][j];
            }
        //    cout<<"gd#..."<<c+1<<endl;
            c++;
 
        }
 
        extstr = ".nc";
//        fname_out = pathstr + missionstr + "_" + senstr + "." + yearstr + monstr + daystr + timestr + prodstr+extstr;
        fname_out = pathstr + ofilestr+"_"+ prodstr+senstr+swtstr+swtnum+extstr;  
        cout<<"path..."<<pathstr<<"ofile.."<<ofilestr<<"prod.."<<prodstr<<endl;
 
        l1cfile->gridname = fname_out.c_str();
        filename_lt = fname_out.c_str();
        cout<<"creating file for L1C coor.with only POS LONGITUDE.."<<filename_lt<<endl;
//        if ((status = nc_create(filename_lt, NC_CLOBBER, &ncid_out)))
        if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
            check_err(status, __LINE__, __FILE__);
        //define dims
     // Define the dimensions,vars and attributes at the root level
      
 
  //DEF DIMENSIONS
        if ((status = nc_def_dim(ncid_out, "bins_across_track", NX, &x_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "bins_along_track", NY, &y_dimid)))
            check_err(status, __LINE__, __FILE__);
        //dims for output var
        dimids[0] = y_dimid;
        dimids[1] = x_dimid;
        NDIMS=2;
        if ((status = nc_def_dim(ncid_out, "number_of_views", NVIEWS, &v_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "intensity_bands_per_view", NBANDS, &b_dimid)))
            check_err(status, __LINE__, __FILE__);
 
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME1.c_str(), strlen(GATT_VAL1.c_str()),
          GATT_VAL1.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME2.c_str(), strlen(GATT_VAL2.c_str()),
          GATT_VAL2.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME3.c_str(), strlen(GATT_VAL3.c_str()),
          GATT_VAL3.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME4.c_str(), strlen(GATT_VAL4.c_str()),
          GATT_VAL4.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME5.c_str(), strlen(GATT_VAL5.c_str()),
          GATT_VAL5.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME6.c_str(), strlen(GATT_VAL6.c_str()),
          GATT_VAL6.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME7.c_str(), strlen(GATT_VAL7.c_str()),
          GATT_VAL7.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME8.c_str(), strlen(GATT_VAL8.c_str()),
          GATT_VAL8.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME9.c_str(), strlen(GATT_VAL9.c_str()),
          GATT_VAL9.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME10.c_str(), strlen(GATT_VAL10.c_str()),
          GATT_VAL10.c_str()))
           check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME11.c_str(), strlen(GATT_VAL11.c_str()),
          GATT_VAL11.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME12.c_str(), strlen(GATT_VAL12.c_str()),
          GATT_VAL12.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME13.c_str(), strlen(GATT_VAL13.c_str()),
                   GATT_VAL13.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME14.c_str(), strlen(GATT_VAL14.c_str()),
          GATT_VAL14.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME15.c_str(), strlen(GATT_VAL15.c_str()),
          GATT_VAL15.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME16.c_str(), strlen(GATT_VAL16.c_str()),
          GATT_VAL16.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME17.c_str(), strlen(GATT_VAL17.c_str()),
          GATT_VAL17.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME18.c_str(), strlen(GATT_VAL18.c_str()),
          GATT_VAL18.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME19.c_str(), strlen(GATT_VAL19.c_str()),
          GATT_VAL19.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME20.c_str(), strlen(GATT_VAL20.c_str()),
          GATT_VAL20.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME21.c_str(), strlen(GATT_VAL21.c_str()),
          GATT_VAL21.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME22.c_str(), strlen(GATT_VAL22.c_str()),
          GATT_VAL22.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME23.c_str(), strlen(GATT_VAL23.c_str()),
          GATT_VAL23.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME24.c_str(), strlen(GATT_VAL24.c_str()),
          GATT_VAL24.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME25.c_str(), strlen(GATT_VAL25.c_str()),
          GATT_VAL25.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME26.c_str(), strlen(GATT_VAL26.c_str()),
          GATT_VAL26.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME27.c_str(), strlen(GATT_VAL27.c_str()),
          GATT_VAL27.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME28.c_str(), strlen(GATT_VAL28.c_str()),
          GATT_VAL28.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME29.c_str(), strlen(GATT_VAL29.c_str()),
          GATT_VAL29.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME30.c_str(), strlen(GATT_VAL30.c_str()),
          GATT_VAL30.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME31.c_str(), strlen(GATT_VAL31.c_str()),
          GATT_VAL31.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME32.c_str(), strlen(GATT_VAL32.c_str()),
          GATT_VAL32.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME33.c_str(), strlen(GATT_VAL33.c_str()),
          GATT_VAL33.c_str()))
          check_err(status, __LINE__, __FILE__);
 
      //define groups                  check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_grp(ncid_out, "geolocation_data", &grp_coor)))  //netcdf-4
             check_err(status, __LINE__, __FILE__);
        //def var
        if ((status = nc_def_var(grp_coor, "latitude", NC_FLOAT, NDIMS,
                dimids, &varid1)))
                check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_var(grp_coor, "longitude", NC_FLOAT, NDIMS,
                dimids, &varid2)))
                check_err(status, __LINE__, __FILE__);
 
                    //leave define mode-----------------------
        if ((status = nc_enddef(grp_coor))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
 
        //writing the whole thing
        if ((status = nc_put_var_float(grp_coor, varid1, &lat_out[0][0])))
            check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_put_var_float(grp_coor, varid2, &lon_out[0][0])))
            check_err(status, __LINE__, __FILE__);
 
//define attributes of vars in groups
        if (nc_put_att_text(grp_coor, varid1, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(grp_coor, varid2, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
 
 
        if ((status = nc_close(ncid_out)))
           check_err(status, __LINE__, __FILE__);
 
 
        delete [] (lat_out);
        delete [] (lon_out);
        lat_out=nullptr;
        lon_out=nullptr;
 
 
 
//CASE INVERTED ALONG/ACROSS INDEXES ***************************************************************************
        prodstr = "L1Cgrid_inverted_";
 
 
        lat_out = allocate2d_float(NY, NX);
        lon_out = allocate2d_float(NY, NX);
 
        c = 0;
        for (int i = NY1; i < NY2 + 1; i++) {
            for (int j = 0; j < NX; j++) {
                lat_out[NY - 1 - c][NX - 1 - j] = lat_gd[i][j];
                lon_out[NY - 1 - c][j] = lon_gd[i][j];
            }
            c++;
        }
 
        extstr = ".nc";
//        fname_out = pathstr + missionstr + "_" + senstr + "." + yearstr + monstr + daystr + timestr + prodstr+extstr;
        fname_out = pathstr + ofilestr+"_"+ prodstr+senstr+swtstr+swtnum+extstr;
        l1cfile->gridname = fname_out.c_str();
        filename_lt = fname_out.c_str();
        cout<<"creating file for L1C coor.with x/y inverted indexes.."<<filename_lt<<endl;
//        if ((status = nc_create(filename_lt, NC_CLOBBER, &ncid_out)))
        if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
            check_err(status, __LINE__, __FILE__);
        //define dims
     // Define the dimensions,vars and attributes at the root level
 
 
  //DEF DIMENSIONS
        if ((status = nc_def_dim(ncid_out, "bins_across_track", NX, &x_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "bins_along_track", NY, &y_dimid)))
            check_err(status, __LINE__, __FILE__);
        //dims for output var
        dimids[0] = y_dimid;
        dimids[1] = x_dimid;
        NDIMS=2;
        if ((status = nc_def_dim(ncid_out, "number_of_views", NVIEWS, &v_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "intensity_bands_per_view", NBANDS, &b_dimid)))
            check_err(status, __LINE__, __FILE__);
/*
//def variables at the root level!
        if ((status = nc_def_var(ncid_out, "latitude", NC_FLOAT, NDIMS,
                dimids, &varid1)))
                check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_var(ncid_out, "longitude", NC_FLOAT, NDIMS,
                dimids, &varid2)))
                check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_enddef(ncid_out))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
        if ((status = nc_put_var_float(ncid_out, varid1, &lat_out[0][0])))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_put_var_float(ncid_out, varid2, &lon_out[0][0])))
            check_err(status, __LINE__, __FILE__);
 
//define attributes
       if (nc_put_att_text(ncid_out, varid1, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, varid2, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str())) 
           check_err(status, __LINE__, __FILE__);
*/
 
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME1.c_str(), strlen(GATT_VAL1.c_str()),
          GATT_VAL1.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME2.c_str(), strlen(GATT_VAL2.c_str()),
          GATT_VAL2.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME3.c_str(), strlen(GATT_VAL3.c_str()),
          GATT_VAL3.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME4.c_str(), strlen(GATT_VAL4.c_str()),
          GATT_VAL4.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME5.c_str(), strlen(GATT_VAL5.c_str()),
          GATT_VAL5.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME6.c_str(), strlen(GATT_VAL6.c_str()),
          GATT_VAL6.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME7.c_str(), strlen(GATT_VAL7.c_str()),
          GATT_VAL7.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME8.c_str(), strlen(GATT_VAL8.c_str()),
          GATT_VAL8.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME9.c_str(), strlen(GATT_VAL9.c_str()),
          GATT_VAL9.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME10.c_str(), strlen(GATT_VAL10.c_str()),
          GATT_VAL10.c_str()))
           check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME11.c_str(), strlen(GATT_VAL11.c_str()),
          GATT_VAL11.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME12.c_str(), strlen(GATT_VAL12.c_str()),
          GATT_VAL12.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME13.c_str(), strlen(GATT_VAL13.c_str()),
          GATT_VAL13.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME14.c_str(), strlen(GATT_VAL14.c_str()),
          GATT_VAL14.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME15.c_str(), strlen(GATT_VAL15.c_str()),
          GATT_VAL15.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME16.c_str(), strlen(GATT_VAL16.c_str()),
          GATT_VAL16.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME17.c_str(), strlen(GATT_VAL17.c_str()),
                   GATT_VAL17.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME18.c_str(), strlen(GATT_VAL18.c_str()),
          GATT_VAL18.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME19.c_str(), strlen(GATT_VAL19.c_str()),
          GATT_VAL19.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME20.c_str(), strlen(GATT_VAL20.c_str()),
          GATT_VAL20.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME21.c_str(), strlen(GATT_VAL21.c_str()),
          GATT_VAL21.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME22.c_str(), strlen(GATT_VAL22.c_str()),
          GATT_VAL22.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME23.c_str(), strlen(GATT_VAL23.c_str()),
          GATT_VAL23.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME24.c_str(), strlen(GATT_VAL24.c_str()),
          GATT_VAL24.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME25.c_str(), strlen(GATT_VAL25.c_str()),
          GATT_VAL25.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME26.c_str(), strlen(GATT_VAL26.c_str()),
          GATT_VAL26.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME27.c_str(), strlen(GATT_VAL27.c_str()),
          GATT_VAL27.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME28.c_str(), strlen(GATT_VAL28.c_str()),
          GATT_VAL28.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME29.c_str(), strlen(GATT_VAL29.c_str()),
          GATT_VAL29.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME30.c_str(), strlen(GATT_VAL30.c_str()),
          GATT_VAL30.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME31.c_str(), strlen(GATT_VAL31.c_str()),
          GATT_VAL31.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME32.c_str(), strlen(GATT_VAL32.c_str()),
          GATT_VAL32.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME33.c_str(), strlen(GATT_VAL33.c_str()),
          GATT_VAL33.c_str()))
          check_err(status, __LINE__, __FILE__);
 
      //define groups                  check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_grp(ncid_out, "geolocation_data", &grp_coor)))  //netcdf-4
           check_err(status, __LINE__, __FILE__);
/*
//DEF DIMENSIONS
        if ((status = nc_def_dim(grp_coor, "x", NX, &x_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(grp_coor, "y", NY, &y_dimid)))
            check_err(status, __LINE__, __FILE__);
        dimids[0] = y_dimid;
        dimids[1] = x_dimid;
        NDIMS=2;
*/
        //def var
        if ((status = nc_def_var(grp_coor, "latitude", NC_FLOAT, NDIMS,
                dimids, &varid1)))
                check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_var(grp_coor, "longitude", NC_FLOAT, NDIMS,
                dimids, &varid2)))
                check_err(status, __LINE__, __FILE__);
 
                    //leave define mode-----------------------
        if ((status = nc_enddef(grp_coor))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
        //writing the whole thing
        if ((status = nc_put_var_float(grp_coor, varid1, &lat_out[0][0])))
            check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_put_var_float(grp_coor, varid2, &lon_out[0][0])))
            check_err(status, __LINE__, __FILE__);
 
 
//define attributes of vars in groups
        if (nc_put_att_text(grp_coor, varid1, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(grp_coor, varid2, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
 
 
 
        if ((status = nc_close(ncid_out)))
           check_err(status, __LINE__, __FILE__);
 
 
        delete [] (lat_out);
        delete [] (lon_out);
        lat_out=nullptr;
        lon_out=nullptr;
 
 
 
//******** save az_east param as nc ***************************************************************
//az_east[count]
        prodstr="az_east_";
        extstr = ".nc";
        fname_out = pathstr + ofilestr+"_"+ prodstr+senstr+extstr;
        filename_lt = fname_out.c_str();
        cout<<"creating file for az_east values in degrees as nc format.."<<filename_lt<<endl;
//        if ((status = nc_create(filename_lt, NC_CLOBBER, &ncid_out)))
        if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
            check_err(status, __LINE__, __FILE__);
        //define dims
     // Define the dimensions,vars and attributes at the root level
 
 
  //DEF DIMENSIONS
        if ((status = nc_def_dim(ncid_out, "bins_along_track", NY, &y_dimid)))
            check_err(status, __LINE__, __FILE__);
//DEF VARIABLE
        if ((status = nc_def_var(ncid_out, "az_east", NC_FLOAT, 1,
                &y_dimid, &varid1)))
                check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_enddef(ncid_out))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
 
          for (int count = 0; count < num_gridlines - 2; count++) {
                if (az_east[count] < 0.001) az_east[count] = 0.0;}
        //writing the whole thing
        if ((status = nc_put_var_float(ncid_out, varid1, &az_east[0])))
            check_err(status, __LINE__, __FILE__);
//close file
        if ((status = nc_close(ncid_out)))
           check_err(status, __LINE__, __FILE__);
 
         l1cfile->azeast_name = fname_out.c_str();
 
 
//***********************************************************************************************
        prodstr = "L1CgridV_";
        extstr=".csv";
 
        fname_out = pathstr + ofilestr+"_"+ prodstr+senstr+extstr;
        //   std::ofstream myl1c("/accounts/mamontes/images/OCIS/swt1_ALLgd_L1C500_swtd13again.csv");
        std::ofstream myl1cV(fname_out);
        for (int count = 0; count < num_gridlines - 2;count++) {
            //         for(int count = 0; count <num_gridlines/100;count ++){
            for (int gp = 0; gp < nbinx; gp++) {
                lontemp = lon_gd[count][gp];
                if (lon_gd[count][gp] < -180.) lontemp = lon_gd[count][gp] + 360;
                if (lon_gd[count][gp] > +180.) lontemp = lon_gd[count][gp] - 360;
                if (lontemp < 0.) lontemp += 360.;//make better visualization, all lon values positive
 
                myl1cV << lontemp << "," << lat_gd[count][gp] << endl;
           }
         }
 
 
        myl1cV.close();
 
 
        prodstr = "lat_nadpix_";
        fname_out = pathstr + ofilestr+"_"+ prodstr+senstr+extstr;
        //   fname_out= "/accounts/mamontes/images/OCIS/out/"+"L1Cgrid_"+"lat_nadpix"+"_"+swtstr+".txt";
        //   ofstream myfile1 ("/accounts/mamontes/images/OCIS/lat_nadpix_swtd13again.txt");
        ofstream myfile1(fname_out);
        if (myfile1.is_open())
        {
            myfile1 << "lat_nadpix.\n";
            for (int count = 0; count < num_gridlines - 2; count++) {
                //   for(int gp = 0; gp <nbinx; gp ++){
                myfile1 << lati2[count] << "," << endl;
            }
            myfile1.close();
        }
        else cout << "Unable to open file";
        prodstr = "lon_nadpix_";
        fname_out = pathstr + ofilestr+"_"+ prodstr+senstr+extstr;
        //  fname_out= "/accounts/mamontes/images/OCIS/out/"+"L1Cgrid_"+"lon_nadpix"+"_"+swtstr+".txt";
        //  ofstream myfile2 ("/accounts/mamontes/images/OCIS/lon_nadpix_swtd13again.txt");
        ofstream myfile2(fname_out);
        if (myfile2.is_open())
        {
            myfile2 << "lon_nadpix.\n";
            for (int count = 0; count < num_gridlines - 2; count++) {
                //   for(int gp = 0; gp <nbinx; gp ++){
                myfile2 << loni2[count] << "," << endl;
            }
            myfile2.close();
        }
        else cout << "Unable to open file";
 
/*        prodstr = "az_east";
        fname_out = pathstr + ofilestr+"_"+ prodstr+extstr;
 
        l1cfile->azeast_name = fname_out.c_str();
 
 
 
        //  fname_out= "/accounts/mamontes/images/OCIS/out/"+"L1Cgrid_"+"lon_nadpix"+"_"+swtstr+".txt";
        //  ofstream myfile2 ("/accounts/mamontes/images/OCIS/lon_nadpix_swtd13again.txt");
        ofstream myfile3(fname_out);
        if (myfile3.is_open())
        {
            myfile3 << "az_east.\n";
            for (int count = 0; count < num_gridlines - 2; count++) {
                if (az_east[count] < 0.001) az_east[count] = 0.0;
                myfile3 << az_east[count] << "," << endl;
            }
            myfile3.close();
        }
        else cout << "Unable to open file";
*/
 
 
        if(lati_l!=nullptr)
        delete[](lati_l);
        if(lati_r!=nullptr)
        delete[](lati_r);
        if(loni_l!=nullptr)
        delete[](loni_l);
        if(loni_r!=nullptr)
        delete[](loni_r);
 
 
        cout << " SUCCESS writing results full L1C grid center positions for--swath #..." << swtd << "\n";
 
 
 
 
     return 0;  
     }       
 
 
 
 
 
//swath processing-----
int32_t L1C::across_gridlines_l1c_vec2(int swtd, l1c_filehandle* l1cfile, L1C_input* l1cinput,float* lati2, float* loni2, float** lat_gd, float** lon_gd, float* az_east) {
        int32_t num_gridlines, nbinx, NY1 = -1, NY2 = -1, c1 = 1;
        float lat1_l, lat1_r, lon1_l, lon1_r, az_r, az_l,  *lati_l, *loni_l, *lati_r, *loni_r;
        int  ncid_out,x_dimid, y_dimid, varid1, varid2, status;
        int NDIMS=2;
        int dimids[NDIMS];
        int32_t NX, NY;
        int16_t selyear = -1, selmon = -1, selday = -1;
        double  latih, lonih, latih2, lonih2, res1, res2;
        float gres;
        int fnan1=0, fnan2=0, fnan3=0, fnan4=0;
        float latfirst = -999;
        int badline = 0;
        int grp_coor;
        const char* filename_lt;
        float **lat_out=nullptr,**lon_out=nullptr;
//        float **lt_out=nullptr;
        int NVIEWS, NBANDS,v_dimid,b_dimid,asc_mode=-1;
        string senstr,tswt_ini,tswt_end,tswt_ini_file;
 
 
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
 
 
        if(l1cinput->sensor==1) senstr="SPEXone";
        else if (l1cinput->sensor==2) senstr="OCI";
        else if (l1cinput->sensor==3) senstr="HARP";
        else{cout<<"sensor by default is OCI option 2....."<<endl;
            senstr="OCI"; }
 
        //compute azimuth angle for each along-track position (nadir pixel or centered swath pixel) of the swath
        //azimuth angle in rads
        //lon+540/360-180 is a normalization factor for -180 to 180 degrees   
        num_gridlines = l1cfile->num_gridlines;
        num_pixels = l1cfile->npix;
        nbinx = l1cfile->nbinx;
 
        tswt_ini=l1cfile->tswt_ini;
        tswt_end=l1cfile->tswt_end;
        tswt_ini_file=l1cfile->tswt_ini_file;
 
 
        lati_l = (float*)calloc(nbinx / 2 , sizeof(float));
        lati_r = (float*)calloc(nbinx / 2 , sizeof(float));
        loni_l = (float*)calloc(nbinx / 2 , sizeof(float));
        loni_r = (float*)calloc(nbinx / 2 , sizeof(float));
 
      //big loop
 
        int gd = 0;
        asc_mode=l1cfile->orb_dir;
 
 
        //compute mean az_east---
 
        float mean_az_east=l1cfile->mean_az_east;
 
         cout << "recomputing mean_az_east..(based on second interp rather than first interp)" << mean_az_east << "num_gridlines.." << num_gridlines << endl;
 
 
 
        for (int j = 0;j < num_gridlines;j++) {
            az_east[j] = mean_az_east;
        }
 
 
//i==1 cause 1 more bin for second interpolation
        for (int i = 0;i <num_gridlines;i++) {
 
            if (i % 1 == 0) {
                //assign central positions---
                lat1_l = lati2[i] * M_PI / 180.;
                lat1_r = lati2[i] * M_PI / 180.;           
                lon1_l = loni2[i] * M_PI / 180.;
                lon1_r = loni2[i] * M_PI / 180.;          
 
                gres = (l1cinput->gres) * 1000; //grid resolution in meters
 
                //compute RIGHT across-gridline pixels---
                for (int k = 0;k < (nbinx / 2);k++) {
 
                    //right pixels---
                    az_r = mean_az_east * degrad;
 
                    //left pixels---
                    az_l = az_r - M_PI;
 
                         //bearing should be always positive (clockwise) before pixel location calculation based on Harverside---
                    if (az_r < 0.) {
                        az_r = 360 + az_r * 180 / M_PI;
                        az_r = az_r * M_PI / 180;
                    }
 
                    if (az_l < 0.) {
                        az_l = 360 + az_l * 180 / M_PI;
                        az_l = az_l * M_PI / 180;
                    }
                   
                  if(k==0){   
                    geod.Direct(lat1_r * 180 / M_PI, lon1_r * 180 / M_PI, az_r * 180 / M_PI, gres/2, latih, lonih);
                    geod.Inverse(lat1_r * 180 / M_PI, lon1_r * 180 / M_PI, latih, lonih, res1);
                          }
                  else{
                    geod.Direct(lat1_r * 180 / M_PI, lon1_r * 180 / M_PI, az_r * 180 / M_PI, gres, latih, lonih);
                    geod.Inverse(lat1_r * 180 / M_PI, lon1_r * 180 / M_PI, latih, lonih, res1);
                  }
 
                
                    fnan1 = isnan(latih);
                    fnan2 = isnan(lonih);
                    lati_r[k] = latih;
                    loni_r[k] = lonih;
                    //     cout<<"righside.."<<latih<<"..."<<lonih<<"res1"<<res1<<endl;
 
                    lat1_r = lati_r[k] * M_PI / 180;
                    lon1_r = loni_r[k] * M_PI / 180;
 
 
                  if(k==0){
                    geod.Direct(lat1_l * 180 / M_PI, lon1_l * 180 / M_PI, az_l * 180 / M_PI, gres/2, latih2, lonih2);
                    geod.Inverse(lat1_l * 180 / M_PI, lon1_l * 180 / M_PI, latih2, lonih2, res2);
                  }
                  else{
                    geod.Direct(lat1_l * 180 / M_PI, lon1_l * 180 / M_PI, az_l * 180 / M_PI, gres, latih2, lonih2);
                    geod.Inverse(lat1_l * 180 / M_PI, lon1_l * 180 / M_PI, latih2, lonih2, res2);
 
                  }
 
/*                     if(i==2000){//before and after crossing 
                       cout<<"gd#..."<<i+1<<"binx.."<<k+1<<"az_r.."<<az_r* 180 / M_PI<<"az_l.."<<az_l* 180 / M_PI<<endl;
                       cout<<"lat1_l.."<<lat1_l<<"lon1_l.."<<lon1_l<<"latih2.."<<latih2<<"lonih2.."<<lonih2<<"res2.."<<res2<<endl;
                       cout<<"lat1_r.."<<lat1_r<<"lon1_r.."<<lon1_r<<"latih.."<<latih<<"lonih.."<<lonih<<"res1.."<<res1<<endl;
                    }
  */                  
 
                    fnan3 = isnan(latih2);
                    fnan4 = isnan(lonih2);
                    lati_l[k] = latih2;
                    loni_l[k] = lonih2;
                    //     cout<<"leftside.."<<latih2<<"..."<<lonih2<<"res2"<<res2<<endl;
 
                    lat1_l = lati_l[k] * M_PI / 180;
                    lon1_l = loni_l[k] * M_PI / 180;
                    
          //right swath side------------- //we tolerate +- 6 m error
                      
//                    if (asc_mode==1 && lati2[i]>lati2[i+1] || asc_mode==0 && lati2[i]<lati2[i+1] || fnan1 > 0 || fnan2 > 0 || res1 > (gres + 6) || res1 < (gres - 6)) { //nan values
//                    if (asc_mode==1 && lati2[i]>lati2[i+1] || asc_mode==0 && lati2[i]<lati2[i+1] || fnan1 > 0 || fnan2 > 0 || res1 > (gres + 6)) { //nan val
                    if (fnan1 > 0 || fnan2 > 0 || res1 > (gres + 6)) { //nan values    
                        badline++;
                        if (badline == 1) {
                            latfirst = lati2[i];
                        }
 
                        cout << "bad interpolation - missing orbital data at near nadir grid cell..NAN right side of line.." << i + 1 << "corresponding to lat..."<<latfirst <<"lati2[i].."<<lati2[i]<<endl;
                        cout<<"gd.."<<gd+1<<"XBIN.."<<k+1<<"lati_l[k]"<<lati_l[k]<<"loni_l[k]"<<loni_l[k]<<"lati_r[k]"<<lati_r[k]<<"loni_r[k]"<<loni_r[k]<<endl;
                        
                        lati2[i] = NAN;
                        loni2[i] = NAN;
 
                        for (int k = 0;k < (nbinx / 2);k++) {
                            lat_gd[gd][k + nbinx / 2] = NAN;
                            lon_gd[gd][k + nbinx / 2] = NAN;
                        }
                        //       cout<<"nan value.right.."<<endl;
                      }
                    else {
                        lat_gd[gd][k + nbinx / 2] = latih;
                        lon_gd[gd][k + nbinx / 2] = lonih;
                         }
 
                    //left side
 //                   if (asc_mode==1 && lati2[i]>lati2[i+1] || asc_mode==0 && lati2[i]<lati2[i+1] || fnan3 > 0 || fnan4 > 0 || res2 > (gres + 6) || res2 < (gres - 6)) {
        //            if (asc_mode==1 && lati2[i]>lati2[i+1] || asc_mode==0 && lati2[i]<lati2[i+1] || fnan3 > 0 || fnan4 > 0 || res2 > (gres + 6)) {                   
                    if (fnan3 > 0 || fnan4 > 0 || res2 > (gres + 6)) {    
                        //     if(fnan3>0 | fnan4>0 |  res2>(gres+6) | res2<(gres-6)){
                        cout << "bad interpolation - missing orbital data at near nadir grid cell..NAN left side of line.." << i + 1 << endl;
                        cout<<"gd.."<<gd+1<<"XBIN.."<<k+1<<"lati_l[k]"<<lati_l[k]<<"loni_l[k]"<<loni_l[k]<<"lati_r[k]"<<lati_r[k]<<"loni_r[k]"<<loni_r[k]<<"lati2[i].."<<lati2[i]<<endl;
                        
                        lati2[i] = NAN;
                        loni2[i] = NAN;
                        for (int k = 0;k < (nbinx / 2);k++) {
                            lat_gd[gd][nbinx / 2 - 1 - k] = NAN;//as k increases we are farther away from nadpix or along-track position---
                            lon_gd[gd][nbinx / 2 - 1 - k] = NAN;
                         }
                        //       cout<<"nan value.left.."<<endl;
                    }
                    else {
                        lat_gd[gd][nbinx / 2 - 1 - k] = latih2;//as k increases we are farther away from nadpix or along-track position---
                        lon_gd[gd][nbinx / 2 - 1 - k] = lonih2;
                       }
                fnan1=0;
                fnan2=0;
                fnan3=0;
                fnan4=0;
 
                }//end BINX k loop
       
                gd++;
            }//end if every 100 gd
        }//end gridlines loop
        cout << "`L1C gridding successful!......................................." << endl;
 
 
//---- writing results -------------------------------------------
//--------------------------------------------------------------
        
 
        selday = l1cinput->selday;
        selmon = l1cinput->selmon;
        selyear = l1cinput->selyear;
 
        std::string timestr,missionstr,fname_out, pathstr,monstr, daystr, yearstr, prodstr, gdstr, swtstr, swtnum, extstr,ofilestr,dirstr;
 
        if(asc_mode==1) dirstr="Ascending";
        else if(asc_mode==0) dirstr="Descending";
 
 
 
        pathstr = "out/";
        missionstr="PACE";       
        monstr = std::to_string(selmon);
        daystr = std::to_string(selday);
        yearstr = std::to_string(selyear);
        timestr="T00:00:00Z";
        prodstr = "L1Cgrid_";        
        swtstr = "_swt";
        swtnum = std::to_string(swtd);
        extstr = ".nc";
        ofilestr=std::string(l1cinput->ofile);
 
//        fname_out = pathstr + ofilestr+"_"+ prodstr+senstr+swtstr+swtnum+extstr;
        fname_out=pathstr+"PACE_"+senstr+"."+tswt_ini_file+".L1C.5.2km.nc";
     //   string datestr=date;
 
        auto t = std::time(nullptr);
        auto tm = *std::localtime(&t);
        std::ostringstream oss,oss2;
        oss << std::put_time(&tm, "%d-%m-%Y %H-%M-%S") << std::endl;
      //  cout<<"current datetime.n UTC."<<datestr<<endl;
        auto datestr = oss.str();
        cout<<"date.."<<datestr.substr(0,2)<<endl;
 
       time_t rawtime;
       time (&rawtime);
       string datestr2=ctime (&rawtime);
 
 
//        oss2<<system("date")<<endl;
//        string datestr2=oss2.str();
        cout<<"date.."<<datestr2.substr(0,10)<<endl;
//        exit(1);
 
 
 
 
        string  ATT_NAME="Units", ATT_VAL="degrees",GATT_NAME1="Title",GATT_VAL1="PACE OCI Level-1C Data",GATT_NAME2="instrument",GATT_VAL2="OCI",GATT_NAME3="processing_version",GATT_VAL3="V1.0",GATT_NAME4="Conventions",GATT_VAL4="CF-1.6";
        string GATT_NAME5="institution",GATT_VAL5="NASA Goddard Space Flight Center, Ocean Biology Processing Group",GATT_NAME6="license",GATT_VAL6="http://science.nasa.gov/earth-science/earth-science-data/data-information-policy/";
        string GATT_NAME7="naming_authority",GATT_VAL7="gov.nasa.gsfc.sci.oceancolor",GATT_NAME8="keywords_vocabulary",GATT_VAL8="NASA Global Change Master Directory (GCMD) Science Keywords";
        string GATT_NAME9="stdname_vocabulary",GATT_VAL9="NetCDF Climate and Forecast (CF) Metadata Convention",GATT_NAME10="creator_name",GATT_VAL10="NASA/GSFC",GATT_NAME11="creator_email",GATT_VAL11="data@oceancolor.gsfc.nasa.gov";
        string GATT_NAME12="creator_url",GATT_VAL12="http://oceancolor.gsfc.nasa.gov",GATT_NAME13="project",GATT_VAL13="PACE Project",GATT_NAME14="publisher_name",GATT_VAL14="NASA/GSFC";
        string GATT_NAME15="publisher_email",GATT_VAL15="data@oceancolor.gsfc.nasa.gov",GATT_NAME16="publisher_url",GATT_VAL16="http://oceancolor.gsfc.nasa.gov",GATT_NAME17="processing_level",GATT_VAL17="L1C";
        string GATT_NAME18="cdm_data_type",GATT_VAL18="swath",GATT_NAME19="orbit_number",GATT_VAL19="xxx",GATT_NAME20="history",GATT_VAL20="",GATT_NAME21="CDL_version_date",GATT_VAL21="2021-09-10",GATT_NAME22="product_name",GATT_VAL22=fname_out;
        string GATT_NAME23="startDirection",GATT_VAL23=dirstr,GATT_NAME24="endDirection",GATT_VAL24=dirstr,GATT_NAME25="time_coverage_start",GATT_VAL25=tswt_ini,GATT_NAME26="time_coverage_end",GATT_VAL26=tswt_end,GATT_NAME27="date_created",GATT_VAL27="2022-03-25T15:12:41Z",GATT_NAME28="sun_earth_distance",GATT_VAL28="0.990849042172323",GATT_NAME29="terrain_data_source",GATT_VAL29="",GATT_NAME30="spectral_response_function",GATT_VAL30="",GATT_NAME31="systematic_uncertainty_model",GATT_VAL31="",GATT_NAME32="nadir_bin",GATT_VAL32="12345",GATT_NAME33="bin_size_at_nadir",GATT_VAL33="5.2km2";
 
 
        l1cfile->gridname = fname_out.c_str();
        filename_lt = fname_out.c_str();
 
        cout<<"creating file for L1C coor..."<<filename_lt<<endl;
 
       
        if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
            check_err(status, __LINE__, __FILE__);
        //define dims
     // Define the dimensions,vars and attributes at the root level
        NY = num_gridlines;
        NX = nbinx;
 
        if(l1cinput->sensor==1){
            senstr="SPEXone";
            GATT_VAL2="SPEXone";
            GATT_VAL32="3567";
            NVIEWS=5;
            NBANDS=400;
             }
        else if (l1cinput->sensor==2){
            senstr="OCI";
            GATT_VAL2="OCI";
            GATT_VAL32="635";
            NVIEWS=2;
            NBANDS=249;
             }
        else if (l1cinput->sensor==3){
            senstr="HARP2";
            GATT_VAL2="HARP";
            GATT_VAL32="127";
            NVIEWS=90;
            NBANDS=1;
              }
        else{
            cout<<"sensor by default is OCI option 2....."<<endl;
            senstr="OCI";
            GATT_VAL2="OCI";
            GATT_VAL32="635";
            NVIEWS=2;
            NBANDS=249;
             }
 
//        lt_out = allocate2d_float(NY, NX);
  //DEF DIMENSIONS
        if ((status = nc_def_dim(ncid_out, "bins_across_track", NX, &x_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "bins_along_track", NY, &y_dimid)))
            check_err(status, __LINE__, __FILE__);
        //dims for output var
        dimids[0] = y_dimid;
        dimids[1] = x_dimid;
        NDIMS=2;
        if ((status = nc_def_dim(ncid_out, "number_of_views", NVIEWS, &v_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "intensity_bands_per_view", NBANDS, &b_dimid)))
            check_err(status, __LINE__, __FILE__);
        //define attributes
//       if (nc_put_att_text(ncid_out, varid1, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
//           check_err(status, __LINE__, __FILE__);
//       if (nc_put_att_text(ncid_out, varid2, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
//           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME1.c_str(), strlen(GATT_VAL1.c_str()),
          GATT_VAL1.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME2.c_str(), strlen(GATT_VAL2.c_str()),
          GATT_VAL2.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME3.c_str(), strlen(GATT_VAL3.c_str()),
          GATT_VAL3.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME4.c_str(), strlen(GATT_VAL4.c_str()),
          GATT_VAL4.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME5.c_str(), strlen(GATT_VAL5.c_str()),
          GATT_VAL5.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME6.c_str(), strlen(GATT_VAL6.c_str()),
          GATT_VAL6.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME7.c_str(), strlen(GATT_VAL7.c_str()),
          GATT_VAL7.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME8.c_str(), strlen(GATT_VAL8.c_str()),
          GATT_VAL8.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME9.c_str(), strlen(GATT_VAL9.c_str()),
          GATT_VAL9.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME10.c_str(), strlen(GATT_VAL10.c_str()),
          GATT_VAL10.c_str()))
           check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME11.c_str(), strlen(GATT_VAL11.c_str()),
          GATT_VAL11.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME12.c_str(), strlen(GATT_VAL12.c_str()),
          GATT_VAL12.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME13.c_str(), strlen(GATT_VAL13.c_str()),
          GATT_VAL13.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME14.c_str(), strlen(GATT_VAL14.c_str()),
          GATT_VAL14.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME15.c_str(), strlen(GATT_VAL15.c_str()),
          GATT_VAL15.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME16.c_str(), strlen(GATT_VAL16.c_str()),
          GATT_VAL16.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME17.c_str(), strlen(GATT_VAL17.c_str()),
          GATT_VAL17.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME18.c_str(), strlen(GATT_VAL18.c_str()),
          GATT_VAL18.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME19.c_str(), strlen(GATT_VAL19.c_str()),
          GATT_VAL19.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME20.c_str(), strlen(GATT_VAL20.c_str()),
          GATT_VAL20.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME21.c_str(), strlen(GATT_VAL21.c_str()),
          GATT_VAL21.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME22.c_str(), strlen(GATT_VAL22.c_str()),
          GATT_VAL22.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME23.c_str(), strlen(GATT_VAL23.c_str()),
          GATT_VAL23.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME24.c_str(), strlen(GATT_VAL24.c_str()),
          GATT_VAL24.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME25.c_str(), strlen(GATT_VAL25.c_str()),
          GATT_VAL25.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME26.c_str(), strlen(GATT_VAL26.c_str()),
          GATT_VAL26.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME27.c_str(), strlen(GATT_VAL27.c_str()),
          GATT_VAL27.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME28.c_str(), strlen(GATT_VAL28.c_str()),
          GATT_VAL28.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME29.c_str(), strlen(GATT_VAL29.c_str()),
          GATT_VAL29.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME30.c_str(), strlen(GATT_VAL30.c_str()),
          GATT_VAL30.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME31.c_str(), strlen(GATT_VAL31.c_str()),
          GATT_VAL31.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME32.c_str(), strlen(GATT_VAL32.c_str()),
          GATT_VAL32.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME33.c_str(), strlen(GATT_VAL33.c_str()),
          GATT_VAL33.c_str()))
          check_err(status, __LINE__, __FILE__);
 
      //define groups                  check_err(status, __LINE__, __FILE__);
       if ((status = nc_def_grp(ncid_out, "geolocation_data", &grp_coor)))  //netcdf-4
          check_err(status, __LINE__, __FILE__);
        //def var
        if ((status = nc_def_var(grp_coor, "latitude", NC_FLOAT, NDIMS,
                dimids, &varid1)))
                check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_var(grp_coor, "longitude", NC_FLOAT, NDIMS,
                dimids, &varid2)))
                check_err(status, __LINE__, __FILE__);
    //leave define mode-----------------------
        if ((status = nc_enddef(grp_coor))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
 
 
        //writing the whole thing
        if ((status = nc_put_var_float(grp_coor, varid1, &lat_gd[0][0])))
            check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_put_var_float(grp_coor, varid2, &lon_gd[0][0])))
            check_err(status, __LINE__, __FILE__);
 
 
 
//define attributes of vars in groups
//UNITS in degrees ----
        if (nc_put_att_text(grp_coor, varid1, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
         check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(grp_coor, varid2, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
 
 
//close file
        if ((status = nc_close(ncid_out)))
           check_err(status, __LINE__, __FILE__);
 
//        delete [] (lt_out);
 
//CASE ONLY LON POS VALUES***************************************************************************
 
        //Only positive longitude 0-360 degrees for visualization ****************************************************************
        //lat lon grid for visualization--
        prodstr = "L1Cgrid_lonpos_";
        //   gdstr="_gdFULL_";
        //recompute number of gridlines based on lat limits -80 to 80 degrees
        //asc orbit goes from negative to positive latitude....
 
        NY = num_gridlines;
        NX = nbinx;
 
        cout<<"NY before geographic constraint."<<NY<<"NY1.initial lat index ."<<NY1<<"NY2..final lat index."<<NY2<<"NX.."<<NX<<endl;
 
        for (int i = 0; i < NY; i++) {
            for (int j = 0; j < NX; j++) {
              if (lat_gd[i][j] >= -80.) c1++;
                if (c1 == nbinx) {
                    NY1 = i;
                }
            }
            if (NY1 >= 0) break;
            c1 = 1;
        }
 
        for (int i = 0;i < NY; i++) {
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= 80.) {
                    NY2 = i - 1;
                }
            }
            if (NY2 >= 0) break;
        }
 
//        l1cfile->NY1 = NY1;
//        l1cfile->NY2 = NY2;
       NY1=0;
       NY2=NY-1;
//        
 
       NY = NY2 - NY1 + 1;
       cout<<"NY.after geographic constraint."<<NY<<"NY1.initial lat index ."<<NY1<<"NY2..final lat index."<<NY2<<"NX.."<<NX<<endl;
 
       lat_out = allocate2d_float(NY, NX);
       lon_out = allocate2d_float(NY, NX);
 
       int c=0;
        for (int i = NY1; i < NY2 + 1; i++) {
            for (int j = 0; j < NX; j++) {
                if(lon_gd[i][j]<0) lon_out[c][j]=lon_gd[i][j]+360;
                else lon_out[c][j]=lon_gd[i][j];
                lat_out[c][j] = lat_gd[i][j];
            }
        //    cout<<"gd#..."<<c+1<<endl;
            c++;
 
        }
 
        extstr = ".nc";
//        fname_out = pathstr + missionstr + "_" + senstr + "." + yearstr + monstr + daystr + timestr + prodstr+extstr;
  //      fname_out = pathstr + ofilestr+"_"+ prodstr+senstr+swtstr+swtnum+extstr;  
        fname_out=pathstr+"PACE_"+senstr+"."+tswt_ini_file+".L1C.5.2km"+prodstr+extstr;  
        cout<<"path..."<<pathstr<<"ofile.."<<ofilestr<<"prod.."<<prodstr<<endl;
 
        l1cfile->gridname = fname_out.c_str();
        filename_lt = fname_out.c_str();
        cout<<"creating file for L1C coor.with only POS LONGITUDE.."<<filename_lt<<endl;
//        if ((status = nc_create(filename_lt, NC_CLOBBER, &ncid_out)))
        if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
            check_err(status, __LINE__, __FILE__);
        //define dims
     // Define the dimensions,vars and attributes at the root level
      
 
  //DEF DIMENSIONS
        if ((status = nc_def_dim(ncid_out, "bins_across_track", NX, &x_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "bins_along_track", NY, &y_dimid)))
            check_err(status, __LINE__, __FILE__);
        //dims for output var
        dimids[0] = y_dimid;
        dimids[1] = x_dimid;
        NDIMS=2;
        if ((status = nc_def_dim(ncid_out, "number_of_views", NVIEWS, &v_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "intensity_bands_per_view", NBANDS, &b_dimid)))
            check_err(status, __LINE__, __FILE__);
 
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME1.c_str(), strlen(GATT_VAL1.c_str()),
          GATT_VAL1.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME2.c_str(), strlen(GATT_VAL2.c_str()),
          GATT_VAL2.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME3.c_str(), strlen(GATT_VAL3.c_str()),
          GATT_VAL3.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME4.c_str(), strlen(GATT_VAL4.c_str()),
          GATT_VAL4.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME5.c_str(), strlen(GATT_VAL5.c_str()),
          GATT_VAL5.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME6.c_str(), strlen(GATT_VAL6.c_str()),
          GATT_VAL6.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME7.c_str(), strlen(GATT_VAL7.c_str()),
          GATT_VAL7.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME8.c_str(), strlen(GATT_VAL8.c_str()),
          GATT_VAL8.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME9.c_str(), strlen(GATT_VAL9.c_str()),
          GATT_VAL9.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME10.c_str(), strlen(GATT_VAL10.c_str()),
          GATT_VAL10.c_str()))
           check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME11.c_str(), strlen(GATT_VAL11.c_str()),
          GATT_VAL11.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME12.c_str(), strlen(GATT_VAL12.c_str()),
          GATT_VAL12.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME13.c_str(), strlen(GATT_VAL13.c_str()),
                   GATT_VAL13.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME14.c_str(), strlen(GATT_VAL14.c_str()),
          GATT_VAL14.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME15.c_str(), strlen(GATT_VAL15.c_str()),
          GATT_VAL15.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME16.c_str(), strlen(GATT_VAL16.c_str()),
          GATT_VAL16.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME17.c_str(), strlen(GATT_VAL17.c_str()),
          GATT_VAL17.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME18.c_str(), strlen(GATT_VAL18.c_str()),
          GATT_VAL18.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME19.c_str(), strlen(GATT_VAL19.c_str()),
          GATT_VAL19.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME20.c_str(), strlen(GATT_VAL20.c_str()),
          GATT_VAL20.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME21.c_str(), strlen(GATT_VAL21.c_str()),
          GATT_VAL21.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME22.c_str(), strlen(GATT_VAL22.c_str()),
          GATT_VAL22.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME23.c_str(), strlen(GATT_VAL23.c_str()),
          GATT_VAL23.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME24.c_str(), strlen(GATT_VAL24.c_str()),
          GATT_VAL24.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME25.c_str(), strlen(GATT_VAL25.c_str()),
          GATT_VAL25.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME26.c_str(), strlen(GATT_VAL26.c_str()),
          GATT_VAL26.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME27.c_str(), strlen(GATT_VAL27.c_str()),
          GATT_VAL27.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME28.c_str(), strlen(GATT_VAL28.c_str()),
          GATT_VAL28.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME29.c_str(), strlen(GATT_VAL29.c_str()),
          GATT_VAL29.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME30.c_str(), strlen(GATT_VAL30.c_str()),
          GATT_VAL30.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME31.c_str(), strlen(GATT_VAL31.c_str()),
          GATT_VAL31.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME32.c_str(), strlen(GATT_VAL32.c_str()),
          GATT_VAL32.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME33.c_str(), strlen(GATT_VAL33.c_str()),
          GATT_VAL33.c_str()))
          check_err(status, __LINE__, __FILE__);
 
      //define groups                  check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_grp(ncid_out, "geolocation_data", &grp_coor)))  //netcdf-4
             check_err(status, __LINE__, __FILE__);
        //def var
        if ((status = nc_def_var(grp_coor, "latitude", NC_FLOAT, NDIMS,
                dimids, &varid1)))
                check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_var(grp_coor, "longitude", NC_FLOAT, NDIMS,
                dimids, &varid2)))
                check_err(status, __LINE__, __FILE__);
 
                    //leave define mode-----------------------
        if ((status = nc_enddef(grp_coor))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
 
        //writing the whole thing
        if ((status = nc_put_var_float(grp_coor, varid1, &lat_out[0][0])))
            check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_put_var_float(grp_coor, varid2, &lon_out[0][0])))
            check_err(status, __LINE__, __FILE__);
 
//define attributes of vars in groups
        if (nc_put_att_text(grp_coor, varid1, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(grp_coor, varid2, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
 
 
        if ((status = nc_close(ncid_out)))
           check_err(status, __LINE__, __FILE__);
 
 
        delete [] (lat_out);
        delete [] (lon_out);
        lat_out=nullptr;
        lon_out=nullptr;
 
 
 
//CASE INVERTED ALONG/ACROSS INDEXES ***************************************************************************
        prodstr = "L1Cgrid_inverted_";
 
 
        lat_out = allocate2d_float(NY, NX);
        lon_out = allocate2d_float(NY, NX);
 
        c = 0;
        for (int i = NY1; i < NY2 + 1; i++) {
            for (int j = 0; j < NX; j++) {
                lat_out[NY - 1 - c][NX - 1 - j] = lat_gd[i][j];
                lon_out[NY - 1 - c][j] = lon_gd[i][j];
            }
            c++;
        }
 
        extstr = ".nc";
//        fname_out = pathstr + missionstr + "_" + senstr + "." + yearstr + monstr + daystr + timestr + prodstr+extstr;
//        fname_out = pathstr + ofilestr+"_"+ prodstr+senstr+swtstr+swtnum+extstr;
        fname_out=pathstr+"PACE_"+senstr+"."+tswt_ini_file+".L1C.5.2km"+prodstr+extstr;
        l1cfile->gridname = fname_out.c_str();
        filename_lt = fname_out.c_str();
        cout<<"creating file for L1C coor.with x/y inverted indexes.."<<filename_lt<<endl;
//        if ((status = nc_create(filename_lt, NC_CLOBBER, &ncid_out)))
        if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
            check_err(status, __LINE__, __FILE__);
        //define dims
     // Define the dimensions,vars and attributes at the root level
 
 
  //DEF DIMENSIONS
        if ((status = nc_def_dim(ncid_out, "bins_across_track", NX, &x_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "bins_along_track", NY, &y_dimid)))
            check_err(status, __LINE__, __FILE__);
        //dims for output var
        dimids[0] = y_dimid;
        dimids[1] = x_dimid;
        NDIMS=2;
        if ((status = nc_def_dim(ncid_out, "number_of_views", NVIEWS, &v_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "intensity_bands_per_view", NBANDS, &b_dimid)))
            check_err(status, __LINE__, __FILE__);
 
 
 
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME1.c_str(), strlen(GATT_VAL1.c_str()),
          GATT_VAL1.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME2.c_str(), strlen(GATT_VAL2.c_str()),
          GATT_VAL2.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME3.c_str(), strlen(GATT_VAL3.c_str()),
          GATT_VAL3.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME4.c_str(), strlen(GATT_VAL4.c_str()),
          GATT_VAL4.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME5.c_str(), strlen(GATT_VAL5.c_str()),
          GATT_VAL5.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME6.c_str(), strlen(GATT_VAL6.c_str()),
          GATT_VAL6.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME7.c_str(), strlen(GATT_VAL7.c_str()),
          GATT_VAL7.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME8.c_str(), strlen(GATT_VAL8.c_str()),
          GATT_VAL8.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME9.c_str(), strlen(GATT_VAL9.c_str()),
          GATT_VAL9.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME10.c_str(), strlen(GATT_VAL10.c_str()),
          GATT_VAL10.c_str()))
           check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME11.c_str(), strlen(GATT_VAL11.c_str()),
          GATT_VAL11.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME12.c_str(), strlen(GATT_VAL12.c_str()),
          GATT_VAL12.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME13.c_str(), strlen(GATT_VAL13.c_str()),
          GATT_VAL13.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME14.c_str(), strlen(GATT_VAL14.c_str()),
          GATT_VAL14.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME15.c_str(), strlen(GATT_VAL15.c_str()),
          GATT_VAL15.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME16.c_str(), strlen(GATT_VAL16.c_str()),
          GATT_VAL16.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME17.c_str(), strlen(GATT_VAL17.c_str()),
                   GATT_VAL17.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME18.c_str(), strlen(GATT_VAL18.c_str()),
          GATT_VAL18.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME19.c_str(), strlen(GATT_VAL19.c_str()),
          GATT_VAL19.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME20.c_str(), strlen(GATT_VAL20.c_str()),
          GATT_VAL20.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME21.c_str(), strlen(GATT_VAL21.c_str()),
          GATT_VAL21.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME22.c_str(), strlen(GATT_VAL22.c_str()),
          GATT_VAL22.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME23.c_str(), strlen(GATT_VAL23.c_str()),
          GATT_VAL23.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME24.c_str(), strlen(GATT_VAL24.c_str()),
          GATT_VAL24.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME25.c_str(), strlen(GATT_VAL25.c_str()),
          GATT_VAL25.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME26.c_str(), strlen(GATT_VAL26.c_str()),
          GATT_VAL26.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME27.c_str(), strlen(GATT_VAL27.c_str()),
          GATT_VAL27.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME28.c_str(), strlen(GATT_VAL28.c_str()),
          GATT_VAL28.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME29.c_str(), strlen(GATT_VAL29.c_str()),
          GATT_VAL29.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME30.c_str(), strlen(GATT_VAL30.c_str()),
          GATT_VAL30.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME31.c_str(), strlen(GATT_VAL31.c_str()),
          GATT_VAL31.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME32.c_str(), strlen(GATT_VAL32.c_str()),
          GATT_VAL32.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME33.c_str(), strlen(GATT_VAL33.c_str()),
          GATT_VAL33.c_str()))
          check_err(status, __LINE__, __FILE__);
 
      //define groups                  check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_grp(ncid_out, "geolocation_data", &grp_coor)))  //netcdf-4
           check_err(status, __LINE__, __FILE__);
 
 
        //def var
        if ((status = nc_def_var(grp_coor, "latitude", NC_FLOAT, NDIMS,
                dimids, &varid1)))
                check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_var(grp_coor, "longitude", NC_FLOAT, NDIMS,
                dimids, &varid2)))
                check_err(status, __LINE__, __FILE__);
 
                    //leave define mode-----------------------
        if ((status = nc_enddef(grp_coor))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
        //writing the whole thing
        if ((status = nc_put_var_float(grp_coor, varid1, &lat_out[0][0])))
            check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_put_var_float(grp_coor, varid2, &lon_out[0][0])))
            check_err(status, __LINE__, __FILE__);
 
 
//define attributes of vars in groups
        if (nc_put_att_text(grp_coor, varid1, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(grp_coor, varid2, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
 
 
 
        if ((status = nc_close(ncid_out)))
           check_err(status, __LINE__, __FILE__);
 
 
        delete [] (lat_out);
        delete [] (lon_out);
        lat_out=nullptr;
        lon_out=nullptr;
 
 
 
//******** save az_east param as nc ***************************************************************
//az_east[count]
        prodstr="az_east_";
        extstr = ".nc";
//        fname_out = pathstr + ofilestr+"_"+ prodstr+senstr+extstr;
        fname_out=pathstr+"PACE_"+senstr+"."+tswt_ini_file+".L1C.5.2km"+prodstr+extstr;
        filename_lt = fname_out.c_str();
        cout<<"creating file for az_east values in degrees as nc format.."<<filename_lt<<endl;
//        if ((status = nc_create(filename_lt, NC_CLOBBER, &ncid_out)))
        if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
            check_err(status, __LINE__, __FILE__);
        //define dims
     // Define the dimensions,vars and attributes at the root level
 
 
  //DEF DIMENSIONS
        if ((status = nc_def_dim(ncid_out, "bins_along_track", NY, &y_dimid)))
            check_err(status, __LINE__, __FILE__);
//DEF VARIABLE
        if ((status = nc_def_var(ncid_out, "az_east", NC_FLOAT, 1,
                &y_dimid, &varid1)))
                check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_enddef(ncid_out))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
 
          for (int count = 0; count < num_gridlines; count++) {
                if (az_east[count] < 0.001) az_east[count] = 0.0;}
        //writing the whole thing
        if ((status = nc_put_var_float(ncid_out, varid1, &az_east[0])))
            check_err(status, __LINE__, __FILE__);
//close file
        if ((status = nc_close(ncid_out)))
           check_err(status, __LINE__, __FILE__);
 
         l1cfile->azeast_name = fname_out.c_str();
 
 
//***********************************************************************************************
        prodstr = "L1CgridV_";
        extstr=".csv";
 
        fname_out = pathstr + ofilestr+"_"+ prodstr+senstr+extstr;
 
        std::ofstream myl1cV(fname_out);
        for (int count = 0; count < num_gridlines;count++) {    
           if(count==1999 || count==2000){//equat crossing lines 
            for (int gp = 0; gp < nbinx; gp++) {
   //             lontemp = lon_gd[count][gp];
  //              if (lon_gd[count][gp] < -180.) lontemp = lon_gd[count][gp] + 360;
 //               if (lon_gd[count][gp] > +180.) lontemp = lon_gd[count][gp] - 360;
 //               if (lontemp < 0.) lontemp += 360.;//make better visualization, all lon values positive
 
//                myl1cV << lontemp << "," << lat_gd[count][gp] << endl;
                myl1cV << lon_gd[count][gp] << "," << lat_gd[count][gp] << endl;
                 }
 
 
           }
         }
 
 
        myl1cV.close();
 
 
        prodstr = "lat_nadpix_";
//        fname_out = pathstr + ofilestr+"_"+ prodstr+senstr+extstr;
        fname_out=pathstr+"PACE_"+senstr+"."+tswt_ini_file+".L1C.5.2km"+prodstr+extstr;  
        //   fname_out= "/accounts/mamontes/images/OCIS/out/"+"L1Cgrid_"+"lat_nadpix"+"_"+swtstr+".txt";
        //   ofstream myfile1 ("/accounts/mamontes/images/OCIS/lat_nadpix_swtd13again.txt");
        ofstream myfile1(fname_out);
        if (myfile1.is_open())
        {
            myfile1 << "lat_nadpix.\n";
            for (int count = 0; count < num_gridlines; count++) {
                //   for(int gp = 0; gp <nbinx; gp ++){
                myfile1 << lati2[count] << "," << endl;
            }
            myfile1.close();
        }
        else cout << "Unable to open file";
        prodstr = "lon_nadpix_";
//        fname_out = pathstr + ofilestr+"_"+ prodstr+senstr+extstr;
        fname_out=pathstr+"PACE_"+senstr+"."+tswt_ini_file+".L1C.5.2km"+prodstr+extstr;
        //  fname_out= "/accounts/mamontes/images/OCIS/out/"+"L1Cgrid_"+"lon_nadpix"+"_"+swtstr+".txt";
        //  ofstream myfile2 ("/accounts/mamontes/images/OCIS/lon_nadpix_swtd13again.txt");
        ofstream myfile2(fname_out);
        if (myfile2.is_open())
        {
            myfile2 << "lon_nadpix.\n";
            for (int count = 0; count < num_gridlines; count++) {
                //   for(int gp = 0; gp <nbinx; gp ++){
                myfile2 << loni2[count] << "," << endl;
            }
            myfile2.close();
        }
        else cout << "Unable to open file";
 
 
        if(lati_l!=nullptr)
        delete[](lati_l);
        if(lati_r!=nullptr)
        delete[](lati_r);
        if(loni_l!=nullptr)
        delete[](loni_l);
        if(loni_r!=nullptr)
        delete[](loni_r);
 
 
        cout << " SUCCESS writing results full L1C grid center positions for--swath #..." << swtd << "\n";
 
 
 
        return 0;
   }  
 
 
 
int32_t L1C::across_gridlines_l1c_vec(int swtd, l1c_filehandle* l1cfile, L1C_input* l1cinput,float* lati2, float* loni2, float** lat_gd, float** lon_gd, float* az_east) {
   int32_t num_gridlines, nbinx, NY1 = -1, NY2 = -1, c1 = 1;
        float lat1_l, lat1_r, lon1_l, lon1_r, lat2, lon2, dlambda, az_r, az_l, h,  *lati_l, *loni_l, *lati_r, *loni_r, htot = 0.,az=0.;
        int  ncid_out,x_dimid, y_dimid, varid1, varid2, status;
        int NDIMS=2;
        int dimids[NDIMS];
        int32_t NX, NY;
        int16_t selyear = -1, selmon = -1, selday = -1;
        double  latih, lonih, latih2, lonih2, res1, res2;
        float gres;
        int fnan1=0, fnan2=0, fnan3=0, fnan4=0;
        float latfirst = -999;
        int badline = 0;
        int grp_coor;
        const char* filename_lt;
        float **lat_out=nullptr,**lon_out=nullptr;
//        float **lt_out=nullptr;
        int NVIEWS, NBANDS,v_dimid,b_dimid;
 
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
 
        //compute azimuth angle for each along-track position (nadir pixel or centered swath pixel) of the swath
        //azimuth angle in rads
        //lon+540/360-180 is a normalization factor for -180 to 180 degrees   
        num_gridlines = l1cfile->num_gridlines;
        num_pixels = l1cfile->npix;
        nbinx = l1cfile->nbinx;
        lati_l = (float*)calloc(nbinx / 2 , sizeof(float));
        lati_r = (float*)calloc(nbinx / 2 , sizeof(float));
        loni_l = (float*)calloc(nbinx / 2 , sizeof(float));
        loni_r = (float*)calloc(nbinx / 2 , sizeof(float));
 
      //big loop
 
        int gd = 0;
 
 
        //compute mean az_east---
        float sum = 0., tot = 0.;
        size_t azc = 0;
        for (int i = 0;i < num_gridlines - 2;i++) {
 
        //    cout<<"gd#.."<<i+1<<"lati2[i].."<<lati2[i]<<endl;
 
            //assign central positions---
            lat1_l = lati2[i] * M_PI / 180.;
            lat1_r = lati2[i] * M_PI / 180.;
            lat2 = lati2[i + 1] * M_PI / 180.;
            lon1_l = loni2[i] * M_PI / 180.;
            lon1_r = loni2[i] * M_PI / 180.;
            lon2 = loni2[i + 1] * M_PI / 180.;
 
            dlambda = (lon2 - lon1_l);
            //bearing---
            //make sure there are not NAN values ----------
            az = atan2(sin(dlambda) * cos(lat2), cos(lat1_l) * sin(lat2) - sin(lat1_l) * cos(lat2) * cos(dlambda));
 
            //     cout<<lat2<<"..."<<lat1_l<<".."<<dlambda<<az*180/M_PI<<endl;
            if (az > M_PI || az < -M_PI) {
                cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "az in degrees.." << az * 180 / M_PI << endl;
                exit(1);
            }
            if (isnan(az) < 1) {
                //       cout<<"az.."<<az<<"azcount"<<azc<<endl;
                az_r = (az + M_PI / 2.);
                az_east[i] = az_r * 180. / M_PI;
                if (az_east[i] < 0.0001 && az_east[i]>0) az_east[i] = 0.0;
                sum = az_east[i];
                tot += sum;
                azc++;
            }
            else {
                az_east[i] = NAN;
                 }
        }
        float mean_az_east = tot / (azc);
 
        cout << "recomputed mean_az_east..(based on second interp rather than first interp)" << mean_az_east << "num_gridlines.." << num_gridlines-2 << endl;
 
 
        for (int j = 0;j < num_gridlines - 2;j++) {
            az_east[j] = mean_az_east;
        }
 
        l1cfile->mean_az_east = mean_az_east;
 
        for (int i = 0;i < num_gridlines - 2;i++) {
 
            if (i % 1 == 0) {
                //assign central positions---
                lat1_l = lati2[i] * M_PI / 180.;
                lat1_r = lati2[i] * M_PI / 180.;
                lat2 = lati2[i + 1] * M_PI / 180.;
                lon1_l = loni2[i] * M_PI / 180.;
                lon1_r = loni2[i] * M_PI / 180.;
                lon2 = loni2[i + 1] * M_PI / 180.;
 
                dlambda = (lon2 - lon1_l);
 
 
                gres = (l1cinput->gres) * 1000; //grid resolution in meters
 
               //bearing---
               //this is Harverside--law f cosines is more accurate---
                az = atan2(sin(dlambda) * cos(lat2), cos(lat1_l) * sin(lat2) - sin(lat1_l) * cos(lat2) * cos(dlambda));
                if (az > M_PI || az < -M_PI) {
                    cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "az in degrees.." << az * 180 / M_PI << endl;
                    exit(1);
                }
 
                //compute RIGHT across-gridline pixels---
                for (int k = 0;k < (nbinx / 2);k++) {
                    h = (l1cinput->gres);//distance between along positions in km, must be 5.2 k m for L1C
                    if (k == 0) h /= 2;//if nadpix
                    htot += h;
 
                    //right pixels---
                    az_r = mean_az_east * degrad;
 
                    //left pixels---
                    az_l = az_r - M_PI;
 
                         //bearing should be always positive (clockwise) before pixel location calculation based on Harverside---
                    if (az_r < 0.) {
                        az_r = 360 + az_r * 180 / M_PI;
                        az_r = az_r * M_PI / 180;
                    }
 
                    if (az_l < 0.) {
                        az_l = 360 + az_l * 180 / M_PI;
                        az_l = az_l * M_PI / 180;
                    }
 
                    geod.Direct(lat1_r * 180 / M_PI, lon1_r * 180 / M_PI, az_r * 180 / M_PI, gres, latih, lonih);
                    geod.Inverse(lat1_r * 180 / M_PI, lon1_r * 180 / M_PI, latih, lonih, res1);
 
               /*     if(i==0){
                       cout<<"gd#..."<<i+1<<"az_r.."<<az_r* 180 / M_PI<<"az_l.."<<az_l* 180 / M_PI<<endl;
                       cout<<"lat1_r.."<<lat1_r<<"lon1_r.."<<lon1_r<<"latih.."<<latih<<"lonih.."<<lonih<<"res1.."<<res1<<endl;
                    }
                   */ 
 
                    fnan1 = isnan(latih);
                    fnan2 = isnan(lonih);
                    lati_r[k] = latih;
                    loni_r[k] = lonih;
                    //     cout<<"righside.."<<latih<<"..."<<lonih<<"res1"<<res1<<endl;
 
                    lat1_r = lati_r[k] * M_PI / 180;
                    lon1_r = loni_r[k] * M_PI / 180;
 
                    geod.Direct(lat1_l * 180 / M_PI, lon1_l * 180 / M_PI, az_l * 180 / M_PI, gres, latih2, lonih2);
                    geod.Inverse(lat1_l * 180 / M_PI, lon1_l * 180 / M_PI, latih2, lonih2, res2);
                    fnan3 = isnan(latih2);
                    fnan4 = isnan(lonih2);
                    lati_l[k] = latih2;
                    loni_l[k] = lonih2;
                    //     cout<<"leftside.."<<latih2<<"..."<<lonih2<<"res2"<<res2<<endl;
 
                    lat1_l = lati_l[k] * M_PI / 180;
                    lon1_l = loni_l[k] * M_PI / 180;
 
                      //right swath side------------- //we tolerate +- 6 m error
                    if (lati2[i]<=80 && (fnan1 > 0 || fnan2 > 0 || res1 > (gres + 6) || res1 < (gres - 6) || lati2[i + 1] < lati2[i] || lati2[i] < latfirst)) { //nan values
                        badline++;
                        if (badline == 1) {
                            latfirst = lati2[i];
                        }
 
                //        cout << "bad interpolation - missing orbital data at near nadir grid cell..NAN right side of line.." << i + 1 << "corresponding to lat..."<<latfirst <<"lati2[i].."<<lati2[i]<<endl;
                //        cout<<"gd.."<<gd+1<<"XBIN.."<<k+1<<"lati_l[k]"<<lati_l[k]<<"loni_l[k]"<<loni_l[k]<<"lati_r[k]"<<lati_r[k]<<"loni_r[k]"<<loni_r[k]<<endl;
                        
                        lati2[i] = NAN;
                        loni2[i] = NAN;
 
                        for (int k = 0;k < (nbinx / 2);k++) {
                            lat_gd[gd][k + nbinx / 2] = NAN;
                            lon_gd[gd][k + nbinx / 2] = NAN;
                        }
                        //       cout<<"nan value.right.."<<endl;
                    }
                    else {
                        lat_gd[gd][k + nbinx / 2] = latih;
                        lon_gd[gd][k + nbinx / 2] = lonih;
                }
 
                    //left side
                    if (lati2[i]<=80 && (fnan3 > 0 || fnan4 > 0 || res2 > (gres + 6) || res2 < (gres - 6) || lati2[i + 1] < lati2[i] || lati2[i] < latfirst)) {
                        //     if(fnan3>0 | fnan4>0 |  res2>(gres+6) | res2<(gres-6)){
                  //      cout << "bad interpolation - missing orbital data at near nadir grid cell..NAN left side of line.." << i + 1 << endl;
                  //      cout<<"gd.."<<gd+1<<"XBIN.."<<k+1<<"lati_l[k]"<<lati_l[k]<<"loni_l[k]"<<loni_l[k]<<"lati_r[k]"<<lati_r[k]<<"loni_r[k]"<<loni_r[k]<<"lati2[i].."<<lati2[i]<<endl;
                        
                        lati2[i] = NAN;
                        loni2[i] = NAN;
                        for (int k = 0;k < (nbinx / 2);k++) {
                            lat_gd[gd][nbinx / 2 - 1 - k] = NAN;//as k increases we are farther away from nadpix or along-track position---
                            lon_gd[gd][nbinx / 2 - 1 - k] = NAN;
                         }
                        //       cout<<"nan value.left.."<<endl;
                    }
                    else {
                        lat_gd[gd][nbinx / 2 - 1 - k] = latih2;//as k increases we are farther away from nadpix or along-track position---
                        lon_gd[gd][nbinx / 2 - 1 - k] = lonih2;
                       }
                fnan1=0;
                fnan2=0;
                fnan3=0;
                fnan4=0;
 
                }//end pixel loop
 
 
                htot = 0;
                gd++;
            }//end if every 100 gd
        }//end gridlines loop
        cout << "`L1C gridding successful!......................................." << endl;
 
 
//---- writing results -------------------------------------------
//--------------------------------------------------------------
        
         float lontemp = 0.;
        selday = l1cinput->selday;
        selmon = l1cinput->selmon;
        selyear = l1cinput->selyear;
 
        std::string timestr,missionstr,fname_out, pathstr, senstr, monstr, daystr, yearstr, prodstr, gdstr, swtstr, swtnum, extstr,ofilestr;
        pathstr = "out/";
        missionstr="PACE";
        senstr = "OCIS";
        monstr = std::to_string(selmon);
        daystr = std::to_string(selday);
        yearstr = std::to_string(selyear);
        timestr="T00:00:00Z";
        prodstr = "L1Cgrid";
        //   gdstr="_gdFULL_";
        swtstr = "_swt";
        swtnum = std::to_string(swtd);
 
        extstr = ".nc";
        ofilestr=std::string(l1cinput->ofile);
 
        fname_out = pathstr + ofilestr+"_"+ prodstr+swtstr+swtnum+extstr;
 
        string  ATT_NAME="Units", ATT_VAL="degrees",GATT_NAME1="Title",GATT_VAL1="PACE OCI Level-1C Data",GATT_NAME2="instrument",GATT_VAL2="OCI",GATT_NAME3="processing_version",GATT_VAL3="V1.0",GATT_NAME4="Conventions",GATT_VAL4="CF-1.6";
        string GATT_NAME5="institution",GATT_VAL5="NASA Goddard Space Flight Center, Ocean Biology Processing Group",GATT_NAME6="license",GATT_VAL6="http://science.nasa.gov/earth-science/earth-science-data/data-information-policy/";
        string GATT_NAME7="naming_authority",GATT_VAL7="gov.nasa.gsfc.sci.oceancolor",GATT_NAME8="keywords_vocabulary",GATT_VAL8="NASA Global Change Master Directory (GCMD) Science Keywords";
        string GATT_NAME9="stdname_vocabulary",GATT_VAL9="NetCDF Climate and Forecast (CF) Metadata Convention",GATT_NAME10="creator_name",GATT_VAL10="NASA/GSFC",GATT_NAME11="creator_email",GATT_VAL11="data@oceancolor.gsfc.nasa.gov";
        string GATT_NAME12="creator_url",GATT_VAL12="http://oceancolor.gsfc.nasa.gov",GATT_NAME13="project",GATT_VAL13="PACE Project",GATT_NAME14="publisher_name",GATT_VAL14="NASA/GSFC";
        string GATT_NAME15="publisher_email",GATT_VAL15="data@oceancolor.gsfc.nasa.gov",GATT_NAME16="publisher_url",GATT_VAL16="http://oceancolor.gsfc.nasa.gov",GATT_NAME17="processing_level",GATT_VAL17="L1C";
        string GATT_NAME18="cdm_data_type",GATT_VAL18="swath",GATT_NAME19="orbit_number",GATT_VAL19="12345",GATT_NAME20="history",GATT_VAL20="",GATT_NAME21="CDL_version_date",GATT_VAL21="2021-09-10",GATT_NAME22="product_name",GATT_VAL22=fname_out;
        string GATT_NAME23="startDirection",GATT_VAL23="Ascending",GATT_NAME24="endDirection",GATT_VAL24="Ascending",GATT_NAME25="time_coverage_start",GATT_VAL25=yearstr+"-"+monstr+"-"+daystr+"-"+timestr,GATT_NAME26="time_coverage_end",GATT_VAL26=yearstr+"-"+monstr+"-"+daystr+"-"+timestr,GATT_NAME27="date{_created",GATT_VAL27="2021-09-10T15:12:41Z",GATT_NAME28="sun_earth_distance",GATT_VAL28="0.990849042172323",GATT_NAME29="terrain_data_source",GATT_VAL29="",GATT_NAME30="spectral_response_function",GATT_VAL30="",GATT_NAME31="systematic_uncertainty_model",GATT_VAL31="",GATT_NAME32="nadir_bin",GATT_VAL32="12345",GATT_NAME33="bin_size_at_nadir",GATT_VAL33="2.6km2";
 
 
        l1cfile->gridname = fname_out.c_str();
        filename_lt = fname_out.c_str();
 
        cout<<"creating file for L1C coor..."<<filename_lt<<endl;
 
       
        if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
            check_err(status, __LINE__, __FILE__);
        //define dims
     // Define the dimensions,vars and attributes at the root level
        NY = num_gridlines-2;
        NX = nbinx;
        NVIEWS= 2;//for OCI
        NBANDS=249;
//        lt_out = allocate2d_float(NY, NX);
  //DEF DIMENSIONS
        if ((status = nc_def_dim(ncid_out, "bins_across_track", NX, &x_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "bins_along_track", NY, &y_dimid)))
            check_err(status, __LINE__, __FILE__);
        //dims for output var
        dimids[0] = y_dimid;
        dimids[1] = x_dimid;
        NDIMS=2;
        if ((status = nc_def_dim(ncid_out, "number_of_views", NVIEWS, &v_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "intensity_bands_per_view", NBANDS, &b_dimid)))
            check_err(status, __LINE__, __FILE__);
        //define attributes
//       if (nc_put_att_text(ncid_out, varid1, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
//           check_err(status, __LINE__, __FILE__);
//       if (nc_put_att_text(ncid_out, varid2, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
//           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME1.c_str(), strlen(GATT_VAL1.c_str()),
          GATT_VAL1.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME2.c_str(), strlen(GATT_VAL2.c_str()),
          GATT_VAL2.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME3.c_str(), strlen(GATT_VAL3.c_str()),
          GATT_VAL3.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME4.c_str(), strlen(GATT_VAL4.c_str()),
          GATT_VAL4.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME5.c_str(), strlen(GATT_VAL5.c_str()),
          GATT_VAL5.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME6.c_str(), strlen(GATT_VAL6.c_str()),
          GATT_VAL6.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME7.c_str(), strlen(GATT_VAL7.c_str()),
          GATT_VAL7.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME8.c_str(), strlen(GATT_VAL8.c_str()),
          GATT_VAL8.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME9.c_str(), strlen(GATT_VAL9.c_str()),
          GATT_VAL9.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME10.c_str(), strlen(GATT_VAL10.c_str()),
          GATT_VAL10.c_str()))
           check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME11.c_str(), strlen(GATT_VAL11.c_str()),
          GATT_VAL11.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME12.c_str(), strlen(GATT_VAL12.c_str()),
          GATT_VAL12.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME13.c_str(), strlen(GATT_VAL13.c_str()),
          GATT_VAL13.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME14.c_str(), strlen(GATT_VAL14.c_str()),
          GATT_VAL14.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME15.c_str(), strlen(GATT_VAL15.c_str()),
          GATT_VAL15.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME16.c_str(), strlen(GATT_VAL16.c_str()),
          GATT_VAL16.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME17.c_str(), strlen(GATT_VAL17.c_str()),
          GATT_VAL17.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME18.c_str(), strlen(GATT_VAL18.c_str()),
          GATT_VAL18.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME19.c_str(), strlen(GATT_VAL19.c_str()),
          GATT_VAL19.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME20.c_str(), strlen(GATT_VAL20.c_str()),
          GATT_VAL20.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME21.c_str(), strlen(GATT_VAL21.c_str()),
          GATT_VAL21.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME22.c_str(), strlen(GATT_VAL22.c_str()),
          GATT_VAL22.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME23.c_str(), strlen(GATT_VAL23.c_str()),
          GATT_VAL23.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME24.c_str(), strlen(GATT_VAL24.c_str()),
          GATT_VAL24.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME25.c_str(), strlen(GATT_VAL25.c_str()),
          GATT_VAL25.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME26.c_str(), strlen(GATT_VAL26.c_str()),
          GATT_VAL26.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME27.c_str(), strlen(GATT_VAL27.c_str()),
          GATT_VAL27.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME28.c_str(), strlen(GATT_VAL28.c_str()),
          GATT_VAL28.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME29.c_str(), strlen(GATT_VAL29.c_str()),
          GATT_VAL29.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME30.c_str(), strlen(GATT_VAL30.c_str()),
          GATT_VAL30.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME31.c_str(), strlen(GATT_VAL31.c_str()),
          GATT_VAL31.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME32.c_str(), strlen(GATT_VAL32.c_str()),
          GATT_VAL32.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME33.c_str(), strlen(GATT_VAL33.c_str()),
          GATT_VAL33.c_str()))
          check_err(status, __LINE__, __FILE__);
 
      //define groups                  check_err(status, __LINE__, __FILE__);
       if ((status = nc_def_grp(ncid_out, "geolocation_data", &grp_coor)))  //netcdf-4
          check_err(status, __LINE__, __FILE__);
        //def var
        if ((status = nc_def_var(grp_coor, "latitude", NC_FLOAT, NDIMS,
                dimids, &varid1)))
                check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_var(grp_coor, "longitude", NC_FLOAT, NDIMS,
                dimids, &varid2)))
                check_err(status, __LINE__, __FILE__);
    //leave define mode-----------------------
        if ((status = nc_enddef(grp_coor))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
 
 
        //writing the whole thing
        if ((status = nc_put_var_float(grp_coor, varid1, &lat_gd[0][0])))
            check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_put_var_float(grp_coor, varid2, &lon_gd[0][0])))
            check_err(status, __LINE__, __FILE__);
 
 
 
//define attributes of vars in groups
//UNITS in degrees ----
        if (nc_put_att_text(grp_coor, varid1, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
         check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(grp_coor, varid2, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
 
 
//close file
        if ((status = nc_close(ncid_out)))
           check_err(status, __LINE__, __FILE__);
 
//        delete [] (lt_out);
 
//CASE ONLY LON POS VALUES***************************************************************************
 
        //Only positive longitude 0-360 degrees for visualization ****************************************************************
        //lat lon grid for visualization--
        prodstr = "L1Cgrid_lonpos";
        //   gdstr="_gdFULL_";
        //recompute number of gridlines based on lat limits -80 to 80 degrees
        //asc orbit goes from negative to positive latitude....
 
        NY = num_gridlines-2;
        NX = nbinx;
 
        cout<<"NY before geographic constraint."<<NY<<"NY1.initial lat index ."<<NY1<<"NY2..final lat index."<<NY2<<"NX.."<<NX<<endl;
 
        for (int i = 0; i < NY; i++) {
            for (int j = 0; j < NX; j++) {
              if (lat_gd[i][j] >= -80.) c1++;
                if (c1 == nbinx) {
                    NY1 = i;
                }
            }
            if (NY1 >= 0) break;
            c1 = 1;
        }
 
        for (int i = 0;i < NY; i++) {
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= 80.) {
                    NY2 = i - 1;
                }
            }
            if (NY2 >= 0) break;
        }
 
        l1cfile->NY1 = NY1;
        l1cfile->NY2 = NY2;
 
       NY = NY2 - NY1 + 1;
       cout<<"NY.after geographic constraint."<<NY<<"NY1.initial lat index ."<<NY1<<"NY2..final lat index."<<NY2<<"NX.."<<NX<<endl;
 
       lat_out = allocate2d_float(NY, NX);
       lon_out = allocate2d_float(NY, NX);
 
       int c=0;
        for (int i = NY1; i < NY2 + 1; i++) {
            for (int j = 0; j < NX; j++) {
                if(lon_gd[i][j]<0) lon_out[c][j]=lon_gd[i][j]+360;
                else lon_out[c][j]=lon_gd[i][j];
                lat_out[c][j] = lat_gd[i][j];
            }
        //    cout<<"gd#..."<<c+1<<endl;
            c++;
 
        }
 
        extstr = ".nc";
//        fname_out = pathstr + missionstr + "_" + senstr + "." + yearstr + monstr + daystr + timestr + prodstr+extstr;
        fname_out = pathstr + ofilestr+"_"+ prodstr+swtstr+swtnum+extstr;  
        cout<<"path..."<<pathstr<<"ofile.."<<ofilestr<<"prod.."<<prodstr<<endl;
 
        l1cfile->gridname = fname_out.c_str();
        filename_lt = fname_out.c_str();
        cout<<"creating file for L1C coor.with only POS LONGITUDE.."<<filename_lt<<endl;
//        if ((status = nc_create(filename_lt, NC_CLOBBER, &ncid_out)))
        if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
            check_err(status, __LINE__, __FILE__);
        //define dims
     // Define the dimensions,vars and attributes at the root level
      
 
  //DEF DIMENSIONS
        if ((status = nc_def_dim(ncid_out, "bins_across_track", NX, &x_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "bins_along_track", NY, &y_dimid)))
            check_err(status, __LINE__, __FILE__);
        //dims for output var
        dimids[0] = y_dimid;
        dimids[1] = x_dimid;
        NDIMS=2;
        if ((status = nc_def_dim(ncid_out, "number_of_views", NVIEWS, &v_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "intensity_bands_per_view", NBANDS, &b_dimid)))
            check_err(status, __LINE__, __FILE__);
 
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME1.c_str(), strlen(GATT_VAL1.c_str()),
          GATT_VAL1.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME2.c_str(), strlen(GATT_VAL2.c_str()),
          GATT_VAL2.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME3.c_str(), strlen(GATT_VAL3.c_str()),
          GATT_VAL3.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME4.c_str(), strlen(GATT_VAL4.c_str()),
          GATT_VAL4.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME5.c_str(), strlen(GATT_VAL5.c_str()),
          GATT_VAL5.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME6.c_str(), strlen(GATT_VAL6.c_str()),
          GATT_VAL6.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME7.c_str(), strlen(GATT_VAL7.c_str()),
          GATT_VAL7.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME8.c_str(), strlen(GATT_VAL8.c_str()),
          GATT_VAL8.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME9.c_str(), strlen(GATT_VAL9.c_str()),
          GATT_VAL9.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME10.c_str(), strlen(GATT_VAL10.c_str()),
          GATT_VAL10.c_str()))
           check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME11.c_str(), strlen(GATT_VAL11.c_str()),
          GATT_VAL11.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME12.c_str(), strlen(GATT_VAL12.c_str()),
          GATT_VAL12.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME13.c_str(), strlen(GATT_VAL13.c_str()),
                   GATT_VAL13.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME14.c_str(), strlen(GATT_VAL14.c_str()),
          GATT_VAL14.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME15.c_str(), strlen(GATT_VAL15.c_str()),
          GATT_VAL15.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME16.c_str(), strlen(GATT_VAL16.c_str()),
          GATT_VAL16.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME17.c_str(), strlen(GATT_VAL17.c_str()),
          GATT_VAL17.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME18.c_str(), strlen(GATT_VAL18.c_str()),
          GATT_VAL18.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME19.c_str(), strlen(GATT_VAL19.c_str()),
          GATT_VAL19.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME20.c_str(), strlen(GATT_VAL20.c_str()),
          GATT_VAL20.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME21.c_str(), strlen(GATT_VAL21.c_str()),
          GATT_VAL21.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME22.c_str(), strlen(GATT_VAL22.c_str()),
          GATT_VAL22.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME23.c_str(), strlen(GATT_VAL23.c_str()),
          GATT_VAL23.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME24.c_str(), strlen(GATT_VAL24.c_str()),
          GATT_VAL24.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME25.c_str(), strlen(GATT_VAL25.c_str()),
          GATT_VAL25.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME26.c_str(), strlen(GATT_VAL26.c_str()),
          GATT_VAL26.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME27.c_str(), strlen(GATT_VAL27.c_str()),
          GATT_VAL27.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME28.c_str(), strlen(GATT_VAL28.c_str()),
          GATT_VAL28.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME29.c_str(), strlen(GATT_VAL29.c_str()),
          GATT_VAL29.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME30.c_str(), strlen(GATT_VAL30.c_str()),
          GATT_VAL30.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME31.c_str(), strlen(GATT_VAL31.c_str()),
          GATT_VAL31.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME32.c_str(), strlen(GATT_VAL32.c_str()),
          GATT_VAL32.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME33.c_str(), strlen(GATT_VAL33.c_str()),
          GATT_VAL33.c_str()))
          check_err(status, __LINE__, __FILE__);
 
      //define groups                  check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_grp(ncid_out, "geolocation_data", &grp_coor)))  //netcdf-4
             check_err(status, __LINE__, __FILE__);
        //def var
        if ((status = nc_def_var(grp_coor, "latitude", NC_FLOAT, NDIMS,
                dimids, &varid1)))
                check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_var(grp_coor, "longitude", NC_FLOAT, NDIMS,
                dimids, &varid2)))
                check_err(status, __LINE__, __FILE__);
 
                    //leave define mode-----------------------
        if ((status = nc_enddef(grp_coor))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
 
        //writing the whole thing
        if ((status = nc_put_var_float(grp_coor, varid1, &lat_out[0][0])))
            check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_put_var_float(grp_coor, varid2, &lon_out[0][0])))
            check_err(status, __LINE__, __FILE__);
 
//define attributes of vars in groups
        if (nc_put_att_text(grp_coor, varid1, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(grp_coor, varid2, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
 
 
        if ((status = nc_close(ncid_out)))
           check_err(status, __LINE__, __FILE__);
 
 
        delete [] (lat_out);
        delete [] (lon_out);
        lat_out=nullptr;
        lon_out=nullptr;
 
 
 
//CASE INVERTED ALONG/ACROSS INDEXES ***************************************************************************
        prodstr = "L1Cgrid_inverted";
 
 
        lat_out = allocate2d_float(NY, NX);
        lon_out = allocate2d_float(NY, NX);
 
        c = 0;
        for (int i = NY1; i < NY2 + 1; i++) {
            for (int j = 0; j < NX; j++) {
                lat_out[NY - 1 - c][NX - 1 - j] = lat_gd[i][j];
                lon_out[NY - 1 - c][j] = lon_gd[i][j];
            }
            c++;
        }
 
        extstr = ".nc";
//        fname_out = pathstr + missionstr + "_" + senstr + "." + yearstr + monstr + daystr + timestr + prodstr+extstr;
        fname_out = pathstr + ofilestr+"_"+ prodstr+swtstr+swtnum+extstr;
        l1cfile->gridname = fname_out.c_str();
        filename_lt = fname_out.c_str();
        cout<<"creating file for L1C coor.with x/y inverted indexes.."<<filename_lt<<endl;
//        if ((status = nc_create(filename_lt, NC_CLOBBER, &ncid_out)))
        if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
            check_err(status, __LINE__, __FILE__);
        //define dims
     // Define the dimensions,vars and attributes at the root level
 
 
  //DEF DIMENSIONS
        if ((status = nc_def_dim(ncid_out, "bins_across_track", NX, &x_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "bins_along_track", NY, &y_dimid)))
            check_err(status, __LINE__, __FILE__);
        //dims for output var
        dimids[0] = y_dimid;
        dimids[1] = x_dimid;
        NDIMS=2;
        if ((status = nc_def_dim(ncid_out, "number_of_views", NVIEWS, &v_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "intensity_bands_per_view", NBANDS, &b_dimid)))
            check_err(status, __LINE__, __FILE__);
/*
//def variables at the root level!
        if ((status = nc_def_var(ncid_out, "latitude", NC_FLOAT, NDIMS,
                dimids, &varid1)))
                check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_var(ncid_out, "longitude", NC_FLOAT, NDIMS,
                dimids, &varid2)))
                check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_enddef(ncid_out))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
        if ((status = nc_put_var_float(ncid_out, varid1, &lat_out[0][0])))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_put_var_float(ncid_out, varid2, &lon_out[0][0])))
            check_err(status, __LINE__, __FILE__);
 
//define attributes
       if (nc_put_att_text(ncid_out, varid1, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, varid2, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str())) 
           check_err(status, __LINE__, __FILE__);
*/
 
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME1.c_str(), strlen(GATT_VAL1.c_str()),
          GATT_VAL1.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME2.c_str(), strlen(GATT_VAL2.c_str()),
          GATT_VAL2.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME3.c_str(), strlen(GATT_VAL3.c_str()),
          GATT_VAL3.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME4.c_str(), strlen(GATT_VAL4.c_str()),
          GATT_VAL4.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME5.c_str(), strlen(GATT_VAL5.c_str()),
          GATT_VAL5.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME6.c_str(), strlen(GATT_VAL6.c_str()),
          GATT_VAL6.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME7.c_str(), strlen(GATT_VAL7.c_str()),
          GATT_VAL7.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME8.c_str(), strlen(GATT_VAL8.c_str()),
          GATT_VAL8.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME9.c_str(), strlen(GATT_VAL9.c_str()),
          GATT_VAL9.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME10.c_str(), strlen(GATT_VAL10.c_str()),
          GATT_VAL10.c_str()))
           check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME11.c_str(), strlen(GATT_VAL11.c_str()),
          GATT_VAL11.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME12.c_str(), strlen(GATT_VAL12.c_str()),
          GATT_VAL12.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME13.c_str(), strlen(GATT_VAL13.c_str()),
          GATT_VAL13.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME14.c_str(), strlen(GATT_VAL14.c_str()),
          GATT_VAL14.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME15.c_str(), strlen(GATT_VAL15.c_str()),
          GATT_VAL15.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME16.c_str(), strlen(GATT_VAL16.c_str()),
          GATT_VAL16.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME17.c_str(), strlen(GATT_VAL17.c_str()),
                   GATT_VAL17.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME18.c_str(), strlen(GATT_VAL18.c_str()),
          GATT_VAL18.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME19.c_str(), strlen(GATT_VAL19.c_str()),
          GATT_VAL19.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME20.c_str(), strlen(GATT_VAL20.c_str()),
          GATT_VAL20.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME21.c_str(), strlen(GATT_VAL21.c_str()),
          GATT_VAL21.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME22.c_str(), strlen(GATT_VAL22.c_str()),
          GATT_VAL22.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME23.c_str(), strlen(GATT_VAL23.c_str()),
          GATT_VAL23.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME24.c_str(), strlen(GATT_VAL24.c_str()),
          GATT_VAL24.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME25.c_str(), strlen(GATT_VAL25.c_str()),
          GATT_VAL25.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME26.c_str(), strlen(GATT_VAL26.c_str()),
          GATT_VAL26.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME27.c_str(), strlen(GATT_VAL27.c_str()),
          GATT_VAL27.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME28.c_str(), strlen(GATT_VAL28.c_str()),
          GATT_VAL28.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME29.c_str(), strlen(GATT_VAL29.c_str()),
          GATT_VAL29.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME30.c_str(), strlen(GATT_VAL30.c_str()),
          GATT_VAL30.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME31.c_str(), strlen(GATT_VAL31.c_str()),
          GATT_VAL31.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME32.c_str(), strlen(GATT_VAL32.c_str()),
          GATT_VAL32.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME33.c_str(), strlen(GATT_VAL33.c_str()),
          GATT_VAL33.c_str()))
          check_err(status, __LINE__, __FILE__);
 
      //define groups                  check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_grp(ncid_out, "geolocation_data", &grp_coor)))  //netcdf-4
           check_err(status, __LINE__, __FILE__);
/*
//DEF DIMENSIONS
        if ((status = nc_def_dim(grp_coor, "x", NX, &x_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(grp_coor, "y", NY, &y_dimid)))
            check_err(status, __LINE__, __FILE__);
        dimids[0] = y_dimid;
        dimids[1] = x_dimid;
        NDIMS=2;
*/
        //def var
        if ((status = nc_def_var(grp_coor, "latitude", NC_FLOAT, NDIMS,
                dimids, &varid1)))
                check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_var(grp_coor, "longitude", NC_FLOAT, NDIMS,
                dimids, &varid2)))
                check_err(status, __LINE__, __FILE__);
 
                    //leave define mode-----------------------
        if ((status = nc_enddef(grp_coor))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
        //writing the whole thing
        if ((status = nc_put_var_float(grp_coor, varid1, &lat_out[0][0])))
            check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_put_var_float(grp_coor, varid2, &lon_out[0][0])))
            check_err(status, __LINE__, __FILE__);
 
 
//define attributes of vars in groups
        if (nc_put_att_text(grp_coor, varid1, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(grp_coor, varid2, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
 
 
 
        if ((status = nc_close(ncid_out)))
           check_err(status, __LINE__, __FILE__);
 
 
        delete [] (lat_out);
        delete [] (lon_out);
        lat_out=nullptr;
        lon_out=nullptr;
 
 
 
//******** save az_east param as nc ***************************************************************
//az_east[count]
        prodstr="az_east";
        extstr = ".nc";
        fname_out = pathstr + ofilestr+"_"+ prodstr+extstr;
        filename_lt = fname_out.c_str();
        cout<<"creating file for az_east values in degrees as nc format.."<<filename_lt<<endl;
//        if ((status = nc_create(filename_lt, NC_CLOBBER, &ncid_out)))
        if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
            check_err(status, __LINE__, __FILE__);
        //define dims
     // Define the dimensions,vars and attributes at the root level
 
 
  //DEF DIMENSIONS
        if ((status = nc_def_dim(ncid_out, "bins_along_track", NY, &y_dimid)))
            check_err(status, __LINE__, __FILE__);
//DEF VARIABLE
        if ((status = nc_def_var(ncid_out, "az_east", NC_FLOAT, 1,
                &y_dimid, &varid1)))
                check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_enddef(ncid_out))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
 
          for (int count = 0; count < num_gridlines - 2; count++) {
                if (az_east[count] < 0.001) az_east[count] = 0.0;}
        //writing the whole thing
        if ((status = nc_put_var_float(ncid_out, varid1, &az_east[0])))
            check_err(status, __LINE__, __FILE__);
//close file
        if ((status = nc_close(ncid_out)))
           check_err(status, __LINE__, __FILE__);
 
 
//***********************************************************************************************
        prodstr = "L1CgridV";
        extstr=".csv";
 
        fname_out = pathstr + ofilestr+"_"+ prodstr+extstr;
        //   std::ofstream myl1c("/accounts/mamontes/images/OCIS/swt1_ALLgd_L1C500_swtd13again.csv");
        std::ofstream myl1cV(fname_out);
        for (int count = 0; count < num_gridlines - 2;count++) {
            //         for(int count = 0; count <num_gridlines/100;count ++){
            for (int gp = 0; gp < nbinx; gp++) {
                lontemp = lon_gd[count][gp];
                if (lon_gd[count][gp] < -180.) lontemp = lon_gd[count][gp] + 360;
                if (lon_gd[count][gp] > +180.) lontemp = lon_gd[count][gp] - 360;
                if (lontemp < 0.) lontemp += 360.;//make better visualization, all lon values positive
 
                myl1cV << lontemp << "," << lat_gd[count][gp] << endl;
           }
         }
 
 
        myl1cV.close();
 
 
        prodstr = "lat_nadpix";
        fname_out = pathstr + ofilestr+"_"+ prodstr+extstr;
        //   fname_out= "/accounts/mamontes/images/OCIS/out/"+"L1Cgrid_"+"lat_nadpix"+"_"+swtstr+".txt";
        //   ofstream myfile1 ("/accounts/mamontes/images/OCIS/lat_nadpix_swtd13again.txt");
        ofstream myfile1(fname_out);
        if (myfile1.is_open())
        {
            myfile1 << "lat_nadpix.\n";
            for (int count = 0; count < num_gridlines - 2; count++) {
                //   for(int gp = 0; gp <nbinx; gp ++){
                myfile1 << lati2[count] << "," << endl;
            }
            myfile1.close();
        }
        else cout << "Unable to open file";
        prodstr = "lon_nadpix";
        fname_out = pathstr + ofilestr+"_"+ prodstr+extstr;
        //  fname_out= "/accounts/mamontes/images/OCIS/out/"+"L1Cgrid_"+"lon_nadpix"+"_"+swtstr+".txt";
        //  ofstream myfile2 ("/accounts/mamontes/images/OCIS/lon_nadpix_swtd13again.txt");
        ofstream myfile2(fname_out);
        if (myfile2.is_open())
        {
            myfile2 << "lon_nadpix.\n";
            for (int count = 0; count < num_gridlines - 2; count++) {
                //   for(int gp = 0; gp <nbinx; gp ++){
                myfile2 << loni2[count] << "," << endl;
            }
            myfile2.close();
        }
        else cout << "Unable to open file";
 
        prodstr = "az_east";
        fname_out = pathstr + ofilestr+"_"+ prodstr+extstr;
 
        l1cfile->azeast_name = fname_out.c_str();
 
 
 
        //  fname_out= "/accounts/mamontes/images/OCIS/out/"+"L1Cgrid_"+"lon_nadpix"+"_"+swtstr+".txt";
        //  ofstream myfile2 ("/accounts/mamontes/images/OCIS/lon_nadpix_swtd13again.txt");
        ofstream myfile3(fname_out);
        if (myfile3.is_open())
        {
            myfile3 << "az_east.\n";
            for (int count = 0; count < num_gridlines - 2; count++) {
                if (az_east[count] < 0.001) az_east[count] = 0.0;
                myfile3 << az_east[count] << "," << endl;
            }
            myfile3.close();
        }
        else cout << "Unable to open file";
        if(lati_l!=nullptr)
        delete[](lati_l);
        if(lati_r!=nullptr)
        delete[](lati_r);
        if(loni_l!=nullptr)
        delete[](loni_l);
        if(loni_r!=nullptr)
        delete[](loni_r);
 
 
        cout << " SUCCESS writing results full L1C grid center positions for--swath #..." << swtd << "\n";
 
        return 0;
   }  
 
 
 
//same as l1c but files are saved as nc
 int32_t L1C::across_gridlines_l1c2(int swtd, l1c_filehandle* l1cfile, L1C_input* l1cinput, int16_t* swtd_id, int16_t* file_id, int16_t* nfiles_swt, float* lati2, float* loni2, float** lat_gd, float** lon_gd, float* az_east) {
        int32_t num_gridlines, nbinx, NY1 = -1, NY2 = -1, c1 = 1;
        float lat1_l, lat1_r, lon1_l, lon1_r, lat2, lon2, dlambda, az_r, az_l, h,  *lati_l, *loni_l, *lati_r, *loni_r, htot = 0.,az=0.;
        int  ncid_out,x_dimid, y_dimid, varid1, varid2, status;       
        int NDIMS=2;
        int dimids[NDIMS];
        int32_t NX, NY;
        int16_t selyear = -1, selmon = -1, selday = -1;
        double  latih, lonih, latih2, lonih2, res1, res2;
        float gres;
        int fnan1=0, fnan2=0, fnan3=0, fnan4=0;
        float latfirst = -999;
        int badline = 0;
        int grp_coor;
        const char* filename_lt;
        float **lat_out=nullptr,**lon_out=nullptr;
//        float **lt_out=nullptr;
        int NVIEWS, NBANDS,v_dimid,b_dimid, asc_mode=-1;
 
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
 
        //compute azimuth angle for each along-track position (nadir pixel or centered swath pixel) of the swath
        //azimuth angle in rads
        //lon+540/360-180 is a normalization factor for -180 to 180 degrees   
        num_gridlines = l1cfile->num_gridlines;
        num_pixels = l1cfile->npix;
        nbinx = l1cfile->nbinx;
        lati_l = (float*)calloc(nbinx / 2 , sizeof(float));
        lati_r = (float*)calloc(nbinx / 2 , sizeof(float));
        loni_l = (float*)calloc(nbinx / 2 , sizeof(float));
        loni_r = (float*)calloc(nbinx / 2 , sizeof(float));
 
      //big loop
 
        int gd = 0;
        asc_mode=l1cfile->orb_dir;
 
 
        //compute mean az_east---
        float sum = 0., tot = 0.;
        size_t azc = 0;
 
 
        
        for (int i = 0;i < num_gridlines - 2;i++) {
 
        //    cout<<"gd#.."<<i+1<<"lati2[i].."<<lati2[i]<<endl;
 
            //assign central positions---
            lat1_l = lati2[i] * M_PI / 180.;
            lat1_r = lati2[i] * M_PI / 180.;
            lat2 = lati2[i + 1] * M_PI / 180.;
            lon1_l = loni2[i] * M_PI / 180.;
            lon1_r = loni2[i] * M_PI / 180.;
            lon2 = loni2[i + 1] * M_PI / 180.;
 
            dlambda = (lon2 - lon1_l);
            //bearing---
            //make sure there are not NAN values ----------
            az = atan2(sin(dlambda) * cos(lat2), cos(lat1_l) * sin(lat2) - sin(lat1_l) * cos(lat2) * cos(dlambda));
 
            //     cout<<lat2<<"..."<<lat1_l<<".."<<dlambda<<az*180/M_PI<<endl;
            if (az > M_PI || az < -M_PI) {
                cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "az in degrees.." << az * 180 / M_PI << endl;
                exit(1);
            }
            if (isnan(az) < 1) {
                //       cout<<"az.."<<az<<"azcount"<<azc<<endl;
                az_r = (az + M_PI / 2.);
                az_east[i] = az_r * 180. / M_PI;
                if (az_east[i] < 0.0001 && az_east[i]>0) az_east[i] = 0.0;
                sum = az_east[i];
                tot += sum;
                azc++;
            }
            else {
                az_east[i] = NAN;
            }
        }
        float mean_az_east = tot / (azc);
 
        cout << "mean_az_east.." << mean_az_east << "numgridlines.." << num_gridlines-2 << endl;
        // exit(1);
 
        for (int j = 0;j < num_gridlines - 2;j++) {
            az_east[j] = mean_az_east;
        }
 
        l1cfile->mean_az_east = mean_az_east;
 
        for (int i = 0;i < num_gridlines - 2;i++) {
 
            if (i % 1 == 0) {
                //assign central positions---
                lat1_l = lati2[i] * M_PI / 180.;
                lat1_r = lati2[i] * M_PI / 180.;
                lat2 = lati2[i + 1] * M_PI / 180.;
                lon1_l = loni2[i] * M_PI / 180.;
                lon1_r = loni2[i] * M_PI / 180.;
                lon2 = loni2[i + 1] * M_PI / 180.;
 
                dlambda = (lon2 - lon1_l);
 
 
                gres = (l1cinput->gres) * 1000; //grid resolution in meters
 
               //bearing---
               //this is Harverside--law f cosines is more accurate---
                az = atan2(sin(dlambda) * cos(lat2), cos(lat1_l) * sin(lat2) - sin(lat1_l) * cos(lat2) * cos(dlambda));
                if (az > M_PI | az < -M_PI) {
                    cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "az in degrees.." << az * 180 / M_PI << endl;
                    exit(1);
                }
 
                //compute RIGHT across-gridline pixels---
 
                for (int k = 0;k < (nbinx / 2);k++) {
                    h = (l1cinput->gres);//distance between along positions in km, must be 5.2 k m for L1C
                    if (k == 0) h /= 2;//if nadpix
                    htot += h;
 
                    //right pixels---
                    az_r = mean_az_east * degrad;
 
                         //left pixels---
 
                    az_l = az_r - M_PI;
                    //     az_l=(az-M_PI/2.);//this should be equal to az_r+M_PI=az_l
 
                         //bearing should be always positive (clockwise) before pixel location calculation based on Harverside---     
                    if (az_r < 0.) {
                        az_r = 360 + az_r * 180 / M_PI;
                        az_r = az_r * M_PI / 180;
                    }
 
                    if (az_l < 0.) {
                        az_l = 360 + az_l * 180 / M_PI;
                        az_l = az_l * M_PI / 180;
                    }
          
                    geod.Direct(lat1_r * 180 / M_PI, lon1_r * 180 / M_PI, az_r * 180 / M_PI, gres, latih, lonih);
                    geod.Inverse(lat1_r * 180 / M_PI, lon1_r * 180 / M_PI, latih, lonih, res1);
                    fnan1 = isnan(latih);
                    fnan2 = isnan(lonih);
                    lati_r[k] = latih;
                    loni_r[k] = lonih;
                    //     cout<<"righside.."<<latih<<"..."<<lonih<<"res1"<<res1<<endl;
 
                    lat1_r = lati_r[k] * M_PI / 180;
                    lon1_r = loni_r[k] * M_PI / 180;
 
                    geod.Direct(lat1_l * 180 / M_PI, lon1_l * 180 / M_PI, az_l * 180 / M_PI, gres, latih2, lonih2);
                    geod.Inverse(lat1_l * 180 / M_PI, lon1_l * 180 / M_PI, latih2, lonih2, res2);
                    fnan3 = isnan(latih2);
                    fnan4 = isnan(lonih2);
                    lati_l[k] = latih2;
                    loni_l[k] = lonih2;
                    //     cout<<"leftside.."<<latih2<<"..."<<lonih2<<"res2"<<res2<<endl;
 
                    lat1_l = lati_l[k] * M_PI / 180;
                    lon1_l = loni_l[k] * M_PI / 180;
 
                      //right swath side-------------
                    if (asc_mode==1 && lati2[i]>lati2[i+1] || asc_mode==0 && lati2[i]<lati2[i+1] || fnan1 > 0 || fnan2 > 0 || res1 > (gres + 6) || res1 < (gres - 6) || lati2[i + 1] < lati2[i] || lati2[i] < latfirst) { //nan values
                        badline++;
                        if (badline == 1) {
                            latfirst = lati2[i];
                        }
 
                        cout << "bad interpolation - missing orbital data at near nadir grid cell..NAN right side of line.." << i + 1 << "corresponding to lat..."<<latfirst <<"lati2[i].."<<lati2[i]<<endl;
                        cout<<"gd.."<<gd+1<<"XBIN.."<<k+1<<"lati_l[k]"<<lati_l[k]<<"loni_l[k]"<<loni_l[k]<<"lati_r[k]"<<lati_r[k]<<"loni_r[k]"<<loni_r[k]<<endl;
                        lati2[i] = NAN;
                        loni2[i] = NAN;
 
                        for (int k = 0;k < (nbinx / 2);k++) {
                            lat_gd[gd][k + nbinx / 2] = NAN;
                            lon_gd[gd][k + nbinx / 2] = NAN;
                        }
                        //       cout<<"nan value.right.."<<endl;
                    }
                    else {
                        lat_gd[gd][k + nbinx / 2] = latih;
                        lon_gd[gd][k + nbinx / 2] = lonih;                    
                }
 
                    //left side
                    if (asc_mode==1 && lati2[i]>lati2[i+1] || asc_mode==0 && lati2[i]<lati2[i+1] || fnan3 > 0 || fnan4 > 0 || res2 > (gres + 6) || res2 < (gres - 6) || lati2[i + 1] < lati2[i] || lati2[i] < latfirst) {
                        //     if(fnan3>0 | fnan4>0 |  res2>(gres+6) | res2<(gres-6)){
                        cout << "bad interpolation - missing orbital data at near nadir grid cell..NAN left side of line.." << i + 1 << endl;
                        cout<<"gd.."<<gd+1<<"XBIN.."<<k+1<<"lati_l[k]"<<lati_l[k]<<"loni_l[k]"<<loni_l[k]<<"lati_r[k]"<<lati_r[k]<<"loni_r[k]"<<loni_r[k]<<"lati2[i].."<<lati2[i]<<endl;
                        lati2[i] = NAN;
                        loni2[i] = NAN;
                        for (int k = 0;k < (nbinx / 2);k++) {
                            lat_gd[gd][nbinx / 2 - 1 - k] = NAN;//as k increases we are farther away from nadpix or along-track position---
                            lon_gd[gd][nbinx / 2 - 1 - k] = NAN;                        
                         }   
                        //       cout<<"nan value.left.."<<endl;
                    }
                    else {
                        lat_gd[gd][nbinx / 2 - 1 - k] = latih2;//as k increases we are farther away from nadpix or along-track position---
                        lon_gd[gd][nbinx / 2 - 1 - k] = lonih2;                    
                       }  
                fnan1=0;
                fnan2=0;
                fnan3=0;
                fnan4=0;
 
                }//end pixel loop
              
 
                htot = 0;
                gd++;
            }//end if every 100 gd
        }//end gridlines loop
        cout << "`L1C gridding successful!......................................." << endl;
 
//writing results ***************************************************************************
        float lontemp = 0.;
        selday = l1cinput->selday;
        selmon = l1cinput->selmon;
        selyear = l1cinput->selyear;
 
        std::string timestr,missionstr,fname_out, pathstr, senstr, monstr, daystr, yearstr, prodstr, gdstr, swtstr, swtnum, extstr,ofilestr;
        pathstr = "out/";
        missionstr="PACE";
        senstr = "OCIS";
        monstr = std::to_string(selmon);
        daystr = std::to_string(selday);
        yearstr = std::to_string(selyear);
        timestr="T00:00:00Z";
        prodstr = "L1Cgrid";
        //   gdstr="_gdFULL_";
        swtstr = "_swt";
 
        if (l1cfile->l1c_pflag >= 3) {
            swtd = l1cfile->swtnum;
            swtnum = std::to_string(swtd);
            cout << "swtnum.." << swtnum << endl;
        }
        else swtnum = std::to_string(swtd);
 
        extstr = ".nc";
        ofilestr=std::string(l1cinput->ofile);
            
        fname_out = pathstr + ofilestr+"_"+ prodstr+extstr;
 
        string  ATT_NAME="Units", ATT_VAL="degrees",GATT_NAME1="Title",GATT_VAL1="PACE OCI Level-1C Data",GATT_NAME2="instrument",GATT_VAL2="OCI",GATT_NAME3="processing_version",GATT_VAL3="V1.0",GATT_NAME4="Conventions",GATT_VAL4="CF-1.6";
        string GATT_NAME5="institution",GATT_VAL5="NASA Goddard Space Flight Center, Ocean Biology Processing Group",GATT_NAME6="license",GATT_VAL6="http://science.nasa.gov/earth-science/earth-science-data/data-information-policy/";
        string GATT_NAME7="naming_authority",GATT_VAL7="gov.nasa.gsfc.sci.oceancolor",GATT_NAME8="keywords_vocabulary",GATT_VAL8="NASA Global Change Master Directory (GCMD) Science Keywords";
        string GATT_NAME9="stdname_vocabulary",GATT_VAL9="NetCDF Climate and Forecast (CF) Metadata Convention",GATT_NAME10="creator_name",GATT_VAL10="NASA/GSFC",GATT_NAME11="creator_email",GATT_VAL11="data@oceancolor.gsfc.nasa.gov";
        string GATT_NAME12="creator_url",GATT_VAL12="http://oceancolor.gsfc.nasa.gov",GATT_NAME13="project",GATT_VAL13="PACE Project",GATT_NAME14="publisher_name",GATT_VAL14="NASA/GSFC";
        string GATT_NAME15="publisher_email",GATT_VAL15="data@oceancolor.gsfc.nasa.gov",GATT_NAME16="publisher_url",GATT_VAL16="http://oceancolor.gsfc.nasa.gov",GATT_NAME17="processing_level",GATT_VAL17="L1C";
        string GATT_NAME18="cdm_data_type",GATT_VAL18="swath",GATT_NAME19="orbit_number",GATT_VAL19="12345",GATT_NAME20="history",GATT_VAL20="",GATT_NAME21="CDL_version_date",GATT_VAL21="2021-09-10",GATT_NAME22="product_name",GATT_VAL22=fname_out;
        string GATT_NAME23="startDirection",GATT_VAL23="Ascending",GATT_NAME24="endDirection",GATT_VAL24="Ascending",GATT_NAME25="time_coverage_start",GATT_VAL25=yearstr+"-"+monstr+"-"+daystr+"-"+timestr,GATT_NAME26="time_coverage_end",GATT_VAL26=yearstr+"-"+monstr+"-"+daystr+"-"+timestr,GATT_NAME27="date{_created",GATT_VAL27="2021-09-10T15:12:41Z",GATT_NAME28="sun_earth_distance",GATT_VAL28="0.990849042172323",GATT_NAME29="terrain_data_source",GATT_VAL29="",GATT_NAME30="spectral_response_function",GATT_VAL30="",GATT_NAME31="systematic_uncertainty_model",GATT_VAL31="",GATT_NAME32="nadir_bin",GATT_VAL32="12345",GATT_NAME33="bin_size_at_nadir",GATT_VAL33="2.6km2"; 
 
 
        l1cfile->gridname = fname_out.c_str();
        filename_lt = fname_out.c_str();
        cout<<"creating file for L1C coor..."<<filename_lt<<endl;
//        if ((status = nc_create(filename_lt, NC_CLOBBER, &ncid_out))) 
        if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
            check_err(status, __LINE__, __FILE__);
        //define dims
     // Define the dimensions,vars and attributes at the root level
        NY = num_gridlines-2;
        NX = nbinx;
        NVIEWS= 2;//for OCI
        NBANDS=249;
//        lt_out = allocate2d_float(NY, NX);
  //DEF DIMENSIONS
        if ((status = nc_def_dim(ncid_out, "bins_across_track", NX, &x_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "bins_along_track", NY, &y_dimid)))
            check_err(status, __LINE__, __FILE__);
        //dims for output var
        dimids[0] = y_dimid;
        dimids[1] = x_dimid;
        NDIMS=2;
        if ((status = nc_def_dim(ncid_out, "number_of_views", NVIEWS, &v_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "intensity_bands_per_view", NBANDS, &b_dimid)))
            check_err(status, __LINE__, __FILE__);
 
/*
//def variables at the root level!
        if ((status = nc_def_var(ncid_out, "latitude", NC_FLOAT, NDIMS,
                dimids, &varid1)))
                check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_var(ncid_out, "longitude", NC_FLOAT, NDIMS,
                dimids, &varid2)))
                check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_enddef(ncid_out))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
        if ((status = nc_put_var_float(ncid_out, varid1, &lat_gd[0][0])))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_put_var_float(ncid_out, varid2, &lon_gd[0][0])))
            check_err(status, __LINE__, __FILE__);
*/
 
//define attributes
//       if (nc_put_att_text(ncid_out, varid1, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
//           check_err(status, __LINE__, __FILE__);
//       if (nc_put_att_text(ncid_out, varid2, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str())) 
//           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME1.c_str(), strlen(GATT_VAL1.c_str()),
          GATT_VAL1.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME2.c_str(), strlen(GATT_VAL2.c_str()),
          GATT_VAL2.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME3.c_str(), strlen(GATT_VAL3.c_str()),
          GATT_VAL3.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME4.c_str(), strlen(GATT_VAL4.c_str()),
          GATT_VAL4.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME5.c_str(), strlen(GATT_VAL5.c_str()),
          GATT_VAL5.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME6.c_str(), strlen(GATT_VAL6.c_str()),
          GATT_VAL6.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME7.c_str(), strlen(GATT_VAL7.c_str()),
          GATT_VAL7.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME8.c_str(), strlen(GATT_VAL8.c_str()),
          GATT_VAL8.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME9.c_str(), strlen(GATT_VAL9.c_str()),
          GATT_VAL9.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME10.c_str(), strlen(GATT_VAL10.c_str()),
          GATT_VAL10.c_str()))
           check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME11.c_str(), strlen(GATT_VAL11.c_str()),
          GATT_VAL11.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME12.c_str(), strlen(GATT_VAL12.c_str()),
          GATT_VAL12.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME13.c_str(), strlen(GATT_VAL13.c_str()),
          GATT_VAL13.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME14.c_str(), strlen(GATT_VAL14.c_str()),
          GATT_VAL14.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME15.c_str(), strlen(GATT_VAL15.c_str()),
          GATT_VAL15.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME16.c_str(), strlen(GATT_VAL16.c_str()),
          GATT_VAL16.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME17.c_str(), strlen(GATT_VAL17.c_str()),
          GATT_VAL17.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME18.c_str(), strlen(GATT_VAL18.c_str()),
          GATT_VAL18.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME19.c_str(), strlen(GATT_VAL19.c_str()),
          GATT_VAL19.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME20.c_str(), strlen(GATT_VAL20.c_str()),
          GATT_VAL20.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME21.c_str(), strlen(GATT_VAL21.c_str()),
          GATT_VAL21.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME22.c_str(), strlen(GATT_VAL22.c_str()),
          GATT_VAL22.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME23.c_str(), strlen(GATT_VAL23.c_str()),
          GATT_VAL23.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME24.c_str(), strlen(GATT_VAL24.c_str()),
          GATT_VAL24.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME25.c_str(), strlen(GATT_VAL25.c_str()),
          GATT_VAL25.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME26.c_str(), strlen(GATT_VAL26.c_str()),
          GATT_VAL26.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME27.c_str(), strlen(GATT_VAL27.c_str()),
          GATT_VAL27.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME28.c_str(), strlen(GATT_VAL28.c_str()),
          GATT_VAL28.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME29.c_str(), strlen(GATT_VAL29.c_str()),
          GATT_VAL29.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME30.c_str(), strlen(GATT_VAL30.c_str()),
          GATT_VAL30.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME31.c_str(), strlen(GATT_VAL31.c_str()),
          GATT_VAL31.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME32.c_str(), strlen(GATT_VAL32.c_str()),
          GATT_VAL32.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME33.c_str(), strlen(GATT_VAL33.c_str()),
          GATT_VAL33.c_str()))
          check_err(status, __LINE__, __FILE__);
 
      //define groups                  check_err(status, __LINE__, __FILE__);
       if ((status = nc_def_grp(ncid_out, "geolocation_data", &grp_coor)))  //netcdf-4
          check_err(status, __LINE__, __FILE__);
//        if ((status = nc_def_grp(ncid_out, "observation_data", &grp_obs)))  //netcdf-4
//        check_err(status, __LINE__, __FILE__);
 
//DEF DIMENSIONS
  /*      if ((status = nc_def_dim(grp_coor, "x", NX, &x_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(grp_coor, "y", NY, &y_dimid)))
            check_err(status, __LINE__, __FILE__);
        dimids[0] = y_dimid;
        dimids[1] = x_dimid;
 
        NDIMS=2;
*/
        //def var      
        if ((status = nc_def_var(grp_coor, "latitude", NC_FLOAT, NDIMS,
                dimids, &varid1)))
                check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_var(grp_coor, "longitude", NC_FLOAT, NDIMS,
                dimids, &varid2)))
                check_err(status, __LINE__, __FILE__);
    //leave define mode-----------------------
        if ((status = nc_enddef(grp_coor))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
//        if ((status = nc_def_var(grp_obs, "lt", NC_FLOAT, NDIMS,
//                dimids, &varid3)))
//                check_err(status, __LINE__, __FILE__);
                    //leave define mode-----------------------
//        if ((status = nc_enddef(grp_obs))) //done def vars etc
//                        check_err(status, __LINE__, __FILE__);
 
        //writing the whole thing
        if ((status = nc_put_var_float(grp_coor, varid1, &lat_gd[0][0])))
            check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_put_var_float(grp_coor, varid2, &lon_gd[0][0])))
            check_err(status, __LINE__, __FILE__);
//        if ((status = nc_put_var_float(grp_obs, varid3, &lt_out[0][0])))
//            check_err(status, __LINE__, __FILE__);
//define attributes of vars in groups
//UNITS in degrees ----
        if (nc_put_att_text(grp_coor, varid1, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(grp_coor, varid2, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str())) 
             check_err(status, __LINE__, __FILE__);
 
 
//close file
        if ((status = nc_close(ncid_out)))
           check_err(status, __LINE__, __FILE__);
 
//        delete [] (lt_out);
 
//CASE ONLY LON POS VALUES***************************************************************************
 
        //Only positive longitude 0-360 degrees for visualization ****************************************************************
        //lat lon grid for visualization--
        prodstr = "L1Cgrid_lonpos";
        //   gdstr="_gdFULL_";
        //recompute number of gridlines based on lat limits -80 to 80 degrees  
        //asc orbit goes from negative to positive latitude....
 
        NY = num_gridlines-2;
        NX = nbinx;
 
        for (int i = 0; i < NY; i++) {
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= -80.) c1++;
                if (c1 == nbinx) {
                    NY1 = i;
                }
            }
            if (NY1 >= 0) break;
            c1 = 1;
        }
 
        for (int i = 0;i < NY; i++) {
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= 80.) {
                    NY2 = i - 1;
                }
            }
            if (NY2 >= 0) break;
        }
 
        l1cfile->NY1 = NY1;
        l1cfile->NY2 = NY2;
 
       NY = NY2 - NY1 + 1;
 
       lat_out = allocate2d_float(NY, NX);
       lon_out = allocate2d_float(NY, NX);
 
        int c=0;
        for (int i = NY1; i < NY2 + 1; i++) {
            for (int j = 0; j < NX; j++) {
                if(lon_gd[i][j]<0) lon_out[c][j]=lon_gd[i][j]+360;
                else lon_out[c][j]=lon_gd[i][j];
                lat_out[c][j] = lat_gd[i][j];
            }
            cout<<"gd#..."<<c+1<<endl;
            c++;
 
        }
 
 
        extstr = ".nc";
//        fname_out = pathstr + missionstr + "_" + senstr + "." + yearstr + monstr + daystr + timestr + prodstr+extstr;
        fname_out = pathstr + ofilestr+"_"+ prodstr+extstr;
 
        l1cfile->gridname = fname_out.c_str();
        filename_lt = fname_out.c_str();
        cout<<"creating file for L1C coor.with only POS LONGITUDE.."<<filename_lt<<endl;
//        if ((status = nc_create(filename_lt, NC_CLOBBER, &ncid_out))) 
        if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
            check_err(status, __LINE__, __FILE__);
        //define dims
     // Define the dimensions,vars and attributes at the root level
 
 
  //DEF DIMENSIONS
        if ((status = nc_def_dim(ncid_out, "bins_across_track", NX, &x_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "bins_along_track", NY, &y_dimid)))
            check_err(status, __LINE__, __FILE__);
        //dims for output var
        dimids[0] = y_dimid;
        dimids[1] = x_dimid;
        NDIMS=2;
        if ((status = nc_def_dim(ncid_out, "number_of_views", NVIEWS, &v_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "intensity_bands_per_view", NBANDS, &b_dimid)))
            check_err(status, __LINE__, __FILE__);
/*
//def variables at the root level!
        if ((status = nc_def_var(ncid_out, "latitude", NC_FLOAT, NDIMS,
                dimids, &varid1)))
                check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_var(ncid_out, "longitude", NC_FLOAT, NDIMS,
                dimids, &varid2)))
                check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_enddef(ncid_out))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
        if ((status = nc_put_var_float(ncid_out, varid1, &lat_out[0][0])))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_put_var_float(ncid_out, varid2, &lon_out[0][0])))
            check_err(status, __LINE__, __FILE__);
 
//define attributes
       if (nc_put_att_text(ncid_out, varid1, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, varid2, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str())) 
           check_err(status, __LINE__, __FILE__);
*/
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME1.c_str(), strlen(GATT_VAL1.c_str()),
          GATT_VAL1.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME2.c_str(), strlen(GATT_VAL2.c_str()),
          GATT_VAL2.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME3.c_str(), strlen(GATT_VAL3.c_str()),
          GATT_VAL3.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME4.c_str(), strlen(GATT_VAL4.c_str()),
          GATT_VAL4.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME5.c_str(), strlen(GATT_VAL5.c_str()),
          GATT_VAL5.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME6.c_str(), strlen(GATT_VAL6.c_str()),
          GATT_VAL6.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME7.c_str(), strlen(GATT_VAL7.c_str()),
          GATT_VAL7.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME8.c_str(), strlen(GATT_VAL8.c_str()),
          GATT_VAL8.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME9.c_str(), strlen(GATT_VAL9.c_str()),
          GATT_VAL9.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME10.c_str(), strlen(GATT_VAL10.c_str()),
          GATT_VAL10.c_str()))
           check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME11.c_str(), strlen(GATT_VAL11.c_str()),
          GATT_VAL11.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME12.c_str(), strlen(GATT_VAL12.c_str()),
          GATT_VAL12.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME13.c_str(), strlen(GATT_VAL13.c_str()),
          GATT_VAL13.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME14.c_str(), strlen(GATT_VAL14.c_str()),
          GATT_VAL14.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME15.c_str(), strlen(GATT_VAL15.c_str()),
          GATT_VAL15.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME16.c_str(), strlen(GATT_VAL16.c_str()),
          GATT_VAL16.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME17.c_str(), strlen(GATT_VAL17.c_str()),
          GATT_VAL17.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME18.c_str(), strlen(GATT_VAL18.c_str()),
          GATT_VAL18.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME19.c_str(), strlen(GATT_VAL19.c_str()),
          GATT_VAL19.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME20.c_str(), strlen(GATT_VAL20.c_str()),
          GATT_VAL20.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME21.c_str(), strlen(GATT_VAL21.c_str()),
          GATT_VAL21.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME22.c_str(), strlen(GATT_VAL22.c_str()),
          GATT_VAL22.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME23.c_str(), strlen(GATT_VAL23.c_str()),
          GATT_VAL23.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME24.c_str(), strlen(GATT_VAL24.c_str()),
          GATT_VAL24.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME25.c_str(), strlen(GATT_VAL25.c_str()),
          GATT_VAL25.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME26.c_str(), strlen(GATT_VAL26.c_str()),
          GATT_VAL26.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME27.c_str(), strlen(GATT_VAL27.c_str()),
          GATT_VAL27.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME28.c_str(), strlen(GATT_VAL28.c_str()),
          GATT_VAL28.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME29.c_str(), strlen(GATT_VAL29.c_str()),
          GATT_VAL29.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME30.c_str(), strlen(GATT_VAL30.c_str()),
          GATT_VAL30.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME31.c_str(), strlen(GATT_VAL31.c_str()),
          GATT_VAL31.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME32.c_str(), strlen(GATT_VAL32.c_str()),
          GATT_VAL32.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME33.c_str(), strlen(GATT_VAL33.c_str()),
          GATT_VAL33.c_str()))
          check_err(status, __LINE__, __FILE__);
 
 
 
 
      //define groups                  check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_grp(ncid_out, "geolocation_data", &grp_coor)))  //netcdf-4
             check_err(status, __LINE__, __FILE__);
/*
//DEF DIMENSIONS
        if ((status = nc_def_dim(grp_coor, "x", NX, &x_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(grp_coor, "y", NY, &y_dimid)))
            check_err(status, __LINE__, __FILE__);
        dimids[0] = y_dimid;
        dimids[1] = x_dimid;
        NDIMS=2;
*/
        //def var      
        if ((status = nc_def_var(grp_coor, "latitude", NC_FLOAT, NDIMS,
                dimids, &varid1)))
                check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_var(grp_coor, "longitude", NC_FLOAT, NDIMS,
                dimids, &varid2)))
                check_err(status, __LINE__, __FILE__);
 
                    //leave define mode-----------------------
        if ((status = nc_enddef(grp_coor))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
 
        //writing the whole thing
        if ((status = nc_put_var_float(grp_coor, varid1, &lat_out[0][0])))
            check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_put_var_float(grp_coor, varid2, &lon_out[0][0])))
            check_err(status, __LINE__, __FILE__);
 
//define attributes of vars in groups
        if (nc_put_att_text(grp_coor, varid1, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(grp_coor, varid2, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
 
 
        if ((status = nc_close(ncid_out)))
           check_err(status, __LINE__, __FILE__);
 
 
        delete [] (lat_out);
        delete [] (lon_out);
        lat_out=nullptr;
        lon_out=nullptr;
 
 
//CASE INVERTED ALONG/ACROSS INDEXES ***************************************************************************
        prodstr = "L1Cgrid_inverted";
 
 
        lat_out = allocate2d_float(NY, NX);
        lon_out = allocate2d_float(NY, NX);
 
        c = 0;
        for (int i = NY1; i < NY2 + 1; i++) {
            for (int j = 0; j < NX; j++) {
                lat_out[NY - 1 - c][NX - 1 - j] = lat_gd[i][j];
                lon_out[NY - 1 - c][j] = lon_gd[i][j];
            }
            c++;
        }
       
        extstr = ".nc";
//        fname_out = pathstr + missionstr + "_" + senstr + "." + yearstr + monstr + daystr + timestr + prodstr+extstr;
        fname_out = pathstr + ofilestr+"_"+ prodstr+extstr;
        l1cfile->gridname = fname_out.c_str();
        filename_lt = fname_out.c_str();
        cout<<"creating file for L1C coor.with x/y inverted indexes.."<<filename_lt<<endl;
//        if ((status = nc_create(filename_lt, NC_CLOBBER, &ncid_out))) 
        if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
            check_err(status, __LINE__, __FILE__);
        //define dims
     // Define the dimensions,vars and attributes at the root level
 
 
  //DEF DIMENSIONS
        if ((status = nc_def_dim(ncid_out, "bins_across_track", NX, &x_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "bins_along_track", NY, &y_dimid)))
            check_err(status, __LINE__, __FILE__);
        //dims for output var
        dimids[0] = y_dimid;
        dimids[1] = x_dimid;
        NDIMS=2;
        if ((status = nc_def_dim(ncid_out, "number_of_views", NVIEWS, &v_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(ncid_out, "intensity_bands_per_view", NBANDS, &b_dimid)))
            check_err(status, __LINE__, __FILE__);
/*
//def variables at the root level!
        if ((status = nc_def_var(ncid_out, "latitude", NC_FLOAT, NDIMS,
                dimids, &varid1)))
                check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_var(ncid_out, "longitude", NC_FLOAT, NDIMS,
                dimids, &varid2)))
                check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_enddef(ncid_out))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
        if ((status = nc_put_var_float(ncid_out, varid1, &lat_out[0][0])))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_put_var_float(ncid_out, varid2, &lon_out[0][0])))
            check_err(status, __LINE__, __FILE__);
 
//define attributes
       if (nc_put_att_text(ncid_out, varid1, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, varid2, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str())) 
           check_err(status, __LINE__, __FILE__);
*/
 
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME1.c_str(), strlen(GATT_VAL1.c_str()),
          GATT_VAL1.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME2.c_str(), strlen(GATT_VAL2.c_str()),
          GATT_VAL2.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME3.c_str(), strlen(GATT_VAL3.c_str()),
          GATT_VAL3.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME4.c_str(), strlen(GATT_VAL4.c_str()),
          GATT_VAL4.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME5.c_str(), strlen(GATT_VAL5.c_str()),
          GATT_VAL5.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME6.c_str(), strlen(GATT_VAL6.c_str()),
          GATT_VAL6.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME7.c_str(), strlen(GATT_VAL7.c_str()),
          GATT_VAL7.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME8.c_str(), strlen(GATT_VAL8.c_str()),
          GATT_VAL8.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME9.c_str(), strlen(GATT_VAL9.c_str()),
          GATT_VAL9.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME10.c_str(), strlen(GATT_VAL10.c_str()),
          GATT_VAL10.c_str()))
           check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME11.c_str(), strlen(GATT_VAL11.c_str()),
          GATT_VAL11.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME12.c_str(), strlen(GATT_VAL12.c_str()),
          GATT_VAL12.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME13.c_str(), strlen(GATT_VAL13.c_str()),
          GATT_VAL13.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME14.c_str(), strlen(GATT_VAL14.c_str()),
          GATT_VAL14.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME15.c_str(), strlen(GATT_VAL15.c_str()),
          GATT_VAL15.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME16.c_str(), strlen(GATT_VAL16.c_str()),
          GATT_VAL16.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME17.c_str(), strlen(GATT_VAL17.c_str()),
          GATT_VAL17.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME18.c_str(), strlen(GATT_VAL18.c_str()),
          GATT_VAL18.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME19.c_str(), strlen(GATT_VAL19.c_str()),
          GATT_VAL19.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME20.c_str(), strlen(GATT_VAL20.c_str()),
          GATT_VAL20.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME21.c_str(), strlen(GATT_VAL21.c_str()),
          GATT_VAL21.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME22.c_str(), strlen(GATT_VAL22.c_str()),
          GATT_VAL22.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME23.c_str(), strlen(GATT_VAL23.c_str()),
          GATT_VAL23.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME24.c_str(), strlen(GATT_VAL24.c_str()),
          GATT_VAL24.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME25.c_str(), strlen(GATT_VAL25.c_str()),
          GATT_VAL25.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME26.c_str(), strlen(GATT_VAL26.c_str()),
          GATT_VAL26.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME27.c_str(), strlen(GATT_VAL27.c_str()),
          GATT_VAL27.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME28.c_str(), strlen(GATT_VAL28.c_str()),
          GATT_VAL28.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME29.c_str(), strlen(GATT_VAL29.c_str()),
          GATT_VAL29.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME30.c_str(), strlen(GATT_VAL30.c_str()),
          GATT_VAL30.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME31.c_str(), strlen(GATT_VAL31.c_str()),
          GATT_VAL31.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME32.c_str(), strlen(GATT_VAL32.c_str()),
          GATT_VAL32.c_str()))
           check_err(status, __LINE__, __FILE__);
       if (nc_put_att_text(ncid_out, NC_GLOBAL, GATT_NAME33.c_str(), strlen(GATT_VAL33.c_str()),
          GATT_VAL33.c_str()))
          check_err(status, __LINE__, __FILE__);
 
      //define groups                  check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_grp(ncid_out, "geolocation_data", &grp_coor)))  //netcdf-4
           check_err(status, __LINE__, __FILE__);
/*
//DEF DIMENSIONS
        if ((status = nc_def_dim(grp_coor, "x", NX, &x_dimid)))
            check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_dim(grp_coor, "y", NY, &y_dimid)))
            check_err(status, __LINE__, __FILE__);
        dimids[0] = y_dimid;
        dimids[1] = x_dimid;
        NDIMS=2;
*/
        //def var      
        if ((status = nc_def_var(grp_coor, "latitude", NC_FLOAT, NDIMS,
                dimids, &varid1)))
                check_err(status, __LINE__, __FILE__);
        if ((status = nc_def_var(grp_coor, "longitude", NC_FLOAT, NDIMS,
                dimids, &varid2)))
                check_err(status, __LINE__, __FILE__);
 
                    //leave define mode-----------------------
        if ((status = nc_enddef(grp_coor))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
 
        //writing the whole thing
        if ((status = nc_put_var_float(grp_coor, varid1, &lat_out[0][0])))
            check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_put_var_float(grp_coor, varid2, &lon_out[0][0])))
            check_err(status, __LINE__, __FILE__);
 
 
//define attributes of vars in groups
        if (nc_put_att_text(grp_coor, varid1, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
        if (nc_put_att_text(grp_coor, varid2, ATT_NAME.c_str(), strlen(ATT_VAL.c_str()), ATT_VAL.c_str()))
             check_err(status, __LINE__, __FILE__);
 
 
 
        if ((status = nc_close(ncid_out)))
           check_err(status, __LINE__, __FILE__);
 
 
        delete [] (lat_out);
        delete [] (lon_out);
        lat_out=nullptr;
        lon_out=nullptr;
 
 
 
//******** save az_east param as nc ***************************************************************
//az_east[count]
        prodstr="az_east";
        extstr = ".nc";
        fname_out = pathstr + ofilestr+"_"+ prodstr+extstr;
        filename_lt = fname_out.c_str();
        cout<<"creating file for az_east values in degrees as nc format.."<<filename_lt<<endl;
//        if ((status = nc_create(filename_lt, NC_CLOBBER, &ncid_out))) 
        if ((status = nc_create(filename_lt, NC_CLOBBER | NC_NETCDF4, &ncid_out)))
            check_err(status, __LINE__, __FILE__);
        //define dims
     // Define the dimensions,vars and attributes at the root level
 
 
  //DEF DIMENSIONS
        if ((status = nc_def_dim(ncid_out, "bins_along_track", NY, &y_dimid)))
            check_err(status, __LINE__, __FILE__);
//DEF VARIABLE      
        if ((status = nc_def_var(ncid_out, "az_east", NC_FLOAT, 1,
                &y_dimid, &varid1)))
                check_err(status, __LINE__, __FILE__);
 
        if ((status = nc_enddef(ncid_out))) //done def vars etc
                        check_err(status, __LINE__, __FILE__);
 
          for (int count = 0; count < num_gridlines - 2; count++) {
                if (az_east[count] < 0.001) az_east[count] = 0.0;}
        //writing the whole thing
        if ((status = nc_put_var_float(ncid_out, varid1, &az_east[0])))
            check_err(status, __LINE__, __FILE__);
//close file
        if ((status = nc_close(ncid_out)))
           check_err(status, __LINE__, __FILE__);
 
 
//***********************************************************************************************
        prodstr = "L1CgridV";
        extstr=".csv";
 
        fname_out = pathstr + ofilestr+"_"+ prodstr+extstr;
        //   std::ofstream myl1c("/accounts/mamontes/images/OCIS/swt1_ALLgd_L1C500_swtd13again.csv");
        std::ofstream myl1cV(fname_out);
        // for(int count = 0; count <num_gridlines; count ++){
             /*    for(int gp = 0; gp <nbinx/2; gp ++){
                    if (loni_l[gp]<0.) loni_l[gp]+=360;
                    if (loni_r[gp]<0.) loni_r[gp]+=360;
                        myl1c << loni_l[gp] << ","<<lati_l[gp]<<endl;
                        myl1c << loni_r[gp] << ","<<lati_r[gp]<<endl;}*/
 
        for (int count = 0; count < num_gridlines - 2;count++) {
            //         for(int count = 0; count <num_gridlines/100;count ++){
            for (int gp = 0; gp < nbinx; gp++) {
                lontemp = lon_gd[count][gp];
                if (lon_gd[count][gp] < -180.) lontemp = lon_gd[count][gp] + 360;
                if (lon_gd[count][gp] > +180.) lontemp = lon_gd[count][gp] - 360;
                if (lontemp < 0.) lontemp += 360.;//make better visualization, all lon values positive
 
                myl1cV << lontemp << "," << lat_gd[count][gp] << endl;            
           }        
         }
 
 
        myl1cV.close();
 
 
        prodstr = "lat_nadpix";
        fname_out = pathstr + ofilestr+"_"+ prodstr+extstr;
        //   fname_out= "/accounts/mamontes/images/OCIS/out/"+"L1Cgrid_"+"lat_nadpix"+"_"+swtstr+".txt";
        //   ofstream myfile1 ("/accounts/mamontes/images/OCIS/lat_nadpix_swtd13again.txt");
        ofstream myfile1(fname_out);
        if (myfile1.is_open())
        {
            myfile1 << "lat_nadpix.\n";
            for (int count = 0; count < num_gridlines - 2; count++) {
                //   for(int gp = 0; gp <nbinx; gp ++){
                myfile1 << lati2[count] << "," << endl;
            }
            myfile1.close();
        }
        else cout << "Unable to open file";
        prodstr = "lon_nadpix";
        fname_out = pathstr + ofilestr+"_"+ prodstr+extstr;
        //  fname_out= "/accounts/mamontes/images/OCIS/out/"+"L1Cgrid_"+"lon_nadpix"+"_"+swtstr+".txt";
        //  ofstream myfile2 ("/accounts/mamontes/images/OCIS/lon_nadpix_swtd13again.txt");
        ofstream myfile2(fname_out);
        if (myfile2.is_open())
        {
            myfile2 << "lon_nadpix.\n";
            for (int count = 0; count < num_gridlines - 2; count++) {
                //   for(int gp = 0; gp <nbinx; gp ++){
                myfile2 << loni2[count] << "," << endl;
            }
            myfile2.close();
        }
        else cout << "Unable to open file";
 
        prodstr = "az_east";
        fname_out = pathstr + ofilestr+"_"+ prodstr+extstr;
 
        l1cfile->azeast_name = fname_out.c_str();
 
 
 
        //  fname_out= "/accounts/mamontes/images/OCIS/out/"+"L1Cgrid_"+"lon_nadpix"+"_"+swtstr+".txt";
        //  ofstream myfile2 ("/accounts/mamontes/images/OCIS/lon_nadpix_swtd13again.txt");
        ofstream myfile3(fname_out);
        if (myfile3.is_open())
        {
            myfile3 << "az_east.\n";
            for (int count = 0; count < num_gridlines - 2; count++) {
                if (az_east[count] < 0.001) az_east[count] = 0.0;
                myfile3 << az_east[count] << "," << endl;
            }
            myfile3.close();
        }
        else cout << "Unable to open file";
        if(lati_l!=nullptr)
        delete[](lati_l);
        if(lati_r!=nullptr)
        delete[](lati_r);
        if(loni_l!=nullptr)
        delete[](loni_l);
        if(loni_r!=nullptr)
        delete[](loni_r);
 
 
        cout << " SUCCESS writing results full L1C grid center positions for--swath #..." << swtd << "\n";
 
        return 0;
    }
 
 
 
 
 
 
 
 
    int32_t L1C::across_gridlines_l1c(int swtd, l1c_filehandle* l1cfile, L1C_input* l1cinput, int16_t* swtd_id, int16_t* file_id, int16_t* nfiles_swt, float* lati2, float* loni2, float** lat_gd, float** lon_gd, float* az_east) {
        int32_t num_gridlines, nbinx, NY1 = -1, NY2 = -1, c1 = 1;
        float lat1_l, lat1_r, lon1_l, lon1_r, lat2, lon2, az, dlambda, az_r, az_l, h, *lati_l, *loni_l, *lati_r, *loni_r, htot = 0.;
        int32_t NX, NY;
        int16_t selyear = -1, selmon = -1, selday = -1;
        double latih, lonih, latih2, lonih2, res1, res2;
        float gres;
        int fnan1, fnan2, fnan3, fnan4;
        float latfirst = -999;
        int badline = 0;
 
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
 
        //compute azimuth angle for each along-track position (nadir pixel or centered swath pixel) of the swath
        //azimuth angle in rads
        //lon+540/360-180 is a normalization factor for -180 to 180 degrees   
        num_gridlines = l1cfile->num_gridlines;
        num_pixels = l1cfile->npix;
        nbinx = l1cfile->nbinx;
        lati_l = (float*)malloc(nbinx / 2 * sizeof(float));
        lati_r = (float*)malloc(nbinx / 2 * sizeof(float));
        loni_l = (float*)malloc(nbinx / 2 * sizeof(float));
        loni_r = (float*)malloc(nbinx / 2 * sizeof(float));
 
     
 
 
      //big loop
 
        int gd = 0;
 
 
        //compute mean az_east---
        float sum = 0., tot = 0.;
        size_t azc = 0;
        for (int i = 0;i < num_gridlines - 1;i++) {
 
            //assign central positions---
            lat1_l = lati2[i] * M_PI / 180.;
            lat1_r = lati2[i] * M_PI / 180.;
            lat2 = lati2[i + 1] * M_PI / 180.;
            lon1_l = loni2[i] * M_PI / 180.;
            lon1_r = loni2[i] * M_PI / 180.;
            lon2 = loni2[i + 1] * M_PI / 180.;
 
            dlambda = (lon2 - lon1_l);
            //bearing---
            //make sure there are not NAN values ----------
            az = atan2(sin(dlambda) * cos(lat2), cos(lat1_l) * sin(lat2) - sin(lat1_l) * cos(lat2) * cos(dlambda));
 
            //     cout<<lat2<<"..."<<lat1_l<<".."<<dlambda<<az*180/M_PI<<endl;
            if (az > M_PI || az < -M_PI) {
                cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "az in degrees.." << az * 180 / M_PI << endl;
                exit(1);
            }
            if (isnan(az) < 1) {
                //       cout<<"az.."<<az<<"azcount"<<azc<<endl;
                az_r = (az + M_PI / 2.);
                az_east[i] = az_r * 180. / M_PI;
                if (az_east[i] < 0.0001 && az_east[i]>0) az_east[i] = 0.0;
                sum = az_east[i];
                tot += sum;
                azc++;
            }
            else {
                az_east[i] = NAN;
            }
        }
        float mean_az_east = tot / (azc);
        // float mean_az_east=tot/(num_gridlines-1);
        cout << "mean_az_east.." << mean_az_east << "numgridlines.." << num_gridlines << endl;
        // exit(1);
 
        for (int j = 0;j < num_gridlines - 1;j++) {
            az_east[j] = mean_az_east;
        }
 
        l1cfile->mean_az_east = mean_az_east;
 
        for (int i = 0;i < num_gridlines - 1;i++) {
 
            if (i % 1 == 0) {
                //assign central positions---
                lat1_l = lati2[i] * M_PI / 180.;
                lat1_r = lati2[i] * M_PI / 180.;
                lat2 = lati2[i + 1] * M_PI / 180.;
                lon1_l = loni2[i] * M_PI / 180.;
                lon1_r = loni2[i] * M_PI / 180.;
                lon2 = loni2[i + 1] * M_PI / 180.;
 
                dlambda = (lon2 - lon1_l);
 
                /*    deltaphi=(lati2[i]-lati2[i+1])*degrad;
                    deltalam=(loni2[i]-loni2[i+1])*degrad;
                    aterm=sin(deltaphi/2)*sin(deltaphi/2)+cos(lati2[i]*degrad)*cos(lati2[i+1]*degrad)*sin(deltalam/2)*sin(deltalam/2);
                    bterm=2*atan2(sqrt(aterm),sqrt(1-aterm));
                    dist=Re*bterm;
                    cout<<dist<<endl;
               */
 
 
                gres = (l1cinput->gres) * 1000; //grid resolution in meters
 
             //   geod.Inverse(lati2[i], loni2[i], lati2[i+1], loni2[i+1], s12);
             //   cout << s12 << "\n";
 
               //bearing---
               //this is Harverside--law f cosines is more accurate---
                az = atan2(sin(dlambda) * cos(lat2), cos(lat1_l) * sin(lat2) - sin(lat1_l) * cos(lat2) * cos(dlambda));
                if (az > M_PI | az < -M_PI) {
                    cout << "problem with BEARING in across-gridline method...az<-180 or >180...." << "az in degrees.." << az * 180 / M_PI << endl;
                    exit(1);
                }
 
                //compute RIGHT across-gridline pixels---
 
                for (int k = 0;k < (nbinx / 2);k++) {
                    h = (l1cinput->gres);//distance between along positions in km, must be 5.2 k m for L1C
                    if (k == 0) h /= 2;//if nadpix
                    htot += h;
 
                    //right pixels---
                    az_r = mean_az_east * degrad;
 
 
                    //    az_r=(az+M_PI/2.);
                   //     az_east[i]=az_r*180./M_PI;
                   //     if(az_east[i]<0.001) az_east[i]=0.0;//this is important later on to avoid issues when converting string to double
 
                         //left pixels---
 
                    az_l = az_r - M_PI;
                    //     az_l=(az-M_PI/2.);//this should be equal to az_r+M_PI=az_l
 
                         //bearing should be always positive (clockwise) before pixel location calculation based on Harverside---     
                    if (az_r < 0.) {
                        az_r = 360 + az_r * 180 / M_PI;
                        az_r = az_r * M_PI / 180;
                    }
 
                    if (az_l < 0.) {
                        az_l = 360 + az_l * 180 / M_PI;
                        az_l = az_l * M_PI / 180;
                    }
           //         ad = (h / Re);
                    //right side--Harversine
               /*     lati_r[k]=asin(sin(lat1_r)*cos(ad)+cos(lat1_r)*sin(ad)*cos(az_r))*180./M_PI;
                    loni_r[k]=lon1_r*180./M_PI+atan2(sin(az_r)*sin(ad)*cos(lat1_r),cos(ad)-sin(lat1_r)*sin(lati_r[k]*M_PI/180.))*180./M_PI;
               */
                    geod.Direct(lat1_r * 180 / M_PI, lon1_r * 180 / M_PI, az_r * 180 / M_PI, gres, latih, lonih);
                    geod.Inverse(lat1_r * 180 / M_PI, lon1_r * 180 / M_PI, latih, lonih, res1);
                    fnan1 = isnan(latih);
                    fnan2 = isnan(lonih);
                    lati_r[k] = latih;
                    loni_r[k] = lonih;
                    //     cout<<"righside.."<<latih<<"..."<<lonih<<"res1"<<res1<<endl;
 
                    lat1_r = lati_r[k] * M_PI / 180;
                    lon1_r = loni_r[k] * M_PI / 180;
 
                    //left side-Harversine
               /*     lati_l[k]=asin(sin(lat1_l)*cos(ad)+cos(lat1_l)*sin(ad)*cos(az_l))*180./M_PI;
                    loni_l[k]=lon1_l*180./M_PI+atan2(sin(az_l)*sin(ad)*cos(lat1_l),cos(ad)-sin(lat1_l)*sin(lati_l[k]*M_PI/180.))*180./M_PI;
               */
                    geod.Direct(lat1_l * 180 / M_PI, lon1_l * 180 / M_PI, az_l * 180 / M_PI, gres, latih2, lonih2);
                    geod.Inverse(lat1_l * 180 / M_PI, lon1_l * 180 / M_PI, latih2, lonih2, res2);
                    fnan3 = isnan(latih2);
                    fnan4 = isnan(lonih2);
                    lati_l[k] = latih2;
                    loni_l[k] = lonih2;
                    //     cout<<"leftside.."<<latih2<<"..."<<lonih2<<"res2"<<res2<<endl;
 
                    lat1_l = lati_l[k] * M_PI / 180;
                    lon1_l = loni_l[k] * M_PI / 180;
 
 
                    //     cout<<"gd.."<<gd+1<<"gd.."<<gd+1<<lati_r[k].."<<lati_l[k]"<<lati_l[k]<<"loni_l[k]"<<loni_l[k]<<"lati_r[k]"<<lati_r[k]<<"loni_r[k]"<<loni_r[k]<<endl;
 
                         //left side
                    //     lat_gd[gd][nbinx/2-1-k]=lati_l[k];//as k increases we are farther away from nadpix or along-track position---
                    //     lon_gd[gd][nbinx/2-1-k]=loni_l[k];
 
                       //right swath side--------------
                    //     lat_gd[gd][k+nbinx/2]=lati_r[k];
                    //     lon_gd[gd][k+nbinx/2]=loni_r[k];
 
                      //right swath side-------------
 
 
                    if (fnan1 > 0 || fnan2 > 0 || res1 > (gres + 6) || res1 < (gres - 6) || lati2[i + 1] < lati2[i] || lati2[i] < latfirst) { //nan values
                //     if(fnan1>0 | fnan2>0 | res1>(gres+6) | res1<(gres-6)){
                        badline++;
                        if (badline == 1) {
                            latfirst = lati2[i];
                        }
 
                        cout << "bad interpolation - missing orbital data..deleteing right side of line.." << i + 1 << latfirst << endl;
                        lati2[i] = NAN;
                        loni2[i] = NAN;
 
                        for (int k = 0;k < (nbinx / 2);k++) {
                            lat_gd[gd][k + nbinx / 2] = NAN;
                            lon_gd[gd][k + nbinx / 2] = NAN;
                        }
                        //       cout<<"nan value.right.."<<endl;
                    }
                    else {
                        lat_gd[gd][k + nbinx / 2] = latih;
                        lon_gd[gd][k + nbinx / 2] = lonih;                    
}
 
                    //left side
                    if (fnan3 > 0 || fnan4 > 0 || res2 > (gres + 6) || res2 < (gres - 6) || lati2[i + 1] < lati2[i] || lati2[i] < latfirst) {
                        //     if(fnan3>0 | fnan4>0 |  res2>(gres+6) | res2<(gres-6)){
                        cout << "bad interpolation - missing orbital data..deleteing left side of line.." << i + 1 << endl;
                        lati2[i] = NAN;
                        loni2[i] = NAN;
                        for (int k = 0;k < (nbinx / 2);k++) {
                            lat_gd[gd][nbinx / 2 - 1 - k] = NAN;//as k increases we are farther away from nadpix or along-track position---
                            lon_gd[gd][nbinx / 2 - 1 - k] = NAN;                        
}
                        //       cout<<"nan value.left.."<<endl;
                    }
                    else {
                        lat_gd[gd][nbinx / 2 - 1 - k] = latih2;//as k increases we are farther away from nadpix or along-track position---
                        lon_gd[gd][nbinx / 2 - 1 - k] = lonih2;                    
}
 
 
                    /*   float longd,latgd,latgd2,longd2;
                       latgd=lat_gd[gd][nbinx/2-1-k];
                       longd=lon_gd[gd][nbinx/2-1-k];
                       latgd2=lat_gd[gd][nbinx/2-1-k+1];
                       longd2=lon_gd[gd][nbinx/2-1-k+1];
 
                       geod.Inverse(latgd,longd,latgd2,longd2, s12);
                       cout <<latgd<<"..."<<latgd2<<"s12..left"<< s12 << "\n";
                       cout <<longd<<"..."<<longd2<< "\n";
                       cout<<s12<<endl;
 
                       latgd=lat_gd[gd][k+nbinx/2];
                       longd=lon_gd[gd][k+nbinx/2];
                       latgd2=lat_gd[gd][k+nbinx/2+1];
                       longd2=lon_gd[gd][k+nbinx/2+1];
                       geod.Inverse(latgd,longd,latgd2,longd2, s12);
                       cout <<latgd<<"..."<<latgd2<<"s12..right"<< s12 << "\n";
                       cout <<longd<<"..."<<longd2<< "\n";
                       cout<<s12<<endl;
                   */
                }//end pixel loop
             //  exit(1); 
 
                htot = 0;
                gd++;
            }//end if every 100 gd
        }//end gridlines loop
        cout << "`L1C gridding successful!......................................." << endl;
        //write results-----
 
        float lontemp = 0.;
        selday = l1cinput->selday;
        selmon = l1cinput->selmon;
        selyear = l1cinput->selyear;
 
        std::string fname_out, pathstr, senstr, monstr, daystr, yearstr, prodstr, gdstr, swtstr, swtnum, extstr;
        pathstr = "out/";
        senstr = "OCIS_";
        monstr = std::to_string(selmon);
        daystr = std::to_string(selday);
        yearstr = std::to_string(selyear);
        prodstr = "L1Cgrid";
        //   gdstr="_gdFULL_";
        swtstr = "_swt";
 
        if (l1cfile->l1c_pflag >= 3) {
            swtd = l1cfile->swtnum;
            swtnum = std::to_string(swtd);
            cout << "swtnum.." << swtnum << endl;
        }
        else swtnum = std::to_string(swtd);
 
        extstr = ".csv";
        fname_out = pathstr + senstr + monstr + daystr + yearstr + prodstr + swtstr + swtnum + extstr;
 
 
        l1cfile->gridname = fname_out.c_str();
        std::ofstream myl1c(fname_out);
 
        myl1c << "lon_gd" << "," << "lat_gd" << endl;
        for (int count = 0; count < num_gridlines - 1;count++) {
            for (int gp = 0; gp < nbinx; gp++) {
                /*     if(count<num_gridlines-2 & lat_gd[count][nadpix]>lat_gd[count+1][nadpix])
                        {
                        cout<<"lat is not increasing north..........."<<endl;
                        for(int gp = 0; gp <nbinx; gp ++){
                           lat_gd[count][gp]=NAN;
                           lon_gd[count][gp]=NAN;
                           myl1c << lon_gd[count][gp] << ","<<lat_gd[count][gp]<<endl;
                          }
 
                        }
                       else
                     */
                myl1c << lon_gd[count][gp] << "," << lat_gd[count][gp] << endl;
                //        cout<<"gd"<<count+1<<"gp"<<gp+1<<"lat_gd[count][gp]"<<lat_gd[count][gp]<<"lon_gd[count][gp]"<<lon_gd[count][gp]<<endl;
 
                 /*   deltaphi=(lat_gd[count][gp]-lat_gd[count][gp+1])*degrad;
                    deltalam=(lon_gd[count][gp]-lon_gd[count][gp+1])*degrad;
     //across-track grid size
                    aterm=sin(deltaphi/2)*sin(deltaphi/2)+cos(lat_gd[count][gp]*degrad)*cos(lat_gd[count][gp+1]*degrad)*sin(deltalam/2)*sin(deltalam/2);
                    bterm=2*atan2(sqrt(aterm),sqrt(1-aterm));
                    dist_u=Re*bterm;
                    cout<<dist_u<<endl;*/
            }//end pixels
   //  exit(1);
        } //end lines   
        myl1c.close();
 
 
        //****************************************************************
        //lat lon grid for visualization--
        prodstr = "L1CgridV";
 
        fname_out = pathstr + senstr + monstr + daystr + yearstr + prodstr + gdstr + swtstr + swtnum + extstr;
        //   std::ofstream myl1c("/accounts/mamontes/images/OCIS/swt1_ALLgd_L1C500_swtd13again.csv");
        std::ofstream myl1cV(fname_out);
        // for(int count = 0; count <num_gridlines; count ++){
             /*    for(int gp = 0; gp <nbinx/2; gp ++){
                    if (loni_l[gp]<0.) loni_l[gp]+=360;
                    if (loni_r[gp]<0.) loni_r[gp]+=360;
                        myl1c << loni_l[gp] << ","<<lati_l[gp]<<endl;
                        myl1c << loni_r[gp] << ","<<lati_r[gp]<<endl;}*/
 
        for (int count = 0; count < num_gridlines - 1;count++) {
            //         for(int count = 0; count <num_gridlines/100;count ++){
            for (int gp = 0; gp < nbinx; gp++) {
                lontemp = lon_gd[count][gp];
                if (lon_gd[count][gp] < -180.) lontemp = lon_gd[count][gp] + 360;
                if (lon_gd[count][gp] > +180.) lontemp = lon_gd[count][gp] - 360;
                if (lontemp < 0.) lontemp += 360.;//make better visualization, all lon values positive
 
                myl1cV << lontemp << "," << lat_gd[count][gp] << endl;            
}        
}
 
 
        myl1cV.close();
 
 
        prodstr = "lat_nadpix";
        fname_out = pathstr + senstr + monstr + daystr + yearstr + prodstr + swtstr + swtnum + extstr;
        //   fname_out= "/accounts/mamontes/images/OCIS/out/"+"L1Cgrid_"+"lat_nadpix"+"_"+swtstr+".txt";
        //   ofstream myfile1 ("/accounts/mamontes/images/OCIS/lat_nadpix_swtd13again.txt");
        ofstream myfile1(fname_out);
        if (myfile1.is_open())
        {
            myfile1 << "lat_nadpix.\n";
            for (int count = 0; count < num_gridlines - 1; count++) {
                //   for(int gp = 0; gp <nbinx; gp ++){
                myfile1 << lati2[count] << "," << endl;
            }
            myfile1.close();
        }
        else cout << "Unable to open file";
        prodstr = "lon_nadpix";
        fname_out = pathstr + senstr + monstr + daystr + yearstr + prodstr + swtstr + swtnum + extstr;
        //  fname_out= "/accounts/mamontes/images/OCIS/out/"+"L1Cgrid_"+"lon_nadpix"+"_"+swtstr+".txt";
        //  ofstream myfile2 ("/accounts/mamontes/images/OCIS/lon_nadpix_swtd13again.txt");
        ofstream myfile2(fname_out);
        if (myfile2.is_open())
        {
            myfile2 << "lon_nadpix.\n";
            for (int count = 0; count < num_gridlines - 1; count++) {
                //   for(int gp = 0; gp <nbinx; gp ++){
                myfile2 << loni2[count] << "," << endl;
            }
            myfile2.close();
        }
        else cout << "Unable to open file";
 
        prodstr = "az_east";
        fname_out = pathstr + senstr + monstr + daystr + yearstr + prodstr + swtstr + swtnum + extstr;
 
        l1cfile->azeast_name = fname_out.c_str();
 
 
 
        //  fname_out= "/accounts/mamontes/images/OCIS/out/"+"L1Cgrid_"+"lon_nadpix"+"_"+swtstr+".txt";
        //  ofstream myfile2 ("/accounts/mamontes/images/OCIS/lon_nadpix_swtd13again.txt");
        ofstream myfile3(fname_out);
        if (myfile3.is_open())
        {
            myfile3 << "az_east.\n";
            for (int count = 0; count < num_gridlines - 1; count++) {
                if (az_east[count] < 0.001) az_east[count] = 0.0;
                myfile3 << az_east[count] << "," << endl;
            }
            myfile3.close();
        }
        else cout << "Unable to open file";
        if(lati_l!=nullptr)
        delete[](lati_l);
        if(lati_r!=nullptr)
        delete[](lati_r);
        if(loni_l!=nullptr)
        delete[](loni_l);
        if(loni_r!=nullptr)
        delete[](loni_r);
 
        //recompute number of gridlines based on lat limits -80 to 80 degrees  
        //asc orbit goes from negative to positive latitude....
        NY = num_gridlines;
        NX = nbinx;
 
        for (int i = 0; i < NY; i++) {
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= -80.) c1++;
                if (c1 == nbinx) {
                    NY1 = i;
                }
            }
            if (NY1 >= 0) break;
            c1 = 1;
        }
 
        for (int i = 0;i < NY; i++) {
            for (int j = 0; j < NX; j++) {
                if (lat_gd[i][j] >= 80.) {
                    NY2 = i - 1;
                }
            }
            if (NY2 >= 0) break;
        }
 
        l1cfile->NY1 = NY1;
        l1cfile->NY2 = NY2;
 
        NY = NY2 - NY1 + 1;
 
        cout << " SUCCESS writing results full L1C grid center positions for--swath #..." << swtd << "\n";
 
        return 0;
    }
 
 
 
 
//si plified version of interp_swt_dist2
int32_t L1C::interp_swt_dist_vec(int swtd, l1c_filehandle* l1cfile, L1C_input* l1cinput, double* time_mgv, float* lati, float* loni, float* lati2, float* loni2) {
  std::string str,pathstr,filestr,ofilestr;
        int32_t  num_gridlines = 0;//4000 gridlines at 5.2 km and 8000 at 2.6 km resolution
        float res = 0;
        double s12;
        float mean_az_east;
        float az_track, thre;
        double newlat, newlon;
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
        //compute delta-t for each each swath daytime--
        num_gridlines = l1cfile->num_gridlines;
        res = (l1cinput->gres);
        mean_az_east = l1cfile->mean_az_east;//mean azimuth in degrees
 
        if(mean_az_east<-180){cout<<"ERROR mean_az_east should be >=-180..."<<mean_az_east<<endl; exit(1);}
        az_track = mean_az_east - 90;
        thre = 0.02;//thres error in km
        
        for (int j = 0;j < num_gridlines;j++) {   
         lati2[j]=lati[j];
         loni2[j]=loni[j];
        }
 
 
 
        //solution inestable at gd 3839
        lati2[0]=lati[0];
        loni2[0]=loni[0];
//        newlat=lati2[0];
//        newlon=loni2[0];
 
        for (int j = 1;j < num_gridlines-1;j++) {           
           s12=0; 
            geod.Inverse(lati2[j], loni2[j], lati2[j + 1], loni2[j + 1], s12);//s12 in m
            s12 = s12 / 1000;
 
            if (s12 > (res + thre) | s12 < (res - thre)) {
                 geod.Direct(lati[j], loni[j], az_track, res * 1000, newlat, newlon);
  //              geod.Direct(newlat,newlon, az_track, res * 1000, newlat, newlon);
 
//                lati2[j] = newlat;
//                loni2[j] = newlon;
                  lati2[j+1] = newlat;
                  loni2[j+1] = newlon;
 
                cout<<"gd#.."<<j+1<<"corrected s12.."<<s12<<"lati2.."<<lati2[j]<<"loni2.."<<loni2[j]<<endl;
            }
 
           if (isnan(s12) == 1) { cout << "no convergence for s12" << endl;exit(1); }
 
        }
 
/*
       for (int j = 0;j < num_gridlines - 1;j++) {
           s12=0;
            geod.Inverse(lati2[j], loni2[j], lati2[j + 1], loni2[j + 1], s12);
            cout<<"gd#.."<<j+1<<"corrected s12.."<<s12<<"lati2.."<<lati2[j]<<"loni2.."<<loni2[j]<<endl;
       }  
*/
 
 
 
        cout << "L1C::interp_swt_dist2.. second interpolation (distance along-track gridpoints)..." << "swath #.." << swtd << "\n";
        //-------------------------------------------------------------------------------------------------------------
        //writing results---only nadir pixels---
        cout << " writing results second interpolation--swath #..." << swtd << "\n";
        ofilestr=std::string(l1cinput->ofile);
        filestr="lat2_dist.txt";
        pathstr="out/"+ofilestr+"_"+filestr;
 
        ofstream myfile1(pathstr);
 
        if (myfile1.is_open())
        {
            myfile1 << "lat2_dist.\n";
            for (int count = 0; count < num_gridlines-1; count++) {
                myfile1 << lati2[count] << "," << endl;
            }
            myfile1.close();
        }
        else cout << "Unable to open lat2_dist.txt file";
 
//----------------------------------------------------------------------------------------
        filestr="lon2_dist.txt";
        pathstr="out/"+ofilestr+"_"+filestr;
        ofstream myfile2(pathstr);
 
        if (myfile2.is_open())
        {
            myfile2 << "lon2_dist.\n";
            for (int count = 0; count < num_gridlines-1; count++) {
                myfile2 << loni2[count] << "," << endl;
            }
            myfile2.close();
        }
        else cout << "Unable to open lon2_dist.txt file";
 
 
        exit(1);
 
        return 0;
    }
 
 
 
 
//for the vector version -telemetry files L1A
int32_t L1C::interp_swt_dist3(int swtd, l1c_filehandle* l1cfile, L1C_input* l1cinput, int16_t* swtd_id, int16_t* file_id, int16_t* nfiles_swt, double* time_mgv, float* lati, float* loni, float* lati2, float* loni2) {
        std::string str,pathstr,filestr,ofilestr;
        int32_t  num_gridlines = 0;//4000 gridlines at 5.2 km and 8000 at 2.6 km resolution
        float res = 0;
        double s12;
        float mean_az_east;
        float az_track, thre;
        double newlat, newlon;
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
        //compute delta-t for each each swath daytime--
        num_gridlines = l1cfile->num_gridlines;
        res = (l1cinput->gres);
 
 
        mean_az_east = l1cfile->mean_az_east;
        if(mean_az_east<-180){cout<<"ERROR mean_az_east should be >=-180..."<<mean_az_east<<endl; exit(1);}
 
        az_track = mean_az_east - 90;
        thre = 0.0;
 
        thre = 0.02;//thres error in km
 
        for (int j = 0;j < num_gridlines;j++) {
         lati2[j]=lati[j];
         loni2[j]=loni[j];
        }
 
 
        for (int j = 0;j < num_gridlines-1;j++) {
            s12=0;
            geod.Inverse(lati2[j], loni2[j], lati2[j + 1], loni2[j + 1], s12);//s12 in m
            s12 = s12 / 1000;
 
            if (s12 > (res + thre) | s12 < (res - thre)) {
                geod.Direct(lati[j], loni[j], az_track, res * 1000, newlat, newlon);
 
                lati2[j+1] = newlat;
                loni2[j+1] = newlon;
 
 
  //             cout<<"gd.."<<j+1<<endl;
            }
 
           if (isnan(s12) == 1) { cout << "no convergence for s12" << endl;exit(1); }
 
        }
 
 
        cout << "L1C::interp_swt_dist2.. second interpolation (distance along-track gridpoints)..." << "swath #.." << swtd << "\n";
        //-------------------------------------------------------------------------------------------------------------
        //writing results---only nadir pixels---
        cout << " writing results second interpolation--swath #..." << swtd << "\n";
        ofilestr=std::string(l1cinput->ofile);
        filestr="lat2_dist.txt";
        pathstr="out/"+ofilestr+"_"+filestr;
 
        ofstream myfile1(pathstr);
 
        if (myfile1.is_open())
        {
            myfile1 << "lat2_dist.\n";
            for (int count = 0; count < num_gridlines-1; count++) {
                myfile1 << lati2[count] << "," << endl;
            }
            myfile1.close();
        }
        else cout << "Unable to open lat2_dist.txt file";
 
//----------------------------------------------------------------------------------------
        filestr="lon2_dist.txt";
        pathstr="out/"+ofilestr+"_"+filestr;
        ofstream myfile2(pathstr);
 
        if (myfile2.is_open())
        {
            myfile2 << "lon2_dist.\n";
            for (int count = 0; count < num_gridlines-1; count++) {
                myfile2 << loni2[count] << "," << endl;
            }
            myfile2.close();
        }
        else cout << "Unable to open lon2_dist.txt file";
 
 
        return 0;
    }
 
 
 
 
int32_t L1C::interp_swt_dist2(int swtd, l1c_filehandle* l1cfile, L1C_input* l1cinput, int16_t* swtd_id, int16_t* file_id, int16_t* nfiles_swt, double* time_mgv, float* lati, float* loni, float* lati2, float* loni2) {
        std::string str,pathstr,filestr,ofilestr;
        int32_t  num_gridlines = 0;//4000 gridlines at 5.2 km and 8000 at 2.6 km resolution
        float res = 0;
        double* dist_a, * dist_ai, s12;
        float mean_az_east;
        float az_track, thre;
        double newlat, newlon;
 
        Geodesic geod(Constants::WGS84_a(), Constants::WGS84_f());
        //compute delta-t for each each swath daytime--
        num_gridlines = l1cfile->num_gridlines;
        res = (l1cinput->gres);
        dist_a = (double*)malloc(num_gridlines * sizeof(double));
        dist_ai = (double*)malloc(num_gridlines * sizeof(double));
 
 
        mean_az_east = l1cfile->mean_az_east;
        if(mean_az_east<-180){cout<<"ERROR mean_az_east should be >=-180..."<<mean_az_east<<endl; exit(1);}
        az_track = mean_az_east - 90;
        thre = 0.03;
 
 
 
        for (int j = 0;j < num_gridlines;j++) {
            dist_a[j] = 0.;
            dist_ai[j] = 0.;
            //  cout<<"gd"<<j+1<<"lati..."<<lati[j]<<"loni..."<<loni[j]<<endl;
        }
 
        double tot1, tot2;
 
        for (int j = 0;j < num_gridlines - 2;j++) {
            tot1 += res;//res in km
            dist_a[j] = tot1;
            geod.Inverse(lati[j], loni[j], lati[j + 1], loni[j + 1], s12);//s12 in m
            s12 = s12 / 1000;
            tot2 += s12;
            if (s12 > (res + thre) | s12 < (res - thre)) {
                geod.Direct(lati[j], loni[j], az_track, res * 1000, newlat, newlon);
                lati2[j] = newlat;
                loni2[j] = newlon;
            //    cout<<"gd#..."<<j+1<<"lati2...."<<lati2[j]<<"s12..."<<s12<<"res.."<<res<<endl;
            }
            else {
                lati2[j] = lati[j];
                loni2[j] = loni[j];
            }
 
            if (isnan(s12) == 1) { cout << "no convergence for s12" << endl;exit(1); }
 
//            cout<<"gd#..."<<j+1<<"lati2...."<<lati2[j]<<"s12..."<<s12<<"res.."<<res<<endl;
        }
       
 
        //      dist_ai[j]=tot2;//increasing distance similar to time, important for interpolation
          //    cout<<s12<<endl;
        //      cout<<lati[j]<<endl;
 
            //   cout<<"gd.."<<j+1<<"dista.."<<dist_a[j]<<"distai.."<<dist_ai[j]<<endl;
        //      if(isnan(s12)==1){ cout<<"no convergence for s12"<<endl;exit(1);}
        //      }
 
        //  exit(1);
 
        cout << "L1C::interp_swt_dist2.. second interpolation (distance along-track gridpoints)..." << "swath #.." << swtd << "\n";
 
 
        /*
           latlon_interp_dist(num_gridlines,dist_ai,lati,loni,dist_a,lati2,loni2);
 
           cout<<"checking for badlines................"<<endl;
        int badline=0,fnan1,jini,jend,npoints,c;
           float latfirst=-999,latlast=-999,dlat,dlon,lonfirst,lonlast;
           std::vector<int16_t> badindex;
 
           for(int j=0;j<num_gridlines-1;j++){
            // cout<<"gdindex"<<j<<"lati2..."<<lati2[j]<<"loni2..."<<loni2[j]<<endl;
             //checking that s12 is 5200 m resolutioni????
              geod.Inverse(lati2[j], loni2[j], lati2[j+1], loni2[j+1], s12);
              fnan1=isnan(s12);
 
         //     cout<<"gd.."<<j+1<<s12<<endl;
          //    cout<<lati2[j]<<endl;
         //     cout<<"fnan.."<<fnan1<<"j.."<<j<<endl;
            //time interpolation of lat/lon rather than distance interpolation
 
             if(fnan1>0 | lati2[j+1]<lati2[j]){ //assuming ascending orbit
                 badline++;
                 if(badline==1){
                    latfirst=lati2[j];
                    lonfirst=loni2[j];
                    jini=j;
                        }
                   }
 
             if (fnan1>0 | latfirst>-999 & lati2[j]>latfirst){
                    latlast=lati2[j];
                     lonlast=loni2[j];
                    jend=j;
               //     cout<<"fnan.."<<fnan1<<"j.."<<j<<"lati2[j].."<<lati2[j]<<"latfirst"<<latfirst<<"latlast"<<latlast<<endl;
                        }
             if(latlast>-999){
                  j=num_gridlines-1;
                  break;}
              }//endgridlines
 
          //gd points to interpolate
           npoints=jend-jini+1;
           dlat=(latlast-latfirst)/npoints;
           if(lonfirst<0) lonfirst+=360;
           if(lonlast<0) lonlast+=360;
           dlon=(lonfirst-lonlast)/npoints;
 
           c=1;
           for(int j=jini+1;j<jend;j++){
             lati2[j]=lati2[jini]+dlat*c;
             loni2[j]=loni2[jini]-dlon*c;
             c++;
            }
           cout<<"npoints.."<<npoints<<"dlat.."<<dlat<<"dlon"<<dlon<<"jini"<<jini<<"jend"<<jend<<endl;
           cout<<"latfirst"<<latfirst<<"latpast"<<latlast<<"lonfirst"<<lonfirst<<"lonpast"<<lonlast<<endl;
 
 
           for(int j=0;j<num_gridlines-1;j++){
            if(loni2[j]<0) lontemp=loni2[j]+360;else lontemp=loni2[j];
             if(loni2[j+1]<0) lontemp2=loni2[j+1]+360;else lontemp2=loni2[j+1];
 
         //   cout<<"gdindex.."<<j<<"lati2.."<<lati2[j]<<"loni2.."<<loni2[j]<<endl;
            if(lati2[j+1]<lati2[j] | lontemp2>lontemp & j<num_gridlines-2){
              cout<<"spatial interpolation...still issues lati2[j+1]<lati2[j] "<<"j"<<j<<endl;
              cout<<"lati2.."<<lati2[j]<<"lati2 j+1.."<<lati2[j+1]<<"loni2..."<<loni2[j]<<"loni2 j+1.."<<loni2[j+1]<<endl;
 
                 }
            if(lontemp2>lontemp & j<num_gridlines-2){
               cout<<"spatial interpolation....still issues lontemp2>lontemp"<<"j"<<j<<endl;
                cout<<"lati2.."<<lati2[j]<<"lati2 j+1.."<<lati2[j+1]<<"loni2..."<<loni2[j]<<"loni2 j+1.."<<loni2[j+1]<<endl;
             }
 
           }
 
        //   exit(1);
         //  cout<<"latfirst"<<latfirst<<"latlast"<<latlast<<endl;
 
 
          // cout<<"flat..."<<flat<<"flon"<<flon<<"llat"<<llat<<"llon"<<llon<<endl;
 
        */
 
//-------------------------------------------------------------------------------------------------------------
        //writing results---only nadir pixels---
        cout << " writing results second interpolation--swath #..." << swtd << "\n";
        ofilestr=std::string(l1cinput->ofile);
        filestr="lat2_dist.txt";
        pathstr="out/"+ofilestr+"_"+filestr;
 
        ofstream myfile1(pathstr);
 
        if (myfile1.is_open())
        {
            myfile1 << "lat2_dist.\n";
            for (int count = 0; count < num_gridlines-2; count++) {
                myfile1 << lati2[count] << "," << endl;
            }
            myfile1.close();
        }
        else cout << "Unable to open lat2_dist.txt file";
 
//----------------------------------------------------------------------------------------
        filestr="lon2_dist.txt";
        pathstr="out/"+ofilestr+"_"+filestr;        
        ofstream myfile2(pathstr);
 
        if (myfile2.is_open())
        {
            myfile2 << "lon2_dist.\n";
            for (int count = 0; count < num_gridlines-2; count++) {
                myfile2 << loni2[count] << "," << endl;
            }
            myfile2.close();
        }
        else cout << "Unable to open lon2_dist.txt file";
 
        if (dist_a != NULL)
            delete[](dist_a);
        if (dist_ai != NULL)
            delete[](dist_ai);
 
 
        //  exit(1);
 
        return 0;
    }
 
 
 
 
int32_t L1C::interp_swt1(int swtd, l1c_filehandle* l1cfile, L1C_input* l1cinput,int16_t* swtd_id, int16_t* file_id, int16_t* nfiles_swt, double* time_mgv, orb_array* velig, float* lati, float* loni) {
        const char* ptstr;
        int dimid, status;
        std::string str,pathstr,filestr,ofilestr;
        int16_t fi = 0;
        int32_t  num_scans_tot = 0, swt_orb_rec = 0, num_orb_rec;
        int32_t ffile = 1,num_gridlines = 0, n_files, iscan = 0;//4000 gridlines at 5.2 km and 8000 at 2.6 km resolution
        float hsat = 676.5;
        double* time_tot;
        float** lat_tot, ** lon_tot;
 
        num_gridlines = l1cfile->num_gridlines;
        nswath = l1cfile->nswath;
        num_pixels = l1cfile->npix;
        n_files = l1cfile->ifiles.size();
        int16_t nfiles_swath = nfiles_swt[swtd - 1];
        int nadpix = l1cfile->nadpix;
 
        time_tot = (double*)malloc(num_scans * nfiles_swath * sizeof(double));
        orb_array* posr_tot = new orb_array[num_scans * nfiles_swath]();//these are arrays #orb_rec x 3 vect components
        orb_array* velr_tot = new orb_array[num_scans * nfiles_swath]();
 
        lat_tot = allocate2d_float(num_scans * nfiles_swath, num_pixels);
        lon_tot = allocate2d_float(num_scans * nfiles_swath, num_pixels);
 
        //opening swath files----
        for (int i = 0;i < n_files;i++) {
            if (swtd == swtd_id[i]) {
                fi = file_id[i];
                str = l1cfile->ifiles[fi - 1];
                ptstr = str.c_str();
 
                status = nc_open(ptstr, NC_NOWRITE, &ncid_L1B);
                if (status != NC_NOERR) {
                      fprintf(stderr, "-E- failed nc_open\n");
                    exit(EXIT_FAILURE);
               }
                //Open dimensions
                // num_scans
                status = nc_inq_dimid(ncid_L1B, "number_of_scans", &dimid);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading number_of_scans.\n");
                    exit(EXIT_FAILURE);
                }
                nc_inq_dimlen(ncid_L1B, dimid, &num_scans);
 
                status = nc_inq_dimid(ncid_L1B, "ccd_pixels", &dimid);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading number_of_scans.\n");
                    exit(EXIT_FAILURE);
                }
                nc_inq_dimlen(ncid_L1B, dimid, &num_pixels);
 
                //define file time/geo pointers--
                double* orb_time = new double[num_scans]();//with Fred file num_scans = sdim
                orb_array* posr = new orb_array[num_scans]();//these are arrays #orb_rec x 3 vect components
                orb_array* velr = new orb_array[num_scans]();//num_scans=num_orb_records cause interpolated previously by Fred to scanlines
                lat = allocate2d_float(num_scans, num_pixels);
                lon = allocate2d_float(num_scans, num_pixels);
 
                //open scan_time (in Fred L1B file is orb_time interpolated)
                status = nc_inq_grp_ncid(ncid_L1B, "scan_line_attributes", &scGrp);
                check_err(status, __LINE__, __FILE__);
 
                status = nc_inq_varid(scGrp, "time", &otId);
                check_err(status, __LINE__, __FILE__);
                status = nc_get_var_double(scGrp, otId, orb_time);
                check_err(status, __LINE__, __FILE__);
 
                //open orb vectors
                status = nc_inq_grp_ncid(ncid_L1B, "navigation_data", &navGrp);
                check_err(status, __LINE__, __FILE__);
 
                status = nc_inq_varid(navGrp, "orb_pos", &opId);//scans x velements
                check_err(status, __LINE__, __FILE__);
                status = nc_get_var_float(navGrp, opId, &posr[0][0]);
                check_err(status, __LINE__, __FILE__);
 
                status = nc_inq_varid(navGrp, "orb_vel", &ovId);
                check_err(status, __LINE__, __FILE__);
                status = nc_get_var_float(navGrp, ovId, &velr[0][0]);
                check_err(status, __LINE__, __FILE__);
 
                //open geo data
                status = nc_inq_grp_ncid(ncid_L1B, "geolocation_data", &geoGrp);
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(geoGrp, "latitude", &latId);//scans x velements
                check_err(status, __LINE__, __FILE__);
                status = nc_get_var_float(geoGrp, latId, &lat[0][0]);
                check_err(status, __LINE__, __FILE__);
 
                status = nc_inq_varid(geoGrp, "longitude", &lonId);//scans x velements
                check_err(status, __LINE__, __FILE__);
                status = nc_get_var_float(geoGrp, lonId, &lon[0][0]);
                check_err(status, __LINE__, __FILE__);
 
                //concatenate 1-D time and 2-D geo vectors for the swath---
                //check orbit direction changes (ascending to descending) within the same file if the file is the lastof the swath
                size_t last_scans = 0;
                if (swtd != swtd_id[i + 1]) {
                    for (unsigned int j = 0;j < num_scans + 1;j++) {
                        if (lat[j + 1][nadpix] < lat[j][nadpix]) break;
                        last_scans++;
                    }
                    num_scans = last_scans;
                    cout << "last file..with #scans" << last_scans << endl;
                }
 
                num_scans_tot += num_scans;
                num_orb_rec = num_scans;
                swt_orb_rec += num_orb_rec;
 
                for (unsigned int j = 0;j < num_scans;j++)
                    time_tot[j + iscan] = orb_time[j];
 
                for (unsigned int j = 0;j < num_scans;j++) {
                    posr_tot[j + iscan][0] = posr[j][0];
                    posr_tot[j + iscan][1] = posr[j][1];
                    posr_tot[j + iscan][2] = posr[j][2];
 
                    velr_tot[j + iscan][0] = velr[j][0];
                    velr_tot[j + iscan][1] = velr[j][1];
                    velr_tot[j + iscan][2] = velr[j][2];
                }
 
                for (unsigned int j = 0;j < num_scans;j++) {
                    for (unsigned int k = 0;k < num_pixels;k++) {
                        lat_tot[j + iscan][k] = lat[j][k];
                        lon_tot[j + iscan][k] = lon[j][k];
                    }                
                }  
 
                //close file if not the last   
                status = nc_close(ncid_L1B);
                check_err(status, __LINE__, __FILE__);
 
                delete[](orb_time);
                delete[](posr);
                delete[](velr);
                delete[](lat);
                delete[](lon);
 
                iscan += num_scans;
                ffile++;
            }//end if
        }//end for
 
 
        cout << "num_scans_tot.." << num_scans_tot << "should be equal to numfiles x numscans/file.." << num_scans * nfiles_swath << "and swath records.." << swt_orb_rec << endl;
 
        //the number of orb records must be larger than the number of gridlines for the interpolation since we bracket orb records with gridlines
       //since orb records were interpolated to scanlines we have more orb records than gridlines and we need to decimate orb records by a factor of 10 lets say
       //*******************************************************************************
 
        if (swt_orb_rec <= num_gridlines) {
            cout << "-E- Error --number of swath records" << swt_orb_rec << " must be >= than number of gridlines for interpolation" << num_gridlines << ".\n" << endl;
            exit(EXIT_FAILURE);
        }
 
        orb_array* posi = new orb_array[num_gridlines]();
        orb_array* veli = new orb_array[num_gridlines]();
 
        cout << " first interpolation of orb records..." << "swath #.." << swtd << "\n";
 
        //interpolating orbital velocity and ground position to time_mean ground velocity
        orb_interp(swt_orb_rec, num_gridlines, time_tot, posr_tot, velr_tot, time_mgv, posi, veli);
        latlon_interp(swt_orb_rec, num_gridlines, num_pixels, time_tot, lat_tot, lon_tot, time_mgv, lati, loni);
 
//        for(int i=0;i<num_scans_tot-1;i++) cout<<"scan#.."<<i+1<<"latot.."<<lat_tot[i][nadpix]<<"delta time_mgv.."<<time_tot[i+1]-time_tot[i]<<endl;
//        exit(1);
 
//*****************************************************************************************************************************************************************************        
        //writing results---only nadir pixels---
        cout << " writing results first interpolation---swath #..." << swtd << "\n";
        ofilestr=std::string(l1cinput->ofile);
        filestr="lat_mgv.txt";
        pathstr="out/"+ofilestr+"_"+filestr;
 
//-----lat -------------------------        
        ofstream myfile5(pathstr);
//        ofstream myfile5("out/lat_mgv.txt");
 
        if (myfile5.is_open())
        {
            myfile5 << "lat_mgv.\n";
            for (int count = 0; count < num_gridlines-1; count++) {
                myfile5 << lati[count] << "," << endl;
            }
            myfile5.close();
        }
        else cout << "Unable to open lat_mgv.txt file";
//----lon------------------------------------------------------
       filestr="lon_mgv.txt";
       pathstr="out/"+ofilestr+"_"+filestr;
 
//        ofstream myfile6("out/lon_mgv.txt");
       ofstream myfile6(pathstr);   
 
        if (myfile6.is_open())
        {
            myfile6 << "lon_mgv.\n";
            for (int count = 0; count < num_gridlines-1; count++) {
                myfile6 << loni[count] << "," << endl;
            }
            myfile6.close();
        }
        else cout << "Unable to open lon_mgv.txt file";
 
        if (time_tot != NULL)
            delete[](time_tot);
        if (posr_tot != NULL)
            delete[](posr_tot);
        if (velr_tot != NULL)
            delete[](velr_tot);
        if (lat_tot != NULL)
            delete[](lat_tot);
        if (lon_tot != NULL)
            delete[](lon_tot);
 
        //compute ground velocity--
        for (int j = 0;j < num_gridlines;j++) {
            velig[j][0] = veli[j][0] * Re / (Re + hsat);
            velig[j][1] = veli[j][1] * Re / (Re + hsat);
            velig[j][2] = veli[j][2] * Re / (Re + hsat);
        }
 
        if (posi != NULL)
            delete[](posi);
        if (veli != NULL)
            delete[](veli);
 
        return 0;
    }
 
 
int32_t L1C::time_swt3(int swtd, l1c_filehandle* l1cfile, L1C_input* l1cinput, double* ect_swtd, int16_t* swtd_id, int16_t* file_id, int16_t* nfiles_swt, float* mgv_swath, double* time_mgv) {
        float mot, ect = -1;//mean time
        const char* ptstr;
        int status;
        std::string str;
        int16_t fi = 0;
        size_t num_scans_tot = 0, swt_orb_rec = 0, num_orb_rec = 0;
        double  tini, tend;//in seconds
        int32_t num_frames=-1,n_files, ffile = 1;//4000 gridlines at 5.2 km and 8000 at 2.6 km resolution
 
        cout<<"crossing time..."<<ect_swtd[0]<<endl;
 
        nswath = l1cfile->nswath;
        n_files = l1cfile->ifiles.size();
        num_scans = l1cfile->nscan;
        num_pixels = l1cfile->npix;
        num_frames=l1cfile->nframes;
 
        mot = ((l1cinput->gres) * 1000) / mgv_swath[swtd - 1];//delta-t in seconds
//        cout << "mean swath vel.." << mgv_swath[swtd - 1] << "[mot..." << mot << "for day swath #.." << swtd << endl;
 
        cout<<"computing mean velocity time intervals......................................................................................for swath #...."<<swtd<<endl;
        cout<<"swtd.."<<swtd<<"swtdid"<<swtd_id[0]<<"nfiles"<<n_files<<file_id[0]<<endl;
 
        for (int i = 0;i < n_files;i++) {
          if (swtd == swtd_id[i]) {
                //open files with the same crossing swath and compute time series based on mean time        
                fi = file_id[i];
                str = l1cfile->ifiles[fi - 1];
                ptstr = str.c_str();
                cout << "Opening file.." << ptstr << " for crossing swath..." << swtd << "file_id.." << file_id[i] << "swt_id.." << swtd_id[i] << endl;
                status = nc_open(ptstr, NC_NOWRITE, &ncid_L1B);
 
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error failed nc_open.\n");
                    exit(EXIT_FAILURE);
                        }
                //defining swath pointers
                double* orb_time = new double[num_frames]();//with Fred file num_scans = sdim
 
           //open scan_time (in Fred L1B file is orb_time interpolated)
                status = nc_inq_grp_ncid(ncid_L1B, "NAVIGATION", &scGrp);
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(scGrp, "msec", &otId);
                check_err(status, __LINE__, __FILE__);
                status = nc_get_var_double(scGrp, otId, orb_time);
                check_err(status, __LINE__, __FILE__);
 
           for (int k = 0;k <num_frames;k++){
                num_scans_tot += num_scans;
                num_orb_rec = num_scans;
                swt_orb_rec += num_orb_rec;
 
             //   cout << "num_frames.."<<num_frames<<"num_scans_tot..." << num_scans_tot << "num of orb records for swath..." << swt_orb_rec << "so far file.." << ptstr << "swath #.." << swtd << endl;                 
                if (k == 0)
                    tini = orb_time[0]/1000;//in seconds
 
                if (k==num_frames-1)//this is the last file of the swath
                    tend = orb_time[num_frames - 1]/1000;//in seconds
              }//end frames
 
            cout<<"tini.."<<tini<<"tend.."<<tend<<"ect.."<<ect_swtd[i]<<endl;
 
 
            if (ect_swtd[i] > 0.0)//only 1 file is carrying the crossing time the other bunch of that swath is -999
                    ect = ect_swtd[i];
                //close file if not the last   
            status = nc_close(ncid_L1B);
            check_err(status, __LINE__, __FILE__);
 
            delete[](orb_time);
            ffile++;
            }//end if swath
        }//end for files 
 
       
 
        if (ect > 0.0) {
  //          cout << "tini..." << tini << "tend..." << tend << "for swath..#.." << swtd << "mot..." << mot << "ect..." << ect << endl;
            //before eq crosssing time bins
  //         double  dtime = (ect - mot / 2) - tini;
 
            double tg = ect - mot / 2;
            int binb = 0, bina = 0;
 
            while (tg > (tini - mot / 2)) {
                binb++; //bins below eq crossing bin which is eq cros time +-mot/2
                tg -= mot;
            }
 
            tg = ect + mot / 2;
 
            while (tg < (tend + mot / 2)) {
                bina++;//time bins above eq crossing time
                tg += mot;
            }
 
            //second way of computing gridlines---
//            dtime = tend - tini;
  
 
            l1cfile->num_gridlines = binb + bina;
 
            //before--  
            for (int bin = 0;bin < binb;bin++) //300 seconds are 5 minutes or 1 file from Fred
                time_mgv[bin] = tini + bin * mot;
 
             int binc = binb-1;
//            time_mgv[binc] = ect;//equat crossing time bin
 
            //after
 //           for (int bin = 1;bin < bina + 1;bin++){ //300 seconds are 5 minutes or 1 file from Fred
            for (int bin = 1;bin < bina;bin++){ //300 seconds are 5 minutes or 1 file from Fred
                time_mgv[binc + bin] = time_mgv[binc] + bin * mot;}
 
//                cout<<"bina.."<<bina<<"binb.."<<binb<<"ect.."<<ect<<endl;
        }//ect>0 
 
 
        return 0;
    }
 
 
 
int32_t L1C::time_swt2(int swtd, l1c_filehandle* l1cfile, L1C_input* l1cinput, double* ect_swtd, int16_t* swtd_id, int16_t* file_id, int16_t* nfiles_swt,  float* mgv_swath, double* time_mgv) {
        float mot, ect = -1;//mean time
        const char* ptstr;
        int dimid, status;
        std::string str;
        int16_t fi = 0;
        size_t num_scans_tot = 0, swt_orb_rec = 0, num_orb_rec = 0;
        double  tini, tend;//in seconds
        int32_t n_files, ffile = 1;//4000 gridlines at 5.2 km and 8000 at 2.6 km resolution
 
        nswath = l1cfile->nswath;
        num_scans = l1cfile->nscan;
        n_files = l1cfile->ifiles.size();
 
        mot = ((l1cinput->gres) * 1000) / mgv_swath[swtd - 1];//delta-t in seconds
//        cout << "mean swath vel.." << mgv_swath[swtd - 1] << "[mot..." << mot << "for day swath #.." << swtd << endl;
 
        cout<<"computing mean velocity time intervals......................................................................................for swath #...."<<swtd<<endl;
 
        for (int i = 0;i < n_files;i++) {
            if (swtd == swtd_id[i]) {
                //open files with the same crossing swath and compute time series based on mean time        
                fi = file_id[i];
                str = l1cfile->ifiles[fi - 1];
                ptstr = str.c_str();
                cout << "Opening file.." << ptstr << " for crossing swath..." << swtd << "file_id.." << file_id[i] << "swt_id.." << swtd_id[i] << endl;
                status = nc_open(ptstr, NC_NOWRITE, &ncid_L1B);
 
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error failed nc_open.\n");
                    exit(EXIT_FAILURE);
           }
 
                //Open dimensions
                // num_scans
                status = nc_inq_dimid(ncid_L1B, "number_of_scans", &dimid);
                if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error reading number_of_scans.\n");
                    exit(EXIT_FAILURE);
                }
                nc_inq_dimlen(ncid_L1B, dimid, &num_scans);
 
                num_scans_tot += num_scans;
                num_orb_rec = num_scans;
                swt_orb_rec += num_orb_rec;
 
    //            cout << "num_scans_tot..." << num_scans_tot << "num of orb records for swath..." << swt_orb_rec << "so far file.." << ptstr << "swath #.." << swtd << endl;
 
                //defining swath pointers
                double* orb_time = new double[num_scans]();//with Fred file num_scans = sdim
 
                //open scan_time (in Fred L1B file is orb_time interpolated)
                status = nc_inq_grp_ncid(ncid_L1B, "scan_line_attributes", &scGrp);
                check_err(status, __LINE__, __FILE__);
                status = nc_inq_varid(scGrp, "time", &otId);
                check_err(status, __LINE__, __FILE__);
                status = nc_get_var_double(scGrp, otId, orb_time);
                check_err(status, __LINE__, __FILE__);
 
                if (ffile == 1)
                    tini = orb_time[0];
 
                if (ffile != 1 & swtd != swtd_id[i + 1])//this is the last file of the swath
                    tend = orb_time[num_scans - 1];
 
                if (ect_swtd[i] > 0.0)//only 1 file is carrying the crossing time the other bunch of that swath is -999
                    ect = ect_swtd[i];
                //close file if not the last   
                status = nc_close(ncid_L1B);
                check_err(status, __LINE__, __FILE__);
 
                delete[](orb_time);
                ffile++;
            }//end if
        }//end for  
 
        if (ect > 0.0) {
  //          cout << "tini..." << tini << "tend..." << tend << "for swath..#.." << swtd << "mot..." << mot << "ect..." << ect << endl;
            //before eq crosssing time bins
  //         double  dtime = (ect - mot / 2) - tini;
 
            double tg = ect - mot / 2;
            int binb = 0, bina = 0;
 
            while (tg > (tini - mot / 2)) {
                binb++; //bins below eq crossing bin which is eq cros time +-mot/2
                tg -= mot;
            }
 
            tg = ect + mot / 2;
 
            while (tg < (tend + mot / 2)) {
                bina++;//time bins aove eq crossing time
                tg += mot;
            }
 
            //second way of computing gridlines---
//            dtime = tend - tini;
  
 
            l1cfile->num_gridlines = binb + bina;
 
            //before--  
            for (int bin = 0;bin < binb;bin++) //300 seconds are 5 minutes or 1 file from Fred
                time_mgv[bin] = tini + bin * mot;
 
            int binc = binb-1;
      //      time_mgv[binc] = ect;//equat crossing time bin
 
            //after
            for (int bin = 1;bin < bina;bin++) //300 seconds are 5 minutes or 1 file from Fred
                time_mgv[binc + bin] = time_mgv[binc] + bin * mot;
 
//        for (int bin = 0;bin <bina+binb-1;bin++) cout<<time_mgv[bin]<<endl;
 
 
 
        }//ect>0 
        return 0;
    }
 
 
 
 
int32_t L1C::mov_sd3(l1c_filehandle* l1cfile, L1C_input* l1cinput, double* tcross, int16_t* file_id, int16_t* swtd_id, int16_t* nfiles_swath, double* ect_swtd, int16_t* tod, int16_t* orbdir, float* mgv_swath) {
        int dimidv,dimidx,dimidy,dimidz,status;
        int32_t n_files, nadpix;
        std::string str;
        const char* ptstr;     
        float* lat_id;
        int16_t* swath_id, * tod_id, * orbdir_id;
        std::string ifile_str;
        char* ifile_char;
        float lat_s=-80,lat_n=+80;
        int ovelId,latId1,latId2,latId3,lonId1,lonId2,lonId3,sen1Grp,sen2Grp,sen3Grp;
        float ***latframe1=nullptr,***latframe2=nullptr,***latframe3=nullptr,***lonframe1=nullptr,***lonframe2=nullptr,***lonframe3=nullptr,**ovel=nullptr;
        size_t vcomp;
        float mgv=-1;
 
        
        ifile_str = l1cinput->files[0];
        ifile_char = &ifile_str[0];
        file_format format=getFormat(ifile_char);
        format.type=FT_HARP;
        cout<<"sensor format type.."<<format.type<<endl;
 
        nadpix = l1cfile->nadpix;
        n_files = l1cfile->ifiles.size();
//        int16_t nswath = l1cfile->nswath;
 
        swath_id = (int16_t*)calloc(n_files,sizeof(int16_t));
        lat_id = (float*)calloc(n_files,sizeof(float));
        tod_id = (int16_t*)calloc(n_files,sizeof(int16_t));
        orbdir_id = (int16_t*)calloc(n_files,sizeof(int16_t));
 
 
        cout<<"# HARP files.to be processed.."<<n_files<<endl;
 
 
        //big loop
        size_t swtdid=1,fileid=swtdid;
        for (int i = 0;i < n_files;i++) {
 
            if(tcross[i]>0){
                 ect_swtd[i]=tcross[i]; 
                 swtd_id[i]=swtdid;
                 file_id[i]=fileid;
                 swtdid++;
                 fileid++;
            }
            str = l1cfile->ifiles[i];
            ptstr = str.c_str();
 
            // Open the netcdf4 input file
            status = nc_open(ptstr, NC_NOWRITE, &ncid_L1B);
            if (status != NC_NOERR) {
                fprintf(stderr, "-E- Error failed nc_open.\n");
                 exit(EXIT_FAILURE);
            }
            //dimensions
            status = nc_inq_dimid(ncid_L1B,"Frames", &dimidz);
            if (status != NC_NOERR) {
               fprintf(stderr, "-E- Error reading number_of frames.\n");
               exit(EXIT_FAILURE);
             }
            status = nc_inq_dimid(ncid_L1B,"Lines", &dimidy);
            if (status != NC_NOERR) {
               fprintf(stderr, "-E- Error reading number_of_scans.\n");
               exit(EXIT_FAILURE);
              }
            status = nc_inq_dimid(ncid_L1B,"Pixels", &dimidx);
            if (status != NC_NOERR) {
              fprintf(stderr, "-E- Error reading number_of_pixels per line...\n");
              exit(EXIT_FAILURE);
                }
             status = nc_inq_dimid(ncid_L1B,"Vector_Elements", &dimidv);
            if (status != NC_NOERR) {
              fprintf(stderr, "-E- Error reading vector components...\n");
              exit(EXIT_FAILURE);
                }
            nc_inq_dimlen(ncid_L1B, dimidz, &num_frames);
            nc_inq_dimlen(ncid_L1B, dimidy, &num_scans);
            nc_inq_dimlen(ncid_L1B, dimidx, &num_pixels);
            nc_inq_dimlen(ncid_L1B, dimidv, &vcomp);
 
            l1cfile->nscan=num_scans;
            l1cfile->npix=num_pixels;
            l1cfile->nframes=num_frames;
 
           //check daylight conditions--only checking first scan!! and central pixel!          
          //for HARP ONLY DAYTIME OBSERVATIONS so no need to check zenith angle and day_mode
          //
                    
            if(tcross[i]>0. && tod_id[i]>0)          cout<<"HARP daytime file crossing the equator.."<<endl;
 
            //check first and end line to process based on latmin and latmax ----
            latframe1 = allocate3d_float(num_frames,num_scans, num_pixels);
            lonframe1 = allocate3d_float(num_frames,num_scans, num_pixels);
            latframe2 = allocate3d_float(num_frames,num_scans, num_pixels);
            lonframe2 = allocate3d_float(num_frames,num_scans, num_pixels);
            latframe3 = allocate3d_float(num_frames,num_scans, num_pixels);
            lonframe3 = allocate3d_float(num_frames,num_scans, num_pixels);
 
            //sensor1--0 degrees polariz
            status = nc_inq_grp_ncid(ncid_L1B, "Sensor1", &sen1Grp);
            check_err(status, __LINE__, __FILE__);
            status = nc_inq_varid(sen1Grp, "Latitude", &latId1);//scans x velements
            check_err(status, __LINE__, __FILE__);
            status = nc_get_var_float(sen1Grp, latId1, &latframe1[0][0][0]);
            check_err(status, __LINE__, __FILE__);
            status = nc_inq_varid(sen1Grp, "Longitude", &lonId1);
            check_err(status, __LINE__, __FILE__);
            status = nc_get_var_float(sen1Grp, lonId1, &lonframe1[0][0][0]);
            check_err(status, __LINE__, __FILE__);           
 
 
             //sensor2--45 degrees poilar
            status = nc_inq_grp_ncid(ncid_L1B, "Sensor2", &sen2Grp);
            check_err(status, __LINE__, __FILE__);
            status = nc_inq_varid(sen2Grp, "Latitude", &latId2);//scans x velements
            check_err(status, __LINE__, __FILE__);
            status = nc_get_var_float(sen2Grp, latId2, &latframe2[0][0][0]);
            check_err(status, __LINE__, __FILE__);
            status = nc_inq_varid(sen2Grp, "Longitude", &lonId2);
            check_err(status, __LINE__, __FILE__);
            status = nc_get_var_float(sen2Grp, lonId2, &lonframe2[0][0][0]);
            check_err(status, __LINE__, __FILE__);
 
 
            //sensor3--90 degrees pola
            status = nc_inq_grp_ncid(ncid_L1B, "Sensor3", &sen3Grp);
            check_err(status, __LINE__, __FILE__);
            status = nc_inq_varid(sen3Grp, "Latitude", &latId3);//scans x velements
            check_err(status, __LINE__, __FILE__);
            status = nc_get_var_float(sen3Grp, latId3, &latframe3[0][0][0]);
            check_err(status, __LINE__, __FILE__);
            status = nc_inq_varid(sen3Grp, "Longitude", &lonId3);
            check_err(status, __LINE__, __FILE__);
            status = nc_get_var_float(sen3Grp, lonId3, &lonframe3[0][0][0]);
            check_err(status, __LINE__, __FILE__);
 
 
            //firsr/last line indexes for velocity calculations
            int frame1_s=-1,frame2_s=-1,frame3_s=-1,frame1_n=-1,frame2_n=-1,frame3_n=-1;
            int sline1=-1,sline2=-1,sline3=-1,eline1=-1,eline2=-1,eline3=-1;
 
            for(unsigned int j=0;j<num_frames;j++){
                 for(unsigned int s=0;s<num_scans-1;s++){                
                      if(latframe1[j][s][nadpix]>=lat_s && frame1_s<0){ frame1_s=j,sline1=s;}
                      if(latframe2[j][s][nadpix]>=lat_s && frame2_s<0){ frame2_s=j,sline2=s;}
                      if(latframe3[j][s][nadpix]>=lat_s && frame3_s<0){ frame3_s=j,sline3=s;}
              
                      if(latframe1[j][s][nadpix]<=lat_n && latframe1[j][s+1][nadpix]>latframe1[j][s][nadpix]){ frame1_n=j,eline1=s;}
                      if(latframe2[j][s][nadpix]<=lat_n && latframe2[j][s+1][nadpix]>latframe2[j][s][nadpix]){ frame2_n=j,eline2=s;}
                      if(latframe3[j][s][nadpix]<=lat_n && latframe3[j][s+1][nadpix]>latframe3[j][s][nadpix]){ frame3_n=j,eline3=s;}
            }
         //     cout<<"frame #.."<<j+1<<"latframe1[j][0][nadpix]..."<<latframe1[j][0][nadpix]<<endl;   
            }         
          
            cout<<"frame1s"<<frame1_s<<"frame2s"<<frame2_s<<"frame3s"<<frame3_s<<endl;
            cout<<"frame1n"<<frame1_n<<"frame2n"<<frame2_n<<"frame3n"<<frame3_n<<endl;
            cout<<"sline1"<<sline1<<"sline2"<<sline2<<"sline3"<<sline3<<endl;
            cout<<"eline1"<<eline1<<"eline2"<<eline2<<"eline3"<<eline3<<endl;
        
            //get velocity for those frames/lines and compute mean ground velocity
            
 
            //get the orbit velocity for start/end frame
            ovel = allocate2d_float(num_frames,vcomp);
            status = nc_inq_grp_ncid(ncid_L1B, "NAVIGATION", &navGrp);
            check_err(status, __LINE__, __FILE__);
            status = nc_inq_varid(navGrp, "Orb_Velocity", &ovelId);//scans x velements
            check_err(status, __LINE__, __FILE__);
            status = nc_get_var_float(navGrp, ovelId, &ovel[0][0]);
 
            float sum=0.,vxyz=0.,mov=-1,hsat=676.5;
            int nframes=-1;
            for(int f=frame1_s=0;f<frame1_n;f++){
               vxyz = sqrt(ovel[f][0] * ovel[f][0] + ovel[f][1] * ovel[f][1] + ovel[f][2] * ovel[f][2]);//units m/s 
                        sum = sum + vxyz;
                        nframes=f;  
                    }
 
             mov = (sum /nframes);//mean velocity in m/s (First Fred files OCIS in km/s!!!!!!!!!!!!!!!!!) 
             cout<<"mean velocity in m/s.."<<mov<<endl;
             mgv = mov * Re / (Re + hsat);
             cout<<"mean ground velocity in m/s.."<<mgv<<endl;
             
 
             if(latframe1!=nullptr)
                  delete [](latframe1);             
             if(latframe2!=nullptr)
                  delete [](latframe2);     
             if(latframe3!=nullptr)
                  delete [](latframe3);
             if(lonframe1!=nullptr)
                  delete [](lonframe1);
             if(lonframe2!=nullptr)
                  delete [](lonframe2);
             if(lonframe3!=nullptr)
                  delete [](lonframe3);
             if(ovel!=nullptr)
                 delete [](ovel);
 
            status = nc_close(ncid_L1B);
            check_err(status, __LINE__, __FILE__);
          }//end nfiles loop
 
 
/*
            //make sure the date (year/month.day) is the same for the bunch of files--
            status = nc_inq_attlen(ncid_L1B, NC_GLOBAL, "time_coverage_start", &att_len);
            check_err(status, __LINE__, __FILE__);
            // allocate required space before retrieving values 
            char* time_str = (char*)malloc(att_len + 1); // + 1 for trailing null 
         // get global attribute values 
            status = nc_get_att_text(ncid_L1B, NC_GLOBAL, "time_coverage_start", time_str);
            check_err(status, __LINE__, __FILE__);
            time_str[att_len] = '\0';
            double start_time = isodate2unix(time_str);
            unix2ymds(start_time, &syear, &smon, &sday, &secs);
 
            num_scans = l1cfile->nscan;
            num_pixels = l1cfile->npix;
            lat = allocate2d_float(num_scans, num_pixels);
           if(format.type == FT_SPEXONE){
            status = nc_inq_grp_ncid(ncid_L1B, "GEOLOCATION_DATA", &geoGrp);
            check_err(status, __LINE__, __FILE__);
           }
           else if(format.type == FT_HARP2){
               status = nc_inq_grp_ncid(ncid_L1B, "geolocation_data", &geoGrp);
               check_err(status, __LINE__, __FILE__);
           }
           else{ status = nc_inq_grp_ncid(ncid_L1B, "geolocation_data", &geoGrp);
            check_err(status, __LINE__, __FILE__);
            }
 
 
            status = nc_inq_varid(geoGrp, "latitude", &latId);//scans x velements
            check_err(status, __LINE__, __FILE__);
            status = nc_get_var_float(geoGrp, latId, &lat[0][0]);
            check_err(status, __LINE__, __FILE__);
 
            lat_id[i] = lat[0][nadpix];
 
            //opening solz, solza must be <= 90 for daylight
            solz = allocate2d_short(num_scans, num_pixels);
            status = nc_inq_varid(geoGrp, "solar_zenith", &solzId);//scans x velements
            check_err(status, __LINE__, __FILE__);
            status = nc_get_var_short(geoGrp, solzId, &solz[0][0]);
 
            //check daylight conditions--only checking first scan!! and central pixel!
            float tmp = 0.0;
            tmp = solz[0][nadpix] * 0.01 + 0.0;
            if (tmp > 90.0) {//nightime
                day_mode = 0;
            }
            else {
 
                day_mode = 1;            
              }//daytime
            tod_id[i] = day_mode;
 
            for (unsigned int k = 0;k < num_scans;k++) {
                for (unsigned int j = 0;j < num_pixels;j++) {
                    if (tmp < 0.0) {
                        cout << "Error--negative solz[k][j]..." << tmp << endl;
                        exit(1);                    
                      }   
                }            
            }   
 
            //check north/south boundings
            for (unsigned int k = 0;k < num_scans;k++) {
                for (unsigned int j = 0;j < num_pixels;j++) {
                    //check north/south boundings
                    if (lat[k][j] > l1cfile->latnorth) {
                        lat[k][j] = l1cfile->latnorth;
                        cout << "lat values above 90 degrees..set value to 90" << endl;                    
                      }
                    else if (lat[k][j] < l1cfile->latsouth) {
                        lat[k][j] = l1cfile->latsouth;
                        cout << "lat values below -90 degrees.set value to -90." << endl;                    
                        }                
                  }            
               }  
 
            //loading selected day,month and year-----    
            if (i == 0) {
                selday = l1cinput->selday;
                selmon = l1cinput->selmon;
                selyear = l1cinput->selyear;
                lat1 = lat[0][nadpix];
            }
 
            //MAKE sure the first file is the date WE WANT---init with the first file of the list
            if (i == 0 & selday < 0) {//input selected date manually-----
                selyear = syear;//se is for selected day,month or year
                selmon = smon;
                selday = sday;
                lat1 = lat[0][nadpix];
            }
 
            asc_mode = l1cfile->orb_dir;
            orbdir_id[i] = asc_mode;
 
            if (syear == selyear && smon == selmon && sday == selday) {
                //segment swath based on orbit direction and lat 
                //check if lat between min and max
                //check solar zenith for only daylight granules >90 degrees is nighttime
                //assuming files are ordered by time when creating the initial list
                //we assume only daytime files
                //we compare the nadir pixel
 
                 //ascending or descending  orbit---------
                if (i >= 0 && day_mode == 0) { //nightime--
                    swt++;
                    nite++;
                    swath_id[i] = swt;
                    cout << "nightime file....swath #.." << swt << endl;
                    if (tcross[i] > 0.0) {
                        cout << "nightime eq crossing..for file [" << i << "]" << endl;
                        // break;               
                    }
                }
 
                if (i == 0 && day_mode == 1) { //first file---
                //  selyear=syear;
                //  selmon=smon;
                //  selday=sday;
                    lat1 = lat[0][nadpix];
                    lat2 = lat[num_scans - 1][nadpix];
                    cout << "FIRST filename.." << ptstr << "file number..." << i + 1 << "asc_mode.." << asc_mode << "daymode.." << day_mode << "swt..." << swt << "lat1..." << lat1 << "lat2..." << lat2 << endl;
                    swath_id[i] = swt;
                    lat1 = lat2;
                }
 
                //ascending orbit
                if (i >= 1 && asc_mode == 1 && day_mode == 1)//at least two files to compare
                {
                    lat2 = lat[0][nadpix];
                    if (tod_id[i - 1] == 0) swt++;
                    cout << "filename.." << ptstr << "file number..." << i + 1 << "asc_mode.." << asc_mode << "daymode.." << day_mode << "swt..." << swt << "lat1..." << lat1 << "lat2..." << lat2 << endl;
                    swath_id[i] = swt;
                    if (lat2 < lat1) {
                        lat1 = lat2;
                    }
                }
 
            }//if same day
 
 
           //close file   
            status = nc_close(ncid_L1B);
            check_err(status, __LINE__, __FILE__);
 
            delete[](lat);
            delete[](solz);
        }//end big loop
 
 
        cout << "#nightime swaths..." << nite << "daytime swaths..." << swt - nite << endl;
 
 
        //obtain swath files qith equat crossing-- one swath at the time
        int16_t swtc = 1;
        float vxyz = 0.0, sum = 0.0, mov = 0.0, mgv = 0.0, hsat = 676.5;//Re earth radius in km, hsat sat height above earth surface in km
        size_t num_scans_tot = 0;
        int16_t swtc_id[nswath];
        int16_t swt_id = 0, cross_id = 1;
 
        cout << "nswath..or total (day/night)  crossing swaths..." << nswath << endl;
 
        //find crossing swath ids
        int k = 0;
        for (int i = 0;i < n_files;i++) {
            if (tcross[i] > 0.0 && tod_id[i] == 1) {
                swtc_id[k] = swath_id[i];
                k++;            
           }        
         }  
        ndswaths = k;
 
 
        //dynamic vector to store file_id
        std::vector<int16_t> swt_files, dswaths;
 
        //compute mgv for each swath--(day/night or asc/desc) but always crossing---
        int j = 0, tc = 0;
        int16_t nfiles_swt = 0;
        while (j < nswath) {
            swt_id = swtc_id[j];
            for (int i = 0;i < n_files;i++) {
                if (swt_id == swath_id[i] && tod_id[i] == 1) {
                    swt_files.push_back(i + 1);
                    ect_swtd[tc] = tcross[i];
                    // dswaths.push_back(swt_id);
                    dswaths.push_back(cross_id);
                    ixfile = i;
                    cout << "processing daytime swath with eq cross #...." << swtc << "file #..." << i + 1 << "swath_id.." << swath_id[i] << endl;
                    nfiles_swt++;
 
                    // Open the netcdf4 input file
                    str = l1cfile->ifiles[i];
                    ptstr = str.c_str();
 
                    status = nc_open(ptstr, NC_NOWRITE, &ncid_L1B);
                    if (status != NC_NOERR) {
                    fprintf(stderr, "-E- Error failed nc_open.\n");
                        exit(EXIT_FAILURE);                                
                    }
 
 
                    //allocate velr mem and update #orb records
                    if (format.type == FT_SPEXONE){
                          nscan_str="bins_along_track";
                          status = nc_inq_dimid(ncid_L1B,nscan_str, &dimid);
                        if (status != NC_NOERR) {
                        fprintf(stderr, "-E- Error reading number_of_scans.\n");
                         exit(EXIT_FAILURE);
                          }     
                        }
                    else if (format.type == FT_HARP2){
                         nscan_str="Swath_Lines";
                          status = nc_inq_dimid(ncid_L1B,nscan_str, &dimid);
                       if (status != NC_NOERR) {
                        fprintf(stderr, "-E- Error reading number_of_scans.\n");
                         exit(EXIT_FAILURE);}
                        }
                    else{
                         status = nc_inq_dimid(ncid_L1B, "number_of_scans", &dimid);
                           if (status != NC_NOERR) {
                             fprintf(stderr, "-E- Error reading number_of_scans.\n");
                             exit(EXIT_FAILURE);}
                        }
 
                    nc_inq_dimlen(ncid_L1B, dimid, &num_scans);
                    n_orb_rec = num_scans;
                    velr = allocate2d_float(n_orb_rec, 3);
 
                    status = nc_inq_grp_ncid(ncid_L1B, "navigation_data", &navGrp);
                    check_err(status, __LINE__, __FILE__);
                    status = nc_inq_varid(navGrp, "orb_vel", &ovId);
                    check_err(status, __LINE__, __FILE__);
                    status = nc_get_var_float(navGrp, ovId, &velr[0][0]);
                    check_err(status, __LINE__, __FILE__);
 
                    //compute vx velocity for each scanline or orb_vector---
                    for (unsigned int j = 0;j < num_scans;j++) {
                        vxyz = sqrt(velr[j][0] * velr[j][0] + velr[j][1] * velr[j][1] + velr[j][2] * velr[j][2]);//units m/s 
                        sum = sum + vxyz;
                    }
 
                    num_scans_tot += num_scans;
 
                    tc++;
 
                    status = nc_close(ncid_L1B);
                    check_err(status, __LINE__, __FILE__);
                    delete[](velr);
                }//end if
            }//end for
            cout << "ixfile...last file index of swath" << ixfile << endl;
            tod[swtc - 1] = tod_id[ixfile];//using the last file of the swath
            orbdir[swtc - 1] = orbdir_id[ixfile];
            mov = (sum / num_scans_tot) * 1000;//mean velocity in m/s x 10^3
            mgv = mov * Re / (Re + hsat);
            mgv_swath[swtc - 1] = mgv;
            nfiles_swath[swtc - 1] = nfiles_swt;
            cout << "tod.." << tod[swtc - 1] << "orbdir..." << orbdir[swtc - 1] << "mgv..." << mgv_swath[swtc - 1] << "nfiles per swath.." << nfiles_swt << endl;
            num_scans_tot = 0;
            vxyz = 0.0;
            sum = 0.0;
            j++;
            swtc++;
            nfiles_swt = 0;
            cross_id++;
        }//while end for vel processing
 
 
        nswtfiles = swt_files.size();
        cout << "nfiles day.(#swaths x files/swath).." << nswtfiles << endl;
        cout << "file day crossing id.size.(swaths per day).." << ndswaths << endl;
 
        l1cfile->nswt_files = nswtfiles;
        l1cfile->ndswaths = ndswaths;
 
        k = 0; //day swaths only!! 
        for (std::vector<int16_t>::const_iterator c = swt_files.begin(); c != swt_files.end(); ++c) {
            file_id[k] = *c;
            k++;        
           }
 
        k = 0;
        for (std::vector<int16_t>::const_iterator c = dswaths.begin(); c != dswaths.end(); ++c) {
            swtd_id[k] = *c;
            k++;        
           }  
 
        swt_files.clear();
        dswaths.clear();
*/
        if(tod_id!=nullptr)
          delete [](tod_id);
        if(orbdir_id!=nullptr)  
          delete [](orbdir_id);
        if(swath_id!=nullptr)  
          delete [](swath_id);
        if(lat_id!=nullptr)
          delete[](lat_id);
        return 0;
    }
 
 
int32_t L1C::mov_sd4(l1c_filehandle* l1cfile, L1C_input* l1cinput, double* tcross, int16_t* file_id, int16_t* swtd_id, int16_t* nfiles_swath, double* ect_swtd, int16_t* tod, int16_t* orbdir, float* mgv_swath) {
        int status;
        int32_t n_files, nadpix;
        std::string str;
        const char* ptstr;
        float lat1, lat2;
        int16_t syear, smon, sday, selyear = -1, selmon = -1, selday = -1;
        double secs;
        size_t att_len, swt = 1, nite = 0;
        float* lat_id, ** velr;
        int16_t* swath_id, * tod_id, * orbdir_id;
        int asc_mode, day_mode;//per file--asceding mode: 1 ascending 0 descending, day_mode: 1 day, 0 ys night
        int32_t n_orb_rec;
        int ixfile = 0;
 
        num_scans=l1cfile->nscan;
        num_pixels=l1cfile->npix;
 
        nadpix = l1cfile->nadpix;
        n_files = l1cfile->ifiles.size();
        int16_t nswath = l1cfile->nswath;
 
        swath_id = (int16_t*)calloc(n_files,sizeof(int16_t));
        lat_id = (float*)calloc(n_files,sizeof(float));
        tod_id = (int16_t*)calloc(n_files,sizeof(int16_t));
        orbdir_id = (int16_t*)calloc(n_files,sizeof(int16_t));
 
 
        //big loop
        for (int i = 0;i < n_files;i++) {
            str = l1cfile->ifiles[i];
            ptstr = str.c_str();
            swath_id[i] = 0;
 
            // Open the netcdf4 input file
            status = nc_open(ptstr, NC_NOWRITE, &ncid_L1B);
            if (status != NC_NOERR) {
                fprintf(stderr, "-E- Error failed nc_open.\n");
                        exit(EXIT_FAILURE);
            }
            //make sure the date (year/month.day) is the same for the bunch of files--
            status = nc_inq_attlen(ncid_L1B, NC_GLOBAL, "time_coverage_start", &att_len);
            check_err(status, __LINE__, __FILE__);
            // allocate required space before retrieving values 
            char* time_str = (char*)malloc(att_len + 1); // + 1 for trailing null 
         // get global attribute values 
            status = nc_get_att_text(ncid_L1B, NC_GLOBAL, "time_coverage_start", time_str);
            check_err(status, __LINE__, __FILE__);
        //    time_str[att_len] = '\0';
       //     time_str = "2019-03-21T00:00:00" ;//from Fred OCIS
       //     att_len=19;
            time_str[att_len] = '\0';
      //        :time_coverage_end = "2019-03-21T00:05:00" ; from Fred OCIS
            double start_time = isodate2unix(time_str);
            unix2ymds(start_time, &syear, &smon, &sday, &secs);
 
            syear=2019;
            smon=3;
            sday=21;
 
            lat = allocate2d_float(num_scans, num_pixels);
            status = nc_inq_grp_ncid(ncid_L1B, "GEOLOCATION_DATA", &geoGrp);
            check_err(status, __LINE__, __FILE__);
            status = nc_inq_varid(geoGrp, "latitude", &latId);//scans x velements
            check_err(status, __LINE__, __FILE__);
            status = nc_get_var_float(geoGrp, latId, &lat[0][0]);
            check_err(status, __LINE__, __FILE__);
 
            lat_id[i] = lat[0][nadpix];
 
            //opening solz, solza must be <= 90 for daylight
            solz = allocate2d_short(num_scans, num_pixels);
            status = nc_inq_varid(geoGrp, "solar_zenith", &solzId);//scans x velements
            check_err(status, __LINE__, __FILE__);
            status = nc_get_var_short(geoGrp, solzId, &solz[0][0]);
 
            //check daylight conditions--only checking first scan!! and central pixel!
            float tmp = 0.0;
            tmp = solz[0][nadpix] * 0.01 + 0.0;
            if (tmp > 90.0) {//nightime
                day_mode = 0;
            }
            else {
 
                day_mode = 1;            
              }//daytime
            tod_id[i] = day_mode;
 
            for (unsigned int k = 0;k < num_scans;k++) {
                for (unsigned int j = 0;j < num_pixels;j++) {
                    if (tmp < 0.0) {
                        cout << "Error--negative solz[k][j]..." << tmp << endl;
                        exit(1);                    
                      }   
                }            
            }   
 
            //check north/south boundings
            for (unsigned int k = 0;k < num_scans;k++) {
                for (unsigned int j = 0;j < num_pixels;j++) {
                    //check north/south boundings
                    if (lat[k][j] > l1cfile->latnorth) {
                        lat[k][j] = l1cfile->latnorth;
                        cout << "lat values above 90 degrees..set value to 90" << endl;                    
                      }
                    else if (lat[k][j] < l1cfile->latsouth) {
                        lat[k][j] = l1cfile->latsouth;
                        cout << "lat values below 90 degrees.set value to -90." << endl;                    
                        }                
                  }            
               }  
 
            //loading selected day,month and year-----    
            if (i == 0) {
                selday = l1cinput->selday;
                selmon = l1cinput->selmon;
                selyear = l1cinput->selyear;
                lat1 = lat[0][nadpix];
            }
 
            //MAKE sure the first file is the date WE WANT---init with the first file of the list
            if (i == 0 && selday < 0) {//input selected date manually-----
                selyear = syear;//se is for selected day,month or year
                selmon = smon;
                selday = sday;
                lat1 = lat[0][nadpix];
            }
 
            asc_mode = l1cfile->orb_dir;
            orbdir_id[i] = asc_mode;
            
 
            if (syear == selyear && smon == selmon && sday == selday) {
                //segment swath based on orbit direction and lat 
                //check if lat between min and max
                //check solar zenith for only daylight granules >90 degrees is nighttime
                //assuming files are ordered by time when creating the initial list
                //we assume only daytime files
                //we compare the nadir pixel
 
 
 
                 //ascending or descending  orbit---------
                if (i >= 0 && day_mode == 0) { //nightime--
                    swt++;
                    nite++;
                    swath_id[i] = swt;
                    cout << "nightime file....swath #.." << swt << endl;
                    if (tcross[i] > 0.0) {
                        cout << "nightime eq crossing..for file [" << i << "]" << endl;
                        // break;               
                    }
                }
 
                if (i == 0 && day_mode == 1) { //first file---
                //  selyear=syear;
                //  selmon=smon;
                //  selday=sday;
 
                    lat1 = lat[0][nadpix];
                    lat2 = lat[num_scans - 1][nadpix];
                    cout << "FIRST filename.." << ptstr << "file number..." << i + 1 << "asc_mode.." << asc_mode << "daymode.." << day_mode << "swt..." << swt << "lat1..." << lat1 << "lat2..." << lat2 << endl;
                    swath_id[i] = swt;
                    lat1 = lat2;
                }
 
                //ascending orbit
                if (i >= 1 && asc_mode == 1 && day_mode == 1)//at least two files to compare
                {
                    lat1=lat2;
                    lat2 = lat[0][nadpix];
                    if (tod_id[i - 1] == 0) swt++;
                    cout << "filename.." << ptstr << "file number..." << i + 1 << "asc_mode.." << asc_mode << "daymode.." << day_mode << "swt..." << swt << "lat1..." << lat1 << "lat2..." << lat2 << endl;
                    swath_id[i] = swt;
               //     if (lat2 < lat1) {
               //         lat1 = lat2;
               //     }
                }
 
            }//if same day
            else{  cout<<"ERROR cli date different to image  date..."<<"syear"<<syear<<"smon"<<smon<<"sday"<<sday<<"selyear"<<selyear<<"selmon"<<selmon<<"selday"<<selday<<endl;
                exit(1);}
 
 
           //close file   
            status = nc_close(ncid_L1B);
            check_err(status, __LINE__, __FILE__);
 
            delete[](lat);
            delete[](solz);
        }//end big loop
 
 
        cout << "#nightime swaths..." << nite << "daytime swaths..." << swt - nite << endl;
 
 
        //obtain swath files qith equat crossing-- one swath at the time
        int16_t swtc = 1;
        float mov = 0.0, mgv = 0.0, hsat = 676.5;//Re earth radius in km, hsat sat height above earth surface in km
        size_t num_scans_tot = 0;
        int16_t swtc_id[nswath];
        int16_t swt_id = 0, cross_id = 1;
 
        cout << "nswath..or total (day/night)  crossing swaths..." << nswath << endl;
 
        //find crossing swath ids
        int k = 0;
        for (int i = 0;i < n_files;i++) {
            if (tcross[i] > 0.0 && tod_id[i] == 1) {
                swtc_id[k] = swath_id[i];
                k++;            
           }        
         }  
        ndswaths = k;
 
 
        //dynamic vector to store file_id
        std::vector<int16_t> swt_files, dswaths;
 
        //compute mgv for each swath--(day/night or asc/desc) but always crossing---
        int j = 0, tc = 0;
        int16_t nfiles_swt = 0;
        while (j < nswath) {
            cout<<"computing mean velocity for the swath #..........................................................................................................."<<swtc_id[j]<<endl;
            swt_id = swtc_id[j];
            for (int i = 0;i < n_files;i++) {
                if (swt_id == swath_id[i] && tod_id[i] == 1) {
                    swt_files.push_back(i + 1);
                    ect_swtd[tc] = tcross[i];
                    // dswaths.push_back(swt_id);
                    dswaths.push_back(cross_id);
                    ixfile = i;
                    cout << "processing daytime swath with eq cross #...." << swtc << "file #..." << i + 1 << "swath_id.." << swath_id[i] << endl;
                    nfiles_swt++;
 
                    // Open the netcdf4 input file
                    str = l1cfile->ifiles[i];
                    ptstr = str.c_str();
 
                    status = nc_open(ptstr, NC_NOWRITE, &ncid_L1B);
                    if (status != NC_NOERR) {
                         fprintf(stderr, "-E- failed nc_open.\n");
                        exit(EXIT_FAILURE);
                    }
 
                    //allocate velr mem and update #orb records
                    n_orb_rec = num_scans;
                    velr = allocate2d_float(n_orb_rec, 3);
 
            /*        status = nc_inq_grp_ncid(ncid_L1B, "navigation_data", &navGrp);
                    check_err(status, __LINE__, __FILE__);
                    status = nc_inq_varid(navGrp, "orb_vel", &ovId);
                    check_err(status, __LINE__, __FILE__);
                    status = nc_get_var_float(navGrp, ovId, &velr[0][0]);
                    check_err(status, __LINE__, __FILE__);
 
                    //compute vx velocity for each scanline or orb_vector---
                    for (unsigned int j = 0;j < num_scans;j++) {
                        vxyz = sqrt(velr[j][0] * velr[j][0] + velr[j][1] * velr[j][1] + velr[j][2] * velr[j][2]);//units m/s 
                      //  cout<<"vxyz.."<<vxyz<<endl;
                        sum = sum + vxyz;
                    }
               */
                    num_scans_tot += num_scans;
 
                    tc++;
 
                    status = nc_close(ncid_L1B);
                    check_err(status, __LINE__, __FILE__);
                    delete[](velr);
                }//end if
            }//end for
       //     cout << "ixfile...last file index of swath" << ixfile << endl;
            tod[swtc - 1] = tod_id[ixfile];//using the last file of the swath
            orbdir[swtc - 1] = orbdir_id[ixfile];
            mov=-999.;
       //     mov = (sum / num_scans_tot) * 1000;//mean velocity in m/s x 10^3
            mgv = mov * Re / (Re + hsat);
            mgv_swath[swtc - 1] = mgv;
            nfiles_swath[swtc - 1] = nfiles_swt;
 
//            cout << "tod.." << tod[swtc - 1] << "orbdir..." << orbdir[swtc - 1] << "mgv..." << mgv_swath[swtc - 1] << "nfiles per swath.." << nfiles_swt << endl;
 
            num_scans_tot = 0;
      //      float   vxyz = 0.0;
      //      float   sum = 0.0;
            j++;
            swtc++;
            nfiles_swt = 0;
            cross_id++;
        }//while end for vel processing
 
 
        nswtfiles = swt_files.size();
  //      cout << "nfiles day.(#swaths x files/swath).." << nswtfiles << endl;
 //       cout << "file day crossing id.size.(swaths per day).." << ndswaths << endl;
 
        l1cfile->nswt_files = nswtfiles;
        l1cfile->ndswaths = ndswaths;
 
        k = 0; //day swaths only!! 
        for (std::vector<int16_t>::const_iterator c = swt_files.begin(); c != swt_files.end(); ++c) {
            file_id[k] = *c;
            k++;        
           }
 
        k = 0;
        for (std::vector<int16_t>::const_iterator c = dswaths.begin(); c != dswaths.end(); ++c) {
            swtd_id[k] = *c;
            k++;        
           }  
 
        swt_files.clear();
        dswaths.clear();
 
 
        delete[](tod_id);
        delete[](orbdir_id);
        delete[](swath_id);
        delete[](lat_id);
        return 0;
    }
 
 
 
int32_t L1C::mov_sd2(l1c_filehandle* l1cfile, L1C_input* l1cinput, double* tcross, int16_t* file_id, int16_t* swtd_id, int16_t* nfiles_swath, double* ect_swtd, int16_t* tod, int16_t* orbdir, float* mgv_swath) {
        int dimid, status;
        int32_t n_files, nadpix;
        std::string str;
        const char* ptstr;
        float lat1, lat2;
        int16_t syear, smon, sday, selyear = -1, selmon = -1, selday = -1;
        double secs;
        size_t att_len, swt = 1, nite = 0;
        float* lat_id, ** velr;
        int16_t* swath_id, * tod_id, * orbdir_id;
        int asc_mode, day_mode;//per file--asceding mode: 1 ascending 0 descending, day_mode: 1 day, 0 ys night
        int32_t n_orb_rec;
        int ixfile = 0;
 
 
        nadpix = l1cfile->nadpix;
        n_files = l1cfile->ifiles.size();
        int16_t nswath = l1cfile->nswath;
 
        swath_id = (int16_t*)calloc(n_files,sizeof(int16_t));
        lat_id = (float*)calloc(n_files,sizeof(float));
        tod_id = (int16_t*)calloc(n_files,sizeof(int16_t));
        orbdir_id = (int16_t*)calloc(n_files,sizeof(int16_t));
 
 
        //big loop
        for (int i = 0;i < n_files;i++) {
            str = l1cfile->ifiles[i];
            ptstr = str.c_str();
            swath_id[i] = 0;
 
            // Open the netcdf4 input file
            status = nc_open(ptstr, NC_NOWRITE, &ncid_L1B);
            if (status != NC_NOERR) {
                fprintf(stderr, "-E- Error failed nc_open.\n");
                        exit(EXIT_FAILURE);
            }
            //make sure the date (year/month.day) is the same for the bunch of files--
            status = nc_inq_attlen(ncid_L1B, NC_GLOBAL, "time_coverage_start", &att_len);
            check_err(status, __LINE__, __FILE__);
            // allocate required space before retrieving values 
            char* time_str = (char*)malloc(att_len + 1); // + 1 for trailing null 
         // get global attribute values 
            status = nc_get_att_text(ncid_L1B, NC_GLOBAL, "time_coverage_start", time_str);
            check_err(status, __LINE__, __FILE__);
            time_str[att_len] = '\0';
            double start_time = isodate2unix(time_str);
            unix2ymds(start_time, &syear, &smon, &sday, &secs);
            delete [](time_str);
 
            num_scans = l1cfile->nscan;
            num_pixels = l1cfile->npix;
            lat = allocate2d_float(num_scans, num_pixels);
            status = nc_inq_grp_ncid(ncid_L1B, "geolocation_data", &geoGrp);
            check_err(status, __LINE__, __FILE__);
            status = nc_inq_varid(geoGrp, "latitude", &latId);//scans x velements
            check_err(status, __LINE__, __FILE__);
            status = nc_get_var_float(geoGrp, latId, &lat[0][0]);
            check_err(status, __LINE__, __FILE__);
 
            lat_id[i] = lat[0][nadpix];
 
            //opening solz, solza must be <= 90 for daylight
            solz = allocate2d_short(num_scans, num_pixels);
            status = nc_inq_varid(geoGrp, "solar_zenith", &solzId);//scans x velements
            check_err(status, __LINE__, __FILE__);
            status = nc_get_var_short(geoGrp, solzId, &solz[0][0]);
 
            //check daylight conditions--only checking first scan!! and central pixel!
            float tmp = 0.0;
            tmp = solz[0][nadpix] * 0.01 + 0.0;
            if (tmp > 90.0) {//nightime
                day_mode = 0;
            }
            else {
 
                day_mode = 1;            
              }//daytime
            tod_id[i] = day_mode;
 
            for (unsigned int k = 0;k < num_scans;k++) {
                for (unsigned int j = 0;j < num_pixels;j++) {
                    if (tmp < 0.0) {
                        cout << "Error--negative solz[k][j]..." << tmp << endl;
                        exit(1);                    
                      }   
                }            
            }   
 
            //check north/south boundings
            for (unsigned int k = 0;k < num_scans;k++) {
                for (unsigned int j = 0;j < num_pixels;j++) {
                    //check north/south boundings
                    if (lat[k][j] > l1cfile->latnorth) {
                        lat[k][j] = l1cfile->latnorth;
                        cout << "lat values above 90 degrees..set value to 90" << endl;                    
                      }
                    else if (lat[k][j] < l1cfile->latsouth) {
                        lat[k][j] = l1cfile->latsouth;
                        cout << "lat values below 90 degrees.set value to -90." << endl;                    
                        }                
                  }            
               }  
 
            //loading selected day,month and year-----    
            if (i == 0) {
                selday = l1cinput->selday;
                selmon = l1cinput->selmon;
                selyear = l1cinput->selyear;
                lat1 = lat[0][nadpix];
            }
 
   
  
/*
            //MAKE sure the first file is the date WE WANT---init with the first file of the list
            if (i == 0 & selday < 0) {//input selected date manually-----
                selyear = syear;//se is for selected day,month or year
                selmon = smon;
                selday = sday;
                lat1 = lat[0][nadpix];
            }
*/
            asc_mode = l1cfile->orb_dir;
            orbdir_id[i] = asc_mode;
 
            if (syear == selyear && smon == selmon && sday == selday) {
                //segment swath based on orbit direction and lat 
                //check if lat between min and max
                //check solar zenith for only daylight granules >90 degrees is nighttime
                //assuming files are ordered by time when creating the initial list
                //we assume only daytime files
                //we compare the nadir pixel
 
                 //ascending or descending  orbit---------
                if (i >= 0 && day_mode == 0) { //nightime--
                    swt++;
                    nite++;
                    swath_id[i] = swt;
                    cout << "nightime file....swath #.." << swt << endl;
                    if (tcross[i] > 0.0) {
                        cout << "nightime eq crossing..for file [" << i << "]" << endl;
                        // break;               
                    }
                }
 
                if (i == 0 && day_mode == 1) { //first file---
                //  selyear=syear;
                //  selmon=smon;
                //  selday=sday;
                    lat1 = lat[0][nadpix];
                    lat2 = lat[num_scans - 1][nadpix];
                    cout << "FIRST filename.." << ptstr << "file number..." << i + 1 << "asc_mode.." << asc_mode << "daymode.." << day_mode << "swt..." << swt << "lat1..." << lat1 << "lat2..." << lat2 << endl;
                    swath_id[i] = swt;
                    lat1 = lat2;
                }
 
                //ascending orbit
                if (i >= 1 && asc_mode == 1 && day_mode == 1)//at least two files to compare
                {   lat1=lat2;
                    lat2 = lat[0][nadpix];
                    if (tod_id[i - 1] == 0) swt++;
                    cout << "filename.." << ptstr << "file number..." << i + 1 << "asc_mode.." << asc_mode << "daymode.." << day_mode << "swt..." << swt << "lat1..." << lat1 << "lat2..." << lat2 << endl;
                    swath_id[i] = swt;
            //        if (lat2 < lat1) {
            //            lat1 = lat2;
            //        }
                }
 
            }//if same day
 
 
           //close file   
            status = nc_close(ncid_L1B);
            check_err(status, __LINE__, __FILE__);
 
            delete[](lat);
            delete[](solz);
        }//end big loop
 
 
        cout << "#nightime swaths..." << nite << "daytime swaths..." << swt - nite << endl;
 
 
        //obtain swath files qith equat crossing-- one swath at the time
        int16_t swtc = 1;
        float vxyz = 0.0, sum = 0.0, mov = 0.0, mgv = 0.0, hsat = 676.5;//Re earth radius in km, hsat sat height above earth surface in km
        size_t num_scans_tot = 0;
        int16_t swtc_id[nswath];
        int16_t swt_id = 0, cross_id = 1;
 
        cout << "nswath..or total (day/night)  crossing swaths..." << nswath << endl;
 
        //find crossing swath ids
        int k = 0;
        for (int i = 0;i < n_files;i++) {
            if (tcross[i] > 0.0 && tod_id[i] == 1) {
                swtc_id[k] = swath_id[i];
                k++;            
           }        
         }  
        ndswaths = k;
 
 
        //dynamic vector to store file_id
        std::vector<int16_t> swt_files, dswaths;
 
        //compute mgv for each swath--(day/night or asc/desc) but always crossing---
        int j = 0, tc = 0;
        int16_t nfiles_swt = 0;
        while (j < nswath) {
            cout<<"computing mean velocity for the swath #..........................................................................................................."<<swtc_id[j]<<endl;
            swt_id = swtc_id[j];
            for (int i = 0;i < n_files;i++) {
                if (swt_id == swath_id[i] && tod_id[i] == 1) {
                    swt_files.push_back(i + 1);
                    ect_swtd[tc] = tcross[i];
                    // dswaths.push_back(swt_id);
                    dswaths.push_back(cross_id);
                    ixfile = i;
                    cout << "processing daytime swath with eq cross #...." << swtc << "file #..." << i + 1 << "swath_id.." << swath_id[i] << endl;
                    nfiles_swt++;
 
                    // Open the netcdf4 input file
                    str = l1cfile->ifiles[i];
                    ptstr = str.c_str();
 
                    status = nc_open(ptstr, NC_NOWRITE, &ncid_L1B);
                    if (status != NC_NOERR) {
                         fprintf(stderr, "-E- failed nc_open.\n");
                        exit(EXIT_FAILURE);
                    }
 
                    //allocate velr mem and update #orb records
                    status = nc_inq_dimid(ncid_L1B, "number_of_scans", &dimid);
                    if (status != NC_NOERR) {
                        fprintf(stderr, "-E- Error reading number_of_scans.\n");
                        exit(EXIT_FAILURE);
                    }
 
                    nc_inq_dimlen(ncid_L1B, dimid, &num_scans);
                    n_orb_rec = num_scans;
                    velr = allocate2d_float(n_orb_rec, 3);
 
                    status = nc_inq_grp_ncid(ncid_L1B, "navigation_data", &navGrp);
                    check_err(status, __LINE__, __FILE__);
                    status = nc_inq_varid(navGrp, "orb_vel", &ovId);
                    check_err(status, __LINE__, __FILE__);
                    status = nc_get_var_float(navGrp, ovId, &velr[0][0]);
                    check_err(status, __LINE__, __FILE__);
 
                    //compute vx velocity for each scanline or orb_vector---
                    for (unsigned int j = 0;j < num_scans;j++) {
                        vxyz = sqrt(velr[j][0] * velr[j][0] + velr[j][1] * velr[j][1] + velr[j][2] * velr[j][2]);//units m/s 
                      //  cout<<"vxyz.."<<vxyz<<endl;
                        sum = sum + vxyz;
                    }
 
                    num_scans_tot += num_scans;
 
                    tc++;
 
                    status = nc_close(ncid_L1B);
                    check_err(status, __LINE__, __FILE__);
                    delete[](velr);
                }//end if
            }//end for
       //     cout << "ixfile...last file index of swath" << ixfile << endl;
            tod[swtc - 1] = tod_id[ixfile];//using the last file of the swath
            orbdir[swtc - 1] = orbdir_id[ixfile];
            mov = (sum / num_scans_tot) * 1000;//mean velocity in m/s x 10^3
            mgv = mov * Re / (Re + hsat);
            mgv_swath[swtc - 1] = mgv;
            nfiles_swath[swtc - 1] = nfiles_swt;
 
//            cout << "tod.." << tod[swtc - 1] << "orbdir..." << orbdir[swtc - 1] << "mgv..." << mgv_swath[swtc - 1] << "nfiles per swath.." << nfiles_swt << endl;
 
            num_scans_tot = 0;
            vxyz = 0.0;
            sum = 0.0;
            j++;
            swtc++;
            nfiles_swt = 0;
            cross_id++;
        }//while end for vel processing
 
 
        nswtfiles = swt_files.size();
  //      cout << "nfiles day.(#swaths x files/swath).." << nswtfiles << endl;
 //       cout << "file day crossing id.size.(swaths per day).." << ndswaths << endl;
 
        l1cfile->nswt_files = nswtfiles;
        l1cfile->ndswaths = ndswaths;
 
        k = 0; //day swaths only!! 
        for (std::vector<int16_t>::const_iterator c = swt_files.begin(); c != swt_files.end(); ++c) {
            file_id[k] = *c;
            k++;        
           }
 
        k = 0;
        for (std::vector<int16_t>::const_iterator c = dswaths.begin(); c != dswaths.end(); ++c) {
            swtd_id[k] = *c;
            k++;        
           }  
 
        swt_files.clear();
        dswaths.clear();
 
 
        delete[](tod_id);
        delete[](orbdir_id);
        delete[](swath_id);
        delete[](lat_id);
 
        return 0;
    }
 
 
 
int32_t L1C::ect_sf2(const char* filename, L1C_input* l1cinput,l1c_filehandle* l1cfile) { //ect version for single file
        int dimid,dimidz,dimidx,dimidy,status,sen1Grp,blueGrp,v1Grp,dimidv;
        int asc_mode = 0, scan_brack[2] = { -1,-1 };
        float lat1, lat2, lon1, lon2;//lat,lon defined globally
        float ***latframe=nullptr,***lonframe=nullptr;;
        double t1 = -1, t2 = -1;
        double tcross,secs;
        float loncross;
        std::string  ifile_str;
        char* ifile_char;
        const char *nscan_str,*npix_str;
        double *stime=nullptr;
        int16_t syear, smon, sday, selyear = -1, selmon = -1, selday = -1;
        size_t att_len;
 
        l1cfile->l1b_name = filename;
        selday = l1cinput->selday;
        selmon = l1cinput->selmon;
        selyear = l1cinput->selyear;
 
 
        l1cfile->l1b_name = filename;
 
        // Open the netcdf4 input file
        status = nc_open(filename, NC_NOWRITE, &ncid_L1B);
 
        if (status != NC_NOERR) {
            fprintf(stderr, "-E- Error failed nc_open...\n");
            exit(EXIT_FAILURE);
        }
 
        //Open dimensions
        // num_scans
       ifile_str = l1cinput->files[0];
       ifile_char = &ifile_str[0];
       file_format format = getFormat(ifile_char);
 
       format.type=l1cfile->format;
       cout<<"format type..in ect_sf2"<<format.type<<endl;
 
 
        //checking input date
       status = nc_inq_attlen(ncid_L1B, NC_GLOBAL, "time_coverage_start", &att_len);
            check_err(status, __LINE__, __FILE__);
            // allocate required space before retrieving values
            char* time_str = (char*)malloc(att_len + 1); // + 1 for trailing null
         // get global attribute values
            status = nc_get_att_text(ncid_L1B, NC_GLOBAL, "time_coverage_start", time_str);
            check_err(status, __LINE__, __FILE__);
            time_str[att_len] = '\0';
            double start_time = isodate2unix(time_str);
            unix2ymds(start_time, &syear, &smon, &sday, &secs);
 
       if (syear == selyear && smon == selmon && sday == selday) {
          cout<<"computing equatorial crossing time...............................................................for file."<<filename<<endl;
       }
       else{
         cout<<"input date does not match year.."<<syear<<"month.."<<smon<<"day.."<<sday<<" extracted from the l1b file....."<<endl;
         exit(1);
       }
 
//*******legacy sensors including OCI **************
      if (format.type != FT_SPEXONE && format.type != FT_HARP2 && format.type != FT_HARP){
        cout<<"reading num scan for legacy sensors"<<endl;  
        status = nc_inq_dimid(ncid_L1B, "number_of_scans", &dimid);
        if (status != NC_NOERR) {
            fprintf(stderr, "-E- Error reading number_of_scans.\n");
            exit(EXIT_FAILURE);
        }
        nc_inq_dimlen(ncid_L1B, dimid, &num_scans);
 
        //across-track bins
        status = nc_inq_dimid(ncid_L1B, "ccd_pixels", &dimid);
        if (status != NC_NOERR) {
            fprintf(stderr, "-E- Error reading number_of_pixels per line...\n");
            exit(EXIT_FAILURE);
        }
        nc_inq_dimlen(ncid_L1B, dimid, &num_pixels);
 
        }
 
// *********** SPEXONE **************************
       if (format.type == FT_SPEXONE){
          cout<<"Processing SPEXone equat crossing time......"<<endl;
 
          nscan_str="bins_along_track";
          npix_str="spatial_samples_per_image";
          status = nc_inq_dimid(ncid_L1B,nscan_str, &dimidy);
        if (status != NC_NOERR) {
            fprintf(stderr, "-E- Error reading number_of_scans.\n");
            exit(EXIT_FAILURE);           
            }
           status = nc_inq_dimid(ncid_L1B,npix_str, &dimidx);
        if (status != NC_NOERR) {
            fprintf(stderr, "-E- Error reading number_of_pixels per line...\n");
            exit(EXIT_FAILURE);
           }
          nc_inq_dimlen(ncid_L1B, dimidy, &num_scans);
          nc_inq_dimlen(ncid_L1B, dimidx, &num_pixels);
         } 
 
 //********** HARP2 ***************************      
       if (format.type == FT_HARP2){
         status = nc_inq_dimid(ncid_L1B,"Frames", &dimidz);
       if (status != NC_NOERR) {
            fprintf(stderr, "-E- Error reading number_of frames.\n");
            exit(EXIT_FAILURE);
          }  
         status = nc_inq_dimid(ncid_L1B,"Lines", &dimidy);
       if (status != NC_NOERR) {
            fprintf(stderr, "-E- Error reading number_of_scans.\n");
            exit(EXIT_FAILURE);
          }
         status = nc_inq_dimid(ncid_L1B,"Pixels", &dimidx);
       if (status != NC_NOERR) {
            fprintf(stderr, "-E- Error reading number_of_pixels per line...\n");
            exit(EXIT_FAILURE);
          }
         nc_inq_dimlen(ncid_L1B, dimidz, &num_frames);
         nc_inq_dimlen(ncid_L1B, dimidy, &num_scans);
         nc_inq_dimlen(ncid_L1B, dimidx, &num_pixels);
        }
 
 //********** HARP ***************************      
       if (format.type == FT_HARP){
         status = nc_inq_grp_ncid(ncid_L1B, "blue", &blueGrp);
       if (status != NC_NOERR) {
            fprintf(stderr, "-E- Error reading group blue.\n");
            exit(EXIT_FAILURE);
          }
         status = nc_inq_dimid(blueGrp,"Views", &dimidv);
       if (status != NC_NOERR) {
            fprintf(stderr, "-E- Error reading dimensions number_of views.\n");
            exit(EXIT_FAILURE);
          }
       //reading subgroup view1
          status = nc_inq_grp_ncid(blueGrp, "View01", &v1Grp);
       if (status != NC_NOERR) {
            fprintf(stderr, "-E- Error reading subgroup view 1 --blue.\n");
            exit(EXIT_FAILURE);
          }
   //lines and pixels    
          status = nc_inq_dimid(v1Grp,"Swath_Pixels", &dimidx);
       if (status != NC_NOERR) {
            fprintf(stderr, "-E- Error reading # pixel dimensions view01.\n");
            exit(EXIT_FAILURE);
          }
         status = nc_inq_dimid(v1Grp,"Swath_Lines", &dimidy);
       if (status != NC_NOERR) {
            fprintf(stderr, "-E- Error reading # lines dimensions view01.\n");
            exit(EXIT_FAILURE);
          }
         nc_inq_dimlen(ncid_L1B, dimidv, &nviews);
         nc_inq_dimlen(ncid_L1B, dimidy, &num_scans);
         nc_inq_dimlen(ncid_L1B, dimidx, &num_pixels);
        }
 
 
 
        l1cfile->nscan = num_scans;
        l1cfile->npix = num_pixels;
 
  //time line and geolocation attributes------     
  //************************************************************
  //
       if(format.type == FT_SPEXONE){
        stime = new double[num_scans]();    
        lat = allocate2d_float(num_scans, num_pixels);
        lon = allocate2d_float(num_scans, num_pixels);              
        status = nc_inq_grp_ncid(ncid_L1B, "BIN_ATTRIBUTES", &scGrp);
        check_err(status, __LINE__, __FILE__);
        status = nc_inq_varid(scGrp, "image_time", &otId);
        check_err(status, __LINE__, __FILE__);
        status = nc_get_var_double(scGrp, otId, stime);
        check_err(status, __LINE__, __FILE__);
        lat = allocate2d_float(num_scans, num_pixels);
        lon = allocate2d_float(num_scans, num_pixels);
        status = nc_inq_grp_ncid(ncid_L1B, "GEOLOCATION_DATA", &navGrp);
        check_err(status, __LINE__, __FILE__);
        status = nc_inq_varid(navGrp, "latitude", &latId);//scans x velements
        check_err(status, __LINE__, __FILE__);
        status = nc_get_var_float(navGrp, latId, &lat[0][0]);
        check_err(status, __LINE__, __FILE__);
        status = nc_inq_varid(navGrp, "longitude", &lonId);
        check_err(status, __LINE__, __FILE__);
        status = nc_get_var_float(navGrp, lonId, &lon[0][0]);
        check_err(status, __LINE__, __FILE__);
        }
       else if(format.type == FT_HARP2){
        stime = new double[num_frames]();  
        status = nc_inq_grp_ncid(ncid_L1B, "NAVIGATION", &scGrp);
        check_err(status, __LINE__, __FILE__);
        status = nc_inq_varid(scGrp, "msec", &otId);
        check_err(status, __LINE__, __FILE__);
        status = nc_get_var_double(scGrp, otId, stime);
        check_err(status, __LINE__, __FILE__); 
        latframe = allocate3d_float(num_frames,num_scans, num_pixels);
        lonframe = allocate3d_float(num_frames,num_scans, num_pixels);   
        status = nc_inq_grp_ncid(ncid_L1B, "Sensor1", &sen1Grp);
        check_err(status, __LINE__, __FILE__);
        status = nc_inq_varid(sen1Grp, "Latitude", &latId);//scans x velements
        check_err(status, __LINE__, __FILE__);
        status = nc_get_var_float(sen1Grp, latId, &latframe[0][0][0]);
        check_err(status, __LINE__, __FILE__);
        status = nc_inq_varid(sen1Grp, "Longitude", &lonId);
        check_err(status, __LINE__, __FILE__);
        status = nc_get_var_float(sen1Grp, lonId, &lonframe[0][0][0]);
        check_err(status, __LINE__, __FILE__);
       }
        else if(format.type == FT_HARP){
         cout<<"checking lat/lon arrays...HARP.."<<endl;   
        stime = new double[num_scans]();
        lat = allocate2d_float(num_scans, num_pixels);
        lon = allocate2d_float(num_scans, num_pixels);
   /*     stime = new double[num_frames]();
        status = nc_inq_grp_ncid(ncid_L1B, "NAVIGATION", &scGrp);
        check_err(status, __LINE__, __FILE__);
        status = nc_inq_varid(scGrp, "msec", &otId);
        check_err(status, __LINE__, __FILE__);
        status = nc_get_var_double(scGrp, otId, stime);
        check_err(status, __LINE__, __FILE__);
        latframe = allocate3d_float(num_frames,num_scans, num_pixels);
        lonframe = allocate3d_float(num_frames,num_scans, num_pixels);
        status = nc_inq_grp_ncid(ncid_L1B, "Sensor1", &sen1Grp);
        check_err(status, __LINE__, __FILE__);
 
        status = nc_inq_varid(sen1Grp, "Latitude", &latId);//scans x velements
        check_err(status, __LINE__, __FILE__);
        status = nc_get_var_float(sen1Grp, latId, &latframe[0][0][0]);
        check_err(status, __LINE__, __FILE__);
        status = nc_inq_varid(sen1Grp, "Longitude", &lonId);
        check_err(status, __LINE__, __FILE__);
        status = nc_get_var_float(sen1Grp, lonId, &lonframe[0][0][0]);
        check_err(status, __LINE__, __FILE__);
        */
       }
       else{ //legacy sensors including OCI
        stime = new double[num_scans]();   
        status = nc_inq_grp_ncid(ncid_L1B, "scan_line_attributes", &scGrp);
        check_err(status, __LINE__, __FILE__);
        status = nc_inq_varid(scGrp, "time", &otId);
        check_err(status, __LINE__, __FILE__);
        status = nc_get_var_double(scGrp, otId, stime);
        check_err(status, __LINE__, __FILE__); 
        lat = allocate2d_float(num_scans, num_pixels);
        lon = allocate2d_float(num_scans, num_pixels);   
        status = nc_inq_grp_ncid(ncid_L1B, "geolocation_data", &navGrp);
        check_err(status, __LINE__, __FILE__);         
        status = nc_inq_varid(navGrp, "latitude", &latId);//scans x velements
        check_err(status, __LINE__, __FILE__);
        status = nc_get_var_float(navGrp, latId, &lat[0][0]);
        check_err(status, __LINE__, __FILE__);
        status = nc_inq_varid(navGrp, "longitude", &lonId);
        check_err(status, __LINE__, __FILE__);
        status = nc_get_var_float(navGrp, lonId, &lon[0][0]);
        check_err(status, __LINE__, __FILE__);
        }
 
        //find scans bracketing equator
        int nad_pix = floor(num_pixels / 2) + 1;
        int timeix=0;
        nad_pix = nad_pix - 1;
        l1cfile->nadpix = nad_pix;
 
       if(format.type == FT_HARP2 | format.type == FT_HARP){
        if (latframe[0][0][nad_pix] > latframe[0][1][nad_pix])
            asc_mode = 0;//descending
        else
            asc_mode = 1;//ascending
           }
        else{//OCIS/SPEXONE
         if (lat[0][nad_pix] > lat[1][nad_pix])
            asc_mode = 0;//descending
         else
            asc_mode = 1;//ascending
           }    
 
 
        l1cfile->orb_dir = asc_mode;
 
//HARP2-----------
     if(format.type == FT_HARP2 | format.type == FT_HARP){
        for (unsigned k = 0;k < num_frames;k++) {
         for (unsigned i = 0;i < num_scans - 1;i++) { //improve with binary search
            if (asc_mode == 1 && latframe[k][i][nad_pix] < 0. && latframe[k][i + 1][nad_pix]>0.) {
                scan_brack[0] = i + 1;
                scan_brack[1] = i + 2;
                lat1 = latframe[k][i][nad_pix];
                lat2 = latframe[k][i + 1][nad_pix];
                lon1 = lonframe[k][i][nad_pix];
                lon2 = lonframe[k][i + 1][nad_pix];
                timeix=k;
                i=num_scans;
                k=num_frames;
                break;
            }
 
            else if (asc_mode == 0 && latframe[k][i][nad_pix] > 0. && latframe[k][i + 1][nad_pix] < 0) { //descending orbit
                scan_brack[0] = i + 2;//negative lat first convention
                scan_brack[1] = i + 1;
                lat1 = latframe[k][i + 1][nad_pix];
                lat2 = latframe[k][i][nad_pix];
                lon1 = lonframe[k][i + 1][nad_pix];
                lon2 = lonframe[k][i][nad_pix];
                timeix=k;
                i=num_scans;
                k=num_frames;
                break;
            }
           } }//end for
         }
     else{
 
//OCIS/SPEXONE--------    
        for (unsigned i = 0;i < num_scans - 1;i++) { //improve with binary search
            if (asc_mode == 1 && lat[i][nad_pix] < 0. && lat[i + 1][nad_pix]>0.) {                
                scan_brack[0] = i + 1;
                scan_brack[1] = i + 2;
                lat1 = lat[i][nad_pix];
                lat2 = lat[i + 1][nad_pix];
                lon1 = lon[i][nad_pix];
                lon2 = lon[i + 1][nad_pix];
                timeix=i;
                i=num_scans;       
                break;            
            }
 
            else if (asc_mode == 0 && lat[i][nad_pix] > 0. && lat[i + 1][nad_pix] < 0) { //descending orbit
                scan_brack[0] = i + 2;//negative lat first convention
                scan_brack[1] = i + 1;
                lat1 = lat[i + 1][nad_pix];
                lat2 = lat[i][nad_pix];
                lon1 = lon[i + 1][nad_pix];
                lon2 = lon[i][nad_pix];
                timeix=i;
                i=num_scans;
                break;            
            }     
           } //end for
          }
 
 
        if (scan_brack[0] > -1) {//if file with equat crossing
            t1 = stime[timeix];
            t2 = stime[timeix + 1];
            //interpolate time--linear--this can be improved using Harversine!!
            tcross = t1 - lat1 * (t2 - t1) / (lat2 - lat1);//equat crossing time
            float dtcross = (tcross - t1) / (t2 - t1);
            loncross = lon1 + (lon2 - lon1) * dtcross;//latcross is zero
            l1cfile->eqt = tcross;
            l1cfile->orbit_node_lon = loncross;
 
            cout<<"tcross..in ect_sf2.."<<tcross<<endl;
        }
        else {
            l1cfile->eqt = -999.0;
            l1cfile->orbit_node_lon = -999.0;
        }
 
        status = nc_close(ncid_L1B);
        check_err(status, __LINE__, __FILE__);
 
        delete [](time_str);
        delete [](stime);
        delete [](lat);
        delete [](lon);
        delete [](latframe);
        delete [](lonframe);
 
        return status;
    }
 
 
 
 
int32_t L1C::ect_sf(const char* filename, l1c_filehandle* l1cfile,L1C_input* l1cinput) { //ect version for single file
        int dimid,  status;
        int asc_mode = 0, scan_brack[2] = { -1,-1 };
        float lat1, lat2, lon1, lon2;//lat,lon defined globally
        double t1 = -1, t2 = -1;
        double tcross,secs;
        float loncross;
        int tindex;
        float **lat=nullptr,**lon=nullptr; 
        int16_t syear, smon, sday, selyear = -1, selmon = -1, selday = -1;
        size_t att_len;
 
        l1cfile->l1b_name = filename;
        selday = l1cinput->selday;
        selmon = l1cinput->selmon;
        selyear = l1cinput->selyear;
 
 
 
        // Open the netcdf4 input file
        status = nc_open(filename, NC_NOWRITE, &ncid_L1B);
 
        if (status != NC_NOERR) {
            fprintf(stderr, "-E- %s line %d: nc_open(%s) failed.\n",
                __FILE__, __LINE__, filename);
            return (1);
        }
 
       //checking input date
       status = nc_inq_attlen(ncid_L1B, NC_GLOBAL, "time_coverage_start", &att_len);
            check_err(status, __LINE__, __FILE__);
            // allocate required space before retrieving values
            char* time_str = (char*)malloc(att_len + 1); // + 1 for trailing null
         // get global attribute values
            status = nc_get_att_text(ncid_L1B, NC_GLOBAL, "time_coverage_start", time_str);
            check_err(status, __LINE__, __FILE__);
            time_str[att_len] = '\0';
            double start_time = isodate2unix(time_str);
            unix2ymds(start_time, &syear, &smon, &sday, &secs);
      
       if (syear == selyear && smon == selmon && sday == selday) { 
          cout<<"computing equatorial crossing time...............................................................for file."<<filename<<endl;
       }
       else{
         cout<<"input date does not match year.."<<syear<<"month.."<<smon<<"day.."<<sday<<" extracted from the l1b file....."<<endl;  
         exit(1);
       }    
       
        status = nc_inq_dimid(ncid_L1B, "number_of_scans", &dimid);
        if (status != NC_NOERR) {
            fprintf(stderr, "-E- Error reading number_of_scans.\n");
            exit(EXIT_FAILURE);
        }
        nc_inq_dimlen(ncid_L1B, dimid, &num_scans);
 
        //across-track bins
        status = nc_inq_dimid(ncid_L1B, "ccd_pixels", &dimid);
        if (status != NC_NOERR) {
            fprintf(stderr, "-E- Error reading number_of_pixels per line...\n");
            exit(EXIT_FAILURE);
        }
        nc_inq_dimlen(ncid_L1B, dimid, &num_pixels);
 
        l1cfile->nscan = num_scans;
        l1cfile->npix = num_pixels;
 
        lat = allocate2d_float(num_scans, num_pixels);
        lon = allocate2d_float(num_scans, num_pixels);
 
        status = nc_inq_grp_ncid(ncid_L1B, "geolocation_data", &navGrp);
        check_err(status, __LINE__, __FILE__);
 
        status = nc_inq_varid(navGrp, "latitude", &latId);//scans x velements
        check_err(status, __LINE__, __FILE__);
        status = nc_get_var_float(navGrp, latId, &lat[0][0]);
        check_err(status, __LINE__, __FILE__);
 
        status = nc_inq_varid(navGrp, "longitude", &lonId);
        check_err(status, __LINE__, __FILE__);
        status = nc_get_var_float(navGrp, lonId, &lon[0][0]);
        check_err(status, __LINE__, __FILE__);
 
        //find scans bracketing equator
        int nad_pix = floor(num_pixels / 2) + 1;
        nad_pix = nad_pix - 1;
        l1cfile->nadpix = nad_pix;
 
        if (lat[0][nad_pix] > lat[1][nad_pix])
            asc_mode = 0;//descending
        else
            asc_mode = 1;//ascending
 
        l1cfile->orb_dir = asc_mode;
 
        for (unsigned i = 0;i < num_scans - 1;i++) { //improve with binary search
            if (asc_mode == 1 && lat[i][nad_pix] < 0. && lat[i + 1][nad_pix]>0.) {
                scan_brack[0] = i + 1;
                scan_brack[1] = i + 2;
                lat1 = lat[i][nad_pix];
                lat2 = lat[i + 1][nad_pix];
                lon1 = lon[i][nad_pix];
                lon2 = lon[i + 1][nad_pix];
                tindex=i;
                i=num_scans;
                break;            
           }
 
            else if (asc_mode == 0 && lat[i][nad_pix] > 0. && lat[i + 1][nad_pix] < 0) { //descending orbit
                scan_brack[0] = i + 2;//negative lat first convention
                scan_brack[1] = i + 1;
                lat1 = lat[i + 1][nad_pix];
                lat2 = lat[i][nad_pix];
                lon1 = lon[i + 1][nad_pix];
                lon2 = lon[i][nad_pix];
                tindex=i;
                i=num_scans;
                break;            
              }
        } //end for
 
    //************************************************************************************
       //obtain time for lower and upper scan--
       //open scan_time (in Fred L1B file is orb_time interpolated)
        double* stime = new double[num_scans]();
        status = nc_inq_grp_ncid(ncid_L1B, "scan_line_attributes", &scGrp);
        check_err(status, __LINE__, __FILE__);
 
        status = nc_inq_varid(scGrp, "time", &otId);
        check_err(status, __LINE__, __FILE__);
        status = nc_get_var_double(scGrp, otId, stime);
        check_err(status, __LINE__, __FILE__);
 
        if (scan_brack[0] > -1) {//if file with equat crossing
            t1 = stime[tindex];
            t2 = stime[tindex + 1];
            //interpolate time--linear--this can be improved using Harversine!!
            tcross = t1 - lat1 * (t2 - t1) / (lat2 - lat1);//equat crossing time
            float dtcross = (tcross - t1) / (t2 - t1);
            loncross = lon1 + (lon2 - lon1) * dtcross;//latcross is zero
 
            l1cfile->eqt = tcross;
            l1cfile->orbit_node_lon = loncross;
            l1cfile->orb_dir = asc_mode;
        }
        else {
 
            l1cfile->eqt = -999.0;
            l1cfile->orbit_node_lon = -999.0;
            l1cfile->orb_dir = asc_mode;
        }
 
        status = nc_close(ncid_L1B);
        check_err(status, __LINE__, __FILE__);
 
        delete[](stime);
        delete[](lat);
        delete[](lon);
        delete [] (time_str);
 
 
        return status;
    }
 
 
 
 
 
 
 
int32_t L1C::ect(l1c_filehandle* l1cfile) {
        int dimid, status;
        int32_t n_files;
        std::string str;
        const char* ptstr;
        int asc_mode, scan_brack[2];
        float lat1, lat2, lon1, lon2;
        double t1, t2;
        n_files = l1cfile->ifiles.size();
 
        //big loop
        for (int i = 0;i < n_files;i++) {
            str = l1cfile->ifiles[i];
            ptstr = str.c_str();
 
            // Open the netcdf4 input file
            cout << "Opening L1B file..." << l1cfile->ifiles[i] << endl;
            status = nc_open(ptstr, NC_NOWRITE, &ncid_L1B);
 
            if (status != NC_NOERR) {
               fprintf(stderr, "-E- Error reading the file.\n");
                exit(EXIT_FAILURE);              
            }
 
            //Open dimensions
            // num_scans
            status = nc_inq_dimid(ncid_L1B, "number_of_scans", &dimid);
            if (status != NC_NOERR) {
                fprintf(stderr, "-E- Error reading number_of_scans.\n");
                exit(EXIT_FAILURE);
            }
            nc_inq_dimlen(ncid_L1B, dimid, &num_scans);
            printf("number_of_scans.....%zu\n", num_scans);
 
            //across-track bins
            status = nc_inq_dimid(ncid_L1B, "ccd_pixels", &dimid);
            if (status != NC_NOERR) {
                fprintf(stderr, "-E- Error reading number_of_pixels per line...\n");
                exit(EXIT_FAILURE);
            }
            nc_inq_dimlen(ncid_L1B, dimid, &num_pixels);
            printf("number_of_pixels.....%zu\n", num_pixels);
 
            lat = allocate2d_float(num_scans, num_pixels);
            lon = allocate2d_float(num_scans, num_pixels);
 
            status = nc_inq_grp_ncid(ncid_L1B, "geolocation_data", &navGrp);
            check_err(status, __LINE__, __FILE__);
 
            status = nc_inq_varid(navGrp, "latitude", &latId);//scans x velements
            check_err(status, __LINE__, __FILE__);
            status = nc_get_var_float(navGrp, latId, &lat[0][0]);
            check_err(status, __LINE__, __FILE__);
 
            status = nc_inq_varid(navGrp, "longitude", &lonId);
            check_err(status, __LINE__, __FILE__);
            status = nc_get_var_float(navGrp, lonId, &lon[0][0]);
            check_err(status, __LINE__, __FILE__);
 
            //obtain time for lower and upper scan--
           //open scan_time (in Fred L1B file is orb_time interpolated)
            double* stime = new double[num_scans]();
            status = nc_inq_grp_ncid(ncid_L1B, "scan_line_attributes", &scGrp);
            check_err(status, __LINE__, __FILE__);
 
            status = nc_inq_varid(scGrp, "time", &otId);
            check_err(status, __LINE__, __FILE__);
            status = nc_get_var_double(scGrp, otId, stime);
            check_err(status, __LINE__, __FILE__);
 
            //find scans bracketing equator
            int nad_pix = floor(num_pixels / 2) + 1;
 
            //also in global attribute startDirection endDirection
            if (lat[0][nad_pix] > lat[1][nad_pix])
                asc_mode = 0;//descending
            else
                asc_mode = 1;//ascending
 
            for (unsigned int i = 0;i < num_scans - 1;i++) { //improve with binary search
                if (asc_mode == 1 && lat[i][nad_pix] < 0. && lat[i + 1][nad_pix]>0.) {
                    scan_brack[0] = i + 1;
                    scan_brack[1] = i + 2;
                    lat1 = lat[i][nad_pix - 1];
                    lat2 = lat[i + 1][nad_pix - 1];
                    lon1 = lon[i][nad_pix - 1];
                    lon2 = lon[i + 1][nad_pix - 1];
                    t1 = stime[i];
                    t2 = stime[i + 1];
 
                    cout << "lower_scan.." << scan_brack[0] << "upper_scan.." << scan_brack[1] << endl;
                    cout << "lower_lat.." << lat[i][nad_pix - 1] << "upper_lat.." << lat[i + 1][nad_pix - 1] << endl;
                    break;                
}
                else if (asc_mode == 0 && lat[i][nad_pix] > 0. && lat[i + 1][nad_pix] < 0) { //descending orbit
                    scan_brack[0] = i + 2;
                    scan_brack[1] = i + 1;
                    lat1 = lat[i + 1][nad_pix - 1];
                    lat2 = lat[i][nad_pix - 1];
                    lon1 = lon[i + 1][nad_pix - 1];
                    lon2 = lon[i][nad_pix - 1];
                    t1 = stime[i];
                    t2 = stime[i + 1];
                    break;                
}
            }
 
            //interpolate time--linear
            float tcross = t1 - lat1 * (t2 - t1) / (lat2 - lat1);//equat crossing time
            float dtcross = (tcross - t1) / (t2 - t1);
            float loncross = lon1 + (lon2 - lon1) * dtcross;//latcross is zero
            cout << "tcross...." << tcross << "loncross..." << loncross << endl;
 
 
            cout << "Closing L1B file..." << l1cfile->ifiles[i] << endl;
            status = nc_close(ncid_L1B);
            check_err(status, __LINE__, __FILE__);
 
            delete[](stime);
            delete[](lat);
            delete[](lon);
 
        }//end big loop
 
 
        return 0;
    }
 
 
 
 
 
 
 
 
    //this version includes info coming from Don open file routines--
 
    int32_t L1C::load_l1c_filehandle4(l1c_filehandle* l1cfile, L1C_input* l1cinput) {
        int nfiles;
        string filename;
        //  printf("Loading filehandle with L1B input sensor info\n");
 
      //    openl1b_ocis(file);
 
 
       //   file_format format = getFormat(file->name);
 
          //if (format.type == FT_INVALID) {
 
      //    l1cfile->l1b_name=file->name;
 
        nfiles = l1cinput->files.size();
        //    cout<<"number of files to be processed.."<<nfiles<<endl;
        for (int j = 0;j < nfiles;j++) {
            // cout<<l1cinput->files[j]<<endl;
            filename = l1cinput->files[j];
            l1cfile->ifiles.push_back(filename);
            //     cout<<l1cfile->ifiles[j]<<endl;
        }
 
 
        //these are going to be default values and not coming actually from opening the files--
    /*    l1cfile->sd_id=file->sd_id;
        l1cfile->format=file->format;
        l1cfile->mode=file->mode;
        l1cfile->length=file->length;
        l1cfile->sensorID=file->sensorID;
        l1cfile->subsensorID=file->subsensorID;
    */
 
    //    cout<<"file->sd_id.."<<file->sd_id<<"file->format.."<<file->format<<"file->mode.."<<file->mode<<"file->length.."<<file->length<<"file->sensorID.."<<file->sensorID<<"file->subsensorID.."<<file->subsensorID<<endl;
    //    exit(1);
 
 
        //res_spat;//nc file? or input str
        //res_spec=-999.0;;//nc file?
 
        //time-space limits of image
        //syear=0;//from nc
        //sday=0;//nc
        //minlat_img=-999.0;//from nc
        //maxlat_img=-999.0;
        //minlon_img=-999.0;
        //maxlon_img=-999.0;
 
        //dimensions--
    /*    l1cfile->ndets=file->ndets;
        l1cfile->nscan=file->nscan;
        //n_views=1;//sensor views //nc
        //npols=1; //polarization states //nc
        l1cfile->nbands=file->nbands;//number of total bands //nc
        l1cfile->nband_blue=file->nbands_b;//nc file--this includes uv + visible bands//nc
        l1cfile->nband_red=file->nbands_r;//nc--this includes nir + visible bands
        l1cfile->nband_swir=file->nbands_swir;//nc--
        l1cfile->npix=file->npix;
    */
 
    //    cout<<"file->name"<<file->name<<"file->sd_id"<<file->sd_id<<"file->format"<<file->format<<"file->mode"<<file->mode<<"file->length.."<<file->length<<"file->sensorID"<<file->sensorID<<"file->subsensorID"<<file->subsensorID<<endl;
    //    cout<<"file->ndets"<<file->ndets<<"file->nscan"<<file->nscan<<"file->nbands.."<<file->nbands<<"file->nbands_b"<<file->nbands_b<<"file->nbands_swir"<<file->nbands_swir<<"file->npix"<<file->npix<<endl;
    //    exit(1);
 
 
 
        //sensor characteritics
        //views=nullptr;//nc file !!indexes are not defined//?? no pointer in filehandle, nc
        //pols[0] = 0;//0: non-pol, 1: cross, 2: parall//nc file
        //pols[1] = 0;//0: non-pol, 1: cross, 2: parall
        //pols[2] = 0;//0: non-pol, 1: cross, 2: parall
        //bbands=nullptr;//nc file group sensor_band_parameters !! array with bands wavelengths//fwwave pointer in filehandle
        //rbands=nullptr;//nc file
        //swirbands=nullptr;//nc file
 
        //navigation attributes
    //    l1cfile->orbit_number=file->orbit_number;
        //orb_dir=-1;//nc file global attributes--0 asc 1 des file//nc
    //    l1cfile->orbit_node_lon=file->orbit_node_lon;//this is node_crossing_time
 
        //geolocation attributes
    //    l1cfile->terrain_corrected=file->terrain_corrected;
 
        //cloud_height=nullptr;//anc file or observ data group in nc?
        //More iput L1C parameters-----
        l1cfile->l1c_pflag = l1cinput->l1c_pflag;
        l1cfile->swtnum = l1cinput->swtnum;
  
 
        for (int j = 0;j < 10;j++) {
            l1cfile->selgran[j] = l1cinput->selgran[j];
        }
        //projection params
        l1cfile->gres = l1cinput->gres;
        l1cfile->proj_type = l1cinput->l1c_proj;
        l1cfile->cloud_corrected = l1cinput->cloud_correct;
        //multi  attributes (view, pol, bands) 
        l1cfile->overlap_vflag = l1cinput->overlap_vflag;
        l1cfile->overlap_pflag = l1cinput->overlap_pflag;
        l1cfile->overlap_bflag = l1cinput->overlap_bflag;
        //uncertainty params l1c merged products
        l1cfile->unc_meth = l1cinput->unc_meth;
        l1cfile->unc_thres_v = l1cinput->unc_thres_v;
        l1cfile->unc_thres_p = l1cinput->unc_thres_p;
        l1cfile->unc_thres_b = l1cinput->unc_thres_b;
 
        //calibration attributes
        //l1cfile->Fobar=file->Fobar;//nc
 
        cout << "ok transfering filehandle to l1c_filehandle info.." << endl;
        return 0;
    }
 
 
}//close l1c namespace