//
//  $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.
//
//-----------------------------------------------------------------------
//
// Module:	Event.cpp
//
// Author:	John Burton	<john@traveler.gats-inc.com>
//
// Date:  	Wed May  3 15:02:52 2006
//
//-----------------------------------------------------------------------
//
// Modification History:
//
//     $Log$
//
//-----------------------------------------------------------------------
//
//-----------------------------------------------------------------------
// Include Files:
//-----------------------------------------------------------------------
//
#include "Event.h"
#include "EventVar.h"
#include "EventVarVect.h"
#include <map>
#include <vector>
#include <string>
#include <iostream>
#include <time.h>
#include <stdexcept>

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



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



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

std::string Event::timestamp()
{
  struct tm   *tmp;
  time_t       t;
  char         outstr[256];
  char        *format = "%F %T";

  t   = time(NULL);
  tmp = localtime(&t);
  strftime(outstr,sizeof(outstr),format,tmp);

  return std::string(outstr);
}



void Event::init()
{

  EventLogEnabled  = false;
  TimeStampEnabled = false;
  
  EventNumber    = -9999;
  OrbitNumber    = -9999;
  SR_SS_Flag     = 'X';
  EventStartTime = -9999;
  EventStopTime  = -9999;
  Latitude83km   = -9999;
  Longitude83km  = -9999;
}


Event::Event()
{
  init();
}

Event::Event(int en)
{
  init();
  EventNumber    = en;
}


Event::Event(int en, int on)
{
  init();
  EventNumber    = en;
  OrbitNumber    = on;
}

Event::Event(int en, int on, char flag)
{
  init();
  EventNumber    = en;
  OrbitNumber    = on;
  SR_SS_Flag     = flag;
}

Event::Event(int en, int on, char flag, int start)
{
  init();
  EventNumber    = en;
  OrbitNumber    = on;
  SR_SS_Flag     = flag;
  EventStartTime = start;
}

Event::Event(int en, int on, char flag, int start, int stop)
{
  init();
  EventNumber    = en;
  OrbitNumber    = on;
  SR_SS_Flag     = flag;
  EventStartTime = start;
  EventStopTime  = stop;
}


Event::Event(int en, int on, char flag, int start, int stop, float lat)
{
  init();
  EventNumber    = en;
  OrbitNumber    = on;
  SR_SS_Flag     = flag;
  EventStartTime = start;
  EventStopTime  = stop;
  Latitude83km   = lat;
}


Event::Event(int en, int on, char flag, int start, int stop, float lat, float lon)
{
  init();
  EventNumber    = en;
  OrbitNumber    = on;
  SR_SS_Flag     = flag;
  EventStartTime = start;
  EventStopTime  = stop;
  Latitude83km   = lat;
  Longitude83km  = lon;
}


Event::~Event()
{
  EventLog.clear();
  intEventVarMap.clear();
  floatEventVarMap.clear();
  doubleEventVarMap.clear();
}


void Event::clear()
{
  EventLog.clear();
  intEventVarMap.clear();
  floatEventVarMap.clear();
  doubleEventVarMap.clear();
  init();
}


void Event::openEventLog()
{
  bool temp;

  temp = TimeStampEnabled;
  EventLogEnabled  = true;
  TimeStampEnabled = true;
  addLogEntry(" - START EVENT LOG");
  TimeStampEnabled = temp;

}

void Event::openEventLog(std::string filename)
{
  bool temp;

  temp = TimeStampEnabled;

  logfile.open(filename.c_str(),std::ofstream::out | std::ofstream::app);

  if(logfile.bad()){
    std::string errstr = "Cannot Open Log FIle " + filename;
    throw std::runtime_error(errstr);
  }
  
  EventLogEnabled  = true;
  TimeStampEnabled = true;
  addLogEntry(" - START EVENT LOG");
  TimeStampEnabled = temp;
}

void Event::openEventLog(char *filename)
{
  bool temp;

  temp = TimeStampEnabled;

  logfile.open(filename,std::ofstream::out | std::ofstream::app);

  if(logfile.bad()){
    std::string errstr = "Cannot Open Log FIle " + std::string(filename);
    throw std::runtime_error(errstr);
  }
  
  EventLogEnabled  = true;
  TimeStampEnabled = true;
  addLogEntry(" - START EVENT LOG");
  TimeStampEnabled = temp;
}


