//
//  $Id$
//-----------------------------------------------------------------------
//
//            (c) Copyright 2006 by GATS, Inc.,
//     11864 Canon Blvd, Suite 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
//
// Filename:    AltReg.cpp
//
// Author:      Christopher W. Brown  <c.w.brown@gats-inc.com>
//
// Date:        December 2006
//
//-----------------------------------------------------------------------
// Modification History:
//
//-----------------------------------------------------------------------
// Include Files:
//-----------------------------------------------------------------------
//

#include "ConfigFile.h"
#include "EventVar.h"
#include "AltReg.h"
#include "ModelData.h"
#include "NonLinearity.h"
#include "sofiefov.h"
#include "ConvFunctions.h"
#include <iostream>
#include <string>
#include <stdexcept>
#include<vector>
//
//-----------------------------------------------------------------------
// Defines and Macros:
//-----------------------------------------------------------------------
//
//#define LOGOUT
#define MISSINGVAL -1.e+24
#define MINRANGE1 5.0    //Minimum Altitude Range to base Pressure Registration
#define MINRANGE2 0.02   //Minimum Transmission Range to base Pressure Registration
#define EVENTVAR_ALTMIN -200.0   //Minimum Altitude for Altitude EventVars
#define EVENTVAR_ALTMAX 500.0    //Maximum Altitude for Altitude EventVars
//
//-----------------------------------------------------------------------
// Global Variables:
//-----------------------------------------------------------------------
//

//
//-----------------------------------------------------------------------
// Utility Routines:
//-----------------------------------------------------------------------
//

using namespace std;

AltReg::AltReg()
//!< Default Constructor for AltReg Class
{
}

//AltReg::AltReg(Event &InEvent, Event &Stat, ConfigFile &cf)
AltReg::AltReg(Event &InEvent, Event &Stat, ConfigFile &cf, int regNum)
//!< Constructor for AltReg Class
//!< Loads Initial AltReg Data from file
{
#ifdef LOGOUT
  cout << "In Constructor AltReg::AltReg(Event &, Event &, ConfigFile &)" << endl;
#endif
   gridSpacing = 0.0;
   rangeMethod = 1;
   band = 0;
   plotGridData = 0;
   plotSimData = 0;
   initTimeOffset = 0.0;
   deltaTime = 0.0;
   dRMS = 0.0;
   convCriteria = 0.0;
   maxIterations = 0;
   logModelData = 0;
   plotLockdownFunc = 0;
   plotRefrReg = 0;
   plotFunctions = 0;
   plotInputParams = 0;
   presetGrid = 0;
   presetRange = 0;
   plotDebug = 0;
   plotGeomAngles = 0;
   plotConvolve = 0;
   plotSLDC = 0;
   plotSunSensor = 0;
   plotNonLinearity = 0;
   plotModelCalcFinal = 0;
   plotModelCalcIt = 0;
   plotDifferences = 0;
   plotDifferencesIt = 0;
   plotCorrectionBand = 0;
   plotZImpact = 0;
   doConvolution = 0;
   doNonLinearCorr = 0;
   doNonLinearCorrCenterSums = 0;
   doSmoothLockdown = 0;
   logDebug = 0;
   logGriddedRefraction = 0;
   //Initialize To Defaults
   currConverge = 100.0; //Set High so it will run
   saveConverge = 100.0; //Set High so it will run
   eventType = 0;
   gridNum = 0;
   iteration = 0;
   numBands = 24;
   sIndex = 0;
   bandOffset_SR = 0.0;
   bandOffset_SS = 0.0;
   zCompareAlt = 0.0;
   zCompareRatio = 0.0;
   zCompareIndex = 0;
   timeOffset = 0.0;
   saveTimeOffset = 0.0;
   minTimeOffset = -3.0;
   //minTransmission = 0.3;
   //maxTransmission = 0.4;
   maxTimeOffset = 3.0;
   minLockIndex = -1;
   maxLockIndex = -1;
   MAXFINALTIMEOFFSET = 2.0;
   regValidityFlag = 0;
   altRange.resize(2, 0.0);
   gridRange.resize(2, 0.0);
   setConfigParameters(cf, regNum);

   if(gridSpacing != 0)
     gridNum = int (((gridRange[1] - gridRange[0]) / gridSpacing ) + 1.01);
   else gridNum = 0;

   //allSignals.setName("allSignals");

   altRegTime.setName("Registered Time");
   corrBandSignal.setName("corrBandSignal");
   angleImpact.setName("angleImpact");
   angleImpactEdge.setName("angleImpactEdge");
   angleRefr.setName("angleRefr");
   angleGeom.setName("angleGeom");
   angleGeomEdge.setName("angleGeomEdge");
   angleGeomEdgeBottom.setName("angleGeomEdgeBottom");
   zGeom.setName("zGeom");
   zImpact.setName("zImpact");
   zImpactEdgeTop.setName("zImpactTopEdge");
   zImpactEdgeBottom.setName("zImpactEdgeBottom");
   methodComparisonZValues.setName("altReg_ZImpact");
   methodComparisonBands.setName("altReg_Band");
   methodComparison.setName("altReg_Method");
   lockdownAngle.setName("LockdownAngle");
   //EventVar<double> losVectorSun();
   radiusSC.setName("radiusSC");
   radiusSC_Shifted.setName("radiusSC_Shifted");
   //losSun.setName("losSun");
   allSignals.setName("allSignals");
//   ssTran.setName("SS_CompositeTransmission");

}

AltReg::~AltReg()
//!< Default Destructor for AltReg Class
{
#ifdef LOGOUT
   cout << "In Destructor AltReg::~AltReg()" << endl;
#endif
}

void AltReg::smoothLockdown(){

   double smoothed = 0.0;;
   int smoothPts = 9;

   EventVar<double> newLockdownAngle(lockdownAngle.size());

   newLockdownAngle = lockdownAngle;

   for(int i=minLockIndex; i<maxLockIndex; i++){
      for(int j=0; j<smoothPts; j++){
         if(i+j-smoothPts/2 < minLockIndex)
            smoothed += lockdownAngle[minLockIndex];
         else if(i+j-smoothPts/2 > maxLockIndex)
            smoothed += lockdownAngle[maxLockIndex];
         else smoothed += lockdownAngle[i+j-smoothPts/2];
      }
      newLockdownAngle[i] = smoothed / smoothPts;
      smoothed = 0.0;
   }

   lockdownAngle = newLockdownAngle;

}


void AltReg::addLockdown()
//!< Adds Lockdown Angle to Time Offset Array
{

   int i;
   int shift = getShift(300);
   double aiEdge, agEdge, aMin, aMax;
   double tTarget, tMin, tMax;
   EventVar<double> angleImpactFOV(angleImpact.size());
   EventVar<double> angleGeomFOV(angleGeom.size());

   if(minLockIndex == -1 || maxLockIndex == -1)
      getLockdownSettleIndex();

   if(timeOffset == 0.0){
      angleImpact += lockdownAngle;
      angleGeom += lockdownAngle;
   }
   else {
      for(int i=minLockIndex; i<maxLockIndex; i++){
      //for(int i=0; i<angleImpact.size()-1; i++){

         //Start with limiting the lockdown angle to 1/3 full sun . . .
         //if(lockdownAngle[i]>0.00)
         angleImpactFOV[i] = lockdownAngle[i];
         angleGeomFOV[i] = lockdownAngle[i];
         //else angleImpactFOV[i] = 0.00;
         //cout << "i: " << i << "  Time:  " << altRegTime[i] << "  timeOffset: " << timeOffset
         //     << " time0 " <<  altRegTime[0] << "lockAng:  " << lockdownAngle[i] << endl;
         //... then add Edge Impact Angle
         //If timeOffset is OOR, extrapolate value
         if(altRegTime[i] + timeOffset < altRegTime[minLockIndex]){
         //if(altRegTime[i] + timeOffset < altRegTime[0]){
            //angleImpactFOV[i] = angleImpact[i] + timeOffset * (angleImpact[i+1] - angleImpact[i]) / (altRegTime[i+1] - altRegTime[i]);
            angleImpactFOV[i] += angleImpact[i] + timeOffset * (angleImpact[i+1] - angleImpact[i]) / (altRegTime[i+1] - altRegTime[i]);
            angleGeomFOV[i] += angleGeom[i] + timeOffset * (angleGeom[i+1] - angleGeom[i]) / (altRegTime[i+1] - altRegTime[i]);
            //cout << "TimeOffset: " << timeOffset << "   aFOV[i-2]: " << angleImpactFOV[i-2]
            //     << "   aFOV[i-1]: " << angleImpactFOV[i-1] << "  angleMoney:  " << angleImpactFOV[i] << endl;
            //cout << "angleI[i-1]: " << angleImpact[i-1] << "  angleI[i]: " << angleImpact[i]
            //     << "angleI[i+1]: " << angleImpact[i+1] << "  lockAng[i]: " << lockdownAngle[i] << endl << endl;
         }
         else if(altRegTime[i] + timeOffset > altRegTime[maxLockIndex]){
         //else if(altRegTime[i] + timeOffset > altRegTime[altRegTime.size()-1]){
            //angleImpactFOV[i] = angleImpact[i] - timeOffset * (angleImpact[i-1] - angleImpact[i]) / (altRegTime[i-1] - altRegTime[i]);
            angleImpactFOV[i] += angleImpact[i] - timeOffset * (angleImpact[i-1] - angleImpact[i]) / (altRegTime[i-1] - altRegTime[i]);
            angleGeomFOV[i] += angleGeom[i] - timeOffset * (angleGeom[i-1] - angleGeom[i]) / (altRegTime[i-1] - altRegTime[i]);
            //cout << "AngTimeOOR:  " << (altRegTime[i]+timeOffset)*1000 << "  altTime0 " << altRegTime[0]
            //     << "  altTimeN " << altRegTime[altRegTime.size()-1] << "  timeOffset " << timeOffset << endl;
            //cout << "TimeOffset: " << timeOffset << "   aFOV[i-2]: " << angleImpactFOV[i-2]
            //     << "   aFOV[i-1]: " << angleImpactFOV[i-1] << "  angleMoney:  " << angleImpactFOV[i] << endl;
            //cout << "angleI[i-1]: " << angleImpact[i-1] << "  angleI[i]: " << angleImpact[i]
            //     << "angleI[i+1]: " << angleImpact[i+1] << "  lockAng[i]: " << lockdownAngle[i] << endl << endl;
         }
         // Interpolate and Add Lockdown
         else {
            //shift = getShift(i);  // Find Indices to Shift
            tTarget = altRegTime[i] + timeOffset;
            tMin =  altRegTime[i+shift];
            tMax = altRegTime[i+shift+1];
            aMin = angleImpact[i+shift];
            aMax = angleImpact[i+shift+1];
            interpLine(tTarget, tMin, tMax, aMin, aMax, aiEdge);

            //if(lockdownAngle[i]>0.0)  angleImpactFOV[i] = lockdownAngle[i];
            //else angleImpactFOV[i] = 0.0;
            angleImpactFOV[i] += aiEdge;

            aMin = angleGeom[i+shift];
            aMax = angleGeom[i+shift+1];
            interpLine(tTarget, tMin, tMax, aMin, aMax, agEdge);

            //if(lockdownAngle[i]>0.0)  angleImpactFOV[i] = lockdownAngle[i];
            //else angleImpactFOV[i] = 0.0;
            angleGeomFOV[i] += agEdge;
            //cout << "AngTime:  " << (altRegTime[i]+timeOffset)*1000 << "  angleGeom " << angleGeom[i+shift]
            //     << "  angleImpact " << angleImpact[i] << "  angleGeom1 " << angleGeom[i+shift+1] << endl;
         }
      }
      //Just Linear Extrapolate the Last point
      angleImpactFOV[maxLockIndex-1] = angleImpactFOV[maxLockIndex-2]*2 - angleImpactFOV[maxLockIndex-3];
      angleGeomFOV[maxLockIndex-1] = angleGeomFOV[maxLockIndex-2]*2 - angleGeomFOV[maxLockIndex-3];
      //angleImpactFOV[angleImpact.size()-1] = angleImpactFOV[angleImpact.size()-2]*2 - angleImpactFOV[angleImpact.size()-3];

      angleImpact = angleImpactFOV;
      angleGeom = angleGeomFOV;
   }

   if(plotLockdownFunc){
/*
      string title("Function:  addLockdown");
      altRegTime.setAxisRange();
      angleImpact.setAxisRange(15.0, 25.0);
      angleImpact.Plot("Altitude Registration",title,altRegTime);
*/
      //EventVarVect<double> Comparison;
      //Comparison.addEventVar(angleImpact);
      //Comparison.addEventVar(angleImpactEdge);
      //Comparison.Plot("Altitude Registration", title, altRegTime);
      char strIt[56];
      sprintf(strIt, "Impact Angle FOV Iteration %02i", iteration);
      //nameEV = "Model Signal Iteration " + strIt;
      //signalMod.setName(nameEV);
      angleImpactFOV.setName(strIt);
      angleImpactFOV.setAxisRange(0.3, 0.5);
      angleImpactFOV.setDescription(strIt);
      angleImpactFOV.Plot("AR addLockdown", strIt, altRegTime);

      plotLockdownIt.addEventVar(angleImpactFOV);

/*
      //title = "Function:  addLockdown()";
      altRegTime.setAxisRange();
      lockdownAngle.setAxisRange(15.0, 25.0);
      lockdownAngle.Plot("Altitude Registration","Lockdown in Add",altRegTime);
*/
   }

   return;

}

void AltReg::getLockdownSettleIndex()
//!< Finds indices of Lockdown settle
{
   int writeSignal = 0;
   int mid = lockdownAngle.size()/2;

   minLockIndex = mid;
   maxLockIndex = mid;

   while(minLockIndex >= 0 &&
         lockdownAngle[minLockIndex] != MISSINGVAL)
      minLockIndex--;
   minLockIndex++;

   while(maxLockIndex <= lockdownAngle.size()-1 &&
         lockdownAngle[maxLockIndex] != MISSINGVAL)
      maxLockIndex++;
   maxLockIndex--;

   //Check Last Sample Index if needed
   //if(maxLockIndex == lockdownAngle.size()-1 && lockdownAngle[maxLockIndex] == MISSINGVAL)
   //   maxLockIndex = lockdownAngle.size()-2;

   if(maxLockIndex - minLockIndex < 1200){
      cout << "  WARNING:  Lockdown Angle has less than 1 minute of values. " << endl;
      writeSignal = 1;
   }

   if(maxLockIndex > lockdownAngle.size()-1 || minLockIndex > lockdownAngle.size()-1){
      cout << "  WARNING:  Lockdown Angle Indices Too Large in getLockdownSettleIndex(). " << endl;
      writeSignal = 1;
   }

   if(logDebug || writeSignal){
      cout << "MinLockIndex:  " << minLockIndex << "  LockdownAngle:  " << lockdownAngle[minLockIndex] << endl;
      cout << "MaxLockIndex:  " << maxLockIndex << "  LockdownAngle:  " << lockdownAngle[maxLockIndex] << endl;
   }

   //searchValidIndices();

   //smoothLockdown();

   return;

}

double AltReg::getExoLockdown()
//!< Finds ExoAtmospheric Lockdown Angle
{
   int i, num;
   double sum, avg;

   num = 0;
   sum = 0.0;

   for(i=minLockIndex; i<maxLockIndex; i++){
       if(zImpact[i] <= 120.0 && zImpact[i] >= 110.0) {
//      if(((zImpact[i] <= 120.0 && zImpact[i+1] >= 110.0)  || //SS
 //         (zImpact[i] >= 110.0 && zImpact[i+1] <= 120.0)) ) { // &&  //SR
//         (lockdownAngle[i] != MISSINGVAL &&
//          lockdownAngle[i] > 0.0 &&
//          lockdownAngle[i] < 0.009)){
         //cout << i << "  LockdownAngle:  " << lockdownAngle[i] << "  zImpact " << zImpact[i] << endl;
         sum += lockdownAngle[i];
         num++;
      }
   }

   if(num != 0) avg = sum / (double)num;
   else exit(23); //avg = MISSINGVAL;
cout << " Exo Lockdown: " << avg* 10800./M_PI << " arcminutes " << endl;
   return avg;

}

