//
//-----------------------------------------------------------------------
/// @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	Level0Profiles.cpp
///
/// @author	John Burton	<j.c.burton@gats-inc.com>
///
/// @date  	Thu Jan 17 14:08:25 2008
///
//-----------------------------------------------------------------------
//
//-----------------------------------------------------------------------
// Include Files:
//-----------------------------------------------------------------------
//
#include <map>
#include "ChainSawFilter.h"
#include "Level0Profiles.h"
#include "SunSensorRegion.h"
#include "GATS_Utilities.hpp"
#include "Interpolate.h"

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



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

static const double FIXED2FLOAT = 32.0;

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

EventVarVect<double> Level0Profiles::convertSums2Double(EventVarVect<int> intSums)
{
  EventVar<double> tmp;
  EventVarVect<double> doubleSums;
  int i,n,len;

  for(n=0;n<intSums.size(); n++)
  {
    len = intSums[n].size();
    tmp.resize(len);
    for (i=0; i<len; i++)
      tmp[i] = (double)intSums[n][i];
    doubleSums.addEventVar(tmp);
  }
  return doubleSums;
}


Level0Profiles::Level0Profiles(Event& L0, Event& L1, ConfigFile& cf, std::string Section)
{
  

  CF_      = cf;
  Section_ = Section;
  EventVarVect<int> intSums;
  EventVar<double> SunSensorTimeStamp_;

  L0.getEventVar("L0_SolarTrackerTimes",  TrackTimeStamp_);
  L0.getEventVar("L0_SolarImageTimes",    PixelTimeStamp_);
  L0.getEventVar("L0_SolarTrackXLow",     Track_Low_X_);
  L0.getEventVar("L0_SolarTrackXHigh",    Track_High_X_);
  L0.getEventVar("L0_SolarTrackYLow",     Track_Low_Y_);
  L0.getEventVar("L0_SolarTrackYHigh",    Track_High_Y_);
  L0.getEventVar("L0_SolarTrackerStatus", Track_Status_);
  L0.getEventVar("L0_SolarImages",        SumsData_);
  eventNumber_ = L0.getEventNumber();
  srssflag_    = L0.getSRSSFlag();
        
//  L1.getEventVar("L1_DetectorTimes",   SunSensorTimeStamp_);
//  EventVar<double> CorrectedTimeStamp(TrackTimeStamp_);
//  CorrectedTimeStamp[0] = CorrectedTimeStamp[0] * 0.999998505;
//  for(int i=0; i<SunSensorTimeStamp_.size(); i++)
//  {
//    std::cerr << i << ", " << SunSensorTimeStamp_[i] << ", " ;
//    std::cerr << TrackTimeStamp_[i] << ", " << PixelTimeStamp_[i] << "\n";
//  }
  
}


void Level0Profiles::convertFixed2FloatingPoint(void)
{

  Track_Low_X_  = Track_Low_X_  / FIXED2FLOAT;
  Track_High_X_ = Track_High_X_ / FIXED2FLOAT;
  Track_Low_Y_  = Track_Low_Y_  / FIXED2FLOAT;
  Track_High_Y_ = Track_High_Y_ / FIXED2FLOAT;
}



