//*-- AUTHOR : Ilse Koenig
//*-- created :  13/06/2002 by I.Koenig
//*-- Modified : 04/08/2007 by I.Koenig

//_HADES_CLASS_DESCRIPTION 
//////////////////////////////////////////////////////////////////////////////
// HSpecParOraIo
//
// Interface class to database Oracle for input/output of parameters needed
// by the Kickplane
// (uses the Oracle C/C++ precompiler)
//
//////////////////////////////////////////////////////////////////////////////
using namespace std;
#include "hkickparoraio.h"
#include "hades.h"
#include "hruntimedb.h"
#include "hrun.h"
#include "hkickplane2.h"
#include "hkickmatchpar.h"
#include "hkicktrackfpar.h"
#include "hsurface.h"
#include "hkickgrid.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(HKickParOraIo)

#define KICK_PARTS 2
#define KICK_MAXSURFACEPAR 10
#define KICK_MAXARRAY 9000

HKickParOraIo::HKickParOraIo(HOraConn* pC) : HDetParOraIo(pC) {
  // constructor
  // sets the name of the I/O class "HKickParIo"
  // gets the pointer to the connection class
  fName="HKickParIo";
  idMdc3=-1;
  idMeta=-1;
}


Bool_t HKickParOraIo::init(HParSet* pPar,Int_t* set) {
  // calls special read-function for each parameter container
  const Text_t* name=pPar->GetName();
  if (startIo(pPar)<=0) return kFALSE;
  if (strncmp(name,"KickPlane2MDC3",strlen("KickPlane2MDC3"))==0)
    return read((HKickPlane2*)pPar,idMdc3);
  if (strncmp(name,"KickPlane2Meta",strlen("KickPlane2Meta"))==0)
    return read((HKickPlane2*)pPar,idMeta);
  if (strncmp(name,"KickMatchParMDC3",strlen("KickMatchParMDC3"))==0)
    return read((HKickMatchPar*)pPar,idMdc3);
  if (strncmp(name,"KickMatchParMeta",strlen("KickMatchParMeta"))==0)
    return read((HKickMatchPar*)pPar,idMeta);
  if (strncmp(name,"KickTrackFPar",strlen("KickTrackFPar"))==0)
    return readCond((HParCond*)pPar,set);
  cout<<"initialization of "<<name<<" not possible from Oracle!"<<endl;
  return kFALSE;
}

Int_t HKickParOraIo::write(HParSet* pPar) {
  // calls the appropriate write function for the container
  const Text_t* name=pPar->GetName();
  if (startIo(pPar)<=0) return kFALSE;
  if (strncmp(name,"KickPlane2MDC3",strlen("KickPlane2MDC3"))==0)
    return writePar((HKickPlane2*)pPar,idMdc3);
  if (strncmp(name,"KickPlane2Meta",strlen("KickPlane2Meta"))==0)
    return writePar((HKickPlane2*)pPar,idMeta);
  if (strncmp(name,"KickMatchParMDC3",strlen("KickMatchParMDC3"))==0)
    return writePar((HKickMatchPar*)pPar,idMdc3);
  if (strncmp(name,"KickMatchParMeta",strlen("KickMatchParMeta"))==0)
    return writePar((HKickMatchPar*)pPar,idMeta);
  if (strncmp(name,"KickTrackFPar",strlen("KickTrackFPar"))==0)
    return writeCond((HParCond*)pPar);
  cout<<"No write-interface to Oracle for parameter container "
      <<name<<endl;
  return 0;
}

Int_t HKickParOraIo::startIo(HParSet* pPar) {
  // gets the run start of the actual run
  // reads the ids for Mdc3 and Meta related parameters
  // returns -1, if the run is not found
  runStart=getRunStart(pPar);
  if (runStart==-1) pPar->setInputVersion(-1,inputNumber);
  else if (idMdc3==-1) readIds();
  return runStart;
}


void HKickParOraIo::readIds() {
  // reads the ids for Mdc3 and Meta related parameters
  // returns the number of modules found
  EXEC SQL BEGIN DECLARE SECTION;
    struct {
      int pid[KICK_PARTS];
      varchar pname[KICK_PARTS][80];
    } parts;
    struct {
      short pid[KICK_PARTS];
      short pname[KICK_PARTS];
    } parts_Ind;
  EXEC SQL END DECLARE SECTION;

  EXEC SQL WHENEVER SQLERROR DO showSqlError("readIds()");
  EXEC SQL WHENEVER NOT FOUND CONTINUE;

  EXEC SQL SELECT det_part_id, det_part_name
    INTO :parts INDICATOR :parts_Ind
    FROM santiago_ana.kickplane_parts;

  for(Int_t k=0;k<sqlca.sqlerrd[2];k++) {
    if (parts_Ind.pname[k]!=-1) {
      parts.pname[k].arr[parts.pname[k].len]='\0';
      const Char_t* name=(Char_t*)parts.pname[k].arr;
      if (strcmp(name,"MDC3")==0) idMdc3=parts.pid[k];
      else if (strcmp(name,"META")==0) idMeta=parts.pid[k];
        else Error("HMdcParOraIo::readIds()","\nInvalid part %s for kickplane",name);
    }
  }
}


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