void Event::addLogEntry(std::string entry)
{
  if(EventLogEnabled){
    if(TimeStampEnabled)
      entry = timestamp() + " " + entry;
    EventLog.push_back(entry);
    if(logfile.is_open())
      logfile << entry << std::endl;
  }
}


void Event::closeEventLog()
{
  TimeStampEnabled = true;
  addLogEntry(" - STOP EVENT LOG");
  TimeStampEnabled = false;
  EventLogEnabled  = false;
  if(logfile.is_open())
    logfile.close();
}

void Event::enableLogTimeStamp()
{
  TimeStampEnabled = true;
}

void Event::disableLogTimeStamp()
{
  TimeStampEnabled = false;
}


void Event::PrintLog()
{
  time_t rawtime;
  std::string entry;
  char *timestr;

  time(&rawtime);
  timestr = ctime(&rawtime);
  timestr[24] = '\0';
  entry = "* * * PRINTED EVENT LOG " + std::string(timestr) + " * * *";
  int i;
  for(i=0;i<EventLog.size();i++)
    std::cout << EventLog[i] << "\n";
  std::cout << entry << "\n";

}


int Event::EventVarExists(std::string name)
{
  std::map<std::string,EventVarVect<int> *>::iterator iter;
  std::map<std::string,EventVarVect<float> *>::iterator fter;
  std::map<std::string,EventVarVect<double> *>::iterator dter;

  iter = intEventVarMap.find(name);
  if(iter != intEventVarMap.end())
    return INTEGER;
  fter = floatEventVarMap.find(name);
  if(fter != floatEventVarMap.end())
    return FLOAT;
  dter = doubleEventVarMap.find(name);
  if(dter != doubleEventVarMap.end())
    return DOUBLE;
  return NOVAR;
}
  




void Event::addEventVar(EventVar<int>& EV)
{
  std::string name = EV.getName();
  EventVarVect<int>  *vec;

  if(EventVarExists(name) == NOVAR)
  {
    vec = new EventVarVect<int>(name);
    vec->addEventVar(EV);
    intEventVarMap[name] = vec;
  }
  else
  {
    std::string errstr = "addEventVar: EventVar " + name + " already exists";
    throw std::runtime_error(errstr);
  }
}



void Event::addEventVar(EventVar<float>& EV)
{
  std::string name = EV.getName();
  EventVarVect<float> *vec;

  if(EventVarExists(name) == NOVAR)
  {
    vec = new EventVarVect<float>(name);
    vec->addEventVar(EV);
    floatEventVarMap[name] = vec;
  }
  else
  {
    std::string errstr = "addEventVar: EventVar " + name + " already exists";
    throw std::runtime_error(errstr);
  }
}



void Event::addEventVar(EventVar<double>& EV)
{
  std::string name = EV.getName();
  EventVarVect<double> *vec;

  if(EventVarExists(name) == NOVAR)
  {
    vec = new EventVarVect<double>(name);
    vec->addEventVar(EV);
    doubleEventVarMap[name] = vec;
  }
  else
  {
    std::string errstr = "addEventVar: EventVar " + name + " already exists";
    throw std::runtime_error(errstr);
  }
}



void Event::addEventVar(EventVarVect<int>& EVV)
{
  std::string name = EVV.getName();
  EventVarVect<int> *vec;

  if(EventVarExists(name) == NOVAR)
  {
    vec = new EventVarVect<int>(EVV);
    intEventVarMap[name] = vec;
  }
  else
  {
    std::string errstr = "addEventVar: EventVar " + name + " already exists";
    throw std::runtime_error(errstr);
  }
}



void Event::addEventVar(EventVarVect<float>& EVV)
{
  std::string name = EVV.getName();
  EventVarVect<float> *vec;

  if(EventVarExists(name) == NOVAR)
  {
    vec = new EventVarVect<float>(EVV);
    floatEventVarMap[name] = vec;
  }
  else
  {
    std::string errstr = "addEventVar: EventVar " + name + " already exists";
    throw std::runtime_error(errstr);
  }
}



