//_HADES_CLASS_DESCRIPTION
//////////////////////////////////////////////////////////////////////////////
// HFRpcParOra2Io
//
// 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 "hfrpcparora2io.h"
#include "hparora2set.h"
#include "hfrpctrb3lookup.h"
#include "hfrpcgeompar.h"
#include "hfrpccalpar.h"
#include "hfrpcstrippar.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 FRPC_MAX_SECTORS    4
#define FRPC_MAX_MODULES    1
#define FRPC_MAX_COLUMNS    2
#define FRPC_MAX_STRIPS     32
#define FRPC_MAX_NFCONF     2

#define FRPC_MAX_GLOBALCELLS \
		FRPC_MAX_SECTORS * FRPC_MAX_COLUMNS * FRPC_MAX_STRIPS * FRPC_MAX_NFCONF

// = 512

#define FRPC_MAX_GLOBAL_LAYERS FRPC_MAX_SECTORS * FRPC_MAX_MODULES * FRPC_MAX_COLUMNS
#define FRPC_MAX_LAYER_CELLS FRPC_MAX_STRIPS * FRPC_MAX_NFCONF

#define FRPC_STRIPPAR_ZONES 25
// redefine here to avoid trouble with const int arrays and ora precompiler JAM22


#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(HFRpcParOra2Io)

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

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

Bool_t HFRpcParOra2Io::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,"HFRpcTrb3Lookup")==0) return read(((HFRpcTrb3Lookup*)pPar));
  if (strcmp(name,"HFRpcCalPar")==0) return read(((HFRpcCalPar*)pPar));
  if (strcmp(name,"HFRpcStripPar")==0) return read(((HFRpcStripPar*)pPar));
  if (strcmp(name,"HFRpcGeomPar")==0)    return read(((HFRpcGeomPar*)pPar),set);
  cout<<"No read-interface to Oracle for parameter container "
      <<pPar->GetName()<<endl;
  return kFALSE;
}

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

Bool_t HFRpcParOra2Io::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,"HFRpcTrb3Lookup")==0) {
    EXEC SQL SELECT version,
                    hanadate.date_to_number(valid_since),
                    hanadate.date_to_number(valid_until)
            INTO :vers, :since, :until
            FROM fwdet_ana2.frpc_trb3lookup_vers_at_date
            WHERE context_id = :context;
  }
  else if (strcmp(containerClass,"HFRpcCalPar")==0) {
    EXEC SQL SELECT version,
                    hanadate.date_to_number(valid_since),
                    hanadate.date_to_number(valid_until)
            INTO :vers, :since, :until
            FROM fwdet_ana2.frpc_calpar_vers_at_date
            WHERE context_id = :context;
  }
  else if (strcmp(containerClass,"HFRpcStripPar")==0) {
    EXEC SQL SELECT version,
                    hanadate.date_to_number(valid_since),
                    hanadate.date_to_number(valid_until)
            INTO :vers, :since, :until
            FROM fwdet_ana2.frpc_strippar_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 HFRpcParOra2Io::read(HFRpcTrb3Lookup* 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;
    struct {
      int  address[FRPC_MAX_GLOBALCELLS];
      int  channel[FRPC_MAX_GLOBALCELLS];
      int  sector[FRPC_MAX_GLOBALCELLS];
      int  column[FRPC_MAX_GLOBALCELLS];
      int  strip[FRPC_MAX_GLOBALCELLS];
      char  side[FRPC_MAX_GLOBALCELLS][2];
    } lookup;
    
    struct {
    	short address_Ind[FRPC_MAX_GLOBALCELLS];
    	short chan_Ind[FRPC_MAX_GLOBALCELLS];
    	short sector_Ind[FRPC_MAX_GLOBALCELLS];
    	short col_Ind[FRPC_MAX_GLOBALCELLS];
    	short strip_Ind[FRPC_MAX_GLOBALCELLS];
    	short side_Ind[FRPC_MAX_GLOBALCELLS];
       } lookup_Ind;
    
    
  EXEC SQL END DECLARE SECTION;
  vers=oraVersion;
  EXEC SQL WHENEVER SQLERROR DO showSqlError("read(HFRpcTrb3Lookup*)");
  EXEC SQL WHENEVER NOT FOUND CONTINUE;
  EXEC SQL SELECT trbnet_address, channel,
                  module, layer, strip, side
           INTO :lookup INDICATOR :lookup_Ind
           FROM fwdet_ana2.frpc_trb3lookup_data_view
           WHERE vers_id = :vers;
  Int_t nData=sqlca.sqlerrd[2];
  for (Int_t i=0;i<nData;i++) {
	      Char_t s='\0';
	      if (lookup_Ind.side_Ind[i]!=-1) {
	        s=lookup.side[i][0];
	      }
	  
	  
    pPar->fill(lookup.address[i],lookup.channel[i],
               lookup.sector[i]-1,lookup.column[i]-1, lookup.strip[i]-1, s);
  }
  rc=kTRUE;
  if (nData>0) {
    setChanged(pPar,oraVersion);
    cout<<pPar->GetName()<<" initialized from Oracle"<<endl;
  } else {
    pPar->setInputVersion(-1,inputNumber);
    rc=kFALSE;
  }
  return rc;
}
//
//// TODO JAM
//

Bool_t HFRpcParOra2Io::read(HFRpcCalPar* 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 sector[FRPC_MAX_GLOBALCELLS];
      int layer[FRPC_MAX_GLOBALCELLS];
      int strip[FRPC_MAX_GLOBALCELLS];
      float q_threshold_n[FRPC_MAX_GLOBALCELLS];
      float q_threshold_f[FRPC_MAX_GLOBALCELLS];
      float time_offset[FRPC_MAX_GLOBALCELLS];
      float pos_offset[FRPC_MAX_GLOBALCELLS];
      float prop_corr[FRPC_MAX_GLOBALCELLS];
      float twc_par_0[FRPC_MAX_GLOBALCELLS];
      float twc_par_1[FRPC_MAX_GLOBALCELLS];
      float twc_par_2[FRPC_MAX_GLOBALCELLS];
    } cal;
    struct {
      short sector[FRPC_MAX_GLOBALCELLS];
      short layer[FRPC_MAX_GLOBALCELLS];
      short strip[FRPC_MAX_GLOBALCELLS];
      short q_threshold_n[FRPC_MAX_GLOBALCELLS];
      short q_threshold_f[FRPC_MAX_GLOBALCELLS];
      short time_offset[FRPC_MAX_GLOBALCELLS];
      short pos_offset[FRPC_MAX_GLOBALCELLS];
      short prop_corr[FRPC_MAX_GLOBALCELLS];
      short twc_par_0[FRPC_MAX_GLOBALCELLS];
      short twc_par_1[FRPC_MAX_GLOBALCELLS];
      short twc_par_2[FRPC_MAX_GLOBALCELLS];
    } cal_Ind;
    
     EXEC SQL END DECLARE SECTION;
  vers=oraVersion;
  EXEC SQL WHENEVER SQLERROR DO showSqlError("read(HFRpcCalPar*,Int_t*)");
  EXEC SQL WHENEVER NOT FOUND CONTINUE;
  EXEC SQL SELECT sector, column_number, strip_number,
                  q_threshold_n, q_threshold_f, time_offset, pos_offset, prop_corr,
                  twc_par_0, twc_par_1, twc_par_2
           INTO :cal INDICATOR :cal_Ind
           FROM fwdet_ana2.frpc_calpar_data_view
           WHERE vers_id = :vers;
  Int_t nData=sqlca.sqlerrd[2];
  Int_t sec=-1, mod=-1, pos=-1;
  for(Int_t i=0;i<nData;i++) {
    sec=cal.sector[i]-1;
    globalstrip=(cal.layer[i]-1) * 16 + (cal.strip[i] -1);
// JAM disable check for completeness for the moment...    
//     pos=sec* FRPC_MAX_STRIPS + globalstrip;
//     
//     if (set[pos]) 
    {
      HFRpcCalParCell& cell=(*pPar)[sec][globalstrip];
      cell.setQthresholdN(cal.q_threshold_n[i]);
      cell.setQthresholdF(cal.q_threshold_f[i]);
      cell.setTimeOffset(cal.time_offset[i]);
      cell.setPosOffset(cal.pos_offset[i]); 
      cell.setPropCorr(cal.prop_corr[i]); 
      cell.setTwcPar0(cal.twc_par_0[i]);
      cell.setTwcPar1(cal.twc_par_1[i]);
      cell.setTwcPar2(cal.twc_par_2[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;
    

    

}

Bool_t HFRpcParOra2Io::read(HFRpcStripPar* 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 sector[FRPC_MAX_GLOBALCELLS];
      int layer[FRPC_MAX_GLOBALCELLS];
      int strip[FRPC_MAX_GLOBALCELLS];
      // JAM 28.05. not clever, but don't know if oracle precompiler can handle 2d array...
      float strip_par_00[FRPC_MAX_GLOBALCELLS];
      float strip_par_01[FRPC_MAX_GLOBALCELLS];
      float strip_par_02[FRPC_MAX_GLOBALCELLS];
      float strip_par_03[FRPC_MAX_GLOBALCELLS];
      float strip_par_04[FRPC_MAX_GLOBALCELLS];
      float strip_par_05[FRPC_MAX_GLOBALCELLS];
      float strip_par_06[FRPC_MAX_GLOBALCELLS];
      float strip_par_07[FRPC_MAX_GLOBALCELLS];
      float strip_par_08[FRPC_MAX_GLOBALCELLS];
      float strip_par_09[FRPC_MAX_GLOBALCELLS];
      float strip_par_10[FRPC_MAX_GLOBALCELLS];
      float strip_par_11[FRPC_MAX_GLOBALCELLS];
      float strip_par_12[FRPC_MAX_GLOBALCELLS];
      float strip_par_13[FRPC_MAX_GLOBALCELLS];
      float strip_par_14[FRPC_MAX_GLOBALCELLS];
      float strip_par_15[FRPC_MAX_GLOBALCELLS];
      float strip_par_16[FRPC_MAX_GLOBALCELLS];
      float strip_par_17[FRPC_MAX_GLOBALCELLS];
      float strip_par_18[FRPC_MAX_GLOBALCELLS];
      float strip_par_19[FRPC_MAX_GLOBALCELLS];
      float strip_par_20[FRPC_MAX_GLOBALCELLS];
      float strip_par_21[FRPC_MAX_GLOBALCELLS];
      float strip_par_22[FRPC_MAX_GLOBALCELLS];
      float strip_par_23[FRPC_MAX_GLOBALCELLS];
      float strip_par_24[FRPC_MAX_GLOBALCELLS];
    } cal;
    struct {
      short sector[FRPC_MAX_GLOBALCELLS];
      short layer[FRPC_MAX_GLOBALCELLS];
      short strip[FRPC_MAX_GLOBALCELLS];
      short strip_par_00[FRPC_MAX_GLOBALCELLS];
      short strip_par_01[FRPC_MAX_GLOBALCELLS];
      short strip_par_02[FRPC_MAX_GLOBALCELLS];
      short strip_par_03[FRPC_MAX_GLOBALCELLS];
      short strip_par_04[FRPC_MAX_GLOBALCELLS];
      short strip_par_05[FRPC_MAX_GLOBALCELLS];
      short strip_par_06[FRPC_MAX_GLOBALCELLS];
      short strip_par_07[FRPC_MAX_GLOBALCELLS];
      short strip_par_08[FRPC_MAX_GLOBALCELLS];
      short strip_par_09[FRPC_MAX_GLOBALCELLS];
      short strip_par_10[FRPC_MAX_GLOBALCELLS];
      short strip_par_11[FRPC_MAX_GLOBALCELLS];
      short strip_par_12[FRPC_MAX_GLOBALCELLS];
      short strip_par_13[FRPC_MAX_GLOBALCELLS];
      short strip_par_14[FRPC_MAX_GLOBALCELLS];
      short strip_par_15[FRPC_MAX_GLOBALCELLS];
      short strip_par_16[FRPC_MAX_GLOBALCELLS];
      short strip_par_17[FRPC_MAX_GLOBALCELLS];
      short strip_par_18[FRPC_MAX_GLOBALCELLS];
      short strip_par_19[FRPC_MAX_GLOBALCELLS];
      short strip_par_20[FRPC_MAX_GLOBALCELLS];
      short strip_par_21[FRPC_MAX_GLOBALCELLS];
      short strip_par_22[FRPC_MAX_GLOBALCELLS];
      short strip_par_23[FRPC_MAX_GLOBALCELLS];
      short strip_par_24[FRPC_MAX_GLOBALCELLS];
     
    } cal_Ind;
    
     EXEC SQL END DECLARE SECTION;
  vers=oraVersion;
  EXEC SQL WHENEVER SQLERROR DO showSqlError("read(HFRpcCalPar*,Int_t*)");
  EXEC SQL WHENEVER NOT FOUND CONTINUE;
  EXEC SQL SELECT sector, column_number, strip_number,
                 strip_par_00,  strip_par_01, strip_par_02, strip_par_03,  strip_par_04,
		 strip_par_05,  strip_par_06, strip_par_07,  strip_par_08, strip_par_09,
		 strip_par_10,  strip_par_11, strip_par_12,  strip_par_13, strip_par_14,
		 strip_par_15,  strip_par_16, strip_par_17,  strip_par_18,  strip_par_19, 
		 strip_par_20,  strip_par_21, strip_par_22,  strip_par_23,  strip_par_24 
                  
           INTO :cal INDICATOR :cal_Ind
           FROM fwdet_ana2.frpc_strippar_data_view
           WHERE vers_id = :vers;
  Int_t nData=sqlca.sqlerrd[2];
  Int_t sec=-1, mod=-1, pos=-1;
  Float_t data[FRPC_STRIPPAR_ZONES];
  for(Int_t i=0;i<nData;i++) {
    sec=cal.sector[i]-1;
    globalstrip=(cal.layer[i]-1) * 16 + (cal.strip[i] -1);
// JAM disable check for completeness for the moment...    
//     pos=sec* FRPC_MAX_STRIPS + globalstrip;
//     
//     if (set[pos]) 
    {
      HFRpcStripParCell& cell=(*pPar)[sec][globalstrip];
      // JAM TODO: check if we can do this better with ora precompiler?
      data[0]=cal.strip_par_00[i];
      data[1]=cal.strip_par_01[i];
      data[2]=cal.strip_par_02[i];
      data[3]=cal.strip_par_03[i];
      data[4]=cal.strip_par_04[i];
      data[5]=cal.strip_par_05[i];
      data[6]=cal.strip_par_06[i];
      data[7]=cal.strip_par_07[i];
      data[8]=cal.strip_par_08[i];
      data[9]=cal.strip_par_09[i];
      data[10]=cal.strip_par_10[i];
      data[11]=cal.strip_par_11[i];
      data[12]=cal.strip_par_12[i];
      data[13]=cal.strip_par_13[i];
      data[14]=cal.strip_par_14[i];
      data[15]=cal.strip_par_15[i];
      data[16]=cal.strip_par_16[i];
      data[17]=cal.strip_par_17[i];
      data[18]=cal.strip_par_18[i];
      data[19]=cal.strip_par_19[i];
      data[20]=cal.strip_par_20[i];
      data[21]=cal.strip_par_21[i];
      data[22]=cal.strip_par_22[i];
      data[23]=cal.strip_par_23[i];
      data[24]=cal.strip_par_24[i];
  
      cell.fill(data);
      
      
      
      //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 HFRpcParOra2Io::read(HFRpcGeomPar* pPar, Int_t* set) {
  // reads the geometry of the FRpc and fills the FRpcGeomPar container
  Bool_t allFound=kTRUE;
  Int_t detId=-1;
  if (!geomVers) {
    detId=getDetectorId(pPar->getDetectorName());
    //std::cout<< "HFRpcParOra2Io::read HFRpcGeomPar got id"<<detId<<" for detector"<< pPar->getDetectorName() << std::endl;
    geomVers=new HOra2GeomDetVersion(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) || !readCompGeomNames(pPar,set)) {
      allFound=kFALSE;
      pPar->clear();
      //std::cout<< "HFRpcParOra2Io::read HStsGeomPar failed after readModGeomNames or readCompGeomNames"<< std::endl;
  
    } else addGeomOraSet(pPar);
  }
  if (allFound) allFound=readDetectorGeometry(pPar,set,geomVers);
  //std::cout<< "HFRpcParOra2Io::read HStsGeomPar returns"<<allFound << std::endl;
  return allFound;
}

Bool_t HFRpcParOra2Io::readModGeomNames(HFRpcGeomPar* pPar,Int_t* set) {
  // reads the GEANT geometry names of all modules and layers
  EXEC SQL BEGIN DECLARE SECTION;
    struct {
      int mod[FRPC_MAX_GLOBAL_LAYERS];
      int lay[FRPC_MAX_GLOBAL_LAYERS];
      varchar oname[FRPC_MAX_GLOBAL_LAYERS][9];
    } mods;
    struct {
 	  short mod[FRPC_MAX_GLOBAL_LAYERS];
      short lay[FRPC_MAX_GLOBAL_LAYERS];
      short oname[FRPC_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 DISTINCT module_id, geom_obj_name // JAM- distinct will not work for INDICATOR? so leave it
  EXEC SQL SELECT module_id, layer_id, geom_obj_name
    INTO :mods INDICATOR :mods_Ind
    FROM fwdet_ana2.frpc_detector_setup_at_date
	;
  Int_t nMods=sqlca.sqlerrd[2]; // this field contains the number of rows that were processed
  Int_t s;
  Char_t ref[10];
  initModules->Reset();
  for(Int_t i=0;i<nMods;i++) {
	  s=mods.mod[i] -1; // layer=column does not change module name here, reduce index
	  //std::cout<< "HFRpcParOra2Io::readModGeomNames at s: "<<s<<" from mods:"<< mods.mod[i]<<". layer:"<<mods.lay[i] << std::endl;
    HModGeomPar* pMod=pPar->getModule(s);
    //std::cout<< "HFRpcParOra2Io::readModGeomNames has set[s]="<<set[s] <<", pmod is"<< std::hex<< (long) pMod << std::dec<< std::endl;
    if (pMod && set[s]) {
      if (mods_Ind.oname[i]!=-1) {
        mods.oname[i].arr[mods.oname[i].len]='\0';
        //std::cout<< "HFRpcParOra2Io::readModGeomNames at "<<i<<" has name :"<< mods.oname[i].arr << std::endl;
        pMod->SetName((Char_t*)(mods.oname[i].arr));
        initModules->AddAt(s+1,s); // JAM- this will be done twice, but does not hurt in the end

         // TODO: clarify meaning of reference module in this example!
        // for the moment, take first module in setup as reference module?
        HGeomCompositeVolume* refMod=pPar->getRefVolume(0);
        if (refMod==0) {
		  strcpy(ref,(Char_t*)(mods.oname[i].arr));
          refMod=new HGeomCompositeVolume(pPar->getNumComponents());
          refMod->SetName(ref);
          pPar->addRefVolume(refMod,0);
        }
	pMod->setVolume(refMod);
        pMod->setRefName(ref);
      }
       
    }
  }
  Bool_t allFound=kTRUE;
  //for(Int_t i=0;i<FRPC_MAX_GLOBAL_LAYERS;i++) {
  for(Int_t i=0;i<FRPC_MAX_SECTORS;i++) { // one module per sector, column partition does not count here (?) 
    if (set[i]>0 && initModules->At(i)==0) allFound=kFALSE;
  }
  //std::cout<< "HFRpcParOra2Io:readModGeomNames returns"<< allFound<< std::endl;
  return allFound;
}

Bool_t HFRpcParOra2Io::readCompGeomNames(HFRpcGeomPar* pPar,Int_t* set) {
  // reads the names of all cells in the geometry tables
  EXEC SQL BEGIN DECLARE SECTION;
    struct {
      int cell_index[FRPC_MAX_LAYER_CELLS];
      varchar oname[FRPC_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, geom_obj_name
    INTO :lrecG
    FROM fwdet_ana2.frpc_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
      //std::cout<< "FRpcParOra2Io::readCompGeomNames got cell"<<cell<<" for :"<< cName.Data() << std::endl;
      HGeomCompositeVolume* pRefMod=pPar->getRefVolume(0);
      if(pRefMod==0){
	std::cout<<"FRpcParOra2Io::readCompGeomNames ERROR: no reference module for index"<<k<<", cell"<<cell<< std::endl;
	continue;
      }
      HGeomVolume* volu=pRefMod->getComponent(cell);
      if (volu){ 
    	  volu->SetName(cName); // JAM - this will also be done twice here, since we have same name for both lr_side. does not matter.
      }
      else {
    	  Error("readCompGeomNames","Index for cell %s not found",cName.Data());
        return kFALSE;
      }
  
  }
  //std::cout<< "FRpcParOra2Io::readCompGeomNames has read"<<nCells<<" cells."<< std::endl;
  return (nCells>0) ? kTRUE : kFALSE;
}








Int_t HFRpcParOra2Io::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,"HFRpcTrb3Lookup")==0) {
    EXEC SQL EXECUTE
      BEGIN
        SELECT fwdet_ana2.frpc_par_query.next_version INTO :vers FROM DUAL;
        INSERT INTO fwdet_ana2.frpc_trb3lookup_vers
                   (vers_id, orig_context_id, run_id, author, description)
            VALUES (:vers, :context, :run, :creator, :descript);
      END;
    END-EXEC;
  }
else if (strcmp(contName,"HFRpcCalPar")==0) {
    EXEC SQL EXECUTE
      BEGIN
        SELECT fwdet_ana2.frpc_par_query.next_version INTO :vers FROM DUAL;
        INSERT INTO fwdet_ana2.frpc_calpar_vers
                   (vers_id, orig_context_id, run_id, author, description)
            VALUES (:vers, :context, :run, :creator, :descript);
      END;
    END-EXEC;
  }
  else if (strcmp(contName,"HFRpcStripPar")==0) {
    EXEC SQL EXECUTE
      BEGIN
        SELECT fwdet_ana2.frpc_par_query.next_version INTO :vers FROM DUAL;
        INSERT INTO fwdet_ana2.frpc_strippar_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;
}

Int_t HFRpcParOra2Io::writePar(HFRpcTrb3Lookup* pPar) {
  // creates a new version and writes the lookup table to Oracle
  cout <<"writePar(HFRpcTrb3Lookup* "<< endl;
  Int_t version=createVers(pPar); 
  //cout <<"Got version "<<version<< endl;
  if (version==-1) return -1;
  EXEC SQL BEGIN DECLARE SECTION;
    int   rows_to_insert;
    int   vers[FRPC_MAX_GLOBALCELLS];
    int   address[FRPC_MAX_GLOBALCELLS];
    int   channel[FRPC_MAX_GLOBALCELLS];
    int   sector[FRPC_MAX_GLOBALCELLS];
    int   column[FRPC_MAX_GLOBALCELLS];
    int   strip[FRPC_MAX_GLOBALCELLS];
    char  side[FRPC_MAX_GLOBALCELLS][2];
    short side_Ind[FRPC_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++) {
	  HFRpcTrb3LookupTdc* tdc=(*pPar)[t];
    if (tdc) {
      nChan=0;
      for(Int_t c=0;c<tdc->getSize();c++) {
    	  HFRpcTrb3LookupChan& rChan=(*tdc)[c];
        if (rChan.getSector()!=-1 && rChan.getColumn()!=-1 && rChan.getStrip()!=-1  && rChan.getSide()!=-1) {
          vers[nChan]=version;
          address[nChan]=arrayOffset+t;
          channel[nChan]=c;
          sector[nChan]=rChan.getSector() +1;
          column[nChan]=rChan.getColumn() +1;
          strip[nChan]=rChan.getStrip() +1;
          side[nChan][0]=rChan.getSide();
          if (side[nChan][0]!='\0') {
        	  	  side[nChan][1]='\0';
        	  	  side_Ind[nChan]=0;
          	  } 
          else { 
        	  side_Ind[nChan]=-1;
          	  	}
          
          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.frpc_trb3lookup_data
                  (vers_id, trbnet_address, channel_id, cell_id)
             VALUES (:vers,
            	     :address,
            	     :channel,
            	     fwdet_ana2.frpc_par_query.get_cell_id(:sector, :column, :strip,  :side:side_Ind)
            	     );
      cout<<"Trbnet-address "<<"0x"<<hex<<(arrayOffset+t)<<dec<<":  "<<rows_to_insert<<" rows inserted\n";
    }
  }

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



Int_t HFRpcParOra2Io::writePar(HFRpcCalPar* 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 sector[FRPC_MAX_GLOBALCELLS];
  int globcell[FRPC_MAX_GLOBALCELLS];
  int layer[FRPC_MAX_GLOBALCELLS];
  int strip[FRPC_MAX_GLOBALCELLS];
  char  side[FRPC_MAX_GLOBALCELLS][2];
  short side_Ind[FRPC_MAX_GLOBALCELLS];
  
   int vers[FRPC_MAX_GLOBALCELLS];
  float q_threshold_n[FRPC_MAX_GLOBALCELLS];
  float q_threshold_f[FRPC_MAX_GLOBALCELLS];
  float time_offset[FRPC_MAX_GLOBALCELLS];
  float pos_offset[FRPC_MAX_GLOBALCELLS];
  float prop_corr[FRPC_MAX_GLOBALCELLS];
  float twc_par_0[FRPC_MAX_GLOBALCELLS];
  float twc_par_1[FRPC_MAX_GLOBALCELLS];
  float twc_par_2[FRPC_MAX_GLOBALCELLS];
  int rows_to_insert;
  EXEC SQL END DECLARE SECTION;
  Int_t nRod=0;
  for(Int_t s=0; s<pPar->getSize(); s++) {
    HFRpcCalParSec& rSec= (*pPar)[s];
    for(Int_t c=0; c<rSec.getSize() && c<FRPC_MAX_GLOBALCELLS; c++) {     
        HFRpcCalParCell& cell= rSec[c];
        sector[nRod]=s+1;
      
        globcell[nRod]=c; // global cell index in sector here!
        layer[nRod]= (int) (globcell[nRod] / 16) +1;
	strip[nRod]= (globcell[nRod] % 16) +1; // back to logic of trb3 lookup cells JAM 22
        side[nRod][0]='n'; // we fake the near/far size info which is redundant for calibration par JAM22
	side[nRod][1]='\0';
        side_Ind[nRod]=0;
        
        vers[nRod]=version;
	q_threshold_n[nRod]=cell.getQthresholdN();
        q_threshold_f[nRod]=cell.getQthresholdF();
        time_offset[nRod]=cell.getTimeOffset();
        pos_offset[nRod]=cell.getPosOffset();
	prop_corr[nRod]=cell.getPropCorr();
	twc_par_0[nRod]=cell.getTwcPar0();
	twc_par_1[nRod]=cell.getTwcPar1();
	twc_par_2[nRod]=cell.getTwcPar2();	
        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.frpc_calpar_data
                  (vers_id, cell_id, 
		   q_threshold_n, q_threshold_f, time_offset, pos_offset,prop_corr,
		    twc_par_0, twc_par_1, twc_par_2
		  )
             VALUES (:vers,
            	     fwdet_ana2.frpc_par_query.get_cell_id(:sector, :layer, :strip, :side:side_Ind),
		     :q_threshold_n, :q_threshold_f, :time_offset, :pos_offset,
		     :prop_corr, :twc_par_0, :twc_par_1, :twc_par_2
            	     );
  cout<<rows_to_insert<<" rows inserted\n";
  commit();
  pPar->setChanged(kFALSE);
  return version;
not_found:
  showSqlError("writePar(HFRpcCalPar*)");
  rollback();
  pPar->setChanged(kFALSE);
  return -1;
}

Int_t HFRpcParOra2Io::writePar(HFRpcStripPar* 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 sector[FRPC_MAX_GLOBALCELLS];
  int globcell[FRPC_MAX_GLOBALCELLS];
  int layer[FRPC_MAX_GLOBALCELLS];
  int strip[FRPC_MAX_GLOBALCELLS];
  char  side[FRPC_MAX_GLOBALCELLS][2];
  short side_Ind[FRPC_MAX_GLOBALCELLS];
  
   int vers[FRPC_MAX_GLOBALCELLS];
   
   
   // JAM TODO 28.05.
   float strip_par_00[FRPC_MAX_GLOBALCELLS];
  float strip_par_01[FRPC_MAX_GLOBALCELLS];
  float strip_par_02[FRPC_MAX_GLOBALCELLS];
  float strip_par_03[FRPC_MAX_GLOBALCELLS];
  float strip_par_04[FRPC_MAX_GLOBALCELLS];
  float strip_par_05[FRPC_MAX_GLOBALCELLS];
  float strip_par_06[FRPC_MAX_GLOBALCELLS];
  float strip_par_07[FRPC_MAX_GLOBALCELLS];
  float strip_par_08[FRPC_MAX_GLOBALCELLS];
  float strip_par_09[FRPC_MAX_GLOBALCELLS];
  float strip_par_10[FRPC_MAX_GLOBALCELLS];
  float strip_par_11[FRPC_MAX_GLOBALCELLS];
  float strip_par_12[FRPC_MAX_GLOBALCELLS];
  float strip_par_13[FRPC_MAX_GLOBALCELLS];
  float strip_par_14[FRPC_MAX_GLOBALCELLS];
  float strip_par_15[FRPC_MAX_GLOBALCELLS];
  float strip_par_16[FRPC_MAX_GLOBALCELLS];
  float strip_par_17[FRPC_MAX_GLOBALCELLS];
  float strip_par_18[FRPC_MAX_GLOBALCELLS];
  float strip_par_19[FRPC_MAX_GLOBALCELLS];
  float strip_par_20[FRPC_MAX_GLOBALCELLS];
  float strip_par_21[FRPC_MAX_GLOBALCELLS];
  float strip_par_22[FRPC_MAX_GLOBALCELLS];
  float strip_par_23[FRPC_MAX_GLOBALCELLS];
  float strip_par_24[FRPC_MAX_GLOBALCELLS];

 
  int rows_to_insert;
  EXEC SQL END DECLARE SECTION;
  Int_t nRod=0;
  Float_t fData[FRPC_STRIPPAR_ZONES];
  for(Int_t s=0; s<pPar->getSize(); s++) {
    HFRpcStripParSec& rSec= (*pPar)[s];
    for(Int_t c=0; c<rSec.getSize() && c<FRPC_MAX_GLOBALCELLS; c++) {     
        HFRpcStripParCell& cell= rSec[c];
        sector[nRod]=s+1;
      
        globcell[nRod]=c; // global cell index in sector here!
        layer[nRod]= (int) (globcell[nRod] / 16) +1;
	strip[nRod]= (globcell[nRod] % 16) +1; // back to logic of trb3 lookup cells JAM 22
        side[nRod][0]='n'; // we fake the near/far size info which is redundant for calibration par JAM22
	side[nRod][1]='\0';
        side_Ind[nRod]=0;
        
        vers[nRod]=version;
	cell.getData(fData);
	strip_par_00[nRod]=fData[0];
	strip_par_01[nRod]=fData[1];
	strip_par_02[nRod]=fData[2];
	strip_par_03[nRod]=fData[3];
	strip_par_04[nRod]=fData[4];
	strip_par_05[nRod]=fData[5];
	strip_par_06[nRod]=fData[6];
	strip_par_07[nRod]=fData[7];
	strip_par_08[nRod]=fData[8];
	strip_par_09[nRod]=fData[9];
	strip_par_10[nRod]=fData[10];
	strip_par_11[nRod]=fData[11];
	strip_par_12[nRod]=fData[12];
	strip_par_13[nRod]=fData[13];
	strip_par_14[nRod]=fData[14];
	strip_par_15[nRod]=fData[15];
	strip_par_16[nRod]=fData[16];
	strip_par_17[nRod]=fData[17];
	strip_par_18[nRod]=fData[18];
	strip_par_19[nRod]=fData[19];
	strip_par_20[nRod]=fData[20];
	strip_par_21[nRod]=fData[21];
	strip_par_22[nRod]=fData[22];
	strip_par_23[nRod]=fData[23];
	strip_par_24[nRod]=fData[24];
        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.frpc_strippar_data
                  (vers_id, cell_id, 
		    strip_par_00,
		    strip_par_01,
		    strip_par_02,
		    strip_par_03, 
		    strip_par_04,
		    strip_par_05,
		    strip_par_06,
		    strip_par_07, 
		    strip_par_08,
		    strip_par_09,
		    strip_par_10,
		    strip_par_11, 
		    strip_par_12,
		    strip_par_13,
		    strip_par_14,
		    strip_par_15,  
		    strip_par_16,
		    strip_par_17,
		    strip_par_18,
		    strip_par_19, 
		    strip_par_20,
		    strip_par_21,
		    strip_par_22,
		    strip_par_23, 
		    strip_par_24  )
             VALUES (:vers,
            	     fwdet_ana2.frpc_par_query.get_cell_id(:sector, :layer, :strip, :side:side_Ind),
		     :strip_par_00, :strip_par_01, :strip_par_02, :strip_par_03, :strip_par_04,
		     :strip_par_05, :strip_par_06, :strip_par_07, :strip_par_08, :strip_par_09,
		     :strip_par_10, :strip_par_11, :strip_par_12, :strip_par_13, :strip_par_14,
		     :strip_par_15, :strip_par_16, :strip_par_17, :strip_par_18, :strip_par_19,
		     :strip_par_20, :strip_par_21, :strip_par_22, :strip_par_23, :strip_par_24
            	     );
  cout<<rows_to_insert<<" rows inserted\n";
  commit();
  pPar->setChanged(kFALSE);
  return version;
not_found:
  showSqlError("writePar(HFRpcStripPar*)");
  rollback();
  pPar->setChanged(kFALSE);
  return -1;
}



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