/// Class to hold Gas Properties inside TPC
/// at a particular time
/// Blair Jamieson (C) 2009, 2010

#include <string>
#include <math.h>
#include "ITPCGas.hxx"


///--------------------------------------------------------------------
/// build new TTPC Gas reading with intended time range of use specified
ITPCGas::ITPCGas( long autimemin, long autimemax ){
  fTime = autimemin;
  fStartTime = autimemin;
  fEndTime = autimemax;
  fDebug = false;
  fTimeStamp = 0x0;
  Init();
}

///--------------------------------------------------------------------
/// build new TTPC Gas reading with intended time range of use specified
ITPCGas::ITPCGas( int ayearmin, int amonthmin, int adaymin, int ahourmin, int aminmin, int asecmin,
		  int ayearmax, int amonthmax, int adaymax, int ahourmax, int aminmax, int asecmax ){
  fTimeStamp=0x0;
  fDebug = false;
  SetTimeNoRead(ayearmax, amonthmax, adaymax, ahourmax, aminmax, asecmax);
  fEndTime = fTime;
  SetTimeNoRead(ayearmin, amonthmin, adaymin, ahourmin, aminmin, asecmin);
  fStartTime = fTime;
  Init();
}



/// Initialize gas properties object
void ITPCGas::Init(){

  // set up the field names
  SetupFieldNames();
  fPlca_vec.clear();

  // set timestamp of when Jordan implemented isobutane T, P corrections in PLC
  fIbuCorTime = GetUnixTime( 2010, 3, 4, 16, 14 ); 

  // set timestamp of when Jordan implemented gas analyzer T, P corrections in PLC
  // 03/25/2010 ~13:40:30
  fAnalyzerCorTime = GetUnixTime( 2010, 3, 25, 13, 40, 30 ); 

  // set timestamp of when Jordan changed gas analyzer T, P corrections to P/T in PLC
  // 05/2/2010 ~22:59
  fAnalyzerCorTime2 = GetUnixTime( 2010, 5, 2, 22, 59 ); 

  // Now read gas properties
  Read();
}


///--------------------------------------------------------------------
/// Setup vectors of strings for field names
/// that will be querried in the database
void ITPCGas::SetupFieldNames(){
  fPlca_names.clear();
  fTpc1_names.clear();
  fTpc2_names.clear();
  fTpc3_names.clear();
  fVda_names.clear();
  fVdb_names.clear();
  fGa_names.clear();
  fGb_names.clear();

  fPlca_names.push_back("d0fc1_rdflow_plca");
  fPlca_names.push_back("d0fc2_rdflow_plca"); 
  fPlca_names.push_back("d0fc3_rdflow_plca"); 
  fPlca_names.push_back("d2pa1_rdpress_plca");  
  fPlca_names.push_back("g1pd1_rdpress_plca");  
  fPlca_names.push_back("d1pd1_rdpress_plca");  
  fPlca_names.push_back("d0pd4_rdpress_plca");  
  fPlca_names.push_back("a0an1_rdmon_plca");  
  fPlca_names.push_back("a0an2_rdmon_plca");  
  fPlca_names.push_back("d0an1_rdmon_plca");  
  fPlca_names.push_back("a0an3_rdmon_plca");  
  fPlca_names.push_back("a0an3b_rdmon_plca");  
  fPlca_names.push_back("a0an3c_rdmon_plca");  
  fPlca_names.push_back("a0an2b_rdmon_plca");  
  fPlca_names.push_back("d0tc1_rdtemp_plca");  
  fPlca_names.push_back("d0tc2_rdtemp_plca");  
  fPlca_names.push_back("d0tc3_rdtemp_plca");  
  fPlca_names.push_back("d0tc4_rdtemp_plca");  
  fPlca_names.push_back("d0tc5_rdtemp_plca");  
  fPlca_names.push_back("p0tc1_rdtemp_plca");  
  fPlca_names.push_back("p0tc2_rdtemp_plca");  
  fPlca_names.push_back("p0tc3_rdtemp_plca");  
  fPlca_names.push_back("p0tc4_rdtemp_plca");  
  fPlca_names.push_back("p0tc5_rdtemp_plca");  
  fPlca_names.push_back("p0tc6_rdtemp_plca");  
  fPlca_names.push_back("dxtc1_rdtemp_plca");  
  fPlca_names.push_back("dxtc2_rdtemp_plca");  

  fTpc1_names.push_back("tr0agasmanleft_tpc1");  
  fTpc1_names.push_back("tr0agasmanright_tpc1");  
  fTpc1_names.push_back("tr1agasmanleft_tpc1");  
  fTpc1_names.push_back("tr1agasmanright_tpc1");

  fTpc2_names.push_back("tr0agasmanleft_tpc2");  
  fTpc2_names.push_back("tr0agasmanright_tpc2");  
  fTpc2_names.push_back("tr1agasmanleft_tpc2");  
  fTpc2_names.push_back("tr1agasmanright_tpc2");

  fTpc3_names.push_back("tr0agasmanleft_tpc3");  
  fTpc3_names.push_back("tr0agasmanright_tpc3");  
  fTpc3_names.push_back("tr1agasmanleft_tpc3");  
  fTpc3_names.push_back("tr1agasmanright_tpc3");

  fVda_names.push_back("mean_vda")   ;         
  fVda_names.push_back("sigma_vda")  ;  

  fVdb_names.push_back("mean_vdb")   ;      
  fVdb_names.push_back("sigma_vdb")  ;     

  fGa_names.push_back("mean_ga")    ;         
  fGa_names.push_back("sigma_ga")   ;  

  fGb_names.push_back("mean_gb")    ;      
  fGb_names.push_back("sigma_gb")   ;     
  
  return;
}