void Event::addEventVar(EventVarVect<double>& EVV)
{
  std::string name = EVV.getName();
  EventVarVect<double> *vec;

  if(EventVarExists(name) == NOVAR)
  {
    vec = new EventVarVect<double>(EVV);
    doubleEventVarMap[name] = vec;
  }
  else
  {
    std::string errstr = "addEventVar: EventVar " + name + " already exists";
    throw std::runtime_error(errstr);
  }
}




void Event::addEventVar(EventVar<int>* EV)
{
  std::string name = EV->getName();
  EventVarVect<int> *vec;

  if(EventVarExists(name) == NOVAR)
  {
    vec = new EventVarVect<int>(name);
    vec->addEventVar(EV);
    intEventVarMap[name] = vec;
  }
  else
  {
    std::string errstr = "addEventVar: EventVar " + name + " already exists";
    throw std::runtime_error(errstr);
  }

}



void Event::addEventVar(EventVar<float>* EV)
{
  std::string name = EV->getName();
  EventVarVect<float> *vec;

  if(EventVarExists(name) == NOVAR)
  {
    vec = new EventVarVect<float>(name);
    vec->addEventVar(EV);
    floatEventVarMap[name] = vec;
  }
  else
  {
    std::string errstr = "addEventVar: EventVar " + name + " already exists";
    throw std::runtime_error(errstr);
  }
}



void Event::addEventVar(EventVar<double>* EV)
{
  std::string name = EV->getName();
  EventVarVect<double> *vec;

  if(EventVarExists(name) == NOVAR)
  {
    vec = new EventVarVect<double>(name);
    vec->addEventVar(EV);
    doubleEventVarMap[name] = vec;
  }
  else
  {
    std::string errstr = "addEventVar: EventVar " + name + " already exists";
    throw std::runtime_error(errstr);
  }
}


void Event::addEventVar(EventVarVect<int>* EVV)
{
  std::string name = EVV->getName();
  EventVarVect<int> *vec;

//  std::cerr << "Event::addEvent::EventVarVect<int>::" << name << "\n";
  if(EventVarExists(name) == NOVAR)
  {
    vec = new EventVarVect<int>(*EVV);
    intEventVarMap[name] = vec;
  }
  else
  {
    std::string errstr = "addEventVar: EventVar " + name + " already exists";
    throw std::runtime_error(errstr);
  }
}



void Event::addEventVar(EventVarVect<float>* EVV)
{
  std::string name = EVV->getName();
  EventVarVect<float> *vec;

  if(EventVarExists(name) == NOVAR)
  {
    vec = new EventVarVect<float>(*EVV);
    floatEventVarMap[name] = vec;
  }
  else
  {
    std::string errstr = "addEventVar: EventVar " + name + " already exists";
    throw std::runtime_error(errstr);
  }
}



void Event::addEventVar(EventVarVect<double>* EVV)
{
  std::string name = EVV->getName();
  EventVarVect<double> *vec;

  if(EventVarExists(name) == NOVAR)
  {
    vec = new EventVarVect<double>(*EVV);
    doubleEventVarMap[name] = vec;
  }
  else
  {
    std::string errstr = "addEventVar: EventVar " + name + " already exists";
    throw std::runtime_error(errstr);
  }
}


void Event::getEventVar(std::string name, EventVar<int>& ev)
{
  
  EventVarVect<int> *vec;
  EventVar<int>     *var;
  std::map<std::string,EventVarVect<int> *>::iterator iter;

  iter = intEventVarMap.find(name);
  if(iter == intEventVarMap.end())
  {
    std::string errstr = "getEventVar: EventVar<int> " + name + " not found";
    throw std::runtime_error(errstr);
  }
  vec = iter->second;
  var = vec->at(0);
  if(var->size() != ev.size())
    ev.resize(var->size());
  ev.copy(*var);
}



