//
// Ray Culbertson and Hartmut Stadie
// 6/4/01 - change branch names - make them unique
// 7/4/01 - add tev store number 


#include "cstdlib"
#include <string> 
#include <iostream>
#include <iomanip>
#include <fstream>

#include "Alignment/CotBeam.hh"
#include "Alignment/SvxBeam.hh"

#include "TROOT.h"
#include "TFile.h"
#include "TTree.h"
#include "CalibDB/RunListDefs.hh"
#include "CalibDB/UsedSetKey.hh"
#include "CalibDB/UsedSetDefs.hh"
#include "CalibDB/ValidSetKey.hh"
#include "CalibDB/ValidSetDefs.hh"
#include "RunConfigDB/BEAM_CONDITIONS.Defs.hh"
#include "DBManager/ConControl.hh"
#include "DBManager/IoEntry.hh"

using std::string;
using std::ostringstream;


struct cotBeamEntry {
  float cotBeamX, cotBeamY, cotSlopeX, cotSlopeY;
  int cotTableVersion,cotTableStatus;
  float cotBeamXSigma, cotBeamYSigma, cotSlopeXSigma, cotSlopeYSigma;
  float cotWidthX, cotWidthY, cotWidthXY, cotBeamZ, cotWidthZ;
  float cotBeamXRate, cotBeamYRate, cotSlopeXRate, cotSlopeYRate;
  float cotWidthXRate, cotWidthYRate, cotWidthXYRate;
  float cotBeamZRate, cotWidthZRate;
  float cotMinimZFit, cotWidthZFit, cotBstarZFit, cotZzeroZFit;
  float cotMinimZFitRate, cotWidthZFitRate, cotBstarZFitRate, cotZzeroZFitRate;
  float cotFitCov00, cotFitCov01, cotFitCov02, cotFitCov03, cotFitCov11;
  float cotFitCov12, cotFitCov13, cotFitCov22, cotFitCov23, cotFitCov33;
  float cotStatistics0, cotStatistics1;
  int cotFlag0, cotFlag1;
  float cotSpare0, cotSpare1, cotSpare2, cotSpare3;
};

struct svxBeamEntry {
  float svxBeamX, svxBeamY, svxSlopeX, svxSlopeY;
  int svxTableVersion,svxTableStatus;
  float svxBeamXSigma, svxBeamYSigma, svxSlopeXSigma, svxSlopeYSigma;
  float svxWidthX, svxWidthY, svxWidthXY;
  float svxBeamZ, svxWidthZ;
  float svxBeamXRate, svxBeamYRate, svxSlopeXRate, svxSlopeYRate;
  float svxWidthXRate, svxWidthYRate, svxWidthXYRate;
  float svxBeamZRate, svxWidthZRate;
  float svxMinimZFit, svxWidthZFit, svxBstarZFit, svxZzeroZFit;
  float svxMinimZFitRate, svxWidthZFitRate, svxBstarZFitRate, svxZzeroZFitRate;
  float svxEmittXFit, svxBstarXFit, svxZzeroXFit;
  float svxEmittYFit, svxBstarYFit, svxZzeroYFit;
  float svxEmittXRate, svxBstarXRate, svxZzeroXRate;
  float svxEmittYRate, svxBstarYRate, svxZzeroYRate;
  float svxFitCov00, svxFitCov01, svxFitCov02, svxFitCov03, svxFitCov11;
  float svxFitCov12, svxFitCov13, svxFitCov22, svxFitCov23, svxFitCov33;
  float svxStatistics0, svxStatistics1;
  int Flag0, Flag1;
  float svxSpare0, svxSpare1, svxSpare2, svxSpare3;
  int nTime;
  int chanTime[100],statTime[100];
  float x0Time[100],y0Time[100],xsTime[100],ysTime[100];
};

//turn table status into a number -implemented below
int statusNumber(const string status);

// get storeNumber for specified run -implemented below
int storeNumber(int run);

int main(int argc, char* argv[])
{

  TROOT root("MyRoot","ROOT for BeamNTupler");
  TFile *file = NULL;
  TTree *tree = NULL;

  bool qavail = false;
  bool qsvx = true;
  bool qcot = true;
  bool qprint = true;
  bool qfull = false;
  bool qbrief = false;
  bool qloadused = false;
  bool qntuple = false;
  char outfile[100];

  bool writecid = false;
  char cidtextfile[100]; 
  std::ofstream cidfile;

  char dbid[50] = "ofotl_prd_read";
  char status[50] = "NONE";
  int alg = -1;
  int version = -1;
  int source = -1;
  int history = -1;
  int minrun = -1;
  int maxrun = -1;
  int store = -1;

  int apt = 1;
  while(apt<argc) {

    if (!strncmp(argv[apt],"-avail",5)) {
      qavail = true;
    } else if (!strncmp(argv[apt],"-nosvx",5)) {
      qsvx = false;
    } else if (!strncmp(argv[apt],"-nocot",5)) {
      qcot = false;
    } else if (!strncmp(argv[apt],"-noprint",5)) {
      qprint = false;
    } else if (!strncmp(argv[apt],"-full",5)) {
      qfull = true;
    } else if (!strncmp(argv[apt],"-brief",5)) {
      qbrief = true; 
    } else if (!strncmp(argv[apt],"-usedset",5)) {
      qloadused = true;
    } else if (!strncmp(argv[apt],"-ntuple",5)) {
      strncpy(outfile,argv[++apt],50);
      qntuple = true;
    } else if (!strncmp(argv[apt],"-cidfile",5)) {
      strncpy(cidtextfile,argv[++apt],50);
      writecid = true;
    } else if (!strncmp(argv[apt],"-dbid",5)) {
      strncpy(dbid,argv[++apt],50);
    } else if (!strncmp(argv[apt],"-algorithm",4)) {
      alg = atoi(argv[++apt]);
    } else if (!strncmp(argv[apt],"-version",4)) {
      version = atoi(argv[++apt]);
    } else if (!strncmp(argv[apt],"-source",4)) {
      source = atoi(argv[++apt]);
    } else if (!strncmp(argv[apt],"-status",4)) {
      strncpy(status,argv[++apt],30);
    } else if (!strncmp(argv[apt],"-history",4)) {
      history = atoi(argv[++apt]);
    } else if (!strncmp(argv[apt],"-store",6)) {
      store = atoi(argv[++apt]);
      
    } else if (!strncmp(argv[apt],"-help",100) || !strncmp(argv[apt],"-h",100) 
	|| !strncmp(argv[apt],"--help",100)  ) {
      std::cout << " Usage:" << std::endl;
      std::cout << " " << argv[0] 
	   << "  [OPTIONS] " << std::endl;
      std::cout << " " << argv[0] 
	   << "  [OPTIONS] RUN_NUMBER " << std::endl;
      std::cout << " " << argv[0] 
	   << "  [OPTIONS] MIN_RUN_NUMBER MAX_RUN_NUMBER " << std::endl;

      std::cout << " -avail              print available runs" << std::endl;
      std::cout << " -nosvx              ignore SVX beamline" << std::endl;
      std::cout << " -nocot              ignore COT beamline" << std::endl;
      std::cout << " -noprint            do not dump data to screen" << std::endl;
      std::cout << " -full               print/ntuple all variables" << std::endl;
      std::cout << " -brief              print/ntuple minimal variables" << std::endl;
      std::cout << " -usedset            show UsedSet entries as well" << std::endl;
      std::cout << " -ntuple FILE      write output to ntuple (default = none)" << std::endl;
      std::cout << " The following require expert information..." << std::endl;
      std::cout << " -dbid DATABASEID      database (default = ofotl_prd)" << std::endl;
      std::cout << " -algorithm ALGORITHM  select on algorithm code (default = best)" << std::endl;
      std::cout << " -history HISTORY      select on history code (default = best)" << std::endl;
      std::cout << " -source SOURCE        select on data source (default = best)" << std::endl;
      std::cout << " -status STATUS        select on database status (default = best)" << std::endl;
      std::cout << " -version VERSION      select on version number (default = best)" << std::endl;
      std::cout << " -store STORE          scan for all runs belonging to store STORE" << std::endl;
      std::cout << " " << std::endl;
      std::cout << " Typical usage:" << std::endl;
      std::cout << " Print run 123456: " << argv[0] << " -full 123456" << std::endl;
      std::cout << " Scan runs: " << argv[0] << " -brief 100000 100100" << std::endl;
      std::cout << " Make ntuple: " << argv[0] << " -ntuple beam.ntp" << std::endl;
      std::cout << " Selections are based on a best entry algorithm and " << std::endl
	   << " may not be the same as the used/valid set selection" << std::endl;
      std::cout << std::endl;
      return 0;
    } else if (!strncmp(argv[apt],"-",1)) {
      std::cout << "Unknown option '" << argv[apt] << "'" << std::endl;
      std::cout << "Try " << argv[0] << " -help " << std::endl;
      return 1;
    } else {   // must be run numbers
      int i = atoi(argv[apt]);
      if(i<1 || i>1000000) {
	std::cout << "Bad run number '" << argv[apt] << "'" << std::endl;
	std::cout << "Try " << argv[0] << " -help " << std::endl;
	return 1;
      }
      if(minrun==-1) {
	minrun = i; 
	maxrun = i;
      } else {
	maxrun = i;
      }
    } // end multiple ifs

    apt++;

  } // end while loop

  if((minrun==-1) || (store != -1)){   
    // no range specified at all
    // could also find good range from db...
    minrun=100000;
    maxrun=200000;
  }
  if(store != -1) 
    {
      std::cout << "Reading from "<<dbid<<" all runs for store " << store <<std::endl;
    }
  std::cout << "Reading from "<<dbid<<" range: "<<minrun<<"-"<<maxrun<<std::endl;


  // get the list of available entries

  int* goodrunc;
  int ngoodc=0;
  int* goodruns;
  int ngoods=0;

  RunList_mgr runIom(dbid,"RunList");
  if( !runIom.isValid() ) {std::cerr<< "Error opening RunList database" << std::endl;}
  RunListKey rlk("CotBeamPosition","UNDEFINED",
                  Run::undefined,Version::undefined,
                  PrimType::undefined, "UNDEFINED");
  RunList_var row;
  if(runIom.get(rlk,row)!=Result::success) {
    std::cerr << "Failure of runIom.get() to retrieve db contents" << std::endl;  }

  goodrunc = new int[row->size()];
  for(RunList::iterator iter=row->begin(); iter!=row->end(); iter++) {
    goodrunc[ngoodc++] = iter->run();
  }

  rlk.setTable("SvxBeamPosition");
  if(runIom.get(rlk,row)!=Result::success) {
    std::cerr << "Failure of runIom.get() to retrieve db contents" << std::endl;  }

  goodruns = new int[row->size()];
  for(RunList::iterator iter=row->begin(); iter!=row->end(); iter++) {
    goodruns[ngoods++] = iter->run();
  }

  // if asked for the list of available runs, then print those and quit
  if(qavail) {
    for(int i=0; i<ngoodc; i++) {
      if(goodrunc[i]>minrun && goodrunc[i]<maxrun) std::cout << goodrunc[i] << std::endl;
    }
    for(int i=0; i<ngoods; i++) {
      if(goodruns[i]>minrun && goodruns[i]<maxrun) std::cout << goodruns[i] << std::endl;
    }
    return 0;
  } // end avail

  std::cout << "Entries   COT: "<< ngoodc <<"  SVX: "<< ngoods << std::endl;


  CotBeam cotbeam(dbid);
  cotbeam.setStatus(status);
  cotbeam.setHistoryCode(history);
  cotbeam.setAlgorithm(alg);
  cotbeam.setSource(source);
  cotbeam.printLevel(1);
  if(qbrief)  cotbeam.printLevel(0);
  if(qfull)   cotbeam.printLevel(2);
  if(!qprint) cotbeam.printLevel(0);

  SvxBeam svxbeam(dbid);
  svxbeam.setStatus(status);
  svxbeam.setHistoryCode(history);
  svxbeam.setAlgorithm(alg);
  svxbeam.setSource(source);
  svxbeam.printLevel(1);
  if(qbrief)  svxbeam.printLevel(0);
  if(qfull)   svxbeam.printLevel(2);
  if(!qprint) svxbeam.printLevel(0);

  cotBeamEntry cEntry;
  svxBeamEntry sEntry;
  int runEntry[2];//0: run 1: store


  if(qntuple) {
    file = new TFile(outfile,"RECREATE","beam positions");
    tree = new TTree("BEAMPOS","beam positions");

    tree->Branch("Run",&runEntry,"run/I:store/I");

    if(qcot) {
      tree->Branch("cEntry0",&cEntry.cotBeamX,
	       "cotBeamX:cotBeamY:cotSlopeX:cotSlopeY");
      if(!qbrief) {
	tree->Branch("cEntry1",&cEntry.cotTableVersion,
	       "cotTableVersion/I:cotTableStatus");
	tree->Branch("cEntry2",&cEntry.cotBeamXSigma,
	       "cotBeamXSigma:cotBeamYSigma:cotSlopeXSigma:cotSlopeYSigma");
	tree->Branch("cEntry3",&cEntry.cotWidthX,
               "cotWidthX:cotWidthY:cotWidthXY:cotBeamZ:cotWidthZ");
      }
      if(qfull) {
	tree->Branch("cEntry4",&cEntry.cotBeamXRate,
               "cotBeamXRate:cotBeamYRate:cotSlopeXRate:cotSlopeYRate");
	tree->Branch("cEntry5",&cEntry.cotWidthXRate,
               "cotWidthXRate:cotWidthYRate:cotWidthXYRate");
	tree->Branch("cEntry6",&cEntry.cotBeamZRate,
               "cotBeamZRate:cotWidthZRate");
      }
      if(!qbrief) {
	tree->Branch("cEntry7",&cEntry.cotMinimZFit,
               "cotMinimZFit:cotWidthZFit:cotBstarZFit:cotZzeroZFit");
      }
      if(qfull) {
	tree->Branch("cEntry8",&cEntry.cotMinimZFitRate,
      "cotMinimZFitRate:cotWidthZFitRate:cotBstarZFitRate:cotZzeroZFitRate");
	tree->Branch("cEntry9",&cEntry.cotFitCov00,
               "cotFitCov00:cotFitCov01:cotFitCov02:cotFitCov03:cotFitCov11");
	tree->Branch("cEntrya",&cEntry.cotFitCov12,
               "cotFitCov12:cotFitCov13:cotFitCov22:cotFitCov23:cotFitCov33");
      }
      if(!qbrief) {
	tree->Branch("cEntryb",&cEntry.cotStatistics0,
               "cotStatistics0:cotStatistics1");
	tree->Branch("cEntryc",&cEntry.cotFlag0,
               "cotFlag0/I:cotFlag1");
      }
      if(qfull) {
	tree->Branch("cEntryd",&cEntry.cotSpare0,
               "cotSpare0/F:cotSpare1:cotSpare2:cotSpare3");
      }
    }  // end if cot

    if(qsvx) {
      tree->Branch("sEntry0",&sEntry.svxBeamX,
	       "svxBeamX:svxBeamY:svxSlopeX:svxSlopeY");
      if(!qbrief) {
	tree->Branch("sEntry1",&sEntry.svxTableVersion,
	       "svxTableVersion/I:svxTableStatus");
	tree->Branch("sEntry2",&sEntry.svxWidthX,
	       "svxWidthX:svxWidthY:svxWidthXY");
	tree->Branch("sEntry3",&sEntry.svxBeamZ,
	       "svxBeamZ:svxWidthZ");
      }
      if(qfull) {
	tree->Branch("sEntry4",&sEntry.svxBeamXRate,
	       "svxBeamXRate:svxBeamYRate:svxSlopeXRate:svxSlopeYRate");
	tree->Branch("sEntry5",&sEntry.svxWidthXRate,
	       "svxWidthXRate:svxWidthYRate:svxWidthXYRate");
	tree->Branch("sEntry6",&sEntry.svxBeamZRate,
	       "svxBeamZRate:svxWidthZRate");
      }
      if(!qbrief) {
	tree->Branch("sEntry7",&sEntry.svxMinimZFit,
	       "svxMinimZFit:svxWidthZFit:svxBstarZFit:svxZzeroZFit");
      }
      if(qfull) {
	tree->Branch("sEntry8",&sEntry.svxMinimZFitRate,
  "svxMinimZFitRate:svxWidthZFitRate:svxBstarZFitRate:svxZzeroZFitRate");
      }
      if(!qbrief) {
	tree->Branch("sEntry9",&sEntry.svxEmittXFit,
	       "svxEmittXFit:svxBstarXFit:svxZzeroXFit");
	tree->Branch("sEntrya",&sEntry.svxEmittYFit,
	       "svxEmittYFit:svxBstarYFit:svxZzeroYFit");
      }
      if(qfull) {
	tree->Branch("sEntryb",&sEntry.svxEmittXRate,
	       "svxEmittXRate:svxBstarXRate:svxZzeroXRate");
	tree->Branch("sEntryc",&sEntry.svxEmittYRate,
	       "svxEmittYRate:svxBstarYRate:svxZzeroYRate");
	tree->Branch("sEntryd",&sEntry.svxFitCov00,
	  "svxFitCov00:svxFitCov01:svxFitCov02:svxFitCov03:svxFitCov11");
	tree->Branch("sEntrye",&sEntry.svxFitCov12,
	  "svxFitCov12:svxFitCov13:svxFitCov22:svxFitCov23:svxFitCov33");
      }
      if(!qbrief) {
	tree->Branch("sEntryf",&sEntry.svxStatistics0,
	       "svxStatistics0:svxStatistics1");
	tree->Branch("sEntryg",&sEntry.Flag0,
	       "Flag0/I:Flag1");
      }
      if(qfull) {
	tree->Branch("sEntryh",&sEntry.svxSpare0,
	       "svxSpare0:svxSpare1:svxSpare2:svxSpare3");
      }
      if(!qbrief) {
	tree->Branch("sEntryi",&sEntry.nTime,"nTime/I");
	tree->Branch("sEntryi0",sEntry.chanTime,"chanTime[nTime]/I");
	tree->Branch("sEntryi1",sEntry.statTime,"statTime[nTime]/I");
	tree->Branch("sEntryi2",sEntry.x0Time,"x0Time[nTime]/F");
	tree->Branch("sEntryi3",sEntry.y0Time,"y0Time[nTime]/F");
	tree->Branch("sEntryi4",sEntry.xsTime,"xsTime[nTime]/F");
	tree->Branch("sEntryi5",sEntry.ysTime,"ysTime[nTime]/F");
      }
    }  // if svx

  }  // end if ntuple init

  if(writecid)
    {
      // open text file
      cidfile.open(cidtextfile, std::ios::out | std::ios::trunc);
    }

  bool svxOK,cotOK;	
  runEntry[0] = -1;
  runEntry[1] = -1;
  
  for(int run = minrun ; run <= maxrun ; ++run) {
    
    //get the used set 
    static UsedSet_mgr used_mgr(dbid,"UsedSet");
    static ValidSet_mgr valid_mgr(dbid,"ValidSet");
    
    UsedSet_var used_set;
    if(qloadused) {
      std::cout << "UsedSet entries for run " << run << ":" << std::endl;
      if(qcot) {
	UsedSetKey used_set_key(ProcessTag("PAD_PHYSICS_COTBEAM"),RunVersion(run));
	
	if(used_mgr.isValid() && (used_mgr.get(used_set_key,used_set) == Result::success)) {
	  //std::cout << "used_set set : process " <<  used_set->at(0).process() << std::endl;     
	  //std::cout << "             : jobset " <<  used_set->at(0).jobset() << std::endl; 
	  //get the valid set
	  
	  ValidSetKey valid_set_key(used_set->at(0).jobset());
	  ValidSet_var valid_set;
	  if(valid_mgr.isValid() && (valid_mgr.get(valid_set_key,valid_set) == Result::success)) {
	    //create 
	    if(cotbeam.loadCid(valid_set->at(0).cids_[0]) == 0) {
	      CotBeamPosition cBeamPos(cotbeam.getRecord());
	      if(qbrief && qprint) {
		std::ios::fmtflags iflsave = 
		  std::cout.setf(std::ios::showpoint|std::ios::fixed);
		int ipre = std::cout.precision(5);
		std::cout << "Cot" 
			  << std::setw(8) << run 
			  << std::setprecision(4)
			  << "  x(cm) " << std::setw(8) << cBeamPos.BeamX()
			  << "  y(cm) " << std::setw(8) << cBeamPos.BeamY()
			  << std::setprecision(4)
			  << "  x'(mr) " << std::setw(8) << 1000.0*cBeamPos.SlopeX()
			  << "  y'(mr) " << std::setw(8) << 1000.0*cBeamPos.SlopeY() << std::endl;
		std::cout.flags(iflsave);
		std::cout.precision(ipre);
	      }
	    }
	  }
	}
      }
      
      if(qsvx) {
	UsedSetKey used_set_key(ProcessTag("PAD_PHYSICS_SVXBEAM"),RunVersion(run));
	
	if(used_mgr.isValid() && (used_mgr.get(used_set_key,used_set) == Result::success)) {
	  //std::cout << "used_set set : process " <<  used_set->at(0).process() << std::endl;     
	  //std::cout << "             : jobset " <<  used_set->at(0).jobset() << std::endl; 
	  //get the valid set
	  
	  ValidSetKey valid_set_key(used_set->at(0).jobset());
	  ValidSet_var valid_set;
	  if(valid_mgr.isValid() && (valid_mgr.get(valid_set_key,valid_set) == Result::success)) {
	    //create 
	    if(svxbeam.loadCid(valid_set->at(0).cids_[0]) == 0) {
	      SvxBeamPosition sBeamPos(svxbeam.getRecord());
	      if(qbrief && qprint) {
		std::ios::fmtflags iflsave = 
		  std::cout.setf(std::ios::showpoint|std::ios::fixed);
		int ipre = std::cout.precision(5);
		std::cout << "Svx" 
			  << std::setw(8) << run 
			  << std::setprecision(4)
			  << "  x(cm) " << std::setw(8) << sBeamPos.BeamX()
			  << "  y(cm) " << std::setw(8) << sBeamPos.BeamY()
			  << std::setprecision(4)
			  << "  x'(mr) " << std::setw(8) << 1000.0*sBeamPos.SlopeX()
			  << "  y'(mr) " << std::setw(8) << 1000.0*sBeamPos.SlopeY() << std::endl;
		std::cout.flags(iflsave);
		std::cout.precision(ipre);
	      }
	    }
	  }
	}
      }
      std::cout << "latest entries for run " << run << ":" << std::endl;
    }
    
    bool trySvx=false;
    bool tryCot=false;
    for(int i=0; i<ngoodc; i++) if(goodrunc[i]==run) tryCot=true;
    for(int i=0; i<ngoods; i++) if(goodruns[i]==run) trySvx=true;

    svxOK=false;
    cotOK=false;	
    
    // only get store number if needed
    if((qcot && tryCot)||(qsvx && trySvx))
      {
	runEntry[0] = run;
	runEntry[1] = storeNumber(run);
	//std::cout << "store: " << runEntry[1] << std::endl;
      }

    if((store == -1) || (runEntry[1] == store))
      {
	if(qcot && tryCot && cotbeam.loadRun(run,version) == 0) {
	  cotOK = true;
	  CotBeamPosition cBeamPos(cotbeam.getRecord());
	  
	  if(qbrief && qprint) {
	    std::ios::fmtflags iflsave = 
	      std::cout.setf(std::ios::showpoint|std::ios::fixed);
	    int ipre = std::cout.precision(5);
	    std::cout << "Cot" 
		 << std::setw(8) << run 
		 << std::setprecision(4)
		 << "  x(cm) " << std::setw(8) << cBeamPos.BeamX()
		 << "  y(cm) " << std::setw(8) << cBeamPos.BeamY()
		 << std::setprecision(4)
		 << "  x'(mr) " << std::setw(8) << 1000.0*cBeamPos.SlopeX()
		 << "  y'(mr) " << std::setw(8) << 1000.0*cBeamPos.SlopeY() << std::endl;
	    std::cout.flags(iflsave);
	    std::cout.precision(ipre);
	  }
	  
	  if(writecid) {
	    cidfile << "COTBEAMPOSITION " << cotbeam.getCid() << std::endl;
	  }

	  cEntry.cotBeamX          = cBeamPos.BeamX();          
	  cEntry.cotBeamY          = cBeamPos.BeamY();          
	  cEntry.cotSlopeX         = cBeamPos.SlopeX();         
	  cEntry.cotSlopeY         = cBeamPos.SlopeY();         
	  cEntry.cotTableVersion   = cotbeam.getVersion();
	  cEntry.cotTableStatus    = statusNumber(cotbeam.getStatus());
	  cEntry.cotBeamXSigma     = sqrt(cBeamPos.FitCov00());          
	  cEntry.cotBeamYSigma     = sqrt(cBeamPos.FitCov11());          
	  cEntry.cotSlopeXSigma    = sqrt(cBeamPos.FitCov22());         
	  cEntry.cotSlopeYSigma    = sqrt(cBeamPos.FitCov33());         
	  cEntry.cotWidthX         = cBeamPos.WidthX();         
	  cEntry.cotWidthY         = cBeamPos.WidthY();         
	  cEntry.cotWidthXY        = cBeamPos.WidthXY();        
	  cEntry.cotBeamZ          = cBeamPos.BeamZ();          
	  cEntry.cotWidthZ         = cBeamPos.WidthZ();         
	  cEntry.cotBeamXRate      = cBeamPos.BeamXRate();      
	  cEntry.cotBeamYRate      = cBeamPos.BeamYRate();      
	  cEntry.cotSlopeXRate     = cBeamPos.SlopeXRate();     
	  cEntry.cotSlopeYRate     = cBeamPos.SlopeYRate();     
	  cEntry.cotWidthXRate     = cBeamPos.WidthXRate();     
	  cEntry.cotWidthYRate     = cBeamPos.WidthYRate();     
	  cEntry.cotWidthXYRate    = cBeamPos.WidthXYRate();    
	  cEntry.cotBeamZRate      = cBeamPos.BeamZRate();      
	  cEntry.cotWidthZRate     = cBeamPos.WidthZRate();     
	  cEntry.cotMinimZFit      = cBeamPos.MinimZFit();      
	  cEntry.cotWidthZFit      = cBeamPos.WidthZFit();      
	  cEntry.cotBstarZFit      = cBeamPos.BstarZFit();      
	  cEntry.cotZzeroZFit      = cBeamPos.ZzeroZFit();      
	  cEntry.cotMinimZFitRate  = cBeamPos.MinimZFitRate();  
	  cEntry.cotWidthZFitRate  = cBeamPos.WidthZFitRate();  
	  cEntry.cotBstarZFitRate  = cBeamPos.BstarZFitRate();  
	  cEntry.cotZzeroZFitRate  = cBeamPos.ZzeroZFitRate();  
	  cEntry.cotFitCov00       = cBeamPos.FitCov00();       
	  cEntry.cotFitCov01       = cBeamPos.FitCov01();       
	  cEntry.cotFitCov02       = cBeamPos.FitCov02();       
	  cEntry.cotFitCov03       = cBeamPos.FitCov03();       
	  cEntry.cotFitCov11       = cBeamPos.FitCov11();       
	  cEntry.cotFitCov12       = cBeamPos.FitCov12();       
	  cEntry.cotFitCov13       = cBeamPos.FitCov13();       
	  cEntry.cotFitCov22       = cBeamPos.FitCov22();       
	  cEntry.cotFitCov23       = cBeamPos.FitCov23();       
	  cEntry.cotFitCov33       = cBeamPos.FitCov33();       
	  cEntry.cotStatistics0    = cBeamPos.Statistics0();    
	  cEntry.cotStatistics1    = cBeamPos.Statistics1();    
	  cEntry.cotFlag0          = cBeamPos.Flag0();          
	  cEntry.cotFlag1          = cBeamPos.Flag1();          
	  cEntry.cotSpare0         = cBeamPos.Spare0();         
	  cEntry.cotSpare1         = cBeamPos.Spare1();         
	  cEntry.cotSpare2         = cBeamPos.Spare2();         
	  cEntry.cotSpare3         = cBeamPos.Spare3();         
	}
	else
	  {
	    cEntry.cotBeamX          = 0;  
	    cEntry.cotBeamY          = 0; 
	    cEntry.cotSlopeX         = 0;     
	    cEntry.cotSlopeY         = 0;  
	    cEntry.cotTableVersion   = 0;
	    cEntry.cotTableStatus    = 0;
	    cEntry.cotBeamXSigma     = 0;   
	    cEntry.cotBeamYSigma     = 0;     
	    cEntry.cotSlopeXSigma    = 0;      
	    cEntry.cotSlopeYSigma    = 0; 
	    cEntry.cotWidthX         = 0;    
	    cEntry.cotWidthY         = 0;    
	    cEntry.cotWidthXY        = 0;       
	    cEntry.cotBeamZ          = 0;         
	    cEntry.cotWidthZ         = 0;         
	    cEntry.cotBeamXRate      = 0;     
	    cEntry.cotBeamYRate      = 0;      
	    cEntry.cotSlopeXRate     = 0;     
	    cEntry.cotSlopeYRate     = 0;     
	    cEntry.cotWidthXRate     = 0;     
	    cEntry.cotWidthYRate     = 0;     
	    cEntry.cotWidthXYRate    = 0;    
	    cEntry.cotBeamZRate      = 0;      
	    cEntry.cotWidthZRate     = 0;     
	    cEntry.cotMinimZFit      = 0;      
	    cEntry.cotWidthZFit      = 0;      
	    cEntry.cotBstarZFit      = 0;      
	    cEntry.cotZzeroZFit      = 0;      
	    cEntry.cotMinimZFitRate  = 0;  
	    cEntry.cotWidthZFitRate  = 0;  
	    cEntry.cotBstarZFitRate  = 0;  
	    cEntry.cotZzeroZFitRate  = 0;  
	    cEntry.cotFitCov00       = 0;       
	    cEntry.cotFitCov01       = 0;       
	    cEntry.cotFitCov02       = 0;       
	    cEntry.cotFitCov03       = 0;       
	    cEntry.cotFitCov11       = 0;       
	    cEntry.cotFitCov12       = 0;       
	    cEntry.cotFitCov13       = 0;       
	    cEntry.cotFitCov22       = 0;       
	    cEntry.cotFitCov23       = 0;       
	    cEntry.cotFitCov33       = 0;       
	    cEntry.cotStatistics0    = 0;    
	    cEntry.cotStatistics1    = 0;    
	    cEntry.cotFlag0          = 0;          
	    cEntry.cotFlag1          = 0;          
	    cEntry.cotSpare0         = 0;         
	    cEntry.cotSpare1         = 0;         
	    cEntry.cotSpare2         = 0;         
	    cEntry.cotSpare3         = 0; 
	  }
	if(qsvx && trySvx && svxbeam.loadRun(run,version) == 0) {
	  
	  svxOK = true;
	  SvxBeamPosition sBeamPos(svxbeam.getRecord());
	  
	  if(qbrief && qprint) {
	    std::ios::fmtflags iflsave = 
	      std::cout.setf(std::ios::showpoint|std::ios::fixed);
	    int ipre = std::cout.precision(5);
	    std::cout << "Svx" 
		 << std::setw(8) << run 
		 << std::setprecision(4)
		 << "  x(cm) " << std::setw(8) << sBeamPos.BeamX()
		 << "  y(cm) " << std::setw(8) << sBeamPos.BeamY()
		 << std::setprecision(4)
		 << "  x'(mr) " << std::setw(8) << 1000.0*sBeamPos.SlopeX()
		 << "  y'(mr) " << std::setw(8) << 1000.0*sBeamPos.SlopeY() << std::endl;
	    std::cout.flags(iflsave);
	    std::cout.precision(ipre);
	  }
	 
	  if(writecid) {
            cidfile << "SVXBEAMPOSITION " << svxbeam.getCid() << std::endl;
          }	  

	  sEntry.svxBeamX          = sBeamPos.BeamX();         
	  sEntry.svxBeamY          = sBeamPos.BeamY();         
	  sEntry.svxSlopeX         = sBeamPos.SlopeX();        
	  sEntry.svxSlopeY         = sBeamPos.SlopeY();        
	  sEntry.svxTableVersion   = svxbeam.getVersion();
	  sEntry.svxTableStatus    = statusNumber(svxbeam.getStatus());
	  sEntry.svxBeamXSigma     = sqrt(sBeamPos.FitCov00());         
	  sEntry.svxBeamYSigma     = sqrt(sBeamPos.FitCov11());         
	  sEntry.svxSlopeXSigma    = sqrt(sBeamPos.FitCov22());        
	  sEntry.svxSlopeYSigma    = sqrt(sBeamPos.FitCov33());        
	  sEntry.svxWidthX         = sBeamPos.WidthX();        
	  sEntry.svxWidthY         = sBeamPos.WidthY();        
	  sEntry.svxWidthXY        = sBeamPos.WidthXY();       
	  sEntry.svxBeamZ          = sBeamPos.BeamZ();         
	  sEntry.svxWidthZ         = sBeamPos.WidthZ();        
	  sEntry.svxBeamXRate      = sBeamPos.BeamXRate();     
	  sEntry.svxBeamYRate      = sBeamPos.BeamYRate();     
	  sEntry.svxSlopeXRate     = sBeamPos.SlopeXRate();    
	  sEntry.svxSlopeYRate     = sBeamPos.SlopeYRate();    
	  sEntry.svxWidthXRate     = sBeamPos.WidthXRate();    
	  sEntry.svxWidthYRate     = sBeamPos.WidthYRate();    
	  sEntry.svxWidthXYRate    = sBeamPos.WidthXYRate();   
	  sEntry.svxBeamZRate      = sBeamPos.BeamZRate();     
	  sEntry.svxWidthZRate     = sBeamPos.WidthZRate();    
	  sEntry.svxMinimZFit      = sBeamPos.MinimZFit();     
	  sEntry.svxWidthZFit      = sBeamPos.WidthZFit();     
	  sEntry.svxBstarZFit      = sBeamPos.BstarZFit();     
	  sEntry.svxZzeroZFit      = sBeamPos.ZzeroZFit();     
	  sEntry.svxMinimZFitRate  = sBeamPos.MinimZFitRate(); 
	  sEntry.svxWidthZFitRate  = sBeamPos.WidthZFitRate(); 
	  sEntry.svxBstarZFitRate  = sBeamPos.BstarZFitRate(); 
	  sEntry.svxZzeroZFitRate  = sBeamPos.ZzeroZFitRate(); 
	  sEntry.svxEmittXFit      = sBeamPos.EmittXFit();     
	  sEntry.svxBstarXFit      = sBeamPos.BstarXFit();     
	  sEntry.svxZzeroXFit      = sBeamPos.ZzeroXFit();     
	  sEntry.svxEmittYFit      = sBeamPos.EmittYFit();     
	  sEntry.svxBstarYFit      = sBeamPos.BstarYFit();     
	  sEntry.svxZzeroYFit      = sBeamPos.ZzeroYFit();     
	  sEntry.svxEmittXRate     = sBeamPos.EmittXRate();    
	  sEntry.svxBstarXRate     = sBeamPos.BstarXRate();    
	  sEntry.svxZzeroXRate     = sBeamPos.ZzeroXRate();    
	  sEntry.svxEmittYRate     = sBeamPos.EmittYRate();    
	  sEntry.svxBstarYRate     = sBeamPos.BstarYRate();    
	  sEntry.svxZzeroYRate     = sBeamPos.ZzeroYRate();    
	  sEntry.svxFitCov00       = sBeamPos.FitCov00();      
	  sEntry.svxFitCov01       = sBeamPos.FitCov01();      
	  sEntry.svxFitCov02       = sBeamPos.FitCov02();      
	  sEntry.svxFitCov03       = sBeamPos.FitCov03();      
	  sEntry.svxFitCov11       = sBeamPos.FitCov11();      
	  sEntry.svxFitCov12       = sBeamPos.FitCov12();      
	  sEntry.svxFitCov13       = sBeamPos.FitCov13();      
	  sEntry.svxFitCov22       = sBeamPos.FitCov22();      
	  sEntry.svxFitCov23       = sBeamPos.FitCov23();      
	  sEntry.svxFitCov33       = sBeamPos.FitCov33();      
	  sEntry.svxStatistics0    = sBeamPos.Statistics0();   
	  sEntry.svxStatistics1    = sBeamPos.Statistics1();   
	  sEntry.Flag0             = sBeamPos.Flag0();            
	  sEntry.Flag1             = sBeamPos.Flag1();            
	  sEntry.svxSpare0         = sBeamPos.Spare0();        
	  sEntry.svxSpare1         = sBeamPos.Spare1();        
	  sEntry.svxSpare2         = sBeamPos.Spare2();        
	  sEntry.svxSpare3         = sBeamPos.Spare3();        
	  // get container, fill time dep
	  sEntry.nTime = 0;
	  SvxBeamPositionContainer cont = svxbeam.getContainer();
	  for(SvxBeamPositionContainer::iterator it=cont.begin();
	      it!=cont.end(); it++) {
	    SvxBeamPosition& sb = (*it);
	    if(sb.ChannelID()>1) {
	      sEntry.chanTime[sEntry.nTime] = sb.ChannelID();
	      sEntry.statTime[sEntry.nTime] = sb.Statistics0();
	      sEntry.x0Time[sEntry.nTime] = sb.BeamX();
	      sEntry.y0Time[sEntry.nTime] = sb.BeamY();
	      sEntry.xsTime[sEntry.nTime] = sb.SlopeX();
	      sEntry.ysTime[sEntry.nTime] = sb.SlopeY();
	      sEntry.nTime++;
	    }
	  }

	}
	else
	  {
	    sEntry.svxBeamX          = 0;         
	    sEntry.svxBeamY          = 0;         
	    sEntry.svxSlopeX         = 0;        
	    sEntry.svxSlopeY         = 0;        
	    sEntry.svxTableVersion   = 0;
	    sEntry.svxTableStatus    = 0;
	    sEntry.svxBeamXSigma     = 0;         
	    sEntry.svxBeamYSigma     = 0;         
	    sEntry.svxSlopeXSigma    = 0;        
	    sEntry.svxSlopeYSigma    = 0;        
	    sEntry.svxWidthX         = 0;        
	    sEntry.svxWidthY         = 0;        
	    sEntry.svxWidthXY        = 0;       
	    sEntry.svxBeamZ          = 0;         
	    sEntry.svxWidthZ         = 0;        
	    sEntry.svxBeamXRate      = 0;     
	    sEntry.svxBeamYRate      = 0;     
	    sEntry.svxSlopeXRate     = 0;    
	    sEntry.svxSlopeYRate     = 0;    
	    sEntry.svxWidthXRate     = 0;    
	    sEntry.svxWidthYRate     = 0;    
	    sEntry.svxWidthXYRate    = 0;   
	    sEntry.svxBeamZRate      = 0;     
	    sEntry.svxWidthZRate     = 0;    
	    sEntry.svxMinimZFit      = 0;     
	    sEntry.svxWidthZFit      = 0;     
	    sEntry.svxBstarZFit      = 0;     
	    sEntry.svxZzeroZFit      = 0;     
	    sEntry.svxMinimZFitRate  = 0; 
	    sEntry.svxWidthZFitRate  = 0; 
	    sEntry.svxBstarZFitRate  = 0; 
	    sEntry.svxZzeroZFitRate  = 0; 
	    sEntry.svxEmittXFit      = 0;     
	    sEntry.svxBstarXFit      = 0;     
	    sEntry.svxZzeroXFit      = 0;     
	    sEntry.svxEmittYFit      = 0;     
	    sEntry.svxBstarYFit      = 0;     
	    sEntry.svxZzeroYFit      = 0;     
	    sEntry.svxEmittXRate     = 0;    
	    sEntry.svxBstarXRate     = 0;    
	    sEntry.svxZzeroXRate     = 0;    
	    sEntry.svxEmittYRate     = 0;    
	    sEntry.svxBstarYRate     = 0;    
	    sEntry.svxZzeroYRate     = 0;    
	    sEntry.svxFitCov00       = 0;      
	    sEntry.svxFitCov01       = 0;      
	    sEntry.svxFitCov02       = 0;      
	    sEntry.svxFitCov03       = 0;      
	    sEntry.svxFitCov11       = 0;      
	    sEntry.svxFitCov12       = 0;      
	    sEntry.svxFitCov13       = 0;      
	    sEntry.svxFitCov22       = 0;      
	    sEntry.svxFitCov23       = 0;      
	    sEntry.svxFitCov33       = 0;      
	    sEntry.svxStatistics0    = 0;   
	    sEntry.svxStatistics1    = 0;   
	    sEntry.Flag0             = 0;            
	    sEntry.Flag1             = 0;            
	    sEntry.svxSpare0         = 0;        
	    sEntry.svxSpare1         = 0;        
	    sEntry.svxSpare2         = 0;       
	    sEntry.svxSpare3         = 0;        
	  }
	if(qntuple && ( cotOK || svxOK) ) tree->Fill();
      }
    else if((store != -1) && (runEntry[1] > store))
      {
	// stop when we passed the store
	run = maxrun + 1;
      }
  }
  if(qntuple) {
    file->Write();
    file->Close();
  }
  return 0;
}

int statusNumber(const string status) {
  int i=0;
  if(status=="COMPLETE")  i=13;
  if(status=="GOOD")      i=12;
  if(status=="RAW")       i=11;
  if(status=="FILTERED")  i=10;
  if(status=="TIGHT")     i=9;
  if(status=="RELAXED")   i=8;
  if(status=="BAD")       i=7;
  if(status=="TEST")      i=6;
  if(status=="DERIVED")   i=5;
  if(status=="UNDEFINED") i=4;
  if(status=="ORPHANED")  i=3;
  if(status=="COMPLETE_DPS") i=2;
  if(status=="DOWNLOADED")   i=1;
  return i;
}


//following the example in RunConfigDB/Test/BeamConditions.cc
int storeNumber(int run)
{
  static bool initialized = false;
  static PackageManager m;
  if( ! initialized)
    {
      ConControl::instance()->addIoEntry(new IoEntry("offline","OTL","cdf_reader/reader@cdfofprd"));
      m.setDefaultID("offline");
      initialized = true;
    }
  // Define the manager & container/iterator for returned values.
  static BEAM_CONDITIONS_mgr dmgr1("BEAM_CONDITIONS");
  static BEAM_CONDITIONSContainer_ptr rvals1;
  static BEAM_CONDITIONSContainer::iterator it1;
  int store = -1;
  // Set the key -- just simple run selection + cardname selection 
  ostringstream srt;
  //srt << run << ends;
  srt << run;
  string sql_string = "WHERE RC_RUNNUMBER = " ; 
  sql_string += srt.str();
  ROKey dbk(sql_string);
  
  // Do the fetch from the DB and print out returned rows.
  Result rc = dmgr1.get(dbk,rvals1);
  if (rc == Result::success)
    {
      //std::cout << "Rows got:" << std::endl;
      it1 = rvals1->begin();
      if(it1 != rvals1->end()) store = it1->tevStore();
    }
  else std::cout << "could not read RunConfigDB(error = "<< rc << ")" << std::endl;
  return store;
}