Bool_t HKickParOraIo::read(HKickPlane2* pPar,Int_t part) {
  // reads the kickplane2 parameters
  Int_t contVers=pPar->getInputVersion(inputNumber);
  Int_t oraVersion=-1;
  Int_t version=getVersion(pPar,part,oraVersion);
  if (version==-1) {
    pPar->setInputVersion(-1,inputNumber);
    return kFALSE;
  }
  if (contVers==version) return kTRUE;
  pPar->clear();
  EXEC SQL BEGIN DECLARE SECTION;
    int pid;
    int vers;
    int surf_id;
    double scalefac;
    int ga_id;
    int gb_id;
    int gc_id;
    int ga_neg_id;
    int gb_neg_id;
    int gc_neg_id;
  EXEC SQL END DECLARE SECTION;
  HKickGrid* grids[6];
  Int_t gridIds[6];
  EXEC SQL WHENEVER SQLERROR DO showSqlError("read(HKickPlane2*,Int_t)");
  EXEC SQL WHENEVER NOT FOUND GOTO not_found;
  vers=oraVersion;
  pid=part;
  EXEC SQL SELECT surface_id, f_scale_factor, f_grid_a, f_grid_b, f_grid_c,
                  f_grid_a_neg, f_grid_b_neg, f_grid_c_neg
           INTO :surf_id, :scalefac, :ga_id, :gb_id, :gc_id,
                :ga_neg_id, :gb_neg_id, :gc_neg_id
           FROM santiago_ana.kickplane2_data
           WHERE vers_id = :vers and det_part_id = :pid;
  pPar->fScaleFactor=scalefac;
  grids[0]=(&(pPar->fGridA));
  grids[1]=(&(pPar->fGridB));
  grids[2]=(&(pPar->fGridC));
  grids[3]=(&(pPar->fGridANeg));
  grids[4]=(&(pPar->fGridBNeg));
  grids[5]=(&(pPar->fGridCNeg));
  gridIds[0]=ga_id;
  gridIds[1]=gb_id;
  gridIds[2]=gc_id;
  gridIds[3]=ga_neg_id;
  gridIds[4]=gb_neg_id;
  gridIds[5]=gc_neg_id;
  if ((pPar->fSurface=readSurface(surf_id))) {
   if (readGrids(6,grids,gridIds)) {
     setChanged(pPar);
     cout<<pPar->GetName()<<" initialized from Oracle\n";
     return kTRUE;
   } else Error("read","Reading grids");
  } else Error("read","Reading surfaces");
not_found:
  pPar->clear();
  return kFALSE;  
}


Bool_t HKickParOraIo::read(HKickMatchPar* pPar,Int_t part) {
  // reads the matching parameters for kickplane v2
  Int_t contVers=pPar->getInputVersion(inputNumber);
  Int_t oraVersion=-1;
  Int_t version=getVersion(pPar,part,oraVersion);
  if (version==-1) {
    pPar->setInputVersion(-1,inputNumber);
    return kFALSE;
  }
  if (contVers==version) return kTRUE;
  pPar->clear();
  EXEC SQL BEGIN DECLARE SECTION;
    int pid;
    int vers;
    double scalefac;
    int ga_id;
    int gb_id;
    int gc_id;
    int gan_id;
    int gbn_id;
    int gcn_id;
  EXEC SQL END DECLARE SECTION;
  HKickGrid* grids[6];
  Int_t gridIds[6];
  EXEC SQL WHENEVER SQLERROR DO showSqlError("read(HKickMatchPar*,Int_t)");
  EXEC SQL WHENEVER NOT FOUND GOTO not_found;
  vers=oraVersion;
  pid=part;
  EXEC SQL SELECT f_scale_factor, f_grid_a, f_grid_b, f_grid_c,
                  f_grid_a_n, f_grid_b_n, f_grid_c_n
           INTO :scalefac, :ga_id, :gb_id, :gc_id, :gan_id, :gbn_id, :gcn_id
           FROM santiago_ana.kick_match_data
           WHERE vers_id = :vers and det_part_id = :pid;
  pPar->fScaleFactor=scalefac;
  grids[0]=(&(pPar->fGridA));
  grids[1]=(&(pPar->fGridB));
  grids[2]=(&(pPar->fGridC));
  grids[3]=(&(pPar->fGridAN));
  grids[4]=(&(pPar->fGridBN));
  grids[5]=(&(pPar->fGridCN));
  gridIds[0]=ga_id;
  gridIds[1]=gb_id;
  gridIds[2]=gc_id;
  gridIds[3]=gan_id;
  gridIds[4]=gbn_id;
  gridIds[5]=gcn_id;
  if (readGrids(6,grids,gridIds)) {
    setChanged(pPar);
    cout<<pPar->GetName()<<" initialized from Oracle\n";
    return kTRUE;
  }
not_found:
  pPar->clear();
  return kFALSE;  
}


HSurface* HKickParOraIo::readSurface(Int_t surfaceId) {
  // reads the surface with id surfaceId
  HSurface* pPar=0;
  Int_t nValues=0;
  Bool_t rc=kFALSE;
  EXEC SQL BEGIN DECLARE SECTION;
    int id;
    varchar surf_name[81];
    double svalues[KICK_MAXSURFACEPAR];
  EXEC SQL END DECLARE SECTION;
  EXEC SQL WHENEVER SQLERROR DO showSqlError("read(HSurface*,Int_t)");
  EXEC SQL WHENEVER NOT FOUND GOTO not_found;
  id=surfaceId;
  EXEC SQL SELECT surface_type_name INTO :surf_name
           FROM santiago_ana.kick_surface a,
                santiago_ana.kick_surface_type b
           WHERE surface_id = :id AND a.surface_type_id = b. surface_type_id; 
  surf_name.arr[surf_name.len]='\0';
  if ( strcmp((Char_t*)surf_name.arr,"HSurfPlane") == 0 ) {
    pPar = new HSurfPlane;
  } else if (strcmp((Char_t*)surf_name.arr, "HSurfPlaneV") == 0) {
    pPar = new HSurfPlaneV;
  } else if (strcmp((Char_t*)surf_name.arr, "HSurfXCilinder") == 0) {
    pPar = new HSurfXCilinder;    
  } else if (strcmp((Char_t*)surf_name.arr, "HSurfPlaneTriV") == 0) {
    pPar = new HSurfPlaneTriV;    
  } else {
    Error("readSurface","Unknown surface %s",(Char_t*)surf_name.arr);
    return 0;
  }
  EXEC SQL WHENEVER NOT FOUND CONTINUE;
  EXEC SQL SELECT param_value INTO :svalues
           FROM santiago_ana.kick_surface_data 
           WHERE surface_id = :id
           ORDER BY nParam;
  nValues=sqlca.sqlerrd[2];
  if (nValues>0) {
    TArrayD* p=new TArrayD(nValues); 
    for(Int_t k=0;k<nValues;k++) p->AddAt(svalues[k],k);
    rc=pPar->setParams(*p);
    delete p;
  }
  if (rc) return pPar;
  else return 0;
not_found:
  return 0;
}


Bool_t HKickParOraIo::readGrids(Int_t nGrids,HKickGrid** pGrids,Int_t* gridIds) {
  // reads the grids with ids gridIds
  EXEC SQL BEGIN DECLARE SECTION;
    int id;
    float minx;
    float maxx;
    float miny;
    float maxy;
    float gran;
    float sim;
    float gvalues[KICK_MAXARRAY];
  EXEC SQL END DECLARE SECTION;
  EXEC SQL DECLARE grid_cur CURSOR FOR
    SELECT f_min_x, f_max_x, f_min_y, f_max_y, f_granularity, f_sim
    FROM santiago_ana.kick_grid
    WHERE grid_id = :id;
  EXEC SQL DECLARE gridval_cur CURSOR FOR
    SELECT param_value
    FROM santiago_ana.kick_grid_data
    WHERE grid_id = :id
    ORDER BY nParam;
  EXEC SQL WHENEVER SQLERROR DO showSqlError("readGrids(Int_t,HKickGrid**,Int_t*)");
  EXEC SQL WHENEVER NOT FOUND CONTINUE;
  for(Int_t i=0;i<nGrids;i++) {
    id=gridIds[i];   
    EXEC SQL OPEN grid_cur;
    EXEC SQL FETCH grid_cur INTO :minx, :maxx, :miny, :maxy, :gran, :sim;
    if (sqlca.sqlerrd[2]<=0) {
      EXEC SQL CLOSE grid_cur;
      return kFALSE;
    }
    HKickGrid* g=pGrids[i];
    g->fMinX=minx;
    g->fMaxX=maxx;
    g->fMinY=miny;
    g->fMaxY=maxy;
    g->fGranularity=gran;
    g->fSim=sim;
    g->fMidY=(miny+maxy)/2.;
    g->init();
    EXEC SQL OPEN gridval_cur;
    Int_t nbs=0, nbslast=0;
    do {
      EXEC SQL FETCH gridval_cur INTO :gvalues;
      nbs=sqlca.sqlerrd[2] - nbslast;
      for(Int_t k=0;k<nbs;k++) g->fValues[nbslast+k]=gvalues[k];
      nbslast+=nbs;
    } while (nbs==KICK_MAXARRAY);
    if (nbslast!=g->fEntries) {
      EXEC SQL CLOSE grid_cur;
      EXEC SQL CLOSE gridval_cur;
      return kFALSE;
    }
  } 
  EXEC SQL CLOSE grid_cur;
  EXEC SQL CLOSE gridval_cur;
  return kTRUE;
}


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


Int_t HKickParOraIo::writePar(HKickPlane2* pPar,Int_t part) {
  // writes the kickplane2 parameter container to Oracle
  Int_t version, surface, gridA, gridB, gridC, gridANeg, gridBNeg, gridCNeg ;
  if (part==-1 || (version=createVersion(pPar))==-1
      || (surface=writeSurface(pPar->fSurface))==-1
      || (gridA=writeGrid(&(pPar->fGridA)))==-1
      || (gridB=writeGrid(&(pPar->fGridB)))==-1
      || (gridC=writeGrid(&(pPar->fGridC)))==-1
      || (gridANeg=writeGrid(&(pPar->fGridANeg)))==-1
      || (gridBNeg=writeGrid(&(pPar->fGridBNeg)))==-1
      || (gridCNeg=writeGrid(&(pPar->fGridCNeg)))==-1) return -1;
  EXEC SQL BEGIN DECLARE SECTION;
    int pid;
    int vers;
    int surf_id;
    double scalefac;
    int ga_id;
    int gb_id;
    int gc_id;
    int ga_neg_id;
    int gb_neg_id;
    int gc_neg_id;
  EXEC SQL END DECLARE SECTION;
  pid=part;      
  vers=version;
  surf_id=surface;
  scalefac=pPar->fScaleFactor;
  ga_id=gridA;
  gb_id=gridB;
  gc_id=gridC;
  ga_neg_id=gridANeg;
  gb_neg_id=gridBNeg;
  gc_neg_id=gridCNeg;
  EXEC SQL WHENEVER SQLERROR GOTO not_found;
  EXEC SQL WHENEVER NOT FOUND GOTO not_found;
  EXEC SQL INSERT INTO santiago_ana.kickplane2_data
             (det_part_id, vers_id, surface_id, f_scale_factor,
              f_grid_a, f_grid_b, f_grid_c, f_grid_a_neg,
              f_grid_b_neg, f_grid_c_neg)
           VALUES (:pid, :vers, :surf_id, :scalefac, :ga_id, :gb_id,
                   :gc_id, :ga_neg_id, :gb_neg_id, :gc_neg_id);
  commit();
  pPar->setChanged(kFALSE);
  cout<<pPar->GetName()<<" written to Oracle"<<endl<<endl;
  return version;
not_found:
  showSqlError("writePar(HKickPlane2*)");
  rollback();
  return -1;
}


Int_t HKickParOraIo::writePar(HKickMatchPar* pPar,Int_t part) {
  // writes the parameter container HKickMatchPar to Oracle
  Int_t version, gridA, gridB, gridC, gridAN, gridBN, gridCN;
  if (part==-1 || (version=createVersion(pPar))==-1
      || (gridA=writeGrid(&(pPar->fGridA)))==-1
      || (gridB=writeGrid(&(pPar->fGridB)))==-1
      || (gridC=writeGrid(&(pPar->fGridC)))==-1
      || (gridAN=writeGrid(&(pPar->fGridAN)))==-1
      || (gridBN=writeGrid(&(pPar->fGridBN)))==-1
      || (gridCN=writeGrid(&(pPar->fGridCN)))==-1) return -1;
  EXEC SQL BEGIN DECLARE SECTION;
    int pid;
    int vers;
    double scalefac;
    int ga_id;
    int gb_id;
    int gc_id;
    int gan_id;
    int gbn_id;
    int gcn_id;
  EXEC SQL END DECLARE SECTION;
  pid=part;      
  vers=version;
  scalefac=pPar->fScaleFactor;
  ga_id=gridA;
  gb_id=gridB;
  gc_id=gridC;
  gan_id=gridAN;
  gbn_id=gridBN;
  gcn_id=gridCN;
  EXEC SQL WHENEVER SQLERROR GOTO not_found;
  EXEC SQL WHENEVER NOT FOUND GOTO not_found;
  EXEC SQL INSERT INTO santiago_ana.kick_match_data
             (det_part_id, vers_id, f_scale_factor,
              f_grid_a, f_grid_b, f_grid_c, f_grid_a_n, f_grid_b_n, f_grid_c_n)
           VALUES (:pid, :vers, :scalefac,
                   :ga_id, :gb_id, :gc_id, :gan_id, :gbn_id, :gcn_id);
  commit();
  pPar->setChanged(kFALSE);
  cout<<pPar->GetName()<<" written to Oracle"<<endl<<endl;
  return version;
not_found:
  showSqlError("writePar(HKickMatchPar*)");
  rollback();
  return -1;
}


Int_t HKickParOraIo::writeSurface(HSurface* pPar) {
  // writes the surface parameters to Oracle
  // returns the id of the surface
  if (!pPar) return -1;
  EXEC SQL BEGIN DECLARE SECTION;
    int id;
    char* surf_name;
    double svalues[KICK_MAXSURFACEPAR];
    int nval;
  EXEC SQL END DECLARE SECTION;
  surf_name=(Char_t*)pPar->IsA()->GetName();
  TArrayD p(10);
  Int_t n=pPar->getParams(p);
  for (Int_t i=0;i<n;i++) svalues[i]=p.At(i);
  nval=n;
  EXEC SQL WHENEVER SQLERROR GOTO not_found;
  EXEC SQL WHENEVER NOT FOUND GOTO not_found;
  EXEC SQL ARRAYLEN svalues (nval);
  EXEC SQL EXECUTE
    DECLARE
    BEGIN
      santiago_ana.kick_par_query.store_surface
           (:surf_name, :nval, :svalues, :id);
    END;
  END-EXEC;
  cout<<surf_name<<" written with id: "<<id<<endl;
  return id;
not_found:
  showSqlError("writeSurface(HSurface*)");
  rollback();
  return -1;
}


Int_t HKickParOraIo::writeGrid(HKickGrid* pPar) {
  // writes the surface parameters to Oracle
  // returns the id of the surface
  if (!pPar) return -1;
  EXEC SQL BEGIN DECLARE SECTION;
    int id;
    float minx;
    float maxx;
    float miny;
    float maxy;
    float gran;
    float sim;
    int nval;
    int noffset;
    float gvalues[KICK_MAXARRAY];
  EXEC SQL END DECLARE SECTION;
  minx=pPar->fMinX;
  maxx=pPar->fMaxX;
  miny=pPar->fMinY;
  maxy=pPar->fMaxY;
  gran=pPar->fGranularity;
  sim=pPar->fSim;
  Int_t ntotval=pPar->fEntries;
  EXEC SQL WHENEVER SQLERROR GOTO not_found;
  EXEC SQL WHENEVER NOT FOUND GOTO not_found;
  Int_t nmb=(Int_t)floor((Float_t)(ntotval/KICK_MAXARRAY));
  for(Int_t i=0;i<=nmb;i++) {
    nval=(i<nmb)?KICK_MAXARRAY:(ntotval-nmb*KICK_MAXARRAY);
    noffset=i*KICK_MAXARRAY;     
    for (Int_t k=0;k<nval;k++) {
      float v=pPar->fValues[noffset+k];
      if (v<-1.E+8) v=-1.E+8; 
      if (v>1.E+8) v=1.E+8; 
      if (v>-1.E-8 && v<0) v=-1.E-8; 
      if (v<1.E-8 && v>0) v=1.E-8; 
      gvalues[k]=v;
    }
    if (i==0) {        
      EXEC SQL EXECUTE
        DECLARE
        BEGIN
          santiago_ana.kick_par_query.store_grid(:minx, :maxx, :miny,
                    :maxy, :gran, :sim, :nval, :gvalues, :id);
        END;
        END-EXEC;
    } else {
      EXEC SQL EXECUTE
        DECLARE
        BEGIN
          santiago_ana.kick_par_query.expand_grid(
              :id, :noffset, :nval, :gvalues);
        END;
      END-EXEC;
    }
  }
  cout<<"grid written with id: "<<id<<"   number of grid values: "<<ntotval<<endl;
  return id;
not_found:
  showSqlError("writeGrid(HKickGrid*)");
  rollback();
  return -1;
}