/// Class to hold and plot temperature inside TPC
/// at a particular time
/// Blair Jamieson (C) 2008
/// Modifications
///   31 July 2009   Add more names for different run periods
///                  Update to handle more than one TPC and multiple TPC ends
///   28 Jan 2010    Updated for data taken in Tokai

#include "ITPCTemperature.hxx"
#include "TLine.h"


const char *TPCTempNames[NTPCTEMPS] = {
  "tr0asstopright",     
  "tr0asstopleft_",     
  "tr0assmm00",         
  "tr0assmm01",         
  "tr0assmm02",         
  "tr0assmm03",         
  "tr0assmm04",         
  "tr0assmm05",         
  "tr0assbotright",     
  "tr0assbotleft_",     
  "tr0assmm06",         
  "tr0assmm07",         
  "tr0assmm08",         
  "tr0assmm09",         
  "tr0assmm10",         
  "tr0assmm11",         
  "tr0agasmanleft",     
  "tr0agasmanright",    
  "tr0amfmm00",         
  "tr0amfmm01",         
  "tr0amfmm02",         
  "tr0amfmm03",         
  "tr0amfmm04",         
  "tr0amfmm05",         
  "tr0amfmm00mm06",     
  "tr0amfmm01mm07",     
  "tr0amfmm02mm08",     
  "tr0amfmm03mm09",     
  "tr0amfmm04mm10",     
  "tr0amfmm05mm11",     
  "tr0amfmm06",         
  "tr0amfmm07",         
  "tr0amfmm08",         
  "tr0amfmm09",         
  "tr0amfmm10",         
  "tr0amfmm11",         
  "tr1asstopright",     
  "tr1asstopleft_",     
  "tr1assmm00",         
  "tr1assmm01",         
  "tr1assmm02",         
  "tr1assmm03",         
  "tr1assmm04",         
  "tr1assmm05",         
  "tr1assbotright",     
  "tr1assbotleft_",     
  "tr1assmm06",         
  "tr1assmm07",         
  "tr1assmm08",         
  "tr1assmm09",         
  "tr1assmm10",         
  "tr1assmm11",         
  "tr1agasmanleft",     
  "tr1agasmanright",    
  "tr1amfmm00",         
  "tr1amfmm01",         
  "tr1amfmm02",         
  "tr1amfmm03",         
  "tr1amfmm04",         
  "tr1amfmm05",         
  "tr1amfmm00mm06",     
  "tr1amfmm01mm07",     
  "tr1amfmm02mm08",     
  "tr1amfmm03mm09",     
  "tr1amfmm04mm10",     
  "tr1amfmm05mm11",     
  "tr1amfmm06",         
  "tr1amfmm07",         
  "tr1amfmm08",         
  "tr1amfmm09",         
  "tr1amfmm10",         
  "tr1amfmm11",         
  "tarp1leftbackmid",   
  "tarp1leftfrontlo",   
  "tarp1leftfrontmid",  
  "tarp1leftfronthi",   
  "tarp1leftbottom",    
  "tarp1topback",       
  "tarp1topfrontlo",    
  "tarp1topfrontmid",   
  "tatopcenterback",    
  "tarp1topleft",       
  "tatopcenterfront",   
  "tarp1leftbackhi",    
  "tafrontcenter",      
  "tarp1leftbacklo",    
  "tarp1bottomback",    
  "tarp1bottomcenter",  
  "tarp1bottomfront",   
  "tarp1connector50pin",
  "tarp0rightbackmid",  
  "tarp0rightfrontlo",  
  "tarp0rightfrontmid", 
  "tarp0rightfronthi",  
  "tarp0rightbottom",   
  "tarp0topback",       
  "tarp0topfrontlo",    
  "tarp0topfrontmid",   
  "tabottomcenterback", 
  "tarp0bottomleft",    
  "tabottomcenterfront",
  "tarp0rightbackhi",   
  "tabackcenter",        
  "tarp0rightbacklo",   
  "tarp0bottomback",    
  "tarp0bottomcenter",  
  "tarp0bottomfront",   
  "tarp0connector50pin",
};


