/***************************************************************************
 *   (C) Copyright 2006 by GATS, Inc.
 *         11864 Canon Blvd., STE 101
 *         Newport News, VA 23606
 *
 *   All Rights Reserved. No part of this software or publication may be
 *   reproduced, stored in a retrieval system, or transmitted, in any form
 *   or by any means, electronic, mechanical, photocopying, recording, or
 *   otherwise without the prior written permission of GATS, Inc.
 *
 ***************************************************************************
 *
 * Class:    AltReg.h
 *
 * Filename: AltReg.h
 *
 * Description: AltReg has member functions to store signals,
 *              calculate refraction errors, and write altitude
 *              corrected output
 *
                @author      C.W.Brown
 *              (757)952-1048
 *    	        (757)873-5920
 *              <c.w.brown@gats-inc.com>
 *
 ***************************************************************************/

#ifndef ALT_REG_H
#define ALT_REG_H
#include <iostream>
#include <fstream>
#include <string>
//#include <vector>
#include "Event.h"
#include "EventVar.h"
#include "ConfigFile.h"
#include "ModelData.h"
#include "NonLinearity.h"
#include "NonLinearityCorr.h"
//#include "Ephemeris.h"
//#include "GeneralFunctions.h"

using namespace std;

//typedef vector<double> Vec;

class AltReg{
private:
   string _pixelaverage21;
   string _pixelaverage33;
   string _NormalizedPosition;
   //PlotParams plot;
   //InputParams in;
   //LogParams log;
public:

   int gridNum;                //!< Number of Points in Gridded Output
   int eventType;              //!< Event Description (SR = 1, SS = 2)
   int band;                   //!< Registration band (Originally Band 13)
   int numBands;               //!< Number of Bands in Data (24)
   int iteration;              //!< Iteration Count
   int altRegType;             //!< Type of Registration (1-3 for PassThru, Pressure, Refr)
   int sIndex;              //!< Start Index for Refraction Registration
   int zCompareIndex;              //!< ZComparison Index
   int rangeMethod;              //!< ZComparison Index
   double zCompareRatio;              //!< ZComparison Ratio
   double zCompareAlt;              //!< ZComparison Ratio
   double gridSpacing;         //!< Spacing for Output Grid (in KM)
   //double signalExo;           //!< Calculated Signal Exo (Default 1.0)
   char* fovFileName;
   double convCriteria;        //!< Determines if Registration Converged
   int maxIterations;          //!< Maximum Iterations Before Giving Up (Default = 10)
   double zOffset;             //!< Registration Offset From Initial Z
   double timeOffset;          //!< Registration Offset From Ephem Time
   double saveTimeOffset;      //!< Registration Offset From Ephem Time
   double currConverge;        //!< Convergence Evaluation of Current Registration Iteration
   double saveConverge;        //!< Convergence Evaluation of Last Registration Iteration
   //double altRange[2];         //!< Altitude Range of Registration Process
   //double gridRange[2];        //!< Altitude Range of Gridded Output
   int logDebug;                  //!< Boolean for Debug Logging
   int logGriddedRefraction;   //!< Boolean for Logging Refraction Angles
   int logModelData;
   int plotDebug;                  //!< Boolean for Plotting Debug Algorithms (BULK)
   int plotGridData;           //!< Boolean for Plotting Data ... 0 = No
   int plotSimData;            //!< Boolean for Plotting Data ... 0 = No
   int plotInputParams;
   int plotFunctions;
   int plotNonLinearity;
   int plotLockdownFunc;
   int plotRefrReg;
   int plotModelCalcIt;
   int plotModelCalcFinal;
   int plotDifferences;
   int plotDifferencesIt;
   int plotCorrectionBand;
   int plotAllBands;
   int plotZImpact;
   int plotGeomAngles;
   int plotConvolve;
   int plotSLDC;
   int plotSunSensor;
   int doConvolution;
   int doNonLinearCorr;
   int doNonLinearCorrCenterSums;
   int doSmoothLockdown;
   int presetGrid;              //!< Bool for Grid Range being set in Config File
   int presetRange;             //!< Bool for Registration Range being set in Config File
   double initTimeOffset;            //!< Boolean for Plotting Data ... 0 = No
   double deltaTime;            //!< Time Offset From Last Iteration
   double dRMS;                 //!< RMS difference from iteration to iteration
   double rmsSolution;          //!< RMS difference from latest iteration
   double meanSolution;          //!< RMS difference from latest iteration
   double MAXFINALTIMEOFFSET;       //!< Maximum Final Time Offset
   double maxTimeOffset;            //!< Time Offset From Last Iteration
   double minTimeOffset;            //!< Time Offset From Last Iteration
   double maxRefrAlt;          //!< Refraction Registration Max Altitude to Start
   double bandOffset_SR;          //!< SR FOV BandOffset
   double bandOffset_SS;          //!< SS FOV BandOffset
   int refrRegNum;          //!< Number of Refraction Registration Sets to Calculate
   int minLockIndex;            //!< Min Lockdown Index to use
   int maxLockIndex;            //!< Max Lockdown Index to use
   int minAltIndex;            //!< Min Altitude Index to use
   int maxAltIndex;            //!< Max Altitude Index to use
   vector<double> altRange;         //!< Altitude Range of Registration Process
   vector<double> gridRange;        //!< Altitude Range of Gridded Output
   EventVar<double> methodComparisonZValues;        //!< Final Z values for various Registration Methods
   EventVar<double> AltReg_RefractionRMS;  //!< Final QA values for various Registration Methods
   EventVar<double> AltReg_RefractionMean; //!< Final QA values for various Registration Methods
   EventVar<double> methodComparisonBands;        //!< Final Z values for various Registration Methods
   EventVar<double> methodComparison;        //!< Final Z values for various Registration Methods

