/// Class to hold TPC MM status for
/// a particular time.  The class
/// holds information to indicate whether:
///   Low Voltages are on
///   FEMs are Powered
///   MM HV > 245V
///   DCC Power on
///   Cathode HV 24950 to 25050 V
/// Blair Jamieson (C) 2010

#include <string>
#include <math.h>

#include "IOARuntimeParameters.hxx"
#include "ITPCMMStatus.hxx"


///------------------------------------------------------------------------
/// Initialize TPC MM status object using unix time
/// If it is intended to use this class to read many
/// sequential values, set ancache to some value large
/// enough to reduce the number of sql queries
ITPCMMStatus::ITPCMMStatus( long autime, long atstart, long atend ){
  fTime = autime;      // time of current values
  fDebug = false;
  fTimeStamp = 0x0;
  fStartTime = atstart; 
  fEndTime = atend;
  
  Init();
}


///------------------------------------------------------------------------
/// Initialize TPC MM status object using year, month(0-11),
/// day(1-31),...
ITPCMMStatus::ITPCMMStatus(
					   int ayear,
					   int amonth,
					   int aday,
					   int ahour,
					   int amin,
					   int asec,
					   long atstart,
					   long atend){
  fTimeStamp=0x0;
  fDebug = false;
  SetTimeNoRead(ayear, amonth, aday, ahour, amin, asec);
  fStartTime = atstart; 
  fEndTime = atend;
  Init();
}



///------------------------------------------------------------------------
/// Initialize MM status properties object
/// Sets offsets, makes histogram, reads values
void ITPCMMStatus::Init(){
  // setup timestamps of MMHV channel swaps in beam run 31
  fTimeSwap1 = 1269254703;
  fTimeSwap2 = 1269468318;

  // Read special parameter settings
  SetupCheck();

  // Setup field name strings to read
  SetupFieldNames();

  // Now read system properties
  fLV0_vec.clear();
  Read();
}

///------------------------------------------------------------------------
/// Read in the oaRunParameters settings for what to check
void ITPCMMStatus::SetupCheck(){
  char aname[256];
  for (int ifem=0; ifem<6; ifem++){
    sprintf(aname,"oaSlowControlDatabase.toolTPCStatus.enableCheckFEM%d",ifem);
    fFEMCheck[ifem] = (bool) COMET::IOARuntimeParameters::Get().GetParameterI(aname);
    if (fFEMCheck[ifem]==false){
      std::cout<<"WARN: Not checking FEM"<<ifem<<" voltages"<<std::endl;
    }
  }
  for (int itpc=0; itpc<3; itpc++){
    for (int iep=0; iep<2; iep++){
      for (int imm=0; imm<12; imm++){
	sprintf(aname,"oaSlowControlDatabase.toolTPCStatus.TPC%dRP%dMM%dminV",itpc+1,iep,imm);
	fMM_HVminV[itpc][iep][imm] = COMET::IOARuntimeParameters::Get().GetParameterD(aname);
	if ( fMM_HVminV[itpc][iep][imm] < 345.0 ){
	  std::cout<<"WARN: Check minimum MMHV>"<<fMM_HVminV[itpc][iep][imm]
		   <<" for TPC"<<itpc+1<<" RP"<<iep<<" MM"<<imm<<std::endl;
	}
      }
    }
  }
  for (int idcc=0; idcc<18; idcc++){
    sprintf(aname,"oaSlowControlDatabase.toolTPCStatus.enableCheckDCC%d",idcc);
    fDCCCheck[idcc] = (bool) COMET::IOARuntimeParameters::Get().GetParameterI(aname);

    int itpc;
    if (idcc<6) itpc = 1;
    else if (idcc<12) itpc=2;
    else itpc=0;
    int irp = (idcc%6)/3;
    int immoffs = ((idcc%6)%3)*2;

    fDCC_V_Check[itpc][irp][immoffs] = fDCCCheck[idcc];
    fDCC_V_Check[itpc][irp][immoffs+1] = fDCCCheck[idcc];
    fDCC_V_Check[itpc][irp][immoffs+6] = fDCCCheck[idcc];
    fDCC_V_Check[itpc][irp][immoffs+7] = fDCCCheck[idcc];
    if ( fDCCCheck[idcc]==false ){
      std::cout<<"WARN: Not checking DCC"<<idcc<<" voltage, for TPC"<<itpc<<" RP"<<irp
	       <<" MMs "<<immoffs<<", "<<immoffs+1<<", "<<immoffs+6<<", "<<immoffs+7<<", "
	       <<std::endl;
    }
  }
}

///------------------------------------------------------------------------
/// sets up the field names that are read from the slow control database
void ITPCMMStatus::SetupFieldNames(){
  fLV0_names.push_back( "c0m0_imeas" );
  fLV0_names.push_back( "c0m1_imeas" );
  fLV0_names.push_back( "c0m4_imeas" );
  fLV0_names.push_back( "c0m5_imeas" );
  fLV0_names.push_back( "c0m6_imeas" );
  fLV0_names.push_back( "c0m7_imeas" );
  
  fLV1_names.push_back( "c1m2_imeas" );
  fLV1_names.push_back( "c1m3_imeas" );
  fLV1_names.push_back( "c1m4_imeas" );
  fLV1_names.push_back( "c1m5_imeas" );
  fLV1_names.push_back( "c1m6_imeas" );
  fLV1_names.push_back( "c1m7_imeas" );

  char atabname[256];
  char avarname[256];

  for (int iep=0; iep<6; iep++){
    if ( fFEMCheck[iep] == false ) continue;
    sprintf(atabname,"tpc_fe_sc_tsc%1d",iep);
    fFEM_V_tabnames[iep] = std::string( atabname );
    for (int imm=0; imm<12; imm++){
      sprintf(avarname,"e%1dm%02dfem_v33",iep,imm);
      fFEM_V_names[iep].push_back( avarname );
    }
  }

  for (int itpc=0; itpc<3; itpc++){
    for (int irp=0; irp<2; irp++){
      for (int imm=0; imm<12; imm++){
	sprintf(avarname,"tpc%1d_rp%1d_mm%02d_sensevoltage",itpc+1,irp,imm);
	fMM_HV_names.push_back( avarname );
      }
    }
  }
  fMM_HV_names.push_back( "xsp_tpc3_rp0_13_sensevoltage" ); // spare channel used for TPC3 RP0 MM01 for a while

  for (int idcc=0; idcc<18; idcc++){
    int itpc;
    if (idcc<6) itpc = 1;
    else if (idcc<12) itpc=2;
    else itpc=0;
    int ipwrswitch = (idcc/6) + 1;
    int ioutvolt = (idcc%6) +1; 
    sprintf(atabname,"tpcdccpwr%02d_gp%02d",ipwrswitch,ipwrswitch);
    sprintf(avarname,"gp%02d_outvolt%1d",ipwrswitch,ioutvolt);
    fDCC_V_tabnames[itpc] = std::string( atabname );
    fDCC_V_names[itpc].push_back( avarname );
  }

  for (int itpc=0; itpc<3; itpc++){
    sprintf(atabname,"tpc%1d_ccu_v__cchv",itpc+1);
    fCath_V_names.push_back( atabname );
  }

  return;
}