///------------------------------------------------------------------------
/// Read another chunk of data from slow control database
void ITPCGas::ReadSlowDB_Plca(){
  /// read next 500 entries starting from 5 minutes ago
  long astart = fTime - 300;
  fPlca_vec.clear();
  fPlca_vec = ISlowControlDatabase::Get().QueryGetFieldNoCache( astart, "tpcgasplc_plca", fPlca_names, 100 );
  return;
}

///------------------------------------------------------------------------
/// Read another chunk of data from slow control database
void ITPCGas::ReadSlowDB_Tpc1(){
  /// read next 500 entries starting from 10 minutes ago
  long astart = fTime - 300;
  fTpc1_vec.clear();  
  fTpc1_vec = ISlowControlDatabase::Get().QueryGetFieldNoCache( astart, "tpc1temp_tpc1", fTpc1_names, 100 );
  return;
}

///------------------------------------------------------------------------
/// Read another chunk of data from slow control database
void ITPCGas::ReadSlowDB_Tpc2(){
  /// read next 500 entries starting from 10 minutes ago
  long astart = fTime - 300;
  fTpc2_vec.clear();  
  fTpc2_vec = ISlowControlDatabase::Get().QueryGetFieldNoCache( astart, "tpc2temp_tpc2", fTpc2_names, 100 );
  return;
}

///------------------------------------------------------------------------
/// Read another chunk of data from slow control database
void ITPCGas::ReadSlowDB_Tpc3(){
  /// read next 500 entries starting from 10 minutes ago
  long astart = fTime - 300;
  fTpc3_vec.clear();
  fTpc3_vec = ISlowControlDatabase::Get().QueryGetFieldNoCache( astart, "tpc3temp_tpc3", fTpc3_names, 100 );
  return;
}

///------------------------------------------------------------------------
/// Read another chunk of data from slow control database
void ITPCGas::ReadSlowDB_Vda(){
  /// read next 500 entries starting from 10 minutes ago
  long astart = fTime - 1000;
  fVda_vec.clear(); 
  fVda_vec  = ISlowControlDatabase::Get().QueryGetFieldNoCache( astart, "gasmonchamber_vda", fVda_names, 100 );
  return;
}

///------------------------------------------------------------------------
/// Read another chunk of data from slow control database
void ITPCGas::ReadSlowDB_Vdb(){
  /// read next 500 entries starting from 10 minutes ago
  long astart = fTime - 1000;
  fVdb_vec.clear(); 
  fVdb_vec  = ISlowControlDatabase::Get().QueryGetFieldNoCache( astart, "gasmonchamber_vdb", fVdb_names, 100 );
  return;
}

///------------------------------------------------------------------------
/// Read another chunk of data from slow control database
void ITPCGas::ReadSlowDB_Ga(){
  /// read next 500 entries starting from 10 minutes ago
  long astart = fTime - 2000;
  fGa_vec.clear();  
  fGa_vec   = ISlowControlDatabase::Get().QueryGetFieldNoCache( astart, "gasmonchamber_ga", fGa_names, 100 );
  return;
}

///------------------------------------------------------------------------
/// Read another chunk of data from slow control database
void ITPCGas::ReadSlowDB_Gb(){
  /// read next 500 entries starting from 10 minutes ago
  long astart = fTime - 2000;
  fGb_vec.clear();  
  fGb_vec   = ISlowControlDatabase::Get().QueryGetFieldNoCache( astart, "gasmonchamber_gb", fGb_names, 100 );
  return;
}