void Level0Profiles::selectFineTrackData(void)
{

  valarray<bool> good = ((Track_Status_ >= 0xA000) &&
			 (Track_High_X_ >  0.0)    &&
			 (Track_Low_X_  >= 0.0)    &&
			 (Track_High_Y_ >  0.0)    &&
			 (Track_Low_Y_  >= 0.0)    &&
                         (SumsData_[6]  >  0));
//std::cout << SumsData_.size() << std::endl;
//std::cout << good.size() << std::endl;
//exit(23);

  good = good && good.cshift(1)&& good.cshift(2);

//for(unsigned jj = 0; jj < 90; ++jj)
//  std::cout << good[jj] << std::endl;

  TrackTimeStamp_ = TrackTimeStamp_[good];
  PixelTimeStamp_ = PixelTimeStamp_[good];
  Track_Low_X_    = Track_Low_X_[good];
  Track_High_X_   = Track_High_X_[good];
  Track_Low_Y_    = Track_Low_Y_[good];
  Track_High_Y_   = Track_High_Y_[good];
  Track_Status_   = Track_Status_[good];

  ROI_Low_X_  = Track_Low_X_;
  ROI_High_X_ = Track_High_X_;
  ROI_Low_Y_  = Track_Low_Y_;
  ROI_High_Y_ = Track_High_Y_;
  
  for(int i=0; i<SumsData_.size(); i++)
    SumsData_[i] = SumsData_[i][good];
  if(CF_.GetFlag(Section_,"PlotTrackingData"))
  {
    EventVarVect<double> evv;
    evv.addEventVar(Track_Low_X_);
    evv.addEventVar(Track_High_X_);
    evv.addEventVar(Track_Low_Y_);
    evv.addEventVar(Track_High_Y_);
    evv.Plot("Raw Tracking Data","After Select");
    evv.clear();
  }

  DSumsData_   = convertSums2Double(SumsData_);

}


void Level0Profiles::correctTimeStamp(void)
{
  int i;
  double delta, tmp, tts, pts;
  double increment = 0.05;
  double correction_factor = 0.999998505;
  EventVar<double> TTS(TrackTimeStamp_.size());
  EventVar<double> PTS(PixelTimeStamp_.size());
//  std::string fname = "./OutputFiles/TimeStamp.dat";
//  std::ofstream outfile;
//  outfile.open(fname.c_str(),std::ofstream::out);

  TTS[0] = TrackTimeStamp_[0] * correction_factor;
  PTS[0] = PixelTimeStamp_[0] * correction_factor;

  tts = TTS[0];
  pts = PTS[0];

  for(i=1; i<TrackTimeStamp_.size(); i++)
  {
    delta  = TrackTimeStamp_[i] - TrackTimeStamp_[i-1];
    tmp    = round(delta/increment);
    tts    = tts + (tmp * increment);
    TTS[i] = tts;
  }
  for(i=1; i<PixelTimeStamp_.size(); i++)
  {
    delta  = PixelTimeStamp_[i] - PixelTimeStamp_[i-1];
    tmp    = round(delta/increment);
    pts    = pts + (tmp * increment);
    PTS[i] = pts;
  }

//  for(i=0;i<TTS.size();i++)
//  {
//    outfile << i << ", ";
//    outfile << TrackTimeStamp_[i] << ", " << TTS[i] << ", ";
//    outfile << PixelTimeStamp_[i] << ", " << PTS[i] << "\n";
//  }
//  outfile.close();
}