///------------------------------------------------------------------------
/// Print all of the table readings for current time
void ITPCMMStatus::Print(){
  
  std::cout<<"<ITPCMMStatus::Print> Record for "<<fTimeStamp<<" ctime="<<fTime<<std::endl;
  std::cout<<"TPC RP MM  LVI(A)    FEMV(V)    MMHV(V)    DCCV(V)    VCath(V)    Status"<<std::endl;
  for (int itpc=0; itpc<3; itpc++){
    for (int irp=0; irp<2; irp++){
      for (int imm=0; imm<12; imm++){
	std::cout<< std::setiosflags(std::ios::fixed)
		 <<std::setw(3)
		 <<itpc+1<<"  "
		 <<irp<<"  "
		 <<imm<<"  "
		 <<std::setprecision(1)
		 <<std::setw(8)
		 <<fLV_I[itpc][irp][imm]<<"  "
		 <<fFEM_V[itpc][irp][imm]<<"  "
		 <<fMM_HV[itpc][irp][imm]<<"  "
		 <<fDCC_V[itpc][irp][imm]<<"  "
		 <<fCath_V[itpc]<<"  "
		 <<fMMStatus[itpc][irp][imm]
		 <<std::endl;
      }
    }
  }

  for (int itpc=0; itpc<3; itpc++){
    std::cout<<"TPC "<<itpc+1<<" Status is "<<fTPCStatus[itpc]<<std::endl;
  }
  std::cout<<"Overall TPC Status is "<<fStatus<<std::endl;
  return;
}


///------------------------------------------------------------------------
/// Get the time interval for this record
void ITPCMMStatus::GetTimeInterval(long &start_time, long &end_time){
  start_time = fStart;
  end_time = fEnd;
  if ( fLV0_vec.size() > fLV0_idx+1 ){
    start_time = (long) fLV0_vec[ fLV0_idx ].first;
    end_time = (long) fLV0_vec[ fLV0_idx+1 ].first;
  }

  return;
}


///------------------------------------------------------------------------
/// Get unix time
long ITPCMMStatus::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 ITPCMMStatus::SetTimeNoRead( int ayear, int amonth, int aday, int ahour, int amin, int asec){  
  fTime = 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 ITPCMMStatus::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 ITPCMMStatus::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;
}


///------------------------------------------------------------------------
/// Read another chunk of data from slow control database
void ITPCMMStatus::ReadSlowDB_LV0(int adeltat){
  /// read next nread entries
  long astart = fTime - 600;  
  int  nread = 500;
  if (fLV0_vec.size()>2){
    int adt = int(fLV0_vec[1].first - fLV0_vec[0].first);
    if ( adt < adeltat && adt>0 ) nread = (fEndTime - astart)/adt + 5;
    else nread = (fEndTime-astart)/adeltat +5;
    if ( nread > 10000 ) nread = 10000;
  }
  fLV0_vec.clear();
  fLV0_vec = ISlowControlDatabase::Get().QueryGetFieldNoCache(astart, "tpc_lv_ps_tlv0", fLV0_names, nread);
  return;
}

///------------------------------------------------------------------------
/// Read another chunk of data from slow control database
void ITPCMMStatus::ReadSlowDB_LV1(int adeltat){
  /// read next nread entries
  long astart = fTime - 600;
  int  nread = 500;
  if (fLV1_vec.size()>2){
    int adt = int(fLV1_vec[1].first - fLV1_vec[0].first);
    if ( adt < adeltat && adt>0 ) nread = (fEndTime - astart)/adt + 5;
    else nread = (fEndTime-astart)/adeltat +5;
    if ( nread > 10000 ) nread = 10000;
  }
  fLV1_vec.clear();
  fLV1_vec = ISlowControlDatabase::Get().QueryGetFieldNoCache(astart, "tpc_lv_ps_tlv1", fLV1_names, nread);
  return;
}

///------------------------------------------------------------------------
/// Read another chunk of data from slow control database
void ITPCMMStatus::ReadSlowDB_FEM_V(int adeltat){
  /// read next nread entries
  long astart = fTime - 600;
  int  nread = 500;
  if (fFEM_V_vec[0].size()>2){
    int adt = int(fFEM_V_vec[0][1].first - fFEM_V_vec[0][0].first);
    if ( adt < adeltat && adt>0 ) nread = (fEndTime - astart)/adt + 5;
    else nread = (fEndTime-astart)/adeltat +5;
    if ( nread > 10000 ) nread = 10000;
  }

  for ( int i=0; i<6; i++ ){
    if ( fFEMCheck[i] == false ) continue;
    fFEM_V_vec[i].clear();
    fFEM_V_vec[i] = ISlowControlDatabase::Get().QueryGetFieldNoCache(astart, fFEM_V_tabnames[i].c_str(), fFEM_V_names[i], nread);
  }
  return;
}