int AltReg::getExoStartIndex()
//!< Finds ExoAtmospheric Lockdown Angle
{
   int i, num;
   double sum, avg;
   int exoIndex = -999;
   num = 0;
   sum = 0.0;

   EventVar<double> zI(zImpact);

   putMissingValues(zI, EVENTVAR_ALTMIN, EVENTVAR_ALTMAX);

   zImpact = zI;

   for(i=minLockIndex; i<maxLockIndex; i++){
      if(((zImpact[i] <= 120.0 && zImpact[i+1] >= 110.0)  || //SS
          (zImpact[i] >= 110.0 && zImpact[i+1] <= 120.0)) &&  //SR
         ((zImpact[i] != MISSINGVAL) && (zImpact[i+1] != MISSINGVAL))){
      //   (lockdownAngle[i] != MISSINGVAL &&
      //    lockdownAngle[i] > 0.0 &&
      //    lockdownAngle[i] < 0.009)){
         //cout << i << "  LockdownAngle:  " << lockdownAngle[i] << "  zImpact " << zImpact[i] << endl;
         exoIndex = i;
         i=maxLockIndex+1;
      }
   }
   cout << "  ExoAltitude[ " << exoIndex << " ]:  " << zImpact[exoIndex] << endl;

   return exoIndex;

}


void AltReg::searchValidIndices(EventVar<double> Ev, int &low, int &hi)
//!< Look For MISSING Values
{
  int n = Ev.size();
  int first = -1;
  int last = -1;
  string eventVarName = Ev.getName();

  for(int i=0; i<n; i++){
     if(Ev[i] != MISSINGVAL && first < 0){
        first = i;
        //cout << "First  " << first << endl;
     }
     if(Ev[i] == MISSINGVAL && first >= 0 && last < 0){
        last = i-1;
        i = n;
        //cout << "Last  " << last << endl;
     }
  }
  //No Missing Values Found
  if(first < 0 && last < 0){
      first = 0;
      last = n-1;
      //cout << "First0  " << first << endl;
      //cout << "Last0   " << last << endl;
  }

  //Only Missing Values at Beginning of EventVar
  if(first >= 0 && last < 0){
      last=n-1;
      //cout << "Last2  " << last << endl;
  }

  low = first;
  hi = last;

   if(logDebug){
        cout << "Debugging searchValidIndices(EventVar<double>, int, int):  " << eventVarName << endl;
        cout << "First Non-Missing Index:  " << first << "  Value:  " << Ev[first] << endl;
        cout << " Last Non-Missing Index:  " << last  << "  Value:  " << Ev[last] << endl;
   }

   return;

}

void AltReg::getGriddedIndices()
//!< Finds indices of Min/Max Altitudes
{

   int iStart, iEnd;
   int imid = zImpact.size()/2;

   EventVar<double> zTmp(zImpact.size());
   zTmp = zImpact;
   searchValidIndices(zTmp,iStart, iEnd);
   imid =  (iEnd + iStart) / 2;

   minAltIndex = imid;
   maxAltIndex = imid;

   if(eventType == 1){
      while(minAltIndex > minLockIndex &&
            zImpact[minAltIndex] > zImpact[minAltIndex-1])
         minAltIndex--;
      while(maxAltIndex < maxLockIndex &&
            zImpact[maxAltIndex] < zImpact[maxAltIndex+1])
         maxAltIndex++;
   }
   else {
      while(maxAltIndex > minLockIndex &&
            zImpact[maxAltIndex] < zImpact[maxAltIndex-1])
         maxAltIndex--;
      while(minAltIndex < maxLockIndex &&
            zImpact[minAltIndex] > zImpact[minAltIndex+1])
         minAltIndex++;
   }

   if(logDebug){
      cout << "Gridded Indices For EventType:  " << eventType << endl;
      cout << "   MinAltIndex:  " << minAltIndex << "  Minimum Z:  " << zImpact[minAltIndex] << endl;
      cout << "   MaxAltIndex:  " << maxAltIndex << "  Maximum Z:  " << zImpact[maxAltIndex] << endl << endl;
   }

   return;

}

int AltReg::getShift(int x)
{
   return int ((timeOffset / (altRegTime[x+1] - altRegTime[x])));
}

void AltReg::interpLine(double b, double a, double c, double x, double z, double &y){

   double pctg;
   pctg = (b - a) / (c - a);
   y = x + pctg * (z - x);

   return;

}

void AltReg::putRefractionData(EventVar<double> r, EventVar<double> z, double rms, double m){
//!<
#ifdef LOGOUT
cout << "In Function AltReg::putRefractionData(EventVar<double>, EventVar<double>)" << endl;
#endif

   angleRefr = r;
   angleRefr.setName("L1_RefractionAngles");

   zImpactEdgeBottom = z;
   zImpactEdgeBottom.setName("zImpactEdgeBottom");

   rmsSolution = rms;
   meanSolution = m;

   return;

}

void AltReg::readGeometricData(Event& InEvent, Event& SD, ConfigFile& CF)
//!< Reads Geometric EventVars from Event Variable
//!< Reads Config File for Registration Parameters
//!< Stores Information from TimeReg and SigCorr in AltReg Class Object
//!< Input(s):
//!<      Event with EventVars SimSig, SimAlt, SimRef
//!< Stored Output(s):  AltReg.signal[]
//!<                    AltReg.zImpact[]
//!<                    AltReg.angleRef[]
//!<                    AltReg.timeOffset = 0
//!<                    AltReg.signalExo
//!<                    AltReg.currConverge = 0
{
#ifdef LOGOUT
   cout << "In Function AltReg::readGeometricData(Event& InEvent, Event& SD, ConfigFile& CF)" << endl;
#endif

   EventVar<double> obsSize;
   int tmpBand = band;
   if(altRegType == 3 && band >= numBands)
      band = 12;
      
   InEvent.getEventVar("Final_Signal_Time", obsSize);

//Resize ALL EventVars
   corrBandSignal.resize(obsSize.size());
   altRegTime.resize(obsSize.size());
   angleImpact.resize(obsSize.size());
   angleImpactEdge.resize(obsSize.size());
   angleRefr.resize(obsSize.size());
   angleGeom.resize(obsSize.size());
   angleGeomEdge.resize(obsSize.size());
   angleGeomEdgeBottom.resize(obsSize.size());
   zGeom.resize(obsSize.size());
   zImpact.resize(obsSize.size());
   lockdownAngle.resize(obsSize.size());
   radiusSC.resize(obsSize.size());
   radiusSC_Shifted.resize(obsSize.size());
   signalExo.resize(numBands);
//   ssTran.resize(obsSize.size());

   //losSun.resize(obsSize.size());

   angleRefrSolar.resize(obsSize.size());
   solarShrinkageSolar.resize(obsSize.size());
   solarShrinkage.resize(obsSize.size());
   lockdownAngleAz.resize(obsSize.size());
   fpaSolarExtent.resize(obsSize.size());
   normSolarExtent.resize(obsSize.size());
   exoSolarExtent.resize(1);

   //Get EventVars From InEvent
   cout << "Band:  " << band+1 << endl;
   cout << "AltRegType:  " << altRegType << endl;
   InEvent.getEventVar("Corrected_Signals", allSignals);
   //if(altRegType == 2)
     corrBandSignal = allSignals[band];
   //else corrBandSignal = allSignals[12];
   corrBandSignal.setName("Altitude_Registration_Band");

   InEvent.getEventVar("Final_Signal_Time", altRegTime);
   altRegTime.setName("L1_AltRegTime");

   InEvent.getEventVar("L1_TPAlt", zGeom);

   zGeom.setName("Geometric Center Altitude Z");
   zGeom.setAxisRange(0.0, 180.0);

   InEvent.getEventVar("DetectorLockdown_EL", lockdownAngle);
   lockdownAngle.setName("L1_AngleLockdownEl");

/*
   //Test Lockdown Offset
   const double LOCKANG_OFFSET = 0.0001;
   for(int q=0; q<lockdownAngle.size(); q++)
      if(lockdownAngle[q] != MISSINGVAL)
         lockdownAngle[q] += LOCKANG_OFFSET;
*/

   InEvent.getEventVar("DetectorLockdown_AZ", lockdownAngleAz);
   lockdownAngleAz.setName("L1_AngleLockdownAz");

   InEvent.getEventVar("SolarHighElevationEdge", solarHighEdgeEl);
   solarHighEdgeEl.setName("SolarHighElevationEdge");

   InEvent.getEventVar("SolarLowElevationEdge", solarLowEdgeEl);
   solarLowEdgeEl.setName("SolarLowElevationEdge");

   InEvent.getEventVar("SolarHighAzimuthEdge", solarHighEdgeAz);
   solarHighEdgeAz.setName("SolarHighAzimuthEdge");

   InEvent.getEventVar("SolarLowAzimuthEdge", solarLowEdgeAz);
   solarLowEdgeAz.setName("SolarLowAzimuthEdge");

   InEvent.getEventVar("SolarExtent", fpaSolarExtent);
   fpaSolarExtent.setName("SolarExtent");

   InEvent.getEventVar("L1_SolarExtent", exoSolarExtent);
   exoSolarExtent.setName("L1_SolarExtent");

/*
if(currEvent.EventVarExists("SS_CompositeTransmission")) {
   InEvent.getEventVar("SS_CompositeTransmission", ssTran);
   ssTran.setName("SS_CompositeTransmission");
}
*/

   InEvent.getEventVar("NormalizedSolarExtent", normSolarExtent);
   normSolarExtent.setName("NormalizedSolarExtent");

   InEvent.getEventVar("L1_SCRad", radiusSC);
   radiusSC.setName("L1_SCRad");

   InEvent.getEventVar("L1_DopplerShift", doppler);
   doppler.setName("L1_DopplerV");

   InEvent.getEventVar("L1_CurvatureRadius", radiusC);
   radiusC.setName("L1_CurvatureRadius");

   InEvent.getEventVar("L1_Drift_Signal_Ref", signalExo);
   signalExo.setName("L1_VExo");

   InEvent.getEventVar("L1_RefractionAngles", angleRefrSolar);

   InEvent.getEventVar("L1_RefractionTime", refAngTime);
   refAngTime.setName("L1_RefractionTime");

   InEvent.getEventVar("SolarShrinkage", solarShrinkageSolar);

   //InEvent.getEventVar("L1_Drift_Time_Ref", exoTime);
   //exoTime.setName("L1_timeVExo");

   //InEvent.getEventVar("L1_SolarLineOfSight", losSun);
   //losSun.setName("L1_SolarLineOfSight");

   //Initialize Remaining EventVars
   angleImpact.setValueConst(MISSINGVAL);
   angleImpact.setName("L1_AngleImpact");
   angleImpact.setUnits("Radians");
   angleImpact.setDescription("Calculated Modeled FOV Impact Angle");

   angleImpactEdge.setValueConst(MISSINGVAL);
   angleImpactEdge.setName("L1_AngleImpactEdge");
   angleImpactEdge.setUnits("Radians");
   angleImpactEdge.setDescription("Calculated Observed Edge Impact Angle");

   angleRefr.setValueConst(MISSINGVAL);
   angleRefr.setName("L1_RefractionAngles");
   angleRefr.setUnits("Radians");
   angleRefr.setDescription("Calculated Modeled Refraction Angle");

   radiusSC_Shifted.setValueConst(MISSINGVAL);
   radiusSC_Shifted.setName("L1_SCRad_TimeShifted");

   angleGeom.setValueConst(MISSINGVAL);
   angleGeom.setName("L1_AngleGeom");

   angleGeomEdge.setValueConst(MISSINGVAL);
   angleGeomEdge.setName("Tmp_AngleGeomEdge");

   angleGeomEdgeBottom.setValueConst(MISSINGVAL);
   angleGeomEdgeBottom.setName("Tmp_AngleGeomEdgeBottom");

   zImpact.setValueConst(MISSINGVAL);
   zImpact.setName("L1_SimulatedAngleGeom");

   //Store Event Type
   if(zGeom[2] > zGeom[1]) eventType = 1;
   else eventType = 2;

   //signalExo = 1;
   //signalExo = signalExoVar[band];
   //for(int i=0; i<corrBandSignal.size()-1; i++)
   //  if(zGeom[i] < 153.0 && zGeom[i] > 152.0){
   //     signalExo = corrBandSignal[i];
   //     i = corrBandSignal.size()+1;
   //}
   corrBandSignal = corrBandSignal / signalExo[band];
   cout << "EventType:  " << eventType << endl;
   if(logDebug) cout << "Exo Var:  " << signalExo[band] << endl;

   if(plotInputParams && band == 12){
      string title;
      //title = "Interpolate Angle " + iteration;
      altRegTime.setAxisRange();
      altRegTime.setDescription("Observation Time");
      altRegTime.setUnits("Sec");

      corrBandSignal.setAxisRange();
      corrBandSignal.setDescription("Observation Transmission");
      corrBandSignal.setUnits("Trans");
      title = "Observed Band Input";
      corrBandSignal.Plot("Altitude Registration Input",title,altRegTime);

      zGeom.setAxisRange();
      title = "Observed Z Input";
      zGeom.Plot("Altitude Registration Input",title,altRegTime);

      zGeom.setAxisRange();
      title = "Observed Correction Band";
      corrBandSignal.Plot("Altitude Registration Input",title,zGeom);

      angleRefrSolar.setAxisRange();
      refAngTime.setAxisRange();
      title = "Refraction Angle";
      angleRefrSolar.Plot("Altitude Registration Input",title,refAngTime);
      //angleRefrSolar.Plot("Altitude Registration Input",title,altRegTime);

      solarShrinkageSolar.setAxisRange();
      refAngTime.setAxisRange();
      title = "Solar Shrinkage";
      solarShrinkageSolar.Plot("Altitude Registration Input",title,refAngTime);
      //angleRefrSolar.Plot("Altitude Registration Input",title,altRegTime);

      lockdownAngle.setAxisRange();
      title = "Observed Lockdown Input";
      lockdownAngle.Plot("Altitude Registration Input",title,altRegTime);

      lockdownAngleAz.setAxisRange();
      title = "Observed Lockdown Azimuthal Input";
      lockdownAngleAz.Plot("Altitude Registration Input",title,altRegTime);

      fpaSolarExtent.setAxisRange();
      title = "FPA Solar Extent Input";
      fpaSolarExtent.Plot("Altitude Registration Input",title,altRegTime);

      normSolarExtent.setAxisRange();
      title = "FPA Normalized Solar Extent Input";
      normSolarExtent.Plot("Altitude Registration Input",title,altRegTime);

      solarHighEdgeEl.setAxisRange();
      title = "FPA Solar High Elevation Edge Input";
      solarHighEdgeEl.Plot("Altitude Registration Input",title,altRegTime);

      solarLowEdgeEl.setAxisRange();
      title = "FPA Solar Low Elevation Edge Input";
      solarLowEdgeEl.Plot("Altitude Registration Input",title,altRegTime);

      solarHighEdgeAz.setAxisRange();
      title = "FPA Solar High Azimuthal Edge Input";
      solarHighEdgeAz.Plot("Altitude Registration Input",title,altRegTime);

      solarLowEdgeAz.setAxisRange();
      title = "FPA Solar Low Azimuthal Edge Input";
      solarLowEdgeAz.Plot("Altitude Registration Input",title,altRegTime);

      radiusSC.setAxisRange();
      title = "Observed S/C Radius Input";
      radiusSC.Plot("Altitude Registration Input",title,altRegTime);

      doppler.setAxisRange();
      title = "Observed Doppler Input";
      doppler.Plot("Altitude Registration Input",title,altRegTime);

      title = "Observed Correction Band Input";
      zGeom.Plot("Altitude Registration Input",title,corrBandSignal);

      title = "Observed Lockdown Angle Input";
      zGeom.Plot("Altitude Registration Input",title,lockdownAngle);

      //title = "Observed/Measured Refraction Angle Input";
      //zGeom.Plot("Altitude Registration Input",title,angleRefr);

      title = "Observed SCRadius Input";
      zGeom.Plot("Altitude Registration Input",title,radiusSC);

      title = "Observed Doppler Input";
      zGeom.Plot("Altitude Registration Input",title,doppler);

   }

   if(altRegType == 3 && band == 12)
      band = tmpBand;

   return;

}