   EventVar<double> altRegTime;        //!< Time of Signals
   EventVar<double> refAngTime;        //!< Refraction Angle on Refraction Angle Time
   EventVar<double> corrBandSignal;    //!< Band Signal or Transmission
   EventVar<double> angleImpact;       //!< Impact Angle
   EventVar<double> angleImpactEdge;        //!< Impact Angle at Edge From Model Iteration
   EventVar<double> angleImpactEdgeBottom;  //!< Impact Angle at Edge From Model Iteration
   EventVar<double> angleRefr;              //!< Refraction Angle
   EventVar<double> angleRefrEdgeBottom;    //!< Refraction Angle Bottom
   EventVar<double> angleRefrSolar;         //!< Refraction Angle on Solar Tracker Time
   EventVar<double> angleGeom;              //!< Geometric Angle
   EventVar<double> angleGeomEdge;          //!< Geometric Angle Edge
   EventVar<double> angleGeomEdgeBottom;         //!< Geometric Angle Edge
   EventVar<double> zGeom;             //!< Geometric Altitude
   EventVar<double> zImpact;           //!< Impact Altitude
   EventVar<double> zImpactEdgeTop;           //!< Impact Altitude Top Edge
   EventVar<double> zImpactEdgeBottom;           //!< Impact Altitude Bottom Edge
   EventVar<double> lockdownAngle;     //!< Lockdown Angle to FOV
   EventVar<double> lockdownAngleAz;     //!< Lockdown Angle to FOV
   EventVar<double> fpaSolarExtent;     //!< FPA Solar Extent
   EventVar<double> exoSolarExtent;     //!< Exoatmospheric Solar Extent
   EventVar<double> normSolarExtent;     //!< FPA Normalized Solar Extent
   EventVar<double> solarHighEdgeEl;     //!< Solar High Elevation Edge
   EventVar<double> solarHighEdgeAz;     //!< Solar High Azimuthal Edge
   EventVar<double> solarLowEdgeEl;     //!< Solar Low Elevation Edge
   EventVar<double> solarLowEdgeAz;     //!< Solar Low Azimuthal Edge
   EventVar<double> solarShrinkage;          //!< Sun Shrinkage on Detector Time
   EventVar<double> ssTran;		//!Sun Sensor Transmission
   EventVar<double> solarShrinkageSolar;     //!< Sun Shrinkage from RefrAngleCalc 
   EventVar<double> radiusSC;          //!< Spacecraft Radius
   EventVar<double> radiusSC_Shifted;     //!< Time Shifted Spacecraft Radius
   EventVar<double> radiusC;         //!< Permanent Store of Spacecraft Radius
   EventVar<double> doppler;           //!< Doppler Shift
   EventVar<double> modelSignal;
   EventVar<double> signalExo;
   EventVar<double> attenSetting;
   EventVarVect<double> allSignals;
   EventVarVect<double> plotLockdownIt;
   EventVarVect<double> plotZImpactIt;
   EventVarVect<double> plotCBSignalIt;
   EventVarVect<double> plotAnglesIt;

   void setGriddedIndices(EventVar<double>&, int&, int&);
   void setGriddedIndices(EventVar<double>&, int&, int&, int&, int&);
   void analyzeData(EventVarVect<double>, EventVarVect<int>&);
   void setConfigParameters(ConfigFile&, int);
   //!< Reads Config File for Registration Parameters
   //!< Stores Information into AltReg Class Object Private Variables

   int getShift(int);
   //<! Gets the Index Shift for the Time Offset

   void interpLine(double, double, double, double, double, double&);
   //<! Linear Interpolates Between 2 data points

//   void setConvolutionIndices(vector<double>&, vector<double>&, int&, int&);
//   void invertVector(vector<double>&);
   EventVar<double> invertVector(EventVar<double>);
//   void normalize(vector<double>&);
//   void initializeCO2Reg();
//   void finalizeCO2Reg(int, int);
//   void setZOffset(int, int);
   void plotDiff();
   void plotInitialSunSensor(EventVarVect<double>&);
   void plotGriddedSunSensor(Event&, int);
   void gridData(EventVar<double>, EventVar<double>,EventVar<double>&,int, int);
   void gridAltitude(EventVar<double>&, int, int);
   void logGridData(EventVar<double>, EventVar<double>);


//public:

