/**
    @file TestOutputSummary.cpp
    @author Brian Magill
    @creation date 9/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.
        
*/

#include <cassert>
#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <iomanip>

#include "ConfigFile.h"
#include "GATS_Exception.h"
#include "Event.h"
#include "SignalCorrection.h"
#include "SigCorrectCalibSource.h"
#include "SOFIE_namespace.h"
#include "SunriseModel.h"
#include "SunriseBalanceModel.h"

using namespace std;

unsigned long chanStrong(unsigned long chindx);

int FillTime_N_Signals(EventVar <double> &outTime, 
                        EventVarVect <double> & outSignal, 
                        EventVar <double> &outAtten, double &time_150km);

int PrintTime_N_Signals(EventVar <double> &outTime, EventVarVect <double> & outSignal);

int main()
{

    Event L0;
    Event L1;
    Event Tmp(50);
    Event Persist(50);
    
    ConfigFile configB("SignalCorrection.ini");

    EventVar <double> timeArrayIn;
    EventVar <double> timeArrayOut;

    EventVar <double> attenArray;
    
    EventVarVect <double> SignalsIn;
    EventVarVect <double> SignalsOut;

    double time_150km;    
    
    SigCorrectCalibSource calSource(configB);
    
    const string MODULE_NAME = "SignalCorrection";

    calSource.outputParam(Persist); // Put calibration data in Persistent Event object

//     cout << "chanStrong Test: " << endl;
//     for(int i = SOFIE::O3_diff; i <= SOFIE::NO_diff; i++)
//         cout << i << "\t" << chanStrong(i) << endl;
//     cout << endl;
    
    FillTime_N_Signals(timeArrayIn, SignalsIn, attenArray, time_150km); 
    cout << "Input time & signals: " << endl;      
    PrintTime_N_Signals(timeArrayIn, SignalsIn);
    cout << "time_150km = " << time_150km << endl;

    timeArrayIn.setName("L1_DetectorTimes");        
    L1.addEventVar(timeArrayIn);
    
    SignalsIn.setName("L1_TimeShiftedSignals");    
    L1.addEventVar(SignalsIn);

    attenArray.setName("L1_AttenuatorSettings");  
    L1.addEventVar(attenArray);  

        
    cout << "AbortForBadData = " << configB.GetInt(MODULE_NAME, "AbortForBadData") << endl;
    cout << "Check_Infinity = " << configB.GetInt(MODULE_NAME, "Check_Infinity") << endl;        

    L1.openEventLog("TestSignalCorrection.log"); 
    L1.enableLogTimeStamp();
    
    L1.setSRSSFlag('r');
    L1.setEventStartTime(0.0);
    L1.setAtmosStopTime(time_150km);
       
    if (SignalCorrection(L0, L1, Tmp, Persist, configB) )
        {
        cerr << "SignalCorrection failed !" << endl;
        return -1;
        }

   L1.getEventVar("Final_Signal_Time", timeArrayOut);      
   L1.getEventVar("Corrected_Signals", SignalsOut);      

    cout << endl;
    cout << "Output time & signals: " << endl;
    PrintTime_N_Signals(timeArrayOut, SignalsOut);

    L1.closeEventLog();

    cout << endl << endl;
    cout << "Print Event properties" << endl;
    cout << "######################" << endl;
    
    L1.PrintEventProperties();    
    return 0;        
};        

int PrintTime_N_Signals(EventVar <double> &outTime, EventVarVect <double> & outSignal)
    {
    unsigned long i;
    unsigned long j;
    const unsigned long DetectorNumber = SOFIE::tot_det_signals;
    unsigned long N = outTime.size();

    cout << setprecision(5);        
    cout.setf(ios::left);                    // left justify

    for (i = 0; i < N; i++)
        {
        cout << setw (6) << outTime[i];

        //        cout.setf(ios::right);                    // left justify
//        cout << setprecision(5);        
        for(j = 0; j < DetectorNumber; j++)
            {
//            cout << setprecision(5) << setw (5);     //  set number of significant digits and width
//            cout << setw (6);     //  set number of significant digits and width            
            cout << ", " << setw (6) <<outSignal[j][i];
            }
        cout << endl;
            
        }   

    return 0;    
    };

int FillTime_N_Signals(EventVar <double> &outTime, 
                        EventVarVect <double> & outSignal, 
                        EventVar <double> &outAtten, double &time_150km)
    {

    unsigned long i;
    unsigned long j;
    unsigned long indx;
    unsigned long indx_150km;
    double scale;
    SunriseModel detModel;
    SunriseBalanceModel balModel;
    
    const double interval = 5.0;
    double time_ref;
    double G;
    double drift;  
    vector<double> Vref;   
    vector<double> DVref;   
    double B;
        
    EventVar <double> workVar(detModel.size());
//    EventVar <double> worktime(detModel.size());
    valarray<double> worktime(detModel.size());

    vector<valarray<double> > sigVect;
    valarray<double> ValWork(detModel.size());
       
    outTime.resize(detModel.size());
    outTime.setName("Signal Times");

    for (i = 0; i < detModel.size(); i++)
        {
        outTime[i] = 1.0*i;
        }   

    indx_150km = detModel.getTopIndex() + 2;
    time_150km = outTime[indx_150km];
    time_ref = time_150km + interval/2.0;
    worktime = outTime - time_ref;
    
    outAtten.resize(SOFIE::no_of_detectors);

    for(j = 0; j < outAtten.size(); j++)
        { outAtten[j] = 1. - 0.01*j;}


//  set up basic detector signals
    for(j = SOFIE::O3_strong; j <= SOFIE::NO_strong; j++)
        { 
        scale   = double(j+10.); 
        Vref.push_back(scale);
        detModel   = SunriseModel(scale);      
        ValWork = detModel.getModel(); 

        sigVect.push_back(ValWork);           
        }

//  set up basic difference signals
    for(j = SOFIE::O3_strong; j <= SOFIE::NO_strong; j++)
        { 
        scale   = double(j+10.); 
        DVref.push_back(j);        
        balModel = SunriseBalanceModel(scale);      
        ValWork = balModel.getModel(); 
        sigVect.push_back(ValWork);           
        }

//  Add imbalance for differential signals
//     for(j = SOFIE::O3_diff; j <= SOFIE::NO_diff; j++)
//         {
//         indx = 2*(j - SOFIE::O3_diff);  // get the corresponding "high" signal 
//         G = outAtten[indx];
//         sigVect[j] = G*sigVect[j] +(1. - G)*sigVect[indx];           
//         }


    for(j = SOFIE::O3_strong; j <= SOFIE::NO_strong; j++)
        { 

        // add drift effect
        drift = 0.001*j;
        sigVect[j] = (1. + drift*worktime)*sigVect[j];

        // add dark signal offset
        sigVect[j] += j*0.1;  
        }                               

//  add errors to difference signals
    for(j = SOFIE::O3_diff; j <= SOFIE::NO_diff; j++)
        { 
        indx = chanStrong(j);
        B = DVref[j]/Vref[indx] + 1.0;
        sigVect[j] = B*sigVect[j] + (B - 1.0)*sigVect[indx];

        // add drift effect
        drift = 0.0001*j;
        sigVect[j] = sigVect[j] +  drift*worktime;


        G = 1.*(j -  SOFIE::O3_diff + 1);
        sigVect[j] = G*sigVect[j];       

        // add dark signal offset
        sigVect[j] += j*0.1;  
        
        }                               

//  put signals into EventVarVect
    for(j = SOFIE::O3_strong; j <= SOFIE::NO_diff; j++)
        { 

        workVar = sigVect[j];                                 
        outSignal.addEventVar(workVar); 
        
        }
                       
    return 0;    
    };


unsigned long chanStrong(unsigned long chindx)
    {
    chindx = chindx - SOFIE::O3_diff;
    assert(chindx < SOFIE::no_of_chan_diffs);
     
    unsigned long sigIndx[8] = {SOFIE::O3_strong, SOFIE::PartA_strong, 
                      SOFIE::H2O_strong, SOFIE::CO2A_strong, 
                      SOFIE::PartB_strong, SOFIE::CH4_strong, 
                      SOFIE::CO2B_strong, SOFIE::NO_strong}; 
    
    return sigIndx[chindx];
    }