//
//-----------------------------------------------------------------------
/// @copyright
///            (c) Copyright 2008 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.
///
//-----------------------------------------------------------------------
///
/// @file	SunSensorEvent.cpp
///
/// @author	John Burton	<j.c.burton@gats-inc.com>
///
/// @date  	Thu Jan 17 16:53:08 2008
///
//-----------------------------------------------------------------------
//
//-----------------------------------------------------------------------
// Include Files:
//-----------------------------------------------------------------------
//
#include "GATS_Utilities.hpp"
#include "SunSensorEvent.h"
#include "NonLinearityCorrection.h"

//
//-----------------------------------------------------------------------
// Defines and Macros:
//-----------------------------------------------------------------------
//



//
//-----------------------------------------------------------------------
// Global Variables:
//-----------------------------------------------------------------------
//

static double electrons[] = {0.0000, 7459.6630, 13767.1800, 18773.1200, 24107.0200,
			     28500.7400, 33193.8400, 38050.9300, 42503.3300,
			     46290.9700, 50125.6100, 53964.8200, 58868.7600,
			     62040.8200, 66398.8000, 70535.2300, 73929.2800,
			     77665.7400, 81956.0800, 85632.3900, 88642.8300,
			     92540.0000, 95749.8800, 99854.2100, 103084.0000,
			     106711.6000, 110014.8000, 113027.0000, 116854.8000,
			     120015.4000, 123669.8000, 126384.4000, 129498.8000,
			     133382.0000, 136141.2000, 139290.3000, 142051.4000,
			     144244.6000, 146989.9000, 149160.3000};

static double volts[] = {0.0000, 0.0996, 0.1744, 0.2396, 0.2984, 0.3520, 0.4056,
			 0.4564, 0.5052, 0.5520, 0.5988, 0.6428, 0.6868, 0.7268,
			 0.7664, 0.8020, 0.8328, 0.8652, 0.8944, 0.9216, 0.9452,
			 0.9680, 0.9916, 1.0152, 1.0392, 1.0604, 1.0792, 1.0952,
			 1.1076, 1.1160, 1.1196, 1.1244, 1.1268, 1.1276, 1.1280,
			 1.1284, 1.1288, 1.1292, 1.1284, 1.1284};



static const double CSUM_INT    = 347.00; // Center Sum integration time (us)
static const double XROI_INT    = 467.67; // X Edge ROI integration time (us)
static const double YROI_INT    = 456.83; // Y Edge ROI integration time (us)



//
//-----------------------------------------------------------------------
// Class Methods:
//-----------------------------------------------------------------------
//



SunSensorEvent::SunSensorEvent(Level0Profiles &l0p) 
{
  SunSensorRecord *SSS;
  int i,j,en,len,ndx,len2,sts;
  double tts, pts,lox,hix,loy,hiy,st;
  double rlox,rhix,rloy,rhiy;
  EventVar<int> sums;
  EventVar<double> dsums;
  EventVar<double> azcenter,azextent;


  CF_          = l0p.getConfig();
  Section_     = std::string(l0p.getSection());
  eventNumber_ = l0p.getEventNumber();
  srssflag_    = l0p.getSRSSFlag();
  std::cerr << "SunSensorEvent::SunSensorEvent " << eventNumber_ << "\n" ;
  
  for(i=0;i<l0p.size();i++)
  {
    tts  = l0p.getTrackTimeStamp(i);
    pts  = l0p.getPixelTimeStamp(i);
    lox  = l0p.getTrackLowX(i);
    hix  = l0p.getTrackHighX(i);
    loy  = l0p.getTrackLowY(i);
    hiy  = l0p.getTrackHighY(i);
    rlox = l0p.getROILowX(i);
    rhix = l0p.getROIHighX(i);
    rloy = l0p.getROILowY(i);
    rhiy = l0p.getROIHighY(i);
    sts  = l0p.getTrackStatus(i);
    sums = l0p.getSumsData(i);
    dsums= l0p.getDSumsData(i);
//    std::cerr << tts << " " << lox << " " << hix << " " << dsums.size() << " *** ";
//    for(int i=0; i< dsums.size(); i++)
//      std::cerr << dsums[i] << " ";
//    std::cerr << "\n";
//    SSS = new SunSensorRecord(tts,lox,hix,loy,hiy,pts,sums,sts);
    SSS = new SunSensorRecord(tts,rlox,rhix,rloy,rhiy,pts,dsums,sts);
    sssVec_.push_back(SSS);
  }
//  std::cerr << "done\n";
  azcenter = (l0p.getTrackLowY() + l0p.getTrackHighY()) / 2.0;
  azcenter.setName("V1 Production");
  AzCenter_.addEventVar(azcenter);
  azextent = (l0p.getTrackHighY() - l0p.getTrackLowY());
  azextent.setName("V1 Production");
  AzExtent_.addEventVar(azextent);
}