///------------------------------------------------------------------------
/// Read another chunk of data from slow control database
void ITPCMMStatus::ReadSlowDB_MM_HV(int adeltat){
  /// read next nread entries
  long astart = fTime - 600;
  int  nread = 500;
  if (fMM_HV_vec.size()>2){
    int adt = int(fMM_HV_vec[1].first - fMM_HV_vec[0].first);
    if ( adt < adeltat && adt>0 ) nread = (fEndTime - astart)/adt + 5;
    else nread = (fEndTime-astart)/adeltat +5;
    if ( nread > 10000 ) nread = 10000;
  }

  fMM_HV_vec.clear();
  fMM_HV_vec = ISlowControlDatabase::Get().QueryGetFieldNoCache( astart, "tpciseghv02_sensevoltage", fMM_HV_names, nread);
  return;
}

///------------------------------------------------------------------------
/// Read another chunk of data from slow control database
void ITPCMMStatus::ReadSlowDB_DCC_V(int adeltat){
  /// read next nread entries
  long astart = fTime - 300;
  int  nread = 500;
  if (fDCC_V_vec[0].size()>2){
    int adt = int(fDCC_V_vec[0][1].first - fDCC_V_vec[0][0].first);
    if ( adt < adeltat && adt>0 ) nread = (fEndTime - astart)/adt + 5;
    else nread = (fEndTime-astart)/adeltat +5;
    if ( nread > 10000 ) nread = 10000;
  }
  for ( int i=0; i<3; i++ ) fDCC_V_vec[i].clear();
  for ( int i=0; i<3; i++ ){
    fDCC_V_vec[i] = ISlowControlDatabase::Get().QueryGetFieldNoCache( astart, fDCC_V_tabnames[i].c_str(), fDCC_V_names[i], nread);
  }  
  return;
}

///------------------------------------------------------------------------
/// Read another chunk of data from slow control database
void ITPCMMStatus::ReadSlowDB_Cath_V(int adeltat){
  /// read next nread entries
  long astart = fTime - 300;
  int  nread = 500;
  if (fCath_V_vec.size()>2){
    int adt = int(fCath_V_vec[1].first - fCath_V_vec[0].first);
    if ( adt < adeltat && adt>0 ) nread = (fEndTime - astart)/adt + 5;
    else nread = (fEndTime-astart)/adeltat +5;
    if ( nread > 10000 ) nread = 10000;
  }
  fCath_V_vec.clear();
  fCath_V_vec = ISlowControlDatabase::Get().QueryGetFieldNoCache(astart, "ccbertan_cchv", fCath_V_names, nread);
  return;
}


///------------------------------------------------------------------------
/// Get index into each of the vectors of database query
/// results for the current time
void ITPCMMStatus::UpdateVectorTimeIdx(int adeltat){
  //  std::cout<<"UpdateVectorTimeIdx for time "<<fTime<<std::endl;

  // Find index for current and next time for LV0
  fLV0_isok = false;
  fLV0_next_isok = false;
  if ( fLV0_vec.size()>0 ){
    for (unsigned int i=0; i<fLV0_vec.size()-1; i++){
      if ( fTime >= long( (fLV0_vec[i].first) ) &&
	   fTime <  long( (fLV0_vec[i+1].first) ) ) {
	fLV0_idx = i;
	fLV0_isok = true;
      }
      if ( fTime+adeltat >= long( (fLV0_vec[i].first) ) &&
	   fTime+adeltat <  long( (fLV0_vec[i+1].first) ) ) {
	fLV0_next_idx = i;
	fLV0_next_isok = true;
	break;
      }
    }
  }
  
  // Find index for current and next time for LV1
  fLV1_isok = false;
  fLV1_next_isok = false;
  if ( fLV1_vec.size() > 0 ){
    for (unsigned int i=0; i<fLV1_vec.size()-1; i++){
      if ( fTime >= long(fLV1_vec[i].first) &&
	   fTime <  long(fLV1_vec[i+1].first) ) {
	fLV1_idx = i;
	fLV1_isok = true;
      }
      if ( fTime+adeltat >= long(fLV1_vec[i].first) &&
	   fTime+adeltat <  long(fLV1_vec[i+1].first) ) {
	fLV1_next_idx = i;
	fLV1_next_isok = true;
	break;
      }
    }
  }
  
  // Find index for current and next time for FEM_V
  for (int iep=0; iep<6; iep++){
    if ( fFEMCheck[iep] == false ) continue;
    fFEM_V_isok[iep] = false;
    fFEM_V_next_isok[iep] = false;
    if ( (fFEM_V_vec[iep]).size() == 0 ) continue;
    for (unsigned int i=0; i< (fFEM_V_vec[iep]).size()-1; i++){
      //std::cout<<"iep="<<iep<<" i="<<i<<" / "<<(fFEM_V_vec[iep]).size()-1<<std::endl;
      if ( fTime >= long( ( (fFEM_V_vec[iep])[i] ).first  ) &&
	   fTime <  long( ( (fFEM_V_vec[iep])[i+1] ).first  ) ) {
	fFEM_V_idx[iep] = i;
	fFEM_V_isok[iep] = true;
      }
      if ( fTime+adeltat >= long( ( (fFEM_V_vec[iep])[i] ).first  ) &&
	   fTime+adeltat <  long( ( (fFEM_V_vec[iep])[i+1] ).first  ) ) {
	fFEM_V_next_idx[iep] = i;
	fFEM_V_next_isok[iep] = true;
	break;
      }
    }
  }
  
  // Find index for current and next time for MM_HV
  fMM_HV_isok = false;
  fMM_HV_next_isok = false;
  for (unsigned int i=0; i<fMM_HV_vec.size()-1; i++){
    if ( fTime >= long( (fMM_HV_vec[i]).first) &&
	 fTime <  long( (fMM_HV_vec[i+1]).first) ) {
      fMM_HV_idx = i;
      fMM_HV_isok = true;
    }
    if ( fTime+adeltat >= long( (fMM_HV_vec[i]).first) &&
	 fTime+adeltat <  long( (fMM_HV_vec[i+1]).first) ) {
      fMM_HV_next_idx = i;
      fMM_HV_next_isok = true;
      break;
    }
  }
      
  // Find index for current and next time for DCC_V
  for (int itpc=0; itpc<3; itpc++){
    fDCC_V_isok[itpc] = false;
    fDCC_V_next_isok[itpc] = false;
    for (unsigned int i=0; i<(fDCC_V_vec[itpc]).size()-1; i++){
      if ( fTime >= long( ( (fDCC_V_vec[itpc])[i].first) ) &&
	   fTime <  long( ( (fDCC_V_vec[itpc][i+1].first) ) ) ) {
	fDCC_V_idx[itpc] = i;
	fDCC_V_isok[itpc] = true;
      }
      if ( fTime+adeltat >= long( ( (fDCC_V_vec[itpc])[i].first) ) &&
	   fTime+adeltat <  long( ( (fDCC_V_vec[itpc][i+1].first) ) ) ) {
	fDCC_V_next_idx[itpc] = i;
	fDCC_V_next_isok[itpc] = true;
	break;
      }
    }
  }
  
  // Find index for current and next time for Cath_V
  fCath_V_isok = false;
  fCath_V_next_isok = false;
  for (unsigned int i=0; i<fCath_V_vec.size()-1; i++){
    if ( fTime >= long( (fCath_V_vec[i]).first) &&
	 fTime <  long( (fCath_V_vec[i+1]).first) ) {
      fCath_V_idx = i;
      fCath_V_isok = true;
    }
    if ( fTime+adeltat >= long( (fCath_V_vec[i]).first) &&
	 fTime+adeltat <  long( (fCath_V_vec[i+1]).first) ) {
      fCath_V_next_idx = i;
      fCath_V_next_isok = true;
      break;
    }
  }
  return;
}