void AltReg::setConfigParameters(ConfigFile& C, int regNum)
//!< Reads Config File for Registration Parameters
//!< Stores Information into AltReg Class Object Private Variables
{
#ifdef LOGOUT
   cout << "In Function AltReg::setConfigParameters(ConfigFile& C)" << endl;
#endif

    vector<int> temp;
    vector<float> dtemp;

    _pixelaverage21 = C.GetStr("AltitudeRegistration","PixelAverage21");
    _pixelaverage33 = C.GetStr("AltitudeRegistration","PixelAverage33");
    _NormalizedPosition = C.GetStr("AltitudeRegistration","NormalizedPosition");

   //Otherwise uses default Values used in Constructor
   try {
      temp  = C.GetIntValues("AltitudeRegistration", "RegistrationBand");
      band = temp[regNum];
      band--;
      methodComparisonBands.resize(temp.size());
      for(int i = 0; i<temp.size(); i++)
         methodComparisonBands[i] = double (temp[i]);
   }
   catch(...)
   {
      band = 12;
      methodComparisonBands.resize(1);
      methodComparisonBands[0] = double (band);
      cout << "Registration Band Set to Default Value:  " << band << endl;
   }

   try {
      temp  = C.GetIntValues("AltitudeRegistration", "AltRegType");
      altRegType = temp[regNum];
      methodComparisonZValues.resize(temp.size());
      //methodComparisonBands.resize(temp.size());
      methodComparison.resize(temp.size());
      for(int i = 0; i<temp.size(); i++)
         methodComparison[i] = double (temp[i]);

   }
   catch(...)
   {
      altRegType = 2;
      methodComparison.resize(1);
      methodComparisonZValues.resize(1);
      //methodComparisonBands.resize(1);
      methodComparison[0] = double (altRegType);
      cout << "AltRegType Set to Default:  " << altRegType << endl;
   }

   try {
      dtemp  = C.GetRealValues("AltitudeRegistration", "FOVBandOffsetValuesSR");
//cout << " this is band " << band << endl;
      bandOffset_SR = dtemp.at(band);
      cout << "BandOffset_SR Set to INI Value:  " << bandOffset_SR << endl;
   }
   catch(...)
   {
      bandOffset_SR = 0.00;
      cout << "BandOffset_SR Set to Default:  " << bandOffset_SR << endl;
   }

   try {
      dtemp  = C.GetRealValues("AltitudeRegistration", "FOVBandOffsetValuesSS");
      bandOffset_SS = dtemp.at(band);
      cout << "BandOffset_SS Set to INI Value:  " << bandOffset_SS << endl;
   }
   catch(...)
   {
      bandOffset_SS = 0.00;
      cout << "BandOffset_SS Set to Default:  " << bandOffset_SS << endl;
   }





   try {
      plotGridData = C.GetInt("AltitudeRegistration", "PlotGriddedEventVars");
   }
   catch(...)
   {
      plotGridData = 0;
   }

   try {
      plotDebug = C.GetInt("AltitudeRegistration", "PlotDebug");
   }
   catch(...)
   {
      plotDebug = 0;
   }

//   try {
      fovFileName = C.GetStr("AltitudeRegistration", "FOVFile");
//   }
//   catch(...)
//   {
//      sprintf(fovFileName, "../Data/FOV/sofie_fov_V1.1_elevation.txt");
//   }

   try {
      plotGeomAngles = C.GetInt("AltitudeRegistration", "PlotGeometricAngles");
   }
   catch(...)
   {
      plotGeomAngles = 0;
   }

   try {
      plotConvolve = C.GetInt("AltitudeRegistration", "PlotConvolution");
   }
   catch(...)
   {
      plotConvolve = 0;
   }

   try {
      plotSLDC = C.GetInt("AltitudeRegistration", "PlotSLDC");
   }
   catch(...)
   {
      plotSLDC = 0;
   }

   try {
      plotModelCalcIt = C.GetInt("AltitudeRegistration", "PlotIteratedModelCalc");
   }
   catch(...)
   {
      plotModelCalcIt = 0;
   }

   try {
      plotModelCalcFinal = C.GetInt("AltitudeRegistration", "PlotModelCalc");
   }
   catch(...)
   {
      plotModelCalcFinal = 0;
   }

   try {
      plotDifferences = C.GetInt("AltitudeRegistration", "PlotDifferences");
   }
   catch(...)
   {
      plotDifferences = 0;
   }

   try {
      plotDifferencesIt = C.GetInt("AltitudeRegistration", "PlotIteratedDifferences");
   }
   catch(...)
   {
      plotDifferencesIt = 0;
   }

   try {
      plotCorrectionBand = C.GetInt("AltitudeRegistration", "PlotBandSignal");
   }
   catch(...)
   {
      plotCorrectionBand = 0;
   }

   try {
      plotAllBands = C.GetInt("AltitudeRegistration", "PlotAllBands");
   }
   catch(...)
   {
      plotAllBands = 0;
   }

   try {
      plotZImpact = C.GetInt("AltitudeRegistration", "PlotZ");
   }
   catch(...)
   {
      plotZImpact = 0;
   }

   try {
      doConvolution = C.GetInt("AltitudeRegistration", "ConvolveFOV");
   }
   catch(...)
   {
      doConvolution = 1;
   }

   try {
      doNonLinearCorr = C.GetInt("AltitudeRegistration", "AddNonLinearity");
   }
   catch(...)
   {
      doNonLinearCorr = 1;
   }

   try {
      doNonLinearCorrCenterSums = C.GetInt("AltitudeRegistration", "CorrectNLCenterSums");
   }
   catch(...)
   {
      doNonLinearCorrCenterSums = 0;
   }

   try {
      doSmoothLockdown = C.GetInt("AltitudeRegistration", "SmoothLockdown");
   }
   catch(...)
   {
      doSmoothLockdown = 0;
   }

   try {
      logDebug = C.GetInt("AltitudeRegistration", "LogDebug");
   }
   catch(...)
   {
      logDebug = 0;
   }

   try {
      logGriddedRefraction = C.GetInt("AltitudeRegistration", "LogRefraction");
   }
   catch(...)
   {
      logGriddedRefraction = 0;
   }

   try {
      refrRegNum = C.GetInt("AltitudeRegistration", "RefractionProfiles");
   }
   catch(...)
   {
      refrRegNum = 5;
   }

   try {
      plotSimData = C.GetInt("AltitudeRegistration", "PlotModel");
   }
   catch(...)
   {
      plotSimData = 0;
   }

   try {
      initTimeOffset = C.GetReal("AltitudeRegistration", "Init_Time_Offset");
   }
   catch(...)
   {
      initTimeOffset = 0.02;
      cout << "Initial TimeOffset Set to Default Value:  " << initTimeOffset << endl;
   }

   try {
      maxRefrAlt = C.GetReal("AltitudeRegistration", "RefractionMaxAlt");
   }
   catch(...)
   {
      maxRefrAlt = 30.0;
      cout << "Maximum Refraction Altitude Set to Default Value:  " << maxRefrAlt << endl;
   }

   try {
      zCompareAlt = C.GetReal("AltitudeRegistration", "ComparisonAltitude");
   }
   catch(...)
   {
      zCompareAlt = 50.0;
      cout << "Comparison Altitude Set to Default Value:  " << zCompareAlt << endl;
   }

   try {
      MAXFINALTIMEOFFSET = C.GetReal("AltitudeRegistration", "Maximum_Time_Offset");
   }
   catch(...)
   {
      MAXFINALTIMEOFFSET = 2.0;
      cout << "Maximum Final TimeOffset Set to Default Value:  " << MAXFINALTIMEOFFSET << endl;
   }

   try {
      convCriteria = C.GetReal("AltitudeRegistration", "Convergence_Criteria");
   }
   catch(...)
   {
      convCriteria = 0.1;
      cout << "Convergence Criteria Set to Default Value:  " << convCriteria << endl;
   }
      dRMS = convCriteria + 5.0;

   try {
      maxIterations = C.GetInt("AltitudeRegistration", "Maximum_Iterations");
   }
   catch(...)
   {
      maxIterations = 10;
      cout << "Maximum Iterations Set to Default Value:  " <<  maxIterations << endl;
   }

   try {
      logModelData = C.GetInt("AltitudeRegistration", "LogCreateModelGrid");
   }
   catch(...)
   {
      logModelData = 0;
   }

   try {
      plotFunctions = C.GetInt("AltitudeRegistration", "PlotFunctionIO");
   }
   catch(...)
   {
      plotFunctions = 0;
   }

   try {
      plotLockdownFunc = C.GetInt("AltitudeRegistration", "PlotLockdownFunction");
   }
   catch(...)
   {
      plotLockdownFunc = 0;
   }

   try {
      plotRefrReg = C.GetInt("AltitudeRegistration", "PlotRefractionRegistration");
   }
   catch(...)
   {
      plotRefrReg = 0;
   }

   try {
      plotSunSensor = C.GetInt("AltitudeRegistration", "PlotSunSensor");
   }
   catch(...)
   {
      plotSunSensor = 0;
   }

   try {
      plotNonLinearity = C.GetInt("AltitudeRegistration", "PlotNonLinearity");
   }
   catch(...)
   {
      plotNonLinearity = 0;
   }

   try {
      plotInputParams = C.GetInt("AltitudeRegistration", "PlotInputParameters");
   }
   catch(...)
   {
      plotInputParams = 0;
   }

   try {
      gridSpacing = C.GetReal("AltitudeRegistration", "GridSpacingInKM");
   }
   catch(...)
   {
      gridSpacing = 0.2;
      cout << "Grid Spacing Set to Default Value:  " <<  gridSpacing << endl;
   }
//Added 20070803
   try {
      gridRange[0] = C.GetReal("AltitudeRegistration", "GridRangeLower");
      gridRange[1] = C.GetReal("AltitudeRegistration", "GridRangeUpper");
      if(gridRange[0] >= gridRange[1] - gridSpacing) throw;
      presetGrid = 1;
   }
   catch(...)
   {
      gridRange[0] = 3.0;
      gridRange[1] = 180.0;
      presetGrid = 0;
      cout << "Grid Range Set to Default Value:  [ " << gridRange[0] << ", " << gridRange[1]  << endl;
   }

   try {
      //rangeMethod = C.GetInt("AltitudeRegistration", "ComparisonMethod");
      altRange[0] = C.GetReal("AltitudeRegistration", "ComparisonRangeLower");
      altRange[1] = C.GetReal("AltitudeRegistration", "ComparisonRangeUpper");
      if(altRange[0] < 2.0 && altRange[1] < 2.0) rangeMethod = 2;
      else rangeMethod = 1;

      if(rangeMethod == 1 && (altRange[0] >= altRange[1] - MINRANGE1)){
         cout << "WARNING:  Improper AltReg Altitude Range:  { " << altRange[0] << ", " << altRange[1] << " }" << endl;
         throw;
      }
      if(rangeMethod == 2 && (altRange[0] >= altRange[1] - MINRANGE2)){
         cout << "WARNING:  Improper AltReg Transmission Range:  { " << altRange[0] << ", " << altRange[1] << " }" << endl;
         cout << "          Will Use Default Altitude Range." << endl;
         throw;
      }
      presetRange = 1;
   }
   catch(...)
   {
      rangeMethod = 1;
      altRange[0] = 35.0;
      altRange[1] = 45.0;
      presetRange = 0;
      cout << "Altitude Comparison Range Set to Default Value:  [ " << altRange[0] << ", " << altRange[1]  << " ]" << endl;
   }

   if(band >= numBands && altRegType == 2){
      //band = 12;
      cout << "Illegal Registration Band: " << band+1 << ".  There are only " << numBands << " Bands.  Right?" << endl;
      band = 12;
   }

   if(band >= numBands+8 && altRegType == 3){
      //band = 12;
      cout << "Illegal Registration Band: " << band+1 << ".  Sunsensor only goes to " << numBands+8 << " Bands.  Right?" << endl;
      band = 31;
   }



   if(fabs(initTimeOffset) >= 1.0){
      cout << "That's a Large Time Offset: " << initTimeOffset << ".  ";
      initTimeOffset = 0.5;
      cout << "Resetting to " <<  initTimeOffset << " seconds.  Please keep Initial Offset Less than 1.0 seconds." << endl;
      //initTimeOffset = 0.0;
   }

   //Need to Figure Out how to store Range in Config File and Retrieve
   //Until Then Use default Values used in SetConfig
   //altRange = C.getRealArray("Altitude Registration", "Registration Range", num); //Might have to assign later
   //gridRange = C.getRealArray("Altitude Registration", "Level1 Grid Range", num); //Might have to assign later
   //gridSpacing = C.getRealArray("Altitude Registration", "Level1 Grid Spacing", num); //Might have to assign later
   //int num = 2;

   return;

}

//void AltReg::calcAngleGeomCenter(EventVar<double> R)
void AltReg::calcAngleGeomCenter()
//void calcAngleGeomCenter(EventVar& R, EventVar& Rs)
//!< 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
{
#ifdef LOGOUT
   //cout << "In Function AltReg::calcAngleGeomCenter(EventVar<double> R)" << endl;
   cout << "In Function AltReg::calcAngleGeomCenter()" << endl;
#endif

   //zImpact = zGeom;
   //angleGeom = acos((R[0] + xAltitude) / Rs);
   //cout << "zGeomSize:  " << zGeom.size();
   angleGeom = acos((radiusC[0] + zGeom) / radiusSC);

   if(plotGeomAngles){
      angleGeom.setName("Angle Geometric Center");
      angleGeom.setAxisRange(0.3, 0.5);
      plotLockdownIt.addEventVar(angleGeom);
      angleGeom.Plot("AltReg::calcAngleGeomCenter", "vs Time", altRegTime);

   }

   return;

}

//void AltReg::calcAngleGeomEdge(EventVar<double> SolarExtent)
void AltReg::calcAngleGeomEdge()
//!< Adjusts the Angle from the Geometric Center of the Sun
//!< to the Geometric Edge by offsetting the solar extent
{
#ifdef LOGOUT
   cout << "In Function AltReg::calcAngleGeomEdge(EventVar<double> SolarExtent)" << endl;
#endif

   if(logDebug) cout << "SolExtent:  " << exoSolarExtent[0] << endl;

     angleGeomEdge = angleGeom;
     angleGeomEdgeBottom = angleGeom;
     angleGeomEdge -= exoSolarExtent[0] * 0.5;        //Top Edge for Pressure Registration
     angleGeomEdgeBottom += exoSolarExtent[0] * 0.5;

   if(plotGeomAngles){
      angleGeomEdge.setName("Angle Geometric Edge");
      angleGeomEdge.setAxisRange(0.3, 0.5);
      angleGeomEdge.Plot("Altitude Registration","Angle Geometric Edge",altRegTime);
      plotLockdownIt.addEventVar(angleGeomEdge);
   }

   return;
}

double AltReg::getConvergence()
//!< Returns value stored in Altreg.currConvergence
{
#ifdef LOGOUT
   cout << "In Function AltReg::getConvergence()" << endl;
#endif

   return currConverge;
}