SunSensorEvent::~SunSensorEvent()
{

//  std::cerr << "SunSensorEvent::~SunSensorEvent...";

  for(int i=0;i<sssVec_.size();i++)
  {
//    delete sssVec_[i];
//    sssVec_[i] = NULL;
  }
  sssVec_.clear();
//  std::cerr << "done\n";
}

void SunSensorEvent::doIntegrationTimeCorrection(void)
{
  for(int i=0;i<sssVec_.size();i++)
  {
    if(sssVec_[i]->detectType() > 0)
    {
      sssVec_[i]->doIntegrationTimeCorrection(eventNumber_);
    }
  }
}


void SunSensorEvent::doFlatFieldCorrections(Event& SD)
{
  std::string fname;
  std::string prname  = "PixelResponse";
  std::string prFile  = "PixelResponseFile";
  std::string accFile = "PixelDataFile";
  std::ofstream outfile;

  std::cerr << "SunSensorEvent::doFlatFieldCorrections..." << eventNumber_;

//
// Get Relative Pixel Repsonse data
//
  EventVar<double> PixelResponse(prname,1.0,(size_t)1024,(size_t)1024);
  if(SD.EventVarExists(prname))
    SD.getEventVar(prname,PixelResponse);
  else
  {
    if(CF_.ValidEntry(Section_,prFile))
    {
      fname  = CF_.GetStr(Section_,prFile);
      PixelResponse.readVar(fname);
    }
    SD.addEventVar(PixelResponse);
  }

  if(CF_.ValidEntry(Section_,accFile))
  {
    fname  = CF_.GetStr(Section_,accFile);
    outfile.open(fname.c_str(),std::ofstream::out | std::ofstream::app);
  }

  for(int i=0;i<sssVec_.size();i++)
  {
    if(sssVec_[i]->detectType() > 0)
    {
      sssVec_[i]->doFlatField(PixelResponse,outfile,eventNumber_);
    }
  }
//  std::cerr << "done\n";

}



void SunSensorEvent::doNonLinearityCorrections(Event& SD)
{
  std::string fname;
  std::string prname  = "PixelResponse";
  std::string prFile  = "PixelResponseFile";
  std::string accFile = "PixelDataFile";
  std::ofstream outfile;

//  std::cerr << "SunSensorEvent::doFlatFieldCorrections...";

//
// Get Relative Pixel Repsonse data
//
  int len = sizeof(volts)/sizeof(double);

  EventVar<double> Counts(volts,len);
  EventVar<double> Intensity(electrons,len);
  Intensity = 1023.0 * Intensity / 95094.49862;
  Counts    = 1023.0 * Counts / 1.127834561;
  Intensity.setName("Intensity");
  Counts.setName("Counts");
//  Intensity.Plot("Intensity vs. Counts","",Counts);
  for(int i=0;i<sssVec_.size();i++)
  {
    if(sssVec_[i]->detectType() > 0)
    {
      sssVec_[i]->correctNonLinearity(Intensity,Counts);
    }
  }
//  std::cerr << "done\n";

}