///------------------------------------------------------------------------
/// Check if we need to read another chunk of slow control
/// information from the database
void ITPCMMStatus::CheckReadDB(int adeltat){

  // buffer of number of readings to end of vector
  // needed to allow check of next 
  unsigned int NtoEndBuf = 2;  

  if ( fLV0_vec.size() <= NtoEndBuf ||
       fTime+adeltat > fLV0_vec[ fLV0_vec.size()-NtoEndBuf ].first ){
    //std::cout<<"<ITPCMMStatus::CheckReadDB> About to ReadSlowDB_LV0"<<std::endl;
    ReadSlowDB_LV0(adeltat);
  }

  if ( fLV1_vec.size() <= NtoEndBuf ||
       fTime+adeltat > fLV1_vec[ fLV1_vec.size()-NtoEndBuf ].first ){
    // std::cout<<"<ITPCMMStatus::CheckReadDB> About to ReadSlowDB_LV1"<<std::endl;
    ReadSlowDB_LV1(adeltat);
  }


  for (int ifem=0; ifem<6; ifem++ ){
    if ( fFEMCheck[ifem] == false ) continue;
    if ( fFEM_V_vec[ifem].size() <= NtoEndBuf ||
	 fTime+adeltat > fFEM_V_vec[ifem][ fFEM_V_vec[ifem].size()-NtoEndBuf ].first )
      //std::cout<<"<ITPCMMStatus::CheckReadDB> About to ReadSlowDB_FEM_V"<<std::endl;
      ReadSlowDB_FEM_V(adeltat);
    break;
  }

  if ( fMM_HV_vec.size() <= NtoEndBuf ||
       fTime+adeltat > fMM_HV_vec[ fMM_HV_vec.size()-NtoEndBuf ].first ){
    //std::cout<<"<ITPCMMStatus::CheckReadDB> About to ReadSlowDB_MM_HV"<<std::endl;
    ReadSlowDB_MM_HV(adeltat);
  }

  if ( fDCC_V_vec[0].size() <= NtoEndBuf ||
       fTime+adeltat > fDCC_V_vec[0][ fDCC_V_vec[0].size()-NtoEndBuf ].first ||
       fDCC_V_vec[1].size() <= NtoEndBuf ||
       fTime+adeltat > fDCC_V_vec[1][ fDCC_V_vec[1].size()-NtoEndBuf ].first ||
       fDCC_V_vec[NtoEndBuf].size() <= NtoEndBuf ||
       fTime+adeltat > fDCC_V_vec[2][ fDCC_V_vec[2].size()-NtoEndBuf ].first ){
    //std::cout<<"<ITPCMMStatus::CheckReadDB> About to ReadSlowDB_DCC_V"<<std::endl;
    ReadSlowDB_DCC_V(adeltat);
  }

  if ( fCath_V_vec.size() <= NtoEndBuf ||
       fTime+adeltat > fCath_V_vec[ fCath_V_vec.size()-NtoEndBuf ].first ){
    //std::cout<<"<ITPCMMStatus::CheckReadDB> About to ReadSlowDB_Cath_V"<<std::endl;
    ReadSlowDB_Cath_V(adeltat);
  }

  return;
}

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

  // update gas properties
  //fGas->SetTime( fTime );

  // Read system properties
  // if they are not available, set to -1 for no reading
  for (int itpc=0; itpc<3; itpc++){
    fCath_V[itpc] = -1.0;
    fCath_V_next[itpc] = -1.0;
    for (int irp=0; irp<2; irp++){
      for (int imm=0; imm<12; imm++){
	fLV_I[itpc][irp][imm] = -1.0;
	fFEM_V[itpc][irp][imm] = -1.0;
	fMM_HV[itpc][irp][imm] = -1.0;
	fDCC_V[itpc][irp][imm] = -1.0;
	fLV_I_next[itpc][irp][imm] = -1.0;
	fFEM_V_next[itpc][irp][imm] = -1.0;
	fMM_HV_next[itpc][irp][imm] = -1.0;
	fDCC_V_next[itpc][irp][imm] = -1.0;
      }
    }
  }

  // Check if we need to read another chunk of 
  // slow control information from database
  CheckReadDB( adeltat );

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

  // Hard coded mapping of LV cable to channel from Denis Calvet:
  //
  // TPC N°3 Readout plane 0 (End_Plate_4) : LV Crate #0 U0 and U1
  // TPC N°2 Readout plane 0 (End_Plate_2) : LV Crate #0 U4 and U5
  // TPC N°2 Readout plane 1 (End_Plate_3) : LV Crate #0 U6 and U7
  //
  // TPC N°3 Readout plane 1 (End_Plate_5) : LV Crate #1 U2 and U3
  // TPC N°1 Readout plane 0 (End_Plate_0) : LV Crate #1 U4 and U5
  // TPC N°1 Readout plane 1 (End_Plate_1) : LV Crate #1 U6 and U7


  // TPC3 RP0
  if ( fLV0_isok == true && fLV0_next_isok == true ){
    fLV_I[2][0][0] = fLV0_vec[ fLV0_idx ].second[0]; 
    fLV_I_next[2][0][0] = fLV0_vec[ fLV0_next_idx ].second[0]; 
    for (int imm=1; imm<6; imm++){
      fLV_I[2][0][imm] = fLV_I[2][0][0];
      fLV_I_next[2][0][imm] = fLV_I_next[2][0][0];
    }
    fLV_I[2][0][6] = fLV0_vec[ fLV0_idx ].second[1]; 
    fLV_I_next[2][0][6] = fLV0_vec[ fLV0_next_idx ].second[1]; 
    for (int imm=7; imm<12; imm++){
      fLV_I[2][0][imm] = fLV_I[2][0][6];
      fLV_I_next[2][0][imm] = fLV_I_next[2][0][6];
    }
    // TPC2 RP0
    fLV_I[1][0][0] = fLV0_vec[ fLV0_idx ].second[2];
    fLV_I_next[1][0][0] = fLV0_vec[ fLV0_next_idx ].second[2];
    for (int imm=1; imm<6; imm++){
      fLV_I[1][0][imm] = fLV_I[1][0][0];
      fLV_I_next[1][0][imm] = fLV_I_next[1][0][0];
    }
    fLV_I[1][0][6] = fLV0_vec[ fLV0_idx ].second[3];
    fLV_I_next[1][0][6] = fLV0_vec[ fLV0_next_idx ].second[3];
    for (int imm=7; imm<12; imm++){
      fLV_I[1][0][imm] = fLV_I[1][0][6];
      fLV_I_next[1][0][imm] = fLV_I_next[1][0][6];
    }
    // TPC2 RP1
    fLV_I[1][1][0] = fLV0_vec[ fLV0_idx ].second[4];
    fLV_I_next[1][1][0] = fLV0_vec[ fLV0_next_idx ].second[4];
    for (int imm=1; imm<6; imm++){
      fLV_I[1][1][imm] = fLV_I[1][1][0];
      fLV_I_next[1][1][imm] = fLV_I_next[1][1][0];
    }
    fLV_I[1][1][6] = fLV0_vec[ fLV0_idx ].second[5];
    fLV_I_next[1][1][6] = fLV0_vec[ fLV0_next_idx ].second[5];
    for (int imm=7; imm<12; imm++){
      fLV_I[1][1][imm] = fLV_I[1][1][6];
      fLV_I_next[1][1][imm] = fLV_I_next[1][1][6];
    }

  }
  
  if ( fLV1_isok == true && fLV1_next_isok == true ){
    // TPC3 RP1
    fLV_I[2][1][0] = fLV1_vec[ fLV1_idx ].second[0];
    fLV_I_next[2][1][0] = fLV1_vec[ fLV1_next_idx ].second[0];
    for (int imm=1; imm<6; imm++){
      fLV_I[2][1][imm] = fLV_I[2][1][0];
      fLV_I_next[2][1][imm] = fLV_I_next[2][1][0];
    }
    fLV_I[2][1][6] = fLV1_vec[ fLV1_idx ].second[1];
    fLV_I_next[2][1][6] = fLV1_vec[ fLV1_next_idx ].second[1];
    for (int imm=7; imm<12; imm++){
      fLV_I[2][1][imm] = fLV_I[2][1][6];
      fLV_I_next[2][1][imm] = fLV_I_next[2][1][6];
    }
    // TPC1 RP0
    fLV_I[0][0][0] = fLV1_vec[ fLV1_idx ].second[2];
    fLV_I_next[0][0][0] = fLV1_vec[ fLV1_next_idx ].second[2];
    for (int imm=1; imm<6; imm++){
      fLV_I[0][0][imm] = fLV_I[0][0][0];
      fLV_I_next[0][0][imm] = fLV_I_next[0][0][0];
    }
    fLV_I[0][0][6] = fLV1_vec[ fLV1_idx ].second[3];
    fLV_I_next[0][0][6] = fLV1_vec[ fLV1_next_idx ].second[3];
    for (int imm=7; imm<12; imm++){
      fLV_I[0][0][imm] = fLV_I[0][0][6];
      fLV_I_next[0][0][imm] = fLV_I_next[0][0][6];
    }
    // TPC1 RP1
    fLV_I[0][1][0] = fLV1_vec[ fLV1_idx ].second[4];
    fLV_I_next[0][1][0] = fLV1_vec[ fLV1_next_idx ].second[4];
    for (int imm=1; imm<6; imm++){
    fLV_I[0][1][imm] = fLV_I[0][1][0];
    fLV_I_next[0][1][imm] = fLV_I_next[0][1][0];
    }
    fLV_I[0][1][6] = fLV1_vec[ fLV1_idx ].second[5];
    fLV_I_next[0][1][6] = fLV1_vec[ fLV1_next_idx ].second[5];
    for (int imm=7; imm<12; imm++){
      fLV_I[0][1][imm] = fLV_I[0][1][6];
      fLV_I_next[0][1][imm] = fLV_I_next[0][1][6];
    }
  }    

  // Next read FEM Power
  for (int iep=0; iep<6; iep++){
    if ( fFEMCheck[iep] == false ) continue;
    if ( fFEM_V_isok[iep] == true &&  fFEM_V_next_isok[iep] == true ){
      int irp = iep%2;
      int itpc = iep/2;
      for (int imm=0; imm<12; imm++){
	fFEM_V[itpc][irp][imm] = fFEM_V_vec[iep][ fFEM_V_idx[iep] ].second[ imm ]; //(float)ISlowControlDatabase::Get().QueryShowField(fTime,atabname,avarname);
	fFEM_V_next[itpc][irp][imm] = fFEM_V_vec[iep][ fFEM_V_next_idx[iep] ].second[ imm ]; //(float)ISlowControlDatabase::Get().QueryShowField(fTime,atabname,avarname);
      }
    }
  }

  // Next read MM HV settings
  if ( fMM_HV_isok == true && fMM_HV_next_isok == true ){
    int afieldidx = 0;
    for (int itpc=0; itpc<3; itpc++){
      for (int irp=0; irp<2; irp++){
	for (int imm=0; imm<12; imm++){
	  fMM_HV[itpc][irp][imm] = fMM_HV_vec[ fMM_HV_idx ].second[ afieldidx ]; //(float)ISlowControlDatabase::Get().QueryShowField(fTime,"tpciseghv02_sensevoltage",avarname);
	  fMM_HV_next[itpc][irp][imm] = fMM_HV_vec[ fMM_HV_next_idx ].second[ afieldidx ]; //(float)ISlowControlDatabase::Get().QueryShowField(fTime,"tpciseghv02_sensevoltage",avarname);
	  if ( itpc==2 && irp == 0 && imm == 1 && fTime >= fTimeSwap1 && fTime < fTimeSwap2 ){
	    // use alternate channel
	    fMM_HV[itpc][irp][imm] = fMM_HV_vec[ fMM_HV_idx ].second[ fMM_HV_names.size()-1 ];
	    fMM_HV_next[itpc][irp][imm] = fMM_HV_vec[ fMM_HV_next_idx ].second[ fMM_HV_names.size()-1 ];
	  }
	  afieldidx ++;
	}
      }
    }
  }

  // Next read DCC power settings
  // there are 18 DCCs each raeding 4 MMs
  for (int idcc=0; idcc<18; idcc++){
    int itpc;
    if (idcc<6) itpc = 1;
    else if (idcc<12) itpc=2;
    else itpc=0;
    int irp = (idcc%6)/3;
    int immoffs = ((idcc%6)%3)*2;
    int ioutvolt = (idcc%6) +1; 

    if ( fDCC_V_isok[itpc] == true &&  fDCC_V_next_isok[itpc] == true ){
      fDCC_V[itpc][irp][immoffs]   = fDCC_V_vec[itpc][ fDCC_V_idx[itpc] ].second[ ioutvolt-1 ];  //(float)ISlowControlDatabase::Get().QueryShowField(fTime,atabname,avarname);
      fDCC_V[itpc][irp][immoffs+1] = fDCC_V[itpc][irp][immoffs];
      fDCC_V[itpc][irp][immoffs+6] = fDCC_V[itpc][irp][immoffs];
      fDCC_V[itpc][irp][immoffs+7] = fDCC_V[itpc][irp][immoffs];
      //
      fDCC_V_next[itpc][irp][immoffs]   = fDCC_V_vec[itpc][ fDCC_V_next_idx[itpc] ].second[ ioutvolt-1 ];  //(float)ISlowControlDatabase::Get().QueryShowField(fTime,atabname,avarname);
      fDCC_V_next[itpc][irp][immoffs+1] = fDCC_V_next[itpc][irp][immoffs];
      fDCC_V_next[itpc][irp][immoffs+6] = fDCC_V_next[itpc][irp][immoffs];
      fDCC_V_next[itpc][irp][immoffs+7] = fDCC_V_next[itpc][irp][immoffs];
    }
  }

  // Finally get cathode HV
  if ( fCath_V_isok == true &&  fCath_V_next_isok == true ){
    for (int itpc=0; itpc<3; itpc++){
      fCath_V[itpc] = fCath_V_vec[ fCath_V_idx ].second[itpc]; //(float)ISlowControlDatabase::Get().QueryShowField(fTime,"ccbertan_cchv","tpc1_ccu_v__cchv");
      fCath_V_next[itpc] = fCath_V_vec[ fCath_V_next_idx ].second[itpc]; //(float)ISlowControlDatabase::Get().QueryShowField(fTime,"ccbertan_cchv","tpc1_ccu_v__cchv");
    }
  }

  // update status values
  UpdateStatus();

  
  if (fDebug){ 
    // Time check:
    long db_time = (long)ISlowControlDatabase::Get().QueryShowField(fTime,"tpc_lv_ps_tlv0","_i_time");
    std::cout << "<ITPCMMStatus::Read>"<<std::endl;
    std::cout << "   Requested Time: " << fTime << ", Database entry time: "<< db_time <<std::endl;
    Print();
    fTime = db_time;
  }
}