void AltReg::createAltitudeGrid(Event& currEvent)
//!< Places all data on 200 m grid ... Configurable in Config file
{
#ifdef LOGOUT
   cout << "In Function AltReg::createAltitudeGrid(Event& currEvent)" << endl;
#endif

   int i, j, jlast;
   int si, ei;
   unsigned long altRegTimeSize = altRegTime.size();
   char gridName[23];
   string descript;
   string name;

   EventVar<double> EvControl(zImpact.size());
   EventVar<double> EvTarget(zImpact.size());
   EventVar<double> gridTime("gridTime", "Gridded Time", "Secs", MISSINGVAL, gridNum);
   EventVar<double> gridAngleImpact("gridAngleImpact", "Gridded Impact Angle", "Radians", MISSINGVAL, gridNum);
   EventVar<double> gridAngleGeom("gridAngleGeom", "Gridded Geometric Angle", "Radians", MISSINGVAL, gridNum);
   EventVar<double> gridSSTransmission("SS_CompositeTransmission","Gridded Sunsensor Transmission", " " ,  MISSINGVAL, gridNum);
   EventVar<double> gridAngleRefr("gridAngleRefraction", "Gridded Refraction Angle", "Radians", MISSINGVAL, gridNum);
   EventVar<double> gridZImpact("gridImpact", "Gridded Impact Z", "Km", MISSINGVAL, gridNum);
   EventVar<double> gridDoppler("gridDoppler", "Gridded Doppler Velocity", "Km/sec", MISSINGVAL, gridNum);
   EventVar<double> gridRSC("gridRSC", "Gridded Spacecraft Radius", "Km", MISSINGVAL, gridNum);
   EventVar<double> gridLockdownEl("gridAngleLockdownEL", "Gridded Elevation Lockdown Angle", "Radians", MISSINGVAL, gridNum);
   EventVar<double> gridLockdownAz("gridAngleLockdownAZ", "Gridded Azimuthal Lockdown Angle", "Radians", MISSINGVAL, gridNum);
   EventVar<double> gridSolarExtent("gridSolarExtent", "Gridded Solar Extent", "Radians", MISSINGVAL, gridNum);
   EventVar<double> gridSolarHighEdgeEl("gridSolarHighElevationEdge", "Gridded Solar High Elevation Edge Location", "Radians", MISSINGVAL, gridNum);
   EventVar<double> gridSolarLowEdgeEl("gridSolarLowElevationEdge", "Gridded Solar Low Elevation Edge Location", "Radians", MISSINGVAL, gridNum);
   EventVar<double> gridSolarHighEdgeAz("gridSolarHighAzimuthEdge", "Gridded Solar High Azimuthal Edge Location", "Radians", MISSINGVAL, gridNum);
   EventVar<double> gridSolarLowEdgeAz("gridSolarLowAzimuthEdge", "Gridded Solar Low Azimuthal Edge Location", "Radians", MISSINGVAL, gridNum);
   EventVar<double> gridSignal(MISSINGVAL, gridNum);
   EventVarVect<double> gridSignals("gridSignals", "Gridded Band Transmissions");
   for(i=0; i<numBands; i++){
      sprintf(gridName, "Band%02i", i);
      gridSignal.setName(gridName);
      gridSignals.addEventVar(gridSignal);
   }
   EventVar<double> availGridRange("PressReg_GridRange", "Gridded Data Range", 2);
   availGridRange[0] = gridRange[0];
   availGridRange[1] = gridRange[1];

   cout << "eventType:  " << eventType << endl;

   // gregsVars
   int startIndex = 300;
   int endIndex = 1300;
   cout << "Starttime\tEndtime\tStartAlt\tEndAlt" << endl;
   cout << altRegTime[startIndex] << "\t" << altRegTime[endIndex] << "\t" << 
        zImpact[startIndex] << "\t" << zImpact[endIndex] << endl;

   //Finds minAltIndex and maxAltIndex of zImpact Grid
   getGriddedIndices();
   setGriddedIndices(availGridRange, si, ei);
   gridAltitude(gridZImpact, si, ei);
   EvControl = zImpact;
   EvTarget  = altRegTime;
   gridData(EvControl, EvTarget, gridTime, si, ei);

   EvTarget  = angleImpact;
   gridData(EvControl, EvTarget, gridAngleImpact, si, ei);

   EvTarget  = angleGeom;
   gridData(EvControl, EvTarget, gridAngleGeom, si, ei);

   EvTarget  = doppler;
   gridData(EvControl, EvTarget, gridDoppler, si, ei);

   EvTarget  = radiusSC;
   gridData(EvControl, EvTarget, gridRSC, si, ei);

   EvTarget  = lockdownAngle;
   gridData(EvControl, EvTarget, gridLockdownEl, si, ei);

   EvTarget  = lockdownAngleAz;
   gridData(EvControl, EvTarget, gridLockdownAz, si, ei);

   //EvTarget  = fpaSolarExtent;
   EvTarget  = normSolarExtent;
   EvTarget *= exoSolarExtent[0];
   gridData(EvControl, EvTarget, gridSolarExtent, si, ei);

   EvTarget  = solarHighEdgeEl;
   gridData(EvControl, EvTarget, gridSolarHighEdgeEl, si, ei);

   EvTarget  = solarHighEdgeAz;
   gridData(EvControl, EvTarget, gridSolarHighEdgeAz, si, ei);

   EvTarget  = solarLowEdgeEl;
   gridData(EvControl, EvTarget, gridSolarLowEdgeEl, si, ei);

   EvTarget  = solarLowEdgeAz;
   gridData(EvControl, EvTarget, gridSolarLowEdgeAz, si, ei);

   EvTarget  = ssTran;
   gridData(EvControl, EvTarget, gridSSTransmission, si, ei);

   cout << "NumBands:  "  << numBands << endl;
   for(j=0; j<numBands; j++){
      //cout << j << endl;
      EvTarget  = allSignals[j];
      //gridName = allSignals[j].getName();
      //EvTarget.setName(gridName);
      gridData(EvControl, EvTarget, gridSignal, si, ei);
      sprintf(gridName, "GriddedSignal_Band%02i", j);
      //cout << j << endl;
      gridSignals[j] = gridSignal;
      gridSignals[j].setName(gridName);
      //gridSignals.addEventVar(gridSignal);
   }

   //sprintf(gridName, "AngIBottom_%02i", band);
   //angleImpactEdgeBottom.writeVar(gridName); 

   zImpactEdgeBottom = radiusSC;
   zImpactEdgeBottom *= cos(angleImpactEdgeBottom);
   zImpactEdgeBottom -= radiusC[0];

   //angleRefr.Plot("AltitudeRegistration", "CreateAltitudeGrid", zImpactEdgeBottom);
   //angleRefr.Plot("AltitudeRegistration", "CreateAltitudeGrid", altRegTime);

   si = -1;
   ei = -1;
   putMissingValues(zImpactEdgeBottom, EVENTVAR_ALTMIN, EVENTVAR_ALTMAX);
   EvControl = zImpactEdgeBottom;
   EvTarget  = angleRefr;

   gridData(EvControl, EvTarget, gridAngleRefr, si, ei);

   writeToEvent(currEvent, gridTime);
   writeToEvent(currEvent, gridAngleImpact);
   writeToEvent(currEvent, gridAngleRefr);
   writeToEvent(currEvent, gridLockdownEl);
   writeToEvent(currEvent, gridLockdownAz);
   writeToEvent(currEvent, gridSolarExtent);
   writeToEvent(currEvent, gridSolarHighEdgeEl);
   writeToEvent(currEvent, gridSolarHighEdgeAz);
   writeToEvent(currEvent, gridSolarLowEdgeEl);
   writeToEvent(currEvent, gridSolarLowEdgeAz);
   writeToEvent(currEvent, gridDoppler);
   writeToEvent(currEvent, gridRSC);
   writeToEvent(currEvent, gridZImpact);
   writeToEvent(currEvent, availGridRange);

//   if(currEvent.EventVarExists(gridSSTransmission.getName()) ) 
//     currEvent.replaceEventVar(gridSSTransmission);
//   else
      writeToEvent(currEvent, gridSSTransmission);

   name = gridSignals.getName();
   descript = gridSignals.getDescription();
   if(currEvent.EventVarExists(name)){
      cout << "Replacing EVV " << name << ": " << descript << endl;
      currEvent.replaceEventVar(gridSignals);
   }
   else {
      cout << "Adding EVV " << name << ": " << descript << endl;
      currEvent.addEventVar(gridSignals);
   }

   if(logGriddedRefraction){
     cout << "Gridded Calculated Refraction" << endl;
     logGridData(gridAngleRefr, gridZImpact);
   }

   //gridCenterSums(currEvent);

//Plot Gridded Data Flag Set In INI File
   if(plotGridData){
      char subtitle[64];


      cout << "Plotting Gridded Data in CreateAltitudeGrid" << endl;
      EventVar<double> tmpRefr(gridAngleImpact.size());
      EventVarVect<double> refrPlot;
      tmpRefr = gridAngleGeom;
      tmpRefr -= gridAngleImpact;
      tmpRefr.setName("Band CO2 Refraction:  Geom-Impact");
      refrPlot.addEventVar(gridAngleRefr);
      refrPlot.addEventVar(tmpRefr);

      EventVar<double> rangeX(2);
      rangeX[0] = 0;
      rangeX[1] = 1;

      //timeArray -= ephStart;
      //timeArray *= 86400.0;
      gridTime.setUnits("Secs");

      gridTime.setAxisRange();
      gridAngleImpact.setAxisRange();
      gridAngleRefr.setAxisRange();
      gridLockdownEl.setAxisRange();
      gridLockdownAz.setAxisRange();
      gridSolarExtent.setAxisRange();
      gridSolarHighEdgeEl.setAxisRange();
      gridSolarHighEdgeAz.setAxisRange();
      gridSolarLowEdgeEl.setAxisRange();
      gridSolarLowEdgeAz.setAxisRange();
      gridZImpact.setAxisRange(-100.0, 300.0);
      gridRSC.setAxisRange(6800.0, 7000.0);
      gridDoppler.setAxisRange(-10.0, 10.0);
      rangeX.setAxisRange();

      sprintf(subtitle, "Event %05i, Band %02i:  Impact Angle", eventType, band+1);
      gridZImpact.Plot("Altitude Registration",subtitle,gridAngleImpact);
      sprintf(subtitle, "Event %05i, Band %02i:  Refraction Angle", eventType, band+1);
      gridZImpact.Plot("Altitude Registration",subtitle,gridAngleRefr);
      sprintf(subtitle, "Event %05i, Band %02i:  Lockdown Angle", eventType, band+1);
      gridZImpact.Plot("Altitude Registration",subtitle,gridLockdownEl);
      sprintf(subtitle, "Event %05i, Band %02i:  Lockdown Azimuth Angle", eventType, band+1);
      gridZImpact.Plot("Altitude Registration",subtitle,gridLockdownAz);
      sprintf(subtitle, "Event %05i, Band %02i:  FPA Solar Extent", eventType, band+1);
      gridZImpact.Plot("Altitude Registration",subtitle,gridSolarExtent);
      sprintf(subtitle, "Event %05i, Band %02i:  Solar High Elevation Edge", eventType, band+1);
      gridZImpact.Plot("Altitude Registration",subtitle,gridSolarHighEdgeEl);
      sprintf(subtitle, "Event %05i, Band %02i:  Solar High Azimuthal Edge", eventType, band+1);
      gridZImpact.Plot("Altitude Registration",subtitle,gridSolarHighEdgeAz);
      sprintf(subtitle, "Event %05i, Band %02i:  Solar Low Elevation Edge", eventType, band+1);
      gridZImpact.Plot("Altitude Registration",subtitle,gridSolarLowEdgeEl);
      sprintf(subtitle, "Event %05i, Band %02i:  Solar Low Azimuthal Edge", eventType, band+1);
      gridZImpact.Plot("Altitude Registration",subtitle,gridSolarLowEdgeAz);
      sprintf(subtitle, "Event %05i, Band %02i:  Impact Altitude Z", eventType, band+1);
      gridZImpact.Plot("Altitude Registration",subtitle,gridTime);
      sprintf(subtitle, "Event %05i, Band %02i:  Spacecraft Radius", eventType, band+1);
      gridZImpact.Plot("Altitude Registration",subtitle,gridRSC);
      sprintf(subtitle, "Event %05i, Band %02i:  Doppler Velocity", eventType, band+1);
      gridZImpact.Plot("Altitude Registration",subtitle,gridDoppler);
      sprintf(subtitle, "Event %05i, Band %02i:  Grid Range", eventType, band+1);
      availGridRange.Plot("Altitude Registration",subtitle,rangeX);
      sprintf(subtitle, "Event %05i, Band %02i:  Compare Refraction Angles", eventType, band+1);
      refrPlot.Plot("Altitude Registration",subtitle,gridZImpact);
      if(plotAllBands){
         for(j=0; j<numBands; j++){
            sprintf(subtitle, "Event %05i, Band %02i:  Gridded Signal", eventType, band+1);
	    gridSignals[j].setAxisRange();
	    gridSignals[j].setName("Signal");
            gridZImpact.Plot("Altitude Registration",subtitle,gridSignals[j]);
         }
      }
      else {
	gridSignals[band].setAxisRange();
	gridSignals[band].setName("Signal");
        sprintf(subtitle, "Event %05i, Band %02i:  Gridded Signal", eventType, band+1);
        //gridSignals[band].Plot("Altitude Registration","Signal Band",gridTime);
        gridZImpact.Plot("Altitude Registration",subtitle,gridSignals[band]);
      }

   }

   return;

}