void Level0Profiles::filterSumsData(void)
{
  std::string csum_name = "Threshold_csum";
  std::string xsum_name = "Threshold_xsum";
  std::string ysum_name = "Threshold_ysum";
  double csum_threshold = 0.003;
  double xsum_threshold = 0.003;
  double ysum_threshold = 0.003;
  int j;
  if(CF_.ValidEntry(Section_,csum_name))
    csum_threshold  = CF_.GetReal(Section_,csum_name);
  if(CF_.ValidEntry(Section_,xsum_name))
    xsum_threshold  = CF_.GetReal(Section_,xsum_name);
  if(CF_.ValidEntry(Section_,ysum_name))
    ysum_threshold  = CF_.GetReal(Section_,ysum_name);

  int len = ROI_Low_X_.size();
  EventVar<int> low_x_roi_x(len);
  EventVar<int> high_x_roi_x(len);
  EventVar<int> center_roi_x(len);
  EventVar<int> low_y_roi_y(len);
  EventVar<int> high_y_roi_y(len);
  EventVarVect<double> evv;

  for(int i=0; i<len; i++)
  {
    double lox = ROI_Low_X_[i];
    double hix = ROI_High_X_[i];
    double loy = ROI_Low_Y_[i];
    double hiy = ROI_High_Y_[i];
    double midx = (lox + hix) / 2.0;
    double midy = (loy + hiy) / 2.0;
    double ctrx = ((lox * 32.0) + 4279) / 32.0;

    SunSensorRegion lowx(lox,midx,X_ROI);
    SunSensorRegion highx(hix,midx,X_ROI);
    SunSensorRegion lowy(midx,loy,Y_ROI);
    SunSensorRegion highy(midx,hiy,Y_ROI);
    SunSensorRegion center(ctrx,midy,C_ROI);

    low_x_roi_x[i] = lowx.getXCenter();
    high_x_roi_x[i] = highx.getXCenter();
    low_y_roi_y[i]  = lowy.getYCenter();
    high_y_roi_y[i] = highy.getYCenter();
    center_roi_x[i] = center.getXCenter();
  }
  j = 0;

  evv.clear();
  for(int i=0; i<7; i++)
  {
    evv.addEventVar(DSumsData_[i]);
    DSumsData_[i] = applyChainSawFilter(DSumsData_[i], low_x_roi_x, xsum_threshold);
    evv.addEventVar(DSumsData_[i]);
  }
  if(CF_.GetFlag(Section_,"PlotTrackingData"))
    evv.Plot("Low X Sums","Level0Profiles");
  evv.clear();
  for(int i=7; i<14; i++)
  {
    evv.addEventVar(DSumsData_[i]);
    DSumsData_[i] = applyChainSawFilter(DSumsData_[i], high_x_roi_x, xsum_threshold);
    evv.addEventVar(DSumsData_[i]);
  }
  if(CF_.GetFlag(Section_,"PlotTrackingData"))
    evv.Plot("High X Sums","Level0Profiles");
  evv.clear();
  for(int i=14; i<19; i++)
  {
    evv.addEventVar(DSumsData_[i]);
    DSumsData_[i] = applyChainSawFilter(DSumsData_[i], low_y_roi_y, ysum_threshold);
    evv.addEventVar(DSumsData_[i]);
  }
  if(CF_.GetFlag(Section_,"PlotTrackingData"))
    evv.Plot("Low Y Sums","Level0Profiles");
  evv.clear();
  for(int i=19; i<24; i++)
  {
    evv.addEventVar(DSumsData_[i]);
    DSumsData_[i] = applyChainSawFilter(DSumsData_[i], high_y_roi_y, ysum_threshold);
    evv.addEventVar(DSumsData_[i]);
  }
  if(CF_.GetFlag(Section_,"PlotTrackingData"))
    evv.Plot("High Y Sums","Level0Profiles");
  evv.clear();
  for(int i=24; i<31; i++)
  {
    evv.addEventVar(DSumsData_[i]);
    DSumsData_[i] = applyChainSawFilter(DSumsData_[i], center_roi_x, csum_threshold);
    evv.addEventVar(DSumsData_[i]);
  }
  if(CF_.GetFlag(Section_,"PlotTrackingData"))
    evv.Plot("Center Sums","Level0Profiles");
  evv.clear();

}


