/// Class to hold ECAL TFB 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 <sys/time.h>
#include <iostream>
#include <string>
#include <math.h>
#include "IECALTFBStatus.hxx"
#include "ISlowControlDatabase.hxx"

#define nrmm 12

///------------------------------------------------------------------------
/// Initialize ECAL TFB 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
IECALTFBStatus::IECALTFBStatus( long autime, long atstart, long atend ){
  fTime = autime;      // time of current values
  fDebug = false;
  fTimeStamp = 0x0;
  fStartTime = atstart; 
  fEndTime = atend;

  //  nrmm = 2;

  ntfb[0]  = 28;
  ntfb[1]  = 28;
  ntfb[2]  = 15;  
  ntfb[3]  = 44;  
  ntfb[4]  = 44;  
  ntfb[5]  = 26;  
  ntfb[6]  = 26;  
  ntfb[7]  = 15;  
  ntfb[8]  = 26;  
  ntfb[9]  = 26;  
  ntfb[10] = 44;  
  ntfb[11] = 44;  

  Init();

}


///------------------------------------------------------------------------
/// Initialize TPC MM status object using year, month(0-11),
/// day(1-31),...
IECALTFBStatus::IECALTFBStatus(
					   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;

  //  nrmm = 2;

  ntfb[0]  = 28;
  ntfb[1]  = 28;
  ntfb[2]  = 15;  
  ntfb[3]  = 44;  
  ntfb[4]  = 44;  
  ntfb[5]  = 26;  
  ntfb[6]  = 26;  
  ntfb[7]  = 15;  
  ntfb[8]  = 26;  
  ntfb[9]  = 26;  
  ntfb[10] = 44;  
  ntfb[11] = 44;  

  Init();
}



///------------------------------------------------------------------------
/// Initialize TFB status properties object
/// Sets offsets, makes histogram, reads values
void IECALTFBStatus::Init(){
  // Setup field name strings to read

  SetupFieldNames();

  // Now read system properties
  int count = 0;
  for (int irmm=0; irmm<nrmm; irmm++){
    for(int itfb = 0; itfb<ntfb[irmm]; itfb++){
      fTempexternal_vec[count].clear();
      fTFB_vsupplyv2v5_vec[count].clear();
      fTFB_vbias_vec[count].clear();
      count++;
    }
  }

  Read();

}

///------------------------------------------------------------------------
/// sets up the field names that are read from the slow control database ONLY FOR DSECAL
void IECALTFBStatus::SetupFieldNames(){
  char atabname[256];
  char avarname[256];
  int count = 0;
  for (int irmm=0; irmm<nrmm; irmm++){
    for(int itfb = 0; itfb<ntfb[irmm]; itfb++){
      //      count = (irmm*28)+itfb;

      if(irmm==0||irmm==1){
	sprintf(atabname,"scfe09_em%1d0_0%02d",irmm,itfb);
      } else if(irmm==2||irmm==7){
	sprintf(atabname,"scfe10_em%1d0_0%02d",irmm,itfb);
      } else if(irmm==3||irmm==4) {
	sprintf(atabname,"scfe11_em%1d0_0%02d",irmm,itfb);
      } else if(irmm==5||irmm==6) {
	sprintf(atabname,"scfe12_em%1d0_0%02d",irmm,itfb);
      } else if(irmm==8||irmm==9) {
	sprintf(atabname,"scfe13_em%1d0_0%02d",irmm,itfb);
      } else if(irmm==10) {
	sprintf(atabname,"scfe14_ema0_0%02d",itfb);
      } else if(irmm==11) {
	sprintf(atabname,"scfe14_emb0_0%02d",itfb);
      } else {
	std::cout << "Unrecognized RMM number!" << std::endl;
      }

      fTFB_V_tabnames[count] = std::string(atabname);

      if(irmm>=0&&irmm<=9){
	sprintf(avarname,"em%1d0_0%02d_tempexternal0",irmm,itfb);
      } else if(irmm==10){
	sprintf(avarname,"ema0_0%02d_tempexternal0",itfb);
      } else if(irmm==11){
	sprintf(avarname,"emb0_0%02d_tempexternal0",itfb);
      } else {
	std::cout << "Unrecognized RMM number!" << std::endl;
      }

      fTempexternal_names[count].push_back(avarname);

      if(irmm>=0&&irmm<=9){
	sprintf(avarname,"em%1d0_0%02d_vsupply2v5",irmm,itfb);
      } else if(irmm==10){
	sprintf(avarname,"ema0_0%02d_vsupply2v5",itfb);
      } else if(irmm==11){
	sprintf(avarname,"emb0_0%02d_vsupply2v5",itfb);
      } else {
	std::cout << "Unrecognized RMM number!" << std::endl;
      }

      fTFB_vsupplyv2v5_names[count].push_back(avarname);
      fTempexternal_names[count].push_back(avarname); // now fTempexternal_names contains the name of vsupply2v5 row as well

      if(irmm>=0&&irmm<=9){
	sprintf(avarname,"em%1d0_0%02d_vbias",irmm,itfb);
      } else if(irmm==10){
	sprintf(avarname,"ema0_0%02d_vbias",itfb);
      } else if(irmm==11){
	sprintf(avarname,"emb0_0%02d_vbias",itfb);
      } else {
	std::cout << "Unrecognized RMM number!" << std::endl;
      }

      fTFB_vbias_names[count].push_back(avarname);
      fTempexternal_names[count].push_back(avarname); // now fTempexternal_names contains the name of vbias row as well

      //fTempexternal_names[count] = std::string(avarname);
      //      std::cout << "Var name: " << avarname << std::endl;      
      
      count++;
    }
  }
  
  
/*
  for (int irmm=0; irmm<nrmm; irmm++){
    std::cout<<"ECAL RMM"<<irmm<<" Status is "<<fECALStatus[irmm]<<std::endl;
  }
  std::cout<<"Overal ECAL Status is "<<fStatus<<std::endl;
*/
  return;
}