//void AltReg::recreateAltitudeGrid(Event& currEvent, Config& currCfg, EventVar<double> &zRef)
void AltReg::recreateAltitudeGrid(Event& currEvent, EventVar<double> zRef)
//!< Place recalculated data on 200 m grid
{
#ifdef LOGOUT
   cout << "In Function AltReg::recreateAltitudeGrid(Event& currEvent)" << endl;
#endif

   int si, ei;
   unsigned long altRegTimeSize = altRegTime.size();
   //char gridName[20];
   EventVar<double> realZImpact(altRegTimeSize);
   //string descript;
   //string name;

   realZImpact = zImpact;
   zImpact = zRef;

   EventVar<double> EvControl(zImpact.size());
   EventVar<double> EvTarget(zImpact.size());
   EventVar<double> gridZImpact("gridImpact", "Gridded Impact Z", "Km", MISSINGVAL, gridNum);
   EventVar<double> gridAngleRefr("gridAngleRefraction", "Gridded Refraction Angle", "Radians", MISSINGVAL, gridNum);
   EventVar<double> gridLockdownEl("gridAngleLockdownEL", "Gridded Elevation Lockdown Angle", "Radians", MISSINGVAL, gridNum);
   EventVar<double> gridLockdownAz("gridAngleLockdownAZ", "Gridded Azimuthal Lockdown Angle", "Radians", MISSINGVAL, gridNum);
   EventVar<double> gridSolarExtent("gridSolarExtent", "Gridded Solar Extent", "Radians", MISSINGVAL, gridNum);
   EventVar<double> gridSolarHighEdgeEl("gridSolarHighElevationEdge", "Gridded Solar High Elevation Edge Location", "Radians", MISSINGVAL, gridNum);
   EventVar<double> gridSolarLowEdgeEl("gridSolarLowElevationEdge", "Gridded Solar Low Elevation Edge Location", "Radians", MISSINGVAL, gridNum);
   EventVar<double> gridSolarHighEdgeAz("gridSolarHighAzimuthEdge", "Gridded Solar High Azimuthal Edge Location", "Radians", MISSINGVAL, gridNum);
   EventVar<double> gridSolarLowEdgeAz("gridSolarLowAzimuthEdge", "Gridded Solar Low Azimuthal Edge Location", "Radians", MISSINGVAL, gridNum);
   EventVar<double> gridSolarShrinkage("gridSolarShrinkage", "Gridded Shrinkage of Solar Disk", "Radians", MISSINGVAL, gridNum);
   EventVar<double> availGridRange("PressReg_GridRange", "Gridded Data Range", 2);
   availGridRange[0] = gridRange[0];
   availGridRange[1] = gridRange[1];

   cout << "eventType:  " << eventType << endl;

   //Finds minAltIndex and maxAltIndex of zImpact Grid
   getGriddedIndices();
   setGriddedIndices(availGridRange, si, ei);
   gridAltitude(gridZImpact, si, ei);

   EvControl = zRef;
   EvTarget  = lockdownAngle;
   gridData(EvControl, EvTarget, gridLockdownEl, si, ei);

   EvTarget  = lockdownAngleAz;
   gridData(EvControl, EvTarget, gridLockdownAz, si, ei);

   //EvTarget  = fpaSolarExtent;
   EvTarget  = normSolarExtent;
   //EvTarget *= exoSolarExtent[0];
   gridData(EvControl, EvTarget, gridSolarExtent, si, ei);

   EvTarget  = solarHighEdgeEl;
   gridData(EvControl, EvTarget, gridSolarHighEdgeEl, si, ei);

   EvTarget  = solarHighEdgeAz;
   gridData(EvControl, EvTarget, gridSolarHighEdgeAz, si, ei);

   EvTarget  = solarLowEdgeEl;
   gridData(EvControl, EvTarget, gridSolarLowEdgeEl, si, ei);

   EvTarget  = solarLowEdgeAz;
   gridData(EvControl, EvTarget, gridSolarLowEdgeAz, si, ei);

   si = -1;
   ei = -1;
   putMissingValues(zImpactEdgeBottom, EVENTVAR_ALTMIN, EVENTVAR_ALTMAX);
   EvControl = zImpactEdgeBottom;
   EvTarget  = angleRefr;

   gridData(EvControl, EvTarget, gridAngleRefr, si, ei);

   EvTarget  = solarShrinkage;
   gridData(EvControl, EvTarget, gridSolarShrinkage, si, ei);

   writeToEvent(currEvent, gridAngleRefr);
   writeToEvent(currEvent, gridLockdownEl);
   writeToEvent(currEvent, gridLockdownAz);
   writeToEvent(currEvent, gridSolarExtent);
   writeToEvent(currEvent, gridSolarHighEdgeEl);
   writeToEvent(currEvent, gridSolarHighEdgeAz);
   writeToEvent(currEvent, gridSolarLowEdgeEl);
   writeToEvent(currEvent, gridSolarLowEdgeAz);
   writeToEvent(currEvent, gridSolarShrinkage);
   writeToEvent(currEvent, availGridRange);

   if(logGriddedRefraction){
     cout << "Gridded Calculated Refraction (2nd Invocation):" << endl;
     logGridData(gridAngleRefr, gridZImpact);
   }

//Plot Gridded Data Flag Set In INI File
   if(plotGridData){
      char subtitle[64];

      EventVar<double> rangeX(2);
      rangeX[0] = 0;
      rangeX[1] = 1;

      gridAngleRefr.setAxisRange();
      gridLockdownEl.setAxisRange();
      gridLockdownAz.setAxisRange();
      gridSolarExtent.setAxisRange();
      gridSolarHighEdgeEl.setAxisRange();
      gridSolarHighEdgeAz.setAxisRange();
      gridSolarLowEdgeEl.setAxisRange();
      gridSolarLowEdgeAz.setAxisRange();
      gridSolarShrinkage.setAxisRange();
      gridZImpact.setAxisRange(-100.0, 300.0);
      rangeX.setAxisRange();

      sprintf(subtitle, "Event %05i, Band %02i:  Refraction Angle (2nd)", eventType, band+1);
      gridZImpact.Plot("Altitude Registration",subtitle,gridAngleRefr);
      sprintf(subtitle, "Event %05i, Band %02i:  Lockdown Angle (2nd)", eventType, band+1);
      gridZImpact.Plot("Altitude Registration",subtitle,gridLockdownEl);
      sprintf(subtitle, "Event %05i, Band %02i:  Lockdown Azimuth Angle (2nd)", eventType, band+1);
      gridZImpact.Plot("Altitude Registration",subtitle,gridLockdownAz);
      sprintf(subtitle, "Event %05i, Band %02i:  FPA Solar Extent (2nd)", eventType, band+1);
      gridZImpact.Plot("Altitude Registration",subtitle,gridSolarExtent);
      sprintf(subtitle, "Event %05i, Band %02i:  Solar High Elevation Edge (2nd)", eventType, band+1);
      gridZImpact.Plot("Altitude Registration",subtitle,gridSolarHighEdgeEl);
      sprintf(subtitle, "Event %05i, Band %02i:  Solar High Azimuthal Edge (2nd)", eventType, band+1);
      gridZImpact.Plot("Altitude Registration",subtitle,gridSolarHighEdgeAz);
      sprintf(subtitle, "Event %05i, Band %02i:  Solar Low Elevation Edge (2nd)", eventType, band+1);
      gridZImpact.Plot("Altitude Registration",subtitle,gridSolarLowEdgeEl);
      sprintf(subtitle, "Event %05i, Band %02i:  Solar Low Azimuthal Edge (2nd)", eventType, band+1);
      gridZImpact.Plot("Altitude Registration",subtitle,gridSolarLowEdgeAz);
      sprintf(subtitle, "Event %05i, Band %02i:  Solar Shrinkage (2nd)", eventType, band+1);
      gridZImpact.Plot("Altitude Registration",subtitle,gridSolarShrinkage);
      sprintf(subtitle, "Event %05i, Band %02i:  Grid Range", eventType, band+1);
      availGridRange.Plot("Altitude Registration",subtitle,rangeX);
   }

   zImpact = realZImpact;

   return;
}


void AltReg::writeToEvent(Event& currEvent, EventVar<double> currEV)
//!< Writes EventVar to Event Object
//!< Replaces If Already Exists
{
#ifdef LOGOUT
   cout << "In Function AltReg::writeToEvent(Event& currEvent, EventVar<double> currEV)" << endl;
#endif

   string name;
   string descript;

   name = currEV.getName();
   descript = currEV.getDescription();
   if(currEvent.EventVarExists(name)){
      cout << "Replacing " << name << ": " << descript << endl;
      currEvent.replaceEventVar(currEV);
   }
   else {
      cout << "Adding " << name << ": " << descript << endl;
      currEvent.addEventVar(currEV);
   }

   return;

}

void AltReg::logGridData(EventVar<double> X, EventVar<double> Y)
{
   //char xName[128], yName[128];
   string xName, yName;
   char line[128];
   //double x, y;
   xName = X.getName();
   yName = Y.getName();
   cout << "Outputting Data" << endl;
   if(X.size() != Y.size()){
      cout << "Array Sizes Uneven in logGridData." << endl;
      cout << "   XSIZE:  " << X.size() << "  YSIZE:  " << Y.size() << endl;
      if(X.size() < Y.size()) cout << "   Will Only Output First " << X.size() << " Values." << endl;
      else cout << "   Will Only Output First " << Y.size() << " Values." << endl;
   }
   cout << xName << "\t" << yName << endl;
   for(int i=0; i<X.size() && i<Y.size(); i++){
      sprintf(line, "%13.6e\t%13.6e", X[i], Y[i]);
      cout << line << endl;
   }

   cout << endl << "End Of Output" << endl << endl;

   return;

}


void AltReg::gridAltitude(EventVar<double>& zAlt, int sInd, int eInd)
{
#ifdef LOGOUT
   cout << "In Function AltReg:::gridAltitude(EventVar<double>&, int, int)" << endl;
#endif

   double gridZ;

   for(int i=eInd; i>=sInd; i--){
      gridZ = gridRange[0] + i*gridSpacing;
      zAlt[i] = gridZ;
   }

   return;

}

void AltReg::gridData(EventVar<double> zAlt, EventVar<double> timeData, EventVar<double> &griddedData, int sInd, int eInd)
{
#ifdef LOGOUT
   cout << "In Function AltReg::gridData(EventVar<double>, EventVar<double>, EventVar<double>&, int, int)" << endl;
#endif

   int i,j;
   int jlast;
   string evName;

   double gridZ;
   double low, mid, high;
   int minTmp = -1;
   int maxTmp = -1;
   int imin, imax;

   evName = timeData.getName();
   cout << "Gridding " << evName << " data." << endl;

   if(sInd < 0 || eInd < 0){
      setGriddedIndices(zAlt, imin, imax, sInd, eInd);
      minTmp = minAltIndex;
      maxTmp = maxAltIndex;
      minAltIndex = imin;
      maxAltIndex = imax;
   }

   for(i=eInd; i>=sInd; i--){
      gridZ = gridRange[0] + i*gridSpacing;
      if(eventType == 1) {   //SR -- Start Low and Work Up
         //jlast = zImpact.size()-2;
         jlast = maxAltIndex;
         for(j=jlast; j>=minAltIndex; j--){
            //cout << "j:  " << j << "  zI[j]:  " << zImpact[j] << "  zI[j+1]:  "  << zImpact[j+1] << "  gZI: " <<  gridZImpact[i] << endl;
            if(zAlt[j] <= gridZ && zAlt[j+1] > gridZ){
               low = timeData[j];
               high = timeData[j+1];
               interpLine(gridZ, zAlt[j], zAlt[j+1], low, high, mid);
               griddedData[i] = mid;
               jlast = j;
               j = minAltIndex-1;
            }
         }
      }
      else {   //SS -- Start High and Work Down
         jlast = maxAltIndex;
         for(j = jlast; j<minAltIndex; j++){
            if(zAlt[j] >= gridZ && zAlt[j+1] < gridZ){
               low = timeData[j+1];
               high = timeData[j];
               interpLine(gridZ, zAlt[j+1], zAlt[j], low, high, mid);
               griddedData[i] = mid;
               jlast = j;
               j = minAltIndex+2;
            }
         }
      }
   }

   if(minTmp > 0 && maxTmp > 0){
      minAltIndex = minTmp;
      maxAltIndex = maxTmp;
   }

   return;

}

void AltReg::calcSunSensorRefraction(EventVar<double> angI, ModelData RSim, EventVar<double> &angR)
//!<  Create tau and angleImpact for CenterSumData
{
#ifdef LOGOUT
   cout << "In Function AltReg::calcSunSensorRefraction(EventVar<double> angI, ModelData RSim, EventVar<double> &angR)" << endl;
#endif

   EventVar<double> zI(radiusSC);
   int modelSize = RSim.zImpact.size();
   double modelMax, modelMin, modelMaxRefr, modelMinRefr;
   double zMin, zMax, arMin, arMax, arNew;


   zI *= cos(angI);
   zI -= radiusC[0];

   putMissingValues(zI, EVENTVAR_ALTMIN, EVENTVAR_ALTMAX);

   modelMax = RSim.zImpact[0];
   modelMin = RSim.zImpact[modelSize-1];
   modelMaxRefr = RSim.angleRefr[modelSize-1];

   cout << "Model Min, Max, MaxRefr:  " << modelMin << ", " << modelMax << ", " <<  modelMaxRefr << endl;

   for(int i=0; i<zI.size(); i++){

      if(zI[i] != MISSINGVAL){
         //TopEdgeCalculation
         if(zI[i] < modelMin){
            angR[i] = modelMaxRefr;
         }
         else if(zI[i] > modelMax){
            angR[i] = 0.0;
         }
         else {
            for(int j=0; j<modelSize-1; j++){

               zMax = RSim.zImpact[j];
               zMin = RSim.zImpact[j+1];
               if(zI[i] < zMax && zI[i] >= zMin){
                   //Interpolate On Impact Z
                   arMax = RSim.angleRefr[j];
                   arMin = RSim.angleRefr[j+1];
                   interpLine(zI[i], zMin, zMax, arMin, arMax, arNew);
                   //cout << "Z? , zMin, zMax, RefrMin, RefrMax, RefrNew:  " << zI[i] << ", " << zMin << ", " << zMax << ", ";
                   //cout << arMin << ", " << arMax << ", " << arNew << endl;
                   angR[i] = arNew;
                   j = modelSize+1;
               }
            }
         }
      }
      else
         angR[i] = MISSINGVAL;

   }

   return;
}

void AltReg::convertSolarSource(EventVar<double> &deltaAngle, EventVar<double>& SS)
//!<  Put Solar Source On Time Grid
{

   int i, evSize;
   EventVar<double> ave21;
   EventVar<double> ave33;
   EventVar<double> xaxis;
   double maxExt, minExt, minSS, maxSS;
   double tauMin, tauMax, aMin, aMax, tauNew;


   ave21.readVar(_pixelaverage21);
   ave33.readVar(_pixelaverage33);
   xaxis.readVar(_NormalizedPosition);
/*
   ave21.readVar("../Data/21PixelAverage.evr");
   ave33.readVar("../Data/33PixelAverage.evr");
   xaxis.readVar("../Data/ExtentNormalizedPosition.evr");
*/
   evSize = xaxis.size();

   xaxis *= exoSolarExtent[0];
   minExt = xaxis[0];
   maxExt = xaxis[evSize-1];
   minSS = ave33[0];
   maxSS = ave33[evSize-1];

   //cout << "SolarSourceModelExtent:  ( " << minExt << ", " << maxExt << " )" << endl;
   //cout << "SolarSourceModelValues:  ( " << minSS << ", " << maxSS << " )" << endl;
   //cout << "MIN/MAX LOCKINDEX:  " << minLockIndex << ", " << maxLockIndex << endl;


   for(i=0; i<minLockIndex; i++){
      deltaAngle[i] = minExt;
      SS[i] = MISSINGVAL;
   }
   for(i=minLockIndex; i<=maxLockIndex; i++){
     if(deltaAngle[i] < minExt) SS[i] = minSS;
     else if (deltaAngle[i] > maxExt) SS[i] = maxSS;
     else {
        for(int j=0; j<evSize-1; j++){
           aMax = xaxis[j+1];
           aMin = xaxis[j];
           if(deltaAngle[i] < aMax && deltaAngle[i] >= aMin){
                   //Interpolate On Impact Z
                   tauMax = ave33[j+1];
                   tauMin = ave33[j];
                   interpLine(deltaAngle[i], aMin, aMax, tauMin, tauMax, tauNew);
                   SS[i] = tauNew;
                   j = evSize+1;
            }
         }
      }
   }
   for(i=maxLockIndex+1; i<deltaAngle.size(); i++){
      deltaAngle[i] = maxExt;
      SS[i] = MISSINGVAL;
   }

   if(plotSunSensor){
      SS.Plot("Altitude Registration", "Solar Source Model", deltaAngle);
   }

   return;

}