void SunSensorEvent::determineLocations(void)
{
//  std::cerr << "determineLocations\n";

  for(int i=0;i<sssVec_.size();i++)
  {
    if(sssVec_[i]->detectType() > 0)
    {
      sssVec_[i]->correctEdgeLocations();
      sssVec_[i]->determineCenterSumsLocation();
    }
  }
//  std::cerr << "done\n";

}


EventVar<int> SunSensorEvent::getRecordType(EventVar<int> &ev)
{
  int i;
  int len = sssVec_.size();
  ev.resize(len);

  for(i=0;i<len;i++)
    ev[i] = sssVec_[i]->getRecordType();

  return ev;
}
  

EventVar<double> SunSensorEvent::getPixelTimeStamp(EventVar<double> &ev)
{
  int i;
  int len = sssVec_.size();
  ev.resize(len);

  for(i=0;i<len;i++)
    ev[i] = sssVec_[i]->getPixelTimeStamp();

  return ev;
}
  

EventVar<double> SunSensorEvent::getTrackTimeStamp(EventVar<double> &ev)
{
  int i;
  int len = sssVec_.size();
  ev.resize(len);

  for(i=0;i<len;i++)
    ev[i] = sssVec_[i]->getTrackTimeStamp();

  return ev;
}
  


EventVar<double> SunSensorEvent::getTrackLoX(EventVar<double> &ev)
{
  int i;
  int len = sssVec_.size();
  ev.resize(len);

  for(i=0;i<len;i++)
    ev[i] = sssVec_[i]->getTrackLoX();

  return ev;
}
  


EventVar<double> SunSensorEvent::getTrackHiX(EventVar<double> &ev)
{
  int i;
  int len = sssVec_.size();
  ev.resize(len);

  for(i=0;i<len;i++)
    ev[i] = sssVec_[i]->getTrackHiX();

  return ev;
}
  


EventVar<double> SunSensorEvent::getTrackLoY(EventVar<double> &ev)
{
  int i;
  int len = sssVec_.size();
  ev.resize(len);

  for(i=0;i<len;i++)
    ev[i] = sssVec_[i]->getTrackLoY();

  return ev;
}
  

EventVar<double> SunSensorEvent::getTrackHiY(EventVar<double> &ev)
{
  int i;
  int len = sssVec_.size();
  ev.resize(len);

  for(i=0;i<len;i++)
    ev[i] = sssVec_[i]->getTrackHiY();

  return ev;
}
  

EventVarVect<double> SunSensorEvent::getCenterAvePixVals(EventVarVect<double> &evv)
{
  int i,j;
  int len  = sssVec_.size();
  int nave;
  std::string name = evv.getName();
  std::string description = evv.getDescription();
  std::string str;
  EventVar<double> tmp;
  sssVec_[0]->getCenterAvePixVals(tmp);

  nave = tmp.size();
  evv.clear();

  tmp.resize(len);
  for(i=0;i<nave;i++)
  {
    str = "CenterAvePixVals_" + GATS_Utilities::ConvertToString(i);
    tmp.setName(str);
    evv.addEventVar(tmp);
  }

  for(i=0;i<len;i++)
  {
    sssVec_[i]->getCenterAvePixVals(tmp);
    for(j=0;j<nave;j++)
    {
      evv[j][i] = tmp[j];
    }
  }
//  evv = correctNonLinearity(evv);
  evv.setName(name);
  evv.setDescription(description);
  return evv;
}
  