///------------------------------------------------------------------------
/// Print all of the table readings for current time
void IECALTFBStatus::Print(){
  
  //  std::cout<<"<IECALTFBStatus::Print> Record for "<<fTimeStamp<<" ctime="<<fTime<<std::endl;
  //  std::cout<<"ECAL RMM TFB  LVI(A)    FEMV(V)    MMHV(V)    DCCV(V)    VCath(V)    Status"<<std::endl;
  //  std::cout<<"ECAL RMM TFB  ExtTemp   Status"<<std::endl;

  for (int irmm=0; irmm<nrmm; irmm++){
    for (int itfb=0; itfb<ntfb[irmm]; itfb++){
        std::cout<< std::setiosflags(std::ios::fixed)
                 <<std::setw(3)
                 <<irmm<<"  "
                 <<itfb<<"  "
	  //                 <<imm<<"  "
                 <<std::setprecision(1)
                 <<std::setw(8)
	  //                 <<fCath_V[itpc]<<"  "
                 <<fTFBStatus[irmm][itfb]
                 <<std::endl;
    }
  }
  
  std::cout<<"Overall ECAL Status is "<<fStatus<<std::endl;
  return;
}



///------------------------------------------------------------------------
/// Get the time interval for this record
void IECALTFBStatus::GetTimeInterval(long &start_time, long &end_time){
  start_time = fStart;
  end_time = fEnd;
  //wrong way to fix it, but for the moment use rmm=0 tfb=0 status
  if ( fTempexternal_vec[0].size() > fTempexternal_idx[0]+2 ){
    start_time = (long) fTempexternal_vec[0][ fTempexternal_idx[0] ].first;
    end_time = (long) fTempexternal_vec[0][ fTempexternal_idx[0]+1 ].first;
  }

  return;
}


///------------------------------------------------------------------------
/// Get unix time
long IECALTFBStatus::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 IECALTFBStatus::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 IECALTFBStatus::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 IECALTFBStatus::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: tempexternal read section
void IECALTFBStatus::ReadSlowTempexternal(int adeltat){
  /// read next nread entries
  long astart = fTime - 300;  
  int  nread = 500;
  if (fTempexternal_vec[0].size()>2){
    int adt = int(fTempexternal_vec[0][1].first - fTempexternal_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;
  }

  time_t rawtime;
  struct tm * timeinfo;

  //  std::cout << "Database query time: " << astart << std::endl;

  int count = 0;
  for(int irmm = 0;irmm<nrmm;irmm++){
    for(int itfb = 0;itfb<ntfb[irmm];itfb++){

      ISlowControlDatabase::Get().GetTable(astart,fTFB_V_tabnames[count].c_str());
      fTempexternal_vec[count] = ISlowControlDatabase::Get().QueryGetFieldNoCache(astart, fTFB_V_tabnames[count].c_str(), fTempexternal_names[count], nread); 
      //this vector is now longer: contains info about 2.5V and bias voltages
      time ( &rawtime );
      timeinfo = localtime ( &rawtime );

      //      printf ( "Read Tempexternal for rmm %d, tfb %d, total boards read: %d \n", irmm,itfb,count+1 );
      //      printf ( "Current local time and date: %s", asctime (timeinfo) );

      count++;
    }
  }

  return;
}

///------------------------------------------------------------------------
/// Get index into each of the vectors of database query
/// results for the current time
void IECALTFBStatus::UpdateVectorTimeIdx(int adeltat){
  // Find index for current and next time for Tempexternal
  int count=0;

  for(int irmm(0);irmm<nrmm;irmm++){
    for(int itfb(0);itfb<ntfb[irmm];itfb++){
      if((irmm==3&&itfb==0)||(irmm==4&&itfb==20)||(irmm==5&&itfb==0)||(irmm==5&&itfb==5)||(irmm==5&&itfb==22)||(irmm==6&&itfb==19)||(irmm==8&&itfb==19)||(irmm==9&&itfb==23)||(irmm==10&&itfb==10)||(irmm==10&&itfb==13)||(irmm==10&&itfb==15)||(irmm==10&&itfb==20)||(irmm==10&&itfb==22)||(irmm==10&&itfb==24)||(irmm==10&&itfb==27)||(irmm==10&&itfb==30)||(irmm==11&&itfb==14)||(irmm==11&&itfb==20)||(irmm==11&&itfb==28)){
	//broken temperature sensors - do nothing
      } else {
      //      count = (irmm*28)+itfb;
	fTempexternal_isok[count] = false;
	fTempexternal_next_isok[count] = false;
		
	for (unsigned int i=0; i<fTempexternal_vec[count].size()-1; i++){
	  if ( fTime >= long( (fTempexternal_vec[count][i].first) ) &&
	     fTime <  long( (fTempexternal_vec[count][i+1].first) ) ) {
	    fTempexternal_idx[count] = i;
	    fTempexternal_isok[count] = true;
	  }
	  if ( fTime+adeltat >= long( (fTempexternal_vec[count][i].first) ) &&
	     fTime+adeltat <  long( (fTempexternal_vec[count][i+1].first) ) ) {
	    fTempexternal_next_idx[count] = i;
	    fTempexternal_next_isok[count] = true;
	    break;
	  }
	}
      }
      count++;
    }
  } //end for irmm=0
  

  //now 2.5V line
  /*
  count = 0;
  for(int irmm(0);irmm<nrmm;irmm++){
    for(int itfb(0);itfb<ntfb[irmm];itfb++){
      if((irmm==5&&itfb==0)||(irmm==5&&itfb==5)||(irmm==9&&itfb==23)||(irmm==8&&itfb==19)||(irmm==9&&itfb==23)||(irmm==10&&itfb==10)||(irmm==10&&itfb==13)||(irmm==10&&itfb==15)||(irmm==10&&itfb==20)||(irmm==10&&itfb==22)||(irmm==10&&itfb==24)||(irmm==10&&itfb==27)||(irmm==10&&itfb==30)||(irmm==11&&itfb==14)||(irmm==11&&itfb==20)||(irmm==11&&itfb==28)) {  
	//broken sensors - do nothing
      } else {
	fTFB_vsupplyv2v5_isok[count] = false;
	fTFB_vsupplyv2v5_next_isok[count] = false;
		
	for (unsigned int i=0; i<fTFB_vsupplyv2v5_vec[count].size()-1; i++){
	  if ( fTime >= long( (fTFB_vsupplyv2v5_vec[count][i].first) ) &&
	     fTime <  long( (fTFB_vsupplyv2v5_vec[count][i+1].first) ) ) {
	    fTFB_vsupplyv2v5_idx[count] = i;
	    fTFB_vsupplyv2v5_isok[count] = true;
	  }
	  if ( fTime+adeltat >= long( (fTFB_vsupplyv2v5_vec[count][i].first) ) &&
	     fTime+adeltat <  long( (fTFB_vsupplyv2v5_vec[count][i+1].first) ) ) {
	    fTFB_vsupplyv2v5_next_idx[count] = i;
	    fTFB_vsupplyv2v5_next_isok[count] = true;
	    break;
	  }
	}
      }
      count++;
    }
  } //end for irmm=0
  */

  //now  bias voltage
  /*
  count = 0;
  for(int irmm(0);irmm<nrmm;irmm++){
    for(int itfb(0);itfb<ntfb[irmm];itfb++){
      if((irmm==5&&itfb==0)||(irmm==5&&itfb==5)||(irmm==9&&itfb==23)||(irmm==8&&itfb==19)||(irmm==9&&itfb==23)||(irmm==10&&itfb==10)||(irmm==10&&itfb==13)||(irmm==10&&itfb==15)||(irmm==10&&itfb==20)||(irmm==10&&itfb==22)||(irmm==10&&itfb==24)||(irmm==10&&itfb==27)||(irmm==10&&itfb==30)||(irmm==11&&itfb==14)||(irmm==11&&itfb==20)||(irmm==11&&itfb==28)) {  
	//broken sensors - do nothing
      } else {
	fTFB_vbias_isok[count] = false;
	fTFB_vbias_next_isok[count] = false;
		
	for (unsigned int i=0; i<fTFB_vbias_vec[count].size()-1; i++){
	  if ( fTime >= long( (fTFB_vbias_vec[count][i].first) ) &&
	     fTime <  long( (fTFB_vbias_vec[count][i+1].first) ) ) {
	    fTFB_vbias_idx[count] = i;
	    fTFB_vbias_isok[count] = true;
	  }
	  if ( fTime+adeltat >= long( (fTFB_vbias_vec[count][i].first) ) &&
	     fTime+adeltat <  long( (fTFB_vbias_vec[count][i+1].first) ) ) {
	    fTFB_vbias_next_idx[count] = i;
	    fTFB_vbias_next_isok[count] = true;
	    break;
	  }
	}
      }
      count++;
    }
  } //end for irmm=0
  */
  return;
}

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

  // buffer of number of readings to end of vector
  // needed to allow check of next 
  unsigned int NtoEndBuf = 2;  
  
  int passed[366]= {0};
  int proceed = 0;
  int count=0;
  for(int irmm = 0;irmm<nrmm;irmm++){
    for(int itfb = 0;itfb<ntfb[irmm];itfb++){
      if((irmm==3&&itfb==0)||(irmm==4&&itfb==20)||(irmm==5&&itfb==0)||(irmm==5&&itfb==5)||(irmm==5&&itfb==22)||(irmm==6&&itfb==19)||(irmm==8&&itfb==19)||(irmm==9&&itfb==23)||(irmm==10&&itfb==10)||(irmm==10&&itfb==13)||(irmm==10&&itfb==15)||(irmm==10&&itfb==20)||(irmm==10&&itfb==22)||(irmm==10&&itfb==24)||(irmm==10&&itfb==27)||(irmm==10&&itfb==30)||(irmm==11&&itfb==14)||(irmm==11&&itfb==20)||(irmm==11&&itfb==28)){
	//broken temperature sensors
      	passed[count] = 0;
      } else {
	if ( fTempexternal_vec[count].size() <= NtoEndBuf ||
	     fTime+adeltat > fTempexternal_vec[count][ fTempexternal_vec[count].size()-NtoEndBuf ].first ){
	  passed[count] = 1;
	  //	  std::cout << "TempExt Passed (" << count << ") = " << passed[count] << "  rmm = " << irmm << "  tfb = " << itfb <<std::endl;
	}
      }
      count++;
    }
  }
  
  for (int ii = 0; ii<366; ii++){
    if ( passed[ii] == 1 ) proceed = 1;
  }

  if (proceed==1) {
    std::cout<<"<IECALTFBStatus::CheckReadDB> About to ReadSlowTempexternal with granularity "<< adeltat <<std::endl;
    ReadSlowTempexternal(adeltat);
  }
  
  return;
}

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

  int count=0;
  // Read system properties
  // if they are not available, set to -1 for no reading
  for (int irmm=0; irmm<nrmm; irmm++){
    for (int itfb=0; itfb<ntfb[irmm]; itfb++){
      fTempexternal[irmm][itfb] = -1.0;
      fTFB_vsupplyv2v5[irmm][itfb] = -1.0;
      fTFB_vbias[irmm][itfb] = -1.0;
      fTempexternal_next[irmm][itfb] = -1.0;
      fTFB_vsupplyv2v5_next[irmm][itfb] = -1.0;
      fTFB_vbias_next[irmm][itfb] = -1.0;

      count++;
    }
  } //end for irmm = 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 );

  count = 0;
  for (int irmm=0; irmm<nrmm; irmm++){
    for (int itfb=0; itfb<ntfb[irmm]; itfb++){
      //      count = (irmm*28)+itfb;
      if ( fTempexternal_isok[count] == true &&  fTempexternal_next_isok[count] == true) {
	fTempexternal[irmm][itfb] = fTempexternal_vec[count][fTempexternal_idx[count]].second[0];
	fTempexternal_next[irmm][itfb] = fTempexternal_vec[count][fTempexternal_next_idx[count]].second[0];

	fTFB_vsupplyv2v5[irmm][itfb] = fTempexternal_vec[count][fTempexternal_idx[count]].second[1];
	fTFB_vsupplyv2v5_next[irmm][itfb] = fTempexternal_vec[count][fTempexternal_next_idx[count]].second[1];

	fTFB_vbias[irmm][itfb] = fTempexternal_vec[count][fTempexternal_idx[count]].second[2];
	fTFB_vbias_next[irmm][itfb] = fTempexternal_vec[count][fTempexternal_next_idx[count]].second[2];
      }

     count++;
    }
  }

  // update status values
  UpdateStatus();
  long db_time = (long)ISlowControlDatabase::Get().QueryShowField(fTime,"ECAL_rmm0_tfb0","_i_time");
  //  std::cout << "   Requested Time: " << fTime << ", Database entry time: "<< db_time <<std::endl;

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

}


///------------------------------------------------------------------------
/// Read the next ECAL system properties reading after current time setting and
/// update all readings.  Return 1 if all is okay otherwise return 
/// negative value.
int IECALTFBStatus::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 IECALTFBStatus::UpdateStatus(){
  // hard coded values for now
  fStatus = 0;
  // check if bad db read?
  //first external temperature
  int count=0;
  int fail_db_read_temp[12][44]={{0},{0}};
  for (int irmm=0; irmm<nrmm; irmm++){
    for (int itfb=0; itfb<ntfb[irmm]; itfb++){
      //      count = (irmm*28)+itfb;
      if((irmm==3&&itfb==0)||(irmm==4&&itfb==20)||(irmm==5&&itfb==0)||(irmm==5&&itfb==5)||(irmm==5&&itfb==22)||(irmm==6&&itfb==19)||(irmm==8&&itfb==19)||(irmm==9&&itfb==23)||(irmm==10&&itfb==10)||(irmm==10&&itfb==13)||(irmm==10&&itfb==15)||(irmm==10&&itfb==20)||(irmm==10&&itfb==22)||(irmm==10&&itfb==24)||(irmm==10&&itfb==27)||(irmm==10&&itfb==30)||(irmm==11&&itfb==14)||(irmm==11&&itfb==20)||(irmm==11&&itfb==28)){
	//broken temperature sensors - do nothing
      } else {
	if ( fTempexternal_isok[count] == false || fTempexternal_next_isok[count] == false ) {
	  std::cout << "1 - Failed sensor db read: rmm = " << irmm << "  tfb = " << itfb << std::endl;
	  fail_db_read_temp[irmm][itfb] = 1;
	  //  return;
	}
      }
      count++;
    }
  }

  for (int irmm=0; irmm<nrmm; irmm++){
    for (int itfb=0; itfb<ntfb[irmm]; itfb++){
      //      if (fail_db_read_temp[irmm][itfb]||fail_db_read_volt[irmm][itfb]||fail_db_read_bvolt[irmm][itfb]) {
      if (fail_db_read_temp[irmm][itfb]) {
	fStatus = 32;
	fECALStatus[irmm] = 32;
	fTFBStatus[irmm][itfb] = 32;
	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.

  std::cout << "Now checking variable values for external temperature, 2.5V and bias voltage line" << std::endl;

  for (int irmm=0; irmm<nrmm; irmm++){
    fECALStatus[irmm] = 0;  
    for (int itfb=0; itfb<ntfb[irmm]; itfb++){
      fTFBStatus[irmm][itfb] = 0;
      if((irmm==3&&itfb==0)||(irmm==4&&itfb==20)||(irmm==5&&itfb==0)||(irmm==5&&itfb==5)||(irmm==5&&itfb==22)||(irmm==6&&itfb==19)||(irmm==8&&itfb==19)||(irmm==9&&itfb==23)||(irmm==10&&itfb==10)||(irmm==10&&itfb==13)||(irmm==10&&itfb==15)||(irmm==10&&itfb==20)||(irmm==10&&itfb==22)||(irmm==10&&itfb==24)||(irmm==10&&itfb==27)||(irmm==10&&itfb==30)||(irmm==11&&itfb==14)||(irmm==11&&itfb==20)||(irmm==11&&itfb==28)){
	fTFBStatus[irmm][itfb] = 0; //broken temperature sensors
      } else {
	if (fTempexternal[irmm][itfb]<16||fTempexternal[irmm][itfb]>33) {
	  std::cout << "1 - Failed temperature check: rmm = " << irmm << "  tfb = " << itfb << "  Temp = " << fTempexternal[irmm][itfb] << std::endl;
	  fTFBStatus[irmm][itfb] +=1;
	}
      }
      
      if((irmm==5&&itfb==0)||(irmm==5&&itfb==5)||(irmm==9&&itfb==23)||(irmm==8&&itfb==19)||(irmm==9&&itfb==23)||(irmm==10&&itfb==10)||(irmm==10&&itfb==13)||(irmm==10&&itfb==15)||(irmm==10&&itfb==20)||(irmm==10&&itfb==22)||(irmm==10&&itfb==24)||(irmm==10&&itfb==27)||(irmm==10&&itfb==30)||(irmm==11&&itfb==14)||(irmm==11&&itfb==20)||(irmm==11&&itfb==28)) {  
	fTFBStatus[irmm][itfb] = 0; //broken voltage sensors
      } else {
	if (fTFB_vsupplyv2v5[irmm][itfb]<2.4||fTFB_vsupplyv2v5[irmm][itfb]>2.6) {
	  std::cout << "2 - Failed voltage check: rmm = " << irmm << "  tfb = " << itfb << "  2V5 Voltage = " << fTFB_vsupplyv2v5[irmm][itfb] << std::endl;
	  fTFBStatus[irmm][itfb] +=1;
	}
      }

      if((irmm==5&&itfb==0)||(irmm==5&&itfb==5)||(irmm==9&&itfb==23)||(irmm==8&&itfb==19)||(irmm==9&&itfb==23)||(irmm==10&&itfb==10)||(irmm==10&&itfb==13)||(irmm==10&&itfb==15)||(irmm==10&&itfb==20)||(irmm==10&&itfb==22)||(irmm==10&&itfb==24)||(irmm==10&&itfb==27)||(irmm==10&&itfb==30)||(irmm==11&&itfb==14)||(irmm==11&&itfb==20)||(irmm==11&&itfb==28)) {  
	fTFBStatus[irmm][itfb] = 0; //broken voltage sensors
      } else {
	if (fTFB_vbias[irmm][itfb]<65.0||fTFB_vbias[irmm][itfb]>71.0) {
	  std::cout << "3 - Failed bias voltage check: rmm = " << irmm << "  tfb = " << itfb << "  Bias Voltage = " << fTFB_vbias[irmm][itfb] << std::endl;
	  fTFBStatus[irmm][itfb] +=1;
	}
      }
      
      if (fTFBStatus[irmm][itfb] > fECALStatus[irmm] ){
	fECALStatus[irmm] = fTFBStatus[irmm][itfb];
	if ( fECALStatus[irmm] > fStatus ) fStatus = fECALStatus[irmm];
      }
         
    } //end if itfb
  } //end if irmm
  
  return;
}