//_HADES_CLASS_DESCRIPTION
//////////////////////////////////////////////////////////////////////////////
// HStsParOra2Io
//
// Interface class to database Oracle for input/output of parameters needed
// by the FWDET for runs since 2019
// (uses the Oracle C/C++ precompiler)
//
//////////////////////////////////////////////////////////////////////////////

using namespace std;
#include "hstsparora2io.h"
#include "hparora2set.h"
#include "hststrb3lookup.h"
#include "hstscalpar.h"
#include "hstsgeompar.h"
#include "hgeomcompositevolume.h"
#include "hora2geomdetversion.h"
#include "hora2geomobj.h"

//#include "fwdetdef.h"
// JAM2019 - here we have const int instead defines. does this work for precompiler arrays?
// better redefine it here:
#define FWDET_STRAW_MAX_MODULES   2
#define FWDET_STRAW_MAX_LAYERS    4
#define FWDET_STRAW_MAX_STRAWS     224
#define FWDET_STRAW_MAX_SUBCELLS  4

#define FWDET_STRAW_MAX_GLOBALCELLS \
	FWDET_STRAW_MAX_MODULES * FWDET_STRAW_MAX_LAYERS * FWDET_STRAW_MAX_STRAWS * FWDET_STRAW_MAX_SUBCELLS

// = 7168

#define FWDET_STRAW_MAX_GLOBAL_LAYERS FWDET_STRAW_MAX_MODULES * FWDET_STRAW_MAX_LAYERS
#define FWDET_STRAW_MAX_LAYER_CELLS FWDET_STRAW_MAX_STRAWS * FWDET_STRAW_MAX_SUBCELLS

#include "TClass.h"
#include "TList.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(HStsParOra2Io)



HStsParOra2Io::HStsParOra2Io(HOra2Conn* pC) : HDetParOra2Io(pC) {
  // constructor
  // sets the name of the I/O class "HStsParIo"
  // gets the pointer to the connection class
  fName="HStsParIo";
  initModules=new TArrayI(FWDET_STRAW_MAX_GLOBAL_LAYERS);
  geomVers=0;
  sensVolume=0;
}

HStsParOra2Io::~HStsParOra2Io(void) {
  // destructor
  if (initModules) delete initModules;
  if (geomVers) delete geomVers;
  if (sensVolume) delete sensVolume;
}

Bool_t HStsParOra2Io::init(HParSet* pPar,Int_t* set) {
  // calls special read-function for each parameter container
  if (getRunStart(pPar)<0) {
    pPar->setInputVersion(-1,inputNumber);
    return kFALSE;
  }
  const Text_t* name=pPar->IsA()->GetName();
  if (strcmp(name,"HStsTrb3Lookup")==0) return read(((HStsTrb3Lookup*)pPar));
  if (strcmp(name,"HStsCalPar")==0) return read(((HStsCalPar*)pPar));
  if (strcmp(name,"HStsGeomPar")==0)    return read(((HStsGeomPar*)pPar),set);
  cout<<"No read-interface to Oracle for parameter container "
      <<pPar->GetName()<<endl;
  return kFALSE;
}

Int_t HStsParOra2Io::write(HParSet* pPar) {
  // calls the appropriate write function for the container
  cout <<"HStsParOra2Io::write... " << endl;
  if (getRunStart(pPar)<=0) return -1;
  const Text_t* name=pPar->IsA()->GetName();
  cout <<"HStsParOra2Io::write("<<name<<")"<< endl;
  if (strcmp(name,"HStsTrb3Lookup")==0) return writePar((HStsTrb3Lookup*)pPar);
  if (strcmp(name,"HStsCalPar")==0) return writePar((HStsCalPar*)pPar);
  if (strcmp(name,"HStsGeomPar")==0)    return writeAlignment((HStsGeomPar*)pPar);
  cout<<"No write-interface to Oracle for parameter container "
      <<pPar->GetName()<<endl;
  return 0;
}

Bool_t HStsParOra2Io::getVersion(HParSet* pPar,Int_t& version) {
  // checks, if the parameter container needs to be reinitialized
  // reads the newest version valid for the current event file
  // returns kTRUE, if new parameters must be read
  // returns kFALSE, if no reinitialization needed or not valid version found
  HParOra2Set* oraSet=getOraSet(pPar);
  if (oraSet->contextId==-1 || runStart==-1) {
    pPar->setInputVersion(-1,inputNumber);
    version=-1;
    return kFALSE;
  }
  Int_t contVers=pPar->getInputVersion(inputNumber);
  if (contVers!=-1 && runStart>=oraSet->versDate[0] && runStart<=oraSet->versDate[1]) {
    version=contVers;
    return kFALSE;
  }
  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,"HStsTrb3Lookup")==0) {
    EXEC SQL SELECT version,
                    hanadate.date_to_number(valid_since),
                    hanadate.date_to_number(valid_until)
             INTO :vers, :since, :until
               FROM fwdet_ana2.straw_trb3lookup_vers_at_date
             WHERE context_id = :context;
  }
  else if (strcmp(containerClass,"HStsCalPar")==0) {
    EXEC SQL SELECT version,
                    hanadate.date_to_number(valid_since),
                    hanadate.date_to_number(valid_until)
            INTO :vers, :since, :until
            FROM fwdet_ana2.straw_calpar_vers_at_date
            WHERE context_id = :context;
  }
  else {}


  version=vers;
  oraSet->versDate[0]=since;
  oraSet->versDate[1]=until;
  return kTRUE;
notfound:
  pPar->setInputVersion(-1,inputNumber);
  version=-1;
  return kFALSE;
};



Bool_t HStsParOra2Io::read(HStsTrb3Lookup* pPar) {
  // reads the lookup table for the Trb3 unpacker and fill the container FwdetStrawTrb3Lookup
  Int_t oraVersion=-1;
  Bool_t rc=getVersion(pPar,oraVersion);
  if (oraVersion<0) return kFALSE;
  if (oraVersion>=0&&rc==kFALSE) return kTRUE;
  pPar->clear();
  EXEC SQL BEGIN DECLARE SECTION;
    int vers;
    struct {
      int  address[FWDET_STRAW_MAX_GLOBALCELLS];
      int  channel[FWDET_STRAW_MAX_GLOBALCELLS];
      int  module[FWDET_STRAW_MAX_GLOBALCELLS];
      int  layer [FWDET_STRAW_MAX_GLOBALCELLS];
      int  straw[FWDET_STRAW_MAX_GLOBALCELLS];
      int  updown[FWDET_STRAW_MAX_GLOBALCELLS];
    } lookup;
  EXEC SQL END DECLARE SECTION;
  vers=oraVersion;
  EXEC SQL WHENEVER SQLERROR DO showSqlError("read(HStsTrb3Lookup*)");
  EXEC SQL WHENEVER NOT FOUND CONTINUE;
  EXEC SQL SELECT trbnet_address, channel,
                  module, layer, straw, updown
           INTO :lookup
           FROM fwdet_ana2.straw_trb3lookup_data_view
           WHERE vers_id = :vers;
  Int_t nData=sqlca.sqlerrd[2];
  for (Int_t i=0;i<nData;i++) {
    pPar->fill(lookup.address[i],lookup.channel[i],
               lookup.module[i]-1,lookup.layer[i]-1, lookup.straw[i]-1, lookup.updown[i]);
  }
  rc=kTRUE;
  if (nData>0) {
    setChanged(pPar,oraVersion);
    cout<<pPar->GetName()<<" initialized from Oracle"<<endl;
  } else {
    pPar->setInputVersion(-1,inputNumber);
    rc=kFALSE;
  }
  return rc;
}

// JAM22 TODO
Bool_t HStsParOra2Io::read(HStsCalPar* pPar) {
  // reads the lookup table for the Trb3 unpacker and fill the container FRpcTrb3Lookup
  Int_t oraVersion=-1;
  Bool_t rc=getVersion(pPar,oraVersion);
  if (oraVersion<0) return kFALSE;
  if (oraVersion>=0&&rc==kFALSE) return kTRUE;
  pPar->clear();
  EXEC SQL BEGIN DECLARE SECTION;
    int vers;
    int globalstrip;
    struct {
      int module[FWDET_STRAW_MAX_GLOBALCELLS];
      int layer[FWDET_STRAW_MAX_GLOBALCELLS];
      int straw[FWDET_STRAW_MAX_GLOBALCELLS];      
      short updown[FWDET_STRAW_MAX_GLOBALCELLS];
      float time_offset[FWDET_STRAW_MAX_GLOBALCELLS];
      float time_max[FWDET_STRAW_MAX_GLOBALCELLS];
      float time_slope[FWDET_STRAW_MAX_GLOBALCELLS]; 
      float tof_reference[FWDET_STRAW_MAX_GLOBALCELLS]; 
      float iso_par_0[FWDET_STRAW_MAX_GLOBALCELLS];
      float iso_par_1[FWDET_STRAW_MAX_GLOBALCELLS]; 
      float iso_par_2[FWDET_STRAW_MAX_GLOBALCELLS]; 
      float iso_par_3[FWDET_STRAW_MAX_GLOBALCELLS]; 
      float iso_par_4[FWDET_STRAW_MAX_GLOBALCELLS];
      float tot_par_0[FWDET_STRAW_MAX_GLOBALCELLS];
      float tot_par_1[FWDET_STRAW_MAX_GLOBALCELLS];
    } cal;
    struct {
      short module[FWDET_STRAW_MAX_GLOBALCELLS];
      short layer[FWDET_STRAW_MAX_GLOBALCELLS];
      short straw[FWDET_STRAW_MAX_GLOBALCELLS];      
      short updown[FWDET_STRAW_MAX_GLOBALCELLS];
      short time_offset[FWDET_STRAW_MAX_GLOBALCELLS];
      short time_max[FWDET_STRAW_MAX_GLOBALCELLS];
      short time_slope[FWDET_STRAW_MAX_GLOBALCELLS]; 
      short tof_reference[FWDET_STRAW_MAX_GLOBALCELLS]; 
      short iso_par_0[FWDET_STRAW_MAX_GLOBALCELLS];
      short iso_par_1[FWDET_STRAW_MAX_GLOBALCELLS]; 
      short iso_par_2[FWDET_STRAW_MAX_GLOBALCELLS]; 
      short iso_par_3[FWDET_STRAW_MAX_GLOBALCELLS]; 
      short iso_par_4[FWDET_STRAW_MAX_GLOBALCELLS];
      short tot_par_0[FWDET_STRAW_MAX_GLOBALCELLS];
      short tot_par_1[FWDET_STRAW_MAX_GLOBALCELLS];
    } cal_Ind;
    
     EXEC SQL END DECLARE SECTION;
  vers=oraVersion;
  EXEC SQL WHENEVER SQLERROR DO showSqlError("read(HStsCalPar*,Int_t*)");
  EXEC SQL WHENEVER NOT FOUND CONTINUE;
  EXEC SQL SELECT  module, layer, straw, updown, time_offset, time_max,  time_slope, 
		tof_reference, iso_par_0, iso_par_1, iso_par_2, iso_par_3, iso_par_4, 
		tot_par_0, tot_par_1               
           INTO :cal INDICATOR :cal_Ind
           FROM fwdet_ana2.straw_calpar_data_view
           WHERE vers_id = :vers;
  Int_t nData=sqlca.sqlerrd[2];
  Int_t sec=-1, mod=-1, tube=-1, kind=-1;
  for(Int_t i=0;i<nData;i++) {
    
    sec=cal.layer[i]-1;
    mod=cal.module[i]-1;
    tube=cal.straw[i]-1;
    kind=cal.updown[i];
// JAM disable check for completeness for the moment...    
//     pos=sec* FRPC_MAX_STRIPS + globalstrip;
//     
//     if (set[pos]) 
    {
      HStsCalParCellKind& cell=(*pPar)[mod][sec][tube][kind];
      cell.setTimeOffset(cal.time_offset[i]);
      cell.setTimeMax(cal.time_max[i]);
      cell.setTimeSlope(cal.time_slope[i]);
      cell.setTofReference(cal.tof_reference[i]);
      cell.setIsoPar0(cal.iso_par_0[i]); 
      cell.setIsoPar1(cal.iso_par_1[i]);
      cell.setIsoPar2(cal.iso_par_2[i]); 
      cell.setIsoPar3(cal.iso_par_3[i]);
      cell.setIsoPar4(cal.iso_par_4[i]); 
      cell.setTotPar0(cal.tot_par_0[i]);
      cell.setTotPar1(cal.tot_par_1[i]);
      //initModules->AddAt(1,pos);
    }
  }     
  Bool_t allFound=kTRUE;
  
//   if (nData>0) {
//     for(Int_t i=0;i<FRPC_MAX_SECTORS * FRPC_MAX_STRIPS;i++) {
//       if (set[i]==1 && initModules->At(i)==0) allFound=kFALSE;
//     }
//   } else allFound=kFALSE;
//   
  if (allFound) {
    setChanged(pPar,oraVersion);
    printInfo(pPar->GetName());
  } else {
    pPar->setInputVersion(-1,inputNumber);
  }
  return allFound;
    

    

}





/////////////////////////// GEOMETRY follows ///////////////////////////////////

Bool_t HStsParOra2Io::read(HStsGeomPar* pPar, Int_t* set) {
  // reads the geometry of the Sts and fills the StsGeomPar container
  Bool_t allFound=kTRUE;
  Int_t detId=-1;
  if (!geomVers) {
    detId=getDetectorId(pPar->getDetectorName());
    geomVers=new HOra2GeomDetVersion( pPar->getDetectorName(),detId);
    //std::cout<< "HStsParOra2Io::read HStsGeomPar got id"<<detId<<" for detector "<< pPar->getDetectorName() << std::endl;
  } else {
    detId=geomVers->getDetectorId();
  }
  if (detId<=0) {
    allFound=kFALSE;
    delete geomVers;
    geomVers=0;
  }
  if (detId>0&&pPar->isFirstInitialization()) {
	  //std::cout<< "HStsParOra2Io::read HStsGeomPar with detId;"<<detId<<" and first init: "<<  pPar->isFirstInitialization()<< std::endl;
    if (!readModGeomNames(pPar,set) || !readCompGeomNames(pPar,set)) {
      allFound=kFALSE;
      pPar->clear();
      //std::cout<< "HStsParOra2Io::read HStsGeomPar failed after readModGeomNames or readCompGeomNames"<< std::endl;
    } else addGeomOraSet(pPar);
  }
  if (allFound) allFound=readDetectorGeometry(pPar,set,geomVers);
  //std::cout<< "HStsParOra2Io::read HStsGeomPar returns"<<allFound << std::endl;
  return allFound;
}

Bool_t HStsParOra2Io::readModGeomNames(HStsGeomPar* pPar,Int_t* set) {
  // reads the GEANT geometry names of all modules and layers
	//std::cout<< "HStsParOra2Io:readModGeomNames.... "<< std::endl;
  EXEC SQL BEGIN DECLARE SECTION;
    struct {
      int mod[FWDET_STRAW_MAX_GLOBAL_LAYERS];
      int lay[FWDET_STRAW_MAX_GLOBAL_LAYERS];
      varchar oname[FWDET_STRAW_MAX_GLOBAL_LAYERS][9];
    } mods;
    struct {
 	  short mod[FWDET_STRAW_MAX_GLOBAL_LAYERS];
      short lay[FWDET_STRAW_MAX_GLOBAL_LAYERS];
      short oname[FWDET_STRAW_MAX_GLOBAL_LAYERS];
    } mods_Ind;
  EXEC SQL END DECLARE SECTION;
  EXEC SQL WHENEVER SQLERROR DO showSqlError("readModGeomNames()");
  EXEC SQL WHENEVER NOT FOUND CONTINUE;
  EXEC SQL SELECT module_id, layer_id, geom_obj_name
    INTO :mods INDICATOR :mods_Ind
    FROM fwdet_ana2.straw_detector_setup_at_date;
  Int_t nMods=sqlca.sqlerrd[2]; // this field contains the number of rows that were processed
  Int_t s,m,l;
  Char_t ref[10];
  initModules->Reset();
  for(Int_t i=0;i<nMods;i++) {   // 0 < 8 (4 lay * 2 mods)
    m = mods.mod[i] -1;
    l = mods.lay[i] -1;
    s = m * FWDET_STRAW_MAX_LAYERS + l;
    //std::cout<< "HStsParOra2Io::readModGeomNames at s: "<<s<<" from mods:"<< mods.mod[i]<<". layer:"<<mods.lay[i] << std::endl;

    HModGeomPar* pMod=pPar->getModule(l,m);
    if (pMod && set[s]) {
      if (mods_Ind.oname[i]!=-1) {
        mods.oname[i].arr[mods.oname[i].len]='\0';
        //std::cout<< "HStsParOra2Io::readModGeomNames at "<<i<<" has name :"<< mods.oname[i].arr << std::endl;
        pMod->SetName((Char_t*)(mods.oname[i].arr));
        initModules->AddAt(s+1,s);
        Int_t refid=mods.mod[i]-1;
          HGeomCompositeVolume* refMod=pPar->getRefVolume(refid);
	    if (refMod==0) {
		  strcpy(ref,(Char_t*)(mods.oname[i].arr));
          refMod=new HGeomCompositeVolume(pPar->getNumComponents());
          refMod->SetName(ref);
          pPar->addRefVolume(refMod,refid);
         //std::cout<< "JAMSTSDEB: Add reference module for"<<i<<" to "<<ref<<std::endl;
	}
	
        pMod->setVolume(refMod);
        pMod->setRefName(ref);
	//std::cout<< "JAMSTSDEB: Reference module has set for"<<i<<" to "<<refMod->GetName()<<std::endl;
      }        
    }
  }
  Bool_t allFound=kTRUE;
  for(Int_t i=0;i<FWDET_STRAW_MAX_GLOBAL_LAYERS;i++) {
    if (set[i]>0 && initModules->At(i)==0) allFound=kFALSE;
  }
  //std::cout<< "HStsParOra2Io:readModGeomNames returns"<< allFound<< std::endl;
  return allFound;
}

Bool_t HStsParOra2Io::readCompGeomNames(HStsGeomPar* pPar,Int_t* set) {
  // reads the names of all cells in the geometry tables
  //std::cout<< "HStsParOra2Io:readCompGeomNames.... "<< std::endl;
  EXEC SQL BEGIN DECLARE SECTION;
    struct {
      int cell_index[FWDET_STRAW_MAX_LAYER_CELLS];
      int module[FWDET_STRAW_MAX_LAYER_CELLS];
      varchar oname[FWDET_STRAW_MAX_LAYER_CELLS][9];
    } lrecG;
  EXEC SQL END DECLARE SECTION;
  EXEC SQL WHENEVER SQLERROR DO showSqlError("readCompGeomNames(...)");
  EXEC SQL WHENEVER NOT FOUND CONTINUE;
  EXEC SQL SELECT cell_index, module_kind, geom_obj_name
    INTO :lrecG
    FROM fwdet_ana2.straw_layer_cell
    WHERE geom_obj_name IS NOT NULL;
  Int_t nCells=sqlca.sqlerrd[2];
  Int_t cell=-1;
  for(Int_t k=0;k<nCells;k++) {
    lrecG.oname[k].arr[lrecG.oname[k].len]='\0';
    TString cName((Char_t*)(lrecG.oname[k].arr));
      cell=pPar->getCompNum(cName); // JAM2021: note that we do _not_ use the Oracle internal cell_index, but a more dense index for TObjArray here
      Int_t refid=lrecG.module[k]-1;
      //std::cout<< "HStsParOra2Io::readCompGeomNames got at module kind "<<refid+1<<" the cell"<<cell<<" for :"<< cName.Data() << std::endl;
      HGeomCompositeVolume* pRefMod=pPar->getRefVolume(refid);
      if(pRefMod==0){
	std::cout<<"HStsParOra2Io::readCompGeomNames ERROR: no reference module for index"<<k<<", cell"<<cell<< std::endl;
	continue;
      }
      HGeomVolume* volu=pRefMod->getComponent(cell);
      if (volu){ 
    	  volu->SetName(cName);
      }
      else {
    	  Error("readCompGeomNames","Index for cell %s not found",cName.Data());
        return kFALSE;
      }
  }
  //std::cout<< "HStsParOra2Io:readCompGeomNames has read"<<nCells<<" cells."<< std::endl;
  return (nCells>0) ? kTRUE : kFALSE;
}




Int_t HStsParOra2Io::createVers(HParSet* pPar) {
  // creates a new version for parameters
  // returns the new version
  cout<<"---------------  "<<pPar->GetName()<<"   ---------------\n";
  if (strlen(pPar->getAuthor())==0) {
    Error("createVers(HParSet*)",
          "author of parameters not defined");
    return -1;
  }
  if (strlen(pPar->getDescription())==0) {
    Error("createVers(HParSet*)",
          "descriction of parameters not defined");
    return -1;
  }
  const Char_t* contName=pPar->IsA()->GetName();
  EXEC SQL BEGIN DECLARE SECTION;
    int   vers=-1;
    int   context;
    int   run;
    char* creator;
    char* descript;
  EXEC SQL END DECLARE SECTION;
  context = getContextId(contName,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,"HStsTrb3Lookup")==0) {
    EXEC SQL EXECUTE
      BEGIN
        SELECT fwdet_ana2.straw_par_query.next_version INTO :vers FROM DUAL;
        INSERT INTO fwdet_ana2.straw_trb3lookup_vers
                   (vers_id, orig_context_id, run_id, author, description)
            VALUES (:vers, :context, :run, :creator, :descript);
      END;
    END-EXEC;
  }
  else if (strcmp(contName,"HStsCalPar")==0) {
    EXEC SQL EXECUTE
      BEGIN
        SELECT fwdet_ana2.straw_par_query.next_version INTO :vers FROM DUAL;
        INSERT INTO fwdet_ana2.straw_calpar_vers
                   (vers_id, orig_context_id, run_id, author, description)
            VALUES (:vers, :context, :run, :creator, :descript);
      END;
    END-EXEC;
  }
  else { }
  cout<<"Oracle version for "<<pPar->GetName()<<" created:  "<<vers<<endl;
  return vers;
not_found:
  showSqlError("createVers(HParSet*)");
  return vers;
}


// TODO
Int_t HStsParOra2Io::writePar(HStsTrb3Lookup* pPar) {
  // creates a new version and writes the lookup table to Oracle
  cout <<"writePar(HStsTrb3Lookup* "<< endl;
  Int_t version=createVers(pPar);
  if (version==-1) return -1;
  EXEC SQL BEGIN DECLARE SECTION;
    int   rows_to_insert;
    int   vers[FWDET_STRAW_MAX_GLOBALCELLS];
    int   address[FWDET_STRAW_MAX_GLOBALCELLS];
    int   channel[FWDET_STRAW_MAX_GLOBALCELLS];
    int   module[FWDET_STRAW_MAX_GLOBALCELLS];
    int   layer [FWDET_STRAW_MAX_GLOBALCELLS];
    int   straw[FWDET_STRAW_MAX_GLOBALCELLS];
    int   updown[FWDET_STRAW_MAX_GLOBALCELLS];
  EXEC SQL END DECLARE SECTION;
  Int_t nChan=0;
  Int_t arrayOffset=pPar->getArrayOffset();


  for(Int_t t=0;t<pPar->getSize();t++) {
	  HStsTrb3LookupTdc* tdc=(*pPar)[t];
    if (tdc) {
      nChan=0;
      for(Int_t c=0;c<tdc->getSize();c++) {
    	  HStsTrb3LookupChan& rChan=(*tdc)[c];
        if (rChan.getModule()!=-1 && rChan.getLayer()!=-1 && rChan.getCell()!=-1  && rChan.getSubCell()!=-1) {
          vers[nChan]=version;
          address[nChan]=arrayOffset+t;
          channel[nChan]=c;
          module[nChan]=rChan.getModule() +1;
          layer[nChan]=rChan.getLayer() +1;
          straw[nChan]=rChan.getCell() +1;
          updown[nChan]=rChan.getSubCell();
          nChan++;
        }
      }

      rows_to_insert=nChan;

      EXEC SQL WHENEVER SQLERROR GOTO errorfound;
      EXEC SQL WHENEVER NOT FOUND GOTO errorfound;
      EXEC SQL FOR :rows_to_insert
      INSERT INTO fwdet_ana2.straw_trb3lookup_data
                  (vers_id, trbnet_address, channel_id, cell_id)
             VALUES (:vers,
            	     :address,
            	     :channel,
            	     fwdet_ana2.straw_par_query.get_cell_id(:module, :layer, :straw, :updown)
            	     );
      cout<<"Trbnet-address "<<"0x"<<hex<<(arrayOffset+t)<<dec<<":  "<<rows_to_insert<<" rows inserted\n";
    }
  }

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


// JAM TODO
Int_t HStsParOra2Io::writePar(HStsCalPar* pPar) {
  // creates a new version and writes the lookup table to Oracle
  Int_t version=createVers(pPar);
  if (version==-1) return -1;
  EXEC SQL BEGIN DECLARE SECTION;
   int module[FWDET_STRAW_MAX_GLOBALCELLS];
      int layer[FWDET_STRAW_MAX_GLOBALCELLS];
      int straw[FWDET_STRAW_MAX_GLOBALCELLS];
      int kind[FWDET_STRAW_MAX_GLOBALCELLS];
      int vers[FWDET_STRAW_MAX_GLOBALCELLS];
      float time_offset[FWDET_STRAW_MAX_GLOBALCELLS];
      float time_max[FWDET_STRAW_MAX_GLOBALCELLS];
      float time_slope[FWDET_STRAW_MAX_GLOBALCELLS]; 
      float tof_reference[FWDET_STRAW_MAX_GLOBALCELLS]; 
      float iso_par_0[FWDET_STRAW_MAX_GLOBALCELLS];
      float iso_par_1[FWDET_STRAW_MAX_GLOBALCELLS]; 
      float iso_par_2[FWDET_STRAW_MAX_GLOBALCELLS]; 
      float iso_par_3[FWDET_STRAW_MAX_GLOBALCELLS]; 
      float iso_par_4[FWDET_STRAW_MAX_GLOBALCELLS];
      float tot_par_0[FWDET_STRAW_MAX_GLOBALCELLS];
      float tot_par_1[FWDET_STRAW_MAX_GLOBALCELLS];
  int rows_to_insert;
  EXEC SQL END DECLARE SECTION;
  Int_t nRod=0;
  for(Int_t m=0; m<pPar->getSize(); m++) {
    HStsCalParMod& rMod=(*pPar)[m];   
    for(Int_t s=0; s<rMod.getSize(); s++) {
      HStsCalParSec& rSec= rMod[s];
      for(Int_t c=0; c<rSec.getSize() ; c++) {   
        //if(m==0 && c >= 159) continue;
	//if(m==1 && c >= 223) continue; // JAM workaround for fake input file
	 HStsCalParCell& rStraw= rSec[c];
         for(Int_t k=0; k<rStraw.getSize() ; k++) {  
	  HStsCalParCellKind& cell=rStraw[k];
	  if(cell.getTimeOffset() == 0.f) continue; // JAM- maybe better to have separate valid flag here?

	  module[nRod]=m+1;
	  layer[nRod]=s+1;
	  straw[nRod]=c+1;
	  kind[nRod]=k;
	  //printf ("Processing mod=%d, lay=%d, cell=%d kind=%d- time offset:%f \n", m+1,s+1,c+1, k, cell.getTimeOffset());
	  vers[nRod]=version;
	  time_offset[nRod]	= cell.getTimeOffset();
	  time_max[nRod]		= cell.getTimeMax();
	  time_slope[nRod]	= cell.getTimeSlope();
	  tof_reference[nRod]	= cell.getTofReference();
	  iso_par_0[nRod]	= cell.getIsoPar0();
	  iso_par_1[nRod]	= cell.getIsoPar1();
	  iso_par_2[nRod]	= cell.getIsoPar2();
	  iso_par_3[nRod]	= cell.getIsoPar3();
	  iso_par_4[nRod]	= cell.getIsoPar4() ;
	  tot_par_0[nRod]	= cell.getTotPar0();
	  tot_par_1[nRod]	= cell.getTotPar1();   
	  nRod++;
	 }
      }
    }
  }
  rows_to_insert=nRod;
  EXEC SQL WHENEVER SQLERROR GOTO not_found;
  EXEC SQL WHENEVER NOT FOUND GOTO not_found;
  EXEC SQL FOR :rows_to_insert
     INSERT INTO fwdet_ana2.straw_calpar_data
                  (vers_id, cell_id, 	   
		   time_offset, time_max, time_slope, tof_reference, 
		   iso_par_0, iso_par_1, iso_par_2, iso_par_3, iso_par_4, 
		   tot_par_0,tot_par_1  
		  )
             VALUES (:vers,
            	     fwdet_ana2.straw_par_query.get_cell_id(:module, :layer, :straw, :kind),
		     :time_offset, :time_max, :time_slope, :tof_reference,
		     :iso_par_0, :iso_par_1,:iso_par_2, :iso_par_3, :iso_par_4,
		     :tot_par_0, :tot_par_1
            	     );
  cout<<rows_to_insert<<" rows inserted\n";
  commit();
  pPar->setChanged(kFALSE);
  return version;
not_found:
  showSqlError("writePar(HStsCalPar*)");
  rollback();
  pPar->setChanged(kFALSE);
  return -1;
}


void HStsParOra2Io::printInfo(const Char_t* contName) {
  // prints the sectors initialized from Oracle
  Bool_t first=kTRUE;
  for(Int_t i=0;i<FWDET_STRAW_MAX_GLOBAL_LAYERS;i++) {
    if (initModules->At(i)) {
      if (first) {
        cout<<contName<<": layer initialized from Oracle: ";
        first=kFALSE;
      }
      cout<<i<<" ";
    }
  }
  cout<<'\n';
}