//void AltReg::createCenterSumData(Event &currEvent, Event &tmpEvent, ModelData &SSModel, ModelData &BandModel)
void AltReg::createCenterSumData(Event &currEvent, Event &tmpEvent, ModelData &SSModel)
//!<  Create tau and angleImpact for CenterSumData
{
#ifdef LOGOUT
   cout << "In Function AltReg::createCenterSumData(Event& currEvent)" << endl;
#endif

   int i, j, k;
   int jlast;
   int sizeEph;
   int ei, si;      //Indices for 200m Grid
   int mini, maxi;  //Indices for Z-time Grid
   int numCenterSums, exoStartIndex;
   double exoSource, exoSunSensor, exoRatio;

   char gridName[128];
   char gridNameAlt[128];
   char gridDesc[128];
   string name;
   string descript;

   if(angleImpact.size() != radiusSC.size())
      throw runtime_error("Failure in AltReg::createCenterSumData(Event&):  Incompatible EventVar Sizes.");

   sizeEph = radiusSC.size();
   cout << "EPHSIZE: "  << sizeEph << endl;

   EventVar<double> sunSensorImpactAngle(angleImpact);
   EventVar<double> compositeImpactAngle(angleImpact);
   EventVar<double> sunSensorRefrAngle(sizeEph);
   EventVar<double> angleGeomDeltaSunSensor(sizeEph);
   EventVar<double> tauSolar(sizeEph);
   EventVar<double> tauSolarComposite(sizeEph);
   EventVar<double> rmsSolarComposite(sizeEph);
   EventVar<double> solarSourceValue(sizeEph);
   EventVar<double> sunSensorImpactAlt(sizeEph);
   EventVar<double> centerSumOffsets;

   EventVar<double> ssAInv(angleImpact.size());
   EventVar<double> ssTInv(angleImpact.size());
   EventVar<double> compAInv(angleImpact.size());
   EventVar<double> compTInv(angleImpact.size());

   EventVarVect<double> sunSensorAvgPixelUncorrected;
   EventVarVect<double> sunSensorAvgPixel;
   //EventVarVect<double> sunSensorAvgPixelNorm;
   EventVarVect<double> sunSensorTransmissions("SS_Transmission", "Sun Sensor Center Sums Transmission Values");
   EventVarVect<double> ssCompositeTransmissions("SS_CompositeTransmissions", "Sun Sensor Center Sums Transmission Values");
   EventVarVect<double> sunSensorImpactAngles("SS_ImpactAngle", "Sun Sensor Center Sums Impact Angles");
   EventVar<double> SS_ImpactAngleTop(angleImpactEdge);
   SS_ImpactAngleTop.setName("SS_TopEdgeImpactAngle");
   SS_ImpactAngleTop.setDescription("Top Edge Impact Angle");
   EventVar<double> SS_ImpactAngleBottom(angleImpactEdgeBottom);
   SS_ImpactAngleBottom.setName("SS_BottomEdgeImpactAngle");
   SS_ImpactAngleBottom.setDescription("Bottom Edge Impact Angle");
   double gridZ;
   double arcMin;
   double interpSum, sumLower, sumHigher;
   int tmpMinIndex, tmpMaxIndex;
   int ssMinIndex, ssMaxIndex;
   int tsMinIndex,tsMaxIndex;
   int aiMinIndex = minLockIndex;
   int aiMaxIndex = maxLockIndex;
   double transMax, angMax, angMin;
   char fname[60];

   if(doNonLinearCorrCenterSums){
      cout << "Applying NonLinearity Correction to SunSensor Data" << endl;
      currEvent.getEventVar("CenterAveragePixelValues", sunSensorAvgPixelUncorrected);
      currEvent.getEventVar("SolarCenterSumsOffsets", centerSumOffsets);
      if(plotSunSensor)
         sunSensorAvgPixelUncorrected.Plot("AltReg", "SunSensorPixel Before NLCorrection", angleImpact);

      sunSensorAvgPixel = correctNonLinearity(sunSensorAvgPixelUncorrected);

      if(plotSunSensor)
         sunSensorAvgPixel.Plot("AltReg", "SunSensorPixel After NLCorrection", angleImpact);
   }
   else {
      cout << "Not Applying NonLinearity to SunSensor Data" << endl;
      currEvent.getEventVar("CenterAveragePixelValues", sunSensorAvgPixel);
      currEvent.getEventVar("SolarCenterSumsOffsets", centerSumOffsets);
   }

   numCenterSums = centerSumOffsets.size();
   angleGeomEdge = angleGeom;
   angleGeomEdge -= lockdownAngle;

   if(logDebug){
      cout << "NumCenterSums:  " << numCenterSums << endl;
      for(k=0; k<numCenterSums; k++)
         cout << "Row " << k << ":  " << centerSumOffsets[k] << endl;
   }

/*   compositeImpactAngle = angleImpact;
   compositeImpactAngle.setName("SS_CompositeImpactAngles");
   compositeImpactAngle.setDescription("Impact Angle for Composite Sun Sensor Data");
   compositeImpactAngle.setUnits("Radians");
   compositeImpactAngle.setMissingValue(MISSINGVAL);

   putMissingValues(compositeImpactAngle, 0.35, 0.45);
   setMinMaxIndices(compositeImpactAngle, aiMinIndex, aiMaxIndex);
   fillMissingValues(compositeImpactAngle, aiMinIndex, aiMaxIndex);
   cout << "MinMax AI:  " << aiMinIndex << "  " << aiMaxIndex << endl;
   cout << "AIAngle:  " << compositeImpactAngle[aiMinIndex] << ", " << compositeImpactAngle[aiMaxIndex] << endl;
*/


   for(k=0; k<numCenterSums; k++){

      ssMinIndex = minLockIndex;
      ssMaxIndex = maxLockIndex;
      tsMinIndex = minLockIndex;
      tsMaxIndex = maxLockIndex;
      aiMinIndex = minLockIndex;
      aiMaxIndex = maxLockIndex;

      arcMin = centerSumOffsets[k] * 10800.0 / M_PI ; 

      if(plotSunSensor){
         altRegTime.setAxisRange();
         sunSensorAvgPixel[k].Plot("AltitudeRegistration", "SunSensorAvgPixelInput-Pre", altRegTime);
      }

      cout << "Begin Center Sum Row " << k+1 << endl;
      cout << "  " << arcMin << " arcmin from FOV" << endl;
      putMissingValues(sunSensorAvgPixel[k], 1.0e-15, 1.0e+15);
      setMinMaxIndices(sunSensorAvgPixel[k], ssMinIndex, ssMaxIndex);
//         sunSensorAvgPixel[k].Plot("AltitudeRegistration", "SunSensorAvgPixelInput-Post", altRegTime);

      sunSensorImpactAngle = angleImpact;
      sunSensorImpactAngle += centerSumOffsets[k];

//      sunSensorImpactAngle.Plot("AltitudeRegistration", "SunSensorImpactAngle-Pre", altRegTime);
      //fillMissingValues(sunSensorImpactAngle, ssMinIndex, ssMaxIndex);

      calcSunSensorRefraction(sunSensorImpactAngle, SSModel, sunSensorRefrAngle);
//      sunSensorRefrAngle.Plot("AltitudeRegistration", "SunSensorRefractionAngle", altRegTime);

      //Calc Delta G
      angleGeomDeltaSunSensor = sunSensorImpactAngle;
      angleGeomDeltaSunSensor +=  sunSensorRefrAngle;
      angleGeomDeltaSunSensor -=  angleGeomEdge;

      fillMissingValues(angleGeomDeltaSunSensor, ssMinIndex, ssMaxIndex);

      convertSolarSource(angleGeomDeltaSunSensor, solarSourceValue);

      if(plotSunSensor){
         altRegTime.setAxisRange();
         sprintf(fname, "Angle Geometric Delta %02i", k);
         angleGeomDeltaSunSensor.Plot("AltitudeRegistration", fname, altRegTime);
         sprintf(fname, "SolarSourceValue %02i", k);
         solarSourceValue.Plot("AltitudeRegistration", fname, altRegTime);
      }

      exoStartIndex = getExoStartIndex();

      if(plotSunSensor){

         cout << "Plotting Initial Sun Sensor Data ... " << endl;
         cout << "EPHSIZE: "  << sizeEph << endl;
         EventVar<double> tempAngle(sizeEph);
         EventVar<double> tempTrans(sizeEph);
         EventVar<double> tempTrans2(sizeEph);
         char title[45];
         double arcMinOffset;

         tempAngle = sunSensorImpactAngle;
         tempTrans.setValueOne();
         tempTrans2 = sunSensorAvgPixel[k];
         tempTrans2 /= sunSensorAvgPixel[k][exoStartIndex];
         tempTrans -= tempTrans2;
         fillMissingValues(tempTrans, ssMinIndex, ssMaxIndex);
         putMissingValues(tempTrans, 1e-15, 2.0);
         putMissingValues(tempAngle, 0.3, 0.5);
         sprintf(gridName, "SunSensor Row %1i: %05.2f arcMin offset", k, arcMin);
         tempTrans.setName(gridName);
         tempAngle.setName(gridName);
         tempAngle.setUnits("Radians");
         //tempTrans.setAxisRange(1e-8, 2.0);
         tempTrans.setAxisRange();
         //tempAngle.setAxisRange(0.3, 0.5);
         tempAngle.setAxisRange();
         tempTrans.Plot("AltitudeRegistration", "Sun Sensor Impact Angle Before Removal", tempAngle);
         cout << " ... Done. " << endl << endl;

      }

      exoSource = solarSourceValue[exoStartIndex];
      exoSunSensor = sunSensorAvgPixel[k][exoStartIndex];
      exoRatio = exoSource / exoSunSensor;

      cout << "exoStartIndex:  " << exoStartIndex << endl;
      cout << "exoRatio:  " << exoRatio << endl;

      EventVar<double> sourceTemp(sizeEph);
      sourceTemp.setValueConst(exoRatio);
      sourceTemp /= solarSourceValue;
      tauSolar = sunSensorAvgPixel[k];
      tauSolar *= sourceTemp;

      fillMissingValues(tauSolar, ssMinIndex, ssMaxIndex);
      fillMissingValues(sunSensorImpactAngle, ssMinIndex, ssMaxIndex);

      //sprintf(fname, "SolarSource_%02i", k);
      //solarSourceValue.writeVar(fname);
      //sprintf(fname, "TauSolarPre_%02i", k);
      //tauSolar.writeVar(fname);

      //putMissingValues(tauSolar, -1000.0, 1000.0);

      //Should equal one.
      //exoSource = tauSolar[exoStartIndex];
      //tauSolar /= exoSource;

      putMissingValues(tauSolar, 1e-12, 2.0);
      setMinMaxIndices(tauSolar, tsMinIndex, tsMaxIndex);

      putMissingValues(sunSensorImpactAngle, 0.30, 0.45);
      setMinMaxIndices(sunSensorImpactAngle, ssMinIndex, ssMaxIndex);

      if(tsMinIndex < ssMinIndex){
          cout << "Changing TS to SS:  "  << tsMinIndex << ", " << ssMinIndex << endl;
          tsMinIndex = ssMinIndex;
      }
      if(tsMaxIndex > ssMaxIndex){
          cout << "Changing TS to SS:  "  << tsMaxIndex << ", " << ssMaxIndex << endl;
          tsMaxIndex = ssMaxIndex;
      }
      fillMissingValues(sunSensorImpactAngle, tsMinIndex, tsMaxIndex);
      fillMissingValues(tauSolar, tsMinIndex, tsMaxIndex);

      //sprintf(fname, "TauSolarPre_%02i", k);
      //tauSolar.writeVar(fname);
      //sprintf(fname, "SSIA_%02i", k);
      //sunSensorImpactAngle.writeVar(fname);

      //angMax = sunSensorImpactAngle.max();
      //angMin = sunSensorImpactAngle.min();
      compositeImpactAngle = angleImpact;
      compositeImpactAngle.setName("SS_CompositeImpactAngles");
      compositeImpactAngle.setDescription("Impact Angle for Composite Sun Sensor Data");
      compositeImpactAngle.setUnits("Radians");
      compositeImpactAngle.setMissingValue(MISSINGVAL);
      //compositeImpactAngle.Plot("AltReg", "Impact Angle Initial", altRegTime);

      angMax = compositeImpactAngle.max();
      //putMissingValues(compositeImpactAngle, angMin, angMax);
      putMissingValues(compositeImpactAngle, 0.3, angMax);
      setMinMaxIndices(compositeImpactAngle, aiMinIndex, aiMaxIndex);
      fillMissingValues(compositeImpactAngle, aiMinIndex, aiMaxIndex);

   //If Sunset, reverse to make angle descending
   if(eventType == 2){

      ssAInv = sunSensorImpactAngle;
      ssTInv = tauSolar;
      compAInv = compositeImpactAngle;

      sunSensorImpactAngle = invertVector(ssAInv);
      tauSolar = invertVector(ssTInv);
      compositeImpactAngle = invertVector(compAInv);
      //compTInv.setValueToMissing();

   }

   tauSolarComposite.setValueToMissing();

   //sprintf(fname, "./compositeIA_%02i", k);
   //compositeImpactAngle.writeVar(fname);

   for(i=0; i<compositeImpactAngle.size(); i++){
      double iaA, iaB, iaC;
      double tA, tB, tC;

      if(compositeImpactAngle[i] == MISSINGVAL)
         tauSolarComposite[i] = MISSINGVAL;
      else {
         for(j=0; j<sunSensorImpactAngle.size();j++){
            if(compositeImpactAngle[i] <= sunSensorImpactAngle[j] &&
               compositeImpactAngle[i] > sunSensorImpactAngle[j+1] &&
               sunSensorImpactAngle[j] != MISSINGVAL &&
               sunSensorImpactAngle[j+1] != MISSINGVAL){
                  iaA = sunSensorImpactAngle[j];
                  iaB = compositeImpactAngle[i];
                  iaC = sunSensorImpactAngle[j+1];
                  tA = tauSolar[j];
                  tC = tauSolar[j+1];
                  interpLine(iaB, iaA, iaC, tA, tC, tB);
//            interpLine(compositeImpactAngle[i], sunSensorImpactAngle[j], sunSensorImpactAngle[j+1],
//                       tauSolar[j], tauSolar[j+1], tauSolarComposite[i]);
                  tauSolarComposite[i] = tB;
            }
         }
      }
   }


   if(eventType == 2){

      sunSensorImpactAngle = ssAInv;
      tauSolar = ssTInv;
      compositeImpactAngle = compAInv;
      compTInv = tauSolarComposite;

      tauSolarComposite = invertVector(compTInv);
   }

//    sprintf(fname, "./tauSolarComposite_%02i", k);
//    tauSolarComposite.writeVar(fname);

      putMissingValues(tauSolarComposite, 1e-15, 2.0);
      setMinMaxIndices(tauSolarComposite, aiMinIndex, aiMaxIndex);
      fillMissingValues(tauSolarComposite, aiMinIndex, aiMaxIndex);

      if(plotSunSensor){
         cout << "Plotting Source Removed Sun Sensor Data ... " << endl;
         EventVar<double> tempAngle(sizeEph);
         EventVar<double> tempTrans(sizeEph);
         char title[45];
         double arcMinOffset;

         tempAngle = compositeImpactAngle;
         tempTrans.setValueOne();
         tempTrans -= tauSolarComposite;
         putMissingValues(tempTrans, 1e-10, 2.0);
         putMissingValues(tempAngle, 0.3, 0.5);
         sprintf(title, "TauSolarCompositeRow%02i", k);
         tempTrans.setName(title);
         tempAngle.setName(title);
         tempAngle.setUnits("Radians");
         tempTrans.setAxisRange();
         tempAngle.setAxisRange();
         sprintf(title, "AfterSourceRemoval%02i", k);
         tempTrans.Plot("AltitudeRegistration", title, tempAngle);
         cout << " ... Done. " << endl;

      }

      sunSensorTransmissions.addEventVar(tauSolar);
      sunSensorImpactAngles.addEventVar(sunSensorImpactAngle);
      ssCompositeTransmissions.addEventVar(tauSolarComposite);

   }

   compositeImpactAngle = angleImpact;
   compositeImpactAngle.setName("SS_CompositeImpactAngles");
   compositeImpactAngle.setDescription("Impact Angle for Composite Sun Sensor Data");
   compositeImpactAngle.setUnits("Radians");
   compositeImpactAngle.setMissingValue(MISSINGVAL);

   //putMissingValues(compositeImpactAngle, angMin, angMax);
   putMissingValues(compositeImpactAngle, 0.3, 0.45);
   aiMinIndex = minLockIndex;
   aiMaxIndex = maxLockIndex;
   setMinMaxIndices(compositeImpactAngle, aiMinIndex, aiMaxIndex);
   fillMissingValues(compositeImpactAngle, aiMinIndex, aiMaxIndex);

   //ssCompositeTransmissions.Plot("AltitudeRegistration", "Sun Sensor Composite Trans", compositeImpactAngle);

   //combineComposite(ssCompositeTransmissions, tauSolarComposite);
   combineComposite(ssCompositeTransmissions, tauSolarComposite, rmsSolarComposite);

   tauSolarComposite.setName("SS_CompositeTransmission");
   tauSolarComposite.setDescription("Composite Transmission for Sun Sensor Data");
   tauSolarComposite.setUnits("Transmission");

   name = sunSensorTransmissions.getName();
   descript = sunSensorTransmissions.getDescription();
   cout << "Adding " << name << ": " << descript << endl;
   tmpEvent.addEventVar(sunSensorTransmissions);

   name = sunSensorImpactAngles.getName();
   descript = sunSensorImpactAngles.getDescription();
   cout << "Adding " << name << ": " << descript << endl;
   tmpEvent.addEventVar(sunSensorImpactAngles);

   name = SS_ImpactAngleTop.getName();
   descript = SS_ImpactAngleTop.getDescription();
   cout << "Adding " << name << ": " << descript << endl;
   tmpEvent.addEventVar(SS_ImpactAngleTop);

   name = SS_ImpactAngleBottom.getName();
   descript = SS_ImpactAngleBottom.getDescription();
   cout << "Adding " << name << ": " << descript << endl;
   tmpEvent.addEventVar(SS_ImpactAngleBottom);

   name = tauSolarComposite.getName();
   descript = tauSolarComposite.getDescription();
   cout << "Adding " << name << ": " << descript << endl;
   tmpEvent.addEventVar(tauSolarComposite);
// LED also store into ssTran private data member
   ssTran.copy( tauSolarComposite );

   name = compositeImpactAngle.getName();
   descript = compositeImpactAngle.getDescription();
   cout << "Adding " << name << ": " << descript << endl;
   tmpEvent.addEventVar(compositeImpactAngle);

   if(plotSunSensor){

      EventVar<double> tempAngle(sizeEph);
      EventVar<double> tempTrans(sizeEph);
      char title[45];
      double arcMinOffset;

      tauSolarComposite.Plot("AltitudeRegistration", "Sun Sensor Source Composite", compositeImpactAngle);

      rmsSolarComposite.Plot("AltitudeRegistration", "Sun Sensor Source RMS", compositeImpactAngle);

      tempAngle = compositeImpactAngle;
      tempTrans.setValueOne();
      tempTrans -= tauSolarComposite;
      putMissingValues(tempTrans, 1e-10, 2.0);
      putMissingValues(tempAngle, 0.3, 0.5);
      tempTrans.setName("Composite");
      tempAngle.setName("Impact Angle");
      tempAngle.setUnits("Radians");
      tempTrans.setAxisRange();
      tempAngle.setAxisRange();
      tempTrans.Plot("AltitudeRegistration", "Sun Sensor Source Composite Inverse", tempAngle);

      altRegTime.setAxisRange();
      SS_ImpactAngleTop.Plot("AltitudeRegistration", "Sun Sensor Top Edge", altRegTime);
      SS_ImpactAngleBottom.Plot("AltitudeRegistration", "Sun Sensor Bottom Edge", altRegTime);
   }

return;

}