ITPCTemperature::ITPCTemperature( long autimemin, long autimemax ){
  fTime = autimemin;
  fTimeMin = autimemin;
  fTimeMax = autimemax;
  fDebug = false;
  fTimeStamp = 0x0;
  Init();
}

ITPCTemperature::ITPCTemperature(
         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);
  fTimeMax = fTime;
  SetTimeNoRead(ayearmin, amonthmin, adaymin, ahourmin, aminmin, asecmin);
  fTimeMin = fTime;
  Init();
}



/// Initialize temperature object
/// Sets offsets, makes histogram, reads tempearture, fills histogram
void ITPCTemperature::Init(){
  fNTemps=NTPCTEMPS*MAXNTPCS;

  // setup names for all three tpcs
  fNames = new  char * [fNTemps];
  char tmpname[256];
  for (int itpc=1; itpc<=3; itpc++){
    for (int iname=0; iname<NTPCTEMPS; iname++){
      sprintf(tmpname,"%s_tpc%1d",TPCTempNames[iname],itpc);
      int astrlen = strlen(tmpname)+1;
      fNames[ (itpc-1)*NTPCTEMPS + iname ] = new char [ astrlen ];
      strncpy( fNames[ (itpc-1)*NTPCTEMPS + iname ], tmpname, astrlen );
      fTPC_names[itpc-1].push_back( tmpname );
    }
  }

  // now setup histogram 
  char ahistname[256];
  char ahisttitle[256];
  sprintf(ahistname,"htpctemp%ld",fTime);
  sprintf(ahisttitle,"Temperature (degC) %s",fTimeStamp);
  fHist = new TH2F(ahistname,ahisttitle,34,0.5,34.5,17,0.5,17.5);
  fHist->SetNdivisions(0,"X");
  fHist->SetNdivisions(0,"Y");
  fHist->SetTickLength(0,"X");
  fHist->SetTickLength(0,"Y");
  fHist->SetStats(kFALSE);

  fHist->GetXaxis()->SetBinLabel(1,"Left");
  fHist->GetXaxis()->SetBinLabel(5,"Right");
  fHist->GetXaxis()->SetBinLabel(13,"Left");
  fHist->GetXaxis()->SetBinLabel(17,"Right");
  fHist->GetXaxis()->SetBinLabel(25,"Left");
  fHist->GetXaxis()->SetBinLabel(29,"Right");
  fHist->GetYaxis()->SetBinLabel(1,"Bot");
  fHist->GetYaxis()->SetBinLabel(8,"Top");
  fHist->GetYaxis()->SetBinLabel(10,"Bot");
  fHist->GetYaxis()->SetBinLabel(17,"Top");

  // Put a slash accross broken probe positions
  TLine * tltmp;
  tltmp=new TLine(2.4 ,0.6 ,1.6 ,1.4) ;tltmp->SetLineColor(kRed+2); fHist->GetListOfFunctions()->Add((TObject*)tltmp);
  tltmp=new TLine(3.4 ,0.6 ,2.6 ,1.4) ;tltmp->SetLineColor(kRed+2); fHist->GetListOfFunctions()->Add((TObject*)tltmp);
  tltmp=new TLine(2.4 ,4.6 ,1.6 ,5.4) ;tltmp->SetLineColor(kRed+2); fHist->GetListOfFunctions()->Add((TObject*)tltmp);
                                    
  tltmp=new TLine(15.4,1.6 ,14.6,2.4) ;tltmp->SetLineColor(kRed+2); fHist->GetListOfFunctions()->Add((TObject*)tltmp);
  tltmp=new TLine(15.4,2.6 ,14.6,3.4) ;tltmp->SetLineColor(kRed+2); fHist->GetListOfFunctions()->Add((TObject*)tltmp);
  tltmp=new TLine(15.4,3.6 ,14.6,4.4) ;tltmp->SetLineColor(kRed+2); fHist->GetListOfFunctions()->Add((TObject*)tltmp);
                                                        
  tltmp=new TLine(18.4,10.6,17.6,11.4);tltmp->SetLineColor(kRed+2); fHist->GetListOfFunctions()->Add((TObject*)tltmp);
  tltmp=new TLine(28.4,10.6,27.6,11.4);tltmp->SetLineColor(kRed+2); fHist->GetListOfFunctions()->Add((TObject*)tltmp);
 


  // use hard coded histogram index
  for (int itpc=0;itpc<3;itpc++){
    int itpcx = itpc*12;
    int imapoffs = itpc*NTPCTEMPS;
    // first do for each inside temperature on each readout plane
    for (int irp=0; irp<2; irp++){
      int irpy = irp*9;
      int irpoffs = irp*36;
      fHistMap[imapoffs+irpoffs+0] = fHist->GetBin(5+itpcx,8+irpy);
      fHistMap[imapoffs+irpoffs+1] = fHist->GetBin(1+itpcx,8+irpy);

      fHistMap[imapoffs+irpoffs+8] = fHist->GetBin(5+itpcx,1+irpy);
      fHistMap[imapoffs+irpoffs+9] = fHist->GetBin(1+itpcx,1+irpy);

      fHistMap[imapoffs+irpoffs+16] = fHist->GetBin(2+itpcx,1+irpy);
      fHistMap[imapoffs+irpoffs+17] = fHist->GetBin(3+itpcx,1+irpy);

      for (int itemp=7; itemp>1; itemp--){
  fHistMap[imapoffs+irpoffs+2+(7-itemp)] = fHist->GetBin(1+itpcx,itemp+irpy);
  fHistMap[imapoffs+irpoffs+10+(7-itemp)] = fHist->GetBin(5+itpcx,itemp+irpy);
  fHistMap[imapoffs+irpoffs+18+(7-itemp)] = fHist->GetBin(2+itpcx,itemp+irpy);
  if (itpc==1 && itemp<5 && irp==0){
    fHistMap[imapoffs+irpoffs+24+(7-itemp)] = 0;
  }else{
    fHistMap[imapoffs+irpoffs+24+(7-itemp)] = fHist->GetBin(3+itpcx,itemp+irpy);
  }
  fHistMap[imapoffs+irpoffs+30+(7-itemp)] = fHist->GetBin(4+itpcx,itemp+irpy);
      }
    }
    // now do the exterior temperatures... almost randomly placed, so one per probe
    fHistMap[imapoffs+ 72] = fHist->GetBin(6+itpcx,14);
    fHistMap[imapoffs+ 73] = fHist->GetBin(8+itpcx,13);
    fHistMap[imapoffs+ 74] = fHist->GetBin(8+itpcx,14);
    fHistMap[imapoffs+ 75] = fHist->GetBin(8+itpcx,15);
    fHistMap[imapoffs+ 76] = fHist->GetBin(7+itpcx,12);
    fHistMap[imapoffs+ 77] = fHist->GetBin(6+itpcx,16);
    fHistMap[imapoffs+ 78] = fHist->GetBin(6+itpcx,15);
    fHistMap[imapoffs+ 79] = fHist->GetBin(8+itpcx,16);
    fHistMap[imapoffs+ 80] = fHist->GetBin(6+itpcx,17);
    fHistMap[imapoffs+ 81] = fHist->GetBin(7+itpcx,16);
    fHistMap[imapoffs+ 82] = fHist->GetBin(8+itpcx,17);
    fHistMap[imapoffs+ 83] = fHist->GetBin(9+itpcx,14);
    fHistMap[imapoffs+ 84] = fHist->GetBin(10+itpcx,14);
    fHistMap[imapoffs+ 85] = fHist->GetBin(6+itpcx,13);
    fHistMap[imapoffs+ 86] = fHist->GetBin(6+itpcx,11);
    fHistMap[imapoffs+ 87] = fHist->GetBin(7+itpcx,11);
    fHistMap[imapoffs+ 88] = fHist->GetBin(8+itpcx,11);
    fHistMap[imapoffs+ 89] = fHist->GetBin(7+itpcx,13);
    fHistMap[imapoffs+ 90] = fHist->GetBin(8+itpcx,6);
    fHistMap[imapoffs+ 91] = fHist->GetBin(6+itpcx,5);
    fHistMap[imapoffs+ 92] = fHist->GetBin(6+itpcx,6);
    fHistMap[imapoffs+ 93] = fHist->GetBin(6+itpcx,7);
    fHistMap[imapoffs+ 94] = fHist->GetBin(7+itpcx,4);
    fHistMap[imapoffs+ 95] = fHist->GetBin(8+itpcx,8);
    fHistMap[imapoffs+ 96] = fHist->GetBin(8+itpcx,7);
    fHistMap[imapoffs+ 97] = fHist->GetBin(6+itpcx,8);
    fHistMap[imapoffs+ 98] = fHist->GetBin(8+itpcx,2);
    fHistMap[imapoffs+ 99] = fHist->GetBin(7+itpcx,2);
    fHistMap[imapoffs+100] = fHist->GetBin(6+itpcx,2);
    fHistMap[imapoffs+101] = fHist->GetBin(9+itpcx,6);
    fHistMap[imapoffs+102] = fHist->GetBin(10+itpcx,6);
    fHistMap[imapoffs+103] = fHist->GetBin(8+itpcx,5);
    fHistMap[imapoffs+104] = fHist->GetBin(8+itpcx,3);
    fHistMap[imapoffs+105] = fHist->GetBin(7+itpcx,3);
    fHistMap[imapoffs+106] = fHist->GetBin(6+itpcx,3);
    fHistMap[imapoffs+107] = fHist->GetBin(7+itpcx,5);
  }


  // add position labels 
  for (int itpc=0;itpc<3;itpc++){
    float itpcxmax=12.0*float(itpc)+5.5;
    float itpcxmin=12.0*float(itpc);

    // cross off empty positions
    float ixoff = float(itpc)*12.0;
    fHist->GetListOfFunctions()->Add((TObject*)new TLine(5.6+ixoff,3.6, 6.4+ixoff,4.4));
    fHist->GetListOfFunctions()->Add((TObject*)new TLine(7.6+ixoff,3.6, 8.4+ixoff,4.4));
    fHist->GetListOfFunctions()->Add((TObject*)new TLine(6.6+ixoff,5.6, 7.4+ixoff,6.4));
    fHist->GetListOfFunctions()->Add((TObject*)new TLine(6.6+ixoff,6.6, 7.4+ixoff,7.4));
    fHist->GetListOfFunctions()->Add((TObject*)new TLine(6.6+ixoff,7.6, 7.4+ixoff,8.4));
                                       
    fHist->GetListOfFunctions()->Add((TObject*)new TLine(5.6+ixoff,11.6,6.4+ixoff,12.4));
    fHist->GetListOfFunctions()->Add((TObject*)new TLine(7.6+ixoff,11.6,8.4+ixoff,12.4));
    fHist->GetListOfFunctions()->Add((TObject*)new TLine(6.6+ixoff,13.6,7.4+ixoff,14.4));
    fHist->GetListOfFunctions()->Add((TObject*)new TLine(6.6+ixoff,14.6,7.4+ixoff,15.4));
    fHist->GetListOfFunctions()->Add((TObject*)new TLine(6.6+ixoff,16.6,7.4+ixoff,17.4));

    
    // now add details for exterior temperatures
    TPaveText* tpt[8];
    
    tpt[0] = new TPaveText(itpcxmin+5.6,7.6,itpcxmin+8.4,8.4);
    //tpt[0]->SetLabel("Top");
    tpt[1] = new TPaveText(itpcxmin+5.6,4.6,itpcxmin+8.4,7.4);
    tpt[1]->SetLabel("SS");
    tpt[2] = new TPaveText(itpcxmin+8.6,5.6,itpcxmin+10.4,6.4);
    tpt[2]->SetLabel("Side");
    tpt[3] = new TPaveText(itpcxmin+5.6,1.6,itpcxmin+8.4,4.4);
    tpt[3]->SetLabel("Bot");

    tpt[4] = new TPaveText(itpcxmin+5.6,15.6,itpcxmin+8.4,17.4);
    //tpt[4]->SetLabel("Top");
    tpt[5] = new TPaveText(itpcxmin+5.6,12.6,itpcxmin+8.4,15.4);
    tpt[5]->SetLabel("SS");
    tpt[6] = new TPaveText(itpcxmin+8.6,13.6,itpcxmin+10.4,14.4);
    tpt[6]->SetLabel("Side");
    tpt[7] = new TPaveText(itpcxmin+5.6,10.6,itpcxmin+8.4,12.4);
    tpt[7]->SetLabel("Bot");

    itpcxmin=12.0*float(itpc)+0.5;

    for (int ipt=0;ipt<8;ipt++){
      tpt[ipt]->SetFillStyle(0);
      tpt[ipt]->SetBorderSize(1);
      tpt[ipt]->SetTextSize(0.1);
      fHist->GetListOfFunctions()->Add((TObject*)tpt[ipt]);
    }
    
    for (int irp=0; irp<2; irp++){
      float irpymin = 9.0*float(irp)+0.5;
      float irpymax = 9.0*float(irp)+8.5;

      TPaveText* tmftx = new TPaveText(itpcxmin,irpymin,itpcxmax,irpymax);
      char aname[256];
      sprintf(aname,"TPC%1dRP%1d",itpc+1,irp);
      tmftx->SetLabel(aname);
      tmftx->SetFillStyle(0);
      tmftx->SetBorderSize(2);
      tmftx->SetLineColor( kBlue+2 );

      sprintf(aname,"TPC%1dEXT%1d",itpc+1,irp);
      TPaveText* textx = new TPaveText(itpcxmin+5.0,irpymin+1.0,itpcxmin+10.0,irpymax);
      textx->SetLabel(aname);
      textx->SetFillStyle(0);
      textx->SetBorderSize(2);
      textx->SetLineColor( kBlue+2 );

      sprintf(aname,"RP%d",irp);
      TPaveText* trptx = new TPaveText(itpcxmin+1.1,irpymin+1.1,itpcxmin+3.9,irpymin+6.9);
      trptx->SetLabel(aname);
      trptx->SetFillStyle(0);
      trptx->SetBorderSize(1);

      TPaveText* tssltx = new TPaveText(itpcxmin+0.1,irpymin+0.1,itpcxmin+0.9,irpymin+7.9);
      tssltx->SetLabel("SS");
      tssltx->SetFillStyle(0);
      tssltx->SetBorderSize(1);

      TPaveText* tssrtx = new TPaveText(itpcxmin+4.1,irpymin+0.1,itpcxmin+4.9,irpymin+7.9);
      tssrtx->SetLabel("SS");
      tssrtx->SetFillStyle(0);
      tssrtx->SetBorderSize(1);

      TPaveText* tmantx = new TPaveText(itpcxmin+1.1,irpymin+0.1,itpcxmin+2.9,irpymin+0.9);
      tmantx->SetLabel("Gas");
      tmantx->SetFillStyle(0);
      tmantx->SetBorderSize(1);

      textx->SetTextSize(0.1);
      tssrtx->SetTextSize(0.1);
      tmftx ->SetTextSize(0.1);
      tssltx->SetTextSize(0.1);
      tmantx->SetTextSize(0.1);
      trptx->SetTextSize(0.1);

      fHist->GetListOfFunctions()->Add((TObject*)tssrtx);
      fHist->GetListOfFunctions()->Add((TObject*)tmftx);
      fHist->GetListOfFunctions()->Add((TObject*)tssltx);
      fHist->GetListOfFunctions()->Add((TObject*)tmantx);
      fHist->GetListOfFunctions()->Add((TObject*)trptx);
      fHist->GetListOfFunctions()->Add((TObject*)textx);
    }

  }

  if ( fDebug ){
    // Print histmap
    for (int i=0; i<fNTemps; i++){
      std::cout<<"Histmap i="<<i<<" bin="<<fHistMap[i]<<" name="<<fNames[i]<<std::endl;
    }
  }

  // Now read temperatures, and fill histogram
  Read();
}


void ITPCTemperature::PrintMap(){
  
  std::cout<<"<ITPCTemperature::PrintMap>"<<std::endl;
  std::cout<<"  xbin ybin bin  name"<<std::endl;
  for (int iy=1; iy<=17; iy++){
    for (int ix=1; ix<=34; ix++){
        int ibin = fHist->GetBin(ix,iy);
  int ib = -1;
  for (int j=0;j<fNTemps; j++){
    if ( fHistMap[j] == ibin ) ib = j;
  }
  if (ib>=0){
    std::cout<<"  "<<ix<<" "<<iy<<" "<<ib<<" "<<fNames[ib]<<std::endl;
  } else {
    std::cout<<"  "<<ix<<" "<<iy<<" "<<ib<<" empty bin"<<std::endl;
  }
    }
  }

}

const char* ITPCTemperature::GetBinName(int ix, int iy){
  int ibin = fHist->GetBin(ix,iy);
  int ib = -1;
  for (int j=0;j<fNTemps; j++){
    if ( fHistMap[j] == ibin ) ib = j;
  }
  if (ib>=0) return(  fNames[ib] );
  return "";
}



/// Get the time interval for this record
void ITPCTemperature::GetTimeInterval(long &start_time, long &end_time){
  int st,et;
  ISlowControlDatabase ::
    Get().GetFieldInterval((int)fTime,"tpc1temp_tpc1","_i_time",
         st, et);
  start_time = (long)st;
  end_time = (long)et;
  
  return;

}


/// Set the time for this object
void ITPCTemperature::SetTimeNoRead( 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;
  fTime = (long)mktime(&mt);

}

/// Set string timestamp from unix integer timestamp
void ITPCTemperature::SetupTimeStamp(){
  char aCtime[256];
  ctime_r(  (const time_t*)&fTime, aCtime );
  int aslen = strlen(aCtime);
  if (fTimeStamp!=0x0) delete fTimeStamp;
  fTimeStamp = new char[aslen+1];
  sprintf(fTimeStamp,"%s",aCtime);
}

/// Set the time for this object
void ITPCTemperature::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 ITPCTemperature::ReadSlowControlDatabase(){
  /// read next 500 entries starting from 5 minutes ago
  long astart = fTime - 300;
  char fTableName[256];
  
  // clear existing data, then read from slow control database
  for (int itpc=0; itpc<3; itpc++){
    fTPC_vec[itpc].clear();
    sprintf(fTableName,"tpc%1dtemp_tpc%1d",itpc+1,itpc+1);    
    fTPC_vec[itpc] = ISlowControlDatabase::Get().QueryGetFieldNoCache( astart, fTableName, fTPC_names[itpc], 500 );
  }
  return;
}



///------------------------------------------------------------------------
/// Get index into each of the vectors of database query
/// results for the current time
void ITPCTemperature::UpdateVectorTimeIdx(){
  
  // Find index for current time for TPC Temperatures
  for (int itpc=0; itpc<3; itpc++ ){
    fTPC_isok[itpc] = false;
    for (unsigned int i=0; i< (fTPC_vec[itpc]).size()-1; i++){
      if ( fTime >= long( ((fTPC_vec[itpc])[i]).first ) &&
     fTime <  long( ((fTPC_vec[itpc])[i+1]).first ) ) {
  fTPC_idx[itpc] = i;
  fTPC_isok[itpc] = true;
  break;
      }
    }
  }
  
  return;
}

/// Read the temperature reading and update all
/// object temperature readings. 
void ITPCTemperature::Read(){
  SetupTimeStamp();
  char ahistname[256];
  sprintf(ahistname,"htpcintemp%ld",fTime);
  char ahisttitle[256];
  sprintf(ahisttitle,"TPC Temperatures (degC) %s",fTimeStamp);
  fHist->SetName( ahistname );
  fHist->SetTitle( ahisttitle );

  // Check if we need to read more data
  // from slow control database
  if ( fTPC_vec[0].size() <= 2 ||
       fTime > long( ((fTPC_vec[0])[ fTPC_vec[0].size()-2 ]).first ) ||
       fTPC_vec[1].size() <= 2 ||
       fTime > long( ((fTPC_vec[1])[ fTPC_vec[1].size()-2 ]).first ) ||
       fTPC_vec[2].size() <= 2 ||
       fTime > long( ((fTPC_vec[2])[ fTPC_vec[2].size()-2 ]).first ) ){
    std::cout<<"<ITPCTemperature::Read> About to read slow control database"<<std::endl;
    ReadSlowControlDatabase();
  }

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

  // Read temperatures
  fTempMax = -273.;
  fTempMin =  273.;
  int ntemps = 0;
  fTempAvg = 0.0;
  if (fDebug) std::cout<<"<ITPCTemperature::Read> Reading temperatures..."<<std::endl;
  for (int i=0; i<fNTemps; i++){
    int itpc = i/NTPCTEMPS + 1;
    int itemp = i % NTPCTEMPS;
    //if (fDebug) std::cout<<"   "<<i<<" "<<fTableName<<" "<<(char*)(fNames[i])<<" = ";
    double temp = -273.0;
    if ( fTPC_isok[itpc-1] == true ){
      temp = fTPC_vec[itpc-1][ fTPC_idx[itpc-1] ].second[ itemp ] ;
    }
    //ISlowControlDatabase :: Get().QueryShowField(fTime,fTableName,(char*)(fNames[i]));
    fTemperature[i] = temp;
    if ( fTemperature[i] > 0.1 ){
      if ( fTemperature[i]> fTempMax) fTempMax = fTemperature[i];
      if ( fTemperature[i]< fTempMin) fTempMin = fTemperature[i];
      fTempAvg += (double) (fTemperature[i]);
      ntemps++;
    }
    if (fDebug) std::cout<<fTemperature[i]<<std::endl;
    fHist->SetBinContent( fHistMap[i], (double)(fTemperature[i]) );
  }  
  if (ntemps>0) fTempAvg /= double(ntemps);
  if (fTempAvg>0.1){
    fHist->SetMinimum( std::max<float>(float(fTempAvg) - 7.0,fTempMin) );
    fHist->SetMaximum( std::min<float>(float(fTempAvg) + 7.0,fTempMax) );
  } else{
    fHist->SetMinimum( 12.0 );
    fHist->SetMaximum( 42.0 );
  }
  
  if (fDebug){ 
    // Time check:
    long db_time = (long)ISlowControlDatabase::Get().QueryShowField(fTime,"tpc1temp_tpc1","_i_time");
    std::cout << "<ITPCTemperature::Read>"<<std::endl;
    std::cout << "   Requested Time: " << fTime << ", Database entry time: "<< db_time 
        << fNames[1] << " " << fTemperature[1] << std::endl;
    fTime = db_time;
  }
}


/// Read the next temperature reading after current time setting and
/// update all object temperature readings.  Return 1 if all is okay
/// otherwize return negative value.
int ITPCTemperature::ReadNext(int adeltat){
  static int amult = 1;
  long astart;
  long aend;
  
  GetTimeInterval(astart,aend);
  
  //std::cout<<"Readnext fTime="<<fTime<<" start="<<astart<<" end="<<aend<<std::endl;
  //long foo = fTime;
  
  if (astart+adeltat > aend){
    amult = 1;
    fTime = fTime + adeltat;
  } else {
    if ( aend+1 <= fTime ){
      // handle case where no readings for a while
      amult *= 2;
      fTime += amult;
    } else {
      amult = 1;
      fTime = aend+1;
    }
  }

  //std::cout<<" ... Prev time="<<foo<<" set fTime="<<fTime<<" requested dt="<<adeltat<<" actual dt="<<fTime-foo<<std::endl;
  Read();

  return 1;
}