void Event::getEventVar(std::string name, EventVar<float>& ev)
{
  
  EventVarVect<float> *vec;
  EventVar<float>     *var;
  std::map<std::string,EventVarVect<float> *>::iterator iter;

  iter = floatEventVarMap.find(name);
  if(iter == floatEventVarMap.end())
  {
    std::string errstr = "getEventVar: EventVar<float> " + name + " not found";
    throw std::runtime_error(errstr);
  }
  vec = iter->second;;
  var = vec->at(0);
  if(var->size() != ev.size())
    ev.resize(var->size());
  ev.copy(*var);
}



void Event::getEventVar(std::string name, EventVar<double>& ev)
{
  
  EventVarVect<double> *vec;
  EventVar<double>     *var;
  std::map<std::string,EventVarVect<double> *>::iterator iter;

  iter = doubleEventVarMap.find(name);
  if(iter == doubleEventVarMap.end())
  {
    std::string errstr = "getEventVar: EventVar<double> " + name + " not found";
    throw std::runtime_error(errstr);
  }
  vec = iter->second;;
  var = vec->at(0);
  if(var->size() != ev.size())
    ev.resize(var->size());
  ev.copy(*var);
}




void Event::getEventVar(std::string name, EventVarVect<int>& vec)
{
  EventVarVect<int> *tmp;
  std::map<std::string,EventVarVect<int> *>::iterator iter;

  iter = intEventVarMap.find(name);
  if(iter == intEventVarMap.end())
  {
    std::string errstr = "getEventVar: EventVarVect<int> " + name + " not found";
    throw std::runtime_error(errstr);
  }
  tmp = new EventVarVect<int>(*(iter->second));
  vec = *(tmp);
}



void Event::getEventVar(std::string name, EventVarVect<float>& vec)
{
  EventVarVect<float> *tmp;
  std::map<std::string,EventVarVect<float> *>::iterator iter;

  iter = floatEventVarMap.find(name);
  if(iter == floatEventVarMap.end())
  {
    std::string errstr = "getEventVar: EventVarVect<float> " + name + " not found";
    throw std::runtime_error(errstr);
  }
  tmp = new EventVarVect<float>(*(iter->second));
  vec = *(tmp);
}



void Event::getEventVar(std::string name, EventVarVect<double>& vec)
{
  int i;
  EventVarVect<double> *tmp;
  std::map<std::string,EventVarVect<double> *>::iterator iter;

  iter = doubleEventVarMap.find(name);
  if(iter == doubleEventVarMap.end())
  {
    std::string errstr = "getEventVar: EventVarVect<double> " + name + " not found";
    throw std::runtime_error(errstr);
  }
//  tmp = new EventVarVect<double>(*(iter->second));
//  std::cerr << "iter->second->size() = " << tmp->size() << " \n";
//  for(i=0;i<tmp->size();i++)
//    (*tmp)[i]->PrintVar();
//  vec = *(tmp);
  tmp = new EventVarVect<double>(*(iter->second));
  vec = *(tmp);
}


//
//  ReplaceEventVar
//




void Event::replaceEventVar(EventVar<int>& EV)
{
  std::string name = EV.getName();
  std::string errstr;
  EventVarVect<int>  *vec;
  int type;

  type = EventVarExists(name);
  switch(type)
  {
  case NOVAR:
    errstr = "replaceEventVar: EventVar " + name + " does not exist";
    throw std::runtime_error(errstr);
    break;
  case INTEGER:
    vec = intEventVarMap[name];
    vec->clear();
    delete vec;
    intEventVarMap.erase(name);
    vec = new EventVarVect<int>(name);
    vec->addEventVar(EV);
    intEventVarMap[name] = vec;
    break;
  case FLOAT:
    errstr = "replaceEventVar: EventVar " + name + " is of wrong type:";
    errstr = errstr + "is FLOAT should be INTEGER";
    throw std::runtime_error(errstr);
    break;
  case DOUBLE:
    errstr = "replaceEventVar: EventVar " + name + " is of wrong type:";
    errstr = errstr + "is DOUBLE should be INTEGER";
    throw std::runtime_error(errstr);
    break;
  }
}