///--------------------------------------------------------------------
/// Print out the values for the current time
void ITPCGas::Print(){
  
  std::cout<<"<ITPCGas::Print> Record for "<<fTimeStamp<<" ctime="<<fTime<<std::endl;
  std::cout<<"Ar  flow            (l/min):\t"<<fArFlow<<std::endl;
  std::cout<<"CF4 flow            (l/min):\t"<<fCF4Flow<<std::endl;
  std::cout<<"Ibu flow            (l/min):\t"<<fIbuFlow<<std::endl;
  std::cout<<"Atmospheric Pressure  (bar):\t"<<fPatm<<std::endl;
  std::cout<<"dP (gap-atmosphere) (mbarg):\t"<<fPD1<<std::endl;
  std::cout<<"dP (inner-gap)      (mbarg):\t"<<fPD2<<std::endl;
  std::cout<<"P  (inner)           (mbar):\t"<<fPD2<<std::endl;
  std::cout<<"dP (ibumon-atmos)   (mbarg):\t"<<fPD4<<std::endl;
  std::cout<<"H2O                   (ppm):\t"<<fH2O<<std::endl;
  std::cout<<"O2                    (ppm):\t"<<fO2<<std::endl;
  std::cout<<"Ibu Monitor             (%):\t"<<fIbuMon<<std::endl;
  std::cout<<"Ibu Analyzer (crap)     (%):\t"<<fIbuAn<<std::endl;
  std::cout<<"CO2 Analyzer          (ppm):\t"<<fCO2An<<std::endl;
  std::cout<<"CF4 Analyzer            (%):\t"<<fCF4An<<std::endl;
  std::cout<<"O2 analyzer Temp     (degC):\t"<<fTO2<<std::endl;
  std::cout<<"TPC1 manifold Temp   (degC):\t"<<fTTPC1<<std::endl;
  std::cout<<"TPC2 manifold Temp   (degC):\t"<<fTTPC2<<std::endl;
  std::cout<<"TPC3 manifold Temp   (degC):\t"<<fTTPC3<<std::endl;
  std::cout<<"Ibu flowmeter1 Temp  (degC):\t"<<fD0TC1<<std::endl;  
  std::cout<<"Ibu flowmeter2 Temp  (degC):\t"<<fD0TC2<<std::endl;  
  std::cout<<"Ibu purge supply Temp(degC):\t"<<fD0TC3<<std::endl;    
  std::cout<<"Ar supply line Temp  (degC):\t"<<fD0TC4<<std::endl;    
  std::cout<<"Ibu norm supply Temp (degC):\t"<<fD0TC5<<std::endl;  					     	 			  
  std::cout<<"purifier 1 top Temp  (degC):\t"<<fP0TC1<<std::endl;    
  std::cout<<"purifier 1 mid Temp  (degC):\t"<<fP0TC2<<std::endl;    
  std::cout<<"purifier 1 bot Temp  (degC):\t"<<fP0TC3<<std::endl;    
  std::cout<<"purifier 2 top Temp  (degC):\t"<<fP0TC4<<std::endl;    
  std::cout<<"purifier 2 mid Temp  (degC):\t"<<fP0TC5<<std::endl;    
  std::cout<<"purifier 2 bot Temp  (degC):\t"<<fP0TC6<<std::endl;      					     	 			  
  std::cout<<"Ibu bottle 1 Temp    (degC):\t"<<fDXTC1<<std::endl;    
  std::cout<<"Ibu bottle 2 Temp    (degC):\t"<<fDXTC2<<std::endl;    
  std::cout<<"Ibu line Temp        (degC):\t"<<fDXTC3<<std::endl;
  std::cout<<"Drift speed input  (cm/mus):\t"<<fVdIn <<std::endl;
  std::cout<<"Drift speed in unc.(cm/mus):\t"<<fVdInUnc<<std::endl;
  std::cout<<"Drift speed return (cm/mus):\t"<<fVdOut <<std::endl;
  std::cout<<"Drift speed ret unc(cm/mus):\t"<<fVdOutUnc <<std::endl;

  std::cout<<"Gain of input gas          :\t"<<fGainIn <<std::endl;
  std::cout<<"Unc. in gain of input gas  :\t"<<fGainInUnc<<std::endl;
  std::cout<<"Gain of return gas         :\t"<<fGainOut <<std::endl;
  std::cout<<"Unc. in gain of return gas :\t"<<fGainOutUnc <<std::endl;

}


///--------------------------------------------------------------------
/// Get the time interval for this record
void ITPCGas::GetTimeInterval(long &start_time, long &end_time){
  start_time = fStart;
  end_time = fEnd;
  if ( fPlca_vec.size() > fPlca_idx+2 ){
    start_time = (long) fPlca_vec[ fPlca_idx ].first;
    end_time = (long) fPlca_vec[ fPlca_idx+1 ].first;
  } else if ( fPlca_vec.size() < 2 ){
    end_time = fEndTime+1;
  }
  return;
}


///--------------------------------------------------------------------
/// Get unix time
long ITPCGas::GetUnixTime( int ayear, int amonth, int aday, int ahour, int amin, int asec){  
  tm mt;
  // use time structure from time.h
  // to build unix time from year,month, etc.
  mt.tm_year = ayear - 1900;
  mt.tm_mon  = amonth-1;
  mt.tm_mday = aday;
  mt.tm_hour = ahour;
  mt.tm_min  = amin;
  mt.tm_sec  = asec;
  mt.tm_isdst = -1;
  return (long)mktime(&mt);
}


///--------------------------------------------------------------------
/// Set the time for this object
void ITPCGas::SetTimeNoRead( int ayear, int amonth, int aday, int ahour, int amin, int asec){  
  fTime = (int)GetUnixTime(ayear, amonth, aday, ahour, amin, asec );
  //std::cout<<"SetTimeNoRead "<<ayear<<"/"<<amonth<<"/"<<aday<<" "<<ahour<<":"<<amin<<":"<<asec<<" fTime="<<fTime<<std::endl;
}


///--------------------------------------------------------------------
/// Set sg timestamp from unix integer timestamp
void ITPCGas::SetupTimeStamp(){
  char * aCtime;//[256];
  aCtime = ctime(  (const time_t*)&fTime );
  int aslen = strlen(aCtime);
  if (fTimeStamp!=0x0) delete [] fTimeStamp;
  fTimeStamp = new char[aslen+1];
  sprintf(fTimeStamp,"%s",aCtime);
  //std::cout<<"SetupTimeStamp "<<fTimeStamp<<" fTime="<<fTime<<std::endl;
}