///------------------------------------------------------------------------
/// Read the next TPC system properties reading after current time setting and
/// update all readings.  Return 1 if all is okay otherwize return 
/// negative value.
int ITPCMMStatus::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( adeltat );

  return 1;
}


///------------------------------------------------------------------------
/// Update status variables based on the latest readings
void ITPCMMStatus::UpdateStatus(){
  // hard coded values for now
  fStatus = 0;
  // check if bad db read?
  if ( fLV0_isok      == false || fLV0_next_isok      == false ||	  
       fLV1_isok      == false || fLV1_next_isok      == false ||	  
       fMM_HV_isok    == false || fMM_HV_next_isok    == false ||	  
       fDCC_V_isok[0] == false || fDCC_V_next_isok[0] == false || 
       fDCC_V_isok[1] == false || fDCC_V_next_isok[1] == false || 
       fDCC_V_isok[2] == false || fDCC_V_next_isok[2] == false || 
       fCath_V_isok   == false || fCath_V_next_isok   == false      ) {
    //fStatus=32;
     fStatus=0;
     for (int itpc=0; itpc<3; itpc++){
       fTPCStatus[itpc] = 0;
       for (int irp=0; irp<2; irp++){
         for (int imm=0; imm<12; imm++){
           //      fMMStatus[itpc][irp][imm] = 32;                                                                                                                                        
           fMMStatus[itpc][irp][imm] = 0;
           fMMStatus[itpc][irp][imm] += (1<<((itpc+1)*8+5)); // 6th status flag                                                                                                              
         }
       }
       fTPCStatus[itpc] += (1<<((itpc+1)*8+5)); // 6th status flag                                                                                                                           
       fStatus += fTPCStatus[itpc];
     }


    if ( fLV0_isok      == false ) {
      std::cout<<"fLV0_isok==false, vecsize="<<fLV0_vec.size()
	       <<" frst time="<<long(fLV0_vec[ 0 ].first )
	       <<" last time="<<long(fLV0_vec[ fLV0_vec.size()-1 ].first )
	       <<" time requested="<<fTime<<std::endl;
    }

                               	  
    if(   fLV1_isok      == false 	  ) {
      std::cout<<"fLV1_isok==false, vecsize="<<fLV1_vec.size()
	       <<" frst time="<<long(fLV1_vec[ 0 ].first )
	       <<" last time="<<long(fLV1_vec[ fLV1_vec.size()-1 ].first )
	       <<" time requested="<<fTime<<std::endl;
    }
    if ( fLV0_next_isok      == false ) {
      std::cout<<"fLV0_next_isok==false, vecsize="<<fLV0_vec.size()
	       <<" frst time="<<long(fLV0_vec[ 0 ].first )
	       <<" last time="<<long(fLV0_vec[ fLV0_vec.size()-1 ].first )
	       <<" time requested="<<fTime
	       <<" fLV0_idx="<<fLV0_idx
	       <<std::endl;
    }
    if(   fLV1_next_isok      == false 	  ) {
      std::cout<<"fLV1_next_isok==false, vecsize="<<fLV1_vec.size()
	       <<" frst time="<<long(fLV1_vec[ 0 ].first )
	       <<" last time="<<long(fLV1_vec[ fLV1_vec.size()-1 ].first )
	       <<" time requested="<<fTime
	       <<" fLV1_idx="<<fLV1_idx
	       <<std::endl;
    }

    if ( fMM_HV_isok    == false 	  ){
      std::cout<<"fMM_HV_isok==false, vecsize="<<fMM_HV_vec.size()
	       <<" frst time="<<long(fMM_HV_vec[ 0 ].first )
	       <<" last time="<<long(fMM_HV_vec[ fMM_HV_vec.size()-1 ].first )
	       <<" time requested="<<fTime<<std::endl;
    }
    if ( fMM_HV_next_isok    == false 	  ){
      std::cout<<"fMM_HV_next_isok==false, vecsize="<<fMM_HV_vec.size()
	       <<" frst time="<<long(fMM_HV_vec[ 0 ].first )
	       <<" last time="<<long(fMM_HV_vec[ fMM_HV_vec.size()-1 ].first )
	       <<" time requested="<<fTime
	       <<" fMM_HV_idx="<<fMM_HV_idx
	       <<std::endl;
    }
    for (int itpc=0; itpc<3; itpc++){
      if ( fDCC_V_isok[itpc] == false ){
	std::cout<<"fDCC_V_isok["<<itpc<<"]==false, vecsize="<<fDCC_V_vec[itpc].size()
		 <<" frst time="<<long(fDCC_V_vec[ itpc ][0].first )
		 <<" last time="<<long(fDCC_V_vec[ itpc ][ fDCC_V_vec[itpc].size()-1 ].first )
		 <<" time requested="<<fTime<<std::endl;
      } 
      if(   fDCC_V_next_isok[itpc] == false ) {
	std::cout<<"fDCC_V_next_isok["<<itpc<<"]==false, vecsize="<<fDCC_V_vec[itpc].size()
		 <<" frst time="<<long(fDCC_V_vec[ itpc ][0].first )
		 <<" last time="<<long(fDCC_V_vec[ itpc ][ fDCC_V_vec[itpc].size()-1 ].first )
		 <<" time requested="<<fTime
		 <<" fDCC_V_idx="<<fDCC_V_idx[itpc]<<std::endl;
      }
    }

    if ( fCath_V_isok   == false  ) {
      std::cout<<"fCath_V_isok==false, vecsize="<<fCath_V_vec.size()
	       <<" frst time="<<long(fCath_V_vec[ 0 ].first )
	       <<" last time="<<long(fCath_V_vec[ fCath_V_vec.size()-1 ].first )
	       <<" time requested="<<fTime<<std::endl;
    }


    if ( fCath_V_next_isok   == false  ) {
      std::cout<<"fCath_V_next_isok==false, vecsize="<<fCath_V_vec.size()
	       <<" frst time="<<long(fCath_V_vec[ 0 ].first )
	       <<" last time="<<long(fCath_V_vec[ fCath_V_vec.size()-1 ].first )
	       <<" time requested="<<fTime
	       <<" fCath_V_idx="<<fCath_V_idx
	       <<std::endl;
    }

    // for (int itpc=0; itpc<3; itpc++){
    //fTPCStatus[itpc] = 32;
      //fTPCStatus[itpc] = 0;
      //for (int irp=0; irp<2; irp++){
    //for (int imm=0; imm<12; imm++){
    //  fMMStatus[itpc][irp][imm] = 32;
	  //fMMStatus[itpc][irp][imm] = 0;
    //}
    //}
    //}

    return;
  }



  for (int iep=0; iep<6; iep++){
    bool gotbadread=false;
    if ( fFEMCheck[iep] == false ) continue;
    if(   fFEM_V_isok[iep] == false ) {
      gotbadread=true;
      std::cout<<"fFEM_V_isok["<<iep<<"]==false, vecsize="<<fFEM_V_vec[iep].size();
      if ( fFEM_V_vec[iep].size()>0 ){
	std::cout<<" frst time="<<long(fFEM_V_vec[ iep ][0].first )
		 <<" last time="<<long(fFEM_V_vec[ iep ][ fFEM_V_vec[iep].size()-1 ].first );
      }
      std::cout <<" time requested="<<fTime<<std::endl;
    }
    if(   fFEM_V_next_isok[iep] == false ) {
      gotbadread=true;
      std::cout<<"fFEM_V_next_isok["<<iep<<"]==false, vecsize="<<fFEM_V_vec[iep].size();
      if ( fFEM_V_vec[iep].size()>0 ){
	std::cout<<" frst time="<<long(fFEM_V_vec[ iep ][0].first )
		 <<" last time="<<long(fFEM_V_vec[ iep ][ fFEM_V_vec[iep].size()-1 ].first );
      }
      std::cout<<" time requested="<<fTime
	       <<" fFEM_V_idx="<<fFEM_V_idx[iep]<<std::endl;
    }
    //if ( gotbadread==true ) return;
    // }

  //add bad db info flag also for FEM voltages
    if(gotbadread==true){
      fStatus=0;
      for (int itpc=0; itpc<3; itpc++){
	fTPCStatus[itpc] = 0;
	for (int irp=0; irp<2; irp++){
	  for (int imm=0; imm<12; imm++){
	    //      fMMStatus[itpc][irp][imm] = 32;                                                                                                                                                
	    fMMStatus[itpc][irp][imm] = 0;
	    fMMStatus[itpc][irp][imm] += (1<<((itpc+1)*8+5)); // 6th status flag                                                                                                               
	  }
	}
	fTPCStatus[itpc] += (1<<((itpc+1)*8+5)); // 6th status flag                                                                                                                                
	fStatus += fTPCStatus[itpc];
      }
      return;
    }
  }
  
  // if all db reads okay, then add to status
  // for each failed condition.  Note that we
  // check the next reading as well as the current
  // reading.  Since this reading will be considered
  // bad if the next one is bad.

  //added bool variables to store if there is any failed condition                                                                             
  //in any of the TPCs RPs MMs. They will be used at the end to                                                                                 
  //compute the global flag (compatible with old schema)                                                                                       


  for (int itpc=0; itpc<3; itpc++){
    fTPCStatus[itpc] = 0;

    bool LV = false;
    bool FEM = false;
    bool MM = false;
    bool DCC = false;
    bool CC = false;
  
    for (int irp=0; irp<2; irp++){
      for (int imm=0; imm<12; imm++){
	fMMStatus[itpc][irp][imm] = 0;

	//first flag
	if ( fLV_I[itpc][irp][imm] < 25.0 ||
	     fLV_I_next[itpc][irp][imm] < 25.0 ){
	  //	  fMMStatus[itpc][irp][imm] += 1;
	  fMMStatus[itpc][irp][imm] += (1<<((itpc+1)*8)); // 1st status flag                                                                                                                       
          LV = true;
	}
	// calculate which FEM power supply this would be?
	int ifem = 2*itpc + irp;
	if ( fFEMCheck[ifem] == true ){
	  //second flag
	  if ( fFEM_V[itpc][irp][imm] < 3100.0 ||
	       fFEM_V_next[itpc][irp][imm] < 3100.0 ){
	    //	    fMMStatus[itpc][irp][imm] += 2;
	    fMMStatus[itpc][irp][imm] += (1<<((itpc+1)*8+1)); //  2nd status flag                                                                                                                 
            FEM = true;
	  }
	}
	//third flag
	if ( fMM_HV[itpc][irp][imm] < fMM_HVminV[itpc][irp][imm] ||
	     fMM_HV[itpc][irp][imm] > 355.0 ||
	     fMM_HV_next[itpc][irp][imm] < fMM_HVminV[itpc][irp][imm] ||
	     fMM_HV_next[itpc][irp][imm] > 355.0 ){
	  //	  fMMStatus[itpc][irp][imm] += 4;
	  fMMStatus[itpc][irp][imm] += (1<<((itpc+1)*8+2)); //  3rd status flag                                                                                                                   
          MM = true;
	}
	//fourth flag
	if ( fDCC_V_Check[itpc][irp][imm] == true ){
	  if ( fDCC_V[itpc][irp][imm] < 2.5 ||
	       fDCC_V_next[itpc][irp][imm] < 2.5 ){
	    //fMMStatus[itpc][irp][imm] += 8;
	    fMMStatus[itpc][irp][imm] += (1<<((itpc+1)*8+3)); //  4th status flag

            DCC = true;
	  }
	}
	//fifth flag
	if ( fCath_V[itpc] > 25050.0 ||
	     fCath_V[itpc] < 24950.0 ||
	     fCath_V_next[itpc] > 25050.0 ||
	     fCath_V_next[itpc] < 24950.0 ){
	  //	  fMMStatus[itpc][irp][imm] += 16;
	  fMMStatus[itpc][irp][imm] += (1<<((itpc+1)*8+4)); //  5th status flag                                                                                                                         
          CC = true;
	}

	//	if (fMMStatus[itpc][irp][imm] > fTPCStatus[itpc] ){
	//fTPCStatus[itpc] = fMMStatus[itpc][irp][imm];
	//if ( fTPCStatus[itpc] > fStatus ) fStatus = fTPCStatus[itpc];
	// }
      }
    }

    //compute the total TPC flag using the bool variables to avoid                                                                                                                                      
    //adding the same flag twice with fMMStatus                                                                                                                                                   
    if (LV) fTPCStatus[itpc] +=(1<<((itpc+1)*8));
    if (FEM) fTPCStatus[itpc] +=(1<<((itpc+1)*8+1));
    if (MM) fTPCStatus[itpc] +=(1<<((itpc+1)*8+2));
    if (DCC) fTPCStatus[itpc] +=(1<<((itpc+1)*8+3));
    if (CC) fTPCStatus[itpc] +=(1<<((itpc+1)*8+4));

    fStatus += fTPCStatus[itpc];

  }
  return;
}