void Event::replaceEventVar(EventVar<float>& EV)
{
  std::string name = EV.getName();
  std::string errstr;
  EventVarVect<float>  *vec;
  int type;

  type = EventVarExists(name);
  switch(type)
  {
  case NOVAR:
    errstr = "replaceEventVar: EventVar " + name + " does not exist";
    throw std::runtime_error(errstr);
    break;
  case INTEGER:
    errstr = "replaceEventVar: EventVar " + name + " is of wrong type:";
    errstr = errstr + "is INTEGER should be FLOAT";
    break;
  case FLOAT:
    vec = floatEventVarMap[name];
    vec->clear();
    delete vec;
    floatEventVarMap.erase(name);
    vec = new EventVarVect<float>(name);
    vec->addEventVar(EV);
    floatEventVarMap[name] = vec;
    break;
  case DOUBLE:
    errstr = "replaceEventVar: EventVar " + name + " is of wrong type:";
    errstr = errstr + "is DOUBLE should be FLOAT";
    throw std::runtime_error(errstr);
    break;
  }
}


void Event::replaceEventVar(EventVar<double>& EV)
{
  std::string name = EV.getName();
  std::string errstr;
  EventVarVect<double>  *vec;
  int type;

  type = EventVarExists(name);
  switch(type)
  {
  case NOVAR:
    errstr = "replaceEventVar: EventVar " + name + " does not exist";
    throw std::runtime_error(errstr);
    break;
  case INTEGER:
    errstr = "replaceEventVar: EventVar " + name + " is of wrong type:";
    errstr = errstr + "is INTEGER should be DOUBLE";
    break;
  case FLOAT:
    errstr = "replaceEventVar: EventVar " + name + " is of wrong type:";
    errstr = errstr + "is FLOAT should be DOUBLE";
    throw std::runtime_error(errstr);
    break;
  case DOUBLE:
    vec = doubleEventVarMap[name];
    vec->clear();
    delete vec;
    doubleEventVarMap.erase(name);
    vec = new EventVarVect<double>(name);
    vec->addEventVar(EV);
    doubleEventVarMap[name] = vec;
    break;
  }
}



void Event::replaceEventVar(EventVarVect<int>& EVV)
{
  std::string name = EVV.getName();
  std::string errstr;
  EventVarVect<int>  *vec;
  int type;

  type = EventVarExists(name);
  switch(type)
  {
  case NOVAR:
    errstr = "replaceEventVar: EventVar " + name + " does not exist";
    throw std::runtime_error(errstr);
    break;
  case INTEGER:
    vec = intEventVarMap[name];
    vec->clear();
    delete vec;
    intEventVarMap.erase(name);
    vec = new EventVarVect<int>(EVV);
    intEventVarMap[name] = vec;
    break;
  case FLOAT:
    errstr = "replaceEventVar: EventVar " + name + " is of wrong type:";
    errstr = errstr + "is FLOAT should be INTEGER";
    throw std::runtime_error(errstr);
    break;
  case DOUBLE:
    errstr = "replaceEventVar: EventVar " + name + " is of wrong type:";
    errstr = errstr + "is DOUBLE should be INTEGER";
    throw std::runtime_error(errstr);
    break;
  }
}


void Event::replaceEventVar(EventVarVect<float>& EVV)
{
  std::string name = EVV.getName();
  std::string errstr;
  EventVarVect<float>  *vec;
  int type;

  type = EventVarExists(name);
  switch(type)
  {
  case NOVAR:
    errstr = "replaceEventVar: EventVar " + name + " does not exist";
    throw std::runtime_error(errstr);
    break;
  case INTEGER:
    errstr = "replaceEventVar: EventVar " + name + " is of wrong type:";
    errstr = errstr + "is INTEGER should be FLOAT";
    throw std::runtime_error(errstr);
    break;
  case FLOAT:
    vec = floatEventVarMap[name];
    vec->clear();
    delete vec;
    floatEventVarMap.erase(name);
    vec = new EventVarVect<float>(EVV);
    floatEventVarMap[name] = vec;
    break;
  case DOUBLE:
    errstr = "replaceEventVar: EventVar " + name + " is of wrong type:";
    errstr = errstr + "is DOUBLE should be FLOAT";
    throw std::runtime_error(errstr);
    break;
  }
}