void AltReg::setMinMaxIndices(EventVar<double> inEV, int &min, int &max){

   if(logDebug)
      cout << "In Function AltReg::setMinMaxIndices(EventVar<double> inEV, int &min, int &max)" << endl;

   int sizeEV = inEV.size();
   int writeSignal = 0;
   int save = max;

   if(min < minLockIndex) min = minLockIndex;
   max = min-1;

   while(max - min < 600 && min < sizeEV / 2){

      min = max+1;

      while(min < sizeEV &&  inEV[min] == MISSINGVAL)
         min++;

      max = min;

      while(max < sizeEV && inEV[max] != MISSINGVAL)
         max++;
      max--;

   }

   if(min < minLockIndex) min = minLockIndex;
   if(max > maxLockIndex) max = maxLockIndex;
   if(max > save) max = save;

   if(max - min < 1200){
      cout << "  WARNING:  inEV has less than 1 minute of values.  " << max-min << endl;
      writeSignal = 1;
   }

   if(max > sizeEV-1 || min > sizeEV-1){
      cout << "  WARNING:  inEV Indices Too Large in setMinMaxIndices(). " << endl;
      writeSignal = 1;
   }

   if (min > sizeEV / 2){
      cout << "  WARNING:  inEV has minIndex larger than half of total array. " << endl;
      writeSignal = 1;
   }

   if(logDebug || writeSignal){
      cout << "Min:  " << min << "  inEV:  " << inEV[min] << endl;
      cout << "Max:  " << max << "  inEV:  " << inEV[max] << endl;
   }

   return;

}

void AltReg::fillMissingValues(EventVar<double>& inEV, int min, int max){
//!< Write MISSINGVAL for all values less than min and greater than max

   int sizeEV = inEV.size();
   int i;
   for(i=0; i<min; i++)
      inEV[i] = MISSINGVAL;
   for(i=sizeEV-1; i>max; i--)
      inEV[i] = MISSINGVAL;

   return;

}

void AltReg::analyzeData(EventVarVect<double> EVV, EventVarVect<int>& outEVV)
//!< Determine Good Data
{
   int numEVs = EVV.size();
   int sizeEV;
   int i, j;
   int goodValues;
   double sum;
   int numGood, oldGood;

   if(numEVs > 0) sizeEV = EVV[0].size();
   EventVar<int> goodData(sizeEV);

   //Create Boolean for Each Sample in EVV
   goodData.setValueConst(-999);
   for(j=0; j<numEVs; j++)
      outEVV.addEventVar(goodData);

   //Set all non-missing values to good
   for(i=0; i<sizeEV; i++){
      for(j=0; j<numEVs; j++){
         if(EVV[j][i] > MISSINGVAL/10){
            outEVV[j][i] = 1;
         }
      }
   }

   //Remove all samples with 2 samples of falling off the edge
   for(j=0; j<numEVs; j++){
      for(i=0; i<sizeEV; i++){
         if(i>0 && outEVV[j][i] == -999 && outEVV[j][i-1] == 1){
            //if(i>=3) outEVV[j][i-3] = 0;
            if(i>=2) outEVV[j][i-2] = 0;
            outEVV[j][i-1] = 0;
            outEVV[j][i] = 0;
            i++;
         }
         if(i<sizeEV-1 && outEVV[j][i] == -999 && outEVV[j][i+1] == 1){
            //if(i<=sizeEV-3) outEVV[j][i+3] = 0;
            if(i<=sizeEV-2) outEVV[j][i+2] = 0;
            outEVV[j][i+1] = 0;
            outEVV[j][i] = 0;
            i+=3;
         }
      }
   }
   return;
}

//void AltReg::combineComposite(EventVarVect<double> EVV, EventVar<double>& outEV)
void AltReg::combineComposite(EventVarVect<double> EVV, EventVar<double>& outEV, EventVar<double>& rmsEV)
//!< Average All Vars in EventVarVect
{

   //cout << "In Combine Composite: " << endl;
   int numEVs = EVV.size();
   int sizeEV;
   int i, j, k;
   int goodValues;
   double sum, sumsq;
   EventVar<double> values(numEVs);
   EventVarVect<int> useEVV;


   if(numEVs > 0) sizeEV = EVV[0].size();

   analyzeData(EVV, useEVV);

   for(i=0; i<sizeEV; i++){
      values.setValueConst(MISSINGVAL);
      goodValues = 0;
      sum = 0.0;
      for(j=0; j<numEVs; j++){

         if(useEVV[j][i] == 1){
            //if(j==0) cout << i << "Valid:  " << EVV[j][i];
            //else cout << ", " << EVV[j][i];
            sum += EVV[j][i];
            values[j] = EVV[j][i];
            goodValues++;
         }
      }
      if(goodValues == 0){
         outEV[i] = MISSINGVAL;
         rmsEV[i] = MISSINGVAL;
      }
      else {
         outEV[i] = sum / goodValues;
         //cout << ", " << outEV[i];
         sumsq = 0.0;
         for(j=0; j<goodValues; j++)
            sumsq += ((values[j] - outEV[i]) * (values[j] - outEV[i]));
         rmsEV[i] = sqrt(sumsq / goodValues);
         //cout << ", " << rmsEV[i] << endl;
      }
   }
   //cout << endl;
   return;

}

void AltReg::gridCenterSums(Event &currEvent)
//!<  Grid the Center Sums on Specific Altitude Grids
{
#ifdef LOGOUT
   cout << "In Function AltReg::gridCenterSums(Event& currEvent)" << endl;
#endif

   int i, j, k;
   int jlast;
   int ei, si;      //Indices for 200m Grid
   int mini, maxi;  //Indices for Z-time Grid
   int numCenterSums;
   char gridName[128];
   char gridNameAlt[128];
   char gridDesc[128];
   string name;
   string descript;


   if(angleImpact.size() != radiusSC.size())
      throw runtime_error("Failure in AltReg::gridCenterSums(Event&):  Incompatible EventVar Sizes.");

   EventVar<double> sunSensorImpactAngle(angleImpact);
   EventVar<double> sunSensorImpactAlt(radiusSC.size());
   EventVar<double> centerSumOffsets;
   EventVarVect<double> sunSensorAvgPixel;
   //EventVarVect<double> sunSensorAvgPixelNorm;
   EventVarVect<double> gridSunSensorAvgPixelValues("GriddedAvgPixelValues", "Gridded Sun Sensor Average Pixel Values");
   double gridZ;
   double interpSum, sumLower, sumHigher;



   currEvent.getEventVar("CenterAveragePixelValues", sunSensorAvgPixel);
   currEvent.getEventVar("SolarCenterSumsOffsets", centerSumOffsets);
   //numCenterSums = sunSensorAvgPixel.size();
   numCenterSums = centerSumOffsets.size();

   //Plot Initial Sun Sensor Positions
//   if(plotSunSensor)
//      plotInitialSunSensor(sunSensorAvgPixel);

   for(k=0; k<numCenterSums; k++){
      sunSensorImpactAngle = angleImpact;
      sunSensorImpactAngle += centerSumOffsets[k];
      sunSensorImpactAlt = radiusSC;
      sunSensorImpactAlt *= cos(sunSensorImpactAngle);
      sunSensorImpactAlt -= radiusC[0];

      EventVar<double> gridSunSensorAvgPixelTemp(gridName, gridDesc, "Counts", MISSINGVAL, gridNum);
      sprintf(gridName, "GriddedAvgPixelValue_%01i", k);
      sprintf(gridNameAlt, "Z_GriddedAvgPixelValue_%01i", k);
      sprintf(gridDesc, "Gridded Average Pixel Values For Row %01i", k);
      sunSensorImpactAlt.setName(gridNameAlt);
      sunSensorImpactAlt.setDescription(gridDesc);

      setGriddedIndices(sunSensorImpactAlt, mini, maxi, si, ei);

      for(i=ei; i>=si; i--){
         gridZ = gridRange[0] + i*gridSpacing;
         if(eventType == 1) {   //SR -- Start Low and Work Up
            //jlast = zImpact.size()-2;
            jlast = maxi;
            for(j=jlast; j>=mini; j--){
               if(sunSensorImpactAlt[j] <= gridZ && sunSensorImpactAlt[j+1] > gridZ){
                  sumLower = sunSensorAvgPixel[k][j];
                  sumHigher = sunSensorAvgPixel[k][j+1];
                  interpLine(gridZ, sunSensorImpactAlt[j], sunSensorImpactAlt[j+1], sumLower, sumHigher, interpSum);
                  gridSunSensorAvgPixelTemp[i] = interpSum;
                  jlast = j;
                  j = mini-1;
               }
            }
         }
         else {   //SS -- Start High and Work Down
            jlast = maxi;
            for(j = jlast; j<mini; j++){
               if(sunSensorImpactAlt[j] >= gridZ && sunSensorImpactAlt[j+1] < gridZ){
                  sumLower = sunSensorAvgPixel[k][j+1];
                  sumHigher = sunSensorAvgPixel[k][j];
                  interpLine(gridZ, sunSensorImpactAlt[j+1], sunSensorImpactAlt[j], sumLower, sumHigher, interpSum);
                  gridSunSensorAvgPixelTemp[i] = interpSum;
                  jlast = j;
                  j = mini+2;
               }
            }
         }
      }
      gridSunSensorAvgPixelValues.addEventVar(gridSunSensorAvgPixelTemp);
   }
   name = gridSunSensorAvgPixelValues.getName();
   descript = gridSunSensorAvgPixelValues.getDescription();
   cout << "Adding " << name << ": " << descript << endl;
   currEvent.addEventVar(gridSunSensorAvgPixelValues);

   //Plot Gridded Data Flag Set In INI File
   if(plotGridData || plotSunSensor)
      plotGriddedSunSensor(currEvent, ei);
      //plotGriddedSunSensor(gridSunSensorAvgPixelValues);

   return;

}

void AltReg::putMissingValues(EventVar<double> &Ev, double min, double max)
{
   int n = Ev.size();
   for(int i=0; i<n; i++)
      if(Ev[i] < min || Ev[i] > max)
         Ev[i] = MISSINGVAL;

   Ev.setMissingValue(MISSINGVAL);

   return;

}


void AltReg::plotInitialSunSensor(EventVarVect<double> &Evv)
{
#ifdef LOGOUT
   cout << "In Function AltReg::plotInitialSunSensor(EventVarVect<double>)" << endl;
#endif

   int i, j;
   int exoRange = 30;
   int ialt = 0;
   double initVal = 1.0;
   double exoVal;
   char setName[30];
   EventVarVect<double> sunSensorNorm("sunSensorNorm", "Sun Sensor Average Pixel Values");
   EventVar<double> sunSensorTimeValues(Evv[0].size());
   zImpact.setAxisRange(0.0, 180.0);

      ialt = maxAltIndex;
      while(zImpact[ialt] > 150.0 && ialt>0 && ialt < zImpact.size()-1){
         if(eventType == 1) ialt--;
         else ialt++;
      }

      if(zImpact[ialt] < 160.0 && zImpact[ialt] > 140.0){

         for(i=0; i<Evv.size(); i++){
            sunSensorTimeValues = Evv[i];
            exoVal = 0.0;
            for(j=ialt; j<ialt+exoRange; j++){
               exoVal += sunSensorTimeValues[j];
            }
            exoVal /= exoRange;
            sunSensorTimeValues /= exoVal;
            EventVar<double> gridTempNorm(initVal, int(sunSensorTimeValues.size()));
            gridTempNorm -= sunSensorTimeValues;
            sunSensorNorm.addEventVar(gridTempNorm);
         }

         for(j=0; j<sunSensorNorm.size(); j++){
           sprintf(setName, "Sun Sensor Row %02i", j+1);
           sunSensorNorm[j].setAxisRange();
           sunSensorNorm[j].setName(setName);
         }

         //sunSensorNorm.Plot("Altitude Registration", "Initial Normalized Sun Sensor Values", zImpact);

      }
      else { cout << "Could not plot Initial Sun Sensor Values." << endl; }

   return;

}

//void AltReg::plotGriddedSunSensor(EventVarVect<double> &Evv)
void AltReg::plotGriddedSunSensor(Event &currEvent, int iEnd)
{
#ifdef LOGOUT
   cout << "In Function AltReg:::plotGriddedSunSensor(Event&, int)" << endl;
#endif

   int i,j;
   int exoRange = 10;
   double arcMinOffset;
   double initVal = 1.0;
   double exoVal;
   char setName[30];
   EventVar<double> gridZImpact;
   EventVar<double> centerSumOffsets;
   EventVarVect<double> gridSSAPV("GriddedSSAPV", "Gridded Sun Sensor Average Pixel Values");

   currEvent.getEventVar("gridImpact", gridZImpact);
   currEvent.getEventVar("GriddedAvgPixelValues", gridSSAPV);
   currEvent.getEventVar("SolarCenterSumsOffsets", centerSumOffsets);
   gridZImpact.setAxisRange(-100.0, 300.0);

   for(i=0; i<gridSSAPV.size(); i++){
      exoVal = 0.0;
      for(j=0; j<exoRange; j++){
         exoVal += gridSSAPV[i][iEnd-j];
      }
      exoVal /= exoRange;
      gridSSAPV[i] /= exoVal;
      EventVar<double> gridTempNorm(initVal, int(gridSSAPV[i].size()));
      gridTempNorm -= gridSSAPV[i];
      //gridSSAPV.addEventVar(gridTempNorm);
      gridSSAPV[i] = gridTempNorm;
   //}

   //for(i=0; i<gridSSAPV.size(); i++){
     arcMinOffset = centerSumOffsets[i];
     arcMinOffset = arcMinOffset * (60.0 * 180.0 / 3.14159265358979);
     sprintf(setName, "Sun Sensor Row %02i:  %4.1f arcMin offset", i+1, arcMinOffset);
     gridSSAPV[i].setAxisRange();
     gridSSAPV[i].setName(setName);
   }

   //gridSSAPV.Plot("Altitude Registration", "Normalized Sun Sensor Values", gridZImpact);

   return;
}