void Level0Profiles::doChainSawFilter(void)
{
  EventVarVect<double> evv;
  std::string lox_name = "Threshold_lox";
  std::string hix_name = "Threshold_hix";
  std::string loy_name = "Threshold_loy";
  std::string hiy_name = "Threshold_hiy";
  double lox_threshold = 0.000015; 
  double hix_threshold = 0.000015; 
  double loy_threshold = 0.0002; 
  double hiy_threshold = 0.0002; 

  if(CF_.ValidEntry(Section_,lox_name))
    lox_threshold  = CF_.GetReal(Section_,lox_name);
  if(CF_.ValidEntry(Section_,hix_name))
    hix_threshold  = CF_.GetReal(Section_,hix_name);
  if(CF_.ValidEntry(Section_,loy_name))
    loy_threshold  = CF_.GetReal(Section_,loy_name);
  if(CF_.ValidEntry(Section_,hiy_name))
    hiy_threshold  = CF_.GetReal(Section_,hiy_name);

  evv.addEventVar(Track_Low_X_);
  std::cerr << "doChainSawFilter::Track_Low_X\n";
  Track_Low_X_ = applyChainSawFilter(Track_Low_X_,lox_threshold);
  evv.addEventVar(Track_Low_X_);
  if(CF_.GetFlag(Section_,"PlotTrackingData"))
    evv.Plot("Low_X_Track_","Level0Profiles::doChainSawFilter");
  evv.clear();
//  std::cerr << "doChainSawFilter::Track_High_X\n";
  evv.addEventVar(Track_High_X_);
  Track_High_X_ = applyChainSawFilter(Track_High_X_,hix_threshold);
  evv.addEventVar(Track_High_X_);
  if(CF_.GetFlag(Section_,"PlotTrackingData"))
    evv.Plot("High_X_Track_","Level0Profiles::doChainSawFilter");
  evv.clear();
//  std::cerr << "doChainSawFilter::Track_Low_Y\n";
  Track_Low_Y_ = applyChainSawFilter(Track_Low_Y_,loy_threshold);
//  std::cerr << "doChainSawFilter::Track_High_Y\n";
  Track_High_Y_ = applyChainSawFilter(Track_High_Y_,hiy_threshold);
//  Track_Low_X_.Plot("Track_Low_X_","After Chainsaw Filter");
  if(CF_.GetFlag(Section_,"PlotTrackingData"))
  {
    EventVarVect<double> evv;
    evv.addEventVar(Track_Low_X_);
    evv.addEventVar(Track_High_X_);
    evv.addEventVar(Track_Low_Y_);
    evv.addEventVar(Track_High_Y_);
    evv.Plot("Filtered Tracking Data","Level0Profiles::doChainSawFilter");
    evv.clear();
  }


}






EventVarVect<double> Level0Profiles::timeAlignSumsData(EventVarVect<double> &sums, 
						       EventVarVect<int> &locs, double &shft)
{
  int nelem = sums.size();
  int nlen  = sums[0].size();
  int minrow = 1023;
  int maxrow = 0;
  int tmp,i,j;
  std::string str;
  std::map<int, int> rows;
  std::map<int, int> revs;
  EventVarVect<double> unsums;
  EventVarVect<double> outsums;
  EventVarVect<double> tmpsums;
  EventVar<double> evtmp(nlen);
  EventVar<double> ts;

  evtmp.setValueZero();
  for(i=0;i<nelem;i++)
    outsums.addEventVar(evtmp);

  ts = PixelTimeStamp_ - shft;

  for(int i=0; i<nlen; i++)
  {
    tmp = locs[i].min();
    minrow = (minrow > tmp) ? tmp : minrow;
    tmp = locs[i].max();
    maxrow = (maxrow < tmp) ? tmp : maxrow;
  }
  minrow = minrow - 1;
  maxrow = maxrow + 1;
  j = 0;
  for(i=0;i<1024;i++)
    unsums.addEventVar(evtmp);
  
  for(i=0; i<nelem; i++)
  {
    for(j=0; j<nlen; j++)
    {
      tmp = locs[j][i];
      unsums[tmp][j] = sums[i][j];
    }
  }
  for(i=0; i<1024; i++)
  {
    int count = 0;
    for(j=0; j<nlen; j++)
      if(unsums[i][j]>0)
	count++;
    if(count>500)
      tmpsums.addEventVar(unsums[i]);
  }
  int ext = 1;
  for(i=0; i<unsums.size(); i++)
  {
    unsums[i] = unsums[i].VInterpol(ts,PixelTimeStamp_,ext);
  }
  EventVar<int> tmploc(sums[0].size());
  for(i=0; i<sums.size(); i++)
  {
    for(j=0; j<sums[0].size(); j++)
      tmploc[j] = locs[j][i];
    sums[i] = VInterpolate(tmploc,sums[i],ts,PixelTimeStamp_);
  }

  for(i=0; i<nelem; i++)
  {
    for(j=0; j<nlen; j++)
    {
      tmp = locs[j][i];
      outsums[i][j] = unsums[tmp][j];
    }
  }
  return outsums;
}