   int regValidityFlag;        //!< Registration Validity Flag -- Used To Pass Over Registration Rather Than THROW exception

   AltReg();
   //!< default constructor - Constructs an empty EphemerisClass object

   AltReg(Event&, Event&, ConfigFile&, int);
   //!< Constructs an empty AltReg object
   //!< This constructor will be used with the Solar Ephem Object

   ~AltReg();
   //!< default destructor

   void readForwardModelData(Event&, Event&, ConfigFile&);
   //!< Reads Simulated Forward Model EventVars from Event Variable
   //!< Stores Information from CO2Sim in AltReg Class Object
   //!< Input(s):
   //!<      Event with EventVars SimSig, SimAlt, SimRef
   //!< Stored Output(s):  AltReg.signal[]
   //!<                    AltReg.zAltitude[]
   //!<                    AltReg.angleRef[]
   //!<                    AltReg.timeOffset = 0
   //!<                    AltReg.signalExo
   //!<                    AltReg.convergence = 0

   void readGeometricData(Event&, Event&, ConfigFile&);
   //!< Reads Geometric EventVars from Event Variable
   //!< Reads Config File for Registration Parameters
   //!< Stores Information from TimeReg and SigCorr in AltReg Class Object

   void addLockdown();
   //<! Adds Lockdown Angle to Time Shifted Impact Angle

   void smoothLockdown();
   //<! Smooths Lockdown Angle over X=9 poitns

   void getLockdownSettleIndex();
   //<! Returns minimum and maximum indexes for Lockdown reaching settle point

   double getExoLockdown();
   //<! Returns Lockdown Angle of 110-120 km data

   void getGriddedIndices();
   //<! Returns minimum and maximum indexes for Lockdown reaching settle point

   void calcAngleGeomCenter();
   //void calcAngleGeomCenter(EventVar<double>);
   //!< Calculates the Angle to the Geometric Center of the Sun
   //!< Based on the Radius of Curvature at the Tangent Point
   //!< And the Spacecraft Radius for each temporal location
   //!< Input(s):  EventVar radiusCurv
   //!<            EventVar radiusSC
   //!< Output:    EventVar

   //void calcAngleGeomEdge(EventVar<double>);
   void calcAngleGeomEdge();
   //!< Adjusts the Angle from the Geometric Center of the Sun
   //!< to the Geometric Edge by offsetting the solar extent

   void calcAngleGeomFOV();
   //!< Adds Lockdown Position to Geometric Angle

   void calcAngleImpactFOV(EventVar<double>);
   //!< Adds Lockdown Position to Geometric Angle

   double getConvergence();
   //!< Returns value stored in Altreg.convergence

   double getZcompare();
   //!< Returns zComparison Value for Operational Altitude Registration Method

   double getZcompare(int, double);
   //!< Returns zComparison Value for Secondary AltReg Methods

   int getZcompareIndex();
   //!< Returns zComparison Index for Comparison Method

   double getZcompareRatio();
   //!< Returns zComparison Ratio (Percentage from Index to Comparison Altitude)

   void putZcompare(EventVar<double>);
   //!< Adds zComparison Vector to AltReg Object

   void putRefractionData(EventVar<double>, EventVar<double>, double, double);
   //!< Adds Refraction Angle and Z to AltReg Object

   void searchValidIndices(EventVar<double>, int&, int&);

   void putMissingValues(EventVar<double>&, double, double);

   void createAltitudeGrid(Event&);
   //!< Places all data on 200 m grid ... Configurable in Config file.
   //!< Writes that Grid to Event Object

   void recreateAltitudeGrid(Event&, EventVar<double>);

   //void combineComposite(EventVarVect<double>, EventVar<double>&);
   void combineComposite(EventVarVect<double>, EventVar<double>&, EventVar<double>&);
   void setMinMaxIndices(EventVar<double>, int&, int&);
   void fillMissingValues(EventVar<double>&, int, int);


   void writeOutput(Event&);
   //!< Writes the Output of All Member Variables to Event Object Tmp or Level1

   void writeToEvent(Event&);
   void writePassThruToEvent(Event&);
   //!< Writes the EventVars To The 
   void writeToEvent(Event&, EventVar<double>);

   //void writeToEvent(Event&, EventVar<double>);

   void gridCenterSums(Event &);

   int getExoStartIndex();
   void calcSunSensorRefraction(EventVar<double>, ModelData, EventVar<double>&);
   void convertSolarSource(EventVar<double>&, EventVar<double>&);
   void createCenterSumData(Event&, Event&, ModelData&);

   //friend class CO2Reg;

};

#endif