void Event::replaceEventVar(EventVarVect<double>& EVV)
{
  std::string name = EVV.getName();
  std::string errstr;
  EventVarVect<double>  *vec;
  int type;

  type = EventVarExists(name);
  switch(type)
  {
  case NOVAR:
    errstr = "replaceEventVar: EventVar " + name + " does not exist";
    throw std::runtime_error(errstr);
    break;
  case INTEGER:
    errstr = "replaceEventVar: EventVar " + name + " is of wrong type:";
    errstr = errstr + "is INTEGER should be DOUBLE";
    throw std::runtime_error(errstr);
    break;
  case FLOAT:
    errstr = "replaceEventVar: EventVar " + name + " is of wrong type:";
    errstr = errstr + "is FLOAT should be DOUBLE";
    throw std::runtime_error(errstr);
    break;
  case DOUBLE:
    vec = doubleEventVarMap[name];
    vec->clear();
    delete vec;
    intEventVarMap.erase(name);
    vec = new EventVarVect<double>(EVV);
    doubleEventVarMap[name] = vec;
    break;
  }
}


//
//  DeleteEventVar
//




void Event::deleteEventVar(EventVar<int>& EV)
{
  std::string name = EV.getName();
  std::string errstr;
  EventVarVect<int>  *vec;
  int type;

  type = EventVarExists(name);
  switch(type)
  {
  case NOVAR:
    errstr = "deleteEventVar: EventVar " + name + " does not exist";
    throw std::runtime_error(errstr);
    break;
  case INTEGER:
    vec = intEventVarMap[name];
    vec->clear();
    delete vec;
    intEventVarMap.erase(name);
    break;
  case FLOAT:
    errstr = "deleteEventVar: EventVar " + name + " is of wrong type:";
    errstr = errstr + "is FLOAT should be INTEGER";
    throw std::runtime_error(errstr);
    break;
  case DOUBLE:
    errstr = "deleteEventVar: EventVar " + name + " is of wrong type:";
    errstr = errstr + "is DOUBLE should be INTEGER";
    throw std::runtime_error(errstr);
    break;
  }
}


void Event::deleteEventVar(EventVar<float>& EV)
{
  std::string name = EV.getName();
  std::string errstr;
  EventVarVect<float>  *vec;
  int type;

  type = EventVarExists(name);
  switch(type)
  {
  case NOVAR:
    errstr = "deleteEventVar: EventVar " + name + " does not exist";
    throw std::runtime_error(errstr);
    break;
  case INTEGER:
    errstr = "deleteEventVar: EventVar " + name + " is of wrong type:";
    errstr = errstr + "is INTEGER should be FLOAT";
    throw std::runtime_error(errstr);
    break;
  case FLOAT:
    vec = floatEventVarMap[name];
    vec->clear();
    delete vec;
    floatEventVarMap.erase(name);
    break;
  case DOUBLE:
    errstr = "deleteEventVar: EventVar " + name + " is of wrong type:";
    errstr = errstr + "is DOUBLE should be FLOAT";
    throw std::runtime_error(errstr);
    break;
  }
}


void Event::deleteEventVar(EventVar<double>& EV)
{
  std::string name = EV.getName();
  std::string errstr;
  EventVarVect<double>  *vec;
  int type;

  type = EventVarExists(name);
  switch(type)
  {
  case NOVAR:
    errstr = "deleteEventVar: EventVar " + name + " does not exist";
    throw std::runtime_error(errstr);
    break;
  case INTEGER:
    errstr = "deleteEventVar: EventVar " + name + " is of wrong type:";
    errstr = errstr + "is INTEGER should be DOUBLE";
    throw std::runtime_error(errstr);
    break;
  case FLOAT:
    errstr = "deleteEventVar: EventVar " + name + " is of wrong type:";
    errstr = errstr + "is FLOAT should be DOUBLE";
    throw std::runtime_error(errstr);
    break;
  case DOUBLE:
    vec = doubleEventVarMap[name];
    vec->clear();
    delete vec;
    doubleEventVarMap.erase(name);
    break;
  }
}



void Event::deleteEventVar(EventVarVect<int>& EVV)
{
  std::string name = EVV.getName();
  std::string errstr;
  EventVarVect<int>  *vec;
  int type;

  type = EventVarExists(name);
  switch(type)
  {
  case NOVAR:
    errstr = "deleteEventVar: EventVar " + name + " does not exist";
    throw std::runtime_error(errstr);
    break;
  case INTEGER:
    vec = intEventVarMap[name];
    vec->clear();
    delete vec;
    intEventVarMap.erase(name);
    break;
  case FLOAT:
    errstr = "deleteEventVar: EventVar " + name + " is of wrong type:";
    errstr = errstr + "is FLOAT should be INTEGER";
    throw std::runtime_error(errstr);
    break;
  case DOUBLE:
    errstr = "deleteEventVar: EventVar " + name + " is of wrong type:";
    errstr = errstr + "is DOUBLE should be INTEGER";
    throw std::runtime_error(errstr);
    break;
  }
}


void Event::deleteEventVar(EventVarVect<float>& EVV)
{
  std::string name = EVV.getName();
  std::string errstr;
  EventVarVect<float>  *vec;
  int type;

  type = EventVarExists(name);
  switch(type)
  {
  case NOVAR:
    errstr = "deleteEventVar: EventVar " + name + " does not exist";
    throw std::runtime_error(errstr);
    break;
  case INTEGER:
    errstr = "deleteEventVar: EventVar " + name + " is of wrong type:";
    errstr = errstr + "is INTEGER should be FLOAT";
    throw std::runtime_error(errstr);
    break;
  case FLOAT:
    vec = floatEventVarMap[name];
    vec->clear();
    delete vec;
    floatEventVarMap.erase(name);
    break;
  case DOUBLE:
    errstr = "deleteEventVar: EventVar " + name + " is of wrong type:";
    errstr = errstr + "is DOUBLE should be FLOAT";
    throw std::runtime_error(errstr);
    break;
  }
}


void Event::deleteEventVar(EventVarVect<double>& EVV)
{
  std::string name = EVV.getName();
  std::string errstr;
  EventVarVect<double>  *vec;
  int type;

  type = EventVarExists(name);
  switch(type)
  {
  case NOVAR:
    errstr = "deleteEventVar: EventVar " + name + " does not exist";
    throw std::runtime_error(errstr);
    break;
  case INTEGER:
    errstr = "deleteEventVar: EventVar " + name + " is of wrong type:";
    errstr = errstr + "is INTEGER should be DOUBLE";
    throw std::runtime_error(errstr);
    break;
  case FLOAT:
    errstr = "deleteEventVar: EventVar " + name + " is of wrong type:";
    errstr = errstr + "is FLOAT should be DOUBLE";
    throw std::runtime_error(errstr);
    break;
  case DOUBLE:
    vec = doubleEventVarMap[name];
    vec->clear();
    delete vec;
    doubleEventVarMap.erase(name);
    break;
  }
}



void Event::deleteEventVar(std::string name)
{
  std::string errstr;
  int type;
  EventVarVect<int> *ivec;
  EventVarVect<float> *fvec; 
  EventVarVect<double> *dvec;

  type = EventVarExists(name);
  switch(type)
  {
  case NOVAR:
    errstr = "deleteEventVar: EventVar " + name + " does not exist";
    throw std::runtime_error(errstr);
    break;
  case INTEGER:
    ivec = intEventVarMap[name];
    ivec->clear();
    delete ivec;
    intEventVarMap.erase(name);
    break;
  case FLOAT:
    fvec = floatEventVarMap[name];
    fvec->clear();
    delete fvec;
    floatEventVarMap.erase(name);
    break;
  case DOUBLE:
    dvec = doubleEventVarMap[name];
    dvec->clear();
    delete dvec;
    doubleEventVarMap.erase(name);
    break;
  }
}



//
// Operators
//

Event& Event::operator = (const Event& a)
{
  this->EventNumber        = a.EventNumber;
  this->OrbitNumber        = a.OrbitNumber;
  this->SR_SS_Flag         = a.SR_SS_Flag;
  this->EventStartTime     = a.EventStartTime;
  this->EventStopTime      = a.EventStopTime;
  this->AtmosStartTime     = a.AtmosStartTime;
  this->AtmosStopTime      = a.AtmosStopTime;
  this->SolarScanStartTime = a.SolarScanStartTime;
  this->SolarScanStopTime  = a.SolarScanStopTime;
  this->Latitude83km       = a.Latitude83km;
  this->Longitude83km      = a.Longitude83km;
}


//
//
//EventVar<int>* Event::getEventVarInt(std::string name)
//{
//  EventVarVect<int> vec;
//
//  vec = intEventVarMap[name];
//  if(vec.size() == 0)
//  {
//    std::string errstr = "getEventVarInt: EventVar " + name + " not found";
//    THROW_GATS_EXCEPTION(EventNameException,errstr);
//  }
//  return vec[0];
//}
//
//
//
//EventVar<float>* Event::getEventVarFloat(std::string name)
//{
//  EventVarVect<float> vec;
//
//  vec = floatEventVarMap[name];
//  if(vec.size() == 0)
//  {
//    std::string errstr = "getEventVarFloat: EventVar " + name + " not found";
//    throw  SOFIE_NameNotFoundException(errstr);
//  }
//
//  return vec[0];
//}
//
//
//EventVar<double>* Event::getEventVarDouble(std::string name)
//{
//  EventVarVect<double> vec;
//
//  vec = doubleEventVarMap[name];
//  if(vec.size() == 0)
//  {
//    std::string errstr = "getEventVarDouble: EventVar " + name + " not found";
//    throw  SOFIE_NameNotFoundException(errstr);
//  }
//
//  return vec[0];
//
//}
//
//
//void Event::getEventVarDouble(std::string name, EventVar<double>* ev)
//{
//  
//  std::vector<EventVar<double> *> vec;
//
//  vec = doubleEventVarMap[name];
//
//  if(vec[0]->size() != ev->size())
//    ev->resize(vec[0]->size());
//  ev = vec[0];
//}
//

void Event::PrintEventProperties(void)
{
  int  i;
  EventVarVect<int>    *evvi;
  EventVarVect<float>  *evvf;
  EventVarVect<double> *evvd;


  std::cerr << "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n";
  std::cerr << "               Event::PrintEventProperties()\n";
  std::cerr << "Event Number           = " << EventNumber << "\n";
  std::cerr << "Orbit Number           = " << OrbitNumber << "\n";
  std::cerr << "Sunrise / Sunset Flag  = " << SR_SS_Flag  << "\n";
  std::cerr << "Event Start Time       = " << EventStartTime << "\n";
  std::cerr << "Event Stop Time        = " << EventStopTime  << "\n";
  std::cerr << "Event Latitude @ 83km  = " << Latitude83km   << "\n";
  std::cerr << "Event Longitude @ 83km = " << Longitude83km  << "\n";
//
// Print the EventVar properties
//
  std::cerr << "============================================================\n";
  std::cerr << "               Event::intEventVarMap Properties\n";
  std::map<std::string,EventVarVect<int> *>::iterator iter;
  for(iter=intEventVarMap.begin(); iter!=intEventVarMap.end(); iter++)
  {
    std::cerr << "Map Name = " << iter->first << "\n";
    evvi = iter->second;
    evvi->PrintEventVarVect();
  }
  std::cerr << "============================================================\n";

  std::cerr << "============================================================\n";
  std::cerr << "               Event::floatEventVarMap Properties\n";
  std::map<std::string,EventVarVect<float> *>::iterator fter;
  for(fter=floatEventVarMap.begin(); fter!=floatEventVarMap.end(); fter++)
  {
    std::cerr << "Map Name = " << fter->first << "\n";
    evvf = fter->second;
    evvf->PrintEventVarVect();
  }
  std::cerr << "============================================================\n";

  std::cerr << "============================================================\n";
  std::cerr << "               Event::doubleEventVarMap Properties\n";
  std::map<std::string,EventVarVect<double> *>::iterator dter;
  for(dter=doubleEventVarMap.begin(); dter!=doubleEventVarMap.end(); dter++)
  {
    std::cerr << "Map Name = " << dter->first << "\n";
    evvd = dter->second;
    evvd->PrintEventVarVect();
  }
  std::cerr << "============================================================\n";

  std::cerr << "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n";

}