void Level0Profiles::alignSumsData2TimeGrid(void)
{
  int j;
  int len = ROI_Low_X_.size();
  std::string hix_name = "HighXSumTimeShift";
  std::string lox_name = "LowXSumTimeShift";
  std::string hiy_name = "HighSumYTimeShift";
  std::string loy_name = "LowYSumTimeShift";
  std::string ctr_name = "CenterSumTimeShift";
  EventVarVect<double> low_x_sums;
  EventVarVect<double> high_x_sums;
  EventVarVect<double> low_y_sums;
  EventVarVect<double> high_y_sums;
  EventVarVect<double> center_sums;

  EventVarVect<int> low_x_loc;
  EventVarVect<int> high_x_loc;
  EventVarVect<int> low_y_loc;
  EventVarVect<int> high_y_loc;
  EventVarVect<int> center_loc;
  EventVarVect<int> evv;
  EventVar<int> itmp;

//  double hix_ts = 0.02232;
//  double lox_ts = 0.02072;
//  double hix_ts = 0.0015605;
//  double lox_ts = -0.00175509;
  double hix_ts = 0.00115636;
  double lox_ts = 1.3407e-08;
  double hiy_ts = 0.0;
  double loy_ts = 0.0;
  double ctr_ts = 0.0166074;

  if(CF_.ValidEntry(Section_,hix_name))
    hix_ts= CF_.GetReal(Section_,hix_name);
  if(CF_.ValidEntry(Section_,lox_name))
    lox_ts= CF_.GetReal(Section_,lox_name);
  if(CF_.ValidEntry(Section_,hiy_name))
    hiy_ts= CF_.GetReal(Section_,hiy_name);
  if(CF_.ValidEntry(Section_,loy_name))
    loy_ts= CF_.GetReal(Section_,loy_name);
  if(CF_.ValidEntry(Section_,ctr_name))
    ctr_ts= CF_.GetReal(Section_,ctr_name);

  for(int i=0; i<len; i++)
  {
    double lox = ROI_Low_X_[i];
    double hix = ROI_High_X_[i];
    double loy = ROI_Low_Y_[i];
    double hiy = ROI_High_Y_[i];
    double midx = (lox + hix) / 2.0;
    double midy = (loy + hiy) / 2.0;
    double ctrx = ((lox * 32.0) + 4279) / 32.0;

    SunSensorRegion lowx(lox,midx,X_ROI);
    SunSensorRegion highx(hix,midx,X_ROI);
    SunSensorRegion lowy(midx,loy,Y_ROI);
    SunSensorRegion highy(midx,hiy,Y_ROI);
    SunSensorRegion center(ctrx,midy,C_ROI);

    itmp = lowx.getXLocs();
    low_x_loc.addEventVar(itmp);
    itmp = highx.getXLocs();
    high_x_loc.addEventVar(itmp);
    itmp = lowy.getYLocs();
    low_y_loc.addEventVar(itmp);
    itmp = highy.getYLocs();
    high_y_loc.addEventVar(itmp);
    itmp = center.getXLocs();
    center_loc.addEventVar(itmp);
  }
  for(int i=0; i<7; i++)
    low_x_sums.addEventVar(DSumsData_[i]);
  for(int i=7; i<14; i++)
    high_x_sums.addEventVar(DSumsData_[i]);
  for(int i=14; i<19; i++)
    low_y_sums.addEventVar(DSumsData_[i]);
  for(int i=19; i<24; i++)
    high_y_sums.addEventVar(DSumsData_[i]);
  for(int i=24; i<31; i++)
    center_sums.addEventVar(DSumsData_[i]);

  low_x_sums = timeAlignSumsData(low_x_sums, low_x_loc, lox_ts);
  high_x_sums = timeAlignSumsData(high_x_sums, high_x_loc, hix_ts);
  low_y_sums = timeAlignSumsData(low_y_sums, low_y_loc, loy_ts);
  high_y_sums = timeAlignSumsData(high_y_sums, high_y_loc, hiy_ts);
  center_sums = timeAlignSumsData(center_sums, center_loc, ctr_ts);

  j = 0;
  for(int i=0; i<7; i++)
    DSumsData_[j++] = low_x_sums[i];
  for(int i=0; i<7; i++)
    DSumsData_[j++] = high_x_sums[i];
  for(int i=0; i<5; i++)
    DSumsData_[j++] = low_y_sums[i];
  for(int i=0; i<5; i++)
    DSumsData_[j++] = high_y_sums[i];
  for(int i=0; i<7; i++)
    DSumsData_[j++] = center_sums[i];
}