EventVarVect<double> SunSensorEvent::getAveragePixVals(EventVarVect<double> &evv)
{
  int i,j;
  int len  = sssVec_.size();
  int nave;
  std::string name = evv.getName();
  std::string description = evv.getDescription();
  std::string str;
  EventVar<double> tmp;
  sssVec_[0]->getAvePixVals(tmp);

  nave = tmp.size();
  evv.clear();

  tmp.resize(len);
  for(i=0;i<nave;i++)
  {
    str = "AveragePixVals_" + GATS_Utilities::ConvertToString(i);
    tmp.setName(str);
    evv.addEventVar(tmp);
  }

  for(i=0;i<len;i++)
  {
    sssVec_[i]->getAvePixVals(tmp);
    for(j=0;j<nave;j++)
    {
      evv[j][i] = tmp[j];
    }
  }
//  evv = correctNonLinearity(evv);
  evv.setName(name);
  evv.setDescription(description);
  return evv;
}
  
  
EventVarVect<double> SunSensorEvent::getCenterSums(EventVarVect<double> &evv)
{
  int i,j;
  int len  = sssVec_.size();
  int nave;
  std::string name = evv.getName();
  std::string description = evv.getDescription();
  std::string str;
  EventVar<double> tmp;

  sssVec_[0]->getCenterSums(tmp);
  nave = tmp.size();
  evv.clear();
  
  tmp.resize(len);
  for(i=0;i<nave;i++)
  {
    str = "CenterSums_" + GATS_Utilities::ConvertToString(i);
    tmp.setName(str);
    evv.addEventVar(tmp);
  }

  for(i=0;i<len;i++)
  {
    sssVec_[i]->getCenterSums(tmp);
    for(j=0;j<nave;j++)
    {
      evv[j][i] = tmp[j];
    }
  }
  evv.setName(name);
  evv.setDescription(description);
  return evv;
}
  


EventVarVect<double> SunSensorEvent::getCenterSumsOffsets(EventVarVect<double> &evv)
{
  int i,j;
  int len  = sssVec_.size();
  int nave;
  std::string name = evv.getName();
  std::string description = evv.getDescription();
  std::string str;
  EventVar<double> tmp;

  sssVec_[0]->getCenterSumsX(tmp);
  nave = tmp.size();
  evv.clear();
  
  tmp.resize(len);
  for(i=0;i<nave;i++)
  {
    str = "CenterSumsX_" + GATS_Utilities::ConvertToString(i);
    tmp.setName(str);
    evv.addEventVar(tmp);
  }

  for(i=0;i<len;i++)
  {
    sssVec_[i]->getCenterSumsX(tmp);
    for(j=0;j<nave;j++)
    {
      evv[j][i] = tmp[j];
    }
  }
  evv.setName(name);
  evv.setDescription(description);
  return evv;
}
  
EventVarVect<int> SunSensorEvent::getCenterSumsRows(EventVarVect<int> &evv)
{
  int i,j;
  int len  = sssVec_.size();
  int nave;
  std::string name = evv.getName();
  std::string description = evv.getDescription();
  std::string str;
  EventVar<int> tmp;

  sssVec_[0]->getCenterSumsRows(tmp);
  nave = tmp.size();
  evv.clear();
  
  tmp.resize(len);
  for(i=0;i<nave;i++)
  {
    str = "CenterSums_" + GATS_Utilities::ConvertToString(i);
    tmp.setName(str);
    evv.addEventVar(tmp);
  }

  for(i=0;i<len;i++)
  {
    sssVec_[i]->getCenterSumsRows(tmp);
    for(j=0;j<nave;j++)
    {
      evv[j][i] = tmp[j];
    }
  }
  evv.setName(name);
  evv.setDescription(description);
  return evv;
}


EventVarVect<int> SunSensorEvent::getAverageLocations(EventVarVect<int> &evv)
{
  int i,j;
  int len  = sssVec_.size();
  int nave;
  std::string name = evv.getName();
  std::string description = evv.getDescription();
  std::string str;
  EventVar<int> tmp;

  sssVec_[0]->getAverageLocations(tmp);
  nave = tmp.size();
  evv.clear();
  
  tmp.resize(len);
  for(i=0;i<nave;i++)
  {
    str = "CenterSums_" + GATS_Utilities::ConvertToString(i);
    tmp.setName(str);
    evv.addEventVar(tmp);
  }

  for(i=0;i<len;i++)
  {
    sssVec_[i]->getAverageLocations(tmp);
    for(j=0;j<nave;j++)
    {
      evv[j][i] = tmp[j];
    }
  }
  evv.setName(name);
  evv.setDescription(description);
  return evv;
}
  