void AltReg::setGriddedIndices(EventVar<double> &zAlt, int &min, int &max, int &gs, int &ge)
//!< Finds indices of Min/Max Altitudes
{
#ifdef LOGOUT
   cout << "In Function AltReg:::setGriddedIndices(EventVar<double>&, int&, int&, int&, int&)" << endl;
#endif

   int imid;
   int iMaxValue, iNegValue, iStart, iEnd;
   string eventVarName = zAlt.getName();

   searchValidIndices(zAlt,iStart, iEnd);
   imid =  (iEnd + iStart) / 2;

   min = imid;
   max = imid;

   if(eventType == 1){
      while(min > minLockIndex &&
            zAlt[min] > zAlt[min-1])
         min--;
      while(max < maxLockIndex &&
            zAlt[max] < zAlt[max+1])
         max++;
   }
   else {
      while(max > minLockIndex &&
            zAlt[max] < zAlt[max-1])
         max--;
//      while(min < maxLockIndex &&
//            zAlt[min] > zAlt[min+1])
std::cout << " now before loop " << min << std::endl;
      while(min < maxLockIndex && zAlt[min] > 0.) { 
       if(     zAlt[min] < zAlt[min+1] ) {
          if(zAlt[min] < 90.) break;
           double p = zAlt[min] ;
           zAlt[min] = zAlt[min+1] ;
           zAlt[min+1] = p;
       }


          min++;
       }
   }

std::cout << " min maxLockIndex " << min << " fred " << maxLockIndex << std::endl;
   gs = 0;
   ge = gridNum-1;
   //if(zImpact[zImpact.size()-1] < gridRange[1]){
   if(zAlt[max] < gridRange[1]){
      ge = gridNum - int (((gridRange[1] - zAlt[max]) / gridSpacing) + 1) - 1;
      cout << "WARNING:  Gridded " << eventVarName << " Values Truncated Due To Insufficient Data" << endl;
      cout << "          Data Available at " << zAlt[max] << endl;
      cout << "          Gridded Data Ends " << gridRange[0] + ge*gridSpacing << endl;
   }
   if(zAlt[min] > gridRange[0]){
      gs = int ((zAlt[min] - gridRange[0]) / gridSpacing) + 1;
      cout << "WARNING:  Gridded " << eventVarName << " Values Truncated Due To Insufficient Data" << endl;
      cout << "          Data Available at " << zAlt[min] << endl;
      cout << "          Gridded Data Begins " << gridRange[0] + gs*gridSpacing << endl;
   }

   if (gridNum <= gs || gridNum <= ge)
   {
      cerr << "AltReg::setGriddedIndices() Error:  Grid Indices Out of Range:  ( " << gs << ", " << ge << " ). " << endl;
      cerr << "   Grid size = " << gridNum << endl;
      throw runtime_error("Failure in AltReg::setGriddedIndices(EventVar, int, int, int, int):  gs or ge out of range");
   }

   if(logDebug){
      cout << "Gridded " << eventVarName << " Indices For EventType:  " << eventType << endl;
      cout << "   MinAlt:  " << min << "  Minimum Z:  " << zAlt[min] << endl;
      cout << "   MaxAlt:  " << max << "  Maximum Z:  " << zAlt[max] << endl << endl;
   }

   return;

}

void AltReg::setGriddedIndices(EventVar<double> &X, int &s, int &e)
//!< Sets Gridded Range
{
#ifdef LOGOUT
   cout << "In Function AltReg:::setGriddedIndices(EventVar<double>&, int&, int&)" << endl;
#endif
   // Get Indexes and Linear Interpolation for
   s = 0;
   e = gridNum-1;
   //if(zImpact[zImpact.size()-1] < gridRange[1]){
   if(zImpact[maxAltIndex] < gridRange[1]){
      e = gridNum - int (((gridRange[1] - zImpact[maxAltIndex]) / gridSpacing) + 1) - 1;
      cout << "WARNING:  Gridded Values Truncated Due To Insufficient Data" << endl;
      cout << "          Data Available at " << zImpact[maxAltIndex] << endl;
      cout << "          Gridded Data Ends " << gridRange[0] + e*gridSpacing << endl;
      X[1] = gridRange[0] + e*gridSpacing;
   }
   if(zImpact[minAltIndex] > gridRange[0]){
      s = int ((zImpact[minAltIndex] - gridRange[0]) / gridSpacing) + 1;
      cout << "WARNING:  Gridded Values Truncated Due To Insufficient Data" << endl;
      cout << "          Data Available at " << zImpact[minAltIndex] << endl;
      cout << "          Gridded Data Begins " << gridRange[0] + s*gridSpacing << endl;
      X[0] = gridRange[0] + s*gridSpacing;
   }

   if (gridNum <= s || gridNum < e)
   {
      cerr << "AltReg::createAltitudeGrid() Error:  Grid Indices Out of Range:  ( " << s << ", " << e << " ). " << endl;
      cerr << "   Grid size = " << gridNum << endl;
      throw runtime_error("Failure in AltReg::setGriddedIndices(EventVar, int, int):  si or ei out of range");
   }

   return;

}

//void interpolate2Grid(Ephemeris&)
//!< Interpolates stateVector

void AltReg::writeOutput(Event& currEvent)
//!< Writes the Output of All Member Variables to Event Object Tmp or Level1
//!< Requires No Parameters ... Uses Config for Output Parameters and Locations
{
#ifdef LOGOUT
   cout << "In Function AltReg::writeOutput(Event& currEvent)" << endl;
#endif

   char title[50];
   //EventVar<double> tOffsetPR("PressReg_ShiftedTime", "Shifted Time of Pressure Registration", timeOffset, 1);
   //EventVar<double> zOffsetPR("PressReg_ShiftedZ", "Shifted Z of Pressure Registration", zOffset, 1);
   //EventVar<double> rmsPR("PressReg_RMS", "RMS of Pressure Registration", rmsSolution, 1);
   //EventVar<double> regMethod("PressReg_Method", "Registration Method", altRegType, 1);
   //EventVar<double> ("37 Km Value", "Registration Comparison at 37 Km", z37, numMethods);



/*   EventVar<double> AltReg_QA_RefractionRMS("AltReg_RefractionRMS", "SOFIE QA RMS Value of Refraction Angle Registration Profiles At Start Index", rmsSolution, 1);
   EventVar<double> AltReg_QA_RefractionMean("AltReg_RefractionMean", "SOFIE QA Mean Value of Refraction Angle Registration Profiles At Start Index", meanSolution, 1);
*/



   //if(altRegType == 2){
   //   cout << "Final Time Offset is " << tOffsetPR[0] << endl;
   //   cout << "Final RMS is         " << rmsPR[0] << endl;
   //}
   //cout << "Final Z Offset is    " << zOffsetPR[0] << endl;

   altRegTime.setName("Registered Time");
   corrBandSignal.setName("corrBandSignal");
   angleImpact.setName("angleImpact");
   angleRefr.setName("angleRefr");
   angleGeom.setName("angleGeom");
   zGeom.setName("zGeom");
   zImpact.setName("zImpact");
   lockdownAngle.setName("LockdownAngle");
   //EventVar<double> losVectorSun();
   radiusSC.setName("radiusSC");
   //losSun.setName("losSun");
   allSignals.setName("allSignals");
   methodComparisonZValues.setName("altReg_ZImpact");
   methodComparison.setName("altReg_Method");
   methodComparisonBands.setName("altReg_Band");

   if(plotFunctions || plotSimData || plotCorrectionBand){
      sprintf(title, "CO2 Registration Band %02i", band+1);
      corrBandSignal.setAxisRange();
      zImpact.setAxisRange();
      zImpact.Plot("Altitude Registration", title, corrBandSignal);
      altRegTime.setAxisRange();
      corrBandSignal.Plot("Altitude Registration", title, altRegTime);

   }

   if(band == 12){

      writeToEvent(currEvent, angleImpact);

      writeToEvent(currEvent, angleRefr);

      writeToEvent(currEvent, angleGeom);

      writeToEvent(currEvent, zGeom);

      writeToEvent(currEvent, zImpact);
      //writeToEvent(currEvent, lockdownAngle);

      writeToEvent(currEvent, radiusSC);
      //writeToEvent(currEvent, losSun);

/*    writeToEvent(currEvent, tOffsetPR);
      writeToEvent(currEvent, zOffsetPR);
      writeToEvent(currEvent, rmsPR);
*/
      string name;
      string descript;

/*   IF UNCOMMENTED, Change to: writeToEvent(Event, EventVar) function
      name = methodComparisonZValues.getName();
      descript = methodComparisonZValues.getDescription();
      cout << "Adding " << name << ":  " << descript << endl;
      currEvent.addEventVar(methodComparisonZValues);

      name = methodComparison.getName();
      descript = methodComparison.getDescription();
      cout << "Adding " << name << ":  " << descript << endl;
      currEvent.addEventVar(methodComparison);

      name = methodComparisonBands.getName();
      descript = methodComparisonBands.getDescription();
      cout << "Adding " << name << ":  " << descript << endl;
      currEvent.addEventVar(methodComparisonBands);
*/

/*   IF UNCOMMENTED, Change to: writeToEvent(Event, EventVar) function
      name = AltReg_QA_RefractionRMS.getName();
      descript = AltReg_QA_RefractionRMS.getDescription();
      cout << "Adding " << name << ":  " << descript << endl;
      currEvent.addEventVar(AltReg_QA_RefractionRMS);

      name = AltReg_QA_RefractionMean.getName();
      descript = AltReg_QA_RefractionMean.getDescription();
      cout << "Adding " << name << ":  " << descript << endl;
      currEvent.addEventVar(AltReg_QA_RefractionMean);

      name = regMethod.getName();
      descript = regMethod.getDescription();
      cout << "Adding " << name << ":  " << descript << endl;
      currEvent.addEventVar(regMethod);
*/

   }


   return;

}

void AltReg::plotDiff(){
#ifdef LOGOUT
cout << "In Function CO2Reg::plotDiff()" << endl;
#endif

   EventVar<double> Difference(altRegTime.size());
   char diffSetName[256];
   char subtitle[256];
   sprintf(diffSetName, "Iteration %02i -- ( %6.3f secs )", iteration, timeOffset);
   sprintf(subtitle, "Difference Band %02i (Model - Observed)", band+1);
   Difference.setName(diffSetName);
   Difference = modelSignal;
   Difference -= corrBandSignal;
   Difference /= modelSignal;
   Difference *= 100.0;
   zImpact.setAxisRange(30.0, 50.0);
   Difference.setAxisRange(-10.0, 10.0);
   zImpact.Plot("Altitude Registration", subtitle, Difference);
   sprintf(subtitle, "CO2 Registration Model %02i with Non-Linearity", band+1);
   zImpact.Plot("Altitude Registration", subtitle, modelSignal);

   return;
}


/*void AltReg::checkInputs(){

   getLockdownSettleIndex();

   checkSolarExtent();

   checkRefractionAngles();

   return;

}

void AltReg::checkSolarExtent(){

   EventVar<double> Ev(normSolarExtent);
   int lo, hi;
   int i;

   searchValidIndices(Ev, lo, hi);  // Finds Missing Value Indexes

   //i = lo;
   while((Ev[lo] < 0.0 || Ev[lo] > 1.0) && lo < hi) lo++;
   i = lo;
   while(Ev[i] >=0.0 && Ev[i] <= 1.0 && i < hi) i++;
   if(i < hi) hi = i;


   if(minLockIndex < lo){
      cout << "Solar Extent Indices Changed MinIndex From " << minLockIndex << " to " << lo << endl;
      minLockIndex = lo;
   }
   if(maxLockIndex > hi){
      cout << "Solar Extent Indices Changed MaxIndex From " << maxLockIndex << " to " << hi << endl;
      maxLockIndex = hi;
   }

   return;

}

void AltReg::checkRefractionAngles()
{
   EventVar<double> Ev(angleRefr);

   if(eventType == 1)


*/

double AltReg::getZcompare(){
//!<
#ifdef LOGOUT
cout << "In Function AltReg::getZcompare()" << endl;
#endif

   //return zImpact[sIndex];
   return zImpact[zCompareIndex];

}

double AltReg::getZcompare(int idx, double rat){
//!< Returns Z a Ratio Distance Past Idx
//!< Used To Compare Different Registration Methods at a Specific Altitude.
#ifdef LOGOUT
cout << "In Function AltReg::getZcompare(index, ratio)" << endl;
#endif

   double zc;

   zc = zImpact[idx] + rat * (zImpact[idx+1] - zImpact[idx]);

   return zc;

}

void AltReg::putZcompare(EventVar<double> z){
//!<
#ifdef LOGOUT
cout << "In Function AltReg::putZcompare(vector<double>)" << endl;
#endif

   EventVar<double> Z(z);
   methodComparisonZValues = Z;

   return;

}

void AltReg::writeToEvent(Event &currEvent){
//!<
#ifdef LOGOUT
cout << "In Function AltReg::writeToEvent(Event &currEvent)" << endl;
#endif

   char evname[50];

   sprintf(evname, "RegisteredTime_Band%02i", band+1);
   altRegTime.setName(evname);

   sprintf(evname, "CorrBandSignal_Band%02i", band+1);
   corrBandSignal.setName(evname);

   sprintf(evname, "AngleImpact_Band%02i", band+1);
   angleImpact.setName(evname);

   sprintf(evname, "AngleRefr_Band%02i", band+1);
   angleRefr.setName(evname);

   sprintf(evname, "AngleGeom_Band%02i", band+1);
   angleGeom.setName(evname);

   sprintf(evname, "ZAltGeom_Band%02i", band+1);
   zGeom.setName(evname);

   sprintf(evname, "ZAltImpact_Band%02i", band+1);
   zImpact.setName(evname);

   sprintf(evname, "LockdownAngle_Band%02i", band+1);
   lockdownAngle.setName(evname);

   sprintf(evname, "RadiusSC_Band%02i", band+1);
   radiusSC.setName(evname);

   currEvent.addEventVar(altRegTime);
   currEvent.addEventVar(corrBandSignal);
   currEvent.addEventVar(angleImpact);
   currEvent.addEventVar(angleRefr);
   currEvent.addEventVar(angleGeom);
   currEvent.addEventVar(zGeom);
   currEvent.addEventVar(zImpact);
   currEvent.addEventVar(lockdownAngle);
   currEvent.addEventVar(radiusSC);

return;
}

void AltReg::writePassThruToEvent(Event &currEvent){
//!<
#ifdef LOGOUT
cout << "In Function AltReg::writePassThruToEvent(Event &currEvent)" << endl;
#endif
   EventVar<double> zPT(zImpact);
   char evname[50];
   sprintf(evname, "ZAltImpact_Band%02ipt", band+1);
   zPT.setName(evname);
   writeToEvent(currEvent, zPT);
   return;

}
/*
EventVarVect<double> AltReg::readStoredEventVars(Event &currEvent, int* bands){
//!<
#ifdef LOGOUT
cout << "In Function AltReg::readStoredEventVars(Event &currEvent)" << endl;
#endif

   EventVar<double> tmpEV;
   EventVarVect<double> evs;

   char evname[50];

   //int bands[3] = { 13, 7, 25 };

   for(int i=0; i<3; i++){
      sprintf(evname, "RegisteredTime_Band%02i", bands[i]);
      tmpEV.getEventVar(evname);
      evs.addEventVar(tmpEV);

      sprintf(evname, "CorrBandSignal_Band%02i", bands[i]);
      tmpEV.getEventVar(evname);
      evs.addEventVar(tmpEV);

      sprintf(evname, "AngleImpact_Band%02i", bands[i]);
      tmpEV.getEventVar(evname);
      evs.addEventVar(tmpEV);

      sprintf(evname, "AngleRefr_Band%02i", bands[i]);
      tmpEV.getEventVar(evname);
      evs.addEventVar(tmpEV);

      sprintf(evname, "AngleGeom_Band%02i", bands[i]);
      tmpEV.getEventVar(evname);
      evs.addEventVar(tmpEV);

      sprintf(evname, "ZAltGeom_Band%02i", bands[i]);
      tmpEV.getEventVar(evname);
      //zGeom.getEventVar(evname);
      evs.addEventVar(tmpEV);

      sprintf(evname, "ZAltImpact_Band%02i", bands[i]);
      tmpEV.getEventVar(evname);
      //zImpact.getEventVar(evname);
      evs.addEventVar(tmpEV);

      sprintf(evname, "LockdownAngle_Band%02i", bands[i]);
      tmpEV.getEventVar(evname);
      //lockdownAngle.getEventVar(evname);
      evs.addEventVar(tmpEV);

      sprintf(evname, "RadiusSC_Band%02i", bands[i]);
      tmpEV.getEventVar(evname);
      evs.addEventVar(tmpEV);
  }

  return evs;

}
*/

EventVar<double> AltReg::invertVector(EventVar<double> inEV)
{
#ifdef LOGOUT
cout << "In Function CO2Reg::invertVector(vector<double>&)" << endl;
#endif

   int vSize = inEV.size();
   EventVar<double> outEV(vSize);

   outEV = inEV;
   for(int i=0; i<vSize; i++)
      outEV[i] = inEV[vSize-i-1];

   return outEV;

}