void Level0Profiles::alignSumsData2TimeGrid(double *par)
{
  int j;
  int len = ROI_Low_X_.size();
  EventVarVect<double> low_x_sums;
  EventVarVect<double> high_x_sums;
  EventVarVect<double> low_y_sums;
  EventVarVect<double> high_y_sums;
  EventVarVect<double> center_sums;

  EventVarVect<int> low_x_loc;
  EventVarVect<int> high_x_loc;
  EventVarVect<int> low_y_loc;
  EventVarVect<int> high_y_loc;
  EventVarVect<int> center_loc;
  EventVar<int> itmp;

  double hix_ts = 0.00115636;
  double lox_ts = 1.3407e-08;
  double ctr_ts =  0.0166074;;
//  double hix_ts = par[0];
//  double lox_ts = par[1];
//  double ctr_ts = par[3];
  double hiy_ts = par[0];
  double loy_ts = par[1];
//  double hiy_ts = par[2];
//  double loy_ts = par[3];
//  double ctr_ts = par[4];
//  double hix_ts = par[4];
//  double lox_ts = par[5];
//  double hiy_ts = par[6];
//  double loy_ts = par[7];
//  double ctr_ts = par[8];

  for(int i=0; i<len; i++)
  {
    double lox = ROI_Low_X_[i];
    double hix = ROI_High_X_[i];
    double loy = ROI_Low_Y_[i];
    double hiy = ROI_High_Y_[i];
    double midx = (lox + hix) / 2.0;
    double midy = (loy + hiy) / 2.0;
    double ctrx = ((lox * 32.0) + 4279) / 32.0;

    SunSensorRegion lowx(lox,midx,X_ROI);
    SunSensorRegion highx(hix,midx,X_ROI);
    SunSensorRegion lowy(midx,loy,Y_ROI);
    SunSensorRegion highy(midx,hiy,Y_ROI);
    SunSensorRegion center(ctrx,midy,C_ROI);

    itmp = lowx.getXLocs();
    low_x_loc.addEventVar(itmp);
    itmp = highx.getXLocs();
    high_x_loc.addEventVar(itmp);
    itmp = lowy.getYLocs();
    low_y_loc.addEventVar(itmp);
    itmp = highy.getYLocs();
    high_y_loc.addEventVar(itmp);
    itmp = center.getXLocs();
    center_loc.addEventVar(itmp);
  }
  for(int i=0; i<7; i++)
    low_x_sums.addEventVar(DSumsData_[i]);
  for(int i=7; i<14; i++)
    high_x_sums.addEventVar(DSumsData_[i]);
  for(int i=14; i<19; i++)
    low_y_sums.addEventVar(DSumsData_[i]);
  for(int i=19; i<24; i++)
    high_y_sums.addEventVar(DSumsData_[i]);
  for(int i=24; i<31; i++)
    center_sums.addEventVar(DSumsData_[i]);

//  low_x_sums.Plot("Before timeAlignSumsData","");
  low_x_sums = timeAlignSumsData(low_x_sums, low_x_loc, lox_ts);
  high_x_sums = timeAlignSumsData(high_x_sums, high_x_loc, hix_ts);
  low_y_sums = timeAlignSumsData(low_y_sums, low_y_loc, loy_ts);
  high_y_sums = timeAlignSumsData(high_y_sums, high_y_loc, hiy_ts);
  center_sums = timeAlignSumsData(center_sums, center_loc, ctr_ts);

//  low_x_sums.Plot("After timeAlignSumsData","");
  j = 0;
  for(int i=0; i<7; i++)
    DSumsData_[j++] = low_x_sums[i];
  for(int i=0; i<7; i++)
    DSumsData_[j++] = high_x_sums[i];
  for(int i=0; i<5; i++)
    DSumsData_[j++] = low_y_sums[i];
  for(int i=0; i<5; i++)
    DSumsData_[j++] = high_y_sums[i];
  for(int i=0; i<7; i++)
    DSumsData_[j++] = center_sums[i];
}



