/***************************************************************************
 *   (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:    CO2Reg.h
 *
 * Filename: CO2Reg.h
 *
 * Description: CO2Reg 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 CO2REG_H
#define CO2REG_H
#include <iostream>
#include <fstream>
#include <string>
//#include <vector>
#include "Event.h"
#include "EventVar.h"
#include "ConfigFile.h"
#include "AltReg.h"
#include "ModelData.h"
#include "NonLinearity.h"
//#include "Ephemeris.h"
//#include "GeneralFunctions.h"

using namespace std;

//typedef vector<double> Vec;

class CO2Reg:public AltReg{
private:

/*
   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 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
   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> z37;        //!< 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> b37;        //!< Final Z values for various Registration Methods 
   EventVar<double> m37;        //!< 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> angleImpactEdgeLower;   //!< Impact Angle at Edge From Model Iteration
   //EventVar<double> angleImpactComposite;   //!< Impact Angle at Edge From Model Iteration
   EventVar<double> angleRefr;         //!< Refraction Angle
   EventVar<double> angleRefrSolar;    //!< Refraction Angle on Solar Tracker Time
   EventVar<double> angleGeom;         //!< Geometric Angle
   EventVar<double> angleGeomEdge;         //!< Geometric Angle Edge
   //EventVar<double> angleGeo2;         //!< Permanent Store Geometric Angle
   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> losVectorSun();  //!<
   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
   //EventVarVect<double> losSun;        //!< Line Of Sight Vector to Sun
   EventVar<double> modelSignal;
   EventVar<double> signalExo;
   EventVar<double> attenSetting;
   EventVarVect<double> allSignals;
   EventVarVect<double> plotLockdownIt;
   //EventVarVect<double> plotSCRadiusIt;
   EventVarVect<double> plotZImpactIt;
   EventVarVect<double> plotCBSignalIt;
   EventVarVect<double> plotAnglesIt;
   //EventVar<double> sunSensorTime;
   //EventVar<double> sunSensorOffsets;
   //EventVar<double> sunSensorExoValues;
   //EventVarVect<double> sunSensorValues;
   //EventVarVect<double> plotAltitudesIt;

   //void setGriddedIndices(EventVar<double>&, int&, int&);
   //void setGriddedIndices(EventVar<double>&, int&, int&, int&, int&);
   //void gridCenterSums(Event &);

   //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 setConvolutionIndices(vector<double>&, vector<double>&, int&, int&);
   void invertVector(vector<double>&);
   void normalize(vector<double>&);
   void initializeCO2Reg();
   void finalizeCO2Reg(int, int);
   void setZOffset(int, int);
   void writeMetrics(Event&);
/*   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

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

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

   ~CO2Reg();
   //!< 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 initializeParams();
   void initializeNames();


   void readAttenSettings(Event&);
   //!< Reads Attenuator Setting EventVars from Event Variable
   //!< Attenuator Setting In Level 0 Event

   void calcImpactData(ModelData&);
   //<! Altitude Registration 2 -- Finds Model Impact Angle and Refraction Angle
   //<! Used In Pressure registration 

   void calcImpactData(ModelData&, EventVar<double>);
   //<! Finds Model Time and stores Time, angleGeom, and angleImpact
   //<! Used In Pass-Thru Mode

   void calcZImpactFOV();
   //!< Finds TP Location corresponding to AngleImpactFOV

   void calcZImpact();
   //!< Finds TP Location corresponding to AngleImpact

   void convolveFOV(Event&);
   //!< Convolves over the Solar Source Function
   //!< SSF stored in SolarSrcFunc.h

   double getTimeOffset();
   //!< Returns value stored in Altreg.timeOffset

   double getZPTcompare(int, double);
   //!< Returns zComparison Value for Pass-Through Approach

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

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

   void addNonlinearity();
   //!< Adds Non-linearity to Modeled Transmissions

   void convertSignals2Model(ModelData&);
   //!< Interpolates Model Signals Onto Observed Altitude Grid (Thus Time Grid)

   void doPressureRegistration(Event&, ModelData&);
   //!< Iterate Time to Match Model Signals with Observed

   void compareSignals(int&, int&);
   //!< Compare and Get RMS

   void setTimeOffset();
   //!< Calculate New TimeOffset based on Newton Method

   void calcRMS(int, int);
   //!< Get RMS between indices

   void getComparisonRange(int&, int&);
   //<! Find Indices to Compare based on AltitudeRange and New Impact Z.


};

#endif