EventVar<double> SunSensorEvent::calcExtent(void)
{
  double stddev;

  EventVar<double> Loy;
  EventVar<double> Hiy;
  EventVar<double> Extent;

  Loy = getTrackLoY(Loy);
  Hiy = getTrackHiY(Hiy);

  Extent = Hiy - Loy;
  return Extent;
}


void SunSensorEvent::plotAzCenter(void)
{
  EventVar<double> azlo,azhi,azcenter,azextent;
  std::string str = "Event " + GATS_Utilities::ConvertToString(eventNumber_);

  
  azhi = getTrackHiY(azhi);
  azlo = getTrackLoY(azlo);
  azcenter = (azhi + azlo) / 2.0;
  azcenter.setName("Corrected");
  AzCenter_.addEventVar(azcenter);
  AzCenter_.Plot("Solar Center (Azimuth)",str);
  azextent = (azhi - azlo);
  azextent.setName("Corrected");
  AzExtent_.addEventVar(azextent);
  AzExtent_.Plot("Solar Extent (Azimuth)",str);
}


void SunSensorEvent::writeExoAtmosphericDataXYZ(void)
{
  const int nelem = 7;
  int top[nelem]    = {0,1,2,3,4,5,6};
  int bottom[nelem] = {7,8,9,10,11,12,13};
  int center[nelem] = {24,25,26,27,28,29,30};
  int len = sssVec_.size();
  int mid = len / 2;
  int first = mid - 200;
  int last  = mid + 200;
  int l;
  double dloc;

  double tmp = 0.0;
  double maxint = 0.0;
  EventVar<double> avepix;
  EventVar<int> locs;
//  valarray<bool> good  = ((PixelTimeStamp_ >= 60.0) &&
//			  (PixelTimeStamp_ <= 80.0));

  for(int i=first; i<=last; i++)
  {
    sssVec_[i]->getAvePixVals(avepix);
    tmp    = avepix.max();
    maxint = (maxint > tmp) ? maxint : tmp;
  }

  double edge_max_int =  maxint * XROI_INT / CSUM_INT; 
  std::string fname;
  std::string base = GATS_Utilities::ConvertToString(eventNumber_) + ".dat";
  std::ofstream outfile;

  fname = "EdgeData/TopEdge_XYZ_" + base;
  outfile.open(fname.c_str(),std::ofstream::out);
  for(int i=first; i<=last; i++)
  {
    double hix = sssVec_[i]->getTrackHiX();
    double lox = sssVec_[i]->getTrackLoX();
    sssVec_[i]->getAvePixVals(avepix);
    sssVec_[i]->getAverageLocations(locs);
    for(int j=0; j<nelem; j++)
    {
      l = top[j];
      dloc = (double)locs[l] - lox;
      outfile << dloc << ", ";
      outfile << (avepix[l] / edge_max_int) << "\n";
    }
  }
  outfile.close();

  fname = "EdgeData/BottomEdge_XYZ_" + base;
  outfile.open(fname.c_str(),std::ofstream::out);
  for(int i=first; i<=last; i++)
  {
    double hix = sssVec_[i]->getTrackHiX();
    double lox = sssVec_[i]->getTrackLoX();
    sssVec_[i]->getAvePixVals(avepix);
    sssVec_[i]->getAverageLocations(locs);
    for(int j=0; j<nelem; j++)
    {
      l = bottom[j];
      dloc = (double)locs[l] - lox;
      outfile << dloc << ", ";
      outfile << (avepix[l] / edge_max_int) << "\n";
    }
  }
  outfile.close();

  fname = "EdgeData/Center_XYZ_" + base;
  outfile.open(fname.c_str(),std::ofstream::out);
  for(int i=first; i<=last; i++)
  {
    double hix = sssVec_[i]->getTrackHiX();
    double lox = sssVec_[i]->getTrackLoX();
    sssVec_[i]->getAvePixVals(avepix);
    sssVec_[i]->getAverageLocations(locs);
    for(int j=0; j<nelem; j++)
    {
      l = center[j];
      dloc = (double)locs[l] - lox;
      outfile << dloc << ", ";
      outfile << (avepix[l] / edge_max_int) << "\n";
    }
  }
  outfile.close();
}