///////////////////////////////////////////////////////////////////////////////
//  Feb 2002 P.Murat: split source and include files
///////////////////////////////////////////////////////////////////////////////
#include "TSystem.h"
#include "TDatime.h"

#include "Stntuple/base/TUsedSet.hh"
#include "Stntuple/base/TCdf2RunSections.hh"
#include "Stntuple/base/TCdf2Files.hh"
#include "Stntuple/base/TCdf2Filesets.hh"
#include "Stntuple/base/TTriggerConditions.hh"
#include "Stntuple/base/TBeamConditions.hh"
#include "Stntuple/base/TSetRunMaps.hh"

#include "TCdfOracle.hh"
#include "TOracleSession.hh"

#include "Stntuple/obj/TStnRunSummary.hh"
#include "Stntuple/obj/TStnTrigger.hh"
#include "Stntuple/obj/TStnTriggerTable.hh"


//_____________________________________________________________________________
void TCdfOracle::PrintCslSummary(Int_t RunNumber) {
  // print datasets corresponding to a given run (given trigger table)

  TSQLResult* res;

  QueryCslSummary(RunNumber,res);
  printf("#----------------------------------------------------------------\n");
  printf("# Run#  Stream            N(input)       N(output)               \n");
  printf("#----------------------------------------------------------------\n");
  PrintResult(res);
  delete res;
}

//_____________________________________________________________________________
void TCdfOracle::PrintTriggerTable(Int_t RunNumber) {
  // print datasets corresponding to a given run (given trigger table)

  TSQLResult* res;

  QueryTriggerTable(RunNumber,res);
  PrintResult(res);
  delete res;
}

//_____________________________________________________________________________
void TCdfOracle::PrintListOfRuns(const char* Date1, const char* Date2) {
  // print list of good runs from Data1 to Date2 
  // date format: "YYYY.MM.DD"

  TSQLResult* res;

  QueryListOfRuns(Date1,Date2,0,res);
  printf("---------------------------------------------------------------");
  printf("---------------------------------------------------------------");
  printf("-----------------------\n");
  printf("    run   trigger table        version     L2A       L3A   ");
  printf("  Lumi(TeV)           Lumi(Live)            Date                Time");
  printf("            GoodRunBit\n");
  printf("---------------------------------------------------------------");
  printf("---------------------------------------------------------------");
  printf("-----------------------\n");
  PrintResult(res);
  delete res;
  Disconnect();
}

//_____________________________________________________________________________
void TCdfOracle::PrintListOfRuns(Int_t Run1, Int_t Run2) {
  // print list of good runs from Data1 to Date2 
  // date format: "YYYY.MM.DD"

  TSQLResult* res;

  if (Run2 < 0) Run2 = Run1;

  QueryListOfRuns(Run1,Run2,0,res);
  printf("---------------------------------------------------------------");
  printf("---------------------------------------------------------------");
  printf("-----------------------\n");
  printf("    run   trigger table        version     L2A       L3A   ");
  printf("  Lumi(TeV)           Lumi(Live)            Date                Time");
  printf("            GoodRunBit\n");
  printf("---------------------------------------------------------------");
  printf("---------------------------------------------------------------");
  printf("-----------------------\n");
  PrintResult(res);
  delete res;
  Disconnect();
}

//_____________________________________________________________________________
void TCdfOracle::PrintListOfGoodRuns(const char* Date1, const char* Date2) {
  // print list of good runs from Data1 to Date2 
  // date format: "YYYY.MM.DD"

  TSQLResult* res;

  QueryListOfRuns(Date1,Date2,1,res);
  printf("---------------------------------------------------------------");
  printf("---------------------------------------------------------------");
  printf("-----------------------\n");
  printf("    run   trigger table        version     L2A       L3A   ");
  printf("  Lumi(TeV)           Lumi(Live)            Date                Time");
  printf("            GoodRunBit\n");
  printf("---------------------------------------------------------------");
  printf("---------------------------------------------------------------");
  printf("-----------------------\n");
  PrintResult(res);
  delete res;
  Disconnect();
}

//_____________________________________________________________________________
void TCdfOracle::PrintListOfGoodRuns(Int_t Run1, Int_t Run2) {
  // print list of good runs from Data1 to Date2 
  // date format: "YYYY.MM.DD"

  TSQLResult* res;

  if (Run2 < 0) Run2 = Run1;

  QueryListOfRuns(Run1,Run2,1,res);
  printf("---------------------------------------------------------------");
  printf("---------------------------------------------------------------");
  printf("-----------------------\n");
  printf("    run   trigger table        version     L2A       L3A   ");
  printf("  Lumi(TeV)           Lumi(Live)            Date                Time");
  printf("            GoodRunBit\n");
  printf("---------------------------------------------------------------");
  printf("---------------------------------------------------------------");
  printf("-----------------------\n");
  PrintResult(res);
  delete res;
  Disconnect();
}

//_____________________________________________________________________________
void TCdfOracle::PrintCalibTable(Int_t        RunNumber  , 
				 const char*  Table      , 
				 const char*  ProcessName,
				 const char*  PassName   )
{
  TSQLResult* res;

  //  DescribeTable(Table);
  QueryCalibTable(RunNumber, Table, ProcessName, PassName, res);
  PrintResult(res);
  delete res;
  Disconnect();
}


//_____________________________________________________________________________
void TCdfOracle::PrintDatasets(Int_t RunNumber) {
  // print datasets corresponding to a given run (given trigger table)

  TSQLResult* res;

  QueryDatasets(RunNumber,res);
  PrintResult(res);
  delete res;
  Disconnect();
}

//_____________________________________________________________________________
void TCdfOracle::PrintUsedSets(const char*  ProcessName, 
			       const char*  PassName,
			       int          RunMin, 
			       int          RunMax,
			       int          All) 
{

  TObjArray* list_of_good_runs = new TObjArray(10);
  TObjArray* list_of_used_sets = new TObjArray(10);

  GetListOfGoodRuns(list_of_good_runs,RunMin,RunMax);
  GetListOfUsedSets(ProcessName,PassName,list_of_used_sets,RunMin,RunMax,All);

  printf("--------------------------------------------------------------------");
  printf("------------------------------------------------------------------\n");
  printf(" RunNum   Trigger Table           Version      ");
  printf(" date      time          process name      pass name");
  printf("tag version    status      jobset              date           user\n");
  printf("--------------------------------------------------------------------");
  printf("------------------------------------------------------------------\n");

  int nruns = list_of_good_runs->GetEntriesFast();
  int nsets = list_of_used_sets->GetEntriesFast();

  int found, rn;

  for (int i=0; i<nruns; i++) {
    TStnRunSummary* r = (TStnRunSummary*) list_of_good_runs->At(i);
    rn = r->RunNumber();
    found = 0;
    for (int iset=0; iset<nsets; iset++) {
      TUsedSet* us = (TUsedSet*) list_of_used_sets->At(iset);
      if (us->fPROCESS_RUN == rn) {
	char* create_date = Strip(ctime((time_t*)&us->fCREATE_DATE)," \n");
	printf("%8i %20s %3i %10s %10s %20s %10s %5i %5s %12s %10i %20s %10s \n",
	       us->fPROCESS_RUN,
	       r->TriggerTableName().Data(),
	       r->TriggerTableTag(),
	       r->Date().Data(),
	       r->Time().Data(),
	       ProcessName,
	       PassName,
	       us->fPROC_TAG,
	       us->fPROC_CALIB_VERSION.Data(),
	       us->fPROCESS_STATUS.Data(),
	       us->fJOBSET,
	       create_date,
	       us->fCREATE_USER.Data());
	found = 1;
	if (! All) break;
      }
    }
    if (! found) {
      printf("%8i %20s %3i %10s %10s %20s %10s is not available\n",
	     rn,
	     r->TriggerTableName().Data(),
	     r->TriggerTableTag(),
	     r->Date().Data(),
	     r->Time().Data(),
	     ProcessName,PassName);
    }
  }

  list_of_good_runs->Delete();
  delete list_of_good_runs;

  list_of_used_sets->Delete();
  delete list_of_used_sets;
}

//_____________________________________________________________________________
void TCdfOracle::PrintOnlineLuminosity(int  RunMin, int RunMax) {

  Float_t lumi_tev, lumi_live;

  if (RunMax == -1) RunMax = RunMin;
  printf("---------------------------------------------------------------\n");
  printf("   run    lumi_tev    lumi_live \n");
  printf("---------------------------------------------------------------\n");

  for (int run=RunMin; run<=RunMax; run++) {
    GetOnlineLuminosity(run,lumi_tev,lumi_live);
    printf("%8i %10.3f %10.3f\n",
	   run, lumi_tev,lumi_live);
  }
}

//_____________________________________________________________________________
void TCdfOracle::PrintListOfRunSections(int RunNumber)
{

  TObjArray* list_of_runsections = new TObjArray(1000);

  GetListOfRunSections(RunNumber,RunNumber,list_of_runsections);
  printf("-----------------------------------------------------------------");
  printf("---------------------------------------------------------\n");
  printf(" run section birth low_event high_event lum_ave_online ");
  printf(" lum_ave_offline lum_int_online lum_int_offline ");
  printf(" data_quality version\n");
  printf("-----------------------------------------------------------------");
  printf("---------------------------------------------------------\n");

  int n = list_of_runsections->GetEntriesFast();

  char* s;

  Float_t lum_sum_online  = 0;
  Float_t lum_sum_offline = 0;
  Float_t lumi_tev, lumi_live;

  for (int i=0; i<n; i++) {
    TCdf2RunSections* rs = (TCdf2RunSections*) list_of_runsections->At(i);
    s = ctime((const time_t*) &rs->fBIRTH_TIME);
    s[strlen(s)-1] = 0;
    printf("%8i %6i %s %7i %7i %10.3g %10.3g %8.3f %8.3f 0x%08x %3i\n",
	   rs->fRUN_NUMBER,
	   rs->fSECTION_NUMBER,
	   s,
	   rs->fLOW_EVENT,
	   rs->fHIGH_EVENT,
	   rs->fLUM_AVERAGE_ONLINE,
	   rs->fLUM_AVERAGE_OFFLINE,
	   rs->fLUM_INTEGRAL_ONLINE,
	   rs->fLUM_INTEGRAL_OFFLINE,
	   rs->fDATA_QUALITY,
	   rs->fLUMINOSITY_VERSION);
//-----------------------------------------------------------------------------
//  simultaneously sum the luminosity
//-----------------------------------------------------------------------------
    if (rs->fLUM_INTEGRAL_ONLINE >= 0) {
      lum_sum_online  += rs->fLUM_INTEGRAL_ONLINE;
    }
    if (rs->fLUM_INTEGRAL_OFFLINE >= 0) {
      lum_sum_offline += rs->fLUM_INTEGRAL_OFFLINE;
    }
  }
  GetOnlineLuminosity(RunNumber,lumi_tev,lumi_live);

  printf("-----------------------------------------------------------------\n");
  printf(" run_num lumi_onl(rs) lumi_offl(rs) lumi_tev(rc) lumi_live(rc)   \n");
  printf("-----------------------------------------------------------------\n");
  printf(" %8i %10.3f  %10.3f %10.3f %10.3f \n",
	 RunNumber,lum_sum_online,lum_sum_offline,lumi_tev,lumi_live);

  list_of_runsections->Delete();
  delete list_of_runsections;
}

//_____________________________________________________________________________
void TCdfOracle::FindFile(const char* Book, 
			  const char* Dataset, 
			  Int_t       RunNumber, 
			  Int_t       EventNumber, TCdf2Files* File)
{
  // print file corresponding to a given run/event in a given dataset

  TCdf2Files local_file, *file;

  file = File;
  if (! file) file = &local_file ;

  int rc = GetFile(Book,Dataset,RunNumber,EventNumber,file);

  if (rc >= 0) {
    printf (" %10s %10s\n",file->fFILE_NAME.Data(),file->fFILESET_NAME.Data());
  }
  else {
    printf(" file not found\n");
  }
}

//_____________________________________________________________________________
void TCdfOracle::PrintFiles(const char* Dataset, Int_t Run1, Int_t Run2) {
  // print datasets corresponding to a given run (given trigger table)

  TObjArray list_of_files;

  TCdf2Files* fr;

  fForceDisconnect = 1;

  if (Run2 < 0) Run2 = Run1;
  GetListOfFiles(&list_of_files,Dataset,Run1,Run2);

  int nfiles = list_of_files.GetEntriesFast();

  int   banner_printed = 0;
  int   nev            = 0;
  float lum_onl        = 0;
  float lum_offl       = 0;
  float tot_size       = 0;

  for (int i=0; i<nfiles; i++) {
    fr = (TCdf2Files*) list_of_files.At(i);
    if (! banner_printed) {
      fr->Print("banner+data");
      banner_printed = 1;
    }
    else {
      printf("%5i",i);
      fr->Print("data");
    }
    nev      += fr->fEVENT_COUNT;
    lum_onl  += fr->fLUM_SUM_ONLINE;
    lum_offl += fr->fLUM_SUM_OFFLINE;
    tot_size += fr->fFILE_SIZE;
  }
  printf("---------------------------------------------------------------");
  printf("-----------------------------------------\n");
  printf(" total %10i          %10.3f %8i             ",
	 nfiles,tot_size,nev);
  printf("                        %10.3f %10.3f\n", 
	 lum_onl,lum_offl);
  printf("-----------------------------------------------------------------");
  printf("---------------------------------------\n");

  list_of_files.Delete();
}

//_____________________________________________________________________________
void TCdfOracle::PrintTapeContents(const char* TapeName, const char* Dataset) {
  // print files, corresponding to a given tape and dataset

  TSQLResult* res;

  QueryTapeContents(TapeName,res,Dataset);

  printf("#----------------------------------------------------------------\n");
  printf("# dataset fileset     filename    file_size(MB)   N(events)      \n");
  printf("#----------------------------------------------------------------\n");

  PrintResult(res);
  delete res;
  Disconnect();
}

//_____________________________________________________________________________
void TCdfOracle::PrintFileset(const char* Book, const char* Fileset) {

  // print filesets corresponding to a given dataset (given trigger table)

  TCdf2Filesets fileset;
  TObjArray list_of_files;
  TCdf2Files* fr;
  TString book;

  fForceDisconnect = 1;

  book = Book;
  if (book == "") book = "filecatalog";

  GetFileset(book.Data(),Fileset,&fileset);

  char dataset[200];

  sprintf(dataset,"%s:%s",fileset.fDS_NAME_ID.Data(),book.Data());
  
  GetListOfFiles(&list_of_files,dataset,Fileset);

  int nfiles = list_of_files.GetEntriesFast();

  int   banner_printed = 0;
  int   nev            = 0;
  float lum_onl        = 0;
  float lum_offl       = 0;

  for (int i=0; i<nfiles; i++) {
    fr = (TCdf2Files*) list_of_files.At(i);
    if (! banner_printed) {
      fr->Print("banner+data");
      banner_printed = 1;
    }
    else {
      fr->Print("data");
    }
    nev      += fr->fEVENT_COUNT;
    lum_onl  += fr->fLUM_SUM_ONLINE;
    lum_offl += fr->fLUM_SUM_OFFLINE;
  }
  printf("-----------------------------------------------------------------");
  printf("--------------------------------------\n");
  printf(" total   %40i    %41.3f %8.3f\n", nev,lum_onl,lum_offl);
  printf("-----------------------------------------------------------------");
  printf("--------------------------------------\n");

  list_of_files.Delete();
}

//_____________________________________________________________________________
void TCdfOracle::PrintFilesets(const char* Dataset, Int_t Run1, Int_t Run2) {
  // print filesets corresponding to a given dataset (given trigger table)

  // If someone can do it more elegantly please do it
  TString   fullDatasetName(Dataset);
  int iColon = fullDatasetName.Index(":");
  int iEnd   = fullDatasetName.Length();
  TSubString bookName = fullDatasetName.SubString("",iColon+1);
  TString datasetName = fullDatasetName.Copy();
  datasetName.Remove(iColon,iEnd-iColon);

  TObjArray list_of_filesets;
  TObjArray list_of_files;

  int    rmin, rmax, emin, emax, nev, nev_tot, nfiles, nfiles_tot;
  float  size, size_tot;

  list_of_filesets.Delete();
  GetListOfFilesets(Dataset,Run1,Run2,&list_of_filesets);

  printf("#---------------------------------------------");
  printf("----------------------------------\n");
  printf("# MetaName Location Book:Fileset  nEvents  LoRun    LoEvt");
  printf("    HiRun    HiEvt\n");
  printf("#---------------------------------------------");
  printf("----------------------------------\n");

  int nfs    = list_of_filesets.GetEntriesFast();
  nev_tot    = 0;
  size       = 0;
  nfiles_tot = 0;
  size_tot   = 0;
  for (int i=0; i<nfs; i++) {
    TCdf2Filesets* fs = (TCdf2Filesets*) list_of_filesets.At(i);

				// get list of files corresponding to this 
				// fileset
    if (fs->fFILE_COUNT > 0) {
      GetListOfFiles(&list_of_files,Dataset,fs->fFILESET_NAME);
//-----------------------------------------------------------------------------
//  loop over the files and calculate some statistics
//-----------------------------------------------------------------------------
      emin  = 10000000;
      emax  = -1;
      rmin  = 10000000;
      rmax  = -1;
      nev   = 0;
      size  = 0;
      int nfiles = list_of_files.GetEntriesFast();
      for (int ifile=0; ifile<nfiles; ifile++) {
	TCdf2Files* file = (TCdf2Files*) list_of_files.At(ifile);
	nev  += file->fEVENT_COUNT;
	size += file->fFILE_SIZE;

	if (rmin > file->fLOW_RUN ) {
	  rmin = file->fLOW_RUN;
	  emin = file->fLOW_EVENT;
	}
	else if (rmin == file->fLOW_RUN) {
	  if (emin >= file->fLOW_EVENT) emin = file->fLOW_EVENT;
	}

	if (rmax < file->fHIGH_RUN) {
	  rmax = file->fHIGH_RUN;
	  emax = file->fHIGH_EVENT;
	}
	else if (rmax == file->fHIGH_RUN) {
	  if (emax <= file->fHIGH_EVENT) emax = file->fHIGH_EVENT;
	}
      }
      printf("%s.%04d  dfc  %s:%8s %8i %8i %8i %8i %8i\n",
	     datasetName.Data(),i,bookName.Data(),fs->fFILESET_NAME.Data(),
	     nev,rmin,emin,rmax,emax);

      nfiles_tot += nfiles;
      nev_tot    += nev;
      size_tot   += size;
    }
    else {
      printf("%s.%04d  dfc  %s:%8s %8i %8i %8i  Something is wrong here!\n",
	     datasetName.Data(),i,bookName.Data(),fs->fFILESET_NAME.Data(),
	     -1, -1,-1);
      
    }
  }
  printf("#-------------------------------------------------------------------------------\n");
  printf("# total: N(ev) = %8i N(fl) = %5i N(fs) = %4i sz = %8.3f GB\n", 
	 nev_tot, nfiles_tot, nfs, size_tot/1.e9);
  printf("#-------------------------------------------------------------------------------\n");

  Disconnect();
}

//_____________________________________________________________________________
void TCdfOracle::PrintCalibRuns(const char* Table, const char* DataStatus) {
  // print calibration runs for given table

  TString query;

  query = "select * from calibrunlists where calib_table='";

  TString tab = Table;
  tab.ToUpper();

  query += tab;
  query += "' and data_status='";

  tab = DataStatus;
  tab.ToUpper();

  query += tab;
  query += "'";

  printf("%s\n",query.Data());
  Query(query.Data());
  Disconnect();
}

//_____________________________________________________________________________
void TCdfOracle::PrintTriggerPaths(Int_t RunNumber) {
  TSQLResult* res;
  QueryTriggerPaths(RunNumber,res);
  PrintResult(res);
  delete res;
  Disconnect();
}

//_____________________________________________________________________________
void TCdfOracle::PrintTriggers(Int_t RunNumber) {
  TSQLResult* res;
  QueryTriggers(RunNumber,res);
  PrintResult(res);
  delete res;
  Disconnect();
}

//_____________________________________________________________________________
void TCdfOracle::PrintL123(Int_t RunNumber) {
  TSQLResult* res;
  QueryL123(RunNumber,res);
  PrintResult(res);
  delete res;
  Disconnect();
}

//_____________________________________________________________________________
void TCdfOracle::PrintBeamConditions(Int_t Run1, Int_t Run2) {
  // print beam conditions for the all the runs Run1 <= run < Run2

  TObjArray* list = new TObjArray(100);

  if (Run2 == -1) Run2 = Run1;

  GetBeamConditions(list,Run1,Run2);

  int nruns = list->GetEntriesFast();

  printf("----------------------------------------------------------------");
  printf("--------------------------------------------------------------\n");
  printf(" run#   store          Date              Energy      L    L(live) ");
  printf("  IL    IL(live)     PLoss    APLoss  ");
  printf(" Svrad0   Svrad1 Svrad2   Svrad3  \n");
  printf("----------------------------------------------------------------");
  printf("----------------------------------------------------------------\n");

  char text[100];
  for (int i=0; i<nruns; i++) {
    TBeamConditions* bc = (TBeamConditions*) list->At(i);
    printf("%7i ",bc->fRunNumber);
    printf("%5i ",bc->fTevStore);
    strcpy(text,ctime((const time_t*) &bc->fFrontendTime));
    text[strlen(text)-1] = 0;
    printf("%24s ",text);
    printf("%8.3f ",bc->fTevEnergy);
    printf("%7.3f ",bc->fB0Luminosity);
    printf("%7.3f ",bc->fB0LiveLuminosity);
    printf("%9.3f ",bc->fB0IntegratedLumi);
    printf("%9.3f ",bc->fB0IntegratedLiveLumi);
    printf("%11.3f ",bc->fB0ProtonLosses);
    printf("%10.3f ",bc->fB0AntiProtonLosses);
    printf("%8.3f ",bc->fSvrad0);
    printf("%8.3f ",bc->fSvrad1);
    printf("%8.3f ",bc->fSvrad2);
    printf("%8.3f ",bc->fSvrad3);
    printf("\n");
  }

  list->Delete();
  delete list;
}

//_____________________________________________________________________________
void TCdfOracle::PrintRunSection(Int_t RunNumber, Int_t EventNumber) {
  TCdf2RunSections rs;
  int rc;

  rc = GetRunSection(RunNumber,EventNumber,&rs);
  if (rc == 0) {
    printf(" run_number section_number low_event  high_event \n");
    printf("%10i %10i %10i %10i\n",
	   rs.fRUN_NUMBER,
	   rs.fSECTION_NUMBER,
	   rs.fLOW_EVENT,
	   rs.fHIGH_EVENT);
  }
  else {
    printf(" ** not found\n");
  }
}


//_____________________________________________________________________________
void TCdfOracle::PrintTriggerConditions(const char* TriggerName, 
					Int_t       Level,
					Int_t       Run1, 
					Int_t       Run2) {

  // print rates for a given trigger for the all the runs Run1 <= run <= Run2

  if (Run2 == -1) Run2 = Run1;

  TObjArray* list = new TObjArray(100);
  GetTriggerConditions(TriggerName,Level,list,Run1,Run2);

  int ndata = list->GetEntriesFast();

  printf("----------------------------------------------------------------");
  printf("----------------------------\n");
  printf("   run  Trigger              Bit          FrontendTime          ");
  printf(" Unpresc      Presc     Live\n");
  printf("----------------------------------------------------------------");
  printf("----------------------------\n");

  char text[100];
  for (int i=0; i<ndata; i++) {
    TTriggerConditions* tc = (TTriggerConditions*) list->At(i);
    printf("%7i ",tc->fRunNumber);
    printf("%-20s ",tc->fName.Data());
    //    printf("%3i",tc->fLevel);
    printf("%3i   ",tc->fBit);
    strcpy(text,ctime((const time_t*) &tc->fFrontendTime));
    text[strlen(text)-1] = 0;
    printf("%24s ",text);
    printf("%10i ",tc->fUnprescaled);
    printf("%10i ",tc->fPrescaled);
    printf("%10i ",tc->fLive);
    printf("\n");
  }

  list->Delete();
  delete list;
}

//_____________________________________________________________________________
void TCdfOracle::PrintOpenSessions() {
  // print currently open sessions

  TObjArray   list;

  GetListOfOpenSessions(&list);

  int ns = list.GetEntries();

  int banner_printed = 0;

  for (int i=0; i<ns; i++) {
    TOracleSession* s = (TOracleSession*) list.At(i);
    if (! banner_printed) {
      banner_printed = 1;
      s->Print("banner");
    }
    s->Print("data");
  }
}

//_____________________________________________________________________________
void TCdfOracle::PrintListOfSetRunMaps(Int_t Jobset) {
  // print currently open sessions

  TObjArray   list;

  GetListOfSetRunMaps(Jobset,&list);

  int ns = list.GetEntries();

  int banner_printed = 0;

  for (int i=0; i<ns; i++) {
    TSetRunMaps* s = (TSetRunMaps*) list.At(i);
    if (! banner_printed) {
      banner_printed = 1;
      s->Print("banner");
    }
    s->Print("data");
  }
}

//_____________________________________________________________________________
void TCdfOracle::PrintTrigger(const char* Name, Int_t Level, Int_t RunNumber) {
  TSQLResult* res;
  Int_t       bit;

  TStnTrigger* trigger = new TStnTrigger();

  GetTrigger(Name,Level,RunNumber,trigger);

  printf("---------------------------------------------------\n");
  printf(" run #  trig_name               level bit  tag  ID\n");
  printf("---------------------------------------------------\n");
  
  printf("%8i "  ,RunNumber);
  printf("%-20s ",trigger->Name().Data());
  printf("%5i "  ,trigger->Level());
  printf("%5i "  ,trigger->Bit());
  printf("%3i "  ,trigger->Tag());
  printf("%5i "  ,trigger->Id());
  printf("\n");
}


//_____________________________________________________________________________
void TCdfOracle::PrintTriggerBits(Int_t RunNumber) {
  TSQLResult* res;
  QueryTriggerBits(RunNumber,res);

  TObjArray l1_trig(128);
  TObjArray l2_trig(128);
  TObjArray l3_trig(256);

  TOracleRow* row;
  char* line;

  int bit;

  int max_bit = -1;
  while ((row = (TOracleRow*) res->Next())) {

    for (int i=0; i<res->GetFieldCount(); i++) {
      bit = *(int*)row->GetFieldData(0);

      if (max_bit < bit) max_bit = bit;

      line = row->GetFieldData(1);
      for (int k=strlen(line)-1; (k>=0) && (line[k]==' '); k--) line[k] = 0;
      if (line[0] == '1') l1_trig.AddAt(new TObjString(line),bit);
      if (line[0] == '2') l2_trig.AddAt(new TObjString(line),bit);
      if (line[0] == '3') l3_trig.AddAt(new TObjString(line),bit);
    }
  }
  
  printf("#--------------------------------------------------------------------");
  printf("---------------------\n");
  printf("# run %i trigger table: ",RunNumber);
  PrintTriggerTable(RunNumber);
  printf(" bit            L1 trigger      ");
  printf("                         L2 trigger                L3 trigger \n");
  printf("#--------------------------------------------------------------------");
  printf("---------------------\n");

  for (int i=0; i<=max_bit; i++) {
    printf("%3i",i);
    if (l1_trig.At(i)) {
      printf("  %-50s", ((TObjString*) l1_trig.At(i))->String().Data());
    }
    else {
      printf("  %-50s","");
    }

    if (l2_trig.At(i)) {
      printf(" %-50s", ((TObjString*) l2_trig.At(i))->String().Data());
    }
    else {
      printf(" %-50s","");
    }

    if (l3_trig.At(i)) {
      printf(" %-50s", ((TObjString*) l3_trig.At(i))->String().Data());
    }
    else {
      printf(" %-50s","");
    }
    printf("\n");
  }
  delete res;
}

//_____________________________________________________________________________
void TCdfOracle::PrintResult(TSQLResult* res) {
  // print result of a given SQL query

  TOracleRow* row;
  char   *line;

  int n_fields = res->GetFieldCount();

  while ((row = (TOracleRow*) res->Next())) {

    for (int i=0; i<n_fields; i++) {
      int type = row->GetFieldType(i);
//        printf("---- %i %i %s ,",type,row->GetFieldLength(i),row->GetField(i) );
      if (type == 3) {
	printf("%8i ",/* *row->GetFieldLength(i), */ *((int*)row->GetFieldData(i)));
      }
      else if (type == 4) {
	printf("%12.6f ",*((float*)row->GetFieldData(i)));
      }
      else {
	line = row->GetFieldData(i);
	int len = strlen(line);
	for (int k=len-1; (k>=0) && (line[k]==' '); k--) {
	  line[k] = 0;
	}
	printf(" %-20s",line);
      }
      //      printf(")");
    }
    printf("\n");
    delete row;
  }
}


//-----------------------------------------------------------------------------
void TCdfOracle::CalculateOfflineLuminosity(Int_t Run1, 
					    Int_t Run2, 
					    Float_t MinLum) 
{
  // calculate lumi for a set of runs...

  TObjArray* list_of_runs         = new TObjArray(1000);
  TObjArray* list_of_run_sections = new TObjArray(1000);

  TStnRunSummary*   run_sum;
  TCdf2RunSections* run_sec;

  int flag = ForceDisconnect();
  SetForceDisconnect(0);
  GetListOfGoodRuns  (list_of_runs,Run1,Run2);
  GetListOfRunSections(Run1,Run2,list_of_run_sections);

  int nruns = list_of_runs->GetEntriesFast();
  int nrs   = list_of_run_sections->GetEntriesFast();

  //  SetVerbose(1);

  Float_t lum_run_offline;
  Int_t   run_number;

  Float_t lum_sum_online  = 0;
  Float_t lum_sum_offline = 0;

  for (int irun=0; irun<nruns; irun++) {
    run_sum = (TStnRunSummary*) list_of_runs->At(irun);
    run_number = run_sum->RunNumber();
    TString&  ttn = run_sum->TriggerTableName();
    lum_run_offline = 0.;
    if ( (run_sum->GoodRunStatus() == 1) && (run_sum->LumiTape() > MinLum)) {
//-----------------------------------------------------------------------------
//  good run with enough luminosity
//-----------------------------------------------------------------------------
      if ((ttn.Index("PHYSICS") == 0) && (ttn.Index("TEST") < 0)) {
//-----------------------------------------------------------------------------
//  physics run, calculate offline luminosity
//-----------------------------------------------------------------------------
	for (int irs=0; irs<nrs; irs++) {
	  run_sec = (TCdf2RunSections*) list_of_run_sections->At(irs);

				// look at the runsections fron a given run only

	  if (run_sec->fRUN_NUMBER == run_number) {
	    if (run_sec->fLUM_INTEGRAL_ONLINE >= 0) {
	      lum_sum_online  += run_sec->fLUM_INTEGRAL_ONLINE;
	    }
	    if (run_sec->fLUM_INTEGRAL_OFFLINE >= 0) {
	      lum_run_offline += run_sec->fLUM_INTEGRAL_OFFLINE;
	    }
	  }
	}
//-----------------------------------------------------------------------------
//  in case offline lumi is not defined, use online luminosity
//-----------------------------------------------------------------------------
	if (lum_run_offline > 0.) {
	  lum_sum_offline += lum_run_offline;
	}
	else {
	  printf(" run = %8i *WARNING* Offline lumi = 0, use online lumi %10.3f\n",
		 run_number, run_sum->LumiTape());
	  lum_sum_offline += run_sum->LumiTape();
	}
      }
    }

    if (Verbose()) {
      printf(" run, trig_table, good_run_status, lumi_live, offline_lumi: ");
      printf(" %8i %-30s %2i %10.3f %10.3f\n",
	     run_number,
	     ttn.Data(),
	     run_sum->GoodRunStatus(),
	     run_sum->LumiTape(),
	     lum_run_offline);
    }

  }
  
  printf("lum_sum_online, lum_sum_offline = %10.3f  %10.3f\n",
	 lum_sum_online, lum_sum_offline);

  list_of_runs->Delete();
  delete list_of_runs;

  list_of_run_sections->Delete();
  delete list_of_run_sections;

  SetVerbose(0);
  SetForceDisconnect(flag);

}

//_____________________________________________________________________________
void TCdfOracle::PrintCatalog(const char* Book, const char* Dataset,
			      int Run1, int Run2)
{
  //----------------------------------------------------------------------------
  // Print a complete catalog for the given dataset
  //----------------------------------------------------------------------------

  // first determine whether we are updateing
  bool    extending = false;
  int     rc;
  TString cmd;
  TString preText;
  TString postText;

  cmd = TString("ls ") 
    + TString(gSystem->Getenv("HOME")) + TString("/cafdfc/") + TString(Book)
    + TString("/") + TString(Dataset) + TString("/AAA_CATALOG.* >& /dev/null");
  printf("Exists? %s\n",cmd.Data());
  rc = gSystem->Exec(cmd);
  if (rc == 0) {
    printf(" Dataset exists!  -> extend existing one\n\n");
    extending = true;
  }
  else
    printf(" Dataset does not exist!  -> create new one\n\n");

  // Remove existing junk from this directory
  rc = gSystem->Exec(TString("rm -f PreText Contents AAA_CATALOG.html"));

  // Create the new complete content for the AAA_CATALOG.html file
  FILE *f;
  f = fopen("Contents","w");
  printf("Printing: Contents\n");

  if (! extending) {
    // Print header
    fprintf(f,"<pre>\n");
    fprintf(f,"#---------------------------------------------");
    fprintf(f,"----------------------------------\n");
    fprintf(f,"# MetaName Location Book:Fileset  nEvents  LoRun    LoEvt");
    fprintf(f,"    HiRun    HiEvt\n");
    fprintf(f,"#---------------------------------------------");
    fprintf(f,"----------------------------------\n");
  }

  TObjArray listOfFilesets;
  TObjArray listOfFiles;

  // Make sure to select proper run range
  if (Run2 < 0)
    Run2 = Run1;
  
  //----------------------------------------------------------------------------
  // Loop over the files sets and calculate some statistics
  //----------------------------------------------------------------------------
  GetListOfFilesets((TString(Dataset)+TString(":")+TString(Book)).Data(),
		    Run1,Run2,&listOfFilesets);

  // Initialize the proper values before start
  int   rmin, rmax, emin, emax, nev;
  int   nfs       = listOfFilesets.GetEntriesFast();
  int   nfilesTot = 0;
  int   nevTot    = 0;
  float size      = 0.0;
  float sizeTot   = 0.0;
  char  s[200];
  TString contents;

  // Let the loop begin
  for (int i=0; i<nfs; i++) {
    
    // Extract a CDF fileset of the list
    TCdf2Filesets* fs = (TCdf2Filesets*) listOfFilesets.At(i);

    if (fs->fFILE_COUNT > 0) {

      //------------------------------------------------------------------------
      // Loop over the files and calculate some statistics
      //------------------------------------------------------------------------
      GetListOfFiles(&listOfFiles,
		     (TString(Dataset)+TString(":")+TString(Book)).Data(),
		     fs->fFILESET_NAME);

      // Initialize the proper values before start
      emin  = 10000000;
      emax  = -1;
      rmin  = 10000000;
      rmax  = -1;
      nev   = 0;
      size  = 0;

      // Let the loop begin
      for (int ifile=0; ifile<listOfFiles.GetEntriesFast(); ifile++) {

	// Extract a CDF file from the list
	TCdf2Files* file = (TCdf2Files*) listOfFiles.At(ifile);
	nev  += file->fEVENT_COUNT;
	size += file->fFILE_SIZE;

	// Lowest run number and corresponding lowest event number
	if      (rmin > file->fLOW_RUN) {
	  rmin = file->fLOW_RUN;
	  emin = file->fLOW_EVENT;
	}
	else if (rmin == file->fLOW_RUN && emin >= file->fLOW_EVENT)
	  emin = file->fLOW_EVENT;

	// Highest run number and corresponding highest event number
	if      (rmax < file->fHIGH_RUN) {
	  rmax = file->fHIGH_RUN;
	  emax = file->fHIGH_EVENT;
	}
	else if (rmax == file->fHIGH_RUN && emax <= file->fHIGH_EVENT)
	  emax = file->fHIGH_EVENT;
      }

      // Print information for this fileset
      sprintf(s,"%s.%04d  dfc  %s:%8s %8i %8i %8i %8i %8i\n",
	      Dataset,i,Book,fs->fFILESET_NAME.Data(),nev,rmin,emin,rmax,emax);
      fprintf(f,"%s",s);
      contents += TString(s);

      nfilesTot += listOfFiles.GetEntriesFast();
      nevTot    += nev;
      sizeTot   += size;

      // Done with the files
      listOfFiles.Delete();
    }
    else {
      fprintf(f,"%s.%04d  dfc  %s:%8s %8i %8i %8i  Something is wrong here!\n",
	     Dataset,i,Book,fs->fFILESET_NAME.Data(),-1,-1,-1);
      
    }
  }
  fprintf(f,"#---------------------------------------------------------------");
  fprintf(f,"----------------\n");
  fprintf(f,"# total: N(ev) = %8i N(fl) = %5i N(fs) = %4i sz = %8.3f GB\n", 
	 nevTot, nfilesTot, nfs, sizeTot/1.e9);
  fprintf(f,"#---------------------------------------------------------------");
  fprintf(f,"----------------\n");
  fprintf(f,"</pre>\n");

  fclose(f);

  // Done with the filesets
  listOfFilesets.Delete();

  //----------------------------------------------------------------------------
  // Loop over the files and write summary
  //----------------------------------------------------------------------------
  printf("Printing: %s\n",(TString(Dataset)+TString(".files")).Data());
  f = fopen((TString(Dataset)+TString(".files")).Data(),"w");

  GetListOfFiles(&listOfFiles,
		 (TString(Dataset)+TString(":")+TString(Book)).Data(),
		 Run1,Run2);
  
  // Initialize the proper values before start
  float lumOnl        = 0;
  float lumOffl       = 0;
  int   iFileSet      = -1;
  TString lastFS("");
  nev                 = 0;
  sizeTot             = 0;
  
  fprintf(f,"#---------------------------------------------------------------");
  fprintf(f,"----------------------------------------\n");
  fprintf(f,"# fileset   filename               size       date     time     ");
  fprintf(f," nev  lo_run    lo_evt  hi_run    hi_evt\n");
  fprintf(f,"#---------------------------------------------------------------");
  fprintf(f,"----------------------------------------\n");

  for (int i=0; i<listOfFiles.GetEntriesFast(); i++) {

    TCdf2Files *fr = (TCdf2Files*) listOfFiles.At(i);

    if (fr->fFILESET_NAME != lastFS) {
      lastFS = fr->fFILESET_NAME;
      iFileSet++;
    }
    
    fprintf(f,"%s.%04d %17s %9.3f",
	   Dataset,iFileSet,
	   fr->fFILE_NAME.Data(),
	   fr->fFILE_SIZE);
    TDatime t(fr->fCREATE_DATE);
    //t.Print();
    fprintf(f," %4d-%02d-%02d %02d:%02d:%02d",
	   t.GetYear(),t.GetMonth(),t.GetDay(),
	   t.GetHour(),t.GetMinute(),t.GetSecond());
    

    fprintf(f," %8i %7i %9i %7i %9i\n",
	   fr->fEVENT_COUNT,
	   fr->fLOW_RUN,
           fr->fLOW_EVENT,
	   fr->fHIGH_RUN,
	   fr->fHIGH_EVENT);

    // Calculate summary data
    nev     += fr->fEVENT_COUNT;
    lumOnl  += fr->fLUM_SUM_ONLINE;
    lumOffl += fr->fLUM_SUM_OFFLINE;
    sizeTot += fr->fFILE_SIZE;
  }
  fprintf(f,"#---------------------------------------------------------------");
  fprintf(f,"----------------------------------------\n");
  fprintf(f,"# total %10i           %10.3f                             %8i\n",
  	 listOfFiles.GetEntriesFast(),sizeTot,nev);
  fprintf(f,"#---------------------------------------------------------------");
  fprintf(f,"----------------------------------------\n");
  fclose(f);

  // Done with the files
  listOfFiles.Delete();

  Disconnect();

  //----------------------------------------------------------------------------
  // Get Pre contents text from existing file
  //----------------------------------------------------------------------------
  if (extending) {
    cmd = TString("grep -B 200 ^") + TString(Dataset) + TString(".0000 ")
      + TString(gSystem->Getenv("HOME")) + TString("/cafdfc/") + TString(Book)
      + TString("/") + TString(Dataset) + TString("/AAA_CATALOG.html")
      + TString("|grep -v ^") + TString(Dataset) + TString(">PreText");
    printf("PreText: %s\n",cmd.Data());
    rc = gSystem->Exec(cmd);
  }
  else
    rc = gSystem->Exec(TString("touch PreText"));

  rc = gSystem->Exec(TString("cat PreText Contents > AAA_CATALOG.html"));
  rc = gSystem->Exec(TString("cat AAA_CATALOG.html"));

  // Remove remainders
  rc = gSystem->Exec(TString("rm PreText Contents"));

  //----------------------------------------------------------------------------
  // Making directories if needed
  //----------------------------------------------------------------------------
  if (! extending) {
    cmd = TString("mkdir -p ") + TString(gSystem->Getenv("HOME"))
      + TString("/cafdfc/") + TString(Book);
    printf("Mkdir: %s\n",cmd.Data());
    rc = gSystem->Exec(cmd);
    cmd = TString("mkdir -p ") + TString(gSystem->Getenv("HOME"))
      + TString("/cafdfc/") + TString(Book) + TString("/") + TString(Dataset);
    printf("Mkdir: %s\n",cmd.Data());
    rc = gSystem->Exec(cmd);
  }

  //----------------------------------------------------------------------------
  // Move the files into the final location
  //----------------------------------------------------------------------------
  cmd = TString("mv AAA_CATALOG.html ") + TString(gSystem->Getenv("HOME"))
    + TString("/cafdfc/") + TString(Book) + TString("/") + TString(Dataset);
  printf("Move: %s\n",cmd.Data());
  rc = gSystem->Exec(cmd);
  //printf("%s",contents.Data());
  cmd = TString("mv ") + TString(Dataset) + TString(".files ")
    + TString(gSystem->Getenv("HOME")) + TString("/cafdfc/") + TString(Book) 
    + TString("/") + TString(Dataset);
  printf("Move: %s\n",cmd.Data());
  rc = gSystem->Exec(cmd);

  return;
}