//*-- AUTHOR : Ilse Koenig
//*-- created :  27/10/2002

//_HADES_CLASS_DESCRIPTION 
//////////////////////////////////////////////////////////////////////////////
// HTriggerParOraIo
//
// Interface class to database Oracle for input/output of parameters needed
// by the Trigger
// (uses the Oracle C/C++ precompiler)
//
//////////////////////////////////////////////////////////////////////////////
using namespace std;
#include "htriggerparoraio.h"
#include "hades.h"
#include "hruntimedb.h"
#include "hrun.h"
#include "htriggerparrichmap.h"
#include "htriggerparshowermap.h"
#include "htriggerparmommap.h"
#include "hrichIPUparthresholds.h"
#include "hrichIPUparpattern.h"
#include <iostream>
#include <iomanip>
#include <unistd.h>

#define SQLCA_STORAGE_CLASS extern
#define ORACA_STORAGE_CLASS extern

// Oracle communication area
#include <oraca.h>
// SQL Communications Area
#include <sqlca.h>

ClassImp(HTriggerParOraIo)

#define TRIG_MAXARRAY 1000
#define RIPU_MAXARRAY 300
#define RIPU_THRARRAY 12

HTriggerParOraIo::HTriggerParOraIo(HOraConn* pC) : HDetParOraIo(pC) {
  // constructor
  // sets the name of the I/O class "HTriggerParIo"
  // gets the pointer to the connection class
  fName="HTriggerParIo";
}

Bool_t HTriggerParOraIo::init(HParSet* pPar,Int_t* set) {
  // calls special read-function for each parameter container
  const Text_t* name=pPar->GetName();
  if (startIo(pPar)<=0) return kFALSE;
  if (strncmp(name,"TriggerParMuLep",strlen("TriggerParMuLep"))==0)
    return readCond((HParCond*)pPar,set);
  if (strncmp(name,"TriggerParMuDilep",strlen("TriggerParMuDilep"))==0)
    return readCond((HParCond*)pPar,set);
  if (strncmp(name,"TriggerParRichMap",strlen("TriggerParRichMap"))==0)
    return read((HTriggerParRichMap*)pPar);
  if (strncmp(name,"TriggerParShowerMap",strlen("TriggerParShowerMap"))==0)
    return read((HTriggerParShowerMap*)pPar);
  if (strncmp(name,"TriggerParMomMap",strlen("TriggerParMomMap"))==0)
    return read((HTriggerParMomMap*)pPar);
  if (strncmp(name,"RichIPUParLocMax",strlen("RichIPUParLocMax"))==0)
    return readCond((HParCond*)pPar,set);
  if (strncmp(name,"RichIPUParThresholds",strlen("RichIPUParThresholds"))==0)
    return read((HRichIPUParThresholds*)pPar);
  if (strncmp(name,"RichIPUParPattern",strlen("RichIPUParPattern"))==0)
    return read((HRichIPUParPattern*)pPar);
  cout<<"initialization of "<<name<<" not possible from Oracle!"<<endl;
  return kFALSE;
}

Int_t HTriggerParOraIo::write(HParSet* pPar) { 
  // calls the appropriate write function for the container
  const Text_t* name=pPar->GetName();
  if (startIo(pPar)<=0) return kFALSE;
  if (strncmp(name,"TriggerParMuLep",strlen("TriggerParMuLep"))==0)
    return writeCond((HParCond*)pPar);
  if (strncmp(name,"TriggerParMuDilep",strlen("TriggerParMuDilep"))==0)
    return writeCond((HParCond*)pPar); 
  if (strncmp(name,"TriggerParRichMap",strlen("TriggerParRichMap"))==0)
    return writePar((HTriggerParRichMap*)pPar);
  if (strncmp(name,"TriggerParShowerMap",strlen("TriggerParShowerMap"))==0)
    return writePar((HTriggerParShowerMap*)pPar);
  if (strncmp(name,"TriggerParMomMap",strlen("TriggerParMomMap"))==0)
    return writePar((HTriggerParMomMap*)pPar);
  if (strncmp(name,"RichIPUParLocMax",strlen("RichIPUParLocMax"))==0)
    return writeCond((HParCond*)pPar);
  if (strncmp(name,"RichIPUParThresholds",strlen("RichIPUParThresholds"))==0)
    return writePar((HRichIPUParThresholds*)pPar);
  if (strncmp(name,"RichIPUParPattern",strlen("RichIPUParPattern"))==0)
    return writePar((HRichIPUParPattern*)pPar);
  cout<<"No write-interface to Oracle for parameter container "
      <<name<<endl;
  return 0;
}
 
Int_t HTriggerParOraIo::startIo(HParSet* pPar) {
  // gets the run start of the actual run
  // returns -1, if the run is not found
  runStart=getRunStart(pPar);
  if (runStart==-1) pPar->setInputVersion(-1,inputNumber);
  return runStart;
}

Int_t HTriggerParOraIo::getVersion(HParSet* pPar,Int_t& version) {
  // reads the newest version valid for the current event file
  // returns -1, if no data found
  HParOraSet* oraSet=getOraSet(pPar);
  Int_t runStart=getRunStart(pPar);
  if (oraSet->contextId==-1 || runStart==-1) return -1;
  Int_t contVers=pPar->getInputVersion(inputNumber);
  if (contVers!=-1 && runStart>=oraSet->versDate[0] && runStart<=oraSet->versDate[1])
      return contVers;
  const Char_t* containerClass=pPar->IsA()->GetName();
  oraSet->clearVersDate();
  EXEC SQL BEGIN DECLARE SECTION;
    int context;
    int vers;
    double since;
    double until;
  EXEC SQL END DECLARE SECTION;
  context=oraSet->contextId;
  EXEC SQL WHENEVER SQLERROR DO showSqlError("getVersion(HParSet*,Int_t*)");
  EXEC SQL WHENEVER NOT FOUND GOTO notfound;
  if (strcmp(containerClass,"HTriggerParRichMap")==0) {
    EXEC SQL SELECT version,
                    hdate.to_ansitime(valid_since),
                    hdate.to_ansitime(valid_until)
             INTO :vers, :since, :until
             FROM ilse_daq.richmap_vers_at_date
             WHERE context_id = :context;
  } else {
    if (strcmp(containerClass,"HTriggerParShowerMap")==0) {
      EXEC SQL SELECT version,
                      hdate.to_ansitime(valid_since),
                      hdate.to_ansitime(valid_until)
               INTO :vers, :since, :until
               FROM ilse_daq.showermap_vers_at_date
               WHERE context_id = :context;
    } else {
      if (strcmp(containerClass,"HTriggerParMomMap")==0) {
        EXEC SQL SELECT version,
                        hdate.to_ansitime(valid_since),
                        hdate.to_ansitime(valid_until)
                 INTO :vers, :since, :until
                 FROM ilse_daq.mommap_vers_at_date
                 WHERE context_id = :context;
      } else {
        if (strcmp(containerClass,"HRichIPUParThresholds")==0) {
          EXEC SQL SELECT version,
                          hdate.to_ansitime(valid_since),
                          hdate.to_ansitime(valid_until)
                   INTO :vers, :since, :until
                   FROM ilse_daq.rich_ipu_thresh_vers_at_date
                   WHERE context_id = :context;
        } else {
          if (strcmp(containerClass,"HRichIPUParPattern")==0) {
            EXEC SQL SELECT version,
                            hdate.to_ansitime(valid_since),
                            hdate.to_ansitime(valid_until)
                     INTO :vers, :since, :until
                     FROM ilse_daq.rich_ipu_pattern_vers_at_date
                     WHERE context_id = :context;
          }
        }
      }
    }
  }
  version=vers;
  oraSet->versDate[0]=since;
  oraSet->versDate[1]=until;
  return getActRunId();
notfound:
  return -1;
};

Bool_t HTriggerParOraIo::read(HTriggerParRichMap* pPar) {
  // reads the parameters for Rich mapping
  Int_t contVers=pPar->getInputVersion(inputNumber);
  Int_t oraVersion=-1;
  Int_t version=getVersion(pPar,oraVersion);
  if (version==-1) {
    pPar->setInputVersion(-1,inputNumber);
    return kFALSE;
  }
  if (contVers==version) return kTRUE;
  pPar->clear();
  EXEC SQL BEGIN DECLARE SECTION;
    int   vers;
    struct {
      int   rowNum[TRIG_MAXARRAY];
      int   colNum[TRIG_MAXARRAY];
      float theta[TRIG_MAXARRAY];
      float phi[TRIG_MAXARRAY];
    } rmap;
  EXEC SQL END DECLARE SECTION; 
  vers=oraVersion;
  //cout<<"reading Rich mapping parameters with version "<<vers<<endl;
  Int_t nbs=0, nbslast=0;
  EXEC SQL WHENEVER NOT FOUND CONTINUE;
  EXEC SQL WHENEVER SQLERROR GOTO errorfound;
  EXEC SQL DECLARE crmap CURSOR FOR
    SELECT row_num,col_num,rich_theta,rich_phi
      FROM ilse_daq.richmap_data where vers_id=:vers;
  EXEC SQL OPEN crmap;
  do {
    EXEC SQL FETCH crmap INTO :rmap;
    nbs=sqlca.sqlerrd[2] - nbslast;
    nbslast+=nbs;
    for(Int_t i=0;i<nbs;i++) {
      pPar->setRichTheta(rmap.rowNum[i],rmap.colNum[i],rmap.theta[i]);
      pPar->setRichPhi(rmap.rowNum[i],rmap.colNum[i],rmap.phi[i]);
    }
  } while (nbs==TRIG_MAXARRAY);
  EXEC SQL CLOSE crmap;
  if (nbslast==pPar->getRowSize()*pPar->getColSize()) {
    setChanged(pPar);
    cout<<pPar->GetName()<<" initialized from Oracle"<<endl;
    return kTRUE;
  } else {
    pPar->setInputVersion(-1,inputNumber);
    return kFALSE;
  }
errorfound:
  showSqlError("read(HTriggerParRichMap*)");
  pPar->setInputVersion(-1,inputNumber);
  return kFALSE;
}

Bool_t HTriggerParOraIo::read(HTriggerParShowerMap* pPar) {
  // reads the parameters for Shower mapping
  Int_t contVers=pPar->getInputVersion(inputNumber);
  Int_t oraVersion=-1;
  Int_t version=getVersion(pPar,oraVersion);
  if (version==-1) {
    pPar->setInputVersion(-1,inputNumber);
    return kFALSE;
  }
  if (contVers==version) return kTRUE;
  pPar->clear();
  EXEC SQL BEGIN DECLARE SECTION;
    int   vers;
    struct {
      int   rowNum[TRIG_MAXARRAY];
      int   colNum[TRIG_MAXARRAY];
      float theta[TRIG_MAXARRAY];
      float phi[TRIG_MAXARRAY];
    } smap;
  EXEC SQL END DECLARE SECTION; 
  vers=oraVersion;
  //cout<<"reading Shower mapping parameters with version "<<version<<endl;
  Int_t nbs=0, nbslast=0;
  EXEC SQL WHENEVER NOT FOUND CONTINUE;
  EXEC SQL WHENEVER SQLERROR GOTO errorfound;
  EXEC SQL DECLARE csmap CURSOR FOR
    SELECT row_num,col_num,shower_theta,shower_phi
      FROM ilse_daq.showermap_data where vers_id=:vers;
  EXEC SQL OPEN csmap;
  do {
    EXEC SQL FETCH csmap INTO :smap;
    nbs=sqlca.sqlerrd[2] - nbslast;
    nbslast+=nbs;
    for(Int_t i=0;i<nbs;i++) {
      pPar->setShowerTheta(smap.rowNum[i],smap.colNum[i],smap.theta[i]);
      pPar->setShowerPhi(smap.rowNum[i],smap.colNum[i],smap.phi[i]);
    }
  } while (nbs==TRIG_MAXARRAY);
  EXEC SQL CLOSE csmap;
  if (nbslast==pPar->getRowSize()*pPar->getColSize()) {
    setChanged(pPar);
    cout<<pPar->GetName()<<" initialized from Oracle"<<endl;
    return kTRUE;
  } else {
    pPar->setInputVersion(-1,inputNumber);
    return kFALSE;
  }
errorfound:
  showSqlError("read(HTriggerParShowerMap*)");
  pPar->setInputVersion(-1,inputNumber);
  return kFALSE;
}

Bool_t HTriggerParOraIo::read(HTriggerParMomMap* pPar) {
  // reads the parameters for MU momentum mapping
  Int_t contVers=pPar->getInputVersion(inputNumber);
  Int_t oraVersion=-1;
  Int_t version=getVersion(pPar,oraVersion);
  if (version==-1) {
    pPar->setInputVersion(-1,inputNumber);
    return kFALSE;
  }
  if (contVers==version) return kTRUE;
  pPar->clear();
  EXEC SQL BEGIN DECLARE SECTION;
    int   vers;
    struct {
      int   thetaBins;
      int   dthetaBins;
      int   phiBins;
    } mmap;
  EXEC SQL END DECLARE SECTION; 
  vers=oraVersion;
  //cout<<"reading MU momentum mapping parameters with version "<<version<<endl;
  EXEC SQL WHENEVER SQLERROR DO showSqlError("read(HTriggerParMomMap*)");
  EXEC SQL WHENEVER NOT FOUND GOTO notfound;
  EXEC SQL SELECT theta_bins,deltatheta_bins,phi_bins INTO :mmap
           FROM ilse_daq.mommap_data WHERE vers_id=:vers;
  pPar->setTheta_bins(mmap.thetaBins);
  pPar->setDeltatheta_bins(mmap.dthetaBins);
  pPar->setPhi_bins(mmap.phiBins);
  if (readArray(pPar,oraVersion)==mmap.thetaBins*mmap.dthetaBins*mmap.phiBins) {
    setChanged(pPar);
    cout<<pPar->GetName()<<" initialized from Oracle"<<endl;
    return kTRUE;
  }
notfound:
  pPar->setInputVersion(-1,inputNumber);
  return kFALSE;
}

Int_t HTriggerParOraIo::readArray(HTriggerParMomMap* pPar,Int_t version) {
  // reads the parameters for MU momentum mapping
  EXEC SQL BEGIN DECLARE SECTION;
    int   vers;
    struct {
      int   thbin[TRIG_MAXARRAY];
      int   dthbin[TRIG_MAXARRAY];
      int   phibin[TRIG_MAXARRAY];
      float mom[TRIG_MAXARRAY];
    } mamap;
  EXEC SQL END DECLARE SECTION; 
  vers=version;
  Int_t nbs=0, nbslast=0;
  EXEC SQL WHENEVER NOT FOUND CONTINUE;
  EXEC SQL WHENEVER SQLERROR GOTO errorfound;
  EXEC SQL DECLARE cmmap CURSOR FOR
    SELECT theta_bin,deltatheta_bin,phi_bin,momentum
      FROM ilse_daq.mommap_array where vers_id=:vers;
  EXEC SQL OPEN cmmap;
  do {
    EXEC SQL FETCH cmmap INTO :mamap;
    nbs=sqlca.sqlerrd[2] - nbslast;
    nbslast+=nbs;
    for(Int_t i=0;i<nbs;i++) {
      pPar->setMom(mamap.thbin[i],mamap.dthbin[i],mamap.phibin[i],mamap.mom[i]);
    }
  } while (nbs==TRIG_MAXARRAY);
  EXEC SQL CLOSE cmmap;
  return nbslast;
errorfound:
  showSqlError("readArray(HTriggerParMomMap*,Int_t)");
  return -1;
}

Bool_t HTriggerParOraIo::read(HRichIPUParThresholds* pPar) {
  // reads the Rich IPU threshold parameters
  Int_t contVers=pPar->getInputVersion(inputNumber);
  Int_t oraVersion=-1;
  Int_t version=getVersion(pPar,oraVersion);
  if (version==-1) {
    pPar->setInputVersion(-1,inputNumber);
    return kFALSE;
  }
  if (contVers==version) return kTRUE;
  pPar->clear();
  EXEC SQL BEGIN DECLARE SECTION;
    int   vers;
    struct {
      int   reg[RIPU_THRARRAY];
      int   sec[RIPU_THRARRAY];
      float thr[RIPU_THRARRAY];
    } riputhr;
  EXEC SQL END DECLARE SECTION;
  vers=oraVersion;
  Int_t nbs=0, nbslast=0;
  EXEC SQL WHENEVER NOT FOUND CONTINUE;
  EXEC SQL WHENEVER SQLERROR GOTO errorfound;
  EXEC SQL DECLARE criputhr CURSOR FOR
    SELECT region,sector,threshold
      FROM ilse_daq.rich_ipu_threshold_data where vers_id=:vers;
  EXEC SQL OPEN criputhr;
  do {
    EXEC SQL FETCH criputhr INTO :riputhr;
    nbs=sqlca.sqlerrd[2] - nbslast;
    nbslast+=nbs;
    for(Int_t i=0;i<nbs;i++) {
      pPar->setThresholds(riputhr.reg[i],riputhr.sec[i],(Int_t)riputhr.thr[i]);
    }
  } while (nbs==RIPU_THRARRAY);
  EXEC SQL CLOSE criputhr;
  if (nbslast==pPar->getRegionSize()*6) {
    setChanged(pPar);
    cout<<pPar->GetName()<<" initialized from Oracle"<<endl;
    return kTRUE;
  } else {
    pPar->setInputVersion(-1,inputNumber);
    return kFALSE;
  }
errorfound:
  showSqlError("read(HRichIPUParThresholds*)");
  pPar->setInputVersion(-1,inputNumber);
  return kFALSE;
}

Bool_t HTriggerParOraIo::read(HRichIPUParPattern* pPar) {
  // reads the Rich IPU pattern parameters
  Int_t contVers=pPar->getInputVersion(inputNumber);
  Int_t oraVersion=-1;
  Int_t version=getVersion(pPar,oraVersion);
  if (version==-1) {
    pPar->setInputVersion(-1,inputNumber);
    return kFALSE;
  }
  if (contVers==version) return kTRUE;
  pPar->clear();
  EXEC SQL BEGIN DECLARE SECTION;
    int   vers;
    struct {
      int   ng;
      int   npig;
      int   re;
    } ripupat;
  EXEC SQL END DECLARE SECTION;
  vers=oraVersion;
  EXEC SQL WHENEVER SQLERROR DO showSqlError("read(HRichIPUParPattern*)");
  EXEC SQL WHENEVER NOT FOUND GOTO notfound;
  EXEC SQL SELECT n_groups,n_pads_in_group,region INTO :ripupat
           FROM ilse_daq.rich_ipu_pattern_data WHERE vers_id=:vers;
  pPar->setNGroups(ripupat.ng);
  pPar->setNPadsinGroup(ripupat.npig);
  pPar->setNPadDimensions(ripupat.re);
  if (readArray(pPar,oraVersion)==ripupat.ng*ripupat.npig*ripupat.re) {
    setChanged(pPar);
    cout<<pPar->GetName()<<" initialized from Oracle"<<endl;
    return kTRUE;
  }
notfound:
  pPar->setInputVersion(-1,inputNumber);
  return kFALSE;
}

Int_t HTriggerParOraIo::readArray(HRichIPUParPattern* pPar,Int_t version) {
  // reads the Rich IPU pattern parameters
  EXEC SQL BEGIN DECLARE SECTION;
    int   vers;
    struct {
      int   gr[RIPU_MAXARRAY];
      int   pa[RIPU_MAXARRAY];
      float re[RIPU_MAXARRAY];
      float pat[RIPU_MAXARRAY];
    } ripupata;
  EXEC SQL END DECLARE SECTION;
  vers=version;
  Int_t nbs=0, nbslast=0;
  EXEC SQL WHENEVER NOT FOUND CONTINUE;
  EXEC SQL WHENEVER SQLERROR GOTO errorfound;
  EXEC SQL DECLARE cripupat CURSOR FOR
    SELECT group_num,pad,region,pattern
      FROM ilse_daq.rich_ipu_pattern_array where vers_id=:vers;
  EXEC SQL OPEN cripupat;
  do {
    EXEC SQL FETCH cripupat INTO :ripupata;
    nbs=sqlca.sqlerrd[2] - nbslast;
    nbslast+=nbs;
    for(Int_t i=0;i<nbs;i++) {
      pPar->setPattern(ripupata.gr[i],ripupata.pa[i],(Int_t)ripupata.re[i],(Int_t)ripupata.pat[i]);
    }
  } while (nbs==RIPU_MAXARRAY);
  EXEC SQL CLOSE cripupat;
  return nbslast;
errorfound:
  showSqlError("readArray(HRichIPUParPattern*,Int_t)");
  return -1;
}

Int_t HTriggerParOraIo::createVersion(HParSet* pPar) {
  // creates a new version for the parameters
  // returns the new version
  if (strlen(pPar->getAuthor())==0) {
    Error("createVersion(HParSet*)",
          "%s: author not defined\n",pPar->GetName());
    return -1;
  }
  if (strlen(pPar->getDescription())==0) {
    Error("createVersion(HParSet*)",
          "%s: description not defined\n",pPar->GetName());
    return -1;
  }
  EXEC SQL BEGIN DECLARE SECTION;
    int   vers=-1;
    int   context;
    int   run;
    char* creator;
    char* descript;
  EXEC SQL END DECLARE SECTION;
  context = getContextId(pPar->IsA()->GetName(),pPar->getParamContext());
  if (context==-1) return -1;
  run=getActRunId();
  creator=(Char_t*)pPar->getAuthor();
  descript=(Char_t*)pPar->getDescription();
  EXEC SQL WHENEVER SQLERROR GOTO not_found;
  EXEC SQL WHENEVER NOT FOUND GOTO not_found;
  const Char_t* contName=pPar->IsA()->GetName();
  if (strcmp(contName,"HTriggerParRichMap")==0) {
    EXEC SQL EXECUTE
      BEGIN
        SELECT ilse_daq.trigger_par_query.next_version INTO :vers FROM DUAL;
        INSERT INTO ilse_daq.richmap_vers
                   (vers_id, orig_context_id, run_id, author, description)
            VALUES (:vers, :context, :run, :creator, :descript);
      END;
    END-EXEC;
  } else {
    if (strcmp(contName,"HTriggerParShowerMap")==0) {
      EXEC SQL EXECUTE
        BEGIN
          SELECT ilse_daq.trigger_par_query.next_version INTO :vers FROM DUAL;
          INSERT INTO ilse_daq.showermap_vers
                     (vers_id, orig_context_id, run_id, author, description)
              VALUES (:vers, :context, :run, :creator, :descript);
        END;
      END-EXEC;
    } else {
      if (strcmp(contName,"HTriggerParMomMap")==0) {
        EXEC SQL EXECUTE
          BEGIN
            SELECT ilse_daq.trigger_par_query.next_version INTO :vers FROM DUAL;
            INSERT INTO ilse_daq.mommap_vers
                       (vers_id, orig_context_id, run_id, author, description)
                VALUES (:vers, :context, :run, :creator, :descript);
          END;
        END-EXEC;
      } else {
        if (strcmp(contName,"HRichIPUParThresholds")==0) {
          EXEC SQL EXECUTE
            BEGIN
              SELECT ilse_daq.trigger_par_query.next_version INTO :vers FROM DUAL;
              INSERT INTO ilse_daq.rich_ipu_threshold_vers
                         (vers_id, orig_context_id, run_id, author, description)
                  VALUES (:vers, :context, :run, :creator, :descript);
            END;
          END-EXEC;
        } else {
          if (strcmp(contName,"HRichIPUParPattern")==0) {
            EXEC SQL EXECUTE
              BEGIN
                SELECT ilse_daq.trigger_par_query.next_version INTO :vers FROM DUAL;
                INSERT INTO ilse_daq.rich_ipu_pattern_vers
                           (vers_id, orig_context_id, run_id, author, description)
                    VALUES (:vers, :context, :run, :creator, :descript);
              END;
            END-EXEC;
          }
        }
      }
    }
  }
  cout<<"Oracle version for "<<pPar->GetName()<<" created:  "<<vers<<endl;
  return vers;
not_found:
  showSqlError("createVersion(HParSet*)");
  return vers;
}

Int_t HTriggerParOraIo::writePar(HTriggerParRichMap* pPar) {
  // writes the Rich mapping  parameters to Oracle
  Int_t version=createVersion(pPar);
  if (version==-1) return -1;
  EXEC SQL BEGIN DECLARE SECTION;
    int   vers[TRIG_MAXARRAY];
    int   rowNum[TRIG_MAXARRAY];
    int   colNum[TRIG_MAXARRAY];
    float theta[TRIG_MAXARRAY];
    float phi[TRIG_MAXARRAY];
    int nval;
  EXEC SQL END DECLARE SECTION;
  nval=0;
  Int_t colsize=pPar->getColSize();
  Int_t rowsize=pPar->getRowSize();
  Int_t ntotval=colsize*rowsize;
  Int_t r=0, c=0, n=0;
  while (n<ntotval) {
    Int_t k=0;
    do {
      vers[k]=version;
      rowNum[k]=r;
      colNum[k]=c;
      theta[k]=pPar->getRichTheta(r,c);
      phi[k]=pPar->getRichPhi(r,c);
      //cout<<"k="<<k<<" r="<<r<<" c="<<c<<" theta="<<theta[k]<<" phi="<<phi[k]<<endl;
      k++;
      n++;
      c++;
      if (c==rowsize) {
        r++;
        c=0;
      }
    } while (k<TRIG_MAXARRAY && n<ntotval);
    nval=k;
    EXEC SQL WHENEVER SQLERROR GOTO not_found;
    EXEC SQL WHENEVER NOT FOUND GOTO not_found;
    EXEC SQL FOR :nval
      INSERT INTO ilse_daq.richmap_data (vers_id,row_num,col_num,rich_theta,rich_phi)
                            values (:vers,:rowNum,:colNum,:theta,:phi);
  }
  cout<<"Total number of rows inserted: "<<n<<endl;
  commit();
  pPar->setChanged(kFALSE);
  return version;
not_found:
  showSqlError("writePar(HTriggerParRichMap*)");
  rollback();
  pPar->setChanged(kFALSE);
  return -1;
}

Int_t HTriggerParOraIo::writePar(HTriggerParShowerMap* pPar) {
  // writes the Shower mapping  parameters to Oracle
  Int_t version=createVersion(pPar);
  if (version==-1) return -1;
  EXEC SQL BEGIN DECLARE SECTION;
    int   vers[TRIG_MAXARRAY];
    int   rowNum[TRIG_MAXARRAY];
    int   colNum[TRIG_MAXARRAY];
    float theta[TRIG_MAXARRAY];
    float phi[TRIG_MAXARRAY];
    int nval;
  EXEC SQL END DECLARE SECTION;
  nval=0;
  Int_t colsize=pPar->getColSize();
  Int_t rowsize=pPar->getRowSize();
  Int_t ntotval=colsize*rowsize;
  Int_t r=0, c=0, n=0;
  while (n<ntotval) {
    Int_t k=0;
    do {
      vers[k]=version;
      rowNum[k]=r;
      colNum[k]=c;
      theta[k]=pPar->getShowerTheta(r,c);
      phi[k]=pPar->getShowerPhi(r,c);
      //cout<<"k="<<k<<" r="<<r<<" c="<<c<<" theta="<<theta[k]<<" phi="<<phi[k]<<endl;
      k++;
      n++;
      c++;
      if (c==rowsize) {
        r++;
        c=0;
      }
    } while (k<TRIG_MAXARRAY && n<ntotval);
    nval=k;
    EXEC SQL WHENEVER SQLERROR GOTO not_found;
    EXEC SQL WHENEVER NOT FOUND GOTO not_found;
    EXEC SQL FOR :nval
      INSERT INTO ilse_daq.showermap_data (vers_id,row_num,col_num,shower_theta,shower_phi)
                            values (:vers,:rowNum,:colNum,:theta,:phi);
  }
  cout<<"Total number of rows inserted: "<<n<<endl;
  commit();
  pPar->setChanged(kFALSE);
  return version;
not_found:
  showSqlError("writePar(HTriggerParShowerMap*)");
  rollback();
  pPar->setChanged(kFALSE);
  return -1;
}

Int_t HTriggerParOraIo::writePar(HTriggerParMomMap* pPar) {
  // writes the MU momentum mapping parameters to Oracle
  EXEC SQL BEGIN DECLARE SECTION;
    int   vers;
    int   thetaBins;
    int   dthetaBins;
    int   phiBins;
  EXEC SQL END DECLARE SECTION;
  vers=createVersion(pPar);
  if (vers==-1) return -1;
  thetaBins=pPar->getTheta_bins();
  dthetaBins=pPar->getDeltatheta_bins();
  phiBins=pPar->getPhi_bins();
  EXEC SQL WHENEVER SQLERROR GOTO not_found;
  EXEC SQL WHENEVER NOT FOUND GOTO not_found;
  EXEC SQL INSERT INTO ilse_daq.mommap_data (vers_id,theta_bins,deltatheta_bins,phi_bins)
                                     values (:vers,:thetaBins,:dthetaBins,:phiBins);
  if (writeArray(pPar,vers)>0) {
    commit();
    pPar->setChanged(kFALSE);
    return vers;
  }
not_found:
  showSqlError("writePar(HTriggerParMomMap*)");
  rollback();
  pPar->setChanged(kFALSE);
  return -1;
}

Int_t HTriggerParOraIo::writeArray(HTriggerParMomMap* pPar,Int_t version) {
  // writes the MU momentum mapping parameters to Oracle
  EXEC SQL BEGIN DECLARE SECTION;
    int   vers[TRIG_MAXARRAY];
    int   thbin[TRIG_MAXARRAY];
    int   dthbin[TRIG_MAXARRAY];
    int   phibin[TRIG_MAXARRAY];
    float mom[TRIG_MAXARRAY];
    int nval;
  EXEC SQL END DECLARE SECTION;
  nval=0;
  Int_t thsize=pPar->getTheta_bins();
  Int_t dthsize=pPar->getDeltatheta_bins();
  Int_t phisize=pPar->getPhi_bins();
  Int_t ntotval=thsize*dthsize*phisize;
  Int_t t=0, d=0, p=0, n=0;
  while (n<ntotval) {
    Int_t k=0;
    do {
      vers[k]=version;
      thbin[k]=t;
      dthbin[k]=d;
      phibin[k]=p;
      mom[k]=pPar->getMom(t,d,p);
      k++;
      n++;
      p++;
      if (p==phisize) {
        p=0;
        d++;
        if (d==dthsize) {
          d=0;
          t++;
        }
      }
      //cout<<"k="<<k<<" t="<<t<<" d="<<d<<" p="<<p<<" mom="<<mom[k]<<endl;
    } while (k<TRIG_MAXARRAY && n<ntotval);
    nval=k;
    EXEC SQL WHENEVER SQLERROR GOTO not_found;
    EXEC SQL WHENEVER NOT FOUND GOTO not_found;
    EXEC SQL FOR :nval
      INSERT INTO ilse_daq.mommap_array (vers_id,theta_bin,deltatheta_bin,phi_bin,momentum)
                            values (:vers,:thbin,:dthbin,:phibin,:mom);
  }
  cout<<"Total number of rows inserted: "<<n<<endl;
  return n;
not_found:
  return -1;
}

Int_t HTriggerParOraIo::writePar(HRichIPUParThresholds* pPar) {
  // writes the Rich IPU thresholds to Oracle
  Int_t version=createVersion(pPar);
  if (version==-1) return -1;
  EXEC SQL BEGIN DECLARE SECTION;
    int   vers[RIPU_THRARRAY];
    int   reg[RIPU_THRARRAY];
    int   sec[RIPU_THRARRAY];
    float thr[RIPU_THRARRAY];
    int nval;
  EXEC SQL END DECLARE SECTION;
  nval=0;
  Int_t colsize=pPar->getRegionSize();
  Int_t rowsize=6;
  Int_t ntotval=colsize*rowsize;
  Int_t r=0, c=0, n=0;
  while (n<ntotval) {
    Int_t k=0;
    do {
      vers[k]=version;
      reg[k]=r;
      sec[k]=c;
      thr[k]=pPar->getThresholds(r,c);
      //cout<<"k="<<k<<" r="<<r<<" c="<<c<<" thresh="<<thr[k]<<endl;
      k++;
      n++;
      c++;
      if (c==rowsize) {
        r++;
        c=0;
      }
    } while (k<RIPU_THRARRAY && n<ntotval);
    nval=k;
    EXEC SQL WHENEVER SQLERROR GOTO not_found;
    EXEC SQL WHENEVER NOT FOUND GOTO not_found;
    EXEC SQL FOR :nval
      INSERT INTO ilse_daq.rich_ipu_threshold_data (vers_id,region,sector,threshold)
                            values (:vers,:reg,:sec,:thr);
  }
  cout<<"Total number of rows inserted: "<<n<<endl;
  commit();
  pPar->setChanged(kFALSE);
  return version;
not_found:
  showSqlError("writePar(HRichIPUParThresholds*)");
  rollback();
  pPar->setChanged(kFALSE);
  return -1;
}

Int_t HTriggerParOraIo::writePar(HRichIPUParPattern* pPar) {
  // writes the Rich IPU pattern to Oracle
  EXEC SQL BEGIN DECLARE SECTION;
    int   vers;
    int   ng;
    int   np;
    int   re;
  EXEC SQL END DECLARE SECTION;
  vers=createVersion(pPar);
  if (vers==-1) return -1;
  ng=pPar->getNGroups();
  np=pPar->getNPadsinGroup();
  re=pPar->getNPadDimensions();
  EXEC SQL WHENEVER SQLERROR GOTO not_found;
  EXEC SQL WHENEVER NOT FOUND GOTO not_found;
  EXEC SQL INSERT INTO ilse_daq.rich_ipu_pattern_data (vers_id,n_groups,n_pads_in_group,region)
                                     values (:vers,:ng,:np,:re);
  if (writeArray(pPar,vers)>0) {
    commit();
    pPar->setChanged(kFALSE);
    return vers;
  }
not_found:
  showSqlError("writePar(HRichIPUParPattern*)");
  rollback();
  pPar->setChanged(kFALSE);
  return -1;
}

Int_t HTriggerParOraIo::writeArray(HRichIPUParPattern* pPar,Int_t version) {
  // writes the Rich IPU pattern to Oracle
  EXEC SQL BEGIN DECLARE SECTION;
    int   vers[RIPU_MAXARRAY];
    int   gr[RIPU_MAXARRAY];
    int   pa[RIPU_MAXARRAY];
    float re[RIPU_MAXARRAY];
    float pat[RIPU_MAXARRAY];
    int nval;
  EXEC SQL END DECLARE SECTION;
  nval=0;
  Int_t grsize=pPar->getNGroups();
  Int_t pasize=pPar->getNPadsinGroup();
  Int_t resize=pPar->getNPadDimensions();
  Int_t ntotval=grsize*pasize*resize;
  Int_t g=0, p=0, r=0, n=0;
  while (n<ntotval) {
    Int_t k=0;
    do {
      vers[k]=version;
      gr[k]=g;
      pa[k]=p;
      re[k]=r;
      pat[k]=pPar->getPattern(g,p,r);
      k++;
      n++;
      r++;
      if (r==resize) {
        r=0;
        p++;
        if (p==pasize) {
          p=0;
          g++;
        }
      }
      //cout<<"group="<<g<<" pad="<<p<<" region="<<r<<" pattern="<<pat[k]<<endl;
    } while (k<RIPU_MAXARRAY && n<ntotval);
    nval=k;
    EXEC SQL WHENEVER SQLERROR GOTO not_found;
    EXEC SQL WHENEVER NOT FOUND GOTO not_found;
    EXEC SQL FOR :nval
      INSERT INTO ilse_daq.rich_ipu_pattern_array (vers_id,group_num,pad,region,pattern)
                            values (:vers,:gr,:pa,:re,:pat);
  }
  cout<<"Total number of rows inserted: "<<n<<endl;
  return n;
not_found:
  return -1;
}