/* Result Sets Interface */
#ifndef SQL_CRSR
#  define SQL_CRSR
  struct sql_cursor
  {
    unsigned int curocn;
    void *ptr1;
    void *ptr2;
    unsigned int magic;
  };
  typedef struct sql_cursor sql_cursor;
  typedef struct sql_cursor SQL_CURSOR;
#endif /* SQL_CRSR */

/* Thread Safety */
typedef void * sql_context;
typedef void * SQL_CONTEXT;

/* Object support */
struct sqltvn
{
  unsigned char *tvnvsn; 
  unsigned short tvnvsnl; 
  unsigned char *tvnnm;
  unsigned short tvnnml; 
  unsigned char *tvnsnm;
  unsigned short tvnsnml;
};
typedef struct sqltvn sqltvn;

struct sqladts
{
  unsigned int adtvsn; 
  unsigned short adtmode; 
  unsigned short adtnum;  
  sqltvn adttvn[1];       
};
typedef struct sqladts sqladts;

static struct sqladts sqladt = {
  1,1,0,
};

/* Binding to PL/SQL Records */
struct sqltdss
{
  unsigned int tdsvsn; 
  unsigned short tdsnum; 
  unsigned char *tdsval[1]; 
};
typedef struct sqltdss sqltdss;
static struct sqltdss sqltds =
{
  1,
  0,
};

/* File name & Package Name */
struct sqlcxp
{
  unsigned short fillen;
           char  filnam[16];
};
static const struct sqlcxp sqlfpn =
{
    15,
    "hmdcparoraio.pc"
};


static unsigned int sqlctx = 2382019;


static struct sqlexd {
   unsigned int   sqlvsn;
   unsigned int   arrsiz;
   unsigned int   iters;
   unsigned int   offset;
   unsigned short selerr;
   unsigned short sqlety;
   unsigned int   occurs;
      const short *cud;
   unsigned char  *sqlest;
      const char  *stmt;
   sqladts *sqladtp;
   sqltdss *sqltdsp;
            void  **sqphsv;
   unsigned int   *sqphsl;
            int   *sqphss;
            void  **sqpind;
            int   *sqpins;
   unsigned int   *sqparm;
   unsigned int   **sqparc;
   unsigned short  *sqpadto;
   unsigned short  *sqptdso;
   unsigned int   sqlcmax;
   unsigned int   sqlcmin;
   unsigned int   sqlcincr;
   unsigned int   sqlctimeout;
   unsigned int   sqlcnowait;
              int   sqfoff;
   unsigned int   sqcmod;
   unsigned int   sqfmod;
            void  *sqhstv[11];
   unsigned int   sqhstl[11];
            int   sqhsts[11];
            void  *sqindv[11];
            int   sqinds[11];
   unsigned int   sqharm[11];
   unsigned int   *sqharc[11];
   unsigned short  sqadto[11];
   unsigned short  sqtdso[11];
} sqlstm = {12,11};

// Prototypes
extern "C" {
  void sqlcxt (void **, unsigned int *,
               struct sqlexd *, const struct sqlcxp *);
  void sqlcx2t(void **, unsigned int *,
               struct sqlexd *, const struct sqlcxp *);
  void sqlbuft(void **, char *);
  void sqlgs2t(void **, char *);
  void sqlorat(void **, unsigned int *, void *);
}

// Forms Interface
static const int IAPSUCC = 0;
static const int IAPFAIL = 1403;
static const int IAPFTL  = 535;
extern "C" { void sqliem(char *, int *); }

 static const char *sq0002 = 
"select mbo_local_pos_id ,n_tdc_chan  from mdc_ana.mdcrawstruct_at_histdate w\
here mdc_hwobj_id=:b0 order by mbo_local_pos_id            ";

 static const char *sq0003 = 
"select layer_nr ,n_wires  from mdc_ana.mdclayerparam where mdc_hwobj_id=:b0 \
          ";

 static const char *sq0005 = 
"select mbo_local_pos_id ,tdc_nr ,tdc_chan ,layer_nr ,wire_nr ,readout_side  \
from mdc_ana.mdclookupgeom_at_histdate where mdc_hwobj_id=:b0 order by mbo_loc\
al_pos_id            ";

 static const char *sq0007 = 
"select mbo_local_pos_id ,mbo_pos_in_lvl1 ,roc_input_con ,roc_pos_in_crate ,s\
am_input_con ,sam_pos  from mdc_ana.mdcreadout_at_run_hist where mdc_hwobj_id=\
:b0 order by mbo_local_pos_id            ";

 static const char *sq0009 = 
"select layer_nr ,layer_name  from mdc_ana.mdclayerparam where mdc_hwobj_id=:\
b0           ";

 static const char *sq0016 = 
"select mbo ,tdc ,chan ,slope ,slope_err ,slope_method ,offset ,offset_err ,o\
ffset_method  from mdc_ana.mdc_cal1par_data where (mdc=:b0 and version=:b1) or\
der by mbo            ";

 static const char *sq0017 = 
"select angle_step ,distance_bin ,drifttime1 ,drifttime2 ,drifttime1_err ,dri\
fttime2_err  from mdc_ana.cal2parsim_data where (det_part_id=:b0 and vers_id=:\
b1)           ";

 static const char *sq0020 = 
"select layer_nr ,cell_thickness ,cell_pitch ,inclination_angle ,central_wire\
_nr ,cathode_wire_thickness  from mdc_ana.layergeompar_data where (det_part_id\
=:b0 and vers_id=:b1)           ";

 static const char *sq0041 = 
"select mbo_local_pos_id ,tdc_number ,channel_mask ,calibration_mask  from md\
c_ana.mask_data ,mdc_ana.mask_address where ((mdc_hwobj_id=:b0 and vers_id=:b1\
) and mask_data.mask_address_id=mask_address.mask_address_id) order by mbo_loc\
al_pos_id,tdc_number            ";

typedef struct { unsigned short len; unsigned char arr[1]; } VARCHAR;
typedef struct { unsigned short len; unsigned char arr[1]; } varchar;

/* cud (compilation unit data) array */
static const short sqlcud0[] =
{12,4130,1,0,0,
5,0,0,1,89,0,4,167,0,0,3,0,0,1,0,2,3,0,0,2,3,0,0,2,3,0,0,
32,0,0,2,135,0,9,254,0,0,1,1,0,1,0,1,3,0,0,
51,0,0,2,0,0,13,256,0,0,2,0,0,1,0,2,3,0,0,2,3,0,0,
74,0,0,2,0,0,15,272,0,0,0,0,0,1,0,
89,0,0,3,86,0,9,311,0,0,1,1,0,1,0,1,3,0,0,
108,0,0,3,0,0,13,313,0,0,2,0,0,1,0,2,3,0,0,2,3,0,0,
131,0,0,3,0,0,15,328,0,0,0,0,0,1,0,
146,0,0,4,127,0,4,355,0,0,2,0,0,1,0,2,4,0,0,2,4,0,0,
169,0,0,5,175,0,9,413,0,0,1,1,0,1,0,1,3,0,0,
188,0,0,5,0,0,13,415,0,0,6,0,0,1,0,2,3,0,0,2,3,0,0,2,3,0,0,2,3,0,0,2,3,0,0,2,
97,0,0,
227,0,0,5,0,0,15,438,0,0,0,0,0,1,0,
242,0,0,6,883,0,4,469,0,0,6,0,0,1,0,2,4,0,0,2,4,0,0,2,4,0,0,2,4,0,0,2,4,0,0,2,
4,0,0,
281,0,0,7,195,0,9,549,0,0,1,1,0,1,0,1,3,0,0,
300,0,0,7,0,0,13,551,0,0,6,0,0,1,0,2,3,0,0,2,3,0,0,2,3,0,0,2,3,0,0,2,3,0,0,2,3,
0,0,
339,0,0,7,0,0,15,573,0,0,0,0,0,1,0,
354,0,0,8,116,0,4,626,0,0,4,0,0,1,0,2,3,0,0,2,3,0,0,2,3,0,0,2,9,0,0,
385,0,0,9,89,0,9,699,0,0,1,1,0,1,0,1,3,0,0,
404,0,0,9,0,0,13,700,0,0,2,0,0,1,0,2,3,0,0,2,9,0,0,
427,0,0,9,0,0,15,710,0,0,0,0,0,1,0,
442,0,0,10,168,0,4,761,0,0,5,1,0,1,0,2,3,0,0,2,3,0,0,2,4,0,0,2,4,0,0,1,3,0,0,
477,0,0,11,171,0,4,769,0,0,5,1,0,1,0,2,3,0,0,2,3,0,0,2,4,0,0,2,4,0,0,1,3,0,0,
512,0,0,12,173,0,4,777,0,0,5,1,0,1,0,2,3,0,0,2,3,0,0,2,4,0,0,2,4,0,0,1,3,0,0,
547,0,0,13,155,0,4,822,0,0,4,1,0,1,0,2,3,0,0,2,4,0,0,2,4,0,0,1,3,0,0,
578,0,0,14,155,0,4,830,0,0,4,1,0,1,0,2,3,0,0,2,4,0,0,2,4,0,0,1,3,0,0,
609,0,0,15,156,0,4,838,0,0,4,1,0,1,0,2,3,0,0,2,4,0,0,2,4,0,0,1,3,0,0,
640,0,0,16,176,0,9,905,0,0,2,2,0,1,0,1,3,0,0,1,3,0,0,
663,0,0,16,0,0,13,906,0,0,9,0,0,1,0,2,3,0,0,2,3,0,0,2,3,0,0,2,4,0,0,2,4,0,0,2,
4,0,0,2,4,0,0,2,4,0,0,2,4,0,0,
714,0,0,16,0,0,15,918,0,0,0,0,0,1,0,
729,0,0,16,0,0,15,938,0,0,0,0,0,1,0,
744,0,0,17,168,0,9,992,0,0,2,2,0,1,0,1,3,0,0,1,3,0,0,
767,0,0,17,0,0,13,993,0,0,6,0,0,1,0,2,3,0,0,2,3,0,0,2,4,0,0,2,4,0,0,2,4,0,0,2,
4,0,0,
806,0,0,17,0,0,15,1019,0,0,0,0,0,1,0,
821,0,0,18,103,0,4,1049,0,0,5,1,0,1,0,2,3,0,0,2,4,0,0,2,4,0,0,2,4,0,0,1,3,0,0,
856,0,0,19,240,0,4,1091,0,0,9,1,0,1,0,2,3,0,0,2,3,0,0,2,4,0,0,2,4,0,0,2,4,0,0,
2,4,0,0,2,4,0,0,2,4,0,0,1,3,0,0,
907,0,0,20,186,0,9,1159,0,0,2,2,0,1,0,1,3,0,0,1,3,0,0,
930,0,0,20,0,0,13,1160,0,0,6,0,0,1,0,2,3,0,0,2,4,0,0,2,4,0,0,2,4,0,0,2,4,0,0,2,
4,0,0,
969,0,0,20,0,0,15,1173,0,0,0,0,0,1,0,
984,0,0,21,209,0,4,1208,0,0,10,1,0,1,0,2,3,0,0,2,3,0,0,2,3,0,0,2,3,0,0,2,4,0,0,
2,4,0,0,2,4,0,0,2,4,0,0,2,4,0,0,1,3,0,0,
1039,0,0,22,237,0,6,1280,0,0,5,5,0,1,0,3,3,0,0,1,3,0,0,1,3,0,0,1,97,0,0,1,97,0,
0,
1074,0,0,23,237,0,6,1290,0,0,5,5,0,1,0,3,3,0,0,1,3,0,0,1,3,0,0,1,97,0,0,1,97,0,
0,
1109,0,0,24,237,0,6,1300,0,0,5,5,0,1,0,3,3,0,0,1,3,0,0,1,3,0,0,1,97,0,0,1,97,0,
0,
1144,0,0,25,240,0,6,1310,0,0,5,5,0,1,0,3,3,0,0,1,3,0,0,1,3,0,0,1,97,0,0,1,97,0,
0,
1179,0,0,26,242,0,6,1320,0,0,5,5,0,1,0,3,3,0,0,1,3,0,0,1,3,0,0,1,97,0,0,1,97,0,
0,
1214,0,0,27,242,0,6,1330,0,0,5,5,0,1,0,3,3,0,0,1,3,0,0,1,3,0,0,1,97,0,0,1,97,0,
0,
1249,0,0,28,188,0,6,1340,0,0,3,3,0,1,0,3,3,0,0,1,97,0,0,1,97,0,0,
1276,0,0,29,189,0,6,1350,0,0,3,3,0,1,0,3,3,0,0,1,97,0,0,1,97,0,0,
1303,0,0,30,203,0,6,1360,0,0,3,3,0,1,0,3,3,0,0,1,97,0,0,1,97,0,0,
1330,0,0,31,212,0,3,1446,0,0,11,11,0,1,0,1,3,0,0,1,3,0,0,1,3,0,0,1,3,0,0,1,3,0,
0,1,4,0,0,1,4,0,0,1,4,0,0,1,4,0,0,1,4,0,0,1,4,0,0,
1389,0,0,32,95,0,3,1500,0,0,5,5,0,1,0,1,3,0,0,1,3,0,0,1,3,0,0,1,4,0,0,1,4,0,0,
1424,0,0,33,151,0,3,1558,0,0,8,8,0,1,0,1,3,0,0,1,3,0,0,1,4,0,0,1,4,0,0,1,4,0,0,
1,4,0,0,1,4,0,0,1,4,0,0,
1471,0,0,34,174,0,3,1620,0,0,8,8,0,1,0,1,3,0,0,1,3,0,0,1,3,0,0,1,3,0,0,1,4,0,0,
1,4,0,0,1,4,0,0,1,4,0,0,
1518,0,0,35,192,0,3,1688,0,0,10,10,0,1,0,1,3,0,0,1,3,0,0,1,3,0,0,1,3,0,0,1,3,0,
0,1,4,0,0,1,4,0,0,1,4,0,0,1,4,0,0,1,4,0,0,
1573,0,0,36,86,0,4,1713,0,0,2,1,0,1,0,2,3,0,0,1,3,0,0,
1596,0,0,37,63,0,4,1745,0,0,2,1,0,1,0,2,3,0,0,1,3,0,0,
1619,0,0,38,141,0,4,1749,0,0,6,1,0,1,0,2,3,0,0,2,3,0,0,2,3,0,0,2,3,0,0,2,9,0,0,
1,3,0,0,
1658,0,0,39,138,0,3,1836,0,0,6,6,0,1,0,1,3,0,0,1,3,0,0,1,3,0,0,1,3,0,0,1,3,0,0,
1,97,0,0,
1697,0,0,40,192,0,3,1897,0,0,8,8,0,1,0,1,3,0,0,1,3,0,0,1,3,0,0,1,4,0,0,1,4,0,0,
1,4,0,0,1,4,0,0,1,4,0,0,
1744,0,0,42,64,0,4,1944,0,0,2,1,0,1,0,2,3,0,0,1,3,0,0,
1767,0,0,41,264,0,9,1957,0,0,2,2,0,1,0,1,3,0,0,1,3,0,0,
1790,0,0,41,0,0,13,1958,0,0,4,0,0,1,0,2,3,0,0,2,3,0,0,2,97,0,0,2,97,0,0,
1821,0,0,41,0,0,15,1970,0,0,0,0,0,1,0,
1836,0,0,41,0,0,15,1990,0,0,0,0,0,1,0,
1851,0,0,43,161,0,3,2035,0,0,6,6,0,1,0,1,3,0,0,1,3,0,0,1,3,0,0,1,3,0,0,1,97,0,
0,1,97,0,0,
1890,0,0,44,88,0,6,2060,0,0,1,1,0,1,0,1,3,0,0,
1909,0,0,45,89,0,6,2085,0,0,1,1,0,1,0,1,3,0,0,
1928,0,0,46,203,0,4,2111,0,0,2,1,0,1,0,2,3,0,0,1,3,0,0,
1951,0,0,47,204,0,4,2136,0,0,2,1,0,1,0,2,3,0,0,1,3,0,0,
1974,0,0,48,153,0,3,2200,0,0,7,7,0,1,0,1,3,0,0,1,3,0,0,1,3,0,0,1,3,0,0,1,3,0,0,
1,3,0,0,1,3,0,0,
2017,0,0,49,79,0,6,2209,0,0,1,1,0,1,0,1,3,0,0,
};


//*-- AUTHOR : Ilse Koenig
//*-- Modified : 22/11/2005 by I.Koenig
//*-- Modified : 02/07/2003 by I.Koenig
//*-- Modified : 19/11/2002 by I.Koenig
//*-- Modified : 29/10/2002 by I.Koenig
//*-- Modified : 26/07/2002 by I.Koenig
//*-- Modified : 15/07/2002 by I.Koenig
//*-- Modified : 31/05/2002 by I.Koenig
//*-- Modified : 21/02/2000 by I.Koenig

//_HADES_CLASS_DESCRIPTION 
//////////////////////////////////////////////////////////////////////////////
// HMdcParOraIo
//
// Interface class to database Oracle for input/output of parameters needed
// by the Mdc
// (uses the Oracle C/C++ precompiler)
//
//////////////////////////////////////////////////////////////////////////////
using namespace std;
#include "hmdcparoraio.h"
#include "hades.h"
#include "hruntimedb.h"
#include "hrun.h"
#include "hspectrometer.h"
#include "hdetector.h"
#include "hmdcdetector.h"
#include "hmdcrawstruct.h"
#include "hmdcgeomstruct.h"
#include "hmdccalparraw.h"
#include "hmdclookupgeom.h"
#include "hmdclayergeompar.h"
#include "hmdcmboreadout.h"
#include "hmdcgeompar.h"
#include "hgeomcompositevolume.h"
#include "hmdccelleff.h"
#include "hmdctimecut.h"
#include "hmdccal2parsim.h"
#include "hmdctdcthreshold.h"
#include "hmdcclosepaircutspar.h"
#include "hmdctdcchannel.h"
#include "hgeomoradetversion.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(HMdcParOraIo)

#define MDC_MAXMODS 24
#define MDC_MAXMOTHS 16
#define MDC_MAXLAYS 6
#define MDC_MAXTOTLAYS 144
#define MDC_MAXWIRES 1320
#define MDC_MAXCHAN 1536
#define MDC_MAXARR 2000
#define MDC_MAXSMALLARR 50

HMdcParOraIo::HMdcParOraIo(HOraConn* pC) : HDetParOraIo(pC) {
  // constructor
  // sets the name of the I/O class "HMdcParIo"
  // gets the pointer to the connection class
  fName="HMdcParIo";
  numModules=0;
  mdcIds=0;
  modIds=0;
  initModules=0;
  geomVers=0;
}


HMdcParOraIo::~HMdcParOraIo() {
  // destructor
  if (mdcIds) delete mdcIds;
  if (modIds) delete modIds;
  if (initModules) delete initModules;
  if (geomVers) delete geomVers;
}


Bool_t HMdcParOraIo::init(HParSet* pPar,Int_t* set) {
  // calls special read-function for each parameter container
  const Text_t* name=pPar->IsA()->GetName();
  if (strcmp(name,"HMdcSetup")==0) return readCond((HParCond*)pPar,set);
  if (strcmp(name,"HMdcDigitPar")==0) return readCond((HParCond*)pPar,set);
  if (strcmp(name,"HMdcTrackFitPar")==0) return readCond((HParCond*)pPar,set);
  if (strcmp(name,"HMdcTdcThreshold")==0) return read((HMdcTdcThreshold*)pPar,set);
  if (strcmp(name,"HMdcClosePairCutsPar")==0) return read((HMdcClosePairCutsPar*)pPar,set);
  if (startIo(pPar)<=0) return kFALSE;
  if (strcmp(name,"HMdcRawStruct")==0) return read((HMdcRawStruct*)pPar,set);
  if (strcmp(name,"HMdcGeomStruct")==0) return read((HMdcGeomStruct*)pPar,set);
  if (strcmp(name,"HMdcLookupGeom")==0) return read((HMdcLookupGeom*)pPar,set);	
  if (strcmp(name,"HMdcMboReadout")==0) return read((HMdcMboReadout*)pPar,set);
  if (strcmp(name,"HMdcLayerGeomPar")==0) return read((HMdcLayerGeomPar*)pPar,set);
  if (strcmp(name,"HMdcGeomPar")==0) return read((HMdcGeomPar*)pPar,set);
  if (strcmp(name,"HMdcCalParRaw")==0) return read((HMdcCalParRaw*)pPar,set);
  if (strcmp(name,"HMdcCellEff")==0) return read((HMdcCellEff*)pPar,set);
  if (strcmp(name,"HMdcTimeCut")==0) return read((HMdcTimeCut*)pPar,set);
  if (strcmp(name,"HMdcCal2ParSim")==0) return read((HMdcCal2ParSim*)pPar,set);
  if (strcmp(name,"HMdcTdcChannel")==0) return read((HMdcTdcChannel*)pPar,set);
  cout<<"initialization of "<<name<<" not possible from Oracle!"<<endl;
  return kFALSE;
}


Int_t HMdcParOraIo::write(HParSet* pPar) {
  // calls the appropriate write function for the container
  const Text_t* name=pPar->IsA()->GetName();
  if ((runStart=getRunStart(pPar))<=0) return -1;
  if (strcmp(name,"HMdcSetup")==0) return writeCond((HParCond*)pPar);
  if (strcmp(name,"HMdcDigitPar")==0) return writeCond((HParCond*)pPar);
  if (strcmp(name,"HMdcTrackFitPar")==0) return writeCond((HParCond*)pPar);
  if (strcmp(name,"HMdcTdcThreshold")==0) return writePar((HMdcTdcThreshold*)pPar);
  if (strcmp(name,"HMdcClosePairCutsPar")==0) return writePar((HMdcClosePairCutsPar*)pPar);
  if (startIo(pPar)<=0) return -1;
  if (strcmp(name,"HMdcCalParRaw")==0) return writePar((HMdcCalParRaw*)pPar);
  if (strcmp(name,"HMdcCellEff")==0) return writePar((HMdcCellEff*)pPar);
  if (strcmp(name,"HMdcTimeCut")==0) return writePar((HMdcTimeCut*)pPar);
  if (strcmp(name,"HMdcGeomPar")==0) return writeAlignment((HMdcGeomPar*)pPar);
  if (strcmp(name,"HMdcCal2ParSim")==0) return writePar((HMdcCal2ParSim*)pPar);
  if (strcmp(name,"HMdcLayerGeomPar")==0) return writePar((HMdcLayerGeomPar*)pPar);
  if (strcmp(name,"HMdcTdcChannel")==0) return writePar((HMdcTdcChannel*)pPar);
  if (strcmp(name,"HMdcLookupGeom")==0) return writePar((HMdcLookupGeom*)pPar);
  cout<<"No write-interface to Oracle for parameter container "
      <<pPar->GetName()<<endl;
  return 0;
}


Int_t HMdcParOraIo::startIo(HParSet* pPar) {
  // gets the run start of the actual run
  // reads the detector setup from Oracle for the first run and returns the number
  //   of modules found
  // returns -1, if the run is not found, or 0, if no modules are found for this run
  runStart=getRunStart(pPar);
  if (runStart>0 && mdcIds==0) readIds();
  if (runStart==-1 || numModules<=0) {
    pPar->setInputVersion(-1,inputNumber);
    return -1;
  }
  return runStart;
}


Int_t HMdcParOraIo::readIds() {
  // reads the id numbers of all modules defined for the actual run
  // and stores them in array mdcIds
  // returns the number of modules found
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    struct {
      int mdc[MDC_MAXMODS]; 
      int sec[MDC_MAXMODS];
      int pla[MDC_MAXMODS];
    } mods;
  /* EXEC SQL END DECLARE SECTION; */ 


  /* EXEC SQL WHENEVER SQLERROR DO showSqlError("readIds()"); */ 

  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 


  /* EXEC SQL SELECT mdc_hwobj_id, sector, plane
    INTO :mods
    FROM mdc_ana.mdc_loc_at_run_hist; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 3;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "select mdc_hwobj_id ,sector ,plane into :s1 ,:s2 ,:s3   fro\
m mdc_ana.mdc_loc_at_run_hist ";
  sqlstm.iters = (unsigned int  )24;
  sqlstm.offset = (unsigned int  )5;
  sqlstm.selerr = (unsigned short)1;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)mods.mdc;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )sizeof(int);
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqharc[0] = (unsigned int   *)0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqhstv[1] = (         void  *)mods.sec;
  sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[1] = (         int  )sizeof(int);
  sqlstm.sqindv[1] = (         void  *)0;
  sqlstm.sqinds[1] = (         int  )0;
  sqlstm.sqharm[1] = (unsigned int  )0;
  sqlstm.sqharc[1] = (unsigned int   *)0;
  sqlstm.sqadto[1] = (unsigned short )0;
  sqlstm.sqtdso[1] = (unsigned short )0;
  sqlstm.sqhstv[2] = (         void  *)mods.pla;
  sqlstm.sqhstl[2] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[2] = (         int  )sizeof(int);
  sqlstm.sqindv[2] = (         void  *)0;
  sqlstm.sqinds[2] = (         int  )0;
  sqlstm.sqharm[2] = (unsigned int  )0;
  sqlstm.sqharc[2] = (unsigned int   *)0;
  sqlstm.sqadto[2] = (unsigned short )0;
  sqlstm.sqtdso[2] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) showSqlError("readIds()");
}



  numModules=sqlca.sqlerrd[2];
  Int_t maxId=0;
  HMdcDetector* det=(HMdcDetector*)(gHades->getSetup()->getDetector("Mdc"));
  Int_t s, p, pos;
  if (numModules>0) {
    mdcIds=new TArrayI(MDC_MAXMODS);
    for(Int_t i=0;i<MDC_MAXMODS;i++) mdcIds->AddAt(0,i);
    initModules=new TArrayI(MDC_MAXMODS);
    for(Int_t i=0;i<numModules;i++) {
      s=mods.sec[i]-1;
      p=mods.pla[i]-1;
      pos=s*4+p;
      if (det->getModule(s,p)) {
        mdcIds->AddAt(mods.mdc[i],pos);
        maxId=(mods.mdc[i]>maxId)?mods.mdc[i]:maxId;
      }
    }
    if (maxId>0) {
      modIds=new TArrayI((++maxId));
      for(Int_t i=0;i<maxId;i++) modIds->AddAt(0,i);
      for(Int_t i=0;i<mdcIds->GetSize();i++) {
        Int_t j=mdcIds->At(i);
        if (j) modIds->AddAt(j,j);
      }
    }
    //printIds();
  }
  return numModules;
}
 

void HMdcParOraIo::printIds() {
  // prints the id numbers of all modules
  if (mdcIds) {
    for(Int_t i=0;i<6;i++) {
      cout<<"sector: "<<i+1<<"   mdc ids:";
      for(Int_t j=0;j<4;j++) { cout<<" "<<mdcIds->At(i*4+j); }
      cout<<'\n';
    }
    cout<<'\n';
  }
}


Bool_t HMdcParOraIo::read(HMdcRawStruct* pPar,Int_t* set) {
  // reads the names (characterizes the position) of the motherboards
  // and the maximum number of TDCs on each of it and fills the
  // MdcRawStruct container
  Int_t nMoths=-1, pos;
  Char_t mboName[4];
  
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int id;
    struct {
      int mbo[MDC_MAXMOTHS]; 
      int nChan[MDC_MAXMOTHS];
    } moths;
    struct {
      short mbo_Ind[MDC_MAXMOTHS]; 
      short nChan_Ind[MDC_MAXMOTHS];
    } moths_Ind;
  /* EXEC SQL END DECLARE SECTION; */ 


  /* EXEC SQL WHENEVER SQLERROR DO showSqlError("read(HMdcRawStruct*,Int_t*)"); */ 

  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 


  /* EXEC SQL DECLARE c1 CURSOR FOR
    SELECT  mbo_local_pos_id, n_tdc_chan
    FROM mdc_ana.mdcrawstruct_at_histdate
    WHERE mdc_hwobj_id=:id
    ORDER BY mbo_local_pos_id; */ 


  Bool_t allFound=kTRUE, isOpenCursor=kFALSE;
  initModules->Reset();
  HMdcRawStruct& mdc=*pPar;
  for(Int_t i=0;i<6;i++) {
    HMdcRawSecStru& sec=mdc[i];
    for(Int_t j=0;j<4;j++) {
      HMdcRawModStru& mod=sec[j];
      pos=i*4+j;
      if (set[pos]) {
        id=mdcIds->At(pos);
        if (id>0) {
          /* EXEC SQL OPEN c1; */ 

{
          struct sqlexd sqlstm;
          sqlorat((void **)0, &sqlctx, &oraca);
          sqlstm.sqlvsn = 12;
          sqlstm.arrsiz = 3;
          sqlstm.sqladtp = &sqladt;
          sqlstm.sqltdsp = &sqltds;
          sqlstm.stmt = sq0002;
          sqlstm.iters = (unsigned int  )1;
          sqlstm.offset = (unsigned int  )32;
          sqlstm.selerr = (unsigned short)1;
          sqlstm.cud = sqlcud0;
          sqlstm.sqlest = (unsigned char  *)&sqlca;
          sqlstm.sqlety = (unsigned short)256;
          sqlstm.occurs = (unsigned int  )0;
          sqlstm.sqcmod = (unsigned int )0;
          sqlstm.sqhstv[0] = (         void  *)&id;
          sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[0] = (         int  )0;
          sqlstm.sqindv[0] = (         void  *)0;
          sqlstm.sqinds[0] = (         int  )0;
          sqlstm.sqharm[0] = (unsigned int  )0;
          sqlstm.sqadto[0] = (unsigned short )0;
          sqlstm.sqtdso[0] = (unsigned short )0;
          sqlstm.sqphsv = sqlstm.sqhstv;
          sqlstm.sqphsl = sqlstm.sqhstl;
          sqlstm.sqphss = sqlstm.sqhsts;
          sqlstm.sqpind = sqlstm.sqindv;
          sqlstm.sqpins = sqlstm.sqinds;
          sqlstm.sqparm = sqlstm.sqharm;
          sqlstm.sqparc = sqlstm.sqharc;
          sqlstm.sqpadto = sqlstm.sqadto;
          sqlstm.sqptdso = sqlstm.sqtdso;
          sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
          if (sqlca.sqlcode < 0) showSqlError("read(HMdcRawStruct*,Int_t*)");
}


          isOpenCursor=kTRUE;
          /* EXEC SQL FETCH c1 INTO :moths INDICATOR :moths_Ind; */ 

{
          struct sqlexd sqlstm;
          sqlorat((void **)0, &sqlctx, &oraca);
          sqlstm.sqlvsn = 12;
          sqlstm.arrsiz = 3;
          sqlstm.sqladtp = &sqladt;
          sqlstm.sqltdsp = &sqltds;
          sqlstm.iters = (unsigned int  )16;
          sqlstm.offset = (unsigned int  )51;
          sqlstm.selerr = (unsigned short)1;
          sqlstm.cud = sqlcud0;
          sqlstm.sqlest = (unsigned char  *)&sqlca;
          sqlstm.sqlety = (unsigned short)256;
          sqlstm.occurs = (unsigned int  )0;
          sqlstm.sqfoff = (           int )0;
          sqlstm.sqfmod = (unsigned int )2;
          sqlstm.sqhstv[0] = (         void  *)moths.mbo;
          sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[0] = (         int  )sizeof(int);
          sqlstm.sqindv[0] = (         void  *)moths_Ind.mbo_Ind;
          sqlstm.sqinds[0] = (         int  )sizeof(short);
          sqlstm.sqharm[0] = (unsigned int  )0;
          sqlstm.sqharc[0] = (unsigned int   *)0;
          sqlstm.sqadto[0] = (unsigned short )0;
          sqlstm.sqtdso[0] = (unsigned short )0;
          sqlstm.sqhstv[1] = (         void  *)moths.nChan;
          sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[1] = (         int  )sizeof(int);
          sqlstm.sqindv[1] = (         void  *)moths_Ind.nChan_Ind;
          sqlstm.sqinds[1] = (         int  )sizeof(short);
          sqlstm.sqharm[1] = (unsigned int  )0;
          sqlstm.sqharc[1] = (unsigned int   *)0;
          sqlstm.sqadto[1] = (unsigned short )0;
          sqlstm.sqtdso[1] = (unsigned short )0;
          sqlstm.sqphsv = sqlstm.sqhstv;
          sqlstm.sqphsl = sqlstm.sqhstl;
          sqlstm.sqphss = sqlstm.sqhsts;
          sqlstm.sqpind = sqlstm.sqindv;
          sqlstm.sqpins = sqlstm.sqinds;
          sqlstm.sqparm = sqlstm.sqharm;
          sqlstm.sqparc = sqlstm.sqharc;
          sqlstm.sqpadto = sqlstm.sqadto;
          sqlstm.sqptdso = sqlstm.sqtdso;
          sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
          if (sqlca.sqlcode < 0) showSqlError("read(HMdcRawStruct*,Int_t*)");
}


          nMoths=sqlca.sqlerrd[2];
          if (nMoths>0) {
            set[pos]=0;
            initModules->AddAt(pos+1,pos);
            for(Int_t i=0;i<nMoths;i++) {
              sprintf(mboName,"%3i",moths.mbo[i]);
              mod[i].SetName(mboName);
              mod[i].setNTdcs(moths.nChan[i]);
            }
          } else allFound=kFALSE;
        } else allFound=kFALSE;
      }
    }
  }
  if (isOpenCursor) {
    /* EXEC SQL CLOSE c1; */ 

{
    struct sqlexd sqlstm;
    sqlorat((void **)0, &sqlctx, &oraca);
    sqlstm.sqlvsn = 12;
    sqlstm.arrsiz = 3;
    sqlstm.sqladtp = &sqladt;
    sqlstm.sqltdsp = &sqltds;
    sqlstm.iters = (unsigned int  )1;
    sqlstm.offset = (unsigned int  )74;
    sqlstm.cud = sqlcud0;
    sqlstm.sqlest = (unsigned char  *)&sqlca;
    sqlstm.sqlety = (unsigned short)256;
    sqlstm.occurs = (unsigned int  )0;
    sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
    if (sqlca.sqlcode < 0) showSqlError("read(HMdcRawStruct*,Int_t*)");
}


    setChanged(pPar);
    printInfo(pPar->GetName());
  } else pPar->setInputVersion(-1,inputNumber);
  return allFound;
}   


Bool_t HMdcParOraIo::read(HMdcGeomStruct* pPar,Int_t* set) {
  // reads the number of cells in each layer and fills the
  // MdcGeomStruct container
  Int_t nLayers=-1, pos;
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int id;
    struct {
      int lay[MDC_MAXLAYS];
      int nWir[MDC_MAXLAYS];
    } layers;
  /* EXEC SQL END DECLARE SECTION; */ 


  /* EXEC SQL WHENEVER SQLERROR DO showSqlError("read(HMdcGeomStruct*,Int_t*)"); */ 

  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 


  /* EXEC SQL DECLARE c2 CURSOR FOR
    SELECT layer_nr, n_wires 
    FROM mdc_ana.mdclayerparam
    WHERE mdc_hwobj_id=:id; */ 


  Bool_t allFound=kTRUE, isOpenCursor=kFALSE;
  initModules->Reset();
  HMdcGeomStruct& mdc=*pPar;
  for(Int_t i=0;i<6;i++) {
    HMdcGeomSecStru& sec=mdc[i];
    for(Int_t j=0;j<4;j++) {
      HMdcGeomModStru& mod=sec[j];
      pos=i*4+j;
      if (set[pos]) {
        id=mdcIds->At(pos);
        if (id>0) {
          /* EXEC SQL OPEN c2; */ 

{
          struct sqlexd sqlstm;
          sqlorat((void **)0, &sqlctx, &oraca);
          sqlstm.sqlvsn = 12;
          sqlstm.arrsiz = 3;
          sqlstm.sqladtp = &sqladt;
          sqlstm.sqltdsp = &sqltds;
          sqlstm.stmt = sq0003;
          sqlstm.iters = (unsigned int  )1;
          sqlstm.offset = (unsigned int  )89;
          sqlstm.selerr = (unsigned short)1;
          sqlstm.cud = sqlcud0;
          sqlstm.sqlest = (unsigned char  *)&sqlca;
          sqlstm.sqlety = (unsigned short)256;
          sqlstm.occurs = (unsigned int  )0;
          sqlstm.sqcmod = (unsigned int )0;
          sqlstm.sqhstv[0] = (         void  *)&id;
          sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[0] = (         int  )0;
          sqlstm.sqindv[0] = (         void  *)0;
          sqlstm.sqinds[0] = (         int  )0;
          sqlstm.sqharm[0] = (unsigned int  )0;
          sqlstm.sqadto[0] = (unsigned short )0;
          sqlstm.sqtdso[0] = (unsigned short )0;
          sqlstm.sqphsv = sqlstm.sqhstv;
          sqlstm.sqphsl = sqlstm.sqhstl;
          sqlstm.sqphss = sqlstm.sqhsts;
          sqlstm.sqpind = sqlstm.sqindv;
          sqlstm.sqpins = sqlstm.sqinds;
          sqlstm.sqparm = sqlstm.sqharm;
          sqlstm.sqparc = sqlstm.sqharc;
          sqlstm.sqpadto = sqlstm.sqadto;
          sqlstm.sqptdso = sqlstm.sqtdso;
          sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
          if (sqlca.sqlcode < 0) showSqlError("read(HMdcGeomStruct*,Int_t*)");
}


          isOpenCursor=kTRUE;
          /* EXEC SQL FETCH c2 INTO :layers; */ 

{
          struct sqlexd sqlstm;
          sqlorat((void **)0, &sqlctx, &oraca);
          sqlstm.sqlvsn = 12;
          sqlstm.arrsiz = 3;
          sqlstm.sqladtp = &sqladt;
          sqlstm.sqltdsp = &sqltds;
          sqlstm.iters = (unsigned int  )6;
          sqlstm.offset = (unsigned int  )108;
          sqlstm.selerr = (unsigned short)1;
          sqlstm.cud = sqlcud0;
          sqlstm.sqlest = (unsigned char  *)&sqlca;
          sqlstm.sqlety = (unsigned short)256;
          sqlstm.occurs = (unsigned int  )0;
          sqlstm.sqfoff = (           int )0;
          sqlstm.sqfmod = (unsigned int )2;
          sqlstm.sqhstv[0] = (         void  *)layers.lay;
          sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[0] = (         int  )sizeof(int);
          sqlstm.sqindv[0] = (         void  *)0;
          sqlstm.sqinds[0] = (         int  )0;
          sqlstm.sqharm[0] = (unsigned int  )0;
          sqlstm.sqharc[0] = (unsigned int   *)0;
          sqlstm.sqadto[0] = (unsigned short )0;
          sqlstm.sqtdso[0] = (unsigned short )0;
          sqlstm.sqhstv[1] = (         void  *)layers.nWir;
          sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[1] = (         int  )sizeof(int);
          sqlstm.sqindv[1] = (         void  *)0;
          sqlstm.sqinds[1] = (         int  )0;
          sqlstm.sqharm[1] = (unsigned int  )0;
          sqlstm.sqharc[1] = (unsigned int   *)0;
          sqlstm.sqadto[1] = (unsigned short )0;
          sqlstm.sqtdso[1] = (unsigned short )0;
          sqlstm.sqphsv = sqlstm.sqhstv;
          sqlstm.sqphsl = sqlstm.sqhstl;
          sqlstm.sqphss = sqlstm.sqhsts;
          sqlstm.sqpind = sqlstm.sqindv;
          sqlstm.sqpins = sqlstm.sqinds;
          sqlstm.sqparm = sqlstm.sqharm;
          sqlstm.sqparc = sqlstm.sqharc;
          sqlstm.sqpadto = sqlstm.sqadto;
          sqlstm.sqptdso = sqlstm.sqtdso;
          sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
          if (sqlca.sqlcode < 0) showSqlError("read(HMdcGeomStruct*,Int_t*)");
}


          nLayers=sqlca.sqlerrd[2];
          if (nLayers!=MDC_MAXLAYS) allFound=kFALSE;
          else {
            set[pos]=0;
            initModules->AddAt(pos+1,pos);
            for(Int_t i=0;i<nLayers;i++)
              mod.fill((layers.lay[i]-1),layers.nWir[i]);
          }
        }
        else allFound=kFALSE;
      }
    }
  }
  if (isOpenCursor) {
    /* EXEC SQL CLOSE c2; */ 

{
    struct sqlexd sqlstm;
    sqlorat((void **)0, &sqlctx, &oraca);
    sqlstm.sqlvsn = 12;
    sqlstm.arrsiz = 3;
    sqlstm.sqladtp = &sqladt;
    sqlstm.sqltdsp = &sqltds;
    sqlstm.iters = (unsigned int  )1;
    sqlstm.offset = (unsigned int  )131;
    sqlstm.cud = sqlcud0;
    sqlstm.sqlest = (unsigned char  *)&sqlca;
    sqlstm.sqlety = (unsigned short)256;
    sqlstm.occurs = (unsigned int  )0;
    sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
    if (sqlca.sqlcode < 0) showSqlError("read(HMdcGeomStruct*,Int_t*)");
}


    setChanged(pPar);
    printInfo(pPar->GetName());
  } else pPar->setInputVersion(-1,inputNumber);
  return allFound;
} 


Int_t HMdcParOraIo::getLookupVersion(HMdcLookupGeom* pPar) {
  // reads the version for the MdcLookupGeom container valid at the start time
  //   of the actual run
  // if the version differs from the container version, the container must be
  //   reinitialized
  HParOraSet* oraSet=getOraSet(pPar);
  Int_t contVers=pPar->getInputVersion(inputNumber);
  if (contVers!=-1 && runStart>=oraSet->versDate[0] && runStart<=oraSet->versDate[1])
      return contVers;
  oraSet->clearVersDate();

  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    double since;
    double until;
  /* EXEC SQL END DECLARE SECTION; */ 


  /* EXEC SQL WHENEVER SQLERROR DO showSqlError("getLookupVersion(Int_t)"); */ 

  /* EXEC SQL WHENEVER NOT FOUND GOTO notfound; */ 


  /* EXEC SQL SELECT hdate.to_ansitime(MAX(valid_since)),
                  hdate.to_ansitime(MIN(valid_until))
           INTO :since, :until
           FROM mdc_ana.fpc_loc_at_histdate; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 3;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "select hdate.to_ansitime(max(valid_since)) ,hdate.to_ansiti\
me(min(valid_until)) into :b0,:b1  from mdc_ana.fpc_loc_at_histdate ";
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )146;
  sqlstm.selerr = (unsigned short)1;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)&since;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(double);
  sqlstm.sqhsts[0] = (         int  )0;
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqhstv[1] = (         void  *)&until;
  sqlstm.sqhstl[1] = (unsigned int  )sizeof(double);
  sqlstm.sqhsts[1] = (         int  )0;
  sqlstm.sqindv[1] = (         void  *)0;
  sqlstm.sqinds[1] = (         int  )0;
  sqlstm.sqharm[1] = (unsigned int  )0;
  sqlstm.sqadto[1] = (unsigned short )0;
  sqlstm.sqtdso[1] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode == 1403) goto notfound;
  if (sqlca.sqlcode < 0) showSqlError("getLookupVersion(Int_t)");
}


  oraSet->versDate[0]=since;  
  oraSet->versDate[1]=until;  
  return getActRunId();
notfound:
  return -1;
}; 


Bool_t HMdcParOraIo::read(HMdcLookupGeom* pPar, Int_t* set) {
  // reads and fills the container "MdcLookupGeom" for mapping
  Int_t contVers=pPar->getInputVersion(inputNumber);
  Int_t version=getLookupVersion(pPar);
  if (version==-1) {
    pPar->setInputVersion(-1,inputNumber);
    return kFALSE;
  }
  if (contVers==version) return kTRUE;
  if (inputNumber==1) pPar->clear();

  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int id;
    struct {
      int  mbo[MDC_MAXWIRES];
      int  tdc[MDC_MAXWIRES];
      int  chan[MDC_MAXWIRES];
      int  lay[MDC_MAXWIRES];
      int  wire[MDC_MAXWIRES];
      char side[MDC_MAXWIRES][2];
    } lookup;
  /* EXEC SQL END DECLARE SECTION; */ 

  /* EXEC SQL WHENEVER SQLERROR DO showSqlError("read(HMdcLookupGeom*,Int_t*)"); */ 

  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 

  /* EXEC SQL DECLARE c3 CURSOR FOR
    SELECT  mbo_local_pos_id, tdc_nr, tdc_chan, layer_nr, wire_nr, readout_side
    FROM mdc_ana.mdclookupgeom_at_histdate
    WHERE mdc_hwobj_id=:id
    ORDER BY mbo_local_pos_id; */ 

     
  HMdcRawStruct* pRawStruct=
       (HMdcRawStruct*)gHades->getRuntimeDb()->getContainer("MdcRawStruct");
  Bool_t allFound=kTRUE, isOpenCursor=kFALSE;
  initModules->Reset();
  HMdcLookupGeom& mdc=*pPar;
  Int_t nWires=-1, pos, mboNr=-1, mo, ml=-1, ch;
  Char_t buf[4];
   for(Int_t i=0;i<6;i++) {
    HMdcLookupGSec& sec=mdc[i];
    for(Int_t j=0;j<4;j++) {
      HMdcLookupGMod& mod=sec[j];
      pos=i*4+j;
      if (set[pos]) {
        HMdcRawModStru& pModStruct=(*pRawStruct)[i][j];
        id=mdcIds->At(pos);
        if (id>0) {
          /* EXEC SQL OPEN c3; */ 

{
          struct sqlexd sqlstm;
          sqlorat((void **)0, &sqlctx, &oraca);
          sqlstm.sqlvsn = 12;
          sqlstm.arrsiz = 3;
          sqlstm.sqladtp = &sqladt;
          sqlstm.sqltdsp = &sqltds;
          sqlstm.stmt = sq0005;
          sqlstm.iters = (unsigned int  )1;
          sqlstm.offset = (unsigned int  )169;
          sqlstm.selerr = (unsigned short)1;
          sqlstm.cud = sqlcud0;
          sqlstm.sqlest = (unsigned char  *)&sqlca;
          sqlstm.sqlety = (unsigned short)256;
          sqlstm.occurs = (unsigned int  )0;
          sqlstm.sqcmod = (unsigned int )0;
          sqlstm.sqhstv[0] = (         void  *)&id;
          sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[0] = (         int  )0;
          sqlstm.sqindv[0] = (         void  *)0;
          sqlstm.sqinds[0] = (         int  )0;
          sqlstm.sqharm[0] = (unsigned int  )0;
          sqlstm.sqadto[0] = (unsigned short )0;
          sqlstm.sqtdso[0] = (unsigned short )0;
          sqlstm.sqphsv = sqlstm.sqhstv;
          sqlstm.sqphsl = sqlstm.sqhstl;
          sqlstm.sqphss = sqlstm.sqhsts;
          sqlstm.sqpind = sqlstm.sqindv;
          sqlstm.sqpins = sqlstm.sqinds;
          sqlstm.sqparm = sqlstm.sqharm;
          sqlstm.sqparc = sqlstm.sqharc;
          sqlstm.sqpadto = sqlstm.sqadto;
          sqlstm.sqptdso = sqlstm.sqtdso;
          sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
          if (sqlca.sqlcode < 0) showSqlError("read(HMdcLookupGeom*,Int_t*)");
}


          isOpenCursor=kTRUE;
          /* EXEC SQL FETCH c3 INTO :lookup; */ 

{
          struct sqlexd sqlstm;
          sqlorat((void **)0, &sqlctx, &oraca);
          sqlstm.sqlvsn = 12;
          sqlstm.arrsiz = 6;
          sqlstm.sqladtp = &sqladt;
          sqlstm.sqltdsp = &sqltds;
          sqlstm.iters = (unsigned int  )1320;
          sqlstm.offset = (unsigned int  )188;
          sqlstm.selerr = (unsigned short)1;
          sqlstm.cud = sqlcud0;
          sqlstm.sqlest = (unsigned char  *)&sqlca;
          sqlstm.sqlety = (unsigned short)256;
          sqlstm.occurs = (unsigned int  )0;
          sqlstm.sqfoff = (           int )0;
          sqlstm.sqfmod = (unsigned int )2;
          sqlstm.sqhstv[0] = (         void  *)lookup.mbo;
          sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[0] = (         int  )sizeof(int);
          sqlstm.sqindv[0] = (         void  *)0;
          sqlstm.sqinds[0] = (         int  )0;
          sqlstm.sqharm[0] = (unsigned int  )0;
          sqlstm.sqharc[0] = (unsigned int   *)0;
          sqlstm.sqadto[0] = (unsigned short )0;
          sqlstm.sqtdso[0] = (unsigned short )0;
          sqlstm.sqhstv[1] = (         void  *)lookup.tdc;
          sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[1] = (         int  )sizeof(int);
          sqlstm.sqindv[1] = (         void  *)0;
          sqlstm.sqinds[1] = (         int  )0;
          sqlstm.sqharm[1] = (unsigned int  )0;
          sqlstm.sqharc[1] = (unsigned int   *)0;
          sqlstm.sqadto[1] = (unsigned short )0;
          sqlstm.sqtdso[1] = (unsigned short )0;
          sqlstm.sqhstv[2] = (         void  *)lookup.chan;
          sqlstm.sqhstl[2] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[2] = (         int  )sizeof(int);
          sqlstm.sqindv[2] = (         void  *)0;
          sqlstm.sqinds[2] = (         int  )0;
          sqlstm.sqharm[2] = (unsigned int  )0;
          sqlstm.sqharc[2] = (unsigned int   *)0;
          sqlstm.sqadto[2] = (unsigned short )0;
          sqlstm.sqtdso[2] = (unsigned short )0;
          sqlstm.sqhstv[3] = (         void  *)lookup.lay;
          sqlstm.sqhstl[3] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[3] = (         int  )sizeof(int);
          sqlstm.sqindv[3] = (         void  *)0;
          sqlstm.sqinds[3] = (         int  )0;
          sqlstm.sqharm[3] = (unsigned int  )0;
          sqlstm.sqharc[3] = (unsigned int   *)0;
          sqlstm.sqadto[3] = (unsigned short )0;
          sqlstm.sqtdso[3] = (unsigned short )0;
          sqlstm.sqhstv[4] = (         void  *)lookup.wire;
          sqlstm.sqhstl[4] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[4] = (         int  )sizeof(int);
          sqlstm.sqindv[4] = (         void  *)0;
          sqlstm.sqinds[4] = (         int  )0;
          sqlstm.sqharm[4] = (unsigned int  )0;
          sqlstm.sqharc[4] = (unsigned int   *)0;
          sqlstm.sqadto[4] = (unsigned short )0;
          sqlstm.sqtdso[4] = (unsigned short )0;
          sqlstm.sqhstv[5] = (         void  *)lookup.side;
          sqlstm.sqhstl[5] = (unsigned int  )2;
          sqlstm.sqhsts[5] = (         int  )2;
          sqlstm.sqindv[5] = (         void  *)0;
          sqlstm.sqinds[5] = (         int  )0;
          sqlstm.sqharm[5] = (unsigned int  )0;
          sqlstm.sqharc[5] = (unsigned int   *)0;
          sqlstm.sqadto[5] = (unsigned short )0;
          sqlstm.sqtdso[5] = (unsigned short )0;
          sqlstm.sqphsv = sqlstm.sqhstv;
          sqlstm.sqphsl = sqlstm.sqhstl;
          sqlstm.sqphss = sqlstm.sqhsts;
          sqlstm.sqpind = sqlstm.sqindv;
          sqlstm.sqpins = sqlstm.sqinds;
          sqlstm.sqparm = sqlstm.sqharm;
          sqlstm.sqparc = sqlstm.sqharc;
          sqlstm.sqpadto = sqlstm.sqadto;
          sqlstm.sqptdso = sqlstm.sqtdso;
          sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
          if (sqlca.sqlcode < 0) showSqlError("read(HMdcLookupGeom*,Int_t*)");
}


          ml=-1;
          nWires=sqlca.sqlerrd[2];
          if (nWires>0) {
            set[pos]=0;
            initModules->AddAt(pos+1,pos);
            for(Int_t k=0;k<nWires;k++) {
              mo=lookup.mbo[k];
              if (mo>ml) {
                sprintf(buf,"%3i",mo);
                mboNr=pModStruct.getMboIndex(buf);
                ml=mo;
              }
              ch=(lookup.tdc[k]-1)*8 + lookup.chan[k] - 1;
              mod[mboNr][ch].fill((lookup.lay[k]-1),(lookup.wire[k]-1),
                                  (Char_t)(lookup.side[k][0]));
            }
          } else allFound=kFALSE;
        } else allFound=kFALSE;
      }
    }
  }
  if (isOpenCursor) {
    /* EXEC SQL CLOSE c3; */ 

{
    struct sqlexd sqlstm;
    sqlorat((void **)0, &sqlctx, &oraca);
    sqlstm.sqlvsn = 12;
    sqlstm.arrsiz = 6;
    sqlstm.sqladtp = &sqladt;
    sqlstm.sqltdsp = &sqltds;
    sqlstm.iters = (unsigned int  )1;
    sqlstm.offset = (unsigned int  )227;
    sqlstm.cud = sqlcud0;
    sqlstm.sqlest = (unsigned char  *)&sqlca;
    sqlstm.sqlety = (unsigned short)256;
    sqlstm.occurs = (unsigned int  )0;
    sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
    if (sqlca.sqlcode < 0) showSqlError("read(HMdcLookupGeom*,Int_t*)");
}


    setChanged(pPar);
    printInfo(pPar->GetName());
  } else pPar->setInputVersion(-1,inputNumber);
  return allFound;     
}; 
 

Int_t HMdcParOraIo::getReadoutVersion(HMdcMboReadout* pPar) {
  // reads the version for the MboReadout container valid at the start time
  //   of the actual run
  // if the version differs from the container version, the container must
  //   be reinitialized
  HParOraSet* oraSet=getOraSet(pPar);
  Int_t contVers=pPar->getInputVersion(inputNumber);
  if (contVers!=-1 && runStart>=oraSet->versDate[0] && runStart<=oraSet->versDate[1])
      return contVers;
  oraSet->clearVersDate();

  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    double since1;
    double until1;
    double since2;
    double until2;
    double since3;
    double until3;
  /* EXEC SQL END DECLARE SECTION; */ 


  /* EXEC SQL WHENEVER SQLERROR DO showSqlError("getReadoutVersion(Int_t)"); */ 

  /* EXEC SQL WHENEVER NOT FOUND GOTO notfound; */ 


  /* EXEC SQL SELECT ma1, mi1, ma2, mi2, ma3, mi3
       INTO :since1 , :until1, :since2, :until2, :since3, :until3   
       FROM
         (SELECT hdate.to_ansitime(MAX(valid_since)) AS ma1,
                 hdate.to_ansitime(MIN(valid_until)) AS mi1
           FROM mdc_ana.mbo_lvl1_loc           
           WHERE hades_oper.run_query.get_date() BETWEEN valid_since AND valid_until
                 AND hades_oper.run_query.get_history_date BETWEEN date_create And invalid_since),
         (SELECT hdate.to_ansitime(MAX(valid_since)) AS ma2,
                 hdate.to_ansitime(MIN(valid_until)) AS mi2
            FROM mdc_ana.lvl1_loc
            WHERE hades_oper.run_query.get_date() BETWEEN valid_since AND valid_until
                 AND hades_oper.run_query.get_history_date BETWEEN date_create And invalid_since),
         (SELECT hdate.to_ansitime(MAX(valid_since)) AS ma3,
                 hdate.to_ansitime(MIN(valid_until)) AS mi3
            FROM mdc_ana.gtb_loc
            WHERE hades_oper.run_query.get_date() BETWEEN valid_since AND valid_until
                 AND hades_oper.run_query.get_history_date BETWEEN date_create And invalid_since); */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 6;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "select ma1 ,mi1 ,ma2 ,mi2 ,ma3 ,mi3 into :b0,:b1,:b2,:b3,:b\
4,:b5  from (select hdate.to_ansitime(max(valid_since)) ma1 ,hdate.to_ansitime\
(min(valid_until)) mi1  from mdc_ana.mbo_lvl1_loc where (hades_oper.run_query.\
get_date() between valid_since and valid_until and hades_oper.run_query.get_hi\
story_date between date_create and invalid_since)) ,(select hdate.to_ansitime(\
max(valid_since)) ma2 ,hdate.to_ansitime(min(valid_until)) mi2  from mdc_ana.l\
vl1_loc where (hades_oper.run_query.get_date() between valid_since and valid_u\
ntil and hades_oper.run_query.get_history_date between date_create and invalid\
_since)) ,(select hdate.to_ansitime(max(valid_since)) ma3 ,hdate.to_ansitime(m\
in(valid_until)) mi3  from mdc_ana.gtb_loc where (hades_oper.run_query.get_dat\
e() between valid_since and valid_until and hades_oper.run_query.get_history_d\
ate between date_create and invalid_since)) ";
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )242;
  sqlstm.selerr = (unsigned short)1;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)&since1;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(double);
  sqlstm.sqhsts[0] = (         int  )0;
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqhstv[1] = (         void  *)&until1;
  sqlstm.sqhstl[1] = (unsigned int  )sizeof(double);
  sqlstm.sqhsts[1] = (         int  )0;
  sqlstm.sqindv[1] = (         void  *)0;
  sqlstm.sqinds[1] = (         int  )0;
  sqlstm.sqharm[1] = (unsigned int  )0;
  sqlstm.sqadto[1] = (unsigned short )0;
  sqlstm.sqtdso[1] = (unsigned short )0;
  sqlstm.sqhstv[2] = (         void  *)&since2;
  sqlstm.sqhstl[2] = (unsigned int  )sizeof(double);
  sqlstm.sqhsts[2] = (         int  )0;
  sqlstm.sqindv[2] = (         void  *)0;
  sqlstm.sqinds[2] = (         int  )0;
  sqlstm.sqharm[2] = (unsigned int  )0;
  sqlstm.sqadto[2] = (unsigned short )0;
  sqlstm.sqtdso[2] = (unsigned short )0;
  sqlstm.sqhstv[3] = (         void  *)&until2;
  sqlstm.sqhstl[3] = (unsigned int  )sizeof(double);
  sqlstm.sqhsts[3] = (         int  )0;
  sqlstm.sqindv[3] = (         void  *)0;
  sqlstm.sqinds[3] = (         int  )0;
  sqlstm.sqharm[3] = (unsigned int  )0;
  sqlstm.sqadto[3] = (unsigned short )0;
  sqlstm.sqtdso[3] = (unsigned short )0;
  sqlstm.sqhstv[4] = (         void  *)&since3;
  sqlstm.sqhstl[4] = (unsigned int  )sizeof(double);
  sqlstm.sqhsts[4] = (         int  )0;
  sqlstm.sqindv[4] = (         void  *)0;
  sqlstm.sqinds[4] = (         int  )0;
  sqlstm.sqharm[4] = (unsigned int  )0;
  sqlstm.sqadto[4] = (unsigned short )0;
  sqlstm.sqtdso[4] = (unsigned short )0;
  sqlstm.sqhstv[5] = (         void  *)&until3;
  sqlstm.sqhstl[5] = (unsigned int  )sizeof(double);
  sqlstm.sqhsts[5] = (         int  )0;
  sqlstm.sqindv[5] = (         void  *)0;
  sqlstm.sqinds[5] = (         int  )0;
  sqlstm.sqharm[5] = (unsigned int  )0;
  sqlstm.sqadto[5] = (unsigned short )0;
  sqlstm.sqtdso[5] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode == 1403) goto notfound;
  if (sqlca.sqlcode < 0) showSqlError("getReadoutVersion(Int_t)");
}



  if (since1>since2) oraSet->versDate[0]=since1;  
  else oraSet->versDate[0]=since2;
  if (since3>oraSet->versDate[0]) oraSet->versDate[0]=since3;
  if (until1<until2) oraSet->versDate[1]=until1;
  else oraSet->versDate[1]=until2;
  if (until3<oraSet->versDate[1]) oraSet->versDate[1]=until3;
  return getActRunId();
notfound:
  return -1;
} 


Bool_t HMdcParOraIo::read(HMdcMboReadout* pPar, Int_t* set) {
  // reads the lookup tables to connect the hardware adresses (sector, module,
  // motherboard, tdc channel) with the event readout adresses uses in the
  //  unpacker
  Int_t contVers=pPar->getInputVersion(inputNumber);
  Int_t version=getReadoutVersion(pPar);
  if (version==-1) {
    pPar->setInputVersion(-1,inputNumber);
    return kFALSE;
  }
  if (contVers==version) return kTRUE;
  if (inputNumber==1) pPar->clear();

  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int id;
    struct {
      int mbo [MDC_MAXMOTHS];
      int bus [MDC_MAXMOTHS];
      int busPos [MDC_MAXMOTHS];
      int roc [MDC_MAXMOTHS];
      int samPos [MDC_MAXMOTHS];
      int sam [MDC_MAXMOTHS];
    } readout;
  /* EXEC SQL END DECLARE SECTION; */ 

  /* EXEC SQL WHENEVER SQLERROR DO showSqlError("read(HMdcLookupGeom*,Int_t*)"); */ 

  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 

  /* EXEC SQL DECLARE c4 CURSOR FOR
    SELECT mbo_local_pos_id,mbo_pos_in_lvl1,roc_input_con, roc_pos_in_crate,
           sam_input_con,sam_pos
    FROM mdc_ana.mdcreadout_at_run_hist
    WHERE mdc_hwobj_id = :id
    ORDER BY mbo_local_pos_id; */ 


  HMdcRawStruct* pRawStruct=
       (HMdcRawStruct*)gHades->getRuntimeDb()->getContainer("MdcRawStruct");
  Bool_t allFound=kTRUE, isOpenCursor=kFALSE;
  initModules->Reset();
  HMdcMboReadout& mdc=*pPar;
  Int_t pos, nMbo, mboNr=-1, mo;
  Char_t buf[4];
  for(Int_t i=0;i<6;i++) {
    HMdcMboReadoutSec& sec=mdc[i];
    for(Int_t j=0;j<4;j++) {
      HMdcMboReadoutMod& mod=sec[j];
      pos=i*4+j;
      if (set[pos]) {
        HMdcRawModStru& pModStruct=(*pRawStruct)[i][j];
        id=mdcIds->At(pos);
        if (id>0) {
          /* EXEC SQL OPEN c4; */ 

{
          struct sqlexd sqlstm;
          sqlorat((void **)0, &sqlctx, &oraca);
          sqlstm.sqlvsn = 12;
          sqlstm.arrsiz = 6;
          sqlstm.sqladtp = &sqladt;
          sqlstm.sqltdsp = &sqltds;
          sqlstm.stmt = sq0007;
          sqlstm.iters = (unsigned int  )1;
          sqlstm.offset = (unsigned int  )281;
          sqlstm.selerr = (unsigned short)1;
          sqlstm.cud = sqlcud0;
          sqlstm.sqlest = (unsigned char  *)&sqlca;
          sqlstm.sqlety = (unsigned short)256;
          sqlstm.occurs = (unsigned int  )0;
          sqlstm.sqcmod = (unsigned int )0;
          sqlstm.sqhstv[0] = (         void  *)&id;
          sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[0] = (         int  )0;
          sqlstm.sqindv[0] = (         void  *)0;
          sqlstm.sqinds[0] = (         int  )0;
          sqlstm.sqharm[0] = (unsigned int  )0;
          sqlstm.sqadto[0] = (unsigned short )0;
          sqlstm.sqtdso[0] = (unsigned short )0;
          sqlstm.sqphsv = sqlstm.sqhstv;
          sqlstm.sqphsl = sqlstm.sqhstl;
          sqlstm.sqphss = sqlstm.sqhsts;
          sqlstm.sqpind = sqlstm.sqindv;
          sqlstm.sqpins = sqlstm.sqinds;
          sqlstm.sqparm = sqlstm.sqharm;
          sqlstm.sqparc = sqlstm.sqharc;
          sqlstm.sqpadto = sqlstm.sqadto;
          sqlstm.sqptdso = sqlstm.sqtdso;
          sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
          if (sqlca.sqlcode < 0) showSqlError("read(HMdcLookupGeom*,Int_t*)");
}


          isOpenCursor=kTRUE;
          /* EXEC SQL FETCH c4 INTO :readout; */ 

{
          struct sqlexd sqlstm;
          sqlorat((void **)0, &sqlctx, &oraca);
          sqlstm.sqlvsn = 12;
          sqlstm.arrsiz = 6;
          sqlstm.sqladtp = &sqladt;
          sqlstm.sqltdsp = &sqltds;
          sqlstm.iters = (unsigned int  )16;
          sqlstm.offset = (unsigned int  )300;
          sqlstm.selerr = (unsigned short)1;
          sqlstm.cud = sqlcud0;
          sqlstm.sqlest = (unsigned char  *)&sqlca;
          sqlstm.sqlety = (unsigned short)256;
          sqlstm.occurs = (unsigned int  )0;
          sqlstm.sqfoff = (           int )0;
          sqlstm.sqfmod = (unsigned int )2;
          sqlstm.sqhstv[0] = (         void  *)readout.mbo;
          sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[0] = (         int  )sizeof(int);
          sqlstm.sqindv[0] = (         void  *)0;
          sqlstm.sqinds[0] = (         int  )0;
          sqlstm.sqharm[0] = (unsigned int  )0;
          sqlstm.sqharc[0] = (unsigned int   *)0;
          sqlstm.sqadto[0] = (unsigned short )0;
          sqlstm.sqtdso[0] = (unsigned short )0;
          sqlstm.sqhstv[1] = (         void  *)readout.bus;
          sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[1] = (         int  )sizeof(int);
          sqlstm.sqindv[1] = (         void  *)0;
          sqlstm.sqinds[1] = (         int  )0;
          sqlstm.sqharm[1] = (unsigned int  )0;
          sqlstm.sqharc[1] = (unsigned int   *)0;
          sqlstm.sqadto[1] = (unsigned short )0;
          sqlstm.sqtdso[1] = (unsigned short )0;
          sqlstm.sqhstv[2] = (         void  *)readout.busPos;
          sqlstm.sqhstl[2] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[2] = (         int  )sizeof(int);
          sqlstm.sqindv[2] = (         void  *)0;
          sqlstm.sqinds[2] = (         int  )0;
          sqlstm.sqharm[2] = (unsigned int  )0;
          sqlstm.sqharc[2] = (unsigned int   *)0;
          sqlstm.sqadto[2] = (unsigned short )0;
          sqlstm.sqtdso[2] = (unsigned short )0;
          sqlstm.sqhstv[3] = (         void  *)readout.roc;
          sqlstm.sqhstl[3] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[3] = (         int  )sizeof(int);
          sqlstm.sqindv[3] = (         void  *)0;
          sqlstm.sqinds[3] = (         int  )0;
          sqlstm.sqharm[3] = (unsigned int  )0;
          sqlstm.sqharc[3] = (unsigned int   *)0;
          sqlstm.sqadto[3] = (unsigned short )0;
          sqlstm.sqtdso[3] = (unsigned short )0;
          sqlstm.sqhstv[4] = (         void  *)readout.samPos;
          sqlstm.sqhstl[4] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[4] = (         int  )sizeof(int);
          sqlstm.sqindv[4] = (         void  *)0;
          sqlstm.sqinds[4] = (         int  )0;
          sqlstm.sqharm[4] = (unsigned int  )0;
          sqlstm.sqharc[4] = (unsigned int   *)0;
          sqlstm.sqadto[4] = (unsigned short )0;
          sqlstm.sqtdso[4] = (unsigned short )0;
          sqlstm.sqhstv[5] = (         void  *)readout.sam;
          sqlstm.sqhstl[5] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[5] = (         int  )sizeof(int);
          sqlstm.sqindv[5] = (         void  *)0;
          sqlstm.sqinds[5] = (         int  )0;
          sqlstm.sqharm[5] = (unsigned int  )0;
          sqlstm.sqharc[5] = (unsigned int   *)0;
          sqlstm.sqadto[5] = (unsigned short )0;
          sqlstm.sqtdso[5] = (unsigned short )0;
          sqlstm.sqphsv = sqlstm.sqhstv;
          sqlstm.sqphsl = sqlstm.sqhstl;
          sqlstm.sqphss = sqlstm.sqhsts;
          sqlstm.sqpind = sqlstm.sqindv;
          sqlstm.sqpins = sqlstm.sqinds;
          sqlstm.sqparm = sqlstm.sqharm;
          sqlstm.sqparc = sqlstm.sqharc;
          sqlstm.sqpadto = sqlstm.sqadto;
          sqlstm.sqptdso = sqlstm.sqtdso;
          sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
          if (sqlca.sqlcode < 0) showSqlError("read(HMdcLookupGeom*,Int_t*)");
}


          nMbo=sqlca.sqlerrd[2];
          if (nMbo>0) {
            set[pos]=0;
            initModules->AddAt(pos+1,pos);
            for(Int_t k=0;k<nMbo;k++) {
              mo=readout.mbo[k];
              sprintf(buf,"%3i",mo);
              mboNr=pModStruct.getMboIndex(buf);
              HMdcMboReadoutMoth& moth=mod[mboNr];
              moth.setBus(readout.bus[k]);
              moth.setBusPos(readout.busPos[k]);
              moth.setRoc(readout.roc[k]);
              moth.setSamPos(readout.samPos[k]);
              moth.setSam(readout.sam[k]-1);
            }
          } else allFound=kFALSE;
        } else allFound=kFALSE;
      }
    }
  }
  if (isOpenCursor) {
    /* EXEC SQL CLOSE c4; */ 

{
    struct sqlexd sqlstm;
    sqlorat((void **)0, &sqlctx, &oraca);
    sqlstm.sqlvsn = 12;
    sqlstm.arrsiz = 6;
    sqlstm.sqladtp = &sqladt;
    sqlstm.sqltdsp = &sqltds;
    sqlstm.iters = (unsigned int  )1;
    sqlstm.offset = (unsigned int  )339;
    sqlstm.cud = sqlcud0;
    sqlstm.sqlest = (unsigned char  *)&sqlca;
    sqlstm.sqlety = (unsigned short)256;
    sqlstm.occurs = (unsigned int  )0;
    sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
    if (sqlca.sqlcode < 0) showSqlError("read(HMdcLookupGeom*,Int_t*)");
}


    setChanged(pPar);
    printInfo(pPar->GetName());
  } else pPar->setInputVersion(-1,inputNumber);
  return allFound;    
} 


Bool_t HMdcParOraIo::read(HMdcGeomPar* pPar, Int_t* set) {
  // reads the geometry of the MDC and fills the MdcGeomPar container
  Bool_t allFound=kTRUE;
  Int_t detId=-1;
  if (!geomVers) {
    detId=getDetectorId(pPar->getDetectorName());
    geomVers=new HGeomOraDetVersion(pPar->getDetectorName(),detId);
  } else {
    detId=geomVers->getDetectorId();
  }
  if (detId<=0) {
    allFound=kFALSE;
    delete geomVers;
    geomVers=0;
  }
  if (detId>0&&pPar->isFirstInitialization()) {
    if (!readModGeomNames(pPar,set) || !readLayerGeomNames(pPar,set)) {
      allFound=kFALSE;
      pPar->clear();
    } else addGeomOraSet(pPar);
  }  
  if (allFound) allFound=readDetectorGeometry(pPar,set,geomVers);
  return allFound;    
} 
 

Bool_t HMdcParOraIo::readModGeomNames(HMdcGeomPar* pPar,Int_t* set) {
  // reads the mdc_pos_id of all modules
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    struct {
      int mdc[MDC_MAXMODS];
      int sec[MDC_MAXMODS];
      int pla[MDC_MAXMODS];
      /* varchar oname[MDC_MAXMODS][9]; */ 
struct { unsigned short len; unsigned char arr[10]; } oname[24];

    } mods;
    struct {
      short mdc_Ind[MDC_MAXMODS];
      short sec_Ind[MDC_MAXMODS];
      short pla_Ind[MDC_MAXMODS];
      short oname_Ind[MDC_MAXMODS];
    } mods_Ind;
  /* EXEC SQL END DECLARE SECTION; */ 

  /* EXEC SQL WHENEVER SQLERROR DO showSqlError("readModGeomNames()"); */ 

  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 


  /* EXEC SQL SELECT mdc_hwobj_id, sector, plane, geom_obj
    INTO :mods INDICATOR :mods_Ind
    FROM mdc_ana.mdc_loc_at_run_hist; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 6;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "select mdc_hwobj_id ,sector ,plane ,geom_obj into :s1:s2 ,:\
s3:s4 ,:s5:s6 ,:s7:s8   from mdc_ana.mdc_loc_at_run_hist ";
  sqlstm.iters = (unsigned int  )24;
  sqlstm.offset = (unsigned int  )354;
  sqlstm.selerr = (unsigned short)1;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)mods.mdc;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )sizeof(int);
  sqlstm.sqindv[0] = (         void  *)mods_Ind.mdc_Ind;
  sqlstm.sqinds[0] = (         int  )sizeof(short);
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqharc[0] = (unsigned int   *)0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqhstv[1] = (         void  *)mods.sec;
  sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[1] = (         int  )sizeof(int);
  sqlstm.sqindv[1] = (         void  *)mods_Ind.sec_Ind;
  sqlstm.sqinds[1] = (         int  )sizeof(short);
  sqlstm.sqharm[1] = (unsigned int  )0;
  sqlstm.sqharc[1] = (unsigned int   *)0;
  sqlstm.sqadto[1] = (unsigned short )0;
  sqlstm.sqtdso[1] = (unsigned short )0;
  sqlstm.sqhstv[2] = (         void  *)mods.pla;
  sqlstm.sqhstl[2] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[2] = (         int  )sizeof(int);
  sqlstm.sqindv[2] = (         void  *)mods_Ind.pla_Ind;
  sqlstm.sqinds[2] = (         int  )sizeof(short);
  sqlstm.sqharm[2] = (unsigned int  )0;
  sqlstm.sqharc[2] = (unsigned int   *)0;
  sqlstm.sqadto[2] = (unsigned short )0;
  sqlstm.sqtdso[2] = (unsigned short )0;
  sqlstm.sqhstv[3] = (         void  *)mods.oname;
  sqlstm.sqhstl[3] = (unsigned int  )11;
  sqlstm.sqhsts[3] = (         int  )12;
  sqlstm.sqindv[3] = (         void  *)mods_Ind.oname_Ind;
  sqlstm.sqinds[3] = (         int  )sizeof(short);
  sqlstm.sqharm[3] = (unsigned int  )0;
  sqlstm.sqharc[3] = (unsigned int   *)0;
  sqlstm.sqadto[3] = (unsigned short )0;
  sqlstm.sqtdso[3] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) showSqlError("readModGeomNames()");
}



  Int_t nMods=sqlca.sqlerrd[2];
  Int_t pos, s, m;
  Char_t ref[10];
  Bool_t allFound=kTRUE;
  initModules->Reset();
  for(Int_t i=0;i<nMods;i++) {
    s=mods.sec[i]-1;
    m=mods.pla[i]-1;
    HModGeomPar* pMod=pPar->getModule(s,m);
    pos=s*4 + m;
    if (pMod && set[pos]) {
      if (mods_Ind.oname_Ind[i]!=-1) {
        mods.oname[i].arr[mods.oname[i].len]='\0';
        pMod->SetName((Char_t*)(mods.oname[i].arr));
        initModules->AddAt(pos+1,pos);
        strcpy(ref,(Char_t*)(mods.oname[i].arr));
        ref[4]='1'; // reference module in sector 1
                    // not yet introduced in database
        pMod->setRefName(ref);
        Int_t mr=pPar->getModNumInMod(ref);
        HGeomCompositeVolume* refMod=pPar->getRefVolume(mr);
        if (refMod==0) {
          refMod=new HGeomCompositeVolume(pPar->getNumComponents());
          refMod->SetName(ref);
          pPar->addRefVolume(refMod,mr);
        }
        pMod->setVolume(refMod);
      }
    }
  } 
  for(Int_t i=0;i<MDC_MAXMODS;i++) {
    if (set[i]==1 && initModules->At(i)==0) allFound=kFALSE;
  }
  return allFound; 
} 
 

Bool_t HMdcParOraIo::readLayerGeomNames(HMdcGeomPar* pPar,Int_t* set) {
  // reads the names of all layers in the geometry tables
  Int_t nLayers=-1, pos;
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int id;
    struct {
      int lay[MDC_MAXLAYS];
      /* varchar oname[MDC_MAXLAYS][9]; */ 
struct { unsigned short len; unsigned char arr[10]; } oname[6];

    } layers;
    struct {
      short lay_Ind[MDC_MAXMODS];
      short oname_Ind[MDC_MAXMODS];
    } layers_Ind;
  /* EXEC SQL END DECLARE SECTION; */ 


  /* EXEC SQL WHENEVER SQLERROR DO showSqlError("readLayerGeomNames(...)"); */ 

  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 


  /* EXEC SQL DECLARE c7 CURSOR FOR
    SELECT layer_nr, layer_name
    FROM mdc_ana.mdclayerparam
    WHERE mdc_hwobj_id=:id; */ 


  Bool_t allFound=kTRUE;
  for(Int_t i=0;i<6;i++) {
    for(Int_t j=0;j<4;j++) {
      HModGeomPar* pMod=pPar->getModule(i,j);
      pos=i*4+j;
      if (set[pos] && pMod) {
        HGeomCompositeVolume* pRefMod=pMod->getRefVolume();
        id=mdcIds->At(pos);
        if (id>0) {
          /* EXEC SQL OPEN c7; */ 

{
          struct sqlexd sqlstm;
          sqlorat((void **)0, &sqlctx, &oraca);
          sqlstm.sqlvsn = 12;
          sqlstm.arrsiz = 6;
          sqlstm.sqladtp = &sqladt;
          sqlstm.sqltdsp = &sqltds;
          sqlstm.stmt = sq0009;
          sqlstm.iters = (unsigned int  )1;
          sqlstm.offset = (unsigned int  )385;
          sqlstm.selerr = (unsigned short)1;
          sqlstm.cud = sqlcud0;
          sqlstm.sqlest = (unsigned char  *)&sqlca;
          sqlstm.sqlety = (unsigned short)256;
          sqlstm.occurs = (unsigned int  )0;
          sqlstm.sqcmod = (unsigned int )0;
          sqlstm.sqhstv[0] = (         void  *)&id;
          sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[0] = (         int  )0;
          sqlstm.sqindv[0] = (         void  *)0;
          sqlstm.sqinds[0] = (         int  )0;
          sqlstm.sqharm[0] = (unsigned int  )0;
          sqlstm.sqadto[0] = (unsigned short )0;
          sqlstm.sqtdso[0] = (unsigned short )0;
          sqlstm.sqphsv = sqlstm.sqhstv;
          sqlstm.sqphsl = sqlstm.sqhstl;
          sqlstm.sqphss = sqlstm.sqhsts;
          sqlstm.sqpind = sqlstm.sqindv;
          sqlstm.sqpins = sqlstm.sqinds;
          sqlstm.sqparm = sqlstm.sqharm;
          sqlstm.sqparc = sqlstm.sqharc;
          sqlstm.sqpadto = sqlstm.sqadto;
          sqlstm.sqptdso = sqlstm.sqtdso;
          sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
          if (sqlca.sqlcode < 0) showSqlError("readLayerGeomNames(...)");
}


          /* EXEC SQL FETCH c7 INTO :layers INDICATOR :layers_Ind; */ 

{
          struct sqlexd sqlstm;
          sqlorat((void **)0, &sqlctx, &oraca);
          sqlstm.sqlvsn = 12;
          sqlstm.arrsiz = 6;
          sqlstm.sqladtp = &sqladt;
          sqlstm.sqltdsp = &sqltds;
          sqlstm.iters = (unsigned int  )6;
          sqlstm.offset = (unsigned int  )404;
          sqlstm.selerr = (unsigned short)1;
          sqlstm.cud = sqlcud0;
          sqlstm.sqlest = (unsigned char  *)&sqlca;
          sqlstm.sqlety = (unsigned short)256;
          sqlstm.occurs = (unsigned int  )0;
          sqlstm.sqfoff = (           int )0;
          sqlstm.sqfmod = (unsigned int )2;
          sqlstm.sqhstv[0] = (         void  *)layers.lay;
          sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[0] = (         int  )sizeof(int);
          sqlstm.sqindv[0] = (         void  *)layers_Ind.lay_Ind;
          sqlstm.sqinds[0] = (         int  )sizeof(short);
          sqlstm.sqharm[0] = (unsigned int  )0;
          sqlstm.sqharc[0] = (unsigned int   *)0;
          sqlstm.sqadto[0] = (unsigned short )0;
          sqlstm.sqtdso[0] = (unsigned short )0;
          sqlstm.sqhstv[1] = (         void  *)layers.oname;
          sqlstm.sqhstl[1] = (unsigned int  )11;
          sqlstm.sqhsts[1] = (         int  )12;
          sqlstm.sqindv[1] = (         void  *)layers_Ind.oname_Ind;
          sqlstm.sqinds[1] = (         int  )sizeof(short);
          sqlstm.sqharm[1] = (unsigned int  )0;
          sqlstm.sqharc[1] = (unsigned int   *)0;
          sqlstm.sqadto[1] = (unsigned short )0;
          sqlstm.sqtdso[1] = (unsigned short )0;
          sqlstm.sqphsv = sqlstm.sqhstv;
          sqlstm.sqphsl = sqlstm.sqhstl;
          sqlstm.sqphss = sqlstm.sqhsts;
          sqlstm.sqpind = sqlstm.sqindv;
          sqlstm.sqpins = sqlstm.sqinds;
          sqlstm.sqparm = sqlstm.sqharm;
          sqlstm.sqparc = sqlstm.sqharc;
          sqlstm.sqpadto = sqlstm.sqadto;
          sqlstm.sqptdso = sqlstm.sqtdso;
          sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
          if (sqlca.sqlcode < 0) showSqlError("readLayerGeomNames(...)");
}


          nLayers=sqlca.sqlerrd[2];
          if (nLayers!=MDC_MAXLAYS) allFound=kFALSE;
          for(Int_t k=0;k<nLayers;k++) {
            if (layers_Ind.oname_Ind[k]!=-1) {
              layers.oname[k].arr[layers.oname[k].len]='\0';
              HGeomVolume* volu=pRefMod->getComponent((layers.lay[k]-1));
              volu->SetName((Char_t*)(layers.oname[k].arr));
            }
          }
          /* EXEC SQL CLOSE c7; */ 

{
          struct sqlexd sqlstm;
          sqlorat((void **)0, &sqlctx, &oraca);
          sqlstm.sqlvsn = 12;
          sqlstm.arrsiz = 6;
          sqlstm.sqladtp = &sqladt;
          sqlstm.sqltdsp = &sqltds;
          sqlstm.iters = (unsigned int  )1;
          sqlstm.offset = (unsigned int  )427;
          sqlstm.cud = sqlcud0;
          sqlstm.sqlest = (unsigned char  *)&sqlca;
          sqlstm.sqlety = (unsigned short)256;
          sqlstm.occurs = (unsigned int  )0;
          sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
          if (sqlca.sqlcode < 0) showSqlError("readLayerGeomNames(...)");
}

 
        }
      }
    }
  }
  return allFound;    
}

 
void HMdcParOraIo::printInfo(const Char_t* contName) {
  // prints the modules initialized from Oracle
  // will later go to the log file
  Bool_t first=kTRUE;
  for(Int_t i=0;i<MDC_MAXMODS;i++) {
    if (initModules->At(i)) {
      if (first) {
        cout<<contName<<": modules(s) initialized from Oracle: ";
        first=kFALSE;
      }
      cout<<(initModules->At(i)-1)<<" ";
    }
  }
  cout<<'\n';
}


Int_t HMdcParOraIo::getVersion(HParSet* pPar,TArrayI* versions) {
  // used for parameter containers with version management for modules
  // reads the newest versions 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;
    struct {
      int mdc[MDC_MAXSMALLARR];
      int vers[MDC_MAXSMALLARR];
      double since[MDC_MAXSMALLARR];
      double until[MDC_MAXSMALLARR];
    } mods;
  /* EXEC SQL END DECLARE SECTION; */ 

  context=oraSet->contextId;
  /* EXEC SQL WHENEVER SQLERROR DO showSqlError("getVersion(HParSet*,TArrayI*)"); */ 

  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 

  if (strcmp(containerClass,"HMdcCalParRaw")==0) {
    /* EXEC SQL SELECT mdc, version,
                    hdate.to_ansitime(valid_since),
                    hdate.to_ansitime(valid_until)
             INTO :mods
             FROM mdc_ana.mdc_cal1par_vers_at_date
             WHERE context_id = :context; */ 

{
    struct sqlexd sqlstm;
    sqlorat((void **)0, &sqlctx, &oraca);
    sqlstm.sqlvsn = 12;
    sqlstm.arrsiz = 6;
    sqlstm.sqladtp = &sqladt;
    sqlstm.sqltdsp = &sqltds;
    sqlstm.stmt = "select mdc ,version ,hdate.to_ansitime(valid_since) ,hdat\
e.to_ansitime(valid_until) into :s1 ,:s2 ,:s3 ,:s4   from mdc_ana.mdc_cal1par_\
vers_at_date where context_id=:b1";
    sqlstm.iters = (unsigned int  )50;
    sqlstm.offset = (unsigned int  )442;
    sqlstm.selerr = (unsigned short)1;
    sqlstm.cud = sqlcud0;
    sqlstm.sqlest = (unsigned char  *)&sqlca;
    sqlstm.sqlety = (unsigned short)256;
    sqlstm.occurs = (unsigned int  )0;
    sqlstm.sqhstv[0] = (         void  *)mods.mdc;
    sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
    sqlstm.sqhsts[0] = (         int  )sizeof(int);
    sqlstm.sqindv[0] = (         void  *)0;
    sqlstm.sqinds[0] = (         int  )0;
    sqlstm.sqharm[0] = (unsigned int  )0;
    sqlstm.sqharc[0] = (unsigned int   *)0;
    sqlstm.sqadto[0] = (unsigned short )0;
    sqlstm.sqtdso[0] = (unsigned short )0;
    sqlstm.sqhstv[1] = (         void  *)mods.vers;
    sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
    sqlstm.sqhsts[1] = (         int  )sizeof(int);
    sqlstm.sqindv[1] = (         void  *)0;
    sqlstm.sqinds[1] = (         int  )0;
    sqlstm.sqharm[1] = (unsigned int  )0;
    sqlstm.sqharc[1] = (unsigned int   *)0;
    sqlstm.sqadto[1] = (unsigned short )0;
    sqlstm.sqtdso[1] = (unsigned short )0;
    sqlstm.sqhstv[2] = (         void  *)mods.since;
    sqlstm.sqhstl[2] = (unsigned int  )sizeof(double);
    sqlstm.sqhsts[2] = (         int  )sizeof(double);
    sqlstm.sqindv[2] = (         void  *)0;
    sqlstm.sqinds[2] = (         int  )0;
    sqlstm.sqharm[2] = (unsigned int  )0;
    sqlstm.sqharc[2] = (unsigned int   *)0;
    sqlstm.sqadto[2] = (unsigned short )0;
    sqlstm.sqtdso[2] = (unsigned short )0;
    sqlstm.sqhstv[3] = (         void  *)mods.until;
    sqlstm.sqhstl[3] = (unsigned int  )sizeof(double);
    sqlstm.sqhsts[3] = (         int  )sizeof(double);
    sqlstm.sqindv[3] = (         void  *)0;
    sqlstm.sqinds[3] = (         int  )0;
    sqlstm.sqharm[3] = (unsigned int  )0;
    sqlstm.sqharc[3] = (unsigned int   *)0;
    sqlstm.sqadto[3] = (unsigned short )0;
    sqlstm.sqtdso[3] = (unsigned short )0;
    sqlstm.sqhstv[4] = (         void  *)&context;
    sqlstm.sqhstl[4] = (unsigned int  )sizeof(int);
    sqlstm.sqhsts[4] = (         int  )sizeof(int);
    sqlstm.sqindv[4] = (         void  *)0;
    sqlstm.sqinds[4] = (         int  )0;
    sqlstm.sqharm[4] = (unsigned int  )0;
    sqlstm.sqadto[4] = (unsigned short )0;
    sqlstm.sqtdso[4] = (unsigned short )0;
    sqlstm.sqphsv = sqlstm.sqhstv;
    sqlstm.sqphsl = sqlstm.sqhstl;
    sqlstm.sqphss = sqlstm.sqhsts;
    sqlstm.sqpind = sqlstm.sqindv;
    sqlstm.sqpins = sqlstm.sqinds;
    sqlstm.sqparm = sqlstm.sqharm;
    sqlstm.sqparc = sqlstm.sqharc;
    sqlstm.sqpadto = sqlstm.sqadto;
    sqlstm.sqptdso = sqlstm.sqtdso;
    sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
    if (sqlca.sqlcode < 0) showSqlError("getVersion(HParSet*,TArrayI*)");
}


  } else {
    if (strcmp(containerClass,"HMdcCal2ParSim")==0) {
      /* EXEC SQL SELECT mdc, version,
                      hdate.to_ansitime(valid_since),
                      hdate.to_ansitime(valid_until)
               INTO :mods
               FROM mdc_ana.mdc_cal2parsim_vers_at_date
               WHERE context_id = :context; */ 

{
      struct sqlexd sqlstm;
      sqlorat((void **)0, &sqlctx, &oraca);
      sqlstm.sqlvsn = 12;
      sqlstm.arrsiz = 6;
      sqlstm.sqladtp = &sqladt;
      sqlstm.sqltdsp = &sqltds;
      sqlstm.stmt = "select mdc ,version ,hdate.to_ansitime(valid_since) ,hd\
ate.to_ansitime(valid_until) into :s1 ,:s2 ,:s3 ,:s4   from mdc_ana.mdc_cal2pa\
rsim_vers_at_date where context_id=:b1";
      sqlstm.iters = (unsigned int  )50;
      sqlstm.offset = (unsigned int  )477;
      sqlstm.selerr = (unsigned short)1;
      sqlstm.cud = sqlcud0;
      sqlstm.sqlest = (unsigned char  *)&sqlca;
      sqlstm.sqlety = (unsigned short)256;
      sqlstm.occurs = (unsigned int  )0;
      sqlstm.sqhstv[0] = (         void  *)mods.mdc;
      sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
      sqlstm.sqhsts[0] = (         int  )sizeof(int);
      sqlstm.sqindv[0] = (         void  *)0;
      sqlstm.sqinds[0] = (         int  )0;
      sqlstm.sqharm[0] = (unsigned int  )0;
      sqlstm.sqharc[0] = (unsigned int   *)0;
      sqlstm.sqadto[0] = (unsigned short )0;
      sqlstm.sqtdso[0] = (unsigned short )0;
      sqlstm.sqhstv[1] = (         void  *)mods.vers;
      sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
      sqlstm.sqhsts[1] = (         int  )sizeof(int);
      sqlstm.sqindv[1] = (         void  *)0;
      sqlstm.sqinds[1] = (         int  )0;
      sqlstm.sqharm[1] = (unsigned int  )0;
      sqlstm.sqharc[1] = (unsigned int   *)0;
      sqlstm.sqadto[1] = (unsigned short )0;
      sqlstm.sqtdso[1] = (unsigned short )0;
      sqlstm.sqhstv[2] = (         void  *)mods.since;
      sqlstm.sqhstl[2] = (unsigned int  )sizeof(double);
      sqlstm.sqhsts[2] = (         int  )sizeof(double);
      sqlstm.sqindv[2] = (         void  *)0;
      sqlstm.sqinds[2] = (         int  )0;
      sqlstm.sqharm[2] = (unsigned int  )0;
      sqlstm.sqharc[2] = (unsigned int   *)0;
      sqlstm.sqadto[2] = (unsigned short )0;
      sqlstm.sqtdso[2] = (unsigned short )0;
      sqlstm.sqhstv[3] = (         void  *)mods.until;
      sqlstm.sqhstl[3] = (unsigned int  )sizeof(double);
      sqlstm.sqhsts[3] = (         int  )sizeof(double);
      sqlstm.sqindv[3] = (         void  *)0;
      sqlstm.sqinds[3] = (         int  )0;
      sqlstm.sqharm[3] = (unsigned int  )0;
      sqlstm.sqharc[3] = (unsigned int   *)0;
      sqlstm.sqadto[3] = (unsigned short )0;
      sqlstm.sqtdso[3] = (unsigned short )0;
      sqlstm.sqhstv[4] = (         void  *)&context;
      sqlstm.sqhstl[4] = (unsigned int  )sizeof(int);
      sqlstm.sqhsts[4] = (         int  )sizeof(int);
      sqlstm.sqindv[4] = (         void  *)0;
      sqlstm.sqinds[4] = (         int  )0;
      sqlstm.sqharm[4] = (unsigned int  )0;
      sqlstm.sqadto[4] = (unsigned short )0;
      sqlstm.sqtdso[4] = (unsigned short )0;
      sqlstm.sqphsv = sqlstm.sqhstv;
      sqlstm.sqphsl = sqlstm.sqhstl;
      sqlstm.sqphss = sqlstm.sqhsts;
      sqlstm.sqpind = sqlstm.sqindv;
      sqlstm.sqpins = sqlstm.sqinds;
      sqlstm.sqparm = sqlstm.sqharm;
      sqlstm.sqparc = sqlstm.sqharc;
      sqlstm.sqpadto = sqlstm.sqadto;
      sqlstm.sqptdso = sqlstm.sqtdso;
      sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
      if (sqlca.sqlcode < 0) showSqlError("getVersion(HParSet*,TArrayI*)");
}


    } else {
      if (strcmp(containerClass,"HMdcLayerGeomPar")==0) {
        /* EXEC SQL SELECT mdc, version,
                        hdate.to_ansitime(valid_since),
                        hdate.to_ansitime(valid_until)
               INTO :mods
               FROM mdc_ana.mdc_layergeompar_vers_at_date
               WHERE context_id = :context; */ 

{
        struct sqlexd sqlstm;
        sqlorat((void **)0, &sqlctx, &oraca);
        sqlstm.sqlvsn = 12;
        sqlstm.arrsiz = 6;
        sqlstm.sqladtp = &sqladt;
        sqlstm.sqltdsp = &sqltds;
        sqlstm.stmt = "select mdc ,version ,hdate.to_ansitime(valid_since) ,\
hdate.to_ansitime(valid_until) into :s1 ,:s2 ,:s3 ,:s4   from mdc_ana.mdc_laye\
rgeompar_vers_at_date where context_id=:b1";
        sqlstm.iters = (unsigned int  )50;
        sqlstm.offset = (unsigned int  )512;
        sqlstm.selerr = (unsigned short)1;
        sqlstm.cud = sqlcud0;
        sqlstm.sqlest = (unsigned char  *)&sqlca;
        sqlstm.sqlety = (unsigned short)256;
        sqlstm.occurs = (unsigned int  )0;
        sqlstm.sqhstv[0] = (         void  *)mods.mdc;
        sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[0] = (         int  )sizeof(int);
        sqlstm.sqindv[0] = (         void  *)0;
        sqlstm.sqinds[0] = (         int  )0;
        sqlstm.sqharm[0] = (unsigned int  )0;
        sqlstm.sqharc[0] = (unsigned int   *)0;
        sqlstm.sqadto[0] = (unsigned short )0;
        sqlstm.sqtdso[0] = (unsigned short )0;
        sqlstm.sqhstv[1] = (         void  *)mods.vers;
        sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[1] = (         int  )sizeof(int);
        sqlstm.sqindv[1] = (         void  *)0;
        sqlstm.sqinds[1] = (         int  )0;
        sqlstm.sqharm[1] = (unsigned int  )0;
        sqlstm.sqharc[1] = (unsigned int   *)0;
        sqlstm.sqadto[1] = (unsigned short )0;
        sqlstm.sqtdso[1] = (unsigned short )0;
        sqlstm.sqhstv[2] = (         void  *)mods.since;
        sqlstm.sqhstl[2] = (unsigned int  )sizeof(double);
        sqlstm.sqhsts[2] = (         int  )sizeof(double);
        sqlstm.sqindv[2] = (         void  *)0;
        sqlstm.sqinds[2] = (         int  )0;
        sqlstm.sqharm[2] = (unsigned int  )0;
        sqlstm.sqharc[2] = (unsigned int   *)0;
        sqlstm.sqadto[2] = (unsigned short )0;
        sqlstm.sqtdso[2] = (unsigned short )0;
        sqlstm.sqhstv[3] = (         void  *)mods.until;
        sqlstm.sqhstl[3] = (unsigned int  )sizeof(double);
        sqlstm.sqhsts[3] = (         int  )sizeof(double);
        sqlstm.sqindv[3] = (         void  *)0;
        sqlstm.sqinds[3] = (         int  )0;
        sqlstm.sqharm[3] = (unsigned int  )0;
        sqlstm.sqharc[3] = (unsigned int   *)0;
        sqlstm.sqadto[3] = (unsigned short )0;
        sqlstm.sqtdso[3] = (unsigned short )0;
        sqlstm.sqhstv[4] = (         void  *)&context;
        sqlstm.sqhstl[4] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[4] = (         int  )sizeof(int);
        sqlstm.sqindv[4] = (         void  *)0;
        sqlstm.sqinds[4] = (         int  )0;
        sqlstm.sqharm[4] = (unsigned int  )0;
        sqlstm.sqadto[4] = (unsigned short )0;
        sqlstm.sqtdso[4] = (unsigned short )0;
        sqlstm.sqphsv = sqlstm.sqhstv;
        sqlstm.sqphsl = sqlstm.sqhstl;
        sqlstm.sqphss = sqlstm.sqhsts;
        sqlstm.sqpind = sqlstm.sqindv;
        sqlstm.sqpins = sqlstm.sqinds;
        sqlstm.sqparm = sqlstm.sqharm;
        sqlstm.sqparc = sqlstm.sqharc;
        sqlstm.sqpadto = sqlstm.sqadto;
        sqlstm.sqptdso = sqlstm.sqtdso;
        sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
        if (sqlca.sqlcode < 0) showSqlError("getVersion(HParSet*,TArrayI*)");
}


      }
    }
  }
  Int_t idSize=modIds->GetSize();
  for(Int_t i=0;i<sqlca.sqlerrd[2];i++) {
    Int_t m=mods.mdc[i];
    if (m<idSize&&modIds->At(m)>0) {
      versions->AddAt(mods.vers[i],m);
      if (mods.since[i]>oraSet->versDate[0]) oraSet->versDate[0]=mods.since[i];
      if (mods.until[i]<oraSet->versDate[1]) oraSet->versDate[1]=mods.until[i];
    }
  }
  if (oraSet->versDate[0]>0) return getActRunId();
  return -1;  
}; 


Int_t HMdcParOraIo::getVersion(HParSet* pPar, Int_t& version) {
  // used for parameter containers with one version for all modules or planes
  // 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,"HMdcCellEff")==0) {
    /* EXEC SQL SELECT version,
                    hdate.to_ansitime(valid_since),
                    hdate.to_ansitime(valid_until)
             INTO :vers, :since, :until
             FROM mdc_ana.mdc_celleff_vers_at_date
             WHERE context_id = :context; */ 

{
    struct sqlexd sqlstm;
    sqlorat((void **)0, &sqlctx, &oraca);
    sqlstm.sqlvsn = 12;
    sqlstm.arrsiz = 6;
    sqlstm.sqladtp = &sqladt;
    sqlstm.sqltdsp = &sqltds;
    sqlstm.stmt = "select version ,hdate.to_ansitime(valid_since) ,hdate.to_\
ansitime(valid_until) into :b0,:b1,:b2  from mdc_ana.mdc_celleff_vers_at_date \
where context_id=:b3";
    sqlstm.iters = (unsigned int  )1;
    sqlstm.offset = (unsigned int  )547;
    sqlstm.selerr = (unsigned short)1;
    sqlstm.cud = sqlcud0;
    sqlstm.sqlest = (unsigned char  *)&sqlca;
    sqlstm.sqlety = (unsigned short)256;
    sqlstm.occurs = (unsigned int  )0;
    sqlstm.sqhstv[0] = (         void  *)&vers;
    sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
    sqlstm.sqhsts[0] = (         int  )0;
    sqlstm.sqindv[0] = (         void  *)0;
    sqlstm.sqinds[0] = (         int  )0;
    sqlstm.sqharm[0] = (unsigned int  )0;
    sqlstm.sqadto[0] = (unsigned short )0;
    sqlstm.sqtdso[0] = (unsigned short )0;
    sqlstm.sqhstv[1] = (         void  *)&since;
    sqlstm.sqhstl[1] = (unsigned int  )sizeof(double);
    sqlstm.sqhsts[1] = (         int  )0;
    sqlstm.sqindv[1] = (         void  *)0;
    sqlstm.sqinds[1] = (         int  )0;
    sqlstm.sqharm[1] = (unsigned int  )0;
    sqlstm.sqadto[1] = (unsigned short )0;
    sqlstm.sqtdso[1] = (unsigned short )0;
    sqlstm.sqhstv[2] = (         void  *)&until;
    sqlstm.sqhstl[2] = (unsigned int  )sizeof(double);
    sqlstm.sqhsts[2] = (         int  )0;
    sqlstm.sqindv[2] = (         void  *)0;
    sqlstm.sqinds[2] = (         int  )0;
    sqlstm.sqharm[2] = (unsigned int  )0;
    sqlstm.sqadto[2] = (unsigned short )0;
    sqlstm.sqtdso[2] = (unsigned short )0;
    sqlstm.sqhstv[3] = (         void  *)&context;
    sqlstm.sqhstl[3] = (unsigned int  )sizeof(int);
    sqlstm.sqhsts[3] = (         int  )0;
    sqlstm.sqindv[3] = (         void  *)0;
    sqlstm.sqinds[3] = (         int  )0;
    sqlstm.sqharm[3] = (unsigned int  )0;
    sqlstm.sqadto[3] = (unsigned short )0;
    sqlstm.sqtdso[3] = (unsigned short )0;
    sqlstm.sqphsv = sqlstm.sqhstv;
    sqlstm.sqphsl = sqlstm.sqhstl;
    sqlstm.sqphss = sqlstm.sqhsts;
    sqlstm.sqpind = sqlstm.sqindv;
    sqlstm.sqpins = sqlstm.sqinds;
    sqlstm.sqparm = sqlstm.sqharm;
    sqlstm.sqparc = sqlstm.sqharc;
    sqlstm.sqpadto = sqlstm.sqadto;
    sqlstm.sqptdso = sqlstm.sqtdso;
    sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
    if (sqlca.sqlcode == 1403) goto notfound;
    if (sqlca.sqlcode < 0) showSqlError("getVersion(HParSet*,Int_t&)");
}


  } else {
    if (strcmp(containerClass,"HMdcTimeCut")==0) {
      /* EXEC SQL SELECT version,
                      hdate.to_ansitime(valid_since),
                      hdate.to_ansitime(valid_until)
             INTO :vers, :since, :until
             FROM mdc_ana.mdc_timecut_vers_at_date
             WHERE context_id = :context; */ 

{
      struct sqlexd sqlstm;
      sqlorat((void **)0, &sqlctx, &oraca);
      sqlstm.sqlvsn = 12;
      sqlstm.arrsiz = 6;
      sqlstm.sqladtp = &sqladt;
      sqlstm.sqltdsp = &sqltds;
      sqlstm.stmt = "select version ,hdate.to_ansitime(valid_since) ,hdate.t\
o_ansitime(valid_until) into :b0,:b1,:b2  from mdc_ana.mdc_timecut_vers_at_dat\
e where context_id=:b3";
      sqlstm.iters = (unsigned int  )1;
      sqlstm.offset = (unsigned int  )578;
      sqlstm.selerr = (unsigned short)1;
      sqlstm.cud = sqlcud0;
      sqlstm.sqlest = (unsigned char  *)&sqlca;
      sqlstm.sqlety = (unsigned short)256;
      sqlstm.occurs = (unsigned int  )0;
      sqlstm.sqhstv[0] = (         void  *)&vers;
      sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
      sqlstm.sqhsts[0] = (         int  )0;
      sqlstm.sqindv[0] = (         void  *)0;
      sqlstm.sqinds[0] = (         int  )0;
      sqlstm.sqharm[0] = (unsigned int  )0;
      sqlstm.sqadto[0] = (unsigned short )0;
      sqlstm.sqtdso[0] = (unsigned short )0;
      sqlstm.sqhstv[1] = (         void  *)&since;
      sqlstm.sqhstl[1] = (unsigned int  )sizeof(double);
      sqlstm.sqhsts[1] = (         int  )0;
      sqlstm.sqindv[1] = (         void  *)0;
      sqlstm.sqinds[1] = (         int  )0;
      sqlstm.sqharm[1] = (unsigned int  )0;
      sqlstm.sqadto[1] = (unsigned short )0;
      sqlstm.sqtdso[1] = (unsigned short )0;
      sqlstm.sqhstv[2] = (         void  *)&until;
      sqlstm.sqhstl[2] = (unsigned int  )sizeof(double);
      sqlstm.sqhsts[2] = (         int  )0;
      sqlstm.sqindv[2] = (         void  *)0;
      sqlstm.sqinds[2] = (         int  )0;
      sqlstm.sqharm[2] = (unsigned int  )0;
      sqlstm.sqadto[2] = (unsigned short )0;
      sqlstm.sqtdso[2] = (unsigned short )0;
      sqlstm.sqhstv[3] = (         void  *)&context;
      sqlstm.sqhstl[3] = (unsigned int  )sizeof(int);
      sqlstm.sqhsts[3] = (         int  )0;
      sqlstm.sqindv[3] = (         void  *)0;
      sqlstm.sqinds[3] = (         int  )0;
      sqlstm.sqharm[3] = (unsigned int  )0;
      sqlstm.sqadto[3] = (unsigned short )0;
      sqlstm.sqtdso[3] = (unsigned short )0;
      sqlstm.sqphsv = sqlstm.sqhstv;
      sqlstm.sqphsl = sqlstm.sqhstl;
      sqlstm.sqphss = sqlstm.sqhsts;
      sqlstm.sqpind = sqlstm.sqindv;
      sqlstm.sqpins = sqlstm.sqinds;
      sqlstm.sqparm = sqlstm.sqharm;
      sqlstm.sqparc = sqlstm.sqharc;
      sqlstm.sqpadto = sqlstm.sqadto;
      sqlstm.sqptdso = sqlstm.sqtdso;
      sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
      if (sqlca.sqlcode == 1403) goto notfound;
      if (sqlca.sqlcode < 0) showSqlError("getVersion(HParSet*,Int_t&)");
}


    } else {
      if (strcmp(containerClass,"HMdcClosePairCutsPar")==0) {
        /* EXEC SQL SELECT version,
                        hdate.to_ansitime(valid_since),
                        hdate.to_ansitime(valid_until)
               INTO :vers, :since, :until
               FROM mdc_ana.closepaircut_vers_at_date
               WHERE context_id = :context; */ 

{
        struct sqlexd sqlstm;
        sqlorat((void **)0, &sqlctx, &oraca);
        sqlstm.sqlvsn = 12;
        sqlstm.arrsiz = 6;
        sqlstm.sqladtp = &sqladt;
        sqlstm.sqltdsp = &sqltds;
        sqlstm.stmt = "select version ,hdate.to_ansitime(valid_since) ,hdate\
.to_ansitime(valid_until) into :b0,:b1,:b2  from mdc_ana.closepaircut_vers_at_\
date where context_id=:b3";
        sqlstm.iters = (unsigned int  )1;
        sqlstm.offset = (unsigned int  )609;
        sqlstm.selerr = (unsigned short)1;
        sqlstm.cud = sqlcud0;
        sqlstm.sqlest = (unsigned char  *)&sqlca;
        sqlstm.sqlety = (unsigned short)256;
        sqlstm.occurs = (unsigned int  )0;
        sqlstm.sqhstv[0] = (         void  *)&vers;
        sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[0] = (         int  )0;
        sqlstm.sqindv[0] = (         void  *)0;
        sqlstm.sqinds[0] = (         int  )0;
        sqlstm.sqharm[0] = (unsigned int  )0;
        sqlstm.sqadto[0] = (unsigned short )0;
        sqlstm.sqtdso[0] = (unsigned short )0;
        sqlstm.sqhstv[1] = (         void  *)&since;
        sqlstm.sqhstl[1] = (unsigned int  )sizeof(double);
        sqlstm.sqhsts[1] = (         int  )0;
        sqlstm.sqindv[1] = (         void  *)0;
        sqlstm.sqinds[1] = (         int  )0;
        sqlstm.sqharm[1] = (unsigned int  )0;
        sqlstm.sqadto[1] = (unsigned short )0;
        sqlstm.sqtdso[1] = (unsigned short )0;
        sqlstm.sqhstv[2] = (         void  *)&until;
        sqlstm.sqhstl[2] = (unsigned int  )sizeof(double);
        sqlstm.sqhsts[2] = (         int  )0;
        sqlstm.sqindv[2] = (         void  *)0;
        sqlstm.sqinds[2] = (         int  )0;
        sqlstm.sqharm[2] = (unsigned int  )0;
        sqlstm.sqadto[2] = (unsigned short )0;
        sqlstm.sqtdso[2] = (unsigned short )0;
        sqlstm.sqhstv[3] = (         void  *)&context;
        sqlstm.sqhstl[3] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[3] = (         int  )0;
        sqlstm.sqindv[3] = (         void  *)0;
        sqlstm.sqinds[3] = (         int  )0;
        sqlstm.sqharm[3] = (unsigned int  )0;
        sqlstm.sqadto[3] = (unsigned short )0;
        sqlstm.sqtdso[3] = (unsigned short )0;
        sqlstm.sqphsv = sqlstm.sqhstv;
        sqlstm.sqphsl = sqlstm.sqhstl;
        sqlstm.sqphss = sqlstm.sqhsts;
        sqlstm.sqpind = sqlstm.sqindv;
        sqlstm.sqpins = sqlstm.sqinds;
        sqlstm.sqparm = sqlstm.sqharm;
        sqlstm.sqparc = sqlstm.sqharc;
        sqlstm.sqpadto = sqlstm.sqadto;
        sqlstm.sqptdso = sqlstm.sqtdso;
        sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
        if (sqlca.sqlcode == 1403) goto notfound;
        if (sqlca.sqlcode < 0) showSqlError("getVersion(HParSet*,Int_t&)");
}


      }
    }
  }
  version=vers;
  oraSet->versDate[0]=since;
  oraSet->versDate[1]=until;
  return getActRunId();
notfound:
  return -1;  
}; 


Bool_t HMdcParOraIo::read(HMdcCalParRaw* pPar, Int_t* set) {
  // reads the calibration parameters and fill the MdcCalParRaw container
  Int_t contVers=pPar->getInputVersion(inputNumber);
  TArrayI versions(modIds->GetSize());
  Int_t version=getVersion(pPar,&versions);
  if (version==-1) {
    pPar->setInputVersion(-1,inputNumber);
    return kFALSE;
  }
  if (contVers==version) return kTRUE;
  if (inputNumber==1) pPar->clear();
  initModules->Reset();
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int id;
    int vers;
    struct {
      int mbo[MDC_MAXCHAN];
      int tdc[MDC_MAXCHAN];
      int chan[MDC_MAXCHAN];
      float sl[MDC_MAXCHAN];
      float sE[MDC_MAXCHAN];
      float sM[MDC_MAXCHAN];
      float o[MDC_MAXCHAN];
      float oE[MDC_MAXCHAN];
      float oM[MDC_MAXCHAN];
    } cal;
  /* EXEC SQL END DECLARE SECTION; */ 

  /* EXEC SQL WHENEVER SQLERROR DO showSqlError("read(HMdcCalParRaw*,Int_t*)"); */ 

  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 

  /* EXEC SQL DECLARE c8 CURSOR FOR
    SELECT mbo, tdc, chan, slope, slope_err, slope_method,
           offset, offset_err, offset_method
      FROM mdc_ana.mdc_cal1par_data
      WHERE mdc = :id
        AND version =:vers
        ORDER BY mbo; */ 

  Bool_t allFound=kTRUE;
  HMdcCalParRaw& mdc=*pPar;
  Int_t pos;
  for(Int_t i=0;i<6;i++) {
    HMdcCalParRawSec& sec=mdc[i];
    for(Int_t j=0;j<4;j++) {
      HMdcCalParRawMod& mod=sec[j];
      pos=i*4+j;
      if (set[pos]) {
        id=mdcIds->At(pos);
        vers=versions.At(id);
        // cout<<pos<<"  "<<id<<"  "<<vers<<endl;
        if (id>0 && vers>0) {
          /* EXEC SQL OPEN c8; */ 

{
          struct sqlexd sqlstm;
          sqlorat((void **)0, &sqlctx, &oraca);
          sqlstm.sqlvsn = 12;
          sqlstm.arrsiz = 6;
          sqlstm.sqladtp = &sqladt;
          sqlstm.sqltdsp = &sqltds;
          sqlstm.stmt = sq0016;
          sqlstm.iters = (unsigned int  )1;
          sqlstm.offset = (unsigned int  )640;
          sqlstm.selerr = (unsigned short)1;
          sqlstm.cud = sqlcud0;
          sqlstm.sqlest = (unsigned char  *)&sqlca;
          sqlstm.sqlety = (unsigned short)256;
          sqlstm.occurs = (unsigned int  )0;
          sqlstm.sqcmod = (unsigned int )0;
          sqlstm.sqhstv[0] = (         void  *)&id;
          sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[0] = (         int  )0;
          sqlstm.sqindv[0] = (         void  *)0;
          sqlstm.sqinds[0] = (         int  )0;
          sqlstm.sqharm[0] = (unsigned int  )0;
          sqlstm.sqadto[0] = (unsigned short )0;
          sqlstm.sqtdso[0] = (unsigned short )0;
          sqlstm.sqhstv[1] = (         void  *)&vers;
          sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[1] = (         int  )0;
          sqlstm.sqindv[1] = (         void  *)0;
          sqlstm.sqinds[1] = (         int  )0;
          sqlstm.sqharm[1] = (unsigned int  )0;
          sqlstm.sqadto[1] = (unsigned short )0;
          sqlstm.sqtdso[1] = (unsigned short )0;
          sqlstm.sqphsv = sqlstm.sqhstv;
          sqlstm.sqphsl = sqlstm.sqhstl;
          sqlstm.sqphss = sqlstm.sqhsts;
          sqlstm.sqpind = sqlstm.sqindv;
          sqlstm.sqpins = sqlstm.sqinds;
          sqlstm.sqparm = sqlstm.sqharm;
          sqlstm.sqparc = sqlstm.sqharc;
          sqlstm.sqpadto = sqlstm.sqadto;
          sqlstm.sqptdso = sqlstm.sqtdso;
          sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
          if (sqlca.sqlcode < 0) showSqlError("read(HMdcCalParRaw*,Int_t*)");
}


          /* EXEC SQL FETCH c8 INTO :cal; */ 

{
          struct sqlexd sqlstm;
          sqlorat((void **)0, &sqlctx, &oraca);
          sqlstm.sqlvsn = 12;
          sqlstm.arrsiz = 9;
          sqlstm.sqladtp = &sqladt;
          sqlstm.sqltdsp = &sqltds;
          sqlstm.iters = (unsigned int  )1536;
          sqlstm.offset = (unsigned int  )663;
          sqlstm.selerr = (unsigned short)1;
          sqlstm.cud = sqlcud0;
          sqlstm.sqlest = (unsigned char  *)&sqlca;
          sqlstm.sqlety = (unsigned short)256;
          sqlstm.occurs = (unsigned int  )0;
          sqlstm.sqfoff = (           int )0;
          sqlstm.sqfmod = (unsigned int )2;
          sqlstm.sqhstv[0] = (         void  *)cal.mbo;
          sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[0] = (         int  )sizeof(int);
          sqlstm.sqindv[0] = (         void  *)0;
          sqlstm.sqinds[0] = (         int  )0;
          sqlstm.sqharm[0] = (unsigned int  )0;
          sqlstm.sqharc[0] = (unsigned int   *)0;
          sqlstm.sqadto[0] = (unsigned short )0;
          sqlstm.sqtdso[0] = (unsigned short )0;
          sqlstm.sqhstv[1] = (         void  *)cal.tdc;
          sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[1] = (         int  )sizeof(int);
          sqlstm.sqindv[1] = (         void  *)0;
          sqlstm.sqinds[1] = (         int  )0;
          sqlstm.sqharm[1] = (unsigned int  )0;
          sqlstm.sqharc[1] = (unsigned int   *)0;
          sqlstm.sqadto[1] = (unsigned short )0;
          sqlstm.sqtdso[1] = (unsigned short )0;
          sqlstm.sqhstv[2] = (         void  *)cal.chan;
          sqlstm.sqhstl[2] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[2] = (         int  )sizeof(int);
          sqlstm.sqindv[2] = (         void  *)0;
          sqlstm.sqinds[2] = (         int  )0;
          sqlstm.sqharm[2] = (unsigned int  )0;
          sqlstm.sqharc[2] = (unsigned int   *)0;
          sqlstm.sqadto[2] = (unsigned short )0;
          sqlstm.sqtdso[2] = (unsigned short )0;
          sqlstm.sqhstv[3] = (         void  *)cal.sl;
          sqlstm.sqhstl[3] = (unsigned int  )sizeof(float);
          sqlstm.sqhsts[3] = (         int  )sizeof(float);
          sqlstm.sqindv[3] = (         void  *)0;
          sqlstm.sqinds[3] = (         int  )0;
          sqlstm.sqharm[3] = (unsigned int  )0;
          sqlstm.sqharc[3] = (unsigned int   *)0;
          sqlstm.sqadto[3] = (unsigned short )0;
          sqlstm.sqtdso[3] = (unsigned short )0;
          sqlstm.sqhstv[4] = (         void  *)cal.sE;
          sqlstm.sqhstl[4] = (unsigned int  )sizeof(float);
          sqlstm.sqhsts[4] = (         int  )sizeof(float);
          sqlstm.sqindv[4] = (         void  *)0;
          sqlstm.sqinds[4] = (         int  )0;
          sqlstm.sqharm[4] = (unsigned int  )0;
          sqlstm.sqharc[4] = (unsigned int   *)0;
          sqlstm.sqadto[4] = (unsigned short )0;
          sqlstm.sqtdso[4] = (unsigned short )0;
          sqlstm.sqhstv[5] = (         void  *)cal.sM;
          sqlstm.sqhstl[5] = (unsigned int  )sizeof(float);
          sqlstm.sqhsts[5] = (         int  )sizeof(float);
          sqlstm.sqindv[5] = (         void  *)0;
          sqlstm.sqinds[5] = (         int  )0;
          sqlstm.sqharm[5] = (unsigned int  )0;
          sqlstm.sqharc[5] = (unsigned int   *)0;
          sqlstm.sqadto[5] = (unsigned short )0;
          sqlstm.sqtdso[5] = (unsigned short )0;
          sqlstm.sqhstv[6] = (         void  *)cal.o;
          sqlstm.sqhstl[6] = (unsigned int  )sizeof(float);
          sqlstm.sqhsts[6] = (         int  )sizeof(float);
          sqlstm.sqindv[6] = (         void  *)0;
          sqlstm.sqinds[6] = (         int  )0;
          sqlstm.sqharm[6] = (unsigned int  )0;
          sqlstm.sqharc[6] = (unsigned int   *)0;
          sqlstm.sqadto[6] = (unsigned short )0;
          sqlstm.sqtdso[6] = (unsigned short )0;
          sqlstm.sqhstv[7] = (         void  *)cal.oE;
          sqlstm.sqhstl[7] = (unsigned int  )sizeof(float);
          sqlstm.sqhsts[7] = (         int  )sizeof(float);
          sqlstm.sqindv[7] = (         void  *)0;
          sqlstm.sqinds[7] = (         int  )0;
          sqlstm.sqharm[7] = (unsigned int  )0;
          sqlstm.sqharc[7] = (unsigned int   *)0;
          sqlstm.sqadto[7] = (unsigned short )0;
          sqlstm.sqtdso[7] = (unsigned short )0;
          sqlstm.sqhstv[8] = (         void  *)cal.oM;
          sqlstm.sqhstl[8] = (unsigned int  )sizeof(float);
          sqlstm.sqhsts[8] = (         int  )sizeof(float);
          sqlstm.sqindv[8] = (         void  *)0;
          sqlstm.sqinds[8] = (         int  )0;
          sqlstm.sqharm[8] = (unsigned int  )0;
          sqlstm.sqharc[8] = (unsigned int   *)0;
          sqlstm.sqadto[8] = (unsigned short )0;
          sqlstm.sqtdso[8] = (unsigned short )0;
          sqlstm.sqphsv = sqlstm.sqhstv;
          sqlstm.sqphsl = sqlstm.sqhstl;
          sqlstm.sqphss = sqlstm.sqhsts;
          sqlstm.sqpind = sqlstm.sqindv;
          sqlstm.sqpins = sqlstm.sqinds;
          sqlstm.sqparm = sqlstm.sqharm;
          sqlstm.sqparc = sqlstm.sqharc;
          sqlstm.sqpadto = sqlstm.sqadto;
          sqlstm.sqptdso = sqlstm.sqtdso;
          sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
          if (sqlca.sqlcode < 0) showSqlError("read(HMdcCalParRaw*,Int_t*)");
}


          Int_t nChannels=-1, mo, mm=-1, mi=-1, ch;
          nChannels=sqlca.sqlerrd[2];
          for(Int_t k=0;k<nChannels;k++) {
            mo=cal.mbo[k];
            if (mo>mm) {
              mi++;
              const Char_t* mboName=mod[mi].GetName();
              sscanf(mboName,"%i",&mm);
              if (mo!=mm) {
                Error("read(HMdcCalParRaw*,Int_t*)",
                      "MBO %i is missing in parameter container",mm);
                /* EXEC SQL CLOSE c8; */ 

{
                struct sqlexd sqlstm;
                sqlorat((void **)0, &sqlctx, &oraca);
                sqlstm.sqlvsn = 12;
                sqlstm.arrsiz = 9;
                sqlstm.sqladtp = &sqladt;
                sqlstm.sqltdsp = &sqltds;
                sqlstm.iters = (unsigned int  )1;
                sqlstm.offset = (unsigned int  )714;
                sqlstm.cud = sqlcud0;
                sqlstm.sqlest = (unsigned char  *)&sqlca;
                sqlstm.sqlety = (unsigned short)256;
                sqlstm.occurs = (unsigned int  )0;
                sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
                if (sqlca.sqlcode < 0) showSqlError("read(HMdcCalParRaw*,Int_t*)");
}


                return kFALSE;
              }
              mm=mo;
            }
            ch=(cal.tdc[k]-1)*8 + cal.chan[k] - 1;
            mod[mi][ch].fill(cal.sl[k],cal.o[k],
                             cal.sE[k],cal.oE[k],
                             (Int_t)cal.sM[k],(Int_t)cal.oM[k]);
          }
          if (nChannels>0) {
            set[pos]=0;
            initModules->AddAt(pos+1,pos);
          }
          else allFound=kFALSE;
         }
        else allFound=kFALSE;
      }
    }
  }
  /* EXEC SQL CLOSE c8; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 9;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )729;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) showSqlError("read(HMdcCalParRaw*,Int_t*)");
}


  setChanged(pPar);
  printInfo(pPar->GetName());
  return allFound;
}; 


Bool_t HMdcParOraIo::read(HMdcCal2ParSim* pPar, Int_t* set) {
  // reads the calibration parameters and fill the MdcCal2ParSim container
  Int_t contVers=pPar->getInputVersion(inputNumber);
  TArrayI versions(modIds->GetSize());
  Int_t version=getVersion(pPar,&versions);
  if (version==-1) {
    pPar->setInputVersion(-1,inputNumber);
    return kFALSE;
  }
  if (contVers==version) return kTRUE;
  if (inputNumber==1) pPar->clear();
  initModules->Reset();
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int id;
    int vers;
    struct {
      int angle[MDC_MAXARR];
      int dbin[MDC_MAXARR];
      float d1[MDC_MAXARR];
      float d2[MDC_MAXARR];
      float d1e[MDC_MAXARR];
      float d2e[MDC_MAXARR];
    } cal2;
  /* EXEC SQL END DECLARE SECTION; */ 

  /* EXEC SQL WHENEVER SQLERROR DO showSqlError("read(HMdcCal2ParSim*,Int_t*)"); */ 

  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 

  /* EXEC SQL DECLARE c9 CURSOR FOR
    SELECT angle_step, distance_bin,
           drifttime1, drifttime2, drifttime1_err, drifttime2_err
      FROM mdc_ana.cal2parsim_data
      WHERE det_part_id = :id
        AND vers_id =:vers; */ 

  Bool_t allFound=kTRUE;
  HMdcCal2ParSim& mdc=*pPar;
  Int_t pos;
  for(Int_t i=0;i<6;i++) {
    HMdcCal2ParSecSim& sec=mdc[i];
    for(Int_t j=0;j<4;j++) {
      HMdcCal2ParModSim& mod=sec[j];
      pos=i*4+j;
      if (set[pos]) {
        id=mdcIds->At(pos);
        vers=versions.At(id);
        // cout<<pos<<"  "<<id<<"  "<<vers<<endl;
        if (id>0 && vers>0) {
         Int_t nAngles=mod.getSize();
         Int_t nBins=pPar->getNumberOfBins();
          /* EXEC SQL OPEN c9; */ 

{
          struct sqlexd sqlstm;
          sqlorat((void **)0, &sqlctx, &oraca);
          sqlstm.sqlvsn = 12;
          sqlstm.arrsiz = 9;
          sqlstm.sqladtp = &sqladt;
          sqlstm.sqltdsp = &sqltds;
          sqlstm.stmt = sq0017;
          sqlstm.iters = (unsigned int  )1;
          sqlstm.offset = (unsigned int  )744;
          sqlstm.selerr = (unsigned short)1;
          sqlstm.cud = sqlcud0;
          sqlstm.sqlest = (unsigned char  *)&sqlca;
          sqlstm.sqlety = (unsigned short)256;
          sqlstm.occurs = (unsigned int  )0;
          sqlstm.sqcmod = (unsigned int )0;
          sqlstm.sqhstv[0] = (         void  *)&id;
          sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[0] = (         int  )0;
          sqlstm.sqindv[0] = (         void  *)0;
          sqlstm.sqinds[0] = (         int  )0;
          sqlstm.sqharm[0] = (unsigned int  )0;
          sqlstm.sqadto[0] = (unsigned short )0;
          sqlstm.sqtdso[0] = (unsigned short )0;
          sqlstm.sqhstv[1] = (         void  *)&vers;
          sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[1] = (         int  )0;
          sqlstm.sqindv[1] = (         void  *)0;
          sqlstm.sqinds[1] = (         int  )0;
          sqlstm.sqharm[1] = (unsigned int  )0;
          sqlstm.sqadto[1] = (unsigned short )0;
          sqlstm.sqtdso[1] = (unsigned short )0;
          sqlstm.sqphsv = sqlstm.sqhstv;
          sqlstm.sqphsl = sqlstm.sqhstl;
          sqlstm.sqphss = sqlstm.sqhsts;
          sqlstm.sqpind = sqlstm.sqindv;
          sqlstm.sqpins = sqlstm.sqinds;
          sqlstm.sqparm = sqlstm.sqharm;
          sqlstm.sqparc = sqlstm.sqharc;
          sqlstm.sqpadto = sqlstm.sqadto;
          sqlstm.sqptdso = sqlstm.sqtdso;
          sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
          if (sqlca.sqlcode < 0) showSqlError("read(HMdcCal2ParSim*,Int_t*)");
}


          /* EXEC SQL FETCH c9 INTO :cal2; */ 

{
          struct sqlexd sqlstm;
          sqlorat((void **)0, &sqlctx, &oraca);
          sqlstm.sqlvsn = 12;
          sqlstm.arrsiz = 9;
          sqlstm.sqladtp = &sqladt;
          sqlstm.sqltdsp = &sqltds;
          sqlstm.iters = (unsigned int  )2000;
          sqlstm.offset = (unsigned int  )767;
          sqlstm.selerr = (unsigned short)1;
          sqlstm.cud = sqlcud0;
          sqlstm.sqlest = (unsigned char  *)&sqlca;
          sqlstm.sqlety = (unsigned short)256;
          sqlstm.occurs = (unsigned int  )0;
          sqlstm.sqfoff = (           int )0;
          sqlstm.sqfmod = (unsigned int )2;
          sqlstm.sqhstv[0] = (         void  *)cal2.angle;
          sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[0] = (         int  )sizeof(int);
          sqlstm.sqindv[0] = (         void  *)0;
          sqlstm.sqinds[0] = (         int  )0;
          sqlstm.sqharm[0] = (unsigned int  )0;
          sqlstm.sqharc[0] = (unsigned int   *)0;
          sqlstm.sqadto[0] = (unsigned short )0;
          sqlstm.sqtdso[0] = (unsigned short )0;
          sqlstm.sqhstv[1] = (         void  *)cal2.dbin;
          sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[1] = (         int  )sizeof(int);
          sqlstm.sqindv[1] = (         void  *)0;
          sqlstm.sqinds[1] = (         int  )0;
          sqlstm.sqharm[1] = (unsigned int  )0;
          sqlstm.sqharc[1] = (unsigned int   *)0;
          sqlstm.sqadto[1] = (unsigned short )0;
          sqlstm.sqtdso[1] = (unsigned short )0;
          sqlstm.sqhstv[2] = (         void  *)cal2.d1;
          sqlstm.sqhstl[2] = (unsigned int  )sizeof(float);
          sqlstm.sqhsts[2] = (         int  )sizeof(float);
          sqlstm.sqindv[2] = (         void  *)0;
          sqlstm.sqinds[2] = (         int  )0;
          sqlstm.sqharm[2] = (unsigned int  )0;
          sqlstm.sqharc[2] = (unsigned int   *)0;
          sqlstm.sqadto[2] = (unsigned short )0;
          sqlstm.sqtdso[2] = (unsigned short )0;
          sqlstm.sqhstv[3] = (         void  *)cal2.d2;
          sqlstm.sqhstl[3] = (unsigned int  )sizeof(float);
          sqlstm.sqhsts[3] = (         int  )sizeof(float);
          sqlstm.sqindv[3] = (         void  *)0;
          sqlstm.sqinds[3] = (         int  )0;
          sqlstm.sqharm[3] = (unsigned int  )0;
          sqlstm.sqharc[3] = (unsigned int   *)0;
          sqlstm.sqadto[3] = (unsigned short )0;
          sqlstm.sqtdso[3] = (unsigned short )0;
          sqlstm.sqhstv[4] = (         void  *)cal2.d1e;
          sqlstm.sqhstl[4] = (unsigned int  )sizeof(float);
          sqlstm.sqhsts[4] = (         int  )sizeof(float);
          sqlstm.sqindv[4] = (         void  *)0;
          sqlstm.sqinds[4] = (         int  )0;
          sqlstm.sqharm[4] = (unsigned int  )0;
          sqlstm.sqharc[4] = (unsigned int   *)0;
          sqlstm.sqadto[4] = (unsigned short )0;
          sqlstm.sqtdso[4] = (unsigned short )0;
          sqlstm.sqhstv[5] = (         void  *)cal2.d2e;
          sqlstm.sqhstl[5] = (unsigned int  )sizeof(float);
          sqlstm.sqhsts[5] = (         int  )sizeof(float);
          sqlstm.sqindv[5] = (         void  *)0;
          sqlstm.sqinds[5] = (         int  )0;
          sqlstm.sqharm[5] = (unsigned int  )0;
          sqlstm.sqharc[5] = (unsigned int   *)0;
          sqlstm.sqadto[5] = (unsigned short )0;
          sqlstm.sqtdso[5] = (unsigned short )0;
          sqlstm.sqphsv = sqlstm.sqhstv;
          sqlstm.sqphsl = sqlstm.sqhstl;
          sqlstm.sqphss = sqlstm.sqhsts;
          sqlstm.sqpind = sqlstm.sqindv;
          sqlstm.sqpins = sqlstm.sqinds;
          sqlstm.sqparm = sqlstm.sqharm;
          sqlstm.sqparc = sqlstm.sqharc;
          sqlstm.sqpadto = sqlstm.sqadto;
          sqlstm.sqptdso = sqlstm.sqtdso;
          sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
          if (sqlca.sqlcode < 0) showSqlError("read(HMdcCal2ParSim*,Int_t*)");
}


          Int_t nVal=-1;
          nVal=sqlca.sqlerrd[2];
          for(Int_t c=0;c<nVal;c++) {
            Int_t a=cal2.angle[c];
            Int_t b=cal2.dbin[c];
            if (b>nBins || a > nAngles) {
              Error("read(HMdcCal2ParSim,Int_t*)",
                    "Buffer size exceeded!");
              return kFALSE;
            }
            mod[a].setDriftTime1(b,cal2.d1[c]);
            mod[a].setDriftTime2(b,cal2.d2[c]);
            mod[a].setDriftTime1Error(b,cal2.d1e[c]);
            mod[a].setDriftTime2Error(b,cal2.d2e[c]);
          }
          if (nVal>0) {
            set[pos]=0;
            initModules->AddAt(pos+1,pos);
          }
          else allFound=kFALSE;
         }
        else allFound=kFALSE;
      }
    }
  }
  /* EXEC SQL CLOSE c9; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 9;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )806;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) showSqlError("read(HMdcCal2ParSim*,Int_t*)");
}


  setChanged(pPar);
  printInfo(pPar->GetName());
  return allFound;
}; 


Bool_t HMdcParOraIo::read(HMdcCellEff* pPar, Int_t* set) {
  // reads the cell efficiency parameters and fill the container
  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 plane[MDC_MAXARR];
      float an[MDC_MAXARR];
      float mr[MDC_MAXARR];
      float sl[MDC_MAXARR];
    } eff;
  /* EXEC SQL END DECLARE SECTION; */ 

  /* EXEC SQL WHENEVER SQLERROR DO showSqlError("read(HMdcCellEff*,Int_t*)"); */ 

  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 

  vers=oraVersion;
  /* EXEC SQL SELECT plane, angle, max_r, slope INTO :eff
      FROM mdc_ana.celleff_data
      WHERE vers_id =:vers; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 9;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "select plane ,angle ,max_r ,slope into :s1 ,:s2 ,:s3 ,:s4  \
 from mdc_ana.celleff_data where vers_id=:b1";
  sqlstm.iters = (unsigned int  )2000;
  sqlstm.offset = (unsigned int  )821;
  sqlstm.selerr = (unsigned short)1;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)eff.plane;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )sizeof(int);
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqharc[0] = (unsigned int   *)0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqhstv[1] = (         void  *)eff.an;
  sqlstm.sqhstl[1] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[1] = (         int  )sizeof(float);
  sqlstm.sqindv[1] = (         void  *)0;
  sqlstm.sqinds[1] = (         int  )0;
  sqlstm.sqharm[1] = (unsigned int  )0;
  sqlstm.sqharc[1] = (unsigned int   *)0;
  sqlstm.sqadto[1] = (unsigned short )0;
  sqlstm.sqtdso[1] = (unsigned short )0;
  sqlstm.sqhstv[2] = (         void  *)eff.mr;
  sqlstm.sqhstl[2] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[2] = (         int  )sizeof(float);
  sqlstm.sqindv[2] = (         void  *)0;
  sqlstm.sqinds[2] = (         int  )0;
  sqlstm.sqharm[2] = (unsigned int  )0;
  sqlstm.sqharc[2] = (unsigned int   *)0;
  sqlstm.sqadto[2] = (unsigned short )0;
  sqlstm.sqtdso[2] = (unsigned short )0;
  sqlstm.sqhstv[3] = (         void  *)eff.sl;
  sqlstm.sqhstl[3] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[3] = (         int  )sizeof(float);
  sqlstm.sqindv[3] = (         void  *)0;
  sqlstm.sqinds[3] = (         int  )0;
  sqlstm.sqharm[3] = (unsigned int  )0;
  sqlstm.sqharc[3] = (unsigned int   *)0;
  sqlstm.sqadto[3] = (unsigned short )0;
  sqlstm.sqtdso[3] = (unsigned short )0;
  sqlstm.sqhstv[4] = (         void  *)&vers;
  sqlstm.sqhstl[4] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[4] = (         int  )sizeof(int);
  sqlstm.sqindv[4] = (         void  *)0;
  sqlstm.sqinds[4] = (         int  )0;
  sqlstm.sqharm[4] = (unsigned int  )0;
  sqlstm.sqadto[4] = (unsigned short )0;
  sqlstm.sqtdso[4] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) showSqlError("read(HMdcCellEff*,Int_t*)");
}


  for(Int_t k=0;k<sqlca.sqlerrd[2];k++) {
    Int_t p=eff.plane[k]-1;
    set[p]=0;
    (*pPar)[p][(Int_t)eff.an[k]].setFunctionValues(eff.mr[k],eff.sl[k]);
  }
  for (Int_t i=0;i<4;i++) if (set[i]==1) return kFALSE;
  setChanged(pPar);
  cout<<pPar->GetName()<<" initialized from Oracle\n";
  return kTRUE;
}; 


Bool_t HMdcParOraIo::read(HMdcTimeCut* pPar, Int_t* set) {
  // reads the time cut parameters and fill the container
  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 sec[MDC_MAXMODS];
      int pla[MDC_MAXMODS];
      float ct1l[MDC_MAXMODS];
      float ct1r[MDC_MAXMODS];
      float ct2l[MDC_MAXMODS];
      float ct2r[MDC_MAXMODS];
      float cl[MDC_MAXMODS];
      float cr[MDC_MAXMODS];
    } tcuts;
  /* EXEC SQL END DECLARE SECTION; */ 

  /* EXEC SQL WHENEVER SQLERROR DO showSqlError("read(HMdcTimeCut*,Int_t*)"); */ 

  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 

  vers=oraVersion;
  /* EXEC SQL SELECT sector, plane, cut_t1_l, cut_t1_r, cut_t2_l, cut_t2_r,
                  cut_left, cut_right INTO :tcuts
      FROM mdc_ana.mdc_loc_at_run_hist s, mdc_ana.timecut_data d
      WHERE s.mdc_hwobj_id = d.mdc_hwobj_id and vers_id =:vers; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 9;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "select sector ,plane ,cut_t1_l ,cut_t1_r ,cut_t2_l ,cut_t2_\
r ,cut_left ,cut_right into :s1 ,:s2 ,:s3 ,:s4 ,:s5 ,:s6 ,:s7 ,:s8   from mdc_\
ana.mdc_loc_at_run_hist s ,mdc_ana.timecut_data d where (s.mdc_hwobj_id=d.mdc_\
hwobj_id and vers_id=:b1)";
  sqlstm.iters = (unsigned int  )24;
  sqlstm.offset = (unsigned int  )856;
  sqlstm.selerr = (unsigned short)1;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)tcuts.sec;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )sizeof(int);
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqharc[0] = (unsigned int   *)0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqhstv[1] = (         void  *)tcuts.pla;
  sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[1] = (         int  )sizeof(int);
  sqlstm.sqindv[1] = (         void  *)0;
  sqlstm.sqinds[1] = (         int  )0;
  sqlstm.sqharm[1] = (unsigned int  )0;
  sqlstm.sqharc[1] = (unsigned int   *)0;
  sqlstm.sqadto[1] = (unsigned short )0;
  sqlstm.sqtdso[1] = (unsigned short )0;
  sqlstm.sqhstv[2] = (         void  *)tcuts.ct1l;
  sqlstm.sqhstl[2] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[2] = (         int  )sizeof(float);
  sqlstm.sqindv[2] = (         void  *)0;
  sqlstm.sqinds[2] = (         int  )0;
  sqlstm.sqharm[2] = (unsigned int  )0;
  sqlstm.sqharc[2] = (unsigned int   *)0;
  sqlstm.sqadto[2] = (unsigned short )0;
  sqlstm.sqtdso[2] = (unsigned short )0;
  sqlstm.sqhstv[3] = (         void  *)tcuts.ct1r;
  sqlstm.sqhstl[3] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[3] = (         int  )sizeof(float);
  sqlstm.sqindv[3] = (         void  *)0;
  sqlstm.sqinds[3] = (         int  )0;
  sqlstm.sqharm[3] = (unsigned int  )0;
  sqlstm.sqharc[3] = (unsigned int   *)0;
  sqlstm.sqadto[3] = (unsigned short )0;
  sqlstm.sqtdso[3] = (unsigned short )0;
  sqlstm.sqhstv[4] = (         void  *)tcuts.ct2l;
  sqlstm.sqhstl[4] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[4] = (         int  )sizeof(float);
  sqlstm.sqindv[4] = (         void  *)0;
  sqlstm.sqinds[4] = (         int  )0;
  sqlstm.sqharm[4] = (unsigned int  )0;
  sqlstm.sqharc[4] = (unsigned int   *)0;
  sqlstm.sqadto[4] = (unsigned short )0;
  sqlstm.sqtdso[4] = (unsigned short )0;
  sqlstm.sqhstv[5] = (         void  *)tcuts.ct2r;
  sqlstm.sqhstl[5] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[5] = (         int  )sizeof(float);
  sqlstm.sqindv[5] = (         void  *)0;
  sqlstm.sqinds[5] = (         int  )0;
  sqlstm.sqharm[5] = (unsigned int  )0;
  sqlstm.sqharc[5] = (unsigned int   *)0;
  sqlstm.sqadto[5] = (unsigned short )0;
  sqlstm.sqtdso[5] = (unsigned short )0;
  sqlstm.sqhstv[6] = (         void  *)tcuts.cl;
  sqlstm.sqhstl[6] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[6] = (         int  )sizeof(float);
  sqlstm.sqindv[6] = (         void  *)0;
  sqlstm.sqinds[6] = (         int  )0;
  sqlstm.sqharm[6] = (unsigned int  )0;
  sqlstm.sqharc[6] = (unsigned int   *)0;
  sqlstm.sqadto[6] = (unsigned short )0;
  sqlstm.sqtdso[6] = (unsigned short )0;
  sqlstm.sqhstv[7] = (         void  *)tcuts.cr;
  sqlstm.sqhstl[7] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[7] = (         int  )sizeof(float);
  sqlstm.sqindv[7] = (         void  *)0;
  sqlstm.sqinds[7] = (         int  )0;
  sqlstm.sqharm[7] = (unsigned int  )0;
  sqlstm.sqharc[7] = (unsigned int   *)0;
  sqlstm.sqadto[7] = (unsigned short )0;
  sqlstm.sqtdso[7] = (unsigned short )0;
  sqlstm.sqhstv[8] = (         void  *)&vers;
  sqlstm.sqhstl[8] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[8] = (         int  )sizeof(int);
  sqlstm.sqindv[8] = (         void  *)0;
  sqlstm.sqinds[8] = (         int  )0;
  sqlstm.sqharm[8] = (unsigned int  )0;
  sqlstm.sqadto[8] = (unsigned short )0;
  sqlstm.sqtdso[8] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) showSqlError("read(HMdcTimeCut*,Int_t*)");
}


  Int_t pos;
  initModules->Reset();
  for(Int_t k=0;k<sqlca.sqlerrd[2];k++) {
    Int_t s=tcuts.sec[k]-1;
    Int_t p=tcuts.pla[k]-1;
    pos=s*4+p;
    if (set[pos]) {
      (*pPar)[s][p].fill(tcuts.ct1l[k],tcuts.ct1r[k],tcuts.ct2l[k],tcuts.ct2r[k],
                         tcuts.cl[k],tcuts.cr[k]);
      set[pos]=0;
      initModules->AddAt(pos+1,pos);
    }
  }
  Bool_t allFound=kTRUE;
  for (Int_t i=0;i<MDC_MAXMODS;i++) if (set[i]==1) allFound=kFALSE;
  setChanged(pPar);
  printInfo(pPar->GetName());
  return allFound;
}; 


Bool_t HMdcParOraIo::read(HMdcLayerGeomPar* pPar, Int_t* set) {
  // reads the layer parameters and fill the container
  Int_t contVers=pPar->getInputVersion(inputNumber);
  TArrayI versions(modIds->GetSize());
  Int_t version=getVersion(pPar,&versions);
  if (version==-1) {
    pPar->setInputVersion(-1,inputNumber);
    return kFALSE;
  }
  if (contVers==version) return kTRUE;
  if (inputNumber==1) pPar->clear();
  initModules->Reset();
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int id;
    int vers;
    struct {
      int lay[MDC_MAXLAYS];
      float dist[MDC_MAXLAYS];
      float pitch[MDC_MAXLAYS];
      float angle[MDC_MAXLAYS];
      float cwire[MDC_MAXLAYS];
      float cathth[MDC_MAXLAYS];
    } layers;
  /* EXEC SQL END DECLARE SECTION; */ 

  /* EXEC SQL WHENEVER SQLERROR DO showSqlError("read(HMdcLayerGeomPar*,Int_t*)"); */ 

  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 

  /* EXEC SQL DECLARE c5 CURSOR FOR
    SELECT layer_nr, cell_thickness, cell_pitch, inclination_angle,
           central_wire_nr, cathode_wire_thickness
      FROM mdc_ana.layergeompar_data
      WHERE det_part_id = :id and vers_id =:vers; */ 

  Bool_t allFound=kTRUE;
  HMdcLayerGeomPar& mdc=*pPar;
  Int_t pos;
  for(Int_t i=0;i<mdc.getSize();i++) {
    HMdcLayerGeomParSec& sec=mdc[i];
    for(Int_t j=0;j<sec.getSize();j++) {
      HMdcLayerGeomParMod& mod=sec[j];
      pos=i*4+j;
      if (set[pos]) {
        id=mdcIds->At(pos);
        vers=versions.At(id);
        if (id>0 && vers>0) {
          /* EXEC SQL OPEN c5; */ 

{
          struct sqlexd sqlstm;
          sqlorat((void **)0, &sqlctx, &oraca);
          sqlstm.sqlvsn = 12;
          sqlstm.arrsiz = 9;
          sqlstm.sqladtp = &sqladt;
          sqlstm.sqltdsp = &sqltds;
          sqlstm.stmt = sq0020;
          sqlstm.iters = (unsigned int  )1;
          sqlstm.offset = (unsigned int  )907;
          sqlstm.selerr = (unsigned short)1;
          sqlstm.cud = sqlcud0;
          sqlstm.sqlest = (unsigned char  *)&sqlca;
          sqlstm.sqlety = (unsigned short)256;
          sqlstm.occurs = (unsigned int  )0;
          sqlstm.sqcmod = (unsigned int )0;
          sqlstm.sqhstv[0] = (         void  *)&id;
          sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[0] = (         int  )0;
          sqlstm.sqindv[0] = (         void  *)0;
          sqlstm.sqinds[0] = (         int  )0;
          sqlstm.sqharm[0] = (unsigned int  )0;
          sqlstm.sqadto[0] = (unsigned short )0;
          sqlstm.sqtdso[0] = (unsigned short )0;
          sqlstm.sqhstv[1] = (         void  *)&vers;
          sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[1] = (         int  )0;
          sqlstm.sqindv[1] = (         void  *)0;
          sqlstm.sqinds[1] = (         int  )0;
          sqlstm.sqharm[1] = (unsigned int  )0;
          sqlstm.sqadto[1] = (unsigned short )0;
          sqlstm.sqtdso[1] = (unsigned short )0;
          sqlstm.sqphsv = sqlstm.sqhstv;
          sqlstm.sqphsl = sqlstm.sqhstl;
          sqlstm.sqphss = sqlstm.sqhsts;
          sqlstm.sqpind = sqlstm.sqindv;
          sqlstm.sqpins = sqlstm.sqinds;
          sqlstm.sqparm = sqlstm.sqharm;
          sqlstm.sqparc = sqlstm.sqharc;
          sqlstm.sqpadto = sqlstm.sqadto;
          sqlstm.sqptdso = sqlstm.sqtdso;
          sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
          if (sqlca.sqlcode < 0) showSqlError("read(HMdcLayerGeomPar*,Int_t*)");
}


          /* EXEC SQL FETCH c5 INTO :layers; */ 

{
          struct sqlexd sqlstm;
          sqlorat((void **)0, &sqlctx, &oraca);
          sqlstm.sqlvsn = 12;
          sqlstm.arrsiz = 9;
          sqlstm.sqladtp = &sqladt;
          sqlstm.sqltdsp = &sqltds;
          sqlstm.iters = (unsigned int  )6;
          sqlstm.offset = (unsigned int  )930;
          sqlstm.selerr = (unsigned short)1;
          sqlstm.cud = sqlcud0;
          sqlstm.sqlest = (unsigned char  *)&sqlca;
          sqlstm.sqlety = (unsigned short)256;
          sqlstm.occurs = (unsigned int  )0;
          sqlstm.sqfoff = (           int )0;
          sqlstm.sqfmod = (unsigned int )2;
          sqlstm.sqhstv[0] = (         void  *)layers.lay;
          sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[0] = (         int  )sizeof(int);
          sqlstm.sqindv[0] = (         void  *)0;
          sqlstm.sqinds[0] = (         int  )0;
          sqlstm.sqharm[0] = (unsigned int  )0;
          sqlstm.sqharc[0] = (unsigned int   *)0;
          sqlstm.sqadto[0] = (unsigned short )0;
          sqlstm.sqtdso[0] = (unsigned short )0;
          sqlstm.sqhstv[1] = (         void  *)layers.dist;
          sqlstm.sqhstl[1] = (unsigned int  )sizeof(float);
          sqlstm.sqhsts[1] = (         int  )sizeof(float);
          sqlstm.sqindv[1] = (         void  *)0;
          sqlstm.sqinds[1] = (         int  )0;
          sqlstm.sqharm[1] = (unsigned int  )0;
          sqlstm.sqharc[1] = (unsigned int   *)0;
          sqlstm.sqadto[1] = (unsigned short )0;
          sqlstm.sqtdso[1] = (unsigned short )0;
          sqlstm.sqhstv[2] = (         void  *)layers.pitch;
          sqlstm.sqhstl[2] = (unsigned int  )sizeof(float);
          sqlstm.sqhsts[2] = (         int  )sizeof(float);
          sqlstm.sqindv[2] = (         void  *)0;
          sqlstm.sqinds[2] = (         int  )0;
          sqlstm.sqharm[2] = (unsigned int  )0;
          sqlstm.sqharc[2] = (unsigned int   *)0;
          sqlstm.sqadto[2] = (unsigned short )0;
          sqlstm.sqtdso[2] = (unsigned short )0;
          sqlstm.sqhstv[3] = (         void  *)layers.angle;
          sqlstm.sqhstl[3] = (unsigned int  )sizeof(float);
          sqlstm.sqhsts[3] = (         int  )sizeof(float);
          sqlstm.sqindv[3] = (         void  *)0;
          sqlstm.sqinds[3] = (         int  )0;
          sqlstm.sqharm[3] = (unsigned int  )0;
          sqlstm.sqharc[3] = (unsigned int   *)0;
          sqlstm.sqadto[3] = (unsigned short )0;
          sqlstm.sqtdso[3] = (unsigned short )0;
          sqlstm.sqhstv[4] = (         void  *)layers.cwire;
          sqlstm.sqhstl[4] = (unsigned int  )sizeof(float);
          sqlstm.sqhsts[4] = (         int  )sizeof(float);
          sqlstm.sqindv[4] = (         void  *)0;
          sqlstm.sqinds[4] = (         int  )0;
          sqlstm.sqharm[4] = (unsigned int  )0;
          sqlstm.sqharc[4] = (unsigned int   *)0;
          sqlstm.sqadto[4] = (unsigned short )0;
          sqlstm.sqtdso[4] = (unsigned short )0;
          sqlstm.sqhstv[5] = (         void  *)layers.cathth;
          sqlstm.sqhstl[5] = (unsigned int  )sizeof(float);
          sqlstm.sqhsts[5] = (         int  )sizeof(float);
          sqlstm.sqindv[5] = (         void  *)0;
          sqlstm.sqinds[5] = (         int  )0;
          sqlstm.sqharm[5] = (unsigned int  )0;
          sqlstm.sqharc[5] = (unsigned int   *)0;
          sqlstm.sqadto[5] = (unsigned short )0;
          sqlstm.sqtdso[5] = (unsigned short )0;
          sqlstm.sqphsv = sqlstm.sqhstv;
          sqlstm.sqphsl = sqlstm.sqhstl;
          sqlstm.sqphss = sqlstm.sqhsts;
          sqlstm.sqpind = sqlstm.sqindv;
          sqlstm.sqpins = sqlstm.sqinds;
          sqlstm.sqparm = sqlstm.sqharm;
          sqlstm.sqparc = sqlstm.sqharc;
          sqlstm.sqpadto = sqlstm.sqadto;
          sqlstm.sqptdso = sqlstm.sqtdso;
          sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
          if (sqlca.sqlcode < 0) showSqlError("read(HMdcLayerGeomPar*,Int_t*)");
}


          Int_t nVal=sqlca.sqlerrd[2];
          for(Int_t k=0;k<nVal;k++)
            mod[layers.lay[k]-1].fill(layers.pitch[k],layers.dist[k],
                        layers.angle[k],layers.cwire[k],layers.cathth[k]);
          if (nVal>0) {
            set[pos]=0;
            initModules->AddAt(pos+1,pos);
          } else allFound=kFALSE;
        } else allFound=kFALSE;
      }
    }
  }
  /* EXEC SQL CLOSE c5; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 9;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )969;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) showSqlError("read(HMdcLayerGeomPar*,Int_t*)");
}


  setChanged(pPar);
  printInfo(pPar->GetName());
  return allFound;
}; 


Bool_t HMdcParOraIo::read(HMdcClosePairCutsPar* pPar, Int_t* set) {
  // reads the close pair cut parameters and fill the container
  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 lb[MDC_MAXARR];
      int tb[MDC_MAXARR];
      int pb[MDC_MAXARR];
      int eb[MDC_MAXARR];
      float eff[MDC_MAXARR];
      float s2b[MDC_MAXARR];
      float mcs[MDC_MAXARR];
      float mwc[MDC_MAXARR];
      float rcc[MDC_MAXARR];
    } cpcuts;
  /* EXEC SQL END DECLARE SECTION; */ 

  /* EXEC SQL WHENEVER SQLERROR DO showSqlError("read(HMdcTimeCut*,Int_t*)"); */ 

  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 

  vers=oraVersion;
  /* EXEC SQL SELECT levelbin, thetabin, phibin, effbin,
                  efficiency, sig2back, mdc_size_cut, mdc_wires_cut,
                  rich_charge_cut
      INTO :cpcuts
      FROM mdc_ana.closepaircut_data
      WHERE vers_id =:vers; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 10;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "select levelbin ,thetabin ,phibin ,effbin ,efficiency ,sig2\
back ,mdc_size_cut ,mdc_wires_cut ,rich_charge_cut into :s1 ,:s2 ,:s3 ,:s4 ,:s\
5 ,:s6 ,:s7 ,:s8 ,:s9   from mdc_ana.closepaircut_data where vers_id=:b1";
  sqlstm.iters = (unsigned int  )2000;
  sqlstm.offset = (unsigned int  )984;
  sqlstm.selerr = (unsigned short)1;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)cpcuts.lb;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )sizeof(int);
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqharc[0] = (unsigned int   *)0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqhstv[1] = (         void  *)cpcuts.tb;
  sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[1] = (         int  )sizeof(int);
  sqlstm.sqindv[1] = (         void  *)0;
  sqlstm.sqinds[1] = (         int  )0;
  sqlstm.sqharm[1] = (unsigned int  )0;
  sqlstm.sqharc[1] = (unsigned int   *)0;
  sqlstm.sqadto[1] = (unsigned short )0;
  sqlstm.sqtdso[1] = (unsigned short )0;
  sqlstm.sqhstv[2] = (         void  *)cpcuts.pb;
  sqlstm.sqhstl[2] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[2] = (         int  )sizeof(int);
  sqlstm.sqindv[2] = (         void  *)0;
  sqlstm.sqinds[2] = (         int  )0;
  sqlstm.sqharm[2] = (unsigned int  )0;
  sqlstm.sqharc[2] = (unsigned int   *)0;
  sqlstm.sqadto[2] = (unsigned short )0;
  sqlstm.sqtdso[2] = (unsigned short )0;
  sqlstm.sqhstv[3] = (         void  *)cpcuts.eb;
  sqlstm.sqhstl[3] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[3] = (         int  )sizeof(int);
  sqlstm.sqindv[3] = (         void  *)0;
  sqlstm.sqinds[3] = (         int  )0;
  sqlstm.sqharm[3] = (unsigned int  )0;
  sqlstm.sqharc[3] = (unsigned int   *)0;
  sqlstm.sqadto[3] = (unsigned short )0;
  sqlstm.sqtdso[3] = (unsigned short )0;
  sqlstm.sqhstv[4] = (         void  *)cpcuts.eff;
  sqlstm.sqhstl[4] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[4] = (         int  )sizeof(float);
  sqlstm.sqindv[4] = (         void  *)0;
  sqlstm.sqinds[4] = (         int  )0;
  sqlstm.sqharm[4] = (unsigned int  )0;
  sqlstm.sqharc[4] = (unsigned int   *)0;
  sqlstm.sqadto[4] = (unsigned short )0;
  sqlstm.sqtdso[4] = (unsigned short )0;
  sqlstm.sqhstv[5] = (         void  *)cpcuts.s2b;
  sqlstm.sqhstl[5] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[5] = (         int  )sizeof(float);
  sqlstm.sqindv[5] = (         void  *)0;
  sqlstm.sqinds[5] = (         int  )0;
  sqlstm.sqharm[5] = (unsigned int  )0;
  sqlstm.sqharc[5] = (unsigned int   *)0;
  sqlstm.sqadto[5] = (unsigned short )0;
  sqlstm.sqtdso[5] = (unsigned short )0;
  sqlstm.sqhstv[6] = (         void  *)cpcuts.mcs;
  sqlstm.sqhstl[6] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[6] = (         int  )sizeof(float);
  sqlstm.sqindv[6] = (         void  *)0;
  sqlstm.sqinds[6] = (         int  )0;
  sqlstm.sqharm[6] = (unsigned int  )0;
  sqlstm.sqharc[6] = (unsigned int   *)0;
  sqlstm.sqadto[6] = (unsigned short )0;
  sqlstm.sqtdso[6] = (unsigned short )0;
  sqlstm.sqhstv[7] = (         void  *)cpcuts.mwc;
  sqlstm.sqhstl[7] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[7] = (         int  )sizeof(float);
  sqlstm.sqindv[7] = (         void  *)0;
  sqlstm.sqinds[7] = (         int  )0;
  sqlstm.sqharm[7] = (unsigned int  )0;
  sqlstm.sqharc[7] = (unsigned int   *)0;
  sqlstm.sqadto[7] = (unsigned short )0;
  sqlstm.sqtdso[7] = (unsigned short )0;
  sqlstm.sqhstv[8] = (         void  *)cpcuts.rcc;
  sqlstm.sqhstl[8] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[8] = (         int  )sizeof(float);
  sqlstm.sqindv[8] = (         void  *)0;
  sqlstm.sqinds[8] = (         int  )0;
  sqlstm.sqharm[8] = (unsigned int  )0;
  sqlstm.sqharc[8] = (unsigned int   *)0;
  sqlstm.sqadto[8] = (unsigned short )0;
  sqlstm.sqtdso[8] = (unsigned short )0;
  sqlstm.sqhstv[9] = (         void  *)&vers;
  sqlstm.sqhstl[9] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[9] = (         int  )sizeof(int);
  sqlstm.sqindv[9] = (         void  *)0;
  sqlstm.sqinds[9] = (         int  )0;
  sqlstm.sqharm[9] = (unsigned int  )0;
  sqlstm.sqadto[9] = (unsigned short )0;
  sqlstm.sqtdso[9] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) showSqlError("read(HMdcTimeCut*,Int_t*)");
}


  for(Int_t k=0;k<sqlca.sqlerrd[2];k++) {
    if (cpcuts.lb[k]<=pPar->getSize()) {
      HMdcClosePairCutsParTheta &the=(*pPar)[cpcuts.lb[k]];
      if (cpcuts.tb[k]<=the.getSize()) {
        HMdcClosePairCutsParPhi &phi=the[cpcuts.tb[k]];
        if (cpcuts.pb[k]<=phi.getSize()) {
          HMdcClosePairCutsParEf &efb=phi[cpcuts.pb[k]];
          if (cpcuts.eb[k]<=efb.getSize()) {
            HMdcClosePairCutsParCut &cut=efb[cpcuts.eb[k]];
            cut.fill(cpcuts.eff[k],cpcuts.s2b[k],cpcuts.mcs[k],cpcuts.mwc[k],
                     cpcuts.rcc[k]);
          } else {
            Error("HMdcParOraIo::readline()","Eff array out of bounds");
            return kFALSE;
          }
        } else {
          Error("read(HMdcClosePairCutsPar*,Int*)","Phi array out of bounds");
          return kFALSE;
        }
      } else {
        Error("read(HMdcClosePairCutsPar*,Int*)","Theta array out of bounds");
        return kFALSE;
      }
    } else {
      Error("read(HMdcClosePairCutsPar*,Int*)","Level array out of bounds");
      return kFALSE;
    }
  }
  setChanged(pPar);
  cout<<pPar->GetName()<<" initialized from Oracle\n";
  return kTRUE;
}; 

Int_t HMdcParOraIo::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; */ 

  const Char_t* contName=pPar->IsA()->GetName();
  if ((strcmp(contName,"HMdcTdcThreshold") != 0)
       && (strcmp(contName,"HMdcTdcChannel") != 0)
       && (strcmp(contName,"HMdcLookupGeom") != 0)) {
    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; */ 

  if (strcmp(contName,"HMdcCalParRaw")==0) {
    /* EXEC SQL EXECUTE
      BEGIN
        SELECT mdc_ana.mdc_par_query.next_version INTO :vers FROM DUAL;
        INSERT INTO mdc_ana.cal1par_vers
                   (vers_id, orig_context_id, run_id, author, description)
            VALUES (:vers, :context, :run, :creator, :descript);
      END;
    END-EXEC; */ 

{
    struct sqlexd sqlstm;
    sqlorat((void **)0, &sqlctx, &oraca);
    sqlstm.sqlvsn = 12;
    sqlstm.arrsiz = 10;
    sqlstm.sqladtp = &sqladt;
    sqlstm.sqltdsp = &sqltds;
    sqlstm.stmt = "begin SELECT mdc_ana . mdc_par_query . next_version INTO \
:vers FROM DUAL ; INSERT INTO mdc_ana . cal1par_vers ( vers_id , orig_context_\
id , run_id , author , description ) VALUES ( :vers , :context , :run , :creat\
or , :descript ) ; END ;";
    sqlstm.iters = (unsigned int  )1;
    sqlstm.offset = (unsigned int  )1039;
    sqlstm.cud = sqlcud0;
    sqlstm.sqlest = (unsigned char  *)&sqlca;
    sqlstm.sqlety = (unsigned short)256;
    sqlstm.occurs = (unsigned int  )0;
    sqlstm.sqhstv[0] = (         void  *)&vers;
    sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
    sqlstm.sqhsts[0] = (         int  )0;
    sqlstm.sqindv[0] = (         void  *)0;
    sqlstm.sqinds[0] = (         int  )0;
    sqlstm.sqharm[0] = (unsigned int  )0;
    sqlstm.sqadto[0] = (unsigned short )0;
    sqlstm.sqtdso[0] = (unsigned short )0;
    sqlstm.sqhstv[1] = (         void  *)&context;
    sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
    sqlstm.sqhsts[1] = (         int  )0;
    sqlstm.sqindv[1] = (         void  *)0;
    sqlstm.sqinds[1] = (         int  )0;
    sqlstm.sqharm[1] = (unsigned int  )0;
    sqlstm.sqadto[1] = (unsigned short )0;
    sqlstm.sqtdso[1] = (unsigned short )0;
    sqlstm.sqhstv[2] = (         void  *)&run;
    sqlstm.sqhstl[2] = (unsigned int  )sizeof(int);
    sqlstm.sqhsts[2] = (         int  )0;
    sqlstm.sqindv[2] = (         void  *)0;
    sqlstm.sqinds[2] = (         int  )0;
    sqlstm.sqharm[2] = (unsigned int  )0;
    sqlstm.sqadto[2] = (unsigned short )0;
    sqlstm.sqtdso[2] = (unsigned short )0;
    sqlstm.sqhstv[3] = (         void  *)creator;
    sqlstm.sqhstl[3] = (unsigned int  )0;
    sqlstm.sqhsts[3] = (         int  )0;
    sqlstm.sqindv[3] = (         void  *)0;
    sqlstm.sqinds[3] = (         int  )0;
    sqlstm.sqharm[3] = (unsigned int  )0;
    sqlstm.sqadto[3] = (unsigned short )0;
    sqlstm.sqtdso[3] = (unsigned short )0;
    sqlstm.sqhstv[4] = (         void  *)descript;
    sqlstm.sqhstl[4] = (unsigned int  )0;
    sqlstm.sqhsts[4] = (         int  )0;
    sqlstm.sqindv[4] = (         void  *)0;
    sqlstm.sqinds[4] = (         int  )0;
    sqlstm.sqharm[4] = (unsigned int  )0;
    sqlstm.sqadto[4] = (unsigned short )0;
    sqlstm.sqtdso[4] = (unsigned short )0;
    sqlstm.sqphsv = sqlstm.sqhstv;
    sqlstm.sqphsl = sqlstm.sqhstl;
    sqlstm.sqphss = sqlstm.sqhsts;
    sqlstm.sqpind = sqlstm.sqindv;
    sqlstm.sqpins = sqlstm.sqinds;
    sqlstm.sqparm = sqlstm.sqharm;
    sqlstm.sqparc = sqlstm.sqharc;
    sqlstm.sqpadto = sqlstm.sqadto;
    sqlstm.sqptdso = sqlstm.sqtdso;
    sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
    if (sqlca.sqlcode == 1403) goto not_found;
    if (sqlca.sqlcode < 0) goto not_found;
}


  } else {
    if (strcmp(contName,"HMdcCellEff")==0) {
      /* EXEC SQL EXECUTE
        BEGIN
          SELECT mdc_ana.mdc_par_query.next_version INTO :vers FROM DUAL;
          INSERT INTO mdc_ana.celleff_vers
                     (vers_id, orig_context_id, run_id, author, description)
              VALUES (:vers, :context, :run, :creator, :descript);
        END;
      END-EXEC; */ 

{
      struct sqlexd sqlstm;
      sqlorat((void **)0, &sqlctx, &oraca);
      sqlstm.sqlvsn = 12;
      sqlstm.arrsiz = 10;
      sqlstm.sqladtp = &sqladt;
      sqlstm.sqltdsp = &sqltds;
      sqlstm.stmt = "begin SELECT mdc_ana . mdc_par_query . next_version INT\
O :vers FROM DUAL ; INSERT INTO mdc_ana . celleff_vers ( vers_id , orig_contex\
t_id , run_id , author , description ) VALUES ( :vers , :context , :run , :cre\
ator , :descript ) ; END ;";
      sqlstm.iters = (unsigned int  )1;
      sqlstm.offset = (unsigned int  )1074;
      sqlstm.cud = sqlcud0;
      sqlstm.sqlest = (unsigned char  *)&sqlca;
      sqlstm.sqlety = (unsigned short)256;
      sqlstm.occurs = (unsigned int  )0;
      sqlstm.sqhstv[0] = (         void  *)&vers;
      sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
      sqlstm.sqhsts[0] = (         int  )0;
      sqlstm.sqindv[0] = (         void  *)0;
      sqlstm.sqinds[0] = (         int  )0;
      sqlstm.sqharm[0] = (unsigned int  )0;
      sqlstm.sqadto[0] = (unsigned short )0;
      sqlstm.sqtdso[0] = (unsigned short )0;
      sqlstm.sqhstv[1] = (         void  *)&context;
      sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
      sqlstm.sqhsts[1] = (         int  )0;
      sqlstm.sqindv[1] = (         void  *)0;
      sqlstm.sqinds[1] = (         int  )0;
      sqlstm.sqharm[1] = (unsigned int  )0;
      sqlstm.sqadto[1] = (unsigned short )0;
      sqlstm.sqtdso[1] = (unsigned short )0;
      sqlstm.sqhstv[2] = (         void  *)&run;
      sqlstm.sqhstl[2] = (unsigned int  )sizeof(int);
      sqlstm.sqhsts[2] = (         int  )0;
      sqlstm.sqindv[2] = (         void  *)0;
      sqlstm.sqinds[2] = (         int  )0;
      sqlstm.sqharm[2] = (unsigned int  )0;
      sqlstm.sqadto[2] = (unsigned short )0;
      sqlstm.sqtdso[2] = (unsigned short )0;
      sqlstm.sqhstv[3] = (         void  *)creator;
      sqlstm.sqhstl[3] = (unsigned int  )0;
      sqlstm.sqhsts[3] = (         int  )0;
      sqlstm.sqindv[3] = (         void  *)0;
      sqlstm.sqinds[3] = (         int  )0;
      sqlstm.sqharm[3] = (unsigned int  )0;
      sqlstm.sqadto[3] = (unsigned short )0;
      sqlstm.sqtdso[3] = (unsigned short )0;
      sqlstm.sqhstv[4] = (         void  *)descript;
      sqlstm.sqhstl[4] = (unsigned int  )0;
      sqlstm.sqhsts[4] = (         int  )0;
      sqlstm.sqindv[4] = (         void  *)0;
      sqlstm.sqinds[4] = (         int  )0;
      sqlstm.sqharm[4] = (unsigned int  )0;
      sqlstm.sqadto[4] = (unsigned short )0;
      sqlstm.sqtdso[4] = (unsigned short )0;
      sqlstm.sqphsv = sqlstm.sqhstv;
      sqlstm.sqphsl = sqlstm.sqhstl;
      sqlstm.sqphss = sqlstm.sqhsts;
      sqlstm.sqpind = sqlstm.sqindv;
      sqlstm.sqpins = sqlstm.sqinds;
      sqlstm.sqparm = sqlstm.sqharm;
      sqlstm.sqparc = sqlstm.sqharc;
      sqlstm.sqpadto = sqlstm.sqadto;
      sqlstm.sqptdso = sqlstm.sqtdso;
      sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
      if (sqlca.sqlcode == 1403) goto not_found;
      if (sqlca.sqlcode < 0) goto not_found;
}


    } else {
      if (strcmp(contName,"HMdcTimeCut")==0) {
        /* EXEC SQL EXECUTE
          BEGIN
            SELECT mdc_ana.mdc_par_query.next_version INTO :vers FROM DUAL;
            INSERT INTO mdc_ana.timecut_vers
                       (vers_id, orig_context_id, run_id, author, description)
                VALUES (:vers, :context, :run, :creator, :descript);
          END;
        END-EXEC; */ 

{
        struct sqlexd sqlstm;
        sqlorat((void **)0, &sqlctx, &oraca);
        sqlstm.sqlvsn = 12;
        sqlstm.arrsiz = 10;
        sqlstm.sqladtp = &sqladt;
        sqlstm.sqltdsp = &sqltds;
        sqlstm.stmt = "begin SELECT mdc_ana . mdc_par_query . next_version I\
NTO :vers FROM DUAL ; INSERT INTO mdc_ana . timecut_vers ( vers_id , orig_cont\
ext_id , run_id , author , description ) VALUES ( :vers , :context , :run , :c\
reator , :descript ) ; END ;";
        sqlstm.iters = (unsigned int  )1;
        sqlstm.offset = (unsigned int  )1109;
        sqlstm.cud = sqlcud0;
        sqlstm.sqlest = (unsigned char  *)&sqlca;
        sqlstm.sqlety = (unsigned short)256;
        sqlstm.occurs = (unsigned int  )0;
        sqlstm.sqhstv[0] = (         void  *)&vers;
        sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[0] = (         int  )0;
        sqlstm.sqindv[0] = (         void  *)0;
        sqlstm.sqinds[0] = (         int  )0;
        sqlstm.sqharm[0] = (unsigned int  )0;
        sqlstm.sqadto[0] = (unsigned short )0;
        sqlstm.sqtdso[0] = (unsigned short )0;
        sqlstm.sqhstv[1] = (         void  *)&context;
        sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[1] = (         int  )0;
        sqlstm.sqindv[1] = (         void  *)0;
        sqlstm.sqinds[1] = (         int  )0;
        sqlstm.sqharm[1] = (unsigned int  )0;
        sqlstm.sqadto[1] = (unsigned short )0;
        sqlstm.sqtdso[1] = (unsigned short )0;
        sqlstm.sqhstv[2] = (         void  *)&run;
        sqlstm.sqhstl[2] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[2] = (         int  )0;
        sqlstm.sqindv[2] = (         void  *)0;
        sqlstm.sqinds[2] = (         int  )0;
        sqlstm.sqharm[2] = (unsigned int  )0;
        sqlstm.sqadto[2] = (unsigned short )0;
        sqlstm.sqtdso[2] = (unsigned short )0;
        sqlstm.sqhstv[3] = (         void  *)creator;
        sqlstm.sqhstl[3] = (unsigned int  )0;
        sqlstm.sqhsts[3] = (         int  )0;
        sqlstm.sqindv[3] = (         void  *)0;
        sqlstm.sqinds[3] = (         int  )0;
        sqlstm.sqharm[3] = (unsigned int  )0;
        sqlstm.sqadto[3] = (unsigned short )0;
        sqlstm.sqtdso[3] = (unsigned short )0;
        sqlstm.sqhstv[4] = (         void  *)descript;
        sqlstm.sqhstl[4] = (unsigned int  )0;
        sqlstm.sqhsts[4] = (         int  )0;
        sqlstm.sqindv[4] = (         void  *)0;
        sqlstm.sqinds[4] = (         int  )0;
        sqlstm.sqharm[4] = (unsigned int  )0;
        sqlstm.sqadto[4] = (unsigned short )0;
        sqlstm.sqtdso[4] = (unsigned short )0;
        sqlstm.sqphsv = sqlstm.sqhstv;
        sqlstm.sqphsl = sqlstm.sqhstl;
        sqlstm.sqphss = sqlstm.sqhsts;
        sqlstm.sqpind = sqlstm.sqindv;
        sqlstm.sqpins = sqlstm.sqinds;
        sqlstm.sqparm = sqlstm.sqharm;
        sqlstm.sqparc = sqlstm.sqharc;
        sqlstm.sqpadto = sqlstm.sqadto;
        sqlstm.sqptdso = sqlstm.sqtdso;
        sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
        if (sqlca.sqlcode == 1403) goto not_found;
        if (sqlca.sqlcode < 0) goto not_found;
}


      } else {
        if (strcmp(contName,"HMdcCal2ParSim")==0) {
          /* EXEC SQL EXECUTE
            BEGIN
              SELECT mdc_ana.mdc_par_query.next_version INTO :vers FROM DUAL;
              INSERT INTO mdc_ana.cal2parsim_vers
                         (vers_id, orig_context_id, run_id, author, description)
                  VALUES (:vers, :context, :run, :creator, :descript);
            END;
          END-EXEC; */ 

{
          struct sqlexd sqlstm;
          sqlorat((void **)0, &sqlctx, &oraca);
          sqlstm.sqlvsn = 12;
          sqlstm.arrsiz = 10;
          sqlstm.sqladtp = &sqladt;
          sqlstm.sqltdsp = &sqltds;
          sqlstm.stmt = "begin SELECT mdc_ana . mdc_par_query . next_version\
 INTO :vers FROM DUAL ; INSERT INTO mdc_ana . cal2parsim_vers ( vers_id , orig\
_context_id , run_id , author , description ) VALUES ( :vers , :context , :run\
 , :creator , :descript ) ; END ;";
          sqlstm.iters = (unsigned int  )1;
          sqlstm.offset = (unsigned int  )1144;
          sqlstm.cud = sqlcud0;
          sqlstm.sqlest = (unsigned char  *)&sqlca;
          sqlstm.sqlety = (unsigned short)256;
          sqlstm.occurs = (unsigned int  )0;
          sqlstm.sqhstv[0] = (         void  *)&vers;
          sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[0] = (         int  )0;
          sqlstm.sqindv[0] = (         void  *)0;
          sqlstm.sqinds[0] = (         int  )0;
          sqlstm.sqharm[0] = (unsigned int  )0;
          sqlstm.sqadto[0] = (unsigned short )0;
          sqlstm.sqtdso[0] = (unsigned short )0;
          sqlstm.sqhstv[1] = (         void  *)&context;
          sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[1] = (         int  )0;
          sqlstm.sqindv[1] = (         void  *)0;
          sqlstm.sqinds[1] = (         int  )0;
          sqlstm.sqharm[1] = (unsigned int  )0;
          sqlstm.sqadto[1] = (unsigned short )0;
          sqlstm.sqtdso[1] = (unsigned short )0;
          sqlstm.sqhstv[2] = (         void  *)&run;
          sqlstm.sqhstl[2] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[2] = (         int  )0;
          sqlstm.sqindv[2] = (         void  *)0;
          sqlstm.sqinds[2] = (         int  )0;
          sqlstm.sqharm[2] = (unsigned int  )0;
          sqlstm.sqadto[2] = (unsigned short )0;
          sqlstm.sqtdso[2] = (unsigned short )0;
          sqlstm.sqhstv[3] = (         void  *)creator;
          sqlstm.sqhstl[3] = (unsigned int  )0;
          sqlstm.sqhsts[3] = (         int  )0;
          sqlstm.sqindv[3] = (         void  *)0;
          sqlstm.sqinds[3] = (         int  )0;
          sqlstm.sqharm[3] = (unsigned int  )0;
          sqlstm.sqadto[3] = (unsigned short )0;
          sqlstm.sqtdso[3] = (unsigned short )0;
          sqlstm.sqhstv[4] = (         void  *)descript;
          sqlstm.sqhstl[4] = (unsigned int  )0;
          sqlstm.sqhsts[4] = (         int  )0;
          sqlstm.sqindv[4] = (         void  *)0;
          sqlstm.sqinds[4] = (         int  )0;
          sqlstm.sqharm[4] = (unsigned int  )0;
          sqlstm.sqadto[4] = (unsigned short )0;
          sqlstm.sqtdso[4] = (unsigned short )0;
          sqlstm.sqphsv = sqlstm.sqhstv;
          sqlstm.sqphsl = sqlstm.sqhstl;
          sqlstm.sqphss = sqlstm.sqhsts;
          sqlstm.sqpind = sqlstm.sqindv;
          sqlstm.sqpins = sqlstm.sqinds;
          sqlstm.sqparm = sqlstm.sqharm;
          sqlstm.sqparc = sqlstm.sqharc;
          sqlstm.sqpadto = sqlstm.sqadto;
          sqlstm.sqptdso = sqlstm.sqtdso;
          sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
          if (sqlca.sqlcode == 1403) goto not_found;
          if (sqlca.sqlcode < 0) goto not_found;
}


        } else {
          if (strcmp(contName,"HMdcClosePairCutsPar")==0) {
            /* EXEC SQL EXECUTE
              BEGIN
                SELECT mdc_ana.mdc_par_query.next_version INTO :vers FROM DUAL;
                INSERT INTO mdc_ana.closepaircut_vers
                           (vers_id, orig_context_id, run_id, author, description)
                    VALUES (:vers, :context, :run, :creator, :descript);
             END;
            END-EXEC; */ 

{
            struct sqlexd sqlstm;
            sqlorat((void **)0, &sqlctx, &oraca);
            sqlstm.sqlvsn = 12;
            sqlstm.arrsiz = 10;
            sqlstm.sqladtp = &sqladt;
            sqlstm.sqltdsp = &sqltds;
            sqlstm.stmt = "begin SELECT mdc_ana . mdc_par_query . next_versi\
on INTO :vers FROM DUAL ; INSERT INTO mdc_ana . closepaircut_vers ( vers_id , \
orig_context_id , run_id , author , description ) VALUES ( :vers , :context , \
:run , :creator , :descript ) ; END ;";
            sqlstm.iters = (unsigned int  )1;
            sqlstm.offset = (unsigned int  )1179;
            sqlstm.cud = sqlcud0;
            sqlstm.sqlest = (unsigned char  *)&sqlca;
            sqlstm.sqlety = (unsigned short)256;
            sqlstm.occurs = (unsigned int  )0;
            sqlstm.sqhstv[0] = (         void  *)&vers;
            sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
            sqlstm.sqhsts[0] = (         int  )0;
            sqlstm.sqindv[0] = (         void  *)0;
            sqlstm.sqinds[0] = (         int  )0;
            sqlstm.sqharm[0] = (unsigned int  )0;
            sqlstm.sqadto[0] = (unsigned short )0;
            sqlstm.sqtdso[0] = (unsigned short )0;
            sqlstm.sqhstv[1] = (         void  *)&context;
            sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
            sqlstm.sqhsts[1] = (         int  )0;
            sqlstm.sqindv[1] = (         void  *)0;
            sqlstm.sqinds[1] = (         int  )0;
            sqlstm.sqharm[1] = (unsigned int  )0;
            sqlstm.sqadto[1] = (unsigned short )0;
            sqlstm.sqtdso[1] = (unsigned short )0;
            sqlstm.sqhstv[2] = (         void  *)&run;
            sqlstm.sqhstl[2] = (unsigned int  )sizeof(int);
            sqlstm.sqhsts[2] = (         int  )0;
            sqlstm.sqindv[2] = (         void  *)0;
            sqlstm.sqinds[2] = (         int  )0;
            sqlstm.sqharm[2] = (unsigned int  )0;
            sqlstm.sqadto[2] = (unsigned short )0;
            sqlstm.sqtdso[2] = (unsigned short )0;
            sqlstm.sqhstv[3] = (         void  *)creator;
            sqlstm.sqhstl[3] = (unsigned int  )0;
            sqlstm.sqhsts[3] = (         int  )0;
            sqlstm.sqindv[3] = (         void  *)0;
            sqlstm.sqinds[3] = (         int  )0;
            sqlstm.sqharm[3] = (unsigned int  )0;
            sqlstm.sqadto[3] = (unsigned short )0;
            sqlstm.sqtdso[3] = (unsigned short )0;
            sqlstm.sqhstv[4] = (         void  *)descript;
            sqlstm.sqhstl[4] = (unsigned int  )0;
            sqlstm.sqhsts[4] = (         int  )0;
            sqlstm.sqindv[4] = (         void  *)0;
            sqlstm.sqinds[4] = (         int  )0;
            sqlstm.sqharm[4] = (unsigned int  )0;
            sqlstm.sqadto[4] = (unsigned short )0;
            sqlstm.sqtdso[4] = (unsigned short )0;
            sqlstm.sqphsv = sqlstm.sqhstv;
            sqlstm.sqphsl = sqlstm.sqhstl;
            sqlstm.sqphss = sqlstm.sqhsts;
            sqlstm.sqpind = sqlstm.sqindv;
            sqlstm.sqpins = sqlstm.sqinds;
            sqlstm.sqparm = sqlstm.sqharm;
            sqlstm.sqparc = sqlstm.sqharc;
            sqlstm.sqpadto = sqlstm.sqadto;
            sqlstm.sqptdso = sqlstm.sqtdso;
            sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
            if (sqlca.sqlcode == 1403) goto not_found;
            if (sqlca.sqlcode < 0) goto not_found;
}


          } else {
            if (strcmp(contName,"HMdcLayerGeomPar")==0) {
              /* EXEC SQL EXECUTE
                BEGIN
                  SELECT mdc_ana.mdc_par_query.next_version INTO :vers FROM DUAL;
                  INSERT INTO mdc_ana.layergeompar_vers
                             (vers_id, orig_context_id, run_id, author, description)
                      VALUES (:vers, :context, :run, :creator, :descript);
               END;
              END-EXEC; */ 

{
              struct sqlexd sqlstm;
              sqlorat((void **)0, &sqlctx, &oraca);
              sqlstm.sqlvsn = 12;
              sqlstm.arrsiz = 10;
              sqlstm.sqladtp = &sqladt;
              sqlstm.sqltdsp = &sqltds;
              sqlstm.stmt = "begin SELECT mdc_ana . mdc_par_query . next_ver\
sion INTO :vers FROM DUAL ; INSERT INTO mdc_ana . layergeompar_vers ( vers_id \
, orig_context_id , run_id , author , description ) VALUES ( :vers , :context \
, :run , :creator , :descript ) ; END ;";
              sqlstm.iters = (unsigned int  )1;
              sqlstm.offset = (unsigned int  )1214;
              sqlstm.cud = sqlcud0;
              sqlstm.sqlest = (unsigned char  *)&sqlca;
              sqlstm.sqlety = (unsigned short)256;
              sqlstm.occurs = (unsigned int  )0;
              sqlstm.sqhstv[0] = (         void  *)&vers;
              sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
              sqlstm.sqhsts[0] = (         int  )0;
              sqlstm.sqindv[0] = (         void  *)0;
              sqlstm.sqinds[0] = (         int  )0;
              sqlstm.sqharm[0] = (unsigned int  )0;
              sqlstm.sqadto[0] = (unsigned short )0;
              sqlstm.sqtdso[0] = (unsigned short )0;
              sqlstm.sqhstv[1] = (         void  *)&context;
              sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
              sqlstm.sqhsts[1] = (         int  )0;
              sqlstm.sqindv[1] = (         void  *)0;
              sqlstm.sqinds[1] = (         int  )0;
              sqlstm.sqharm[1] = (unsigned int  )0;
              sqlstm.sqadto[1] = (unsigned short )0;
              sqlstm.sqtdso[1] = (unsigned short )0;
              sqlstm.sqhstv[2] = (         void  *)&run;
              sqlstm.sqhstl[2] = (unsigned int  )sizeof(int);
              sqlstm.sqhsts[2] = (         int  )0;
              sqlstm.sqindv[2] = (         void  *)0;
              sqlstm.sqinds[2] = (         int  )0;
              sqlstm.sqharm[2] = (unsigned int  )0;
              sqlstm.sqadto[2] = (unsigned short )0;
              sqlstm.sqtdso[2] = (unsigned short )0;
              sqlstm.sqhstv[3] = (         void  *)creator;
              sqlstm.sqhstl[3] = (unsigned int  )0;
              sqlstm.sqhsts[3] = (         int  )0;
              sqlstm.sqindv[3] = (         void  *)0;
              sqlstm.sqinds[3] = (         int  )0;
              sqlstm.sqharm[3] = (unsigned int  )0;
              sqlstm.sqadto[3] = (unsigned short )0;
              sqlstm.sqtdso[3] = (unsigned short )0;
              sqlstm.sqhstv[4] = (         void  *)descript;
              sqlstm.sqhstl[4] = (unsigned int  )0;
              sqlstm.sqhsts[4] = (         int  )0;
              sqlstm.sqindv[4] = (         void  *)0;
              sqlstm.sqinds[4] = (         int  )0;
              sqlstm.sqharm[4] = (unsigned int  )0;
              sqlstm.sqadto[4] = (unsigned short )0;
              sqlstm.sqtdso[4] = (unsigned short )0;
              sqlstm.sqphsv = sqlstm.sqhstv;
              sqlstm.sqphsl = sqlstm.sqhstl;
              sqlstm.sqphss = sqlstm.sqhsts;
              sqlstm.sqpind = sqlstm.sqindv;
              sqlstm.sqpins = sqlstm.sqinds;
              sqlstm.sqparm = sqlstm.sqharm;
              sqlstm.sqparc = sqlstm.sqharc;
              sqlstm.sqpadto = sqlstm.sqadto;
              sqlstm.sqptdso = sqlstm.sqtdso;
              sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
              if (sqlca.sqlcode == 1403) goto not_found;
              if (sqlca.sqlcode < 0) goto not_found;
}


            } else {
              if (strcmp(contName,"HMdcTdcThreshold") == 0) {
                /* EXEC SQL EXECUTE
                  BEGIN
                    SELECT mdc_ana.mdc_par_query.next_version INTO :vers FROM DUAL;
                    INSERT INTO mdc_ana.thr_vers
                             (vers_id, author, description)
                      VALUES (:vers, :creator, :descript);
                  END;
                END-EXEC; */ 

{
                struct sqlexd sqlstm;
                sqlorat((void **)0, &sqlctx, &oraca);
                sqlstm.sqlvsn = 12;
                sqlstm.arrsiz = 10;
                sqlstm.sqladtp = &sqladt;
                sqlstm.sqltdsp = &sqltds;
                sqlstm.stmt = "begin SELECT mdc_ana . mdc_par_query . next_v\
ersion INTO :vers FROM DUAL ; INSERT INTO mdc_ana . thr_vers ( vers_id , autho\
r , description ) VALUES ( :vers , :creator , :descript ) ; END ;";
                sqlstm.iters = (unsigned int  )1;
                sqlstm.offset = (unsigned int  )1249;
                sqlstm.cud = sqlcud0;
                sqlstm.sqlest = (unsigned char  *)&sqlca;
                sqlstm.sqlety = (unsigned short)256;
                sqlstm.occurs = (unsigned int  )0;
                sqlstm.sqhstv[0] = (         void  *)&vers;
                sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
                sqlstm.sqhsts[0] = (         int  )0;
                sqlstm.sqindv[0] = (         void  *)0;
                sqlstm.sqinds[0] = (         int  )0;
                sqlstm.sqharm[0] = (unsigned int  )0;
                sqlstm.sqadto[0] = (unsigned short )0;
                sqlstm.sqtdso[0] = (unsigned short )0;
                sqlstm.sqhstv[1] = (         void  *)creator;
                sqlstm.sqhstl[1] = (unsigned int  )0;
                sqlstm.sqhsts[1] = (         int  )0;
                sqlstm.sqindv[1] = (         void  *)0;
                sqlstm.sqinds[1] = (         int  )0;
                sqlstm.sqharm[1] = (unsigned int  )0;
                sqlstm.sqadto[1] = (unsigned short )0;
                sqlstm.sqtdso[1] = (unsigned short )0;
                sqlstm.sqhstv[2] = (         void  *)descript;
                sqlstm.sqhstl[2] = (unsigned int  )0;
                sqlstm.sqhsts[2] = (         int  )0;
                sqlstm.sqindv[2] = (         void  *)0;
                sqlstm.sqinds[2] = (         int  )0;
                sqlstm.sqharm[2] = (unsigned int  )0;
                sqlstm.sqadto[2] = (unsigned short )0;
                sqlstm.sqtdso[2] = (unsigned short )0;
                sqlstm.sqphsv = sqlstm.sqhstv;
                sqlstm.sqphsl = sqlstm.sqhstl;
                sqlstm.sqphss = sqlstm.sqhsts;
                sqlstm.sqpind = sqlstm.sqindv;
                sqlstm.sqpins = sqlstm.sqinds;
                sqlstm.sqparm = sqlstm.sqharm;
                sqlstm.sqparc = sqlstm.sqharc;
                sqlstm.sqpadto = sqlstm.sqadto;
                sqlstm.sqptdso = sqlstm.sqtdso;
                sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
                if (sqlca.sqlcode == 1403) goto not_found;
                if (sqlca.sqlcode < 0) goto not_found;
}


              } else {
                if (strcmp(contName,"HMdcTdcChannel") == 0) {
                  /* EXEC SQL EXECUTE
                    BEGIN
                      SELECT mdc_ana.mdc_par_query.next_version INTO :vers FROM DUAL;
                      INSERT INTO mdc_ana.mask_vers
                               (vers_id, author, description)
                        VALUES (:vers, :creator, :descript);
                    END;
                  END-EXEC; */ 

{
                  struct sqlexd sqlstm;
                  sqlorat((void **)0, &sqlctx, &oraca);
                  sqlstm.sqlvsn = 12;
                  sqlstm.arrsiz = 10;
                  sqlstm.sqladtp = &sqladt;
                  sqlstm.sqltdsp = &sqltds;
                  sqlstm.stmt = "begin SELECT mdc_ana . mdc_par_query . next\
_version INTO :vers FROM DUAL ; INSERT INTO mdc_ana . mask_vers ( vers_id , au\
thor , description ) VALUES ( :vers , :creator , :descript ) ; END ;";
                  sqlstm.iters = (unsigned int  )1;
                  sqlstm.offset = (unsigned int  )1276;
                  sqlstm.cud = sqlcud0;
                  sqlstm.sqlest = (unsigned char  *)&sqlca;
                  sqlstm.sqlety = (unsigned short)256;
                  sqlstm.occurs = (unsigned int  )0;
                  sqlstm.sqhstv[0] = (         void  *)&vers;
                  sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
                  sqlstm.sqhsts[0] = (         int  )0;
                  sqlstm.sqindv[0] = (         void  *)0;
                  sqlstm.sqinds[0] = (         int  )0;
                  sqlstm.sqharm[0] = (unsigned int  )0;
                  sqlstm.sqadto[0] = (unsigned short )0;
                  sqlstm.sqtdso[0] = (unsigned short )0;
                  sqlstm.sqhstv[1] = (         void  *)creator;
                  sqlstm.sqhstl[1] = (unsigned int  )0;
                  sqlstm.sqhsts[1] = (         int  )0;
                  sqlstm.sqindv[1] = (         void  *)0;
                  sqlstm.sqinds[1] = (         int  )0;
                  sqlstm.sqharm[1] = (unsigned int  )0;
                  sqlstm.sqadto[1] = (unsigned short )0;
                  sqlstm.sqtdso[1] = (unsigned short )0;
                  sqlstm.sqhstv[2] = (         void  *)descript;
                  sqlstm.sqhstl[2] = (unsigned int  )0;
                  sqlstm.sqhsts[2] = (         int  )0;
                  sqlstm.sqindv[2] = (         void  *)0;
                  sqlstm.sqinds[2] = (         int  )0;
                  sqlstm.sqharm[2] = (unsigned int  )0;
                  sqlstm.sqadto[2] = (unsigned short )0;
                  sqlstm.sqtdso[2] = (unsigned short )0;
                  sqlstm.sqphsv = sqlstm.sqhstv;
                  sqlstm.sqphsl = sqlstm.sqhstl;
                  sqlstm.sqphss = sqlstm.sqhsts;
                  sqlstm.sqpind = sqlstm.sqindv;
                  sqlstm.sqpins = sqlstm.sqinds;
                  sqlstm.sqparm = sqlstm.sqharm;
                  sqlstm.sqparc = sqlstm.sqharc;
                  sqlstm.sqpadto = sqlstm.sqadto;
                  sqlstm.sqptdso = sqlstm.sqtdso;
                  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
                  if (sqlca.sqlcode == 1403) goto not_found;
                  if (sqlca.sqlcode < 0) goto not_found;
}


                } else {
                  if (strcmp(contName,"HMdcLookupGeom") == 0) {
                    /* EXEC SQL EXECUTE
                      BEGIN
                        SELECT mdc_ana.mdc_par_query.next_version INTO :vers FROM DUAL;
                        INSERT INTO mdc_ana.load_mdclookupgeom_vers
                                 (vers_id, author, description)
                          VALUES (:vers, :creator, :descript);
                      END;
                    END-EXEC; */ 

{
                    struct sqlexd sqlstm;
                    sqlorat((void **)0, &sqlctx, &oraca);
                    sqlstm.sqlvsn = 12;
                    sqlstm.arrsiz = 10;
                    sqlstm.sqladtp = &sqladt;
                    sqlstm.sqltdsp = &sqltds;
                    sqlstm.stmt = "begin SELECT mdc_ana . mdc_par_query . ne\
xt_version INTO :vers FROM DUAL ; INSERT INTO mdc_ana . load_mdclookupgeom_ver\
s ( vers_id , author , description ) VALUES ( :vers , :creator , :descript ) ;\
 END ;";
                    sqlstm.iters = (unsigned int  )1;
                    sqlstm.offset = (unsigned int  )1303;
                    sqlstm.cud = sqlcud0;
                    sqlstm.sqlest = (unsigned char  *)&sqlca;
                    sqlstm.sqlety = (unsigned short)256;
                    sqlstm.occurs = (unsigned int  )0;
                    sqlstm.sqhstv[0] = (         void  *)&vers;
                    sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
                    sqlstm.sqhsts[0] = (         int  )0;
                    sqlstm.sqindv[0] = (         void  *)0;
                    sqlstm.sqinds[0] = (         int  )0;
                    sqlstm.sqharm[0] = (unsigned int  )0;
                    sqlstm.sqadto[0] = (unsigned short )0;
                    sqlstm.sqtdso[0] = (unsigned short )0;
                    sqlstm.sqhstv[1] = (         void  *)creator;
                    sqlstm.sqhstl[1] = (unsigned int  )0;
                    sqlstm.sqhsts[1] = (         int  )0;
                    sqlstm.sqindv[1] = (         void  *)0;
                    sqlstm.sqinds[1] = (         int  )0;
                    sqlstm.sqharm[1] = (unsigned int  )0;
                    sqlstm.sqadto[1] = (unsigned short )0;
                    sqlstm.sqtdso[1] = (unsigned short )0;
                    sqlstm.sqhstv[2] = (         void  *)descript;
                    sqlstm.sqhstl[2] = (unsigned int  )0;
                    sqlstm.sqhsts[2] = (         int  )0;
                    sqlstm.sqindv[2] = (         void  *)0;
                    sqlstm.sqinds[2] = (         int  )0;
                    sqlstm.sqharm[2] = (unsigned int  )0;
                    sqlstm.sqadto[2] = (unsigned short )0;
                    sqlstm.sqtdso[2] = (unsigned short )0;
                    sqlstm.sqphsv = sqlstm.sqhstv;
                    sqlstm.sqphsl = sqlstm.sqhstl;
                    sqlstm.sqphss = sqlstm.sqhsts;
                    sqlstm.sqpind = sqlstm.sqindv;
                    sqlstm.sqpins = sqlstm.sqinds;
                    sqlstm.sqparm = sqlstm.sqharm;
                    sqlstm.sqparc = sqlstm.sqharc;
                    sqlstm.sqpadto = sqlstm.sqadto;
                    sqlstm.sqptdso = sqlstm.sqtdso;
                    sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
                    if (sqlca.sqlcode == 1403) goto not_found;
                    if (sqlca.sqlcode < 0) goto not_found;
}


                  }
                }
              }
            }
          }
        }
      }
    }
  }
  cout<<"Oracle version for "<<pPar->GetName()<<" created:  "<<vers<<endl;
  return vers;
not_found:
  showSqlError("createVersion(HParSet*)");
  return vers;
} 


Int_t HMdcParOraIo::writePar(HMdcCalParRaw* pPar) {
  // creates a new version and writes the calibration parameters to Oracle
  Int_t version=createVersion(pPar);
  if (version==-1) return -1;
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int mdc[MDC_MAXCHAN];
    int mbo[MDC_MAXCHAN];
    int tdc[MDC_MAXCHAN];
    int chan[MDC_MAXCHAN];
    int vers[MDC_MAXCHAN];
    float sl[MDC_MAXCHAN];
    float sE[MDC_MAXCHAN];
    float sM[MDC_MAXCHAN];
    float o[MDC_MAXCHAN];
    float oE[MDC_MAXCHAN];
    float oM[MDC_MAXCHAN];
    int rows_to_insert;
  /* EXEC SQL END DECLARE SECTION; */ 

  Int_t id, pos, mboInd;
  for(Int_t s=0; s<pPar->getSize(); s++) {
    HMdcCalParRawSec& rSec= (*pPar)[s];
    for(Int_t m=0; m<rSec.getSize(); m++) {
      HMdcCalParRawMod& rMod= rSec[m];
      pos=s*4+m;
      id=mdcIds->At(pos);
      if (id>0) {
        Int_t nChan=0;
        for(Int_t l=0; l<rMod.getSize(); l++) {
          HMdcCalParMbo& rMbo= rMod[l];
          const Char_t* mboName=rMbo.GetName();
          sscanf(mboName,"%i",&mboInd);
          for(Int_t c=0; c<rMbo.getSize(); c++) {
            HMdcCalParTdc& ch= rMbo[c];
            Int_t tN=(Int_t)(c/8);
            Int_t cN=c-tN*8;
            mdc[nChan]=id;
            mbo[nChan]=mboInd;
            tdc[nChan]=tN+1;
            chan[nChan]=cN+1;
            sl[nChan]=ch.getSlope();
            sE[nChan]=ch.getSlopeErr();
            sM[nChan]=ch.getSlopeMethod();
            o[nChan]=ch.getOffset();
            oE[nChan]=ch.getOffsetErr();
            oM[nChan]=ch.getOffsetMethod();
            vers[nChan]=version;
            nChan++;
          }
        }
        if (nChan==0) continue;
        rows_to_insert=nChan;
        Int_t nChanO=countTdcChannels(id);
        if (nChan!=nChanO) {
          Error("writePar(HMdcCalParRaw*)",
                "\n Number of Tdc channels in Oracle:        %i\n Number of Tdc channels in MdcCalParRaw:  %i\n",
                nChanO,nChan);
          rollback();
          return -1;
        }
        /* EXEC SQL WHENEVER SQLERROR GOTO not_found; */ 

        /* EXEC SQL WHENEVER NOT FOUND GOTO not_found; */ 

        /* EXEC SQL FOR :rows_to_insert
          INSERT INTO mdc_ana.cal1par_data (tdc_channel_id, vers_id,
                                slope, slope_err, slope_method,
                                offset, offset_err, offset_method)
            VALUES (mdc_ana.mdc_par_query.get_tdc_chan_id(:mdc,:mbo,:tdc,:chan),
                    :vers, :sl, :sE, :sM, :o, :oE, :oM); */ 

{
        struct sqlexd sqlstm;
        sqlorat((void **)0, &sqlctx, &oraca);
        sqlstm.sqlvsn = 12;
        sqlstm.arrsiz = 11;
        sqlstm.sqladtp = &sqladt;
        sqlstm.sqltdsp = &sqltds;
        sqlstm.stmt = "insert into mdc_ana.cal1par_data (tdc_channel_id,vers\
_id,slope,slope_err,slope_method,offset,offset_err,offset_method) values (mdc_\
ana.mdc_par_query.get_tdc_chan_id(:b1,:b2,:b3,:b4),:b5,:b6,:b7,:b8,:b9,:b10,:b\
11)";
        sqlstm.iters = (unsigned int  )rows_to_insert;
        sqlstm.offset = (unsigned int  )1330;
        sqlstm.cud = sqlcud0;
        sqlstm.sqlest = (unsigned char  *)&sqlca;
        sqlstm.sqlety = (unsigned short)256;
        sqlstm.occurs = (unsigned int  )0;
        sqlstm.sqhstv[0] = (         void  *)mdc;
        sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[0] = (         int  )sizeof(int);
        sqlstm.sqindv[0] = (         void  *)0;
        sqlstm.sqinds[0] = (         int  )0;
        sqlstm.sqharm[0] = (unsigned int  )0;
        sqlstm.sqharc[0] = (unsigned int   *)0;
        sqlstm.sqadto[0] = (unsigned short )0;
        sqlstm.sqtdso[0] = (unsigned short )0;
        sqlstm.sqhstv[1] = (         void  *)mbo;
        sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[1] = (         int  )sizeof(int);
        sqlstm.sqindv[1] = (         void  *)0;
        sqlstm.sqinds[1] = (         int  )0;
        sqlstm.sqharm[1] = (unsigned int  )0;
        sqlstm.sqharc[1] = (unsigned int   *)0;
        sqlstm.sqadto[1] = (unsigned short )0;
        sqlstm.sqtdso[1] = (unsigned short )0;
        sqlstm.sqhstv[2] = (         void  *)tdc;
        sqlstm.sqhstl[2] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[2] = (         int  )sizeof(int);
        sqlstm.sqindv[2] = (         void  *)0;
        sqlstm.sqinds[2] = (         int  )0;
        sqlstm.sqharm[2] = (unsigned int  )0;
        sqlstm.sqharc[2] = (unsigned int   *)0;
        sqlstm.sqadto[2] = (unsigned short )0;
        sqlstm.sqtdso[2] = (unsigned short )0;
        sqlstm.sqhstv[3] = (         void  *)chan;
        sqlstm.sqhstl[3] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[3] = (         int  )sizeof(int);
        sqlstm.sqindv[3] = (         void  *)0;
        sqlstm.sqinds[3] = (         int  )0;
        sqlstm.sqharm[3] = (unsigned int  )0;
        sqlstm.sqharc[3] = (unsigned int   *)0;
        sqlstm.sqadto[3] = (unsigned short )0;
        sqlstm.sqtdso[3] = (unsigned short )0;
        sqlstm.sqhstv[4] = (         void  *)vers;
        sqlstm.sqhstl[4] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[4] = (         int  )sizeof(int);
        sqlstm.sqindv[4] = (         void  *)0;
        sqlstm.sqinds[4] = (         int  )0;
        sqlstm.sqharm[4] = (unsigned int  )0;
        sqlstm.sqharc[4] = (unsigned int   *)0;
        sqlstm.sqadto[4] = (unsigned short )0;
        sqlstm.sqtdso[4] = (unsigned short )0;
        sqlstm.sqhstv[5] = (         void  *)sl;
        sqlstm.sqhstl[5] = (unsigned int  )sizeof(float);
        sqlstm.sqhsts[5] = (         int  )sizeof(float);
        sqlstm.sqindv[5] = (         void  *)0;
        sqlstm.sqinds[5] = (         int  )0;
        sqlstm.sqharm[5] = (unsigned int  )0;
        sqlstm.sqharc[5] = (unsigned int   *)0;
        sqlstm.sqadto[5] = (unsigned short )0;
        sqlstm.sqtdso[5] = (unsigned short )0;
        sqlstm.sqhstv[6] = (         void  *)sE;
        sqlstm.sqhstl[6] = (unsigned int  )sizeof(float);
        sqlstm.sqhsts[6] = (         int  )sizeof(float);
        sqlstm.sqindv[6] = (         void  *)0;
        sqlstm.sqinds[6] = (         int  )0;
        sqlstm.sqharm[6] = (unsigned int  )0;
        sqlstm.sqharc[6] = (unsigned int   *)0;
        sqlstm.sqadto[6] = (unsigned short )0;
        sqlstm.sqtdso[6] = (unsigned short )0;
        sqlstm.sqhstv[7] = (         void  *)sM;
        sqlstm.sqhstl[7] = (unsigned int  )sizeof(float);
        sqlstm.sqhsts[7] = (         int  )sizeof(float);
        sqlstm.sqindv[7] = (         void  *)0;
        sqlstm.sqinds[7] = (         int  )0;
        sqlstm.sqharm[7] = (unsigned int  )0;
        sqlstm.sqharc[7] = (unsigned int   *)0;
        sqlstm.sqadto[7] = (unsigned short )0;
        sqlstm.sqtdso[7] = (unsigned short )0;
        sqlstm.sqhstv[8] = (         void  *)o;
        sqlstm.sqhstl[8] = (unsigned int  )sizeof(float);
        sqlstm.sqhsts[8] = (         int  )sizeof(float);
        sqlstm.sqindv[8] = (         void  *)0;
        sqlstm.sqinds[8] = (         int  )0;
        sqlstm.sqharm[8] = (unsigned int  )0;
        sqlstm.sqharc[8] = (unsigned int   *)0;
        sqlstm.sqadto[8] = (unsigned short )0;
        sqlstm.sqtdso[8] = (unsigned short )0;
        sqlstm.sqhstv[9] = (         void  *)oE;
        sqlstm.sqhstl[9] = (unsigned int  )sizeof(float);
        sqlstm.sqhsts[9] = (         int  )sizeof(float);
        sqlstm.sqindv[9] = (         void  *)0;
        sqlstm.sqinds[9] = (         int  )0;
        sqlstm.sqharm[9] = (unsigned int  )0;
        sqlstm.sqharc[9] = (unsigned int   *)0;
        sqlstm.sqadto[9] = (unsigned short )0;
        sqlstm.sqtdso[9] = (unsigned short )0;
        sqlstm.sqhstv[10] = (         void  *)oM;
        sqlstm.sqhstl[10] = (unsigned int  )sizeof(float);
        sqlstm.sqhsts[10] = (         int  )sizeof(float);
        sqlstm.sqindv[10] = (         void  *)0;
        sqlstm.sqinds[10] = (         int  )0;
        sqlstm.sqharm[10] = (unsigned int  )0;
        sqlstm.sqharc[10] = (unsigned int   *)0;
        sqlstm.sqadto[10] = (unsigned short )0;
        sqlstm.sqtdso[10] = (unsigned short )0;
        sqlstm.sqphsv = sqlstm.sqhstv;
        sqlstm.sqphsl = sqlstm.sqhstl;
        sqlstm.sqphss = sqlstm.sqhsts;
        sqlstm.sqpind = sqlstm.sqindv;
        sqlstm.sqpins = sqlstm.sqinds;
        sqlstm.sqparm = sqlstm.sqharm;
        sqlstm.sqparc = sqlstm.sqharc;
        sqlstm.sqpadto = sqlstm.sqadto;
        sqlstm.sqptdso = sqlstm.sqtdso;
        sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
        if (sqlca.sqlcode == 1403) goto not_found;
        if (sqlca.sqlcode < 0) goto not_found;
}


        cout<<"mdc_hwobj_id: "<<id<<"    "<<rows_to_insert<<" rows inserted\n";
      }
    }
  }
  commit();
  pPar->setChanged(kFALSE);
  return version;
not_found:
  showSqlError("writePar(HMdcCalParRaw*)");
  rollback();
  return -1;
}
 

Int_t HMdcParOraIo::writePar(HMdcCellEff* pPar) {
  // creates a new version and writes the cell effficiency parameters to Oracle
  Int_t version=createVersion(pPar);
  if (version==-1) return -1;
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int vers[MDC_MAXARR];
    int plane[MDC_MAXARR];
    int an[MDC_MAXARR];
    float mr[MDC_MAXARR];
    float sl[MDC_MAXARR];
    int rows_to_insert;
  /* EXEC SQL END DECLARE SECTION; */ 

  Int_t i=0;
  for(Int_t m=0; m<pPar->getSize(); m++) {
    HMdcCellEffMod& rMod=(*pPar)[m];
    for(Int_t l=0; l<rMod.getSize(); l++) {
      HMdcCellEffAngle& rAngle=rMod[l];      
      vers[i]=version;
      plane[i]=m+1;
      an[i]=l;
      mr[i]=rAngle.getMaxR();
      sl[i]=rAngle.getSlope();
      i++;
    }
  }
  if (i==0) {
    Error("writePar(HMdcCellEff*)",
          "\n Parameter container is empty!\n");
    rollback();
    return -1;
  }
  rows_to_insert=i;
  /* EXEC SQL WHENEVER SQLERROR GOTO not_found; */ 

  /* EXEC SQL WHENEVER NOT FOUND GOTO not_found; */ 

  /* EXEC SQL FOR :rows_to_insert
    INSERT INTO mdc_ana.celleff_data (vers_id, plane, angle, max_r, slope)
            VALUES (:vers, :plane, :an, :mr, :sl); */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 11;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "insert into mdc_ana.celleff_data (vers_id,plane,angle,max_r\
,slope) values (:b1,:b2,:b3,:b4,:b5)";
  sqlstm.iters = (unsigned int  )rows_to_insert;
  sqlstm.offset = (unsigned int  )1389;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)vers;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )sizeof(int);
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqharc[0] = (unsigned int   *)0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqhstv[1] = (         void  *)plane;
  sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[1] = (         int  )sizeof(int);
  sqlstm.sqindv[1] = (         void  *)0;
  sqlstm.sqinds[1] = (         int  )0;
  sqlstm.sqharm[1] = (unsigned int  )0;
  sqlstm.sqharc[1] = (unsigned int   *)0;
  sqlstm.sqadto[1] = (unsigned short )0;
  sqlstm.sqtdso[1] = (unsigned short )0;
  sqlstm.sqhstv[2] = (         void  *)an;
  sqlstm.sqhstl[2] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[2] = (         int  )sizeof(int);
  sqlstm.sqindv[2] = (         void  *)0;
  sqlstm.sqinds[2] = (         int  )0;
  sqlstm.sqharm[2] = (unsigned int  )0;
  sqlstm.sqharc[2] = (unsigned int   *)0;
  sqlstm.sqadto[2] = (unsigned short )0;
  sqlstm.sqtdso[2] = (unsigned short )0;
  sqlstm.sqhstv[3] = (         void  *)mr;
  sqlstm.sqhstl[3] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[3] = (         int  )sizeof(float);
  sqlstm.sqindv[3] = (         void  *)0;
  sqlstm.sqinds[3] = (         int  )0;
  sqlstm.sqharm[3] = (unsigned int  )0;
  sqlstm.sqharc[3] = (unsigned int   *)0;
  sqlstm.sqadto[3] = (unsigned short )0;
  sqlstm.sqtdso[3] = (unsigned short )0;
  sqlstm.sqhstv[4] = (         void  *)sl;
  sqlstm.sqhstl[4] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[4] = (         int  )sizeof(float);
  sqlstm.sqindv[4] = (         void  *)0;
  sqlstm.sqinds[4] = (         int  )0;
  sqlstm.sqharm[4] = (unsigned int  )0;
  sqlstm.sqharc[4] = (unsigned int   *)0;
  sqlstm.sqadto[4] = (unsigned short )0;
  sqlstm.sqtdso[4] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode == 1403) goto not_found;
  if (sqlca.sqlcode < 0) goto not_found;
}


  cout<<rows_to_insert<<" rows inserted\n";
  commit();
  pPar->setChanged(kFALSE);
  return version;
not_found:
  showSqlError("writePar(HMdcCellEff*)");
  rollback();
  return -1;
}
 

Int_t HMdcParOraIo::writePar(HMdcTimeCut* pPar) {
  // creates a new version and writes the TimeCut parameters to Oracle
  Int_t version=createVersion(pPar);
  if (version==-1) return -1;
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int mdc[MDC_MAXMODS];
    int vers[MDC_MAXMODS];
    float ct1l[MDC_MAXMODS];
    float ct1r[MDC_MAXMODS];
    float ct2l[MDC_MAXMODS];
    float ct2r[MDC_MAXMODS];
    float cl[MDC_MAXMODS];
    float cr[MDC_MAXMODS];
    int rows_to_insert;
  /* EXEC SQL END DECLARE SECTION; */ 

  Int_t id, pos, i=0;
  for(Int_t s=0; s<pPar->getSize(); s++) {
    HMdcTimeCutSec& rSec= (*pPar)[s];
    for(Int_t m=0; m<rSec.getSize(); m++) {
      HMdcTimeCutMod& rMod= rSec[m];
      pos=s*4+m;
      id=mdcIds->At(pos);
      if (id>0) {
        mdc[i]=id;
        vers[i]=version;
        ct1l[i]=rMod.getCutTime1Left();
        ct1r[i]=rMod.getCutTime1Right();
        ct2l[i]=rMod.getCutTime2Left();
        ct2r[i]=rMod.getCutTime2Right();
        cl[i]=rMod.getCutTimeLeft();
        cr[i]=rMod.getCutTimeRight();
        i++;
      }
    }
  }
  if (i==0) {
    Error("writePar(HMdcTimeCut*)",
          "\n Parameter container is empty!\n");
    rollback();
    return -1;
  }
  rows_to_insert=i;
  /* EXEC SQL WHENEVER SQLERROR GOTO not_found; */ 

  /* EXEC SQL WHENEVER NOT FOUND GOTO not_found; */ 

  /* EXEC SQL FOR :rows_to_insert
    INSERT INTO mdc_ana.timecut_data (mdc_hwobj_id, vers_id,
           cut_t1_l, cut_t1_r, cut_t2_l, cut_t2_r, cut_left, cut_right)
        VALUES (:mdc, :vers, :ct1l, :ct1r, :ct2l, :ct2r, :cl, :cr); */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 11;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "insert into mdc_ana.timecut_data (mdc_hwobj_id,vers_id,cut_\
t1_l,cut_t1_r,cut_t2_l,cut_t2_r,cut_left,cut_right) values (:b1,:b2,:b3,:b4,:b\
5,:b6,:b7,:b8)";
  sqlstm.iters = (unsigned int  )rows_to_insert;
  sqlstm.offset = (unsigned int  )1424;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)mdc;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )sizeof(int);
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqharc[0] = (unsigned int   *)0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqhstv[1] = (         void  *)vers;
  sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[1] = (         int  )sizeof(int);
  sqlstm.sqindv[1] = (         void  *)0;
  sqlstm.sqinds[1] = (         int  )0;
  sqlstm.sqharm[1] = (unsigned int  )0;
  sqlstm.sqharc[1] = (unsigned int   *)0;
  sqlstm.sqadto[1] = (unsigned short )0;
  sqlstm.sqtdso[1] = (unsigned short )0;
  sqlstm.sqhstv[2] = (         void  *)ct1l;
  sqlstm.sqhstl[2] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[2] = (         int  )sizeof(float);
  sqlstm.sqindv[2] = (         void  *)0;
  sqlstm.sqinds[2] = (         int  )0;
  sqlstm.sqharm[2] = (unsigned int  )0;
  sqlstm.sqharc[2] = (unsigned int   *)0;
  sqlstm.sqadto[2] = (unsigned short )0;
  sqlstm.sqtdso[2] = (unsigned short )0;
  sqlstm.sqhstv[3] = (         void  *)ct1r;
  sqlstm.sqhstl[3] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[3] = (         int  )sizeof(float);
  sqlstm.sqindv[3] = (         void  *)0;
  sqlstm.sqinds[3] = (         int  )0;
  sqlstm.sqharm[3] = (unsigned int  )0;
  sqlstm.sqharc[3] = (unsigned int   *)0;
  sqlstm.sqadto[3] = (unsigned short )0;
  sqlstm.sqtdso[3] = (unsigned short )0;
  sqlstm.sqhstv[4] = (         void  *)ct2l;
  sqlstm.sqhstl[4] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[4] = (         int  )sizeof(float);
  sqlstm.sqindv[4] = (         void  *)0;
  sqlstm.sqinds[4] = (         int  )0;
  sqlstm.sqharm[4] = (unsigned int  )0;
  sqlstm.sqharc[4] = (unsigned int   *)0;
  sqlstm.sqadto[4] = (unsigned short )0;
  sqlstm.sqtdso[4] = (unsigned short )0;
  sqlstm.sqhstv[5] = (         void  *)ct2r;
  sqlstm.sqhstl[5] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[5] = (         int  )sizeof(float);
  sqlstm.sqindv[5] = (         void  *)0;
  sqlstm.sqinds[5] = (         int  )0;
  sqlstm.sqharm[5] = (unsigned int  )0;
  sqlstm.sqharc[5] = (unsigned int   *)0;
  sqlstm.sqadto[5] = (unsigned short )0;
  sqlstm.sqtdso[5] = (unsigned short )0;
  sqlstm.sqhstv[6] = (         void  *)cl;
  sqlstm.sqhstl[6] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[6] = (         int  )sizeof(float);
  sqlstm.sqindv[6] = (         void  *)0;
  sqlstm.sqinds[6] = (         int  )0;
  sqlstm.sqharm[6] = (unsigned int  )0;
  sqlstm.sqharc[6] = (unsigned int   *)0;
  sqlstm.sqadto[6] = (unsigned short )0;
  sqlstm.sqtdso[6] = (unsigned short )0;
  sqlstm.sqhstv[7] = (         void  *)cr;
  sqlstm.sqhstl[7] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[7] = (         int  )sizeof(float);
  sqlstm.sqindv[7] = (         void  *)0;
  sqlstm.sqinds[7] = (         int  )0;
  sqlstm.sqharm[7] = (unsigned int  )0;
  sqlstm.sqharc[7] = (unsigned int   *)0;
  sqlstm.sqadto[7] = (unsigned short )0;
  sqlstm.sqtdso[7] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode == 1403) goto not_found;
  if (sqlca.sqlcode < 0) goto not_found;
}


  cout<<rows_to_insert<<" rows inserted\n";
  commit();
  pPar->setChanged(kFALSE);
  return version;
not_found:
  showSqlError("writePar(HMdcTimeCut*)");
  rollback();
  return -1;
}


Int_t HMdcParOraIo::writePar(HMdcCal2ParSim* pPar) {
  // creates a new version and writes the calibration parameters to Oracle
  Int_t version=createVersion(pPar);
  if (version==-1) return -1;
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int vers[MDC_MAXARR];
    int mdc[MDC_MAXARR];
    int angle[MDC_MAXARR];
    int dbin[MDC_MAXARR];
    float d1[MDC_MAXARR];
    float d2[MDC_MAXARR];
    float d1e[MDC_MAXARR];
    float d2e[MDC_MAXARR];
    int rows_to_insert;
  /* EXEC SQL END DECLARE SECTION; */ 

  Int_t id, pos;
  for(Int_t s=0; s<pPar->getSize(); s++) {
    HMdcCal2ParSecSim& rSec= (*pPar)[s];
    for(Int_t m=0; m<rSec.getSize(); m++) {
      HMdcCal2ParModSim& rMod= rSec[m];
      pos=s*4+m;
      id=mdcIds->At(pos);
      if (id>0) {
        Int_t nVal=0;
        for(Int_t l=0; l<rMod.getSize(); l++) {
          HMdcCal2ParAngleSim& rAngle= rMod[l];
          for(Int_t c=0; c<pPar->getNumberOfBins(); c++) {
            if (nVal>MDC_MAXARR) {
              Error("writePar(HMdcCal2ParSim",
                    "Buffer size exceeded!");
              rollback();
              return -1;
            }
            vers[nVal]=version;
            mdc[nVal]=id;
            angle[nVal]=l;
            dbin[nVal]=c;
            d1[nVal]=rAngle.getDriftTime1(c);            
            d2[nVal]=rAngle.getDriftTime2(c);            
            d1e[nVal]=rAngle.getDriftTime1Error(c);            
            d2e[nVal]=rAngle.getDriftTime2Error(c);            
            nVal++;
          }
        }
        rows_to_insert=nVal;
        /* EXEC SQL WHENEVER SQLERROR GOTO not_found; */ 

        /* EXEC SQL WHENEVER NOT FOUND GOTO not_found; */ 

        /* EXEC SQL FOR :rows_to_insert
          INSERT INTO mdc_ana.cal2parsim_data (
            vers_id, det_part_id, angle_step, distance_bin,
            drifttime1, drifttime2, drifttime1_err, drifttime2_err )
            VALUES (:vers, :mdc, :angle, :dbin, :d1, :d2, :d1e, :d2e); */ 

{
        struct sqlexd sqlstm;
        sqlorat((void **)0, &sqlctx, &oraca);
        sqlstm.sqlvsn = 12;
        sqlstm.arrsiz = 11;
        sqlstm.sqladtp = &sqladt;
        sqlstm.sqltdsp = &sqltds;
        sqlstm.stmt = "insert into mdc_ana.cal2parsim_data (vers_id,det_part\
_id,angle_step,distance_bin,drifttime1,drifttime2,drifttime1_err,drifttime2_er\
r) values (:b1,:b2,:b3,:b4,:b5,:b6,:b7,:b8)";
        sqlstm.iters = (unsigned int  )rows_to_insert;
        sqlstm.offset = (unsigned int  )1471;
        sqlstm.cud = sqlcud0;
        sqlstm.sqlest = (unsigned char  *)&sqlca;
        sqlstm.sqlety = (unsigned short)256;
        sqlstm.occurs = (unsigned int  )0;
        sqlstm.sqhstv[0] = (         void  *)vers;
        sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[0] = (         int  )sizeof(int);
        sqlstm.sqindv[0] = (         void  *)0;
        sqlstm.sqinds[0] = (         int  )0;
        sqlstm.sqharm[0] = (unsigned int  )0;
        sqlstm.sqharc[0] = (unsigned int   *)0;
        sqlstm.sqadto[0] = (unsigned short )0;
        sqlstm.sqtdso[0] = (unsigned short )0;
        sqlstm.sqhstv[1] = (         void  *)mdc;
        sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[1] = (         int  )sizeof(int);
        sqlstm.sqindv[1] = (         void  *)0;
        sqlstm.sqinds[1] = (         int  )0;
        sqlstm.sqharm[1] = (unsigned int  )0;
        sqlstm.sqharc[1] = (unsigned int   *)0;
        sqlstm.sqadto[1] = (unsigned short )0;
        sqlstm.sqtdso[1] = (unsigned short )0;
        sqlstm.sqhstv[2] = (         void  *)angle;
        sqlstm.sqhstl[2] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[2] = (         int  )sizeof(int);
        sqlstm.sqindv[2] = (         void  *)0;
        sqlstm.sqinds[2] = (         int  )0;
        sqlstm.sqharm[2] = (unsigned int  )0;
        sqlstm.sqharc[2] = (unsigned int   *)0;
        sqlstm.sqadto[2] = (unsigned short )0;
        sqlstm.sqtdso[2] = (unsigned short )0;
        sqlstm.sqhstv[3] = (         void  *)dbin;
        sqlstm.sqhstl[3] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[3] = (         int  )sizeof(int);
        sqlstm.sqindv[3] = (         void  *)0;
        sqlstm.sqinds[3] = (         int  )0;
        sqlstm.sqharm[3] = (unsigned int  )0;
        sqlstm.sqharc[3] = (unsigned int   *)0;
        sqlstm.sqadto[3] = (unsigned short )0;
        sqlstm.sqtdso[3] = (unsigned short )0;
        sqlstm.sqhstv[4] = (         void  *)d1;
        sqlstm.sqhstl[4] = (unsigned int  )sizeof(float);
        sqlstm.sqhsts[4] = (         int  )sizeof(float);
        sqlstm.sqindv[4] = (         void  *)0;
        sqlstm.sqinds[4] = (         int  )0;
        sqlstm.sqharm[4] = (unsigned int  )0;
        sqlstm.sqharc[4] = (unsigned int   *)0;
        sqlstm.sqadto[4] = (unsigned short )0;
        sqlstm.sqtdso[4] = (unsigned short )0;
        sqlstm.sqhstv[5] = (         void  *)d2;
        sqlstm.sqhstl[5] = (unsigned int  )sizeof(float);
        sqlstm.sqhsts[5] = (         int  )sizeof(float);
        sqlstm.sqindv[5] = (         void  *)0;
        sqlstm.sqinds[5] = (         int  )0;
        sqlstm.sqharm[5] = (unsigned int  )0;
        sqlstm.sqharc[5] = (unsigned int   *)0;
        sqlstm.sqadto[5] = (unsigned short )0;
        sqlstm.sqtdso[5] = (unsigned short )0;
        sqlstm.sqhstv[6] = (         void  *)d1e;
        sqlstm.sqhstl[6] = (unsigned int  )sizeof(float);
        sqlstm.sqhsts[6] = (         int  )sizeof(float);
        sqlstm.sqindv[6] = (         void  *)0;
        sqlstm.sqinds[6] = (         int  )0;
        sqlstm.sqharm[6] = (unsigned int  )0;
        sqlstm.sqharc[6] = (unsigned int   *)0;
        sqlstm.sqadto[6] = (unsigned short )0;
        sqlstm.sqtdso[6] = (unsigned short )0;
        sqlstm.sqhstv[7] = (         void  *)d2e;
        sqlstm.sqhstl[7] = (unsigned int  )sizeof(float);
        sqlstm.sqhsts[7] = (         int  )sizeof(float);
        sqlstm.sqindv[7] = (         void  *)0;
        sqlstm.sqinds[7] = (         int  )0;
        sqlstm.sqharm[7] = (unsigned int  )0;
        sqlstm.sqharc[7] = (unsigned int   *)0;
        sqlstm.sqadto[7] = (unsigned short )0;
        sqlstm.sqtdso[7] = (unsigned short )0;
        sqlstm.sqphsv = sqlstm.sqhstv;
        sqlstm.sqphsl = sqlstm.sqhstl;
        sqlstm.sqphss = sqlstm.sqhsts;
        sqlstm.sqpind = sqlstm.sqindv;
        sqlstm.sqpins = sqlstm.sqinds;
        sqlstm.sqparm = sqlstm.sqharm;
        sqlstm.sqparc = sqlstm.sqharc;
        sqlstm.sqpadto = sqlstm.sqadto;
        sqlstm.sqptdso = sqlstm.sqtdso;
        sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
        if (sqlca.sqlcode == 1403) goto not_found;
        if (sqlca.sqlcode < 0) goto not_found;
}


        cout<<"mdc_hwobj_id: "<<id<<"    "<<rows_to_insert<<" rows inserted\n";
      }
    }
  }
  commit();
  pPar->setChanged(kFALSE);
  return version;
not_found:
  showSqlError("writePar(HMdcCal2ParSim*)");
  rollback();
  return -1;
}

Int_t HMdcParOraIo::writePar(HMdcClosePairCutsPar* pPar) {
  // creates a new version and writes the ClosePairCuts parameters to Oracle
  Int_t version=createVersion(pPar);
  if (version==-1) return -1;
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int vers[MDC_MAXARR];
    int lb[MDC_MAXARR];
    int tb[MDC_MAXARR];
    int pb[MDC_MAXARR];
    int eb[MDC_MAXARR];
    float eff[MDC_MAXARR];
    float s2b[MDC_MAXARR];
    float mcs[MDC_MAXARR];
    float mwc[MDC_MAXARR];
    float rcc[MDC_MAXARR];
    int rows_to_insert;
  /* EXEC SQL END DECLARE SECTION; */ 

  Int_t i=0;
  for(Int_t lev=0;lev<pPar->getSize();lev++) {
    HMdcClosePairCutsParTheta& the=(*pPar)[lev];
    for(Int_t th=0;th<the.getSize();th++) {
      HMdcClosePairCutsParPhi& phi=the[th];
      for(Int_t p=0;p<phi.getSize();p++) {
        HMdcClosePairCutsParEf& ef=phi[p];
        for(Int_t e=0;e<ef.getSize();e++) {
          HMdcClosePairCutsParCut& cut=ef[e];
          vers[i]=version;
          lb[i]=lev;
          tb[i]=th;
          pb[i]=p;
          eb[i]=e;
          eff[i]=cut.getEfficiency();
          s2b[i]=cut.getSig2Back();
          mcs[i]=cut.getMdcClsSizeCut();
          mwc[i]=cut.getMdcContWiresCut();
          rcc[i]=cut.getRichIntChargeCut();
          i++;
        }
      }
    }
  }
  if (i==0) {
    Error("writePar(HMdcClosePairCutsPar*)",
          "\n Parameter container is empty!\n");
    rollback();
    return -1;
  }
  rows_to_insert=i;
  /* EXEC SQL WHENEVER SQLERROR GOTO not_found; */ 

  /* EXEC SQL WHENEVER NOT FOUND GOTO not_found; */ 

  /* EXEC SQL FOR :rows_to_insert
    INSERT INTO mdc_ana.closepaircut_data (vers_id, levelbin,
           thetabin, phibin, effbin, efficiency, sig2back,
           mdc_size_cut, mdc_wires_cut, rich_charge_cut)
        VALUES (:vers, :lb, :tb, :pb, :eb, :eff, :s2b, :mcs, :mwc, :rcc); */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 11;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "insert into mdc_ana.closepaircut_data (vers_id,levelbin,the\
tabin,phibin,effbin,efficiency,sig2back,mdc_size_cut,mdc_wires_cut,rich_charge\
_cut) values (:b1,:b2,:b3,:b4,:b5,:b6,:b7,:b8,:b9,:b10)";
  sqlstm.iters = (unsigned int  )rows_to_insert;
  sqlstm.offset = (unsigned int  )1518;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)vers;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )sizeof(int);
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqharc[0] = (unsigned int   *)0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqhstv[1] = (         void  *)lb;
  sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[1] = (         int  )sizeof(int);
  sqlstm.sqindv[1] = (         void  *)0;
  sqlstm.sqinds[1] = (         int  )0;
  sqlstm.sqharm[1] = (unsigned int  )0;
  sqlstm.sqharc[1] = (unsigned int   *)0;
  sqlstm.sqadto[1] = (unsigned short )0;
  sqlstm.sqtdso[1] = (unsigned short )0;
  sqlstm.sqhstv[2] = (         void  *)tb;
  sqlstm.sqhstl[2] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[2] = (         int  )sizeof(int);
  sqlstm.sqindv[2] = (         void  *)0;
  sqlstm.sqinds[2] = (         int  )0;
  sqlstm.sqharm[2] = (unsigned int  )0;
  sqlstm.sqharc[2] = (unsigned int   *)0;
  sqlstm.sqadto[2] = (unsigned short )0;
  sqlstm.sqtdso[2] = (unsigned short )0;
  sqlstm.sqhstv[3] = (         void  *)pb;
  sqlstm.sqhstl[3] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[3] = (         int  )sizeof(int);
  sqlstm.sqindv[3] = (         void  *)0;
  sqlstm.sqinds[3] = (         int  )0;
  sqlstm.sqharm[3] = (unsigned int  )0;
  sqlstm.sqharc[3] = (unsigned int   *)0;
  sqlstm.sqadto[3] = (unsigned short )0;
  sqlstm.sqtdso[3] = (unsigned short )0;
  sqlstm.sqhstv[4] = (         void  *)eb;
  sqlstm.sqhstl[4] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[4] = (         int  )sizeof(int);
  sqlstm.sqindv[4] = (         void  *)0;
  sqlstm.sqinds[4] = (         int  )0;
  sqlstm.sqharm[4] = (unsigned int  )0;
  sqlstm.sqharc[4] = (unsigned int   *)0;
  sqlstm.sqadto[4] = (unsigned short )0;
  sqlstm.sqtdso[4] = (unsigned short )0;
  sqlstm.sqhstv[5] = (         void  *)eff;
  sqlstm.sqhstl[5] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[5] = (         int  )sizeof(float);
  sqlstm.sqindv[5] = (         void  *)0;
  sqlstm.sqinds[5] = (         int  )0;
  sqlstm.sqharm[5] = (unsigned int  )0;
  sqlstm.sqharc[5] = (unsigned int   *)0;
  sqlstm.sqadto[5] = (unsigned short )0;
  sqlstm.sqtdso[5] = (unsigned short )0;
  sqlstm.sqhstv[6] = (         void  *)s2b;
  sqlstm.sqhstl[6] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[6] = (         int  )sizeof(float);
  sqlstm.sqindv[6] = (         void  *)0;
  sqlstm.sqinds[6] = (         int  )0;
  sqlstm.sqharm[6] = (unsigned int  )0;
  sqlstm.sqharc[6] = (unsigned int   *)0;
  sqlstm.sqadto[6] = (unsigned short )0;
  sqlstm.sqtdso[6] = (unsigned short )0;
  sqlstm.sqhstv[7] = (         void  *)mcs;
  sqlstm.sqhstl[7] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[7] = (         int  )sizeof(float);
  sqlstm.sqindv[7] = (         void  *)0;
  sqlstm.sqinds[7] = (         int  )0;
  sqlstm.sqharm[7] = (unsigned int  )0;
  sqlstm.sqharc[7] = (unsigned int   *)0;
  sqlstm.sqadto[7] = (unsigned short )0;
  sqlstm.sqtdso[7] = (unsigned short )0;
  sqlstm.sqhstv[8] = (         void  *)mwc;
  sqlstm.sqhstl[8] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[8] = (         int  )sizeof(float);
  sqlstm.sqindv[8] = (         void  *)0;
  sqlstm.sqinds[8] = (         int  )0;
  sqlstm.sqharm[8] = (unsigned int  )0;
  sqlstm.sqharc[8] = (unsigned int   *)0;
  sqlstm.sqadto[8] = (unsigned short )0;
  sqlstm.sqtdso[8] = (unsigned short )0;
  sqlstm.sqhstv[9] = (         void  *)rcc;
  sqlstm.sqhstl[9] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[9] = (         int  )sizeof(float);
  sqlstm.sqindv[9] = (         void  *)0;
  sqlstm.sqinds[9] = (         int  )0;
  sqlstm.sqharm[9] = (unsigned int  )0;
  sqlstm.sqharc[9] = (unsigned int   *)0;
  sqlstm.sqadto[9] = (unsigned short )0;
  sqlstm.sqtdso[9] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode == 1403) goto not_found;
  if (sqlca.sqlcode < 0) goto not_found;
}


  cout<<rows_to_insert<<" rows inserted\n";
  commit();
  pPar->setChanged(kFALSE);
  return version;
not_found:
  showSqlError("writePar(HMdcClosePairCutsPar*)");
  rollback();
  return -1;
}

Int_t HMdcParOraIo::countTdcChannels(Int_t mdc) {
  // returns the number of TDC channels of a module
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int id;
    int num;
  /* EXEC SQL END DECLARE SECTION; */ 

  id=mdc;
  /* EXEC SQL WHENEVER SQLERROR DO
    showSqlError("countTdcChannels(Int_t)"); */ 

  /* EXEC SQL WHENEVER NOT FOUND GOTO notfound; */ 

  /* EXEC SQL SELECT COUNT(tdc_channel_id) INTO :num
           FROM mdc_ana.tdc_channel WHERE mdc_hwobj_id=:id; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 11;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "select count(tdc_channel_id) into :b0  from mdc_ana.tdc_cha\
nnel where mdc_hwobj_id=:b1";
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )1573;
  sqlstm.selerr = (unsigned short)1;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)&num;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )0;
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqhstv[1] = (         void  *)&id;
  sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[1] = (         int  )0;
  sqlstm.sqindv[1] = (         void  *)0;
  sqlstm.sqinds[1] = (         int  )0;
  sqlstm.sqharm[1] = (unsigned int  )0;
  sqlstm.sqadto[1] = (unsigned short )0;
  sqlstm.sqtdso[1] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode == 1403) goto notfound;
  if (sqlca.sqlcode < 0) showSqlError("countTdcChannels(Int_t)");
}


  return num;
notfound:
  return 0;
}

Bool_t HMdcParOraIo::read(HMdcTdcThreshold* pPar,Int_t* set) {
  // reads the calibration parameters and fill the MdcCalParRaw container
  Int_t contVers=pPar->getOraVersion();
  if (contVers==-1) {
    Error("read(HMdcTdcThreshold*,Int_t*)","Specify Oracle input version!");
    return kFALSE;
  }
  pPar->clear();
  initModules->Reset();
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int vers;
    int status;
    struct {
      int sec[MDC_MAXARR];
      int pla[MDC_MAXARR];
      int mbo[MDC_MAXARR];
      int dbo[MDC_MAXARR];
      /* varchar thr[MDC_MAXARR][3]; */ 
struct { unsigned short len; unsigned char arr[6]; } thr[2000];

    } thrdata;
  /* EXEC SQL END DECLARE SECTION; */ 

  Int_t s, p, pos, lastPos=-1, mo, mm=-1, mi=-1, v=-1;
  /* EXEC SQL WHENEVER SQLERROR GOTO not_found; */ 

  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 

  Bool_t allFound=kTRUE;
  vers=contVers;
  /* EXEC SQL SELECT status
           INTO :status
           FROM mdc_ana.thr_vers
           WHERE vers_id = :vers; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 11;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "select status into :b0  from mdc_ana.thr_vers where vers_id\
=:b1";
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )1596;
  sqlstm.selerr = (unsigned short)1;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)&status;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )0;
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqhstv[1] = (         void  *)&vers;
  sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[1] = (         int  )0;
  sqlstm.sqindv[1] = (         void  *)0;
  sqlstm.sqinds[1] = (         int  )0;
  sqlstm.sqharm[1] = (unsigned int  )0;
  sqlstm.sqadto[1] = (unsigned short )0;
  sqlstm.sqtdso[1] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) goto not_found;
}


  /* EXEC SQL SELECT sector, plane, mbo, dbo, thr
           INTO :thrdata
           FROM mdc_ana.mdc_thr_data
           WHERE version = :vers
           ORDER BY sector, plane, mbo, dbo; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 11;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "select sector ,plane ,mbo ,dbo ,thr into :s1 ,:s2 ,:s3 ,:s4\
 ,:s5   from mdc_ana.mdc_thr_data where version=:b1 order by sector,plane,mbo,\
dbo ";
  sqlstm.iters = (unsigned int  )2000;
  sqlstm.offset = (unsigned int  )1619;
  sqlstm.selerr = (unsigned short)1;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)thrdata.sec;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )sizeof(int);
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqharc[0] = (unsigned int   *)0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqhstv[1] = (         void  *)thrdata.pla;
  sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[1] = (         int  )sizeof(int);
  sqlstm.sqindv[1] = (         void  *)0;
  sqlstm.sqinds[1] = (         int  )0;
  sqlstm.sqharm[1] = (unsigned int  )0;
  sqlstm.sqharc[1] = (unsigned int   *)0;
  sqlstm.sqadto[1] = (unsigned short )0;
  sqlstm.sqtdso[1] = (unsigned short )0;
  sqlstm.sqhstv[2] = (         void  *)thrdata.mbo;
  sqlstm.sqhstl[2] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[2] = (         int  )sizeof(int);
  sqlstm.sqindv[2] = (         void  *)0;
  sqlstm.sqinds[2] = (         int  )0;
  sqlstm.sqharm[2] = (unsigned int  )0;
  sqlstm.sqharc[2] = (unsigned int   *)0;
  sqlstm.sqadto[2] = (unsigned short )0;
  sqlstm.sqtdso[2] = (unsigned short )0;
  sqlstm.sqhstv[3] = (         void  *)thrdata.dbo;
  sqlstm.sqhstl[3] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[3] = (         int  )sizeof(int);
  sqlstm.sqindv[3] = (         void  *)0;
  sqlstm.sqinds[3] = (         int  )0;
  sqlstm.sqharm[3] = (unsigned int  )0;
  sqlstm.sqharc[3] = (unsigned int   *)0;
  sqlstm.sqadto[3] = (unsigned short )0;
  sqlstm.sqtdso[3] = (unsigned short )0;
  sqlstm.sqhstv[4] = (         void  *)thrdata.thr;
  sqlstm.sqhstl[4] = (unsigned int  )5;
  sqlstm.sqhsts[4] = (         int  )8;
  sqlstm.sqindv[4] = (         void  *)0;
  sqlstm.sqinds[4] = (         int  )0;
  sqlstm.sqharm[4] = (unsigned int  )0;
  sqlstm.sqharc[4] = (unsigned int   *)0;
  sqlstm.sqadto[4] = (unsigned short )0;
  sqlstm.sqtdso[4] = (unsigned short )0;
  sqlstm.sqhstv[5] = (         void  *)&vers;
  sqlstm.sqhstl[5] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[5] = (         int  )sizeof(int);
  sqlstm.sqindv[5] = (         void  *)0;
  sqlstm.sqinds[5] = (         int  )0;
  sqlstm.sqharm[5] = (unsigned int  )0;
  sqlstm.sqadto[5] = (unsigned short )0;
  sqlstm.sqtdso[5] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) goto not_found;
}


  pPar->setStatus(status);
  for (Int_t i=0;i<sqlca.sqlerrd[2];i++) {
    s=thrdata.sec[i]-1;
    p=thrdata.pla[i]-1;
    pos=s*4+p;
    if (pos!=lastPos && set[pos]>0) {
      set[pos]=0;
      initModules->AddAt(pos+1,pos);
      mm=-1;
      mi=-1;
      lastPos=pos;
    }
    if (!initModules->At(pos)) continue;  
    HMdcTdcThresholdMod& mod=(*pPar)[s][p];
    mo=thrdata.mbo[i];
    if (mo>mm) {
      mi++;
      const Char_t* mboName=mod[mi].GetName();
      sscanf(mboName,"%i",&mm);
      if (mo!=mm) {
        Error("read(HMdcTdcThreshold*,Int_t*)",
                      "MBO %i is missing in parameter container",mm);
        return kFALSE;
      }
      mm=mo;
    }
    thrdata.thr[i].arr[thrdata.thr[i].len]='\0';
    // cout<<s<<" "<<p<<" "<<mm<<" "<<thrdata.dbo[i]-1<<" "<<thrdata.thr[i].arr<<endl;
    sscanf((Char_t*)thrdata.thr[i].arr,"%x",&v);
    mod[mi][thrdata.dbo[i]-1].setThreshold(v);
  }
  pPar->setChanged();
  pPar->setOraVersion(vers);
  pPar->setInputVersion(vers,inputNumber);
  for(Int_t i=0;i<MDC_MAXMODS;i++) {
    if (set[i]==1 && initModules->At(i)==0) allFound=kFALSE;
  }
  printInfo(pPar->GetName());
  return allFound;
not_found:
  showSqlError("read(HMdcTdcThreshold*,Int_t*)");
  return -1;
}

Int_t HMdcParOraIo::writePar(HMdcTdcThreshold* pPar) {
  // creates a new version and writes the threshold parameters to Oracle
  Int_t version=createVersion(pPar);
  if (version==-1) return -1;
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int sec[MDC_MAXARR];
    int pla[MDC_MAXARR];
    int mbo[MDC_MAXARR];
    int dbo[MDC_MAXARR];
    int vers[MDC_MAXARR];
    char thr [MDC_MAXARR][3];
    int rows_to_insert;
  /* EXEC SQL END DECLARE SECTION; */ 

  Int_t mboInd, nDbo=0;
  for(Int_t s=0; s<pPar->getSize(); s++) {
    HMdcTdcThresholdSec& rSec= (*pPar)[s];
    for(Int_t m=0; m<rSec.getSize(); m++) {
      HMdcTdcThresholdMod& rMod= rSec[m];
      for(Int_t l=0; l<rMod.getSize(); l++) {
        HMdcTdcThresholdMbo& rMbo= rMod[l];
        const Char_t* mboName=rMbo.GetName();
        sscanf(mboName,"%i",&mboInd);
        for(Int_t c=0; c<rMbo.getSize(); c++) {
          sec[nDbo]=s+1;
          pla[nDbo]=m+1;
          mbo[nDbo]=mboInd;
          dbo[nDbo]=c+1;
          sprintf(thr[nDbo],"%x",rMbo[c].getThreshold());
          // cout<<sec[nDbo]<<" "<<pla[nDbo]<<" "<<mbo[nDbo]<<" "<<dbo[nDbo]<<" "<<thr[nDbo]<<endl;
          vers[nDbo]=version;
          nDbo++;
        }
      }
    }
  }
  rows_to_insert=nDbo;
  /* EXEC SQL WHENEVER SQLERROR GOTO not_found; */ 

  /* EXEC SQL WHENEVER NOT FOUND GOTO not_found; */ 

  /* EXEC SQL FOR :rows_to_insert
    INSERT INTO mdc_ana.thr_data (thr_address_id, vers_id, threshold)
        VALUES (mdc_ana.mdc_par_query.get_thr_address_id(:sec,:pla,:mbo,:dbo),
                    :vers, :thr); */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 11;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "insert into mdc_ana.thr_data (thr_address_id,vers_id,thresh\
old) values (mdc_ana.mdc_par_query.get_thr_address_id(:b1,:b2,:b3,:b4),:b5,:b6\
)";
  sqlstm.iters = (unsigned int  )rows_to_insert;
  sqlstm.offset = (unsigned int  )1658;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)sec;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )sizeof(int);
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqharc[0] = (unsigned int   *)0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqhstv[1] = (         void  *)pla;
  sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[1] = (         int  )sizeof(int);
  sqlstm.sqindv[1] = (         void  *)0;
  sqlstm.sqinds[1] = (         int  )0;
  sqlstm.sqharm[1] = (unsigned int  )0;
  sqlstm.sqharc[1] = (unsigned int   *)0;
  sqlstm.sqadto[1] = (unsigned short )0;
  sqlstm.sqtdso[1] = (unsigned short )0;
  sqlstm.sqhstv[2] = (         void  *)mbo;
  sqlstm.sqhstl[2] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[2] = (         int  )sizeof(int);
  sqlstm.sqindv[2] = (         void  *)0;
  sqlstm.sqinds[2] = (         int  )0;
  sqlstm.sqharm[2] = (unsigned int  )0;
  sqlstm.sqharc[2] = (unsigned int   *)0;
  sqlstm.sqadto[2] = (unsigned short )0;
  sqlstm.sqtdso[2] = (unsigned short )0;
  sqlstm.sqhstv[3] = (         void  *)dbo;
  sqlstm.sqhstl[3] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[3] = (         int  )sizeof(int);
  sqlstm.sqindv[3] = (         void  *)0;
  sqlstm.sqinds[3] = (         int  )0;
  sqlstm.sqharm[3] = (unsigned int  )0;
  sqlstm.sqharc[3] = (unsigned int   *)0;
  sqlstm.sqadto[3] = (unsigned short )0;
  sqlstm.sqtdso[3] = (unsigned short )0;
  sqlstm.sqhstv[4] = (         void  *)vers;
  sqlstm.sqhstl[4] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[4] = (         int  )sizeof(int);
  sqlstm.sqindv[4] = (         void  *)0;
  sqlstm.sqinds[4] = (         int  )0;
  sqlstm.sqharm[4] = (unsigned int  )0;
  sqlstm.sqharc[4] = (unsigned int   *)0;
  sqlstm.sqadto[4] = (unsigned short )0;
  sqlstm.sqtdso[4] = (unsigned short )0;
  sqlstm.sqhstv[5] = (         void  *)thr;
  sqlstm.sqhstl[5] = (unsigned int  )3;
  sqlstm.sqhsts[5] = (         int  )3;
  sqlstm.sqindv[5] = (         void  *)0;
  sqlstm.sqinds[5] = (         int  )0;
  sqlstm.sqharm[5] = (unsigned int  )0;
  sqlstm.sqharc[5] = (unsigned int   *)0;
  sqlstm.sqadto[5] = (unsigned short )0;
  sqlstm.sqtdso[5] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode == 1403) goto not_found;
  if (sqlca.sqlcode < 0) goto not_found;
}


  cout<<"Thresholds: "<<rows_to_insert<<" rows inserted\n";
  commit();
  pPar->setChanged(kFALSE);
  return version;
not_found:
  showSqlError("writePar(HMdcTdcThreshold*)");
  rollback();
  return -1;
}

Int_t HMdcParOraIo::writePar(HMdcLayerGeomPar* pPar) {
  // creates a new version and writes the layer parameters to Oracle
  Int_t version=createVersion(pPar);
  if (version==-1) return -1;
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int mdc[MDC_MAXTOTLAYS];
    int vers[MDC_MAXTOTLAYS];
    int lay[MDC_MAXTOTLAYS];
    float dist[MDC_MAXTOTLAYS];
    float pitch[MDC_MAXTOTLAYS];
    float angle[MDC_MAXTOTLAYS];
    float cwire[MDC_MAXTOTLAYS];
    float cathth[MDC_MAXTOTLAYS];
    int rows_to_insert;
  /* EXEC SQL END DECLARE SECTION; */ 

  Int_t id, pos, i=0;
  for(Int_t s=0; s<pPar->getSize(); s++) {
    HMdcLayerGeomParSec& rSec= (*pPar)[s];
    for(Int_t m=0; m<rSec.getSize(); m++) {
      HMdcLayerGeomParMod& rMod= rSec[m];
      pos=s*4+m;
      id=mdcIds->At(pos);
      if (id>0) {
        for(Int_t l=0; l<rMod.getSize(); l++) {
          mdc[i]=id;
          vers[i]=version;
          lay[i]=l+1;
          HMdcLayerGeomParLay& rLay= rMod[l];
          dist[i]=rLay.getCatDist();
          pitch[i]=rLay.getPitch();
          angle[i]=rLay.getWireOrient();
          cwire[i]=rLay.getCentralWireNr();
          cathth[i]=rLay.getCathodeWireThickness();
          i++;
        }
      }
    }
  }
  if (i==0) {
    Error("writePar(HMdcLayerGeomPar*)",
          "\n Parameter container is empty!\n");
    rollback();
    return -1;
  }
  rows_to_insert=i;
  /* EXEC SQL WHENEVER SQLERROR GOTO not_found; */ 

  /* EXEC SQL WHENEVER NOT FOUND GOTO not_found; */ 

  /* EXEC SQL FOR :rows_to_insert
    INSERT INTO mdc_ana.layergeompar_data
        ( det_part_id, vers_id, layer_nr, cell_thickness,
          cell_pitch, inclination_angle, central_wire_nr, cathode_wire_thickness )
        VALUES (:mdc, :vers, :lay, :dist, :pitch, :angle, :cwire, :cathth); */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 11;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "insert into mdc_ana.layergeompar_data (det_part_id,vers_id,\
layer_nr,cell_thickness,cell_pitch,inclination_angle,central_wire_nr,cathode_w\
ire_thickness) values (:b1,:b2,:b3,:b4,:b5,:b6,:b7,:b8)";
  sqlstm.iters = (unsigned int  )rows_to_insert;
  sqlstm.offset = (unsigned int  )1697;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)mdc;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )sizeof(int);
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqharc[0] = (unsigned int   *)0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqhstv[1] = (         void  *)vers;
  sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[1] = (         int  )sizeof(int);
  sqlstm.sqindv[1] = (         void  *)0;
  sqlstm.sqinds[1] = (         int  )0;
  sqlstm.sqharm[1] = (unsigned int  )0;
  sqlstm.sqharc[1] = (unsigned int   *)0;
  sqlstm.sqadto[1] = (unsigned short )0;
  sqlstm.sqtdso[1] = (unsigned short )0;
  sqlstm.sqhstv[2] = (         void  *)lay;
  sqlstm.sqhstl[2] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[2] = (         int  )sizeof(int);
  sqlstm.sqindv[2] = (         void  *)0;
  sqlstm.sqinds[2] = (         int  )0;
  sqlstm.sqharm[2] = (unsigned int  )0;
  sqlstm.sqharc[2] = (unsigned int   *)0;
  sqlstm.sqadto[2] = (unsigned short )0;
  sqlstm.sqtdso[2] = (unsigned short )0;
  sqlstm.sqhstv[3] = (         void  *)dist;
  sqlstm.sqhstl[3] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[3] = (         int  )sizeof(float);
  sqlstm.sqindv[3] = (         void  *)0;
  sqlstm.sqinds[3] = (         int  )0;
  sqlstm.sqharm[3] = (unsigned int  )0;
  sqlstm.sqharc[3] = (unsigned int   *)0;
  sqlstm.sqadto[3] = (unsigned short )0;
  sqlstm.sqtdso[3] = (unsigned short )0;
  sqlstm.sqhstv[4] = (         void  *)pitch;
  sqlstm.sqhstl[4] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[4] = (         int  )sizeof(float);
  sqlstm.sqindv[4] = (         void  *)0;
  sqlstm.sqinds[4] = (         int  )0;
  sqlstm.sqharm[4] = (unsigned int  )0;
  sqlstm.sqharc[4] = (unsigned int   *)0;
  sqlstm.sqadto[4] = (unsigned short )0;
  sqlstm.sqtdso[4] = (unsigned short )0;
  sqlstm.sqhstv[5] = (         void  *)angle;
  sqlstm.sqhstl[5] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[5] = (         int  )sizeof(float);
  sqlstm.sqindv[5] = (         void  *)0;
  sqlstm.sqinds[5] = (         int  )0;
  sqlstm.sqharm[5] = (unsigned int  )0;
  sqlstm.sqharc[5] = (unsigned int   *)0;
  sqlstm.sqadto[5] = (unsigned short )0;
  sqlstm.sqtdso[5] = (unsigned short )0;
  sqlstm.sqhstv[6] = (         void  *)cwire;
  sqlstm.sqhstl[6] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[6] = (         int  )sizeof(float);
  sqlstm.sqindv[6] = (         void  *)0;
  sqlstm.sqinds[6] = (         int  )0;
  sqlstm.sqharm[6] = (unsigned int  )0;
  sqlstm.sqharc[6] = (unsigned int   *)0;
  sqlstm.sqadto[6] = (unsigned short )0;
  sqlstm.sqtdso[6] = (unsigned short )0;
  sqlstm.sqhstv[7] = (         void  *)cathth;
  sqlstm.sqhstl[7] = (unsigned int  )sizeof(float);
  sqlstm.sqhsts[7] = (         int  )sizeof(float);
  sqlstm.sqindv[7] = (         void  *)0;
  sqlstm.sqinds[7] = (         int  )0;
  sqlstm.sqharm[7] = (unsigned int  )0;
  sqlstm.sqharc[7] = (unsigned int   *)0;
  sqlstm.sqadto[7] = (unsigned short )0;
  sqlstm.sqtdso[7] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode == 1403) goto not_found;
  if (sqlca.sqlcode < 0) goto not_found;
}


  cout<<rows_to_insert<<" rows inserted\n";
  commit();
  pPar->setChanged(kFALSE);
  return version;
not_found:
  showSqlError("writePar(HMdcLayerGeom*)");
  rollback();
  return -1;
}

Bool_t HMdcParOraIo::read(HMdcTdcChannel* pPar, Int_t* set) {
  // reads the tdc channel masks and fill the container
  Int_t contVers=pPar->getOraVersion();
  if (contVers==-1) {
    Error("read(HMdcTdcChannels*,Int_t*)","Specify Oracle input version!");
    return kFALSE;
  }
  initModules->Reset();
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int id;
    int vers;
    int status;
    struct {
      int mbo[MDC_MAXARR];
      int tdc[MDC_MAXARR];
      char mask[MDC_MAXARR][3];
      char cal[MDC_MAXARR][3];
    } cal;
  /* EXEC SQL END DECLARE SECTION; */ 

  /* EXEC SQL WHENEVER SQLERROR DO showSqlError("read(HMdcTdcChannel*,Int_t*)"); */ 

  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 

  /* EXEC SQL DECLARE c6 CURSOR FOR
    SELECT mbo_local_pos_id,tdc_number, channel_mask, calibration_mask 
      FROM mdc_ana.mask_data, mdc_ana.mask_address
      WHERE mdc_hwobj_id = :id
        AND vers_id = :vers
        AND mask_data.mask_address_id = mask_address.mask_address_id
      ORDER BY mbo_local_pos_id,tdc_number; */ 

  Bool_t allFound=kTRUE;
  HMdcTdcChannel& mdc=*pPar;
  Int_t pos;
  vers=contVers;
  /* EXEC SQL SELECT status
    INTO :status
    FROM mdc_ana.mask_vers
    WHERE vers_id = :vers; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 11;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "select status into :b0  from mdc_ana.mask_vers where vers_i\
d=:b1";
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )1744;
  sqlstm.selerr = (unsigned short)1;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)&status;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )0;
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqhstv[1] = (         void  *)&vers;
  sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[1] = (         int  )0;
  sqlstm.sqindv[1] = (         void  *)0;
  sqlstm.sqinds[1] = (         int  )0;
  sqlstm.sqharm[1] = (unsigned int  )0;
  sqlstm.sqadto[1] = (unsigned short )0;
  sqlstm.sqtdso[1] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) showSqlError("read(HMdcTdcChannel*,Int_t*)");
}


  pPar->setStatus(status);
  for(Int_t i=0;i<6;i++) {
    HMdcTdcChannelSec& sec=mdc[i];
    for(Int_t j=0;j<4;j++) {
      HMdcTdcChannelMod& mod=sec[j];
      pos=i*4+j;
      if (set[pos]) {
        id=mdcIds->At(pos);
        if (id>0 && vers>0) {
          /* EXEC SQL OPEN c6; */ 

{
          struct sqlexd sqlstm;
          sqlorat((void **)0, &sqlctx, &oraca);
          sqlstm.sqlvsn = 12;
          sqlstm.arrsiz = 11;
          sqlstm.sqladtp = &sqladt;
          sqlstm.sqltdsp = &sqltds;
          sqlstm.stmt = sq0041;
          sqlstm.iters = (unsigned int  )1;
          sqlstm.offset = (unsigned int  )1767;
          sqlstm.selerr = (unsigned short)1;
          sqlstm.cud = sqlcud0;
          sqlstm.sqlest = (unsigned char  *)&sqlca;
          sqlstm.sqlety = (unsigned short)256;
          sqlstm.occurs = (unsigned int  )0;
          sqlstm.sqcmod = (unsigned int )0;
          sqlstm.sqhstv[0] = (         void  *)&id;
          sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[0] = (         int  )0;
          sqlstm.sqindv[0] = (         void  *)0;
          sqlstm.sqinds[0] = (         int  )0;
          sqlstm.sqharm[0] = (unsigned int  )0;
          sqlstm.sqadto[0] = (unsigned short )0;
          sqlstm.sqtdso[0] = (unsigned short )0;
          sqlstm.sqhstv[1] = (         void  *)&vers;
          sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[1] = (         int  )0;
          sqlstm.sqindv[1] = (         void  *)0;
          sqlstm.sqinds[1] = (         int  )0;
          sqlstm.sqharm[1] = (unsigned int  )0;
          sqlstm.sqadto[1] = (unsigned short )0;
          sqlstm.sqtdso[1] = (unsigned short )0;
          sqlstm.sqphsv = sqlstm.sqhstv;
          sqlstm.sqphsl = sqlstm.sqhstl;
          sqlstm.sqphss = sqlstm.sqhsts;
          sqlstm.sqpind = sqlstm.sqindv;
          sqlstm.sqpins = sqlstm.sqinds;
          sqlstm.sqparm = sqlstm.sqharm;
          sqlstm.sqparc = sqlstm.sqharc;
          sqlstm.sqpadto = sqlstm.sqadto;
          sqlstm.sqptdso = sqlstm.sqtdso;
          sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
          if (sqlca.sqlcode < 0) showSqlError("read(HMdcTdcChannel*,Int_t*)");
}


          /* EXEC SQL FETCH c6 INTO :cal; */ 

{
          struct sqlexd sqlstm;
          sqlorat((void **)0, &sqlctx, &oraca);
          sqlstm.sqlvsn = 12;
          sqlstm.arrsiz = 11;
          sqlstm.sqladtp = &sqladt;
          sqlstm.sqltdsp = &sqltds;
          sqlstm.iters = (unsigned int  )2000;
          sqlstm.offset = (unsigned int  )1790;
          sqlstm.selerr = (unsigned short)1;
          sqlstm.cud = sqlcud0;
          sqlstm.sqlest = (unsigned char  *)&sqlca;
          sqlstm.sqlety = (unsigned short)256;
          sqlstm.occurs = (unsigned int  )0;
          sqlstm.sqfoff = (           int )0;
          sqlstm.sqfmod = (unsigned int )2;
          sqlstm.sqhstv[0] = (         void  *)cal.mbo;
          sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[0] = (         int  )sizeof(int);
          sqlstm.sqindv[0] = (         void  *)0;
          sqlstm.sqinds[0] = (         int  )0;
          sqlstm.sqharm[0] = (unsigned int  )0;
          sqlstm.sqharc[0] = (unsigned int   *)0;
          sqlstm.sqadto[0] = (unsigned short )0;
          sqlstm.sqtdso[0] = (unsigned short )0;
          sqlstm.sqhstv[1] = (         void  *)cal.tdc;
          sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
          sqlstm.sqhsts[1] = (         int  )sizeof(int);
          sqlstm.sqindv[1] = (         void  *)0;
          sqlstm.sqinds[1] = (         int  )0;
          sqlstm.sqharm[1] = (unsigned int  )0;
          sqlstm.sqharc[1] = (unsigned int   *)0;
          sqlstm.sqadto[1] = (unsigned short )0;
          sqlstm.sqtdso[1] = (unsigned short )0;
          sqlstm.sqhstv[2] = (         void  *)cal.mask;
          sqlstm.sqhstl[2] = (unsigned int  )3;
          sqlstm.sqhsts[2] = (         int  )3;
          sqlstm.sqindv[2] = (         void  *)0;
          sqlstm.sqinds[2] = (         int  )0;
          sqlstm.sqharm[2] = (unsigned int  )0;
          sqlstm.sqharc[2] = (unsigned int   *)0;
          sqlstm.sqadto[2] = (unsigned short )0;
          sqlstm.sqtdso[2] = (unsigned short )0;
          sqlstm.sqhstv[3] = (         void  *)cal.cal;
          sqlstm.sqhstl[3] = (unsigned int  )3;
          sqlstm.sqhsts[3] = (         int  )3;
          sqlstm.sqindv[3] = (         void  *)0;
          sqlstm.sqinds[3] = (         int  )0;
          sqlstm.sqharm[3] = (unsigned int  )0;
          sqlstm.sqharc[3] = (unsigned int   *)0;
          sqlstm.sqadto[3] = (unsigned short )0;
          sqlstm.sqtdso[3] = (unsigned short )0;
          sqlstm.sqphsv = sqlstm.sqhstv;
          sqlstm.sqphsl = sqlstm.sqhstl;
          sqlstm.sqphss = sqlstm.sqhsts;
          sqlstm.sqpind = sqlstm.sqindv;
          sqlstm.sqpins = sqlstm.sqinds;
          sqlstm.sqparm = sqlstm.sqharm;
          sqlstm.sqparc = sqlstm.sqharc;
          sqlstm.sqpadto = sqlstm.sqadto;
          sqlstm.sqptdso = sqlstm.sqtdso;
          sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
          if (sqlca.sqlcode < 0) showSqlError("read(HMdcTdcChannel*,Int_t*)");
}


          Int_t nChannels=-1, mo, mm=-1, mi=-1, ch;
          nChannels=sqlca.sqlerrd[2];
          for(Int_t k=0;k<nChannels;k++) {
            mo=cal.mbo[k];
            if (mo>mm) {
              mi++;
              const Char_t* mboName=mod[mi].GetName();
              sscanf(mboName,"%i",&mm);
              if (mo!=mm) {
                Error("read(HMdcTdcChannel*,Int_t*)",
                      "MBO %i is missing in parameter container",mm);
                /* EXEC SQL CLOSE c6; */ 

{
                struct sqlexd sqlstm;
                sqlorat((void **)0, &sqlctx, &oraca);
                sqlstm.sqlvsn = 12;
                sqlstm.arrsiz = 11;
                sqlstm.sqladtp = &sqladt;
                sqlstm.sqltdsp = &sqltds;
                sqlstm.iters = (unsigned int  )1;
                sqlstm.offset = (unsigned int  )1821;
                sqlstm.cud = sqlcud0;
                sqlstm.sqlest = (unsigned char  *)&sqlca;
                sqlstm.sqlety = (unsigned short)256;
                sqlstm.occurs = (unsigned int  )0;
                sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
                if (sqlca.sqlcode < 0) showSqlError("read(HMdcTdcChannel*,Int_t*)");
}


                return kFALSE;
              }
              mm=mo;
            }
            sscanf(cal.mask[k],"%x",&ch);
            mod[mi][cal.tdc[k]-1].fill(ch,1);
            sscanf(cal.cal[k],"%x",&ch);
            mod[mi][cal.tdc[k]-1].fill(ch,0);
          }
          if (nChannels>0) {
            set[pos]=0;
            initModules->AddAt(pos+1,pos);
          }
          else allFound=kFALSE;
        }
        else allFound=kFALSE;
      }
    }
  }
  /* EXEC SQL CLOSE c6; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 11;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )1836;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) showSqlError("read(HMdcTdcChannel*,Int_t*)");
}


  setChanged(pPar);
  printInfo(pPar->GetName());
  return allFound;
} 

Int_t HMdcParOraIo::writePar(HMdcTdcChannel* pPar) {
  // creates a new version and writes the threshold parameters to Oracle
  Int_t version=createVersion(pPar);
  if (version==-1) return -1;
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int mdc[MDC_MAXARR];
    int mbo[MDC_MAXARR];
    int tdc[MDC_MAXARR];
    int vers[MDC_MAXARR];
    char mask[MDC_MAXARR][3];
    char cal[MDC_MAXARR][3];
    int rows_to_insert;
  /* EXEC SQL END DECLARE SECTION; */ 

  Int_t mboInd, nDbo=0,pos,id;
  for(Int_t s=0; s<pPar->getSize(); s++) {
    HMdcTdcChannelSec& rSec= (*pPar)[s];
    for(Int_t m=0; m<rSec.getSize(); m++) {
      HMdcTdcChannelMod& rMod= rSec[m];
      nDbo=0;
      pos=s*4+m;
      id=mdcIds->At(pos);
      if (id>0) {	
      	for(Int_t l=0; l<rMod.getSize(); l++) {
          HMdcTdcChannelMbo& rMbo= rMod[l];
          const Char_t* mboName=rMbo.GetName();
          sscanf(mboName,"%i",&mboInd);
          for(Int_t c=0; c<rMbo.getSize(); c++) {
            mdc[nDbo]=id;
            mbo[nDbo]=mboInd;
            tdc[nDbo]=c+1;
            sprintf(mask[nDbo],"%x",rMbo[c].getChannelMask(1));
            sprintf(cal[nDbo],"%x",rMbo[c].getChannelMask(0));
            vers[nDbo]=version;
            nDbo++;
          }
        }
        rows_to_insert=nDbo;
        /* EXEC SQL WHENEVER SQLERROR GOTO not_found; */ 

        /* EXEC SQL WHENEVER NOT FOUND GOTO not_found; */ 

        /* EXEC SQL FOR :rows_to_insert
        INSERT INTO mdc_ana.mask_data (mask_address_id, vers_id, channel_mask, calibration_mask)
          VALUES (mdc_ana.mdc_par_query.get_mask_address_id(:mdc,:mbo,:tdc),
                  :vers, :mask, :cal); */ 

{
        struct sqlexd sqlstm;
        sqlorat((void **)0, &sqlctx, &oraca);
        sqlstm.sqlvsn = 12;
        sqlstm.arrsiz = 11;
        sqlstm.sqladtp = &sqladt;
        sqlstm.sqltdsp = &sqltds;
        sqlstm.stmt = "insert into mdc_ana.mask_data (mask_address_id,vers_i\
d,channel_mask,calibration_mask) values (mdc_ana.mdc_par_query.get_mask_addres\
s_id(:b1,:b2,:b3),:b4,:b5,:b6)";
        sqlstm.iters = (unsigned int  )rows_to_insert;
        sqlstm.offset = (unsigned int  )1851;
        sqlstm.cud = sqlcud0;
        sqlstm.sqlest = (unsigned char  *)&sqlca;
        sqlstm.sqlety = (unsigned short)256;
        sqlstm.occurs = (unsigned int  )0;
        sqlstm.sqhstv[0] = (         void  *)mdc;
        sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[0] = (         int  )sizeof(int);
        sqlstm.sqindv[0] = (         void  *)0;
        sqlstm.sqinds[0] = (         int  )0;
        sqlstm.sqharm[0] = (unsigned int  )0;
        sqlstm.sqharc[0] = (unsigned int   *)0;
        sqlstm.sqadto[0] = (unsigned short )0;
        sqlstm.sqtdso[0] = (unsigned short )0;
        sqlstm.sqhstv[1] = (         void  *)mbo;
        sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[1] = (         int  )sizeof(int);
        sqlstm.sqindv[1] = (         void  *)0;
        sqlstm.sqinds[1] = (         int  )0;
        sqlstm.sqharm[1] = (unsigned int  )0;
        sqlstm.sqharc[1] = (unsigned int   *)0;
        sqlstm.sqadto[1] = (unsigned short )0;
        sqlstm.sqtdso[1] = (unsigned short )0;
        sqlstm.sqhstv[2] = (         void  *)tdc;
        sqlstm.sqhstl[2] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[2] = (         int  )sizeof(int);
        sqlstm.sqindv[2] = (         void  *)0;
        sqlstm.sqinds[2] = (         int  )0;
        sqlstm.sqharm[2] = (unsigned int  )0;
        sqlstm.sqharc[2] = (unsigned int   *)0;
        sqlstm.sqadto[2] = (unsigned short )0;
        sqlstm.sqtdso[2] = (unsigned short )0;
        sqlstm.sqhstv[3] = (         void  *)vers;
        sqlstm.sqhstl[3] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[3] = (         int  )sizeof(int);
        sqlstm.sqindv[3] = (         void  *)0;
        sqlstm.sqinds[3] = (         int  )0;
        sqlstm.sqharm[3] = (unsigned int  )0;
        sqlstm.sqharc[3] = (unsigned int   *)0;
        sqlstm.sqadto[3] = (unsigned short )0;
        sqlstm.sqtdso[3] = (unsigned short )0;
        sqlstm.sqhstv[4] = (         void  *)mask;
        sqlstm.sqhstl[4] = (unsigned int  )3;
        sqlstm.sqhsts[4] = (         int  )3;
        sqlstm.sqindv[4] = (         void  *)0;
        sqlstm.sqinds[4] = (         int  )0;
        sqlstm.sqharm[4] = (unsigned int  )0;
        sqlstm.sqharc[4] = (unsigned int   *)0;
        sqlstm.sqadto[4] = (unsigned short )0;
        sqlstm.sqtdso[4] = (unsigned short )0;
        sqlstm.sqhstv[5] = (         void  *)cal;
        sqlstm.sqhstl[5] = (unsigned int  )3;
        sqlstm.sqhsts[5] = (         int  )3;
        sqlstm.sqindv[5] = (         void  *)0;
        sqlstm.sqinds[5] = (         int  )0;
        sqlstm.sqharm[5] = (unsigned int  )0;
        sqlstm.sqharc[5] = (unsigned int   *)0;
        sqlstm.sqadto[5] = (unsigned short )0;
        sqlstm.sqtdso[5] = (unsigned short )0;
        sqlstm.sqphsv = sqlstm.sqhstv;
        sqlstm.sqphsl = sqlstm.sqhstl;
        sqlstm.sqphss = sqlstm.sqhsts;
        sqlstm.sqpind = sqlstm.sqindv;
        sqlstm.sqpins = sqlstm.sqinds;
        sqlstm.sqparm = sqlstm.sqharm;
        sqlstm.sqparc = sqlstm.sqharc;
        sqlstm.sqpadto = sqlstm.sqadto;
        sqlstm.sqptdso = sqlstm.sqtdso;
        sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
        if (sqlca.sqlcode == 1403) goto not_found;
        if (sqlca.sqlcode < 0) goto not_found;
}


        cout<<"Channels: "<<rows_to_insert<<" rows inserted\n";
      }
    }
  }
  commit();
  pPar->setChanged(kFALSE);
  return version;
not_found:
  showSqlError("writePar(HMdcTdcChannels*)");
  rollback();
  return -1;
}

Bool_t HMdcParOraIo::confirmThresholds(Int_t thresholds_version) {
  // sets the threshold version as the actual valid version
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int  version;
  /* EXEC SQL END DECLARE SECTION; */ 

  /* EXEC SQL WHENEVER SQLERROR GOTO error_found; */ 

  /* EXEC SQL WHENEVER NOTFOUND GOTO not_found; */ 

  version = thresholds_version;
  /* EXEC SQL EXECUTE
    DECLARE
    BEGIN
      mdc_ana.thr_mask_mtn.confirm_thr_version(:version);
      COMMIT;
    END;
  END-EXEC; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 11;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "declare BEGIN mdc_ana . thr_mask_mtn . confirm_thr_version \
( :version ) ; COMMIT ; END ;";
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )1890;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)&version;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )0;
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode == 1403) goto not_found;
  if (sqlca.sqlcode < 0) goto error_found;
}


  return kTRUE;
error_found:
  showSqlError("confirmThresholds");
  rollback();
  return kFALSE;
not_found:
  rollback();
  return kFALSE;
}

Bool_t HMdcParOraIo::confirmChannelMasks(Int_t channel_masks_version) {
  // sets the channel mask version as the actual valid version
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int   version;
  /* EXEC SQL END DECLARE SECTION; */ 

  /* EXEC SQL WHENEVER SQLERROR GOTO error_found; */ 

  /* EXEC SQL WHENEVER NOTFOUND GOTO not_found; */ 

  version = channel_masks_version;
  /* EXEC SQL EXECUTE
    DECLARE
    BEGIN
      mdc_ana.thr_mask_mtn.confirm_mask_version(:version);
      COMMIT;
    END;
  END-EXEC; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 11;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "declare BEGIN mdc_ana . thr_mask_mtn . confirm_mask_version\
 ( :version ) ; COMMIT ; END ;";
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )1909;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)&version;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )0;
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode == 1403) goto not_found;
  if (sqlca.sqlcode < 0) goto error_found;
}


  return kTRUE;
error_found:
  showSqlError("confirmChannelMasks");
  rollback();
  return kFALSE;
not_found:
  rollback();
  return kFALSE;
}

Int_t HMdcParOraIo::getThresholdsVersionsLastRunID(Int_t thresholds_version) {
  // returns the last run id in the timerange where the threshold version was valid
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int  id;
    int  version;
  /* EXEC SQL END DECLARE SECTION; */ 

  /* EXEC SQL WHENEVER SQLERROR GOTO error_found; */ 

  /* EXEC SQL WHENEVER NOTFOUND GOTO not_found; */ 

  version = thresholds_version;
  /* EXEC SQL
    SELECT run_id INTO :id FROM daq.daq_runs_ana
    WHERE run_start =
      (SELECT max(run_start) FROM daq.daq_runs_ana
       WHERE run_start <=
         (SELECT MAX(date_expired) FROM mdc_ana.thr_vers_managment
          WHERE vers_id = :version)); */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 11;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "select run_id into :b0  from daq.daq_runs_ana where run_sta\
rt=(select max(run_start)  from daq.daq_runs_ana where run_start<=(select max(\
date_expired)  from mdc_ana.thr_vers_managment where vers_id=:b1))";
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )1928;
  sqlstm.selerr = (unsigned short)1;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)&id;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )0;
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqhstv[1] = (         void  *)&version;
  sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[1] = (         int  )0;
  sqlstm.sqindv[1] = (         void  *)0;
  sqlstm.sqinds[1] = (         int  )0;
  sqlstm.sqharm[1] = (unsigned int  )0;
  sqlstm.sqadto[1] = (unsigned short )0;
  sqlstm.sqtdso[1] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode == 1403) goto not_found;
  if (sqlca.sqlcode < 0) goto error_found;
}


  return id;
error_found:
  showSqlError("getThresholdsVersionsLastRunID");
  return -1;
not_found:
  return -1;
}

Int_t HMdcParOraIo::getChannelMasksVersionsLastRunID(Int_t channel_masks_version) {
  // returns the last run id in the timerange where the channel mask version was valid

  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int  id;
    int  version;
  /* EXEC SQL END DECLARE SECTION; */ 

  /* EXEC SQL WHENEVER SQLERROR GOTO error_found; */ 

  /* EXEC SQL WHENEVER NOTFOUND GOTO not_found; */ 

  version = channel_masks_version;
  /* EXEC SQL
    SELECT run_id INTO :id FROM daq.daq_runs_ana
    WHERE run_start =
      (SELECT max(run_start) FROM daq.daq_runs_ana
       WHERE run_start <=
         (SELECT MAX(date_expired) FROM mdc_ana.mask_vers_managment
          WHERE vers_id = :version)); */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 11;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "select run_id into :b0  from daq.daq_runs_ana where run_sta\
rt=(select max(run_start)  from daq.daq_runs_ana where run_start<=(select max(\
date_expired)  from mdc_ana.mask_vers_managment where vers_id=:b1))";
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )1951;
  sqlstm.selerr = (unsigned short)1;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)&id;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )0;
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqhstv[1] = (         void  *)&version;
  sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[1] = (         int  )0;
  sqlstm.sqindv[1] = (         void  *)0;
  sqlstm.sqinds[1] = (         int  )0;
  sqlstm.sqharm[1] = (unsigned int  )0;
  sqlstm.sqadto[1] = (unsigned short )0;
  sqlstm.sqtdso[1] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode == 1403) goto not_found;
  if (sqlca.sqlcode < 0) goto error_found;
}


  return id;
error_found:
  showSqlError("getChannelMasksVersionsLastRunID");
  return -1;
not_found:
  return -1;
}


Int_t HMdcParOraIo::writePar(HMdcLookupGeom* pPar) {
  // creates a new version and writes the lookup table to Oracle
  Int_t version=createVersion(pPar);
  if (version==-1) return -1;
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int vers[MDC_MAXWIRES];
    int mdc[MDC_MAXWIRES];
    int layer[MDC_MAXWIRES];
    int wire[MDC_MAXWIRES];
    int mbo[MDC_MAXWIRES];
    int tdc[MDC_MAXWIRES];
    int channel[MDC_MAXWIRES];
    int rows_to_insert;
    int vers_id;
  /* EXEC SQL END DECLARE SECTION; */ 

  Int_t pos, id, mboInd, nWire, lay, cell, t;
  for(Int_t i=0;i<pPar->getSize();i++) {
    HMdcLookupGSec& sec=(*pPar)[i];
    for(Int_t j=0;j<sec.getSize();j++) {
      HMdcLookupGMod& mod=sec[j];
      pos=i*4+j;
      id=mdcIds->At(pos);
      if (id>0) {
        nWire=0;
        for(Int_t l=0; l<mod.getSize(); l++) {
          HMdcLookupMoth& moth=mod[l];
          const Char_t* mboName=moth.GetName();
          sscanf(mboName,"%i",&mboInd);
          for(Int_t c=0;c<moth.getSize();c++) {
            HMdcLookupChan& chan=moth[c];
            lay=chan.getNLayer();
            cell=chan.getNCell();
            if (lay>=0&&cell>=0) {
              vers[nWire]=version;
              mdc[nWire]=id;
              layer[nWire]=lay+1;
              wire[nWire]=cell+1;
              mbo[nWire]=mboInd;
              t=(Int_t)(c/8);
              tdc[nWire]=t+1;
              channel[nWire]=c-t*8+1;
              nWire++;
            }
          }
        }
        rows_to_insert=nWire;
        /* EXEC SQL WHENEVER SQLERROR GOTO not_found; */ 

        /* EXEC SQL WHENEVER NOT FOUND GOTO not_found; */ 

        /* EXEC SQL FOR :rows_to_insert
        INSERT INTO mdc_ana.load_mdclookupgeom_data
           (vers_id,mdc_hwobj_id,layer_nr,wire_nr,mbo_local_pos_id,tdc_nr,tdc_chan)
           values (:vers,:mdc,:layer,:wire,:mbo,:tdc,:channel); */ 

{
        struct sqlexd sqlstm;
        sqlorat((void **)0, &sqlctx, &oraca);
        sqlstm.sqlvsn = 12;
        sqlstm.arrsiz = 11;
        sqlstm.sqladtp = &sqladt;
        sqlstm.sqltdsp = &sqltds;
        sqlstm.stmt = "insert into mdc_ana.load_mdclookupgeom_data (vers_id,\
mdc_hwobj_id,layer_nr,wire_nr,mbo_local_pos_id,tdc_nr,tdc_chan) values (:b1,:b\
2,:b3,:b4,:b5,:b6,:b7)";
        sqlstm.iters = (unsigned int  )rows_to_insert;
        sqlstm.offset = (unsigned int  )1974;
        sqlstm.cud = sqlcud0;
        sqlstm.sqlest = (unsigned char  *)&sqlca;
        sqlstm.sqlety = (unsigned short)256;
        sqlstm.occurs = (unsigned int  )0;
        sqlstm.sqhstv[0] = (         void  *)vers;
        sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[0] = (         int  )sizeof(int);
        sqlstm.sqindv[0] = (         void  *)0;
        sqlstm.sqinds[0] = (         int  )0;
        sqlstm.sqharm[0] = (unsigned int  )0;
        sqlstm.sqharc[0] = (unsigned int   *)0;
        sqlstm.sqadto[0] = (unsigned short )0;
        sqlstm.sqtdso[0] = (unsigned short )0;
        sqlstm.sqhstv[1] = (         void  *)mdc;
        sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[1] = (         int  )sizeof(int);
        sqlstm.sqindv[1] = (         void  *)0;
        sqlstm.sqinds[1] = (         int  )0;
        sqlstm.sqharm[1] = (unsigned int  )0;
        sqlstm.sqharc[1] = (unsigned int   *)0;
        sqlstm.sqadto[1] = (unsigned short )0;
        sqlstm.sqtdso[1] = (unsigned short )0;
        sqlstm.sqhstv[2] = (         void  *)layer;
        sqlstm.sqhstl[2] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[2] = (         int  )sizeof(int);
        sqlstm.sqindv[2] = (         void  *)0;
        sqlstm.sqinds[2] = (         int  )0;
        sqlstm.sqharm[2] = (unsigned int  )0;
        sqlstm.sqharc[2] = (unsigned int   *)0;
        sqlstm.sqadto[2] = (unsigned short )0;
        sqlstm.sqtdso[2] = (unsigned short )0;
        sqlstm.sqhstv[3] = (         void  *)wire;
        sqlstm.sqhstl[3] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[3] = (         int  )sizeof(int);
        sqlstm.sqindv[3] = (         void  *)0;
        sqlstm.sqinds[3] = (         int  )0;
        sqlstm.sqharm[3] = (unsigned int  )0;
        sqlstm.sqharc[3] = (unsigned int   *)0;
        sqlstm.sqadto[3] = (unsigned short )0;
        sqlstm.sqtdso[3] = (unsigned short )0;
        sqlstm.sqhstv[4] = (         void  *)mbo;
        sqlstm.sqhstl[4] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[4] = (         int  )sizeof(int);
        sqlstm.sqindv[4] = (         void  *)0;
        sqlstm.sqinds[4] = (         int  )0;
        sqlstm.sqharm[4] = (unsigned int  )0;
        sqlstm.sqharc[4] = (unsigned int   *)0;
        sqlstm.sqadto[4] = (unsigned short )0;
        sqlstm.sqtdso[4] = (unsigned short )0;
        sqlstm.sqhstv[5] = (         void  *)tdc;
        sqlstm.sqhstl[5] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[5] = (         int  )sizeof(int);
        sqlstm.sqindv[5] = (         void  *)0;
        sqlstm.sqinds[5] = (         int  )0;
        sqlstm.sqharm[5] = (unsigned int  )0;
        sqlstm.sqharc[5] = (unsigned int   *)0;
        sqlstm.sqadto[5] = (unsigned short )0;
        sqlstm.sqtdso[5] = (unsigned short )0;
        sqlstm.sqhstv[6] = (         void  *)channel;
        sqlstm.sqhstl[6] = (unsigned int  )sizeof(int);
        sqlstm.sqhsts[6] = (         int  )sizeof(int);
        sqlstm.sqindv[6] = (         void  *)0;
        sqlstm.sqinds[6] = (         int  )0;
        sqlstm.sqharm[6] = (unsigned int  )0;
        sqlstm.sqharc[6] = (unsigned int   *)0;
        sqlstm.sqadto[6] = (unsigned short )0;
        sqlstm.sqtdso[6] = (unsigned short )0;
        sqlstm.sqphsv = sqlstm.sqhstv;
        sqlstm.sqphsl = sqlstm.sqhstl;
        sqlstm.sqphss = sqlstm.sqhsts;
        sqlstm.sqpind = sqlstm.sqindv;
        sqlstm.sqpins = sqlstm.sqinds;
        sqlstm.sqparm = sqlstm.sqharm;
        sqlstm.sqparc = sqlstm.sqharc;
        sqlstm.sqpadto = sqlstm.sqadto;
        sqlstm.sqptdso = sqlstm.sqtdso;
        sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
        if (sqlca.sqlcode == 1403) goto not_found;
        if (sqlca.sqlcode < 0) goto not_found;
}


        cout<<"MdcId: "<<id<<"   "<<rows_to_insert<<" rows inserted\n";
      }
    }
  }
  vers_id=version;
  /* EXEC SQL EXECUTE
    BEGIN
      mdc_ana.mdc_par_query.check_fpc_data_consistency(:vers_id);
    END;
  END-EXEC; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 11;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "begin mdc_ana . mdc_par_query . check_fpc_data_consistency \
( :vers_id ) ; END ;";
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )2017;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)&vers_id;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )0;
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode == 1403) goto not_found;
  if (sqlca.sqlcode < 0) goto not_found;
}


  commit();
  pPar->setChanged(kFALSE);
  return version;
not_found:
  showSqlError("writePar(HMdcMdcLookupGeom*)");
  rollback();
  return -1;
}