void Level0Profiles::alignTrackingData2TimeGrid(void)
{
  EventVarVect<double> tvect;
  EventVar<double> hix_ts, lox_ts, hiy_ts, loy_ts;

  hix_ts   = PixelTimeStamp_ - 0.05260;
  lox_ts   = PixelTimeStamp_ - 0.05100;
  hiy_ts   = PixelTimeStamp_ - 0.07825;
  loy_ts   = PixelTimeStamp_ - 0.06825;

  Track_Low_X_ = Track_Low_X_.VInterpol(lox_ts, PixelTimeStamp_);
  Track_High_X_ = Track_High_X_.VInterpol(hix_ts, PixelTimeStamp_);
  Track_Low_Y_  = Track_Low_Y_.VInterpol(loy_ts, PixelTimeStamp_);
  Track_High_Y_ = Track_High_Y_.VInterpol(hiy_ts, PixelTimeStamp_);
  
}

void Level0Profiles::alignTrackingData2TimeGrid(double *par)
{
  EventVarVect<double> tvect;
  EventVar<double> hix_ts, lox_ts, hiy_ts, loy_ts;

  hix_ts   = PixelTimeStamp_ - 0.05260;
  lox_ts   = PixelTimeStamp_ - 0.05100;
  hiy_ts   = PixelTimeStamp_ - par[2];
  loy_ts   = PixelTimeStamp_ - par[3];

  Track_Low_X_ = Track_Low_X_.VInterpol(lox_ts, PixelTimeStamp_);
  Track_High_X_ = Track_High_X_.VInterpol(hix_ts, PixelTimeStamp_);
  Track_Low_Y_  = Track_Low_Y_.VInterpol(loy_ts, PixelTimeStamp_);
  Track_High_Y_ = Track_High_Y_.VInterpol(hiy_ts, PixelTimeStamp_);
  
  ROI_Low_Y_  = Track_Low_Y_;
  ROI_High_Y_ = Track_High_Y_;
  
}

EventVar<int> Level0Profiles::getSumsData(int i) 
{ 
  int j;
  int len = SumsData_.size();
  EventVar<int> tmp(len);

  for(j=0;j<len;j++)
  {
    tmp[j] = SumsData_[j][i];
  }
  return tmp;
}

EventVar<double> Level0Profiles::getDSumsData(int i) 
{ 
  int j;
  int len = DSumsData_.size();
  EventVar<double> tmp(len);

  for(j=0;j<len;j++)
  {
    tmp[j] = DSumsData_[j][i];
  }
  return tmp;
}