///--------------------------------------------------------------------
/// Set the time for this object
void ITPCGas::GetTime( int &ayear, int &amonth, int &aday, int &ahour, int &amin, int &asec) {
  tm mt;  
  // use time structure from time.h to get time 
  localtime_r( (const time_t*) &fTime, &mt );
  // to build unix time from year,month, etc.
  ayear = 1900 + mt.tm_year;
  amonth = mt.tm_mon;
  aday = mt.tm_mday;
  ahour = mt.tm_hour;
  amin = mt.tm_min;
  asec = mt.tm_sec;
}


///--------------------------------------------------------------------
/// Apply un-correction to the CF4 reading
float ITPCGas::UnCorrectCF4(float aCF4,float aC4H10){
  //"Note aCF4 is true reading, aC4H10 should be true value"
  if ( aC4H10 < 0.0 ) aC4H10 = 0.0;
  if ( aCF4 < 0.0 ) aCF4 = 0.0;
  float retval = fUnParCF4[0];
  retval +=  fUnParCF4[1]*sqrt(aCF4);
  retval +=  fUnParCF4[2]*aCF4;
  retval +=  fUnParCF4[3]*aCF4*aCF4;
  retval +=  fUnParCF4[4]*aC4H10;
  retval +=  fUnParCF4[5]*aC4H10*sqrt(aCF4);
  retval +=  fUnParCF4[6]*aC4H10*aCF4;
  retval +=  fUnParCF4[7]*aC4H10*aCF4*aCF4;
  if (retval < 0.0) retval = 0.0;
  return retval;
}

///--------------------------------------------------------------------
/// Apply un-correction to the CO2 reading
float ITPCGas::UnCorrectCO2(float aCO2,float aC4H10,float aCF4){
  //"Note aCO2 is true reading, aC4H10 and aCF4 should be true values"
  if ( aCO2 < 0.0 ) aCO2 = 0.0;
  if ( aC4H10 < 0.0 ) aC4H10 = 0.0;
  if ( aCF4 < 0.0 ) aCF4 = 0.0;
  float retval = fUnParCO2[0] ;
  retval = retval+ fUnParCO2[1] * aCO2;
  retval = retval+ fUnParCO2[2] * sqrt(aCO2);
  retval = retval+ fUnParCO2[3] * aC4H10;         
  retval = retval+ fUnParCO2[4] * sqrt(aC4H10);
  retval = retval+ fUnParCO2[5] * aCF4;
  retval = retval+ fUnParCO2[6] * aC4H10 * aCF4;
  retval = retval+ fUnParCO2[7] * sqrt(aC4H10) * aCF4;
  retval = retval+ fUnParCO2[8] * aC4H10 * aCO2;                        
  retval = retval+ fUnParCO2[9] * sqrt( aC4H10 ) * aCO2;
  retval = retval+ fUnParCO2[10]* aCF4 * aCO2;                         
  retval = retval+ fUnParCO2[11]* aC4H10 * aCF4 * aCO2;                
  retval = retval+ fUnParCO2[12]* sqrt(aC4H10) * aCF4 * aCO2;       
  retval = retval+ fUnParCO2[13]* aC4H10 * sqrt(aCO2);                        
  retval = retval+ fUnParCO2[14]* sqrt( aC4H10 * aCO2 );       
  retval = retval+ fUnParCO2[15]* aCF4 * sqrt( aCO2 );                        
  retval = retval+ fUnParCO2[16]* aC4H10 * aCF4 * sqrt( aCO2 );         
  retval = retval+ fUnParCO2[17]* aCO2 * aCO2;
  if (retval < 0.0) retval = 0.0;
  return retval;
}


///--------------------------------------------------------------------
/// Apply a correction to the CF4 reading
float ITPCGas::CorrectCF4(float aCF4,float aC4H10){
  //"Note aCF4 is MGA3000 reading, aC4H10 should be true value"
  if ( aC4H10 < 0.0 ) aC4H10 = 0.0;
  if ( aCF4 < 0.2 ) aCF4 = 0.0;
  float retval = fParCF4[0];
  retval +=  fParCF4[1]*sqrt(aCF4);
  retval +=  fParCF4[2]*aCF4;
  retval +=  fParCF4[3]*aCF4*aCF4;
  retval +=  fParCF4[4]*aC4H10;
  retval +=  fParCF4[5]*aC4H10*sqrt(aCF4);
  retval +=  fParCF4[6]*aC4H10*aCF4;
  retval +=  fParCF4[7]*aC4H10*aCF4*aCF4;
  if (retval < 0.0) retval = 0.0;
  return retval;
}

///--------------------------------------------------------------------
/// Apply a correction to the CO2 reading
float ITPCGas::CorrectCO2(float aCO2,float aC4H10,float aCF4){
  //"Note aCO2 is MGA3000 reading, aC4H10 and aCF4 should be true values"
  if ( aCO2 < 0.0 ) aCO2 = 0.0;
  if ( aC4H10 < 0.0 ) aC4H10 = 0.0;
  if ( aCF4 < 0.0 ) aCF4 = 0.0;
  float retval = fParCO2[0] ;
  retval = retval+ fParCO2[1] * aCO2;
  retval = retval+ fParCO2[2] * aCO2 * aCO2;
  retval = retval+ fParCO2[3] * aC4H10;         
  retval = retval+ fParCO2[4] * aC4H10 * aC4H10;
  retval = retval+ fParCO2[5] * aCF4;
  retval = retval+ fParCO2[6] * aC4H10 * aCF4;
  retval = retval+ fParCO2[7] * aC4H10 * aC4H10 * aCF4;
  retval = retval+ fParCO2[8] * aC4H10 * aCO2;                        
  retval = retval+ fParCO2[9] * aC4H10 * aC4H10 * aCO2;
  retval = retval+ fParCO2[10]* aCF4 * aCO2;                         
  retval = retval+ fParCO2[11]* aC4H10 * aCF4 * aCO2;                
  retval = retval+ fParCO2[12]* aC4H10 * aC4H10 * aCF4 * aCO2;       
  retval = retval+ fParCO2[13]* aC4H10 * aCO2 * aCO2;                        
  retval = retval+ fParCO2[14]* aC4H10 * aC4H10 * aCO2 * aCO2;       
  retval = retval+ fParCO2[15]* aCF4 * aCO2 * aCO2;                        
  retval = retval+ fParCO2[16]* aC4H10 * aCF4 * aCO2 * aCO2;         
  retval = retval+ fParCO2[17]* aC4H10 * aC4H10 * aCF4 * aCO2 * aCO2;
  if (retval < 0.0) retval = 0.0;
  return retval;
}

///--------------------------------------------------------------------
/// Apply temperature corrections, and gas cross term Corrections
void ITPCGas::ApplyCorrections(){
  float aT = 20.0 ; // assume 20degC if bad reading!
  if ( fTO2 > 0.0 ) aT = fTO2;
  float aP = fPatm*1000.0;

  // Isobutane analyzer corrections.
  if ( fTime < fIbuCorTime ){
    // pressure correction always done by PLC, just need to 
    // include temperature correction...
    fIbuMon = TMath::Log( fIbuMon / 0.286 ) / 0.1564;
    // now do overall calib
    fIbuMon = 0.286*TMath::Exp( 0.1564*( fIbuMon - 0.1967*(aT-29.19) ) )  ;
  }


  // Main gas analyzer corrections.
  // First undo any corrections applied in PLC
  if ( fTime < fAnalyzerCorTime ) {
    // no corrections were done
    
  } else {
    // first step is to undo cross term corrections
    fCO2An = UnCorrectCO2( fCO2An, 2.0, fCF4An );
    fCF4An = UnCorrectCF4( fCF4An, 2.0 );
    
    // now undo temperature or pressure correction... 
    // depending on date
    if ( fTime < fAnalyzerCorTime2 ){
      // undo older temperature only correction
      fCF4An -= 0.0438 * aT - 0.625;
      fCO2An -= 12.94 * aT - 250.0;
    } else {
      fCF4An -= -2.962 * aP/(aT+273.15) + 10.71;
      fCO2An -= -901.8 * aP/(aT+273.15) + 3165.0;
    }
  }

  // Apply the new temperature correction
  // P/T correction seemed about right for CF4, now add slight T only correction
  fCF4An += -2.0 * aP/(aT+273.15) + 6.8 + 0.0213*aT;
  // CO2 is dominated by temperature correction
  fCO2An += 0.036 * fCO2An * (aT-20) + 8.287 * aT - 1.47 * aP + 1327.3; 

  // now do cross term corrections
  fCF4An = CorrectCF4( fCF4An, 2.0 );
  fCO2An = CorrectCO2( fCO2An, 2.0, fCF4An );

  // Apply corrections to gain and drift velocity
  fVdIn    += 4.0 * aP / (aT+273.15) - 14.0;       
  fVdOut   += 4.0 * aP / (aT+273.15) - 14.0;    
  fGainIn  +=  2350.0 * aP / (aT+273.15) - 8225.0;    
  fGainOut +=  2350.0 * aP / (aT+273.15) - 8225.0;    

}

///------------------------------------------------------------------------
/// Get index into each of the vectors of database query
/// results for the current time
void ITPCGas::UpdateVectorTimeIdx(){
  
  // Find index for current time for PLCA
  fPlca_isok = false;
  if ( fPlca_vec.size()==1 ){
    fPlca_idx = 0;
    fPlca_isok = true;
  } else {
    for (int i=0; i<int(fPlca_vec.size())-2; i++){
      if ( fTime >= long( (fPlca_vec[i].first) ) &&
	   fTime <  long( (fPlca_vec[i+1].first) ) ) {
	fPlca_idx = i;
	fPlca_isok = true;
	break;
      }
    }
  }
  //if (fPlca_isok==false) std::cout<<"Plca_isok==false for "<<fTimeStamp<<std::endl;

  // Find index for current time for Tpc1 temperature
  fTpc1_isok = false;
  if ( fTpc1_vec.size()==1 ){
    fTpc1_idx = 0;
    fTpc1_isok = true;
  } else {
    for (int i=0; i<int(fTpc1_vec.size())-2; i++){
      if ( fTime >= long( (fTpc1_vec[i].first) ) &&
	   fTime <  long( (fTpc1_vec[i+1].first) ) ) {
	fTpc1_idx = i;
	fTpc1_isok = true;
	break;
      }
    }
  }
  //if (fTpc1_isok==false) std::cout<<"fTpc1_isok==false for "<<fTimeStamp<<std::endl;
  
  // Find index for current time for Tpc2 temperature
  fTpc2_isok = false;
  if ( fTpc2_vec.size()==1 ){
    fTpc2_idx = 0;
    fTpc2_isok = true;
  } else {
    for (int i=0; i<int(fTpc2_vec.size())-2; i++){
      if ( fTime >= long( (fTpc2_vec[i].first) ) &&
	   fTime <  long( (fTpc2_vec[i+1].first) ) ) {
	fTpc2_idx = i;
	fTpc2_isok = true;
	break;
      }
    }
  }
  //if (fTpc2_isok==false) std::cout<<"fTpc2_isok==false for "<<fTimeStamp<<std::endl;
  
  // Find index for current time for Tpc3 temperature
  fTpc3_isok = false;
  if ( fTpc3_vec.size()==1 ){
    fTpc3_idx = 0;
    fTpc3_isok = true;
  } else {  
    for (int i=0; i<int(fTpc3_vec.size())-2; i++){
      if ( fTime >= long( (fTpc3_vec[i].first) ) &&
	   fTime <  long( (fTpc3_vec[i+1].first) ) ) {
	fTpc3_idx = i;
	fTpc3_isok = true;
	break;
      }
    }
  }
  //if (fTpc3_isok==false) std::cout<<"fTpc3_isok==false for "<<fTimeStamp<<std::endl;

  // Find index for current time for Vdrift A
  fVda_isok = false;
  if ( fVda_vec.size()==1 ){
    fVda_idx = 0;
    fVda_isok = true;
  } else {  
    for (int i=0; i<int(fVda_vec.size())-2; i++){
      if ( fTime >= long( (fVda_vec[i].first) ) &&
	   fTime <  long( (fVda_vec[i+1].first) ) ) {
	fVda_idx = i;
	fVda_isok = true;
	break;
      }
    }
  }
  //if (fVda_isok==false) std::cout<<"fVda_isok==false for "<<fTimeStamp<<std::endl;

  // Find index for current time for Vdrift B 
  fVdb_isok = false;
  if ( fVdb_vec.size()==1 ){
    fVdb_idx = 0;
    fVdb_isok = true;
  } else {  
    for (int i=0; i<int(fVdb_vec.size())-2; i++){
      if ( fTime >= long( (fVdb_vec[i].first) ) &&
	   fTime <  long( (fVdb_vec[i+1].first) ) ) {
	fVdb_idx = i;
	fVdb_isok = true;
	break;
      }
    }
  }
  //if (fVdb_isok==false) std::cout<<"fVdb_isok==false for "<<fTimeStamp<<std::endl;

  // Find index for current time for Gain A
  fGa_isok = false;
  if ( fGa_vec.size()==1 ){
    fGa_idx = 0;
    fGa_isok = true;
  } else {  
    for (int i=0; i<int(fGa_vec.size())-2; i++){
      if ( fTime >= long( (fGa_vec[i].first) ) &&
	   fTime <  long( (fGa_vec[i+1].first) ) ) {
	fGa_idx = i;
	fGa_isok = true;
	break;
      }
    }
  }
  //if (fGa_isok==false) std::cout<<"fGa_isok==false for "<<fTimeStamp<<std::endl;

  // Find index for current time for Gain B
  fGb_isok = false;
  if ( fGb_vec.size()==1 ){
    fGb_idx = 0;
    fGb_isok = true;
  } else {  
    for (int i=0; i<int(fGb_vec.size())-2; i++){
      //std::cout<<" i="<<i<<std::endl;
      if ( fTime >= long( (fGb_vec[i].first) ) &&
	   fTime <  long( (fGb_vec[i+1].first) ) ) {
	fGb_idx = i;
	fGb_isok = true;
	break;
      }
    }
  }
  //if (fGb_isok==false) std::cout<<"fTGb_isok==false for "<<fTimeStamp<<std::endl;

  return;
}


///--------------------------------------------------------------------
/// Check if anouther chunk of data needs to be read from 
/// slow control database
void ITPCGas::CheckReadDB(){

  //std::cout<<"<ITPCGas::CheckReadDB> "<<fTimeStamp<<std::endl;
  if ( fPlca_vec.size() <= 2 ||
       fTime > long( fPlca_vec[ fPlca_vec.size()-2 ].first ) ){
    //std::cout<<"<ITPCGas::CheckReadDB> About to ReadSlowDB_Plca"<<std::endl;
    ReadSlowDB_Plca();
  }

  if ( fTpc1_vec.size() <= 2 ||
       fTime > long( fTpc1_vec[ fTpc1_vec.size()-2 ].first ) ){
    //std::cout<<"<ITPCGas::CheckReadDB> About to ReadSlowDB_Tpc1"<<std::endl;
    ReadSlowDB_Tpc1();
  }

  if ( fTpc2_vec.size() <= 2 ||
       fTime > long( fTpc2_vec[ fTpc2_vec.size()-2 ].first ) ){
    //std::cout<<"<ITPCGas::CheckReadDB> About to ReadSlowDB_Tpc2"<<std::endl;
    ReadSlowDB_Tpc2();
  }

  if ( fTpc3_vec.size() <= 2 ||
       fTime > long( fTpc3_vec[ fTpc3_vec.size()-2 ].first ) ){
    //std::cout<<"<ITPCGas::CheckReadDB> About to ReadSlowDB_Tpc3"<<std::endl;
    ReadSlowDB_Tpc3();
  }

  if ( fVda_vec.size() <= 2 ||
       fTime > long( fVda_vec[ fVda_vec.size()-2 ].first ) ){
    //std::cout<<"<ITPCGas::CheckReadDB> About to ReadSlowDB_Vda"<<std::endl;
    ReadSlowDB_Vda();
  }

  if ( fVdb_vec.size() <= 2 ||
       fTime > long( fVdb_vec[ fVdb_vec.size()-2 ].first ) ){
    //std::cout<<"<ITPCGas::CheckReadDB> About to ReadSlowDB_Vdb"<<std::endl;
    ReadSlowDB_Vdb();
  }

  if ( fGa_vec.size() <= 2 ||
       fTime > long( fGa_vec[ fGa_vec.size()-2 ].first ) ){
    //std::cout<<"<ITPCGas::CheckReadDB> About to ReadSlowDB_Ga"<<std::endl;
    ReadSlowDB_Ga();
  }

  if ( fGb_vec.size() <= 2 ||
       fTime > long( fGb_vec[ fGb_vec.size()-2 ].first ) ){
    //std::cout<<"<ITPCGas::CheckReadDB> About to ReadSlowDB_Gb"<<std::endl;
    ReadSlowDB_Gb();
  }

  return;
}

///--------------------------------------------------------------------
/// Read the temperature reading and update all
/// object temperature readings. 
void ITPCGas::Read(){
  SetupTimeStamp();

  // Read gas properties
  // since often they are not available, set to -1 for no reading
  fArFlow  = -1.;
  fCF4Flow = -1.;
  fIbuFlow = -1.;
  fPatm    = -1.;
  fPD1     = -1.;
  fPD2     = -1.;
  fP       = -1.;
  fPD4     = -1.;
  fH2O     = -1.;
  fO2      = -1.;
  fIbuMon  = -1.;
  fIbuAn   = -1.;
  fCO2An   = -1.;
  fCF4An   = -1.;
  fTO2     = -1.;
  fD0TC1   = -1.;
  fD0TC2   = -1.;
  fD0TC3   = -1.;
  fD0TC4   = -1.;
  fD0TC5   = -1.;
  fP0TC1   = -1.;
  fP0TC2   = -1.;
  fP0TC3   = -1.;
  fP0TC4   = -1.;
  fP0TC5   = -1.;
  fP0TC6   = -1.;
  fDXTC1   = -1.;
  fDXTC2   = -1.;
  fDXTC3   = -1.;
  fVdIn    = -1.;       
  fVdInUnc = -1.;
  fVdOut   = -1.;    
  fVdOutUnc= -1.;   
  fGainIn    = -1.;       
  fGainInUnc = -1.;
  fGainOut   = -1.;    
  fGainOutUnc= -1.;   

  // Check if we need to read more data
  // from slow control database
  CheckReadDB();

  // Get index into each of the vectors of database query
  // results for the current time
  UpdateVectorTimeIdx();

  if ( fPlca_isok == true ){
    // Read Flows
    fArFlow  = fPlca_vec[ fPlca_idx ].second[0];
    fCF4Flow = fPlca_vec[ fPlca_idx ].second[1];
    fIbuFlow = fPlca_vec[ fPlca_idx ].second[2];
    
    // Read Pressures
    fPatm    = fPlca_vec[ fPlca_idx ].second[3];
    fPD1     = fPlca_vec[ fPlca_idx ].second[4];
    fPD2     = fPlca_vec[ fPlca_idx ].second[5];
    fP       = fPatm*1000.0 + fPD1 + fPD2; // need to convert atm from bar to mbar
    fPD4     = fPlca_vec[ fPlca_idx ].second[6];
    fPD4     *= 1000.0; // convert from bar to mbar 
    
    // Read analyzer values
    fH2O     = fPlca_vec[ fPlca_idx ].second[7];
    fO2      = fPlca_vec[ fPlca_idx ].second[8];
    fIbuMon  = fPlca_vec[ fPlca_idx ].second[9];
    fIbuAn   = fPlca_vec[ fPlca_idx ].second[10];
    fCO2An   = fPlca_vec[ fPlca_idx ].second[11];
    fCF4An   = fPlca_vec[ fPlca_idx ].second[12];
    fTO2     = fPlca_vec[ fPlca_idx ].second[13];
    
    // Read mixing room temperatures
    fD0TC1   = fPlca_vec[ fPlca_idx ].second[14];
    fD0TC2   = fPlca_vec[ fPlca_idx ].second[15];
    fD0TC3   = fPlca_vec[ fPlca_idx ].second[16];
    fD0TC4   = fPlca_vec[ fPlca_idx ].second[17];
    fD0TC5   = fPlca_vec[ fPlca_idx ].second[18];
    
    // Read purifier temperatures
    fP0TC1   = fPlca_vec[ fPlca_idx ].second[19];
    fP0TC2   = fPlca_vec[ fPlca_idx ].second[20];
    fP0TC3   = fPlca_vec[ fPlca_idx ].second[21];
    fP0TC4   = fPlca_vec[ fPlca_idx ].second[22];
    fP0TC5   = fPlca_vec[ fPlca_idx ].second[23];
    fP0TC6   = fPlca_vec[ fPlca_idx ].second[24];
    
    // Read isobutane cylinder temperatures
    fDXTC1   = fPlca_vec[ fPlca_idx ].second[25];
    fDXTC2   = fPlca_vec[ fPlca_idx ].second[26];
    fDXTC3   = fPlca_vec[ fPlca_idx ].second[27];
  }

  // read manifold temperatures
  int nman;
  float tman[4];
  if ( fTpc1_isok == true ) {
    tman[0] =  fTpc1_vec[ fTpc1_idx ].second[0];
    tman[1] =  fTpc1_vec[ fTpc1_idx ].second[1];
    tman[2] =  fTpc1_vec[ fTpc1_idx ].second[2]; 
    tman[3] =  fTpc1_vec[ fTpc1_idx ].second[3];
    fTTPC1 = 0;
    nman=0;
    for (int ii=0;ii<4;ii++){
      if ( tman[ii]>0.1 && tman[ii] < 60.0 ){
	nman++;
	fTTPC1+=tman[ii];
      }
    }
    if (nman>0) fTTPC1 /= float(nman);
    else fTTPC1 = -273.;
  }

  if ( fTpc2_isok == true ) {
    tman[0] = fTpc2_vec[ fTpc2_idx ].second[0];  
    tman[1] = fTpc2_vec[ fTpc2_idx ].second[1];   
    tman[2] = fTpc2_vec[ fTpc2_idx ].second[2];  
    tman[3] = fTpc2_vec[ fTpc2_idx ].second[3]; 
    fTTPC2 = 0;
    nman=0;
    for (int ii=0;ii<4;ii++){
      if ( tman[ii]>0.1 && tman[ii] < 60.0 ){
	nman++;
	fTTPC2+=tman[ii];
      }
    }
    if (nman>0) fTTPC2 /= float(nman);
    else fTTPC2 = -273.;
  }


  if ( fTpc3_isok == true ) {
    tman[0] = fTpc3_vec[ fTpc3_idx ].second[0];  
    tman[1] = fTpc3_vec[ fTpc3_idx ].second[1];   
    tman[2] = fTpc3_vec[ fTpc3_idx ].second[2];  
    tman[3] = fTpc3_vec[ fTpc3_idx ].second[3]; 
    fTTPC3 = 0;
    nman=0;
    for (int ii=0;ii<4;ii++){
      if ( tman[ii]>0.1 && tman[ii] < 60.0 ){
	nman++;
	fTTPC3+=tman[ii];
      }
    }
    if (nman>0) fTTPC3 /= float(nman);
    else fTTPC3 = -273.;
  }

  // Read monitor chamber drift information
  if ( fVdb_isok == true ){
    fVdIn    = fVdb_vec[ fVdb_idx ].second[0];
    fVdInUnc = fVdb_vec[ fVdb_idx ].second[1];
  }
  if ( fVda_isok == true ){
    fVdOut   = fVda_vec[ fVda_idx ].second[0];
    fVdOutUnc= fVda_vec[ fVda_idx ].second[1];
  }
  if ( fGb_isok == true ){
    fGainIn    =  fGb_vec[ fGb_idx ].second[0];       
    fGainInUnc =  fGb_vec[ fGb_idx ].second[1];
  }
  if ( fGa_isok == true ){
    fGainOut   =  fGa_vec[ fGa_idx ].second[0]; 
    fGainOutUnc=  fGa_vec[ fGa_idx ].second[1];
  }

  // check if gas analyzer corrections are done here
  // or if they were already done by the PLC
  // note that between (March 25,2010 13:40) and (May 2, 2010 22:59)
  // the correction was not final version, but it is too
  // tricky to uncorrect then correct it, so not optimal. 
  if ( fPlca_isok == true ) ApplyCorrections();
  
  if (fDebug){ 
    // Time check:
    long db_time = (long)ISlowControlDatabase::Get().QueryShowField(fTime,"tpcgasplc_plca","_i_time");
    std::cout << "<ITPCGas::Read>"<<std::endl;
    std::cout << "   Requested Time: " << fTime << ", Database entry time: "<< db_time <<std::endl;
    Print();
    fTime = db_time;
  }
}


///--------------------------------------------------------------------
/// Read the next gas properties reading after current time setting and
/// update all readings.  Return 1 if all is okay otherwize return 
/// negative value.
int ITPCGas::ReadNext(int adeltat){

  static int amult = 1;
  
  GetTimeInterval(fStart,fEnd);
  
  if (fStart+adeltat > fEnd){
    amult = 1;
    fTime = fTime + adeltat;
  } else {
    if ( fEnd+1 <= fTime ){
      // handle case where no readings for a while
      amult*=2;
      fTime += amult;

    } else {
      amult = 1;
      fTime = fEnd+1;
    }
  }

  
  Read();

  return 1;
}