/**
    @class SigCorrectInput.cpp
    @author Brian Magill
    @creation date 11/13/2006

	$Date:$
    $Revision:$

    @copyright
     (©) 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.
    
    @brief Adaptor class for Signal Corrections Module.  
    
    Only exposes the portions the Event object used by Signal Correction classes

    Note: The detector signals were grouped in terms of strong 
    and weak bands.  
    
*/

#include <iostream>
#include <stdexcept>
#include <string>
#include "SigCorrectInput.h"
#include "SOFIE_namespace.h"
#include "Vec2Val.hpp"

using namespace std;
using namespace SOFIE;

MultiSignal SigCorrectInput::getMultiSignal()
{
MultiSignal outputSignal;

double time_150km;
bool sunsetMode;
double high_atten; 
double low_atten;
char modeFlag;
string errStr;

EventVar <double> timeArray;
EventVar <double> attenArray;

EventVarVect<double> SignalsIn;

int event = inLevelOne->getEventNumber();
inLevelOne->getEventVar("L1_DetectorTimes",  timeArray); 	
inLevelOne->getEventVar("L1_TimeShiftedSignals", SignalsIn); 	
inLevelOne->getEventVar("L1_AttenuatorSettings", attenArray);  //Need to set this up somewhere!!!!	

valarray<double> time(timeArray); 
valarray<double> high((SignalsIn[0]).size());
valarray<double> low(SignalsIn[0].size());
valarray<double> diff(SignalsIn[0].size());
vector<ChannelSignals> channelArray;

double eventStart = inLevelOne->getEventStartTime();

ChannelSignals channel;

modeFlag = inLevelOne->getSRSSFlag();
if (modeFlag == 's')
    {
    sunsetMode = true;
    time_150km = inLevelOne->getAtmosStartTime() - eventStart;
    }
else if (modeFlag == 'r') 
    {
    sunsetMode = false;
    time_150km = inLevelOne->getAtmosStopTime() - eventStart;
    }
else
    {
    errStr = string("Error in SigCorrectInput::getMultiSignal(). ") +
    string("Sunrise/sunset flag needs to be 's' or 'r'. Instead it is ") + modeFlag; 
    throw runtime_error(errStr);    
    }  

//  Note: Channels have to be added to the array in this order

high = SignalsIn[O3_strong];
low    = SignalsIn[O3_weak];
diff = SignalsIn[O3_diff];
high_atten = attenArray[O3_strong]; 
low_atten   = attenArray[O3_weak];
channelArray.push_back(ChannelSignals(O3, high_atten, low_atten, high, low, diff));

high = SignalsIn[PartA_strong];
low    = SignalsIn[PartA_weak];
diff = SignalsIn[PartA_diff];
high_atten = attenArray[PartA_strong]; 
low_atten   = attenArray[PartA_weak];
channelArray.push_back(ChannelSignals(PartA, high_atten, low_atten, high, low, diff));

high = SignalsIn[H2O_strong];
low    = SignalsIn[H2O_weak];
diff = SignalsIn[H2O_diff];
high_atten = attenArray[H2O_strong]; 
low_atten   = attenArray[H2O_weak];
channelArray.push_back(ChannelSignals(H2O, high_atten, low_atten, high, low, diff));

high = SignalsIn[CO2A_strong];
low    = SignalsIn[CO2A_weak];
diff = SignalsIn[CO2A_diff];
high_atten = attenArray[CO2A_strong]; 
low_atten   = attenArray[CO2A_weak];
channelArray.push_back(ChannelSignals(CO2A, high_atten, low_atten, high, low, diff));

high = SignalsIn[PartB_strong];
low    = SignalsIn[PartB_weak];
diff = SignalsIn[PartB_diff];
high_atten = attenArray[PartB_strong]; 
low_atten   = attenArray[PartB_weak];
channelArray.push_back(ChannelSignals(PartB, high_atten, low_atten, high, low, diff));

high = SignalsIn[CH4_strong];
low    = SignalsIn[CH4_weak];
diff = SignalsIn[CH4_diff];
high_atten = attenArray[CH4_strong]; 
low_atten   = attenArray[CH4_weak];
channelArray.push_back(ChannelSignals(CH4, high_atten, low_atten, high, low, diff));

high = SignalsIn[CO2B_strong];
low    = SignalsIn[CO2B_weak];
diff = SignalsIn[CO2B_diff];
high_atten = attenArray[CO2B_strong]; 
low_atten   = attenArray[CO2B_weak];
channelArray.push_back(ChannelSignals(CO2B, high_atten, low_atten, high, low, diff));

high = SignalsIn[NO_strong];
low    = SignalsIn[NO_weak];
diff = SignalsIn[NO_diff];
high_atten = attenArray[NO_strong]; 
low_atten   = attenArray[NO_weak];
channelArray.push_back(ChannelSignals(NO, high_atten, low_atten, high, low, diff));

return MultiSignal(event, time_150km, sunsetMode, time, channelArray);
}

///
/// @return Earth location information from input Event 
/// 
SigEarthLocParam SigCorrectInput::getEarthLocInfo()
{

string errStr;

EventVar <double> timeArray;
EventVar <double> altitudeArray;
EventVar <double> viewArray;
EventVar <double> lockdownAz;
EventVar <double> lockdownEl;
EventVar <double> SolExtArray;

try {
    inLevelOne->getEventVar("L1_DetectorTimes",  timeArray); 	
    inLevelOne->getEventVar("L1_TPAlt", altitudeArray); 	
    inLevelOne->getEventVar("L1_ViewingAngle", viewArray); 	
    inLevelOne->getEventVar("DetectorLockdown_AZ", lockdownAz);    
    inLevelOne->getEventVar("DetectorLockdown_EL", lockdownEl);
    inLevelOne->getEventVar("SolarExtent", SolExtArray);
    
    } catch (exception &ex) {
    
    errStr = string("SigCorrectInput::getEarthLocInfo() Error:") +
            string(" Problem with Event Object. ") + ex.what();
    throw runtime_error(errStr);  
    }

unsigned long N = timeArray.size(); 

if (altitudeArray.size() != N || 
    viewArray.size() != N || 
    lockdownAz.size() != N ||
    lockdownEl.size() != N || SolExtArray.size() != N)
    
    {
    errStr = string("SigCorrectInput::getEarthLocInfo() Error:") +
            " Ephemeris and solar arrays have different sizes!";
    throw runtime_error(errStr);
    }

return SigEarthLocParam(Val2Vec(timeArray), 
                        Val2Vec(altitudeArray), 
                        Val2Vec(viewArray),
                        Val2Vec(lockdownAz),                        
                        Val2Vec(lockdownEl),
                        Val2Vec(SolExtArray) );
}

BalanceTimes SigCorrectInput::getBalanceTimes()
{
EventVar <double> startTime;
EventVar <double> endTime;
string errStr;

try {
    inLevelZero->getEventVar("L0_BalanceStartTime",  startTime); 	
    inLevelZero->getEventVar("L0_BalanceEndTime", endTime); 	
    
    } catch (exception &ex) {
    
    errStr = string("SigCorrectInput::getBalanceTimes() Error:") +
            string(" Problem with Event Object. ") + ex.what();
    throw runtime_error(errStr);  
    }

return BalanceTimes(startTime[0], endTime[0]);
}

CalibrationTimes SigCorrectInput::getCalibrationTimes()
{
double startTime;
double endTime;
double eventStart;
string errStr;

try {

//     startTime = inLevelZero->getSolarScanStartTime(); 	
//     endTime = inLevelZero->getSolarScanStopTime(); 	

    eventStart = inLevelOne->getEventStartTime();
    startTime = inLevelOne->getSolarScanStartTime() - eventStart; 	
    endTime = inLevelOne->getSolarScanStopTime() - eventStart; 	
    
    } catch (exception &ex) {
    
    errStr = string("SigCorrectInput::getCalibrationTimes() Error:") +
            string(" Problem with Event Object. ") + ex.what();
    throw runtime_error(errStr);  
    }

return CalibrationTimes(startTime, endTime);
}