/[PAMELA software]/YodaProfiler/src/PamelaDBOperations.cpp

Diff of /YodaProfiler/src/PamelaDBOperations.cpp

Parent Directory | Revision Log | View Patch Patch

-revision 1.1 by mocchiut,
Wed Aug 30 11:18:13 2006 UTC
+revision 1.47 by mocchiut,
Fri Aug 31 08:51:21 2007 UTC
 Line 8
  #include <list>
  #include <errno.h>
  //
+ #include <TFile.h>
+ #include <TSystem.h>
  #include <TSQLResult.h>
- #include <TRFIOFile.h>
  #include <TSQLRow.h>
  #include <TTree.h>
  #include <TGraph.h>
- #include <TDatime.h>
+ #include <TTimeStamp.h>
  #include <TF1.h>
  //
  #include <EventHeader.h>
-Line 29
+Line 30
  #include <varDump/VarDumpEvent.h>
  #include <varDump/VarDumpRecord.h>
  #include <physics/S4/S4Event.h>
  //
+ #include <sgp4.h>
  #include <PamelaDBOperations.h>
  //
  using namespace std;
  using namespace pamela;
- //using namespace yngn::util;
+ // Some function to work with cTle stuff.
+ bool compTLE(cTle* tle1, cTle *tle2);
+ float getTleJulian(cTle *);
+ string getTleDatetime(cTle*);
  /**
   * Constructor.
-Line 48 
 using namespace pamela;
+Line 54 
 using namespace pamela;
   * @param obt0         file obt0.
   * @param tsync        file timesync.
   * @param debug        debug flag.
+  * @param tlefilename  ascii file with TLE 3 line elements.
   */
- PamelaDBOperations::PamelaDBOperations(TString host, TString user, TString password, TString filerawname, TString filerootname, UInt_t boot, UInt_t tsync, UInt_t obt0, Bool_t debug){
+ PamelaDBOperations::PamelaDBOperations(TString host, TString user, TString password, TString filerawname, TString filerootname, UInt_t boot, UInt_t tsync, UInt_t obt0, Bool_t debug, TString tlefilename, UInt_t dwinput, Bool_t staticp){
    //
+   STATIC=false;
+   if ( staticp ) STATIC=true;
    //
    SetConnection(host,user,password);
    //
-Line 63 
 PamelaDBOperations::PamelaDBOperations(T
+Line 72 
 PamelaDBOperations::PamelaDBOperations(T
    SetTsync(tsync);
    SetObt0(obt0);
    //
+   SetTLEPath(tlefilename);
+   //
    //
-   SetRootName(filerootname);
+   INSERT_RAW =!filerawname.IsNull();
-   SetRawName(filerawname);
+   if(INSERT_RAW)SetRawName(filerawname);
    //
-   this->OpenFile();
+   INSERT_ROOT = !filerootname.IsNull();
+   if( INSERT_ROOT ){
+     this->SetRootName(filerootname);
+     this->SetOrbitNo(dwinput);
+     file = TFile::Open(this->GetRootName().Data());
+   } else {
+     this->SetRootName("");
+   };
    //
    this->SetID_RAW(0);
    this->SetID_ROOT(0);
+   VALIDATE = false;
    //
  };
-Line 79 
 PamelaDBOperations::PamelaDBOperations(T
+Line 100 
 PamelaDBOperations::PamelaDBOperations(T
   */
  void PamelaDBOperations::Close(){
    if( conn && conn->IsConnected() ) conn->Close();
+   delete clean_time;
    delete glrun;
    delete this;
  };
-Line 87 
 void PamelaDBOperations::Close(){
+Line 109 
 void PamelaDBOperations::Close(){
  // SETTERS
  //
+ //
+ // must be out of the constructor in order to FORCE the validation of the latest runs in case you run the validation together with the latest file
+ //
+ void PamelaDBOperations::CheckValidate(Long64_t olderthan){
+   clean_time = new TDatime();
+   //
+   if(olderthan >= 0){
+     VALIDATE = true;
+     UInt_t timelim = 0;
+     timelim =  (UInt_t)clean_time->Convert(true) - olderthan;
+     clean_time->Set(timelim,false);
+   };
+ };
  /**
   * Open the DB connection
   * @param host         hostname for the SQL connection.
-Line 94 
 void PamelaDBOperations::Close(){
+Line 130 
 void PamelaDBOperations::Close(){
   * @param password     password for the SQL connection.
   */
  void PamelaDBOperations::SetConnection(TString host, TString user, TString password){
+   if ( IsDebug() ) printf(" Connecting using host = %s user = %s password = %s \n",host.Data(),user.Data(),password.Data());
    conn = TSQLServer::Connect(host.Data(),user.Data(),password.Data());
  };
-Line 122 
 void PamelaDBOperations::SetDebugFlag(Bo
+Line 159 
 void PamelaDBOperations::SetDebugFlag(Bo
  };
  /**
+  * Set the autoboot flag
+  *
+  */
+ void PamelaDBOperations::SetAutoBoot(Bool_t dbg){
+   AUTOBOOT = dbg;
+ };
+ /**
+  * Set the nofrag flag
+  *
+  */
+ void PamelaDBOperations::SetNoFrag(Bool_t nf){
+   NOFRAG = nf;
+ };
+ /**
   * Store the BOOT number of the RAW file.
   * @param boot    BOOT number of the RAW file
   */
-Line 162 
 void PamelaDBOperations::SetRootName(TSt
+Line 215 
 void PamelaDBOperations::SetRootName(TSt
  };
  /**
+  * Store the downlink orbit number from filename.
+  */
+ void PamelaDBOperations::SetOrbitNo(UInt_t dwinput){
+   dworbit = 0;
+   //
+   if ( dwinput ){
+     dworbit = dwinput;
+     if ( IsDebug() ) printf(" Downlink orbit given by hand: %i  \n",dworbit);
+     return;
+   };
+   //
+   TString name = this->GetRootFile();
+   Int_t nlength = name.Length();
+   if ( nlength < 5 ) return;
+   TString dwo = 0;
+   for (Int_t i = 0; i<5; i++){
+     dwo.Append(name[i],1);
+   };
+   if ( dwo.IsDigit() ){
+     dworbit = (UInt_t)dwo.Atoi();
+   } else {
+     dwo="";
+     for (Int_t i = 8; i<13; i++){
+       dwo.Append(name[i],1);
+     };
+     if ( dwo.IsDigit() ) dworbit = (UInt_t)dwo.Atoi();
+   };
+   if ( IsDebug() ) printf(" Downlink orbit is %i (dwo = %s) \n",dworbit,dwo.Data());
+   return;
+ };
+ /**
   * Store the NOBOOT flag.
   * @param noboot    true/false.
   */
-Line 170 
 void PamelaDBOperations::SetNOBOOT(Bool_
+Line 257 
 void PamelaDBOperations::SetNOBOOT(Bool_
  };
  /**
+  * Store path to the TLE file.
+  */
+ void PamelaDBOperations::SetTLEPath(TString str){
+   tlefilename = str;
+ };
+ TString PamelaDBOperations::GetRawPath(){
+   if ( STATIC ){
+     return((TString)gSystem->DirName(filerawname.Data())+'/');
+   } else {
+     return((TString)gSystem->ExpandPathName("$PAM_RAW")+'/');
+   };
+ };
+ TString PamelaDBOperations::GetRootPath(){
+   if ( STATIC ){
+     return((TString)gSystem->DirName(filerootname.Data())+'/');
+   } else {
+     return((TString)gSystem->ExpandPathName("$PAM_L0")+'/');
+   };
+ };
+ /**
+  * Store the olderthan variable
+  * @param olderthan
+  */
+ // void PamelaDBOperations::SetOlderThan(Long64_t oldthan){
+ //   olderthan = oldthan;
+ // };
+ /**
   * Retrieve the ID_RAW, if exists, returns NULL if does not exist.
   */
  Bool_t PamelaDBOperations::SetID_RAW(){
-Line 177 
 Bool_t PamelaDBOperations::SetID_RAW(){
+Line 295 
 Bool_t PamelaDBOperations::SetID_RAW(){
    TSQLResult *result = 0;
    TSQLRow    *row    = 0;
    oss.str("");
-   oss << "SELECT ID FROM GL_RAW WHERE "
+   if ( STATIC ){
-       << " PATH = '" << this->GetRawPath().Data() << "' AND "
+     oss << "SELECT ID FROM GL_RAW WHERE "
-       << " NAME = '" << this->GetRawFile().Data() << "' ";
+         << " PATH = '" << this->GetRawPath().Data() << "' AND "
+         << " NAME = '" << this->GetRawFile().Data() << "' ";
+   } else {
+     oss << "SELECT ID FROM GL_RAW WHERE "
+         << " PATH = '$PAM_RAW' AND "
+         << " NAME = '" << this->GetRawFile().Data() << "' ";
+   }
    result = conn->Query(oss.str().c_str());
-   if (result == NULL) throw -4;
+   if ( result == NULL ) throw -4;
    row = result->Next();
-   if (row == NULL) return false;
+   if ( !row ) return(false);
    delete result;
    id = (UInt_t)atoll(row->GetField(0));
    return(true);
-Line 210 
 Int_t PamelaDBOperations::SetUpperLimits
+Line 334 
 Int_t PamelaDBOperations::SetUpperLimits
    UInt_t nevent = 0;
    UInt_t pktlast = 0;
    UInt_t obtlast = 0;
-   UInt_t t_pktlast = 0;
+   Long64_t t_pktlast = 0LL;
-   UInt_t t_obtlast = 0;
+   //  UInt_t t_obtlast = 0;
-   UInt_t upperpkt2 = 0;
+   Long64_t t_obtlast = 0LL;
-   ULong64_t upperobt2 = 0;
+   Long64_t upperpkt2 = 0LL;
+   Long64_t upperobt2 = 0LL;
    UInt_t zomp = 0;
    UInt_t jump = 50000; // was 5000
+   EventCounter *code=0;
+   //
+   Long64_t deltapkt = 5000LL;
+   Long64_t deltaobt = 50000LL;
+   //
+   pcksList packetsNames;
+   pcksList::iterator Iter;
+   getPacketsNames(packetsNames);
    //
    pktfirst = 0;
    obtfirst = 0;
+   ppktfirst = 0;
+   pobtfirst = 0;
    //
    TTree *T = 0;
    T = (TTree*)file->Get("Physics");
-Line 232 
 Int_t PamelaDBOperations::SetUpperLimits
+Line 367 
 Int_t PamelaDBOperations::SetUpperLimits
    ph = eh->GetPscuHeader();
    pktfirst = ph->GetCounter();
    obtfirst = ph->GetOrbitalTime();
+   ppktfirst = pktfirst;
+   pobtfirst = obtfirst;
+   //
+   code = eh->GetCounter();
+   UInt_t en = 0;
+   for(Iter = packetsNames.begin(); Iter != packetsNames.end(); Iter++){
+     en = code->Get(GetPacketType(*Iter));
+     if ( !strcmp("CalibCalPed",*Iter) || !strcmp("CalibTrk1",*Iter) || !strcmp("CalibTrk2",*Iter) || !strcmp("CalibS4",*Iter) ){
+       if ( IsDebug() ) printf(" We have a calibration before the first physic packet: packet type is %s, entries: %i \n",*Iter,en);
+       //
+       TTree *TC = 0;
+       TC = (TTree*)file->Get("CalibCalPed");
+       if ( !TC || TC->IsZombie() ) throw -16;
+       EventHeader *ehc = 0;
+       PscuHeader *phc = 0;
+       TC->SetBranchAddress("Header", &ehc);
+       TC->GetEntry(0);
+       phc = ehc->GetPscuHeader();
+       pktfirst = phc->GetCounter();
+       obtfirst = phc->GetOrbitalTime();
+       //
+     };
+   };
    //
    T->GetEntry(nevent-1);
    ph = eh->GetPscuHeader();
-Line 242 
 Int_t PamelaDBOperations::SetUpperLimits
+Line 400 
 Int_t PamelaDBOperations::SetUpperLimits
    upperobt = OBT(obtlast);
    upperentry = nevent-1;
    //
-   if ( IsDebug() ) printf(" First entries are: OBT %llu pkt_num %i \n",obtfirst,pktfirst);
+   if ( IsDebug() ) printf(" First entries are: OBT %u pkt_num %u \n",obtfirst,pktfirst);
    //
-   if ( IsDebug() ) printf(" Last entries are: OBT %llu pkt_num %i entry %i\n",upperobt,upperpkt,upperentry);
+   if ( IsDebug() ) printf(" Last entries are: OBT %lld pkt_num %lld entry %i\n",upperobt,upperpkt,upperentry);
    //
-   if ( (PKT(pktlast) < PKT(pktfirst) && OBT(obtlast) > OBT(obtfirst)) || (PKT(pktlast) > PKT(pktfirst) && OBT(obtlast) < OBT(obtfirst)) ) return(1);
+   if ( (PKT(pktlast) < PKT(pktfirst) && OBT(obtlast) > OBT(obtfirst)) || (PKT(pktlast) > PKT(pktfirst) && OBT(obtlast) < OBT(obtfirst)) ) return(32);
    //
-   if ( !nevent ) return(2);
+   if ( !nevent ) return(64);
    //
-   if ( nevent < 2 ) return(4);
+   if ( nevent < 2 ) return(128);
+   if ( nevent < jump ) jump = 1;
+   //  if ( nevent < jump ) jump = int(nevent/10);
+   //  if ( !jump ) jump = 1;
    //
-   if ( PKT(pktlast) < PKT(pktfirst) && OBT(obtlast) < OBT(obtfirst) ){
+   if ( (PKT(pktlast) < PKT(pktfirst) && OBT(obtlast) < OBT(obtfirst)) || (labs(PKT(pktlast)-PKT(pktfirst))<deltapkt && labs(OBT(obtlast)-OBT(obtfirst))<deltaobt) && nevent > deltapkt ){
+     //
+     if ( IsDebug() ) printf(" starting jump %i \n",jump);
      // go back
      zomp = nevent - 2;
      //
-Line 274 
 Int_t PamelaDBOperations::SetUpperLimits
+Line 437 
 Int_t PamelaDBOperations::SetUpperLimits
          upperpkt2 = PKT(ph->GetCounter());
          upperobt2 = OBT(ph->GetOrbitalTime());
          //
-         if ( (t_pktlast < upperpkt && t_obtlast > upperobt) || (t_pktlast < upperpkt2 && t_obtlast > upperobt2) ) throw -13;
+         if ( (t_pktlast < upperpkt && t_obtlast > upperobt) || (t_pktlast < upperpkt2 && t_obtlast > upperobt2) ){
+           if ( IsDebug() ) printf(" .-. upperpkt2 %lld upperobt2 %lld \n",upperpkt2,upperobt2);
+           if ( IsDebug() ) printf(" .-. upperpkt %lld t_pktlast %lld upperobt %lld t_obtlast %lld \n",upperpkt,t_pktlast,upperobt,t_obtlast);
+           if ( IsDebug() ) printf(" .-. jump %i zomp %i upperpkt %lld pktlast %u upperobt %lld obtlast %u last entry is %i \n",jump,zomp,upperpkt,pktlast,upperobt,obtlast,i);
+           throw -13;
+         };
          //
          if ( t_pktlast < upperpkt && t_obtlast < upperobt && t_pktlast < upperpkt2 && t_obtlast < upperobt2 ){
            zomp = i + jump + 1;
            if ( zomp > nevent-2 ) zomp = nevent - 2;
-           if ( IsDebug() ) printf(" .-. jump %i zomp %i upperpkt %i pktlast %i upperobt %llu obtlast %u last entry is %i \n",jump,zomp,upperpkt,pktlast,upperobt,obtlast,i);
+           if ( IsDebug() ) printf(" .-. jump %i zomp %i upperpkt %lld pktlast %u upperobt %lld obtlast %u last entry is %i \n",jump,zomp,upperpkt,pktlast,upperobt,obtlast,i);
            break;
          };
          //
-Line 301 
 Int_t PamelaDBOperations::SetUpperLimits
+Line 469 
 Int_t PamelaDBOperations::SetUpperLimits
    // check if last runtrailer is within limits, if not extend limits (one should check for all packets but we need only runtrailer)
    //
    PacketType *pctp=0;
-   EventCounter *code=0;
-   T->GetEntry(upperentry);
-   code = eh->GetCounter();
-   Int_t lasttrail = code->Get(pctp->RunTrailer);
-   Int_t lasthead = code->Get(pctp->RunHeader);
    TTree *rh=(TTree*)file->Get("RunHeader");
    if ( !rh || rh->IsZombie() ) throw -17;
    TTree *rt=(TTree*)file->Get("RunTrailer");
-Line 319 
 Int_t PamelaDBOperations::SetUpperLimits
+Line 482 
 Int_t PamelaDBOperations::SetUpperLimits
    //
    rhev = rh->GetEntries();
    rtev = rt->GetEntries();
-   UInt_t pktt = 0;
+   Long64_t sobtt = 0LL;
-   ULong64_t obtt = 0;
+   Long64_t sobth = 0LL;
-   UInt_t pkth = 0;
+   Long64_t spktt = 0LL;
-   ULong64_t obth = 0;
+   Long64_t spkth = 0LL;
+   Long64_t pktt = 0LL;
+   Long64_t obtt = 0LL;
+   Long64_t pkth = 0LL;
+   Long64_t obth = 0LL;
    //
-   if ( lasttrail < rtev ){
+   if ( rhev || rtev ){
-     rt->GetEntry(lasttrail);
-     pht = eht->GetPscuHeader();
+     T->GetEntry(upperentry);
-     pktt = PKT(pht->GetCounter());
+     code = eh->GetCounter();
-     obtt = OBT(pht->GetOrbitalTime());
+     Int_t lasttrail = code->Get(pctp->RunTrailer);
+     Int_t lasthead = code->Get(pctp->RunHeader);
+     if ( lasttrail < rtev ){
+       rt->GetEntry(lasttrail);
+       pht = eht->GetPscuHeader();
+       pktt = PKT(pht->GetCounter());
+       obtt = OBT(pht->GetOrbitalTime());
+     };
+     //
+     if ( lasthead < rhev ){
+       rh->GetEntry(lasthead);
+       phh = ehh->GetPscuHeader();
+       pkth = PKT(phh->GetCounter());
+       obth = OBT(phh->GetOrbitalTime());
+     };
+     //
+     if ( IsDebug() ) printf(" rhev before %i ph %lld upperp %lld oh %lld uppero %lld \n",rhev,pkth,upperpkt,obth,upperobt);
+     if ( pkth > upperpkt && obth > upperobt ){
+       if ( IsDebug() ) printf(" Upper limits extended to include last header: ph %lld upperp %lld oh %lld uppero %lld \n",pkth,upperpkt,obth,upperobt);
+       upperpkt = pkth;
+       upperobt = obth;
+       rhev = lasthead+1;
+     } else {
+       rhev = lasthead;
+     };
+     if ( IsDebug() ) printf(" rhev after %i ph %lld upperp %lld oh %lld uppero %lld \n",rhev,pkth,upperpkt,obth,upperobt);
+     //
+     if ( IsDebug() ) printf(" rtev beforev %i  pt %lld upperp %lld ot %lld uppero %lld \n",rtev,pktt,upperpkt,obtt,upperobt);
+     if ( pktt > upperpkt && obtt > upperobt ){
+       if ( IsDebug() ) printf(" Upper limits extended to include last trailer: pt %lld upperp %lld ot %lld uppero %lld \n",pktt,upperpkt,obtt,upperobt);
+       upperpkt = pktt;
+       upperobt = obtt;
+       rtev = lasttrail+1;
+     } else {
+       rtev = lasttrail;
+     };
+     if ( IsDebug() ) printf(" rtev after %i  pt %lld upperp %lld ot %lld uppero %lld \n",rtev,pktt,upperpkt,obtt,upperobt);
+     //  goto kikko;
+     //
+     //
+     // Check if runtrailer/runheader are within lower limits
+     //
+     //
+     pkth = 0LL;
+     obth = 0LL;
+     spkth = 0LL;
+     sobth = 0LL;
+     for (Int_t k=0; k<rhev; k++){
+       if ( k > 0 ){
+         spkth = pkth;
+         sobth = obth;
+       };
+       rh->GetEntry(k);
+       phh = ehh->GetPscuHeader();
+       pkth = PKT(phh->GetCounter());
+       obth = OBT(phh->GetOrbitalTime());
+       //
+       //    if ( IsDebug() ) printf(" k %i rhev before %i ph %u upperp %u oh %u uppero %u \n",k,rhev,pkth,spkth,obth,sobth);
+       //
+       if ( pkth < spkth && obth < sobth ){
+         if ( IsDebug() ) printf(" RH PROBLEMS determining the event repetition at the end of the file lasthead %i  \n",rhev);
+         //
+         rhev = k-1;
+         rh->GetEntry(rhev);
+         pkth = spkth;
+         obth = sobth;
+         //
+         UInt_t evbefh = 0;
+         code = ehh->GetCounter();
+         evbefh = code->Get(pctp->Physics);
+         if ( evbefh >= 0 ){
+           T->GetEntry(evbefh);
+           ph = eh->GetPscuHeader();
+           t_pktlast = PKT(ph->GetCounter());
+           t_obtlast = OBT(ph->GetOrbitalTime());
+           if ( t_pktlast <= spkth && t_obtlast <= sobth ){ // jump
+             upperpkt = pkth;
+             upperobt = obth;
+             upperentry = evbefh-1;
+           } else {
+             while ( t_pktlast > spkth && t_obtlast > sobth && evbefh < nevent ){
+               evbefh++;
+               T->GetEntry(evbefh);
+               ph = eh->GetPscuHeader();
+               t_pktlast = PKT(ph->GetCounter());
+               t_obtlast = OBT(ph->GetOrbitalTime());
+             };
+             T->GetEntry(evbefh-1);
+             ph = eh->GetPscuHeader();
+             upperpkt = PKT(ph->GetCounter());
+             upperobt = OBT(ph->GetOrbitalTime());
+             upperentry = evbefh-1;
+           };
+         };
+         if ( IsDebug() ) printf(" rhev after %i ph %lld upperp %lld oh %lld uppero %lld \n",rhev,pkth,upperpkt,obth,upperobt);
+         goto kikko0;
+       };
+     };
+   kikko0:
+     //
+     //
+     //
+     pktt = 0LL;
+     obtt = 0LL;
+     spktt = 0LL;
+     sobtt = 0LL;
+     for (Int_t k=0; k<rtev; k++){
+       if ( k > 0 ){
+         spktt = pktt;
+         sobtt = obtt;
+       };
+       rt->GetEntry(k);
+       pht = eht->GetPscuHeader();
+       pktt = PKT(pht->GetCounter());
+       obtt = OBT(pht->GetOrbitalTime());
+       //
+       //    if ( IsDebug() ) printf(" k %i rtev beforev %i  pt %i upperp %i ot %llu uppero %llu \n",k,rtev,pktt,spktt,obtt,sobtt);
+       //
+       if ( pktt < spktt && obtt < sobtt ){
+         if ( IsDebug() ) printf(" RT PROBLEMS determining the event repetition at the end of the file lasttrail %i \n",rtev);
+         //
+         rtev = k-1;
+         rt->GetEntry(rtev);
+         pktt = spktt;
+         obtt = sobtt;
+         if ( IsDebug() ) printf(" lasttrail %i pt %lld upperp %lld ot %lld uppero %lld \n",rtev,pktt,upperpkt,obtt,upperobt);
+         //
+         UInt_t evbeft = 0;
+         code = eht->GetCounter();
+         evbeft = code->Get(pctp->Physics);
+         if ( evbeft >= 0 ){
+           T->GetEntry(evbeft);
+           ph = eh->GetPscuHeader();
+           t_pktlast = PKT(ph->GetCounter());
+           t_obtlast = OBT(ph->GetOrbitalTime());
+           if ( t_pktlast <= spktt && t_obtlast <= sobtt ){ // jump
+             upperpkt = pktt;
+             upperobt = obtt;
+             upperentry = evbeft-1;
+           } else {
+             while ( t_pktlast > spktt && t_obtlast > sobtt && evbeft < nevent ){
+               evbeft++;
+               T->GetEntry(evbeft);
+               ph = eh->GetPscuHeader();
+               t_pktlast = PKT(ph->GetCounter());
+               t_obtlast = OBT(ph->GetOrbitalTime());
+             };
+             T->GetEntry(evbeft-1);
+             ph = eh->GetPscuHeader();
+             upperpkt = PKT(ph->GetCounter());
+             upperobt = OBT(ph->GetOrbitalTime());
+             upperentry = evbeft-1;
+           };
+         };
+         if ( IsDebug() ) printf(" rtev after %i  pt %lld upperp %lld ot %lld uppero %lld \n",rtev,pktt,upperpkt,obtt,upperobt);
+         goto kikko;
+         //      break;
+         //
+       };
+       //
+     };
+     //
+   kikko:
+     //
+     T->GetEntry(upperentry);
+     code = eh->GetCounter();
+     lasttrail = code->Get(pctp->RunTrailer);
+     lasthead = code->Get(pctp->RunHeader);
+     if ( lasttrail < rtev ){
+       rt->GetEntry(lasttrail);
+       pht = eht->GetPscuHeader();
+       pktt = PKT(pht->GetCounter());
+       obtt = OBT(pht->GetOrbitalTime());
+     };
+     //
+     if ( lasthead < rhev ){
+       rh->GetEntry(lasthead);
+       phh = ehh->GetPscuHeader();
+       pkth = PKT(phh->GetCounter());
+       obth = OBT(phh->GetOrbitalTime());
+     };
+     //
+     if ( IsDebug() ) printf(" rhev before %i ph %lld upperp %lld oh %lld uppero %lld \n",rhev,pkth,upperpkt,obth,upperobt);
+     if ( pkth > upperpkt && obth > upperobt ){
+       if ( IsDebug() ) printf(" Upper limits extended to include last header: ph %lld upperp %lld oh %lld uppero %lld \n",pkth,upperpkt,obth,upperobt);
+       upperpkt = pkth;
+       upperobt = obth;
+       rhev = lasthead+1;
+     } else {
+       rhev = lasthead;
+     };
+     if ( IsDebug() ) printf(" rhev after %i ph %lld upperp %lld oh %lld uppero %lld \n",rhev,pkth,upperpkt,obth,upperobt);
+     //
+     if ( IsDebug() ) printf(" rtev beforev %i  pt %lld upperp %lld ot %lld uppero %lld \n",rtev,pktt,upperpkt,obtt,upperobt);
+     if ( pktt > upperpkt && obtt > upperobt ){
+       if ( IsDebug() ) printf(" Upper limits extended to include last trailer: pt %lld upperp %lld ot %lld uppero %lld \n",pktt,upperpkt,obtt,upperobt);
+       upperpkt = pktt;
+       upperobt = obtt;
+       rtev = lasttrail+1;
+     } else {
+       rtev = lasttrail;
+     };
+     if ( IsDebug() ) printf(" rtev after %i  pt %lld upperp %lld ot %lld uppero %lld \n",rtev,pktt,upperpkt,obtt,upperobt);
+     //
    };
    //
-   if ( IsDebug() ) printf(" rtev beforev %i  pt %i upperp %i ot %llu uppero %llu \n",rtev,pktt,upperpkt,obtt,upperobt);
+   if ( IsDebug() ) printf(" Upper limits are: OBT %lld pkt_num %lld upper entry %i \n",upperobt,upperpkt,upperentry);
-   if ( pktt > upperpkt && obtt > upperobt ){
-     if ( IsDebug() ) printf(" Upper limits extended to include last trailer: pt %i upperp %i ot %llu uppero %llu \n",pktt,upperpkt,obtt,upperobt);
-     upperpkt = pktt;
-     upperobt = obtt;
-     rtev = lasttrail+1;
-   } else {
-     rtev = lasttrail;
-   };
-   if ( IsDebug() ) printf(" rtev after %i  pt %i upperp %i ot %llu uppero %llu \n",rtev,pktt,upperpkt,obtt,upperobt);
    //
-   if ( lasthead < rhev ){
+   return(0);
-     rh->GetEntry(lasthead);
+ }
-     phh = ehh->GetPscuHeader();
-     pkth = PKT(pht->GetCounter());
+ /**
-     obth = OBT(pht->GetOrbitalTime());
+  *
-   };
+  * Trick to have unique RUN ID numbers even when runs are deleted and mysql deamon restarted.
+  * Entries in the _RUNID_GEN table are never deleted.
+  *
+  **/
+ UInt_t PamelaDBOperations::AssignRunID(){
    //
-   if ( IsDebug() ) printf(" rhev before %i ph %i upperp %i oh %llu uppero %llu \n",rhev,pkth,upperpkt,obth,upperobt);
+   TSQLResult *result = 0;
-   if ( pkth > upperpkt && obth > upperobt ){
+   TSQLRow *row = 0;
-     if ( IsDebug() ) printf(" Upper limits extended to include last header: ph %i upperp %i oh %llu uppero %llu \n",pkth,upperpkt,obth,upperobt);
+   UInt_t runid = 0;
-     upperpkt = pkth;
-     upperobt = obth;
-     rhev = lasthead+1;
-   } else {
-     rhev = lasthead;
-   };
-   if ( IsDebug() ) printf(" rhev after %i ph %i upperp %i oh %llu uppero %llu \n",rhev,pkth,upperpkt,obth,upperobt);
    //
-   if ( IsDebug() ) printf(" Upper limits are: OBT %llu pkt_num %i upper entry %i \n",upperobt,upperpkt,upperentry);
+   stringstream   oss;
+   //
+   oss.str("");
+   oss << "INSERT INTO _RUNID_GEN VALUES (NULL);";
+   result = conn->Query(oss.str().c_str());
+   if ( !result ) throw -10;
+   oss.str("");
+   oss << "SELECT ID FROM _RUNID_GEN ORDER BY ID DESC LIMIT 1;";
+   result = conn->Query(oss.str().c_str());
+   if ( !result ) throw -10;
    //
-   return(0);
+   row = result->Next();
- }
+   //
+   if ( !row ) throw -28;
+   //
+   runid = (UInt_t)atoll(row->GetField(0));
+   //
+   return(runid);
+ };
  //
  // GETTERS
-Line 440 
 const PacketType* PamelaDBOperations::Ge
+Line 813 
 const PacketType* PamelaDBOperations::Ge
  // PRIVATE FUNCTIONS
  //
- /**
+ // /**
-  * Open the ROOT filename for reading
+ // * Open the ROOT filename for reading
-  */
+ // */
- void PamelaDBOperations::OpenFile(){
+ // void PamelaDBOperations::OpenFile(){
-   file = TFile::Open(this->GetRootName().Data());
+ //   file = TFile::Open(this->GetRootName().Data());
+ //   //
+ void PamelaDBOperations::CheckFile(){
+   if ( !file ) throw -12;
  };
  /**
   * Check if LEVEL0 file and DB connection have really be opened
   */
- void PamelaDBOperations::CheckFile(){
+ void PamelaDBOperations::CheckConnection(){
-   //
-   if ( !file ) throw -12;
    //
    // check connection
    //
    if( !conn ) throw -1;
    bool connect = conn->IsConnected();
    if( !connect ) throw -1;
+   //
+   if ( IsDebug() ) printf("\n DB INFORMATIONS:\n SQL: %s Version: %s Host %s Port %i \n\n",conn->GetDBMS(),conn->ServerInfo(),conn->GetHost(),conn->GetPort());
+   //
+   if ( !dworbit && strcmp(this->GetRootName().Data(),"") ) throw -27;
+   //
+   // set DB timezone to UTC
+   //
+   stringstream oss;
+   //
+   oss.str("");
+   oss << "SET time_zone='+0:00';";
+   TSQLResult *result = 0;
+   result = conn->Query(oss.str().c_str());
+   if ( !result ) throw -10;
+   oss.str("");
+   oss << "SET wait_timeout=173000;";
+   conn->Query(oss.str().c_str());
+   //
  };
  /**
   * Return the correct packet number if we went back to zero
   */
- UInt_t PamelaDBOperations::PKT(UInt_t pkt_num){
+ Long64_t PamelaDBOperations::PKT(UInt_t pkt_num){
    //
-   //  if ( IsDebug() ) printf(" pkt conversion: pkt_num is %u pktfirst is %u (pktfirst - (UInt_t)(16777212/2)) is %u  \n",pkt_num,pktfirst,(pktfirst - (UInt_t)(16777212/2)));
+   if ( IsDebug() ) printf(" pkt conversion: pkt_num is %u pktfirst is %u  (UInt_t)(16777214/2)) is %u  \n",pkt_num,ppktfirst,(UInt_t)(16777214/2));
    //
-   if ( pkt_num < (pktfirst/2) && pktfirst > (16777214/2)  ) return((pkt_num+16777215));
+   if ( pkt_num < (ppktfirst/2) && ppktfirst > (16777214/2)  ){
+     if ( IsDebug() ) printf(" rise up pktnum %lld \n",(Long64_t)pkt_num+16777215LL);
+     return((Long64_t)pkt_num+16777215LL);
+   };
    //
-   if ( pkt_num > pktfirst*2 && pkt_num > (16777214/2) ){
+   if ( pkt_num > ((Long64_t)ppktfirst*2) && pkt_num > (16777214/2) ){
-     if ( (pkt_num-16777215) < 0 ){
+     if ( IsDebug() ) printf(" rise down pktnum %lld \n",(Long64_t)pkt_num-16777215LL);
-       return((16777215-pkt_num));
+     return((Long64_t)pkt_num-16777215LL);
-     } else {
-       return((pkt_num-16777215));
-     };
    };
    //
-   return(pkt_num);
+   if ( IsDebug() ) printf(" as it is %lld \n",(Long64_t)pkt_num);
+   return((Long64_t)pkt_num);
    //
  };
  /**
   * Return the correct On Board Time if we went back to zero
   */
- ULong64_t PamelaDBOperations::OBT(UInt_t obt){
+ Long64_t PamelaDBOperations::OBT(UInt_t obt){
    //
-   if ( obt < (obtfirst/2) && obtfirst > (numeric_limits<UInt_t>::max()/2) ) return((ULong64_t)(obt+numeric_limits<UInt_t>::max()));
+   if ( IsDebug() ) printf(" obt conversion: obt is %u obtfirst is %u  (numeric_limits<UInt_t>::max()/2) is %u  \n",obt,pobtfirst,(UInt_t)(numeric_limits<UInt_t>::max()/2));
    //
-   if ( obt > (obtfirst*2) && obt > (numeric_limits<UInt_t>::max()/2) ){
+   if ( obt < (pobtfirst/2) && pobtfirst > (numeric_limits<UInt_t>::max()/2) ){
-     if ( (obt-numeric_limits<UInt_t>::max()) < 0  ){
+     if ( IsDebug() ) printf(" rise up obt %lld \n",(Long64_t)(obt+numeric_limits<UInt_t>::max()));
-       return((ULong64_t)(numeric_limits<UInt_t>::max()-obt));
+     return((Long64_t)(obt+numeric_limits<UInt_t>::max()));
-     } else {
+   };
-       return((ULong64_t)(obt-numeric_limits<UInt_t>::max()));
+   //
-     };
+   if ( obt > ((Long64_t)pobtfirst*2) && obt > (numeric_limits<UInt_t>::max()/2) ){
+     if ( IsDebug() ) printf(" pobtfirst*2 %lld \n",((Long64_t)pobtfirst*2));
+     if ( IsDebug() ) printf(" rise down pktnum %lld \n", (Long64_t)obt-(Long64_t)numeric_limits<UInt_t>::max());
+     return((Long64_t)obt-(Long64_t)numeric_limits<UInt_t>::max());
    };
    //
-   return((ULong64_t)obt);
+   if ( IsDebug() ) printf(" as it is %lld \n",(Long64_t)obt);
+   return((Long64_t)obt);
  };
  /**
-Line 550 
 void PamelaDBOperations::FillClass(Bool_
+Line 948 
 void PamelaDBOperations::FillClass(Bool_
      lastPkt = glrun->GetRUNTRAILER_PKT();
    };
    //
-   if ( mishead && mistrail && lastev+1 == firstev ) throw -14; // run with no events, no runtrailer, no runheader... unsupported
+   if ( mishead && mistrail && lastev+1 == firstev ) throw -14; // run with no events, no runtrailer, no runheader... unsupported should never arrive here
    //
    if ( mishead ) {
      glrun->Set_GL_RUNH0();
-Line 613 
 Int_t PamelaDBOperations::insertPamelaRa
+Line 1011 
 Int_t PamelaDBOperations::insertPamelaRa
    if ( idr ) return(1);
    //
    oss.str("");
-   oss << "INSERT INTO GL_RAW (PATH, NAME) VALUES ('"
+   if ( STATIC ){
-       << this->GetRawPath().Data() << "', '" << this->GetRawFile().Data() << "')";
+     oss << "INSERT INTO GL_RAW (PATH, NAME) VALUES ('"
+         << this->GetRawPath().Data() << "', '" << this->GetRawFile().Data() << "')";
+   } else {
+     oss << "INSERT INTO GL_RAW (PATH, NAME) VALUES ('$PAM_RAW', '" << this->GetRawFile().Data() << "')";
+   };
    if ( conn->Query(oss.str().c_str()) == 0 ) throw -4;
    //
    idr =  this->SetID_RAW();
-Line 633 
 Int_t PamelaDBOperations::insertPamelaGL
+Line 1035 
 Int_t PamelaDBOperations::insertPamelaGL
    TSQLResult *result = 0;
    TSQLRow *row = 0;
    UInt_t t0 = 0;
+   Int_t signal = 0;
+   //
+   signal = this->SetUpperLimits();
    //
    stringstream   oss;
    //
    if ( this->GetID_RAW() == 0 )  throw -11;
    //
    oss.str("");
-   oss << "SELECT OFFSET_DATE FROM GL_RESURS_OFFSET WHERE FROM_ID_RAW<= "
+   oss << "SELECT YEAR(OFFSET_DATE),MONTH(OFFSET_DATE),DAY(OFFSET_DATE),HOUR(OFFSET_DATE),MINUTE(OFFSET_DATE),SECOND(OFFSET_DATE) FROM GL_RESURS_OFFSET WHERE SPECIAL_FILE='"
-       << id << " AND TO_ID_RAW >= "
+       << this->GetRawFile().Data() << "';";
-       << id << ";";
    if ( IsDebug() ) printf(" %s \n",oss.str().c_str());
    result = conn->Query(oss.str().c_str());
    if ( !result ) throw -10;
    row = result->Next();
-   if ( !row ) throw -10;
    //
-   t0 = (UInt_t)TDatime(row->GetField(0)).Convert();
+   if ( !row ){
+     oss.str("");
+     oss << "SELECT YEAR(OFFSET_DATE),MONTH(OFFSET_DATE),DAY(OFFSET_DATE),HOUR(OFFSET_DATE),MINUTE(OFFSET_DATE),SECOND(OFFSET_DATE) FROM GL_RESURS_OFFSET WHERE FROM_ORBIT< "
+         << dworbit << " order by FROM_ORBIT desc limit 1;";
+     if ( IsDebug() ) printf(" %s \n",oss.str().c_str());
+     result = conn->Query(oss.str().c_str());
+     if ( !result ) throw -10;
+     row = result->Next();
+     if ( !row ) throw -10;
+   };
+   //
+   TTimeStamp tu = TTimeStamp((UInt_t)atoi(row->GetField(0)),(UInt_t)atoi(row->GetField(1)),(UInt_t)atoi(row->GetField(2)),(UInt_t)atoi(row->GetField(3)),(UInt_t)atoi(row->GetField(4)),(UInt_t)atoi(row->GetField(5)),0,true,0);
+   t0 = (UInt_t)tu.GetSec();
+   if ( IsDebug() ) printf(" t0 is %u ti is %s %s %s %s %s %s\n",t0,row->GetField(0),row->GetField(1),row->GetField(2),row->GetField(3),row->GetField(4),row->GetField(5));
+   //
    /*
     * Verify that the TIMESYNC have been not already processed
     */
-Line 663 
 Int_t PamelaDBOperations::insertPamelaGL
+Line 1080 
 Int_t PamelaDBOperations::insertPamelaGL
    if (result == NULL) throw -10;
    row = result->Next();
    if ((row != NULL) && ((UInt_t)atoll(row->GetField(0)) > 0)){
+     if ( IsDebug() ) printf(" found a timesync t0 is %u \n",t0);
      toffset = (UInt_t)atoll(row->GetField(2)) - (UInt_t)(this->OBT((UInt_t)atoll(row->GetField(1)))/1000) + t0;
+     //
+     tsync = (UInt_t)atoll(row->GetField(2));
+     obt0 = (UInt_t)atoll(row->GetField(1));
+     //
      return(1);
    };
    //
-Line 719 
 Int_t PamelaDBOperations::insertPamelaGL
+Line 1141 
 Int_t PamelaDBOperations::insertPamelaGL
          //
          TYPE = 55;//224;
          //
+         if ( IsDebug() ) printf("mcmd tsync %i tsync %u obt %u \n",i,TSYNC,OBT);
+         //
          if ( TSYNC && OBT ){
            existsts = true;
-           goto out;
+           goto eout;
          };
          //
        };
-Line 729 
 Int_t PamelaDBOperations::insertPamelaGL
+Line 1153 
 Int_t PamelaDBOperations::insertPamelaGL
    };
    if ( !existsts ) { // try with runheader and runtrailer
      //
+     if ( IsDebug() ) printf(" No ts mcmd \n");
+     signal = 2;
+     //
      TTree *rh=(TTree*)file->Get("RunHeader");
      if ( !rh || rh->IsZombie() ) throw -17;
      TTree *rt=(TTree*)file->Get("RunTrailer");
-Line 738 
 Int_t PamelaDBOperations::insertPamelaGL
+Line 1165 
 Int_t PamelaDBOperations::insertPamelaGL
      //
      rt->SetBranchAddress("RunTrailer", &runt);
      //
-     //    Int_t rhev = rh->GetEntries();
+     Int_t nrhev = rh->GetEntries();
-     //    Int_t rtev = rt->GetEntries();
+     Int_t nrtev = rt->GetEntries();
+     if ( IsDebug() ) printf(" ou nevent %i rhev %i rtev %i \n",nevent,nrhev,nrtev);
      //
-     if ( rhev > 0 ){
+     if ( nrhev > 0 ){
-       rh->GetEntry(0);
+       for (Int_t i=0; i<nrhev; i++){
-       //
+         //
-       TSYNC = runh->LAST_TIME_SYNC_INFO;
+         rh->GetEntry(i);
-       OBT = runh->OBT_TIME_SYNC * 1000;
+         //
-       //
+         TSYNC = runh->LAST_TIME_SYNC_INFO;
-       TYPE = 20;
+         OBT = runh->OBT_TIME_SYNC * 1000;
-       //
+         //
-       if ( TSYNC && OBT ){
+         TYPE = 20;
-         existsts = true;
+         //
-         goto out;
+         if ( IsDebug() ) printf("runheader %i tsync %u obt %u \n",i,TSYNC,OBT);
+         //
+         if ( TSYNC && OBT ){
+           existsts = true;
+           goto eout;
+         };
        };
        //
      };
-     if ( rtev > 0 ){
+     if ( nrtev > 0 ){
-       rt->GetEntry(0);
        //
-       TSYNC = runt->LAST_TYME_SYNC_INFO;
+       if ( IsDebug() ) printf(" No runheader \n");
-       OBT = runt->OBT_TYME_SYNC * 1000;
+       signal = 6;
        //
-       TYPE = 21;
+       for (Int_t i=0; i<nrtev; i++){
-       //
+         //
-       if ( TSYNC && OBT ){
+         rt->GetEntry(i);
-         existsts = true;
+         //
-         goto out;
+         TSYNC = runt->LAST_TYME_SYNC_INFO;
+         OBT = runt->OBT_TYME_SYNC * 1000;
+         //
+         TYPE = 21;
+         //
+         if ( IsDebug() ) printf("runtrailer %i tsync %u obt %u \n",i,TSYNC,OBT);
+         //
+         if ( TSYNC && OBT ){
+           existsts = true;
+           goto eout;
+         };
        };
        //
+     } else {
+       if ( IsDebug() ) printf(" No runheader \n");
      };
    };
    //
    if ( !existsts ){ // try with inclination mcmd
+     //
+     if ( IsDebug() ) printf(" No runtrailer \n");
+     signal = 14;
+     //
      Double_t timesync = 0.;
      for (UInt_t i=0; i<nevent;i++){
        //
-Line 800 
 Int_t PamelaDBOperations::insertPamelaGL
+Line 1248 
 Int_t PamelaDBOperations::insertPamelaGL
        TYPE = 666;
        if ( TSYNC && OBT ){
          existsts = true;
-         goto out;
+         goto eout;
        };
      };
    };
    //
    if ( !existsts && obt0 ){ // insert timesync by hand
+     //
+     if ( IsDebug() ) printf(" No incl mcmd \n");
+     signal = 30;
+     //
      OBT = obt0;
      TSYNC = tsync;
      TYPE = 999;
      existsts = true;
-     goto out;
+     goto eout;
    };
    //
-  out:
+  eout:
    //
    if ( !existsts ) throw -3;
    //
-Line 826 
 Int_t PamelaDBOperations::insertPamelaGL
+Line 1278 
 Int_t PamelaDBOperations::insertPamelaGL
    conn->Query(oss.str().c_str());
    if ( IsDebug() ) printf(" Query the GL_TIMESYNC table to fill it:\n %s \n",oss.str().c_str());
    //
+   if ( IsDebug() ) printf(" found a timesync t0 is %u \n",t0);
    toffset = (UInt_t)TSYNC - (UInt_t)(this->OBT(OBT)/1000) + t0;
    //
+   tsync = TSYNC;
+   obt0 = OBT;
+   //
    delete result;
-   return(0);
+   return(signal);
  }
  /**
-Line 843 
 Int_t PamelaDBOperations::insertPamelaRo
+Line 1299 
 Int_t PamelaDBOperations::insertPamelaRo
    UInt_t idtimesync = 0;
    //
    oss.str("");
-   oss << " SELECT COUNT(GL_ROOT.ID_RAW),GL_RAW.ID,GL_ROOT.ID FROM GL_RAW "
+   if ( STATIC ){
-       << " LEFT JOIN GL_ROOT "
+     oss << " SELECT COUNT(GL_ROOT.ID_RAW),GL_RAW.ID,GL_ROOT.ID FROM GL_RAW "
-       << " ON GL_RAW.ID = GL_ROOT.ID_RAW "
+         << " LEFT JOIN GL_ROOT "
-       << " WHERE GL_RAW.PATH = '" << this->GetRawPath().Data() << "' AND "
+         << " ON GL_RAW.ID = GL_ROOT.ID_RAW "
-       << " GL_RAW.NAME = '" << this->GetRawFile().Data() << "' GROUP BY GL_RAW.ID ";
+         << " WHERE GL_RAW.PATH = '" << this->GetRawPath().Data() << "' AND "
+         << " GL_RAW.NAME = '" << this->GetRawFile().Data() << "' GROUP BY GL_RAW.ID ";
+   } else {
+     oss << " SELECT COUNT(GL_ROOT.ID_RAW),GL_RAW.ID,GL_ROOT.ID FROM GL_RAW "
+         << " LEFT JOIN GL_ROOT "
+         << " ON GL_RAW.ID = GL_ROOT.ID_RAW "
+         << " WHERE GL_RAW.PATH = '$PAM_RAW' AND "
+         << " GL_RAW.NAME = '" << this->GetRawFile().Data() << "' GROUP BY GL_RAW.ID ";
+   };
    result = conn->Query(oss.str().c_str());
    //
    if ( !result ) throw -12;
-Line 874 
 Int_t PamelaDBOperations::insertPamelaRo
+Line 1338 
 Int_t PamelaDBOperations::insertPamelaRo
    idtimesync = (UInt_t)atoll(row->GetField(0));
    //
    oss.str("");
-   oss << "INSERT INTO GL_ROOT (ID_RAW, ID_TIMESYNC,PATH, NAME) VALUES ('"
+   if ( STATIC ){
-       << this->GetID_RAW() << "', '" << idtimesync << "', '" << this->GetRootPath().Data() << "', '" << this->GetRootFile().Data() << "')";
+     oss << "INSERT INTO GL_ROOT (ID_RAW, ID_TIMESYNC,PATH, NAME) VALUES ('"
+         << this->GetID_RAW() << "', '" << idtimesync << "', '" << this->GetRootPath().Data() << "', '" << this->GetRootFile().Data() << "')";
+   } else {
+     oss << "INSERT INTO GL_ROOT (ID_RAW, ID_TIMESYNC,PATH, NAME) VALUES ('"
+         << this->GetID_RAW() << "', '" << idtimesync << "', '$PAM_L0', '" << this->GetRootFile().Data() << "')";
+   };
    //
    if (conn->Query(oss.str().c_str()) == 0) throw -4;
    //
-Line 902 
 Int_t PamelaDBOperations::assignBOOT_NUM
+Line 1371 
 Int_t PamelaDBOperations::assignBOOT_NUM
    TSQLResult *result = 0;
    TSQLRow    *row    = 0;
    oss.str("");
-   oss << "SELECT ID, BOOT_NUMBER FROM GL_RAW WHERE "
+   if ( STATIC ){
-       << " PATH = '" << this->GetRawPath().Data() << "' AND "
+     oss << "SELECT ID, BOOT_NUMBER FROM GL_RAW WHERE "
-       << " NAME = '" << this->GetRawFile().Data() << "' ";
+         << " PATH = '" << this->GetRawPath().Data() << "' AND "
+         << " NAME = '" << this->GetRawFile().Data() << "' ";
+   } else {
+     oss << "SELECT ID, BOOT_NUMBER FROM GL_RAW WHERE "
+         << " PATH = '$PAM_RAW' AND "
+         << " NAME = '" << this->GetRawFile().Data() << "' ";
+   };
    result = conn->Query(oss.str().c_str());
    //
-   if ( !result ) return(8);
+   if ( !result ) throw -4;;
    row = result->Next();
    if ( !row ) return(16);
    if ( row->GetField(1) ){
      this->SetBOOTnumber((UInt_t)atoll(row->GetField(1)));
      return(1);
    };
-   if ( !row->GetField(0) ) return(8);
+   if ( !row->GetField(0) ) throw -26;
    //
    UInt_t idRaw = (UInt_t)atoll(row->GetField(0));
    //
-Line 924 
 Int_t PamelaDBOperations::assignBOOT_NUM
+Line 1399 
 Int_t PamelaDBOperations::assignBOOT_NUM
    trDumpEv = (TTree*)file->Get("VarDump");
    if ( !trDumpEv || trDumpEv->IsZombie() ) throw -20;
    //
-   if (trDumpEv == NULL) return(2);
-   //
    VarDumpEvent  *vde = 0;
    VarDumpRecord *vdr = 0;
    //
+   Bool_t found = false;
    trDumpEv->SetBranchAddress("VarDump", &vde);
-   if (trDumpEv->GetEntries() > 0){
+   if ( trDumpEv->GetEntries() > 0 ){
-     trDumpEv->GetEntry(0);
+     found = false;
-     vde->Records->GetEntries();
+     for ( Int_t i = 0; i < trDumpEv->GetEntries(); i++){
-     if ( !vde->Records->GetEntries() ){
+       trDumpEv->GetEntry(i);
-       if ( !this->GetBOOTnumber() ) return(4);
+       //      vde->Records->GetEntries();
-     } else {
+       if ( vde->Records->GetEntries()>5 ){
+         found = true;
+         goto fill;
+       };
+     };
+   fill:
+     if ( found ){
+       //
        vdr = (VarDumpRecord*)vde->Records->At(6);
+       //
        this->SetBOOTnumber((Int_t)vdr->VAR_VALUE);
+       //
+     } else {
+       if ( !this->GetBOOTnumber() && !this->AutoBoot()) return(4);
      };
    } else {
-     if ( !this->GetBOOTnumber() ) return(2);
+     if ( !this->GetBOOTnumber() && !this->AutoBoot()) return(2);
    };
    //
-   oss.str("");
+   UInt_t bn = 0;
-   oss << " UPDATE GL_RAW "
+   Bool_t afound = false;
-       << " SET GL_RAW.BOOT_NUMBER = '" << dec << this->GetBOOTnumber() << "'"
+   if ( !found && this->AutoBoot()){
-       << " WHERE GL_RAW.ID = '" << idRaw << "'";
+     afound = true;
-   conn->Query(oss.str().c_str());
+     //
-   //
+     // Search for other files with similar timesync
-   delete result;
+     //
-   return(0);
+     if ( IsDebug() ) printf(" tsync %u obt0 %u \n",tsync,obt0);
- };
+     UInt_t upperts = tsync-(obt0/1000)+5;
+     UInt_t lowerts = tsync-(obt0/1000)-5;
- /**
+     oss.str("");
-  * Scan runtrailer packet, fill the GL_RUN table and
+     oss << "select GL_RAW.BOOT_NUMBER from GL_TIMESYNC LEFT JOIN GL_RAW ON GL_RAW.ID = GL_TIMESYNC.ID_RAW where TIMESYNC-(OBT0/1000)<"
-  * check for missing and truncated runs
+         << upperts
-  */
+         << " AND TIMESYNC-(OBT0/1000)>"
- Int_t PamelaDBOperations::insertPamelaRUN(){
+         << lowerts
+         << " AND GL_RAW.BOOT_NUMBER>0 GROUP BY GL_TIMESYNC.OBT0;";
+     result = conn->Query(oss.str().c_str());
+     if ( IsDebug() ) printf(" Query the GL_TIMESYNC table to find boot number:\n %s \n",oss.str().c_str());
+     //
+     if ( !result ) throw -4;;
+     found = true;
+     if ( result->GetRowCount()<3 ){
+       if ( IsDebug() ) printf(" AGH! no results!\n");
+       found = false;
+     } else {
+       row = result->Next();
+       bn = (UInt_t)atoll(row->GetField(0));
+       for ( Int_t r=1; r<result->GetRowCount() ;r++){
+         if ( !row ) throw -4;
+         if ( IsDebug() ) printf(" BOOT number is %s \n",row->GetField(0));
+         if ( bn != (UInt_t)atoll(row->GetField(0)) ){
+           if ( IsDebug() ) printf(" AGH! bn = %u here instead %u \n",bn,(UInt_t)atoll(row->GetField(0)));
+           found = false;
+         };
+         row = result->Next();
+       };
+     };
+   };
+   //
+   Int_t sgn = 0;
+   //
+   if ( !found && !BOOTNO ){
+     throw -29;
+   } else {
+     if ( afound ){
+       this->SetBOOTnumber(bn);
+       sgn = 8;
+     };
+   };
+   //
+   oss.str("");
+   oss << " UPDATE GL_RAW "
+       << " SET GL_RAW.BOOT_NUMBER = '" << dec << this->GetBOOTnumber() << "'"
+       << " WHERE GL_RAW.ID = '" << idRaw << "'";
+   conn->Query(oss.str().c_str());
+   //
+   delete result;
+   return(sgn);
+ };
+ /**
+  * Scan runtrailer packet, fill the GL_RUN table and
+  * check for missing and truncated runs
+  */
+ Int_t PamelaDBOperations::insertPamelaRUN(){
    Int_t signal = 0;
    //
    stringstream oss;
    oss.str("");
    //
-   signal = this->SetUpperLimits();
+   //  signal = this->SetUpperLimits();
    //
    // loop on runheader and runtrailer events
    //
-Line 981 
 Int_t PamelaDBOperations::insertPamelaRU
+Line 1516 
 Int_t PamelaDBOperations::insertPamelaRU
    rt->SetBranchAddress("RunTrailer", &runt);
    rt->SetBranchAddress("Header", &eht);
    //
+   TTree *T = (TTree*)file->Get("Physics");
+   if ( !T || T->IsZombie() ) throw -16;
+   EventHeader *eh = 0;
+   T->SetBranchAddress("Header", &eh);
+   //
+   if ( !(rh->GetEntries()) && !(rt->GetEntries()) && !(T->GetEntries()) ) return(16);
+   //
    UInt_t obtt = 0;
    UInt_t obth = 0;
    UInt_t pktt = 0;
-Line 1014 
 Int_t PamelaDBOperations::insertPamelaRU
+Line 1556 
 Int_t PamelaDBOperations::insertPamelaRU
        //
        if ( !ptt &&  !(ptht+1) ){
          //
-         if ( IsDebug() ) printf(" Piece of run at the beginning of the file %i %i %i \n",ptht,pth,ptt);
+         if ( IsDebug() ) printf(" Piece of run at the beginning of the file %u %u %u \n",ptht,pth,ptt);
          //
          this->HandleRunFragments(true,false,0,(evbeft-1));
          //
          //
        } else if ( pth == ptht ){
          //
-         if ( IsDebug() ) printf(" Missing header %i %i %i\n",ptht,pth,ptt);
+         if ( IsDebug() ) printf(" Missing header %u %u %u\n",ptht,pth,ptt);
          //
-         if ( (ptt-1) < 0 ) throw -15;
+         if ( (ptt-1) < 0 ) throw -15; // should never arrive here!
          rt->GetEntry(ptt-1);
          cod = eht->GetCounter();
          evbefh = cod->Get(pctp->Physics);
          rt->GetEntry(ptt);
          pht = eht->GetPscuHeader();
          //
-         if ( IsDebug() ) printf(" Try to find the beginning of a run which has only the runtrailer   %i %i %i \n",ptht,pth,ptt);
+         if ( IsDebug() ) printf(" Try to find the beginning of a run which has only the runtrailer   %u %u %u \n",ptht,pth,ptt);
-         if ( IsDebug() ) printf(" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''  %i %i %i \n",pkth,obth,obtt);
+         if ( IsDebug() ) printf(" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''  %u %u %u \n",pkth,obth,obtt);
          //
          this->HandleMissingHoT(true,false,evbefh,evbeft-1);
          //
        } else {
          //
-         if ( IsDebug() ) printf(" Could be a good run, we have a runheader followed by a runtrailer %i %i %i\n",ptht,pth,ptt);
+         if ( IsDebug() ) printf(" Could be a good run, we have a runheader followed by a runtrailer %u %u %u\n",ptht,pth,ptt);
          //
          rh->GetEntry(ptht);
          phh = ehh->GetPscuHeader();
-Line 1045 
 Int_t PamelaDBOperations::insertPamelaRU
+Line 1587 
 Int_t PamelaDBOperations::insertPamelaRU
          obth = phh->GetOrbitalTime();
          cod = ehh->GetCounter();
          evbefh = cod->Get(pctp->Physics);
-         if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' %i %i %i \n",pkth,obth,obtt);
+         if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' %u %u %u \n",pkth,obth,obtt);
          //
          // handle this run
          //
-Line 1055 
 Int_t PamelaDBOperations::insertPamelaRU
+Line 1597 
 Int_t PamelaDBOperations::insertPamelaRU
          //
          if ( PKT(pkth)>PKT(pktfirst) && OBT(obth)>OBT(obtfirst) && !ptt ){
            //
-           if ( IsDebug() ) printf(" Piece of run at the beginning of the file WITH NO RUNTRAILER \n");
+           if ( IsDebug() ) printf(" Piece of run at the beginning of the file WITH NO RUNTRAILER evbefh = %u \n",evbefh);
-           //
-           this->HandleRunFragments(true,true,0,(evbefh-1));
            //
+           if ( evbefh == 0 ) {
+             //
+             signal = 8;
+             if ( IsDebug() ) printf(" Not supported yet: run with no events, no runtrailer, no runheader \n");
+             //
+           } else {
+             //
+             this->HandleRunFragments(true,true,0,(evbefh-1));
+             //
+           };
          };
          //
          //
          if ( (ptht - pth) > 1 ){
            //
            if ( IsDebug() ) printf(" Missing runtrailers! \n");
-           if ( IsDebug() ) printf(" Attention there is a jump in the runheader counter %i %i %i \n",ptht,pth,ptt);
+           if ( IsDebug() ) printf(" Attention there is a jump in the runheader counter %u %u %u \n",ptht,pth,ptt);
            // is not the consecutive header
            while ( pth != ptht ){
              //
-Line 1086 
 Int_t PamelaDBOperations::insertPamelaRU
+Line 1636 
 Int_t PamelaDBOperations::insertPamelaRU
              obth = phh->GetOrbitalTime();
              evbefh = cod->Get(pctp->Physics);
              //
-             if ( IsDebug() ) printf(" Try to find the end of a run which has only the runheader   %i %i %i \n",ptht,pth,ptt);
+             if ( IsDebug() ) printf(" Try to find the end of a run which has only the runheader   %u %u %u \n",ptht,pth,ptt);
-             if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' %i %i %i \n",pkth,obth,obtt);
+             if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' %u %u %u \n",pkth,obth,obtt);
              //
              this->HandleMissingHoT(false,true,evbefh,evbeft-1);
              //
-Line 1096 
 Int_t PamelaDBOperations::insertPamelaRU
+Line 1646 
 Int_t PamelaDBOperations::insertPamelaRU
          } else if ( !(ptht - pth) ){
            //
            if ( IsDebug() ) printf(" Missing runheader! \n");
-           if ( IsDebug() ) printf(" Attention! the runheader counter did not changed %i %i %i \n",ptht,pth,ptt);
+           if ( IsDebug() ) printf(" Attention! the runheader counter did not changed %u %u %u \n",ptht,pth,ptt);
            if ( IsDebug() ) printf(" The run should have already been handled by HandleRun() \n");
            //
          } else {
-Line 1117 
 Int_t PamelaDBOperations::insertPamelaRU
+Line 1667 
 Int_t PamelaDBOperations::insertPamelaRU
            obth = phh->GetOrbitalTime();
            cod = ehh->GetCounter();
            evbefh = cod->Get(pctp->Physics);
-           if ( IsDebug() ) printf(" Piece of run at the end of file %i %i %i \n",pkth,obth,obtt);
+           if ( IsDebug() ) printf(" Piece of run at the end of file %u %u %u \n",pkth,obth,obtt);
-           if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''' %i %i %i \n",ptht,pth,ptt);
+           if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''' %u %u %u \n",ptht,pth,ptt);
-           if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''' %i \n",rhev);
+           if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''' %u \n",rhev);
            //
            this->HandleRunFragments(false,true,evbefh,upperentry);
          } else {
-Line 1129 
 Int_t PamelaDBOperations::insertPamelaRU
+Line 1679 
 Int_t PamelaDBOperations::insertPamelaRU
            if ( (UInt_t)evbeft < upperentry-1 ){
              if ( IsDebug() ) printf(" Piece of run at the end of the file with NO RUNHEADER!\n");
              //
-             if ( (ptt-1) < 0 ) throw -15;
+             if ( (ptt-1) < 0 ) throw -15; // should never arrive here!
              rt->GetEntry(ptt-1);
              cod = eht->GetCounter();
              evbefh = cod->Get(pctp->Physics);
-Line 1167 
 Bool_t PamelaDBOperations::IsRunAlreadyI
+Line 1717 
 Bool_t PamelaDBOperations::IsRunAlreadyI
    //                                  ( runhead_time <= _our_runhead_time &&  runtrail_time >= _our_runtrail_time) &&
    //                                  ( runhead_obt <= _our_runheadobt || runhead_pkt <= _our_runheadpkt ) &&
    //                                  ( runtrail_obt <= _our_runtrailobt || runtrail_pkt <= _our_runtrailpkt ) )
+   //                                  ||
+   //                                  ( runhead_time = _our_runhead_time &&  runtrail_time = _our_runtrail_time && nevents > 100 )
+   //                                  )
+   //                                  ||
+   //                                  ( runhead_time = _our_runhead_time &&  runtrail_time > _our_runtrail_time && nevents > 100 )
+   //                                  )
+   //                                  ||
+   //                                  ( runhead_time < _our_runhead_time &&  runtrail_time = _our_runtrail_time && nevents > 100 )
    //                                  )
    //
    oss << " SELECT ID,NEVENTS,TRK_CALIB_USED,PKT_COUNTER FROM GL_RUN WHERE "
-Line 1182 
 Bool_t PamelaDBOperations::IsRunAlreadyI
+Line 1740 
 Bool_t PamelaDBOperations::IsRunAlreadyI
        << " RUNHEADER_OBT<=" << glrun->GetRUNHEADER_OBT() << " OR "
        << " RUNHEADER_PKT<=" << glrun->GetRUNHEADER_PKT() << ") AND ("
        << " RUNTRAILER_OBT>=" << glrun->GetRUNTRAILER_OBT() << " OR "
-       << " RUNTRAILER_PKT>=" << glrun->GetRUNTRAILER_PKT() << ") ));";
+       << " RUNTRAILER_PKT>=" << glrun->GetRUNTRAILER_PKT() << ") OR "
+       << " (RUNHEADER_TIME=" << (UInt_t)glrun->GetRUNHEADER_TIME() << " AND "                //  these two lines in a certain way disable the patch below...
+       << " RUNTRAILER_TIME=" << (UInt_t)glrun->GetRUNTRAILER_TIME() <<" AND NEVENTS>100)"    //
+       << " (RUNHEADER_TIME=" << (UInt_t)glrun->GetRUNHEADER_TIME() << " AND "                //
+       << " RUNTRAILER_TIME>" << (UInt_t)glrun->GetRUNTRAILER_TIME() <<" AND NEVENTS>100)"    //
+       << " (RUNHEADER_TIME<" << (UInt_t)glrun->GetRUNHEADER_TIME() << " AND "                //
+       << " RUNTRAILER_TIME=" << (UInt_t)glrun->GetRUNTRAILER_TIME() <<" AND NEVENTS>100)"    //
+       << " ));";
    //
    if ( IsDebug() ) printf(" check if run has been inserted: query is \n %s \n",oss.str().c_str());
    result = conn->Query(oss.str().c_str());
-Line 1204 
 Bool_t PamelaDBOperations::IsRunAlreadyI
+Line 1769 
 Bool_t PamelaDBOperations::IsRunAlreadyI
      //
      // the run has already been inserted
      //
-     //    return(true);  //<<<<<<<<<<<<<<<<<<<<<<<< patch follows, uncomment here
+     if ( signal && IsDebug() ) printf(" The run has already been inserted \n");
+     return(true);  //<<<<<<<<<<<<<<<<<<<<<<<< patch follows, uncomment here
      //
      // PATCH!
      // we keep the processing run if (in order of growing importance) 1) we have the runtrailer while the old run doesn't have it 2) we have the runheader
-Line 1213 
 Bool_t PamelaDBOperations::IsRunAlreadyI
+Line 1779 
 Bool_t PamelaDBOperations::IsRunAlreadyI
      if ( glrun->GetNEVENTS() > (UInt_t)atoll(row->GetField(1)) ){
        //
        if ( IsDebug() ) printf(" The new run has more events than the old one \n");
-       oss.str("");
+       glrun->DeleteRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN");
-       oss << "DELETE FROM GL_RUN WHERE ID=" << row->GetField(0) <<";";
+ //       oss.str("");
-       if ( IsDebug() ) printf(" delete the run entry: query is \n %s \n",oss.str().c_str());
+ //       oss << "DELETE FROM GL_RUN WHERE ID=" << row->GetField(0) <<";";
-       conn->Query(oss.str().c_str());
+ //       if ( IsDebug() ) printf(" delete the run entry: query is \n %s \n",oss.str().c_str());
+ //       conn->Query(oss.str().c_str());
        if ( signal ) signal = false;
        goto gonext;
        //
-Line 1230 
 Bool_t PamelaDBOperations::IsRunAlreadyI
+Line 1797 
 Bool_t PamelaDBOperations::IsRunAlreadyI
        //
        if ( IsDebug() ) printf(" The new run has the same number of events and the runheader the old one miss the runheader \n");
        //
-       oss.str("");
+       glrun->DeleteRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN");
-       oss << "DELETE FROM GL_RUN WHERE ID=" << row->GetField(0) <<";";
+ //       oss.str("");
-       if ( IsDebug() ) printf(" delete the run entry: query is \n %s \n",oss.str().c_str());
+ //       oss << "DELETE FROM GL_RUN WHERE ID=" << row->GetField(0) <<";";
-       conn->Query(oss.str().c_str());
+ //       if ( IsDebug() ) printf(" delete the run entry: query is \n %s \n",oss.str().c_str());
+ //       conn->Query(oss.str().c_str());
        //
        if ( signal ) signal = false;
        goto gonext;
-Line 1247 
 Bool_t PamelaDBOperations::IsRunAlreadyI
+Line 1815 
 Bool_t PamelaDBOperations::IsRunAlreadyI
        //
        if ( IsDebug() ) printf(" The new run has the same number of events, the runheader and the runtrailer the old one miss the runtrailer \n");
        //
-       oss.str("");
+       glrun->DeleteRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN");
-       oss << "DELETE FROM GL_RUN WHERE ID=" << row->GetField(0) <<";";
+ //       oss.str("");
-       if ( IsDebug() ) printf(" delete the run entry: query is \n %s \n",oss.str().c_str());
+ //       oss << "DELETE FROM GL_RUN WHERE ID=" << row->GetField(0) <<";";
-       conn->Query(oss.str().c_str());
+ //       if ( IsDebug() ) printf(" delete the run entry: query is \n %s \n",oss.str().c_str());
+ //       conn->Query(oss.str().c_str());
        if ( signal ) signal = false;
        //
      };
-Line 1265 
 Bool_t PamelaDBOperations::IsRunAlreadyI
+Line 1834 
 Bool_t PamelaDBOperations::IsRunAlreadyI
    delete result;
    //
    if ( signal && IsDebug() ) printf(" The run has already been inserted \n");
+   if ( !signal && IsDebug() ) printf(" The run existed and was deleted, fill the DB \n");
    return(signal);
  };
-Line 1286 
 void PamelaDBOperations::HandleRun(){
+Line 1856 
 void PamelaDBOperations::HandleRun(){
      //
      this->FillClass();
      //
-     if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);
+     if ( !IsRunAlreadyInserted() ){
+       glrun->SetID(this->AssignRunID());
+       glrun->SetID_RUN_FRAG(0);
+       glrun->Fill_GL_RUN(conn);
+     };
    } else {
      //
      if ( IsDebug() ) printf(" oh no! the distance between runheader and runtrailer seems wrong: check %llu pktt %llu \n",chkpkt,pktt);
-Line 1309 
 void PamelaDBOperations::HandleRunFragme
+Line 1883 
 void PamelaDBOperations::HandleRunFragme
    UInt_t rhfirstev = firstev;
    UInt_t rtlastev = lastev;
    Bool_t found = false;
+   Bool_t foundinrun = false;
    //
    TSQLResult *result = 0;
    TSQLRow    *row    = 0;
-Line 1335 
 void PamelaDBOperations::HandleRunFragme
+Line 1910 
 void PamelaDBOperations::HandleRunFragme
    //
    if ( IsDebug() ) printf("The run is good, is it the other piece in the GL_RUN_FRAGMENTS table?\n");
    //
+   // First of all insert the run in the fragment table...
+   //
+   oss.str("");
+   oss << " SELECT ID FROM GL_RUN_FRAGMENTS WHERE "
+       << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND ("
+       << " (RUNHEADER_TIME>=" << (UInt_t)(glrun->GetRUNHEADER_TIME()-10) << " AND "
+       << " RUNTRAILER_TIME<=" << (UInt_t)(glrun->GetRUNTRAILER_TIME()+10) << " AND ("
+       << " RUNHEADER_OBT>=" << glrun->GetRUNHEADER_OBT() << " OR "
+       << " RUNHEADER_PKT>=" << glrun->GetRUNHEADER_PKT() << ") AND ("
+       << " RUNTRAILER_OBT<=" << glrun->GetRUNTRAILER_OBT() << " OR "
+       << " RUNTRAILER_PKT<=" << glrun->GetRUNTRAILER_PKT() << ") ) OR "
+       << " (RUNHEADER_TIME<=" << (UInt_t)glrun->GetRUNHEADER_TIME() << " AND "
+       << " RUNTRAILER_TIME>=" << (UInt_t)glrun->GetRUNTRAILER_TIME() <<" AND ("
+       << " RUNHEADER_OBT<=" << glrun->GetRUNHEADER_OBT() << " OR "
+       << " RUNHEADER_PKT<=" << glrun->GetRUNHEADER_PKT() << ") AND ("
+       << " RUNTRAILER_OBT>=" << glrun->GetRUNTRAILER_OBT() << " OR "
+       << " RUNTRAILER_PKT>=" << glrun->GetRUNTRAILER_PKT() << ") ));";
+   //
+   if ( IsDebug() ) printf(" check if run has been inserted: query is \n %s \n",oss.str().c_str());
+   result = conn->Query(oss.str().c_str());
+   //
+   if ( !result ) throw -4;
+   //
+   row = result->Next();
+   //
+   if ( !row ){
+     //
+     // no, insert this run in the GL_RUN_FRAGMENTS table (check if exist before!)
+     //
+     if ( IsDebug() ) printf(" The run is new \n");
+     if ( IsDebug() ) printf(" -> fill the GL_RUNFRAGMENTS table \n");
+     //
+     glrun->SetID(this->AssignRunID());
+     glrun->SetID_RUN_FRAG(0);
+     glrun->Fill_GL_RUN_FRAGMENTS(conn);
+     //
+   } else {
+     if ( IsDebug() ) printf(" The run is already present in the fragment table \n");
+     return;
+   };
+   //
+   //
    // can we find the other piece of the run in the GL_RUN_FRAGMENTS table?
    //
    if ( mishead && rhfirstev == firstev ) { // look for runheader (only when at the beginning of the file, if at the end and the runh is
-Line 1343 
 void PamelaDBOperations::HandleRunFragme
+Line 1960 
 void PamelaDBOperations::HandleRunFragme
      oss.str("");
      oss << " SELECT ID,TRK_CALIB_USED,RUNTRAILER_TIME,RUNTRAILER_OBT,RUNHEADER_PKT,RUNTRAILER_PKT FROM GL_RUN_FRAGMENTS WHERE "
          << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND "
-         << " RUNHEADER_TIME <= " << (UInt_t)glrun->GetRUNHEADER_TIME()
+         << " RUNHEADER_TIME <= " << (UInt_t)glrun->GetRUNHEADER_TIME() << " AND "
+         << " ID != " << glrun->ID
          << " ORDER BY RUNHEADER_TIME DESC LIMIT 1;"; // DESC NOT ASC!!
      //
      if ( IsDebug() ) printf(" look for runheader in the fragments table: query is \n %s \n",oss.str().c_str());
-Line 1353 
 void PamelaDBOperations::HandleRunFragme
+Line 1971 
 void PamelaDBOperations::HandleRunFragme
      //
      row = result->Next();
      //
+     if ( !row && NoFrag() ){
+       //
+       oss.str("");
+       oss << " SELECT ID,TRK_CALIB_USED,RUNTRAILER_TIME,RUNTRAILER_OBT,RUNHEADER_PKT,RUNTRAILER_PKT FROM GL_RUN WHERE "
+           << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND "
+           << " RUNHEADER_TIME <= " << (UInt_t)glrun->GetRUNHEADER_TIME() << " AND "
+           << " ID != " << glrun->ID
+           << " AND ID=ID_RUN_FRAG ORDER BY RUNHEADER_TIME DESC LIMIT 1;"; // DESC NOT ASC!!
+       //
+       if ( IsDebug() ) printf(" look for runheader in the GL_RUN table: query is \n %s \n",oss.str().c_str());
+       result = conn->Query(oss.str().c_str());
+       //
+       if ( !result ) throw -4;
+       //
+       foundinrun = true;
+       //
+       row = result->Next();
+       //
+     };
+     //
      if ( !row ){
        if ( IsDebug() ) printf(" the corresponding piece has NOT been found \n");
        found = false;
-Line 1427 
 void PamelaDBOperations::HandleRunFragme
+Line 2065 
 void PamelaDBOperations::HandleRunFragme
        //
        if ( IsDebug() ) printf(" now you can handle the piece of the run \n ");
        //
+       if ( foundinrun ){
+         glrun->RestoreRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN_FRAGMENTS");
+         glrun->DeleteRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN");
+       };
+       //
        GL_RUN *glrun1 = new GL_RUN();
        //
-       UInt_t idfrag = (UInt_t)atoll(row->GetField(0));
+       //      UInt_t idfrag = (UInt_t)atoll(row->GetField(0));
        //
        oss.str("");
        oss << " ID="<<row->GetField(0)<<";";
-Line 1442 
 void PamelaDBOperations::HandleRunFragme
+Line 2085 
 void PamelaDBOperations::HandleRunFragme
        ULong64_t aobt = OBT(glrun1->GetRUNTRAILER_OBT());
        UInt_t bpkt = PKT(glrun->GetRUNHEADER_PKT());
        ULong64_t bobt = OBT(glrun->GetRUNHEADER_OBT());
-       if ( IsDebug() ) printf(" Check overlapping events: %i %i %llu %llu firstev is %i\n",apkt,bpkt,aobt,bobt,firstev);
+       if ( IsDebug() ) printf(" Check overlapping events: %u %u %llu %llu firstev is %i\n",apkt,bpkt,aobt,bobt,firstev);
        TTree *T= 0;
        T = (TTree*)file->Get("Physics");
        if ( !T || T->IsZombie() ) throw -16;
-Line 1456 
 void PamelaDBOperations::HandleRunFragme
+Line 2099 
 void PamelaDBOperations::HandleRunFragme
          bobt = OBT(ph->GetOrbitalTime());
          firstev++;
        };
-       if ( IsDebug() ) printf(" Check overlapping events done: %i %i %llu %llu firstev is %i\n",apkt,bpkt,aobt,bobt,firstev);
+       if ( IsDebug() ) printf(" Check overlapping events done: %u %u %llu %llu firstev is %i\n",apkt,bpkt,aobt,bobt,firstev);
        //
-       glrun1->SetID(0);
        glrun1->SetPKT_COUNTER(glrun->GetPKT_COUNTER());
        glrun1->SetPKT_READY_COUNTER(glrun->GetPKT_READY_COUNTER());
        glrun1->SetRUNTRAILER_TIME(glrun->GetRUNTRAILER_TIME());
-Line 1467 
 void PamelaDBOperations::HandleRunFragme
+Line 2109 
 void PamelaDBOperations::HandleRunFragme
        //
        glrun->SetEV_FROM(firstev);
        glrun->SetNEVENTS(lastev-firstev+1);
+       //
        glrun->SetRUNHEADER_TIME(glrun1->GetRUNHEADER_TIME());
        glrun->SetRUNHEADER_OBT(glrun1->GetRUNHEADER_OBT());
        glrun->SetRUNHEADER_PKT(glrun1->GetRUNHEADER_PKT());
-Line 1486 
 void PamelaDBOperations::HandleRunFragme
+Line 2129 
 void PamelaDBOperations::HandleRunFragme
        //
        if ( !IsRunAlreadyInserted() ){
          //
+         //      glrun->SetID(this->AssignRunID());
+         glrun->SetID_RUN_FRAG(glrun1->GetID());
          glrun->Fill_GL_RUN(conn);
          //
-         // get id number
+         // set id number
-         //
-         oss.str("");
-         oss << " SELECT ID FROM GL_RUN WHERE BOOT_NUMBER="<<this->GetBOOTnumber()<<" AND "
-             << " RUNHEADER_OBT="<<glrun->GetRUNHEADER_OBT()<<" AND "
-             << " RUNTRAILER_OBT="<<glrun->GetRUNTRAILER_OBT()<<";";
-         //
-         if ( IsDebug() ) printf(" search for idrun0 , query is : \n%s\n",oss.str().c_str());
-         //
-         result =  conn->Query(oss.str().c_str());
-         if ( !result ) throw -4;
-         row = result->Next();
-         //
-         UInt_t idrun0 = 0;
-         if ( !row ){
-           throw -10;
-         } else {
-           idrun0 = (UInt_t)atoll(row->GetField(0));
-         };
-         //
-         glrun1->SetID_RUN_FRAG(idrun0);
          //
+         glrun1->SetID_RUN_FRAG(glrun->GetID());
          glrun1->Fill_GL_RUN(conn);
          //
-         oss.str("");
-         oss << " SELECT ID FROM GL_RUN WHERE ID_RUN_FRAG="<<idrun0<<" ;";
-         //
-         if ( IsDebug() ) printf(" search for idrun1 , query is : \n%s\n",oss.str().c_str());
-         //
-         result =  conn->Query(oss.str().c_str());
-         if ( !result ) throw -4;
-         row = result->Next();
-         //
-         UInt_t idrun1 = 0;
-         if ( !row ){
-           throw -10;
-         } else {
-           idrun1 = (UInt_t)atoll(row->GetField(0));
-         };
-         //
-         oss.str("");
-         oss << " UPDATE GL_RUN SET ID_RUN_FRAG="<<idrun1<<" WHERE ID="<<idrun0<<" ;";
-         //
-         result =  conn->Query(oss.str().c_str());
-         if ( !result ) throw -4;
-         //
        };
-       //
-       delete glrun1;
-       //
        // delete old entry in fragment table
        //
-       oss.str("");
+       glrun->DeleteRun(conn,0,"GL_RUN_FRAGMENTS");
+       glrun1->DeleteRun(conn,0,"GL_RUN_FRAGMENTS");
        //
-       oss << " DELETE FROM GL_RUN_FRAGMENTS WHERE ID = " << idfrag << ";";
+       delete glrun1;
        //
-       if ( IsDebug() ) printf(" Delete from frag table the old run :\n query is \n %s \n",oss.str().c_str());
-       result =  conn->Query(oss.str().c_str());
-       if ( !result ) throw -4;
        //
        return;
        //
-Line 1555 
 void PamelaDBOperations::HandleRunFragme
+Line 2154 
 void PamelaDBOperations::HandleRunFragme
    };
    //
    if ( mistrail && rtlastev == lastev ) { // look for runtrailer (only when at the end of the file, if at the beginning and the runh is
-                                            // missing it no way we can found a piece in the frag table
+     // missing it no way we can found a piece in the frag table
      //
      oss.str("");
      oss << " SELECT ID,PKT_COUNTER,RUNHEADER_TIME,RUNHEADER_OBT,RUNTRAILER_PKT,RUNHEADER_PKT FROM GL_RUN_FRAGMENTS WHERE "
          << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND "
-         << " RUNTRAILER_TIME >= " << (UInt_t)glrun->GetRUNTRAILER_TIME()
+         << " RUNTRAILER_TIME >= " << (UInt_t)glrun->GetRUNTRAILER_TIME() << " AND "
+         << " ID != " << glrun->ID
          << " ORDER BY RUNTRAILER_TIME ASC LIMIT 1;";
      //
      if ( IsDebug() ) printf(" look for runtrailer in the fragments table: query is \n %s \n",oss.str().c_str());
-Line 1570 
 void PamelaDBOperations::HandleRunFragme
+Line 2170 
 void PamelaDBOperations::HandleRunFragme
      //
      row = result->Next();
      //
+     if ( !row && NoFrag() ){
+       //
+       oss.str("");
+       oss << " SELECT ID,PKT_COUNTER,RUNHEADER_TIME,RUNHEADER_OBT,RUNTRAILER_PKT,RUNHEADER_PKT FROM GL_RUN WHERE "
+           << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND "
+           << " RUNTRAILER_TIME >= " << (UInt_t)glrun->GetRUNTRAILER_TIME() << " AND "
+           << " ID != " << glrun->ID
+           << " AND ID=ID_RUN_FRAG ORDER BY RUNTRAILER_TIME ASC LIMIT 1;";
+       //
+       if ( IsDebug() ) printf(" look for runheader in the GL_RUN table: query is \n %s \n",oss.str().c_str());
+       result = conn->Query(oss.str().c_str());
+       //
+       if ( !result ) throw -4;
+       //
+       foundinrun = true;
+       row = result->Next();
+       //
+     };
+     //
      if ( !row ){
        if ( IsDebug() ) printf(" the corresponding piece has NOT been found \n");
        found = false;
-Line 1643 
 void PamelaDBOperations::HandleRunFragme
+Line 2262 
 void PamelaDBOperations::HandleRunFragme
        //
        if ( IsDebug() ) printf(" now you can handle the piece of the run \n ");
        //
+       if ( foundinrun ){
+         glrun->RestoreRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN_FRAGMENTS");
+         glrun->DeleteRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN");
+       };
+       //
        GL_RUN *glrun1 = new GL_RUN();
        //
-       UInt_t idfrag = (UInt_t)atoll(row->GetField(0));
+       //      UInt_t idfrag = (UInt_t)atoll(row->GetField(0));
        //
        oss.str("");
        oss << " ID="<<row->GetField(0)<<";";
-Line 1658 
 void PamelaDBOperations::HandleRunFragme
+Line 2282 
 void PamelaDBOperations::HandleRunFragme
        ULong64_t aobt = OBT(glrun->GetRUNTRAILER_OBT());
        UInt_t bpkt = PKT(glrun1->GetRUNHEADER_PKT());
        ULong64_t bobt = OBT(glrun1->GetRUNHEADER_OBT());
-       if ( IsDebug() ) printf(" Check overlapping events: %i %i %llu %llu lastev is %i\n",apkt,bpkt,aobt,bobt,lastev);
+       if ( IsDebug() ) printf(" Check overlapping events: %u %u %llu %llu lastev is %i\n",apkt,bpkt,aobt,bobt,lastev);
        TTree *T= 0;
        T = (TTree*)file->Get("Physics");
        if ( !T || T->IsZombie() ) throw -16;
-Line 1672 
 void PamelaDBOperations::HandleRunFragme
+Line 2296 
 void PamelaDBOperations::HandleRunFragme
          aobt = OBT(ph->GetOrbitalTime());
          lastev--;
        };
-       if ( IsDebug() ) printf(" Check overlapping events done: %i %i %llu %llu lastev is %i\n",apkt,bpkt,aobt,bobt,lastev);
+       if ( IsDebug() ) printf(" Check overlapping events done: %u %u %llu %llu lastev is %i\n",apkt,bpkt,aobt,bobt,lastev);
        //
        glrun->SetEV_TO(lastev);
        glrun->SetNEVENTS(lastev-firstev+1);
-Line 1682 
 void PamelaDBOperations::HandleRunFragme
+Line 2306 
 void PamelaDBOperations::HandleRunFragme
        glrun->SetRUNTRAILER_OBT(glrun1->GetRUNTRAILER_OBT());
        glrun->SetRUNTRAILER_PKT(glrun1->GetRUNTRAILER_PKT());
        //
-       glrun1->SetID(0);
        glrun1->SetRUNHEADER_TIME(glrun->GetRUNHEADER_TIME());
        glrun1->SetRUNHEADER_OBT(glrun->GetRUNHEADER_OBT());
        glrun1->SetRUNHEADER_PKT(glrun->GetRUNHEADER_PKT());
-Line 1702 
 void PamelaDBOperations::HandleRunFragme
+Line 2325 
 void PamelaDBOperations::HandleRunFragme
        //
        if ( !IsRunAlreadyInserted() ){
          //
-         glrun->Fill_GL_RUN(conn);
+         //      glrun->SetID(this->AssignRunID());
-         //
-         // get id number
-         //
-         oss.str("");
-         oss << " SELECT ID FROM GL_RUN WHERE BOOT_NUMBER="<<this->GetBOOTnumber()<<" AND "
-             << " RUNHEADER_OBT="<<glrun->GetRUNHEADER_OBT()<<" AND "
-             << " RUNTRAILER_OBT="<<glrun->GetRUNTRAILER_OBT()<<";";
-         //
-         if ( IsDebug() ) printf(" search for idrun0 , query is : \n%s\n",oss.str().c_str());
          //
-         result =  conn->Query(oss.str().c_str());
+         glrun->SetID_RUN_FRAG(glrun1->GetID());
-         if ( !result ) throw -4;
+         glrun->Fill_GL_RUN(conn);
-         row = result->Next();
-         //
-         UInt_t idrun0 = 0;
-         if ( !row ){
-           throw -10;
-         } else {
-           idrun0 = (UInt_t)atoll(row->GetField(0));
-         };
          //
-         glrun1->SetID_RUN_FRAG(idrun0);
+         // set id number
          //
+         glrun1->SetID_RUN_FRAG(glrun->GetID());
          glrun1->Fill_GL_RUN(conn);
          //
-         oss.str("");
-         oss << " SELECT ID FROM GL_RUN WHERE ID_RUN_FRAG="<<idrun0<<" ;";
-         //
-         if ( IsDebug() ) printf(" search for idrun1 , query is : \n%s\n",oss.str().c_str());
-         //
-         result =  conn->Query(oss.str().c_str());
-         if ( !result ) throw -4;
-         row = result->Next();
-         //
-         UInt_t idrun1 = 0;
-         if ( !row ){
-           throw -10;
-         } else {
-           idrun1 = (UInt_t)atoll(row->GetField(0));
-         };
-         //
-         oss.str("");
-         oss << " UPDATE GL_RUN SET ID_RUN_FRAG="<<idrun1<<" WHERE ID="<<idrun0<<" ;";
-         //
-         result =  conn->Query(oss.str().c_str());
-         if ( !result ) throw -4;
-         //
        };
        //
-       delete glrun1;
+       // delete old entries in fragment table
-       //
-       // delete old entry in fragment table
-       //
-       oss.str("");
-       //
-       oss << " DELETE FROM GL_RUN_FRAGMENTS WHERE ID = " << idfrag << ";";
        //
-       if ( IsDebug() ) printf(" Delete from frag table the old run :\n query is \n %s \n",oss.str().c_str());
+       glrun->DeleteRun(conn,0,"GL_RUN_FRAGMENTS");
-       result =  conn->Query(oss.str().c_str());
+       glrun1->DeleteRun(conn,0,"GL_RUN_FRAGMENTS");
-       if ( !result ) throw -4;
        //
+       delete glrun1;
        //
        return;
        //
-Line 1800 
 void PamelaDBOperations::HandleRunFragme
+Line 2379 
 void PamelaDBOperations::HandleRunFragme
      //
      row = result->Next();
      //
-     if ( !row ){
+     if ( row ){
-       //
-       oss.str("");
-       oss << " SELECT ID FROM GL_RUN_FRAGMENTS WHERE "
-           << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND ("
-           << " (RUNHEADER_TIME>=" << (UInt_t)(glrun->GetRUNHEADER_TIME()-10) << " AND "
-           << " RUNTRAILER_TIME<=" << (UInt_t)(glrun->GetRUNTRAILER_TIME()+10) << " AND ("
-           << " RUNHEADER_OBT>=" << glrun->GetRUNHEADER_OBT() << " OR "
-           << " RUNHEADER_PKT>=" << glrun->GetRUNHEADER_PKT() << ") AND ("
-           << " RUNTRAILER_OBT<=" << glrun->GetRUNTRAILER_OBT() << " OR "
-           << " RUNTRAILER_PKT<=" << glrun->GetRUNTRAILER_PKT() << ") ) OR "
-           << " (RUNHEADER_TIME<=" << (UInt_t)glrun->GetRUNHEADER_TIME() << " AND "
-           << " RUNTRAILER_TIME>=" << (UInt_t)glrun->GetRUNTRAILER_TIME() <<" AND ("
-           << " RUNHEADER_OBT<=" << glrun->GetRUNHEADER_OBT() << " OR "
-           << " RUNHEADER_PKT<=" << glrun->GetRUNHEADER_PKT() << ") AND ("
-           << " RUNTRAILER_OBT>=" << glrun->GetRUNTRAILER_OBT() << " OR "
-           << " RUNTRAILER_PKT>=" << glrun->GetRUNTRAILER_PKT() << ") ));";
-       //
-       if ( IsDebug() ) printf(" check if run has been inserted: query is \n %s \n",oss.str().c_str());
-       result = conn->Query(oss.str().c_str());
-       //
-       if ( !result ) throw -4;
-       //
-       row = result->Next();
-       //
-       if ( !row ){
-         //
-         // no, insert this run in the GL_RUN_FRAGMENTS table (check if exist before!)
-         //
-         if ( IsDebug() ) printf(" The run is new \n");
-         if ( IsDebug() ) printf(" -> fill the GL_RUNFRAGMENTS table \n");
-         //
-         glrun->Fill_GL_RUN_FRAGMENTS(conn);
-         //
-       } else {
-         if ( IsDebug() ) printf(" The run is already present in the fragment table \n");
-       };
-     } else {
        if ( IsDebug() ) printf(" The run is already present in the GL_RUN table \n");
+     } else {
+       if ( NoFrag() ){
+         glrun->SetID_RUN_FRAG(glrun->GetID());
+         glrun->Fill_GL_RUN(conn);
+         glrun->DeleteRun(conn,0,"GL_RUN_FRAGMENTS");
+       };
      };
    };
    //
-Line 1864 
 void PamelaDBOperations::HandleMissingHo
+Line 2412 
 void PamelaDBOperations::HandleMissingHo
      //
      this->FillClass(mishead,mistrail,firstev,lastev);
      //
-     if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);
+     if ( !IsRunAlreadyInserted() ){
+       glrun->SetID(this->AssignRunID());
+       glrun->SetID_RUN_FRAG(0);
+       glrun->Fill_GL_RUN(conn);
+     };
      //
    };
    //
-Line 2031 
 Bool_t PamelaDBOperations::IsRunConsiste
+Line 2583 
 Bool_t PamelaDBOperations::IsRunConsiste
            //
            this->SetCommonGLRUN(firstTime,lastTime);
            //
-           if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);
+           if ( !IsRunAlreadyInserted() ){
+             glrun->SetID(this->AssignRunID());
+             glrun->SetID_RUN_FRAG(0);
+             glrun->Fill_GL_RUN(conn);
+           };
            //
            firstevno = lastentry + 1;
            //
-Line 2106 
 void PamelaDBOperations::HandleSuspiciou
+Line 2662 
 void PamelaDBOperations::HandleSuspiciou
    if ( firstev == lastev+1 ) { // no events inside the run!
      if ( IsDebug() ) printf(" Checking but no events in the run! \n");
      //
-     //    if ( IsDebug() ) printf(" -> fill the DB \n");
-     //
      this->FillClass();
-     if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);
+     if ( !IsRunAlreadyInserted() ){
+       glrun->SetID(this->AssignRunID());
+       glrun->SetID_RUN_FRAG(0);
+       glrun->Fill_GL_RUN(conn);
+     };
      //
    } else {
      //
-Line 2137 
 void PamelaDBOperations::HandleSuspiciou
+Line 2695 
 void PamelaDBOperations::HandleSuspiciou
        if ( IsDebug() ) printf(" No packets but physics inside the run, I will consider it as good\n");
        //
        this->FillClass();
-       if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);
+       if ( !IsRunAlreadyInserted() ){
+         glrun->SetID(this->AssignRunID());
+         glrun->SetID_RUN_FRAG(0);
+         glrun->Fill_GL_RUN(conn);
+       };
        //
      } else {
        //
-Line 2235 
 void PamelaDBOperations::HandleSuspiciou
+Line 2797 
 void PamelaDBOperations::HandleSuspiciou
            //
            this->SetCommonGLRUN(firstTime,lastTime);
            //
-           if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);
+           if ( !IsRunAlreadyInserted() ){
+             glrun->SetID(this->AssignRunID());
+             glrun->SetID_RUN_FRAG(0);
+             glrun->Fill_GL_RUN(conn);
+           };
            //
            if ( i == lastev && checkfirst < check ){ // if the last event gives a wrong check...
              //
-Line 2270 
 void PamelaDBOperations::HandleSuspiciou
+Line 2836 
 void PamelaDBOperations::HandleSuspiciou
              //
              this->SetCommonGLRUN(firstTime,lastTime);
              //
-             if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);
+             if ( !IsRunAlreadyInserted() ){
+               glrun->SetID(this->AssignRunID());
+               glrun->SetID_RUN_FRAG(0);
+               glrun->Fill_GL_RUN(conn);
+             };
            };
            //
            firstevno = lastentry + 1;
-Line 2318 
 Int_t PamelaDBOperations::insertCALO_CAL
+Line 2888 
 Int_t PamelaDBOperations::insertCALO_CAL
    tr->SetBranchAddress("Header", &eh);
    nevents = tr->GetEntries();
    //
-   if ( !nevents ) return(0);
+   if ( !nevents ) return(1);
    //
    for (UInt_t i=0; i < nevents; i++){
      tr->GetEntry(i);
-Line 2333 
 Int_t PamelaDBOperations::insertCALO_CAL
+Line 2903 
 Int_t PamelaDBOperations::insertCALO_CAL
          fromtime = this->GetAbsTime(ph->GetOrbitalTime());
          if ( this->PKT(pkt) >= this->PKT(pktfirst) && this->OBT(obt) >= this->OBT(obtfirst) ){
            //
-           if ( IsDebug() ) printf(" Calo calibration for section %i at time %i obt %i pkt %i \n",section,fromtime,obt,pkt);
+           if ( IsDebug() ) printf(" Calo calibration for section %i at time %u obt %u pkt %u \n",section,fromtime,obt,pkt);
            //
            // check if the calibration has already been inserted
            //
-Line 2377 
 Int_t PamelaDBOperations::insertCALO_CAL
+Line 2947 
 Int_t PamelaDBOperations::insertCALO_CAL
                // no calibrations in the db contain our calibration
                //
                if ( IsDebug() ) printf(" Calibration with fromtime lower than others to be inserted in the DB for section %i \n",section);
-               if ( fromtime < 1150863400 ){
+               if ( fromtime < 1150871000 ){ //1150866904
-                 if ( IsDebug() ) printf(" First PAMELA flight calibration at time %i \n",fromtime);
+                 if ( IsDebug() ) printf(" First PAMELA flight calibration at time %u \n",fromtime);
                  fromtime = 0;// the first flight calibration was taken at about  1156429100 s, this line allow to analyze first runs in raw mode
                };
                //
-Line 2440 
 Int_t PamelaDBOperations::insertCALO_CAL
+Line 3010 
 Int_t PamelaDBOperations::insertCALO_CAL
            //
          } else {
            //
-           if ( IsDebug() ) printf(" Repetead calo calibration for section %i at time %i obt %i pkt %i \n",section,fromtime,obt,pkt);
+           if ( IsDebug() ) printf(" Repeated calo calibration for section %i at time %u obt %u pkt %u \n",section,fromtime,obt,pkt);
            //
          };
          //
-Line 2522 
 void PamelaDBOperations::HandleTRK_CALIB
+Line 3092 
 void PamelaDBOperations::HandleTRK_CALIB
        // no calibrations in the db contain our calibration
        //
        if ( IsDebug() ) printf(" Calibration with fromtime lower than others to be inserted in the DB\n");
-       if ( fromtime < 1150863400 ) fromtime = 0; // the first flight calibration was taken at about 1150863300 s, this line allows to analyze first runs in raw mode
+       if ( fromtime < 1150871000 ) fromtime = 0; // the first flight calibration was taken at about 1150863300 s, this line allows to analyze first runs in raw mode
        //
        oss.str("");
        oss << " SELECT FROM_TIME FROM GL_TRK_CALIB WHERE "
-Line 2635 
 Int_t PamelaDBOperations::insertTRK_CALI
+Line 3205 
 Int_t PamelaDBOperations::insertTRK_CALI
    tr2->SetBranchAddress("Header", &eh2);
    nevents2 = tr2->GetEntries();
    //
-   if ( !nevents1 && !nevents2 ) return(0);
+   if ( !nevents1 && !nevents2 ) return(1);
    //
    t2 = -1;
    Int_t pret2 = 0;
-Line 2651 
 Int_t PamelaDBOperations::insertTRK_CALI
+Line 3221 
 Int_t PamelaDBOperations::insertTRK_CALI
      pkt1 = ph1->GetCounter();
      fromtime = this->GetAbsTime(ph1->GetOrbitalTime());
      //
-     valid = 1;
+ //     valid = 1;
-     //
+ //     //
-     if ( caltrk1->unpackError != 0 && caltrk1->good0 == 0 ) valid = 0;// CONDITIONS ON THE GOODNESS OF THE CALIBRATION PKT1
+ //     if ( caltrk1->unpackError != 0 && caltrk1->good0 == 0 ) valid = 0;// CONDITIONS ON THE GOODNESS OF THE CALIBRATION PKT1
      //
      //
      if ( this->PKT(pkt1) >= this->PKT(pktfirst) && this->OBT(obt1) >= this->OBT(obtfirst) ){
        //
-       if ( IsDebug() ) printf(" Trk calibration1 at time %i obt %i pkt %i \n",fromtime,obt1,pkt1);
+       if ( IsDebug() ) printf(" Trk calibration1 at time %u obt %u pkt %u \n",fromtime,obt1,pkt1);
+       //
+       valid = ValidateTrkCalib( caltrk1, eh1 );
+       if ( IsDebug() ) cout << " pkt1 validation --> "<<valid<<endl;
        //
        // Do we have the second calibration packet?
        //
-Line 2675 
 Int_t PamelaDBOperations::insertTRK_CALI
+Line 3248 
 Int_t PamelaDBOperations::insertTRK_CALI
            obt2 = ph2->GetOrbitalTime();
            pkt2 = ph2->GetCounter();
            //
-           if ( caltrk2->unpackError != 0 || caltrk2->good0 == 0 ) valid = 0; // CONDITIONS ON THE GOODNESS OF THE CALIBRATION PKT2
+ //        if ( caltrk2->unpackError != 0 || caltrk2->good0 == 0 ) valid = 0; // CONDITIONS ON THE GOODNESS OF THE CALIBRATION PKT2
            //
          } else {
            //
-Line 2698 
 Int_t PamelaDBOperations::insertTRK_CALI
+Line 3271 
 Int_t PamelaDBOperations::insertTRK_CALI
          //
        };
        //
-       if ( IsDebug() ) printf(" Found trk calibration2 at obt %i pkt %i t2 is %i \n",obt2,pkt2,t2);
+       if ( IsDebug() ) printf(" Found trk calibration2 at obt %u pkt %u t2 is %u \n",obt2,pkt2,t2);
        //
        // The calibration is good
        //
        if ( this->PKT(pkt2) == this->PKT(pkt1)+1 ){
          //
-         if ( IsDebug() ) printf(" The trk calibration2 at obt %i pkt %i t2 is %i is good \n",obt2,pkt2,t2);
+         if ( IsDebug() ) printf(" The trk calibration2 at obt %u pkt %u t2 is %u is good \n",obt2,pkt2,t2);
+         //
+         UInt_t valid2 = ValidateTrkCalib( caltrk2, eh2 );
+         if ( IsDebug() ) cout << " pkt2 validation --> "<<valid2<<endl;
+         valid = valid & valid2;
          //
          // Handle good calib
          //
-Line 2714 
 Int_t PamelaDBOperations::insertTRK_CALI
+Line 3291 
 Int_t PamelaDBOperations::insertTRK_CALI
          //
          if ( t2 != pret2+1 ){
            //
-           if ( IsDebug() ) printf(" Missing the trk calibration1! Next one at obt %i pkt %i t2 is %i pret2 is %i \n",obt2,pkt2,t2,pret2);
+           if ( IsDebug() ) printf(" Missing the trk calibration1! Next one at obt %u pkt %u t2 is %u pret2 is %u \n",obt2,pkt2,t2,pret2);
            //
            while ( t2 > pret2+1 ){
              //
-Line 2743 
 Int_t PamelaDBOperations::insertTRK_CALI
+Line 3320 
 Int_t PamelaDBOperations::insertTRK_CALI
          //
          // Check for missing calibtrk2
          //
-         if ( IsDebug() ) printf(" Missing the trk calibration2! Next one at obt %i pkt %i t2 is %i\n",obt2,pkt2,t2);
+         if ( IsDebug() ) printf(" Missing the trk calibration2! Next one at obt %u pkt %u t2 is %u\n",obt2,pkt2,t2);
          t2 = pret2;
          //
          // handle missing calib2
-Line 2757 
 Int_t PamelaDBOperations::insertTRK_CALI
+Line 3334 
 Int_t PamelaDBOperations::insertTRK_CALI
        //
      } else {
        //
-       if ( IsDebug() ) printf(" Repetead trk calibration1 at time %i obt %i pkt %i \n",fromtime,obt1,pkt1);
+       if ( IsDebug() ) printf(" Repetead trk calibration1 at time %u obt %u pkt %u \n",fromtime,obt1,pkt1);
        //
      };
      //
-Line 2782 
 Int_t PamelaDBOperations::insertTRK_CALI
+Line 3359 
 Int_t PamelaDBOperations::insertTRK_CALI
      valid = 0;
      if ( this->PKT(pkt2) > this->PKT(pktfirst) || this->OBT(obt2) > this->OBT(obtfirst) ){
        //
-       if ( IsDebug() ) printf(" Missing the trk calibration1! Next one at obt %i pkt %i t2 is %i\n",obt2,pkt2,t2);
+       if ( IsDebug() ) printf(" Missing the trk calibration1! Next one at obt %u pkt %u t2 is %u\n",obt2,pkt2,t2);
        //
        this->HandleTRK_CALIB(false,true);
        //
-Line 2807 
 Int_t PamelaDBOperations::insertS4_CALIB
+Line 3384 
 Int_t PamelaDBOperations::insertS4_CALIB
    stringstream oss;
    oss.str("");
    //
-   CalibS4Event *calibS4    = new  CalibS4Event();
    TTree *tr = 0;
    EventHeader *eh = 0;
    PscuHeader *ph = 0;
-Line 2821 
 Int_t PamelaDBOperations::insertS4_CALIB
+Line 3397 
 Int_t PamelaDBOperations::insertS4_CALIB
    tr = (TTree*)file->Get("CalibS4");
    if ( !tr || tr->IsZombie() ) throw -24;
    //
-   tr->SetBranchAddress("CalibS4", &calibS4);
    tr->SetBranchAddress("Header", &eh);
    //
    nevents = tr->GetEntries();
    //
-   if ( !nevents ) return(0);
+   if ( !nevents ) return(1);
    //
    for (UInt_t i = 0; i < nevents; i++){
      //
      tr->GetEntry(i);
-     TArrayD params = S4_paramfit(calibS4);
      //
      ph = eh->GetPscuHeader();
      obt = ph->GetOrbitalTime();
-Line 2839 
 Int_t PamelaDBOperations::insertS4_CALIB
+Line 3413 
 Int_t PamelaDBOperations::insertS4_CALIB
      fromtime = this->GetAbsTime(ph->GetOrbitalTime());
      if ( this->PKT(pkt) >= this->PKT(pktfirst) && this->OBT(obt) >= this->OBT(obtfirst) ){
        //
-       if ( IsDebug() ) printf(" S4 calibration at time %i obt %i pkt %i \n",fromtime,obt,pkt);
+       if ( IsDebug() ) printf(" S4 calibration at time %u obt %u pkt %u \n",fromtime,obt,pkt);
        //
        // check if the calibration has already been inserted
        //
-Line 2881 
 Int_t PamelaDBOperations::insertS4_CALIB
+Line 3455 
 Int_t PamelaDBOperations::insertS4_CALIB
            // no calibrations in the db contain our calibration
            //
            if ( IsDebug() ) printf(" Calibration with fromtime lower than others to be inserted in the DB \n");
-           if ( fromtime < 1150863400 ){
+           if ( fromtime < 1150871000 ){
-             if ( IsDebug() ) printf(" First PAMELA flight calibration at time %i \n",fromtime);
+             if ( IsDebug() ) printf(" First PAMELA flight calibration at time %u \n",fromtime);
              fromtime = 0;// the first flight calibration was taken at about  1156429100 s, this line allow to analyze first runs in raw mode
            };
            //
-Line 2921 
 Int_t PamelaDBOperations::insertS4_CALIB
+Line 3495 
 Int_t PamelaDBOperations::insertS4_CALIB
          };
          //
          oss.str("");
-         oss << " INSERT INTO GL_S4_CALIB (ID,ID_ROOT_L0,EV_ROOT,FROM_TIME,TO_TIME,PARAM_FIT0,PARAM_FIT1,OBT,PKT,BOOT_NUMBER,VALIDATION) "
+         oss << " INSERT INTO GL_S4_CALIB (ID,ID_ROOT_L0,EV_ROOT,FROM_TIME,TO_TIME,OBT,PKT,BOOT_NUMBER) "
              << " VALUES (NULL,' "
              << idroot << "','"
              << i << "','"
              << fromtime << "','"
              << totime << "','"
-             << dec << params.At(0) << "','"
-             << dec << params.At(1) << "','"
              << obt << "','"
              << pkt << "','"
-             << this->GetBOOTnumber() << "','"
+             << this->GetBOOTnumber() << "');";
-             << valid << "');";
          //
          if ( IsDebug() ) printf(" Insert the new calibration: query is \n %s \n",oss.str().c_str());
          //
-Line 2944 
 Int_t PamelaDBOperations::insertS4_CALIB
+Line 3515 
 Int_t PamelaDBOperations::insertS4_CALIB
        //
      } else {
        //
-       if ( IsDebug() ) printf(" Repetead S4 calibration at time %i obt %i pkt %i \n",fromtime,obt,pkt);
+       if ( IsDebug() ) printf(" Repeated S4 calibration at time %u obt %u pkt %u \n",fromtime,obt,pkt);
        //
      };
      //
-Line 2953 
 Int_t PamelaDBOperations::insertS4_CALIB
+Line 3524 
 Int_t PamelaDBOperations::insertS4_CALIB
    return(0);
  };
+ /**
- /*
+  * Scan the fragment table and move old fragments to the GL_RUN table
-  * Fit function Received from Valeria Malvezzi 06/02/2006
   */
- Double_t fitf(Double_t *x, Double_t *par){
+ Int_t PamelaDBOperations::CleanGL_RUN_FRAGMENTS(){
-   Double_t fitval =(par[0]*x[0])+par[1];
+   return(this->CleanGL_RUN_FRAGMENTS(""));
-   return fitval;
+ };
- }
- /*
+ /**
-  * Fit the S4 calibration with a straight line - Received from Valeria Malvezzi 06/02/2006
+  * Scan the fragment table and move old fragments to the GL_RUN table
   */
- TArrayD PamelaDBOperations::S4_paramfit(pamela::CalibS4Event *S4CalibEvent){
+ Int_t PamelaDBOperations::CleanGL_RUN_FRAGMENTS(TString fcleanfile){
+   //
-   //----------- variable initialization -------------------------------------------------
+   TSQLResult *result = 0;
+   TSQLRow    *row    = 0;
-   Double_t mip[3]={1, 30, 300};
+   TSQLResult *result2 = 0;
-   Double_t adc[3] = {0.,0.,0.};
+   TSQLRow    *row2   = 0;
+   //
-   TArrayD parametri(2);
+   UInt_t moved = 0;
+   //
-   valid = 1;
+   stringstream oss;
+   oss.str("");
-   //------------ Fit calibrations and find parameters to calibrate data ------------------
+   //
-   pamela::S4::S4Event  *s4Record;
+   if ( !strcmp(fcleanfile.Data(),"") ){
+     //
-   for (Int_t j = 0; j < 4; j++){
+     // check if there are entries older than "olderthan" seconds from now
-     for (Int_t i = 0; i < 128; i++){
+     //
-       s4Record = (pamela::S4::S4Event*)S4CalibEvent->Records->At((j*128 + i));
+     oss.str("");
-       switch (j) {
+     oss << " SELECT ID FROM GL_RUN_FRAGMENTS WHERE"
-       case 0 :{
+         << " INSERT_TIME <= '" << clean_time->AsSQLString() << "';";
-         adc[0]=adc[0]+((s4Record->S4_DATA)-32);
+     //
-         break;
+     if ( IsDebug() ) printf(" Select from GL_RUN_FRAGMENTS runs older than %s : query is \n %s \n",clean_time->AsSQLString(),oss.str().c_str());
-       };
+     result = conn->Query(oss.str().c_str());
-       case 1 :{
+     //
-         adc[1]=adc[1]+((s4Record->S4_DATA)-32);
+   } else {
-         break;
+     oss.str("");
-       };
+     oss << " SELECT ID FROM GL_ROOT WHERE NAME='" << fcleanfile.Data() << "';";
-       case 3 :{
+     if ( IsDebug() ) printf(" Getting ID_ROOT_L0 query %s \n",oss.str().c_str());
-         adc[2]=adc[2]+((s4Record->S4_DATA)-32);
+     result = conn->Query(oss.str().c_str());
-         break;
+     //
-       };
+     if ( result ){
-       };
+       //
-     };
+       row = result->Next();
-   };
+       //
+       if ( row ){
-   adc[0]=adc[0]/128;
+         oss.str("");
-   adc[1]=adc[1]/128;
+         oss << " SELECT ID FROM GL_RUN_FRAGMENTS WHERE"
-   adc[2]=adc[2]/128;
+             << " ID_ROOT_L0=" << row->GetField(0) << ";";
+         //
-   TGraph *fitpar = new TGraph (3, adc, mip);
+         if ( IsDebug() ) printf(" Select from GL_RUN_FRAGMENTS for ROOT file query is \n %s \n",oss.str().c_str());
-   TF1 *func = new TF1("fitf", fitf, -0., 1000., 2); // definizione della funzione, 2 = num. parametri
+         result = conn->Query(oss.str().c_str());
+         //
-   func->SetParameters(0.3,1.);        //inizializzazione dei parametri a 1
+       };
-   func->SetParNames("m","q");      //definisce il nome dei parametri
+     } else {
-   fitpar->Fit(func,"qr");          //fitta fitpar con la funzione func nel range definito nella funzione
+       return(2);
-   //fitpar->Fit(func,"r");          //fitta fitpar con la funzione func nel range definito nella funzione
+     };
+   };
-   parametri[0] = func -> GetParameter(0);
+   //
-   parametri[1] = func -> GetParameter(1);
+   if ( result ){
+     //
-   if ( parametri[0] < 0. || parametri[0] > 0.5 || parametri[1] < 0.8 || parametri[1] > 1. ) valid = 0;
+     row = result->Next();
+     //
-   if ( IsDebug() ) printf(" par1 = %g par2 = %g\n",parametri[0],parametri[1]);
+     while ( row ){
+       //
-   return parametri;
+       oss.str("");
+       oss << " ID= "<< row->GetField(0);
+       //
+       glrun->Query_GL_RUN_FRAGMENTS(oss.str().c_str(),conn);
+       //
+       oss.str("");
+       oss << " SELECT ID,NEVENTS,TRK_CALIB_USED,PKT_COUNTER FROM GL_RUN WHERE "
+           << " BOOT_NUMBER=" << glrun->GetBOOT_NUMBER() << " AND ("
+           << " (RUNHEADER_TIME>=" << (UInt_t)(glrun->GetRUNHEADER_TIME()-10) << " AND "
+           << " RUNTRAILER_TIME<=" << (UInt_t)(glrun->GetRUNTRAILER_TIME()+10) << " AND ("
+           << " RUNHEADER_OBT>=" << glrun->GetRUNHEADER_OBT() << " OR "
+           << " RUNHEADER_PKT>=" << glrun->GetRUNHEADER_PKT() << ") AND ("
+           << " RUNTRAILER_OBT<=" << glrun->GetRUNTRAILER_OBT() << " OR "
+           << " RUNTRAILER_PKT<=" << glrun->GetRUNTRAILER_PKT() << ") ) OR "
+           << " (RUNHEADER_TIME<=" << (UInt_t)glrun->GetRUNHEADER_TIME() << " AND "
+           << " RUNTRAILER_TIME>=" << (UInt_t)glrun->GetRUNTRAILER_TIME() <<" AND ("
+           << " RUNHEADER_OBT<=" << glrun->GetRUNHEADER_OBT() << " OR "
+           << " RUNHEADER_PKT<=" << glrun->GetRUNHEADER_PKT() << ") AND ("
+           << " RUNTRAILER_OBT>=" << glrun->GetRUNTRAILER_OBT() << " OR "
+           << " RUNTRAILER_PKT>=" << glrun->GetRUNTRAILER_PKT() << ") ));";
+       //
+       if ( IsDebug() ) printf(" check if run has been inserted: query is \n %s \n",oss.str().c_str());
+       result2 = conn->Query(oss.str().c_str());
+       //
+       if ( !result2 ) throw -4;
+       //
+       row2 = result2->Next();
+       //
+       if ( !row2 ){
+         //
+         if ( IsDebug() ) printf(" The run is new \n");
+         if ( IsDebug() ) printf(" -> fill the DB \n");
+         //
+         //      glrun->SetID(this->AssignRunID()); we use the old run number!
+         glrun->SetID_RUN_FRAG(glrun->GetID());
+         glrun->Fill_GL_RUN(conn);
+         //
+ //      oss.str("");
+ //      oss << " SELECT ID FROM GL_RUN WHERE "
+ //          << " BOOT_NUMBER=" << glrun->GetBOOT_NUMBER() << " AND "
+ //          << " RUNHEADER_PKT=" << (UInt_t)glrun->GetRUNHEADER_PKT() << " AND "
+ //          << " RUNTRAILER_PKT=" << (UInt_t)glrun->GetRUNTRAILER_PKT() << " AND "
+ //          << " RUNHEADER_OBT=" << (UInt_t)glrun->GetRUNHEADER_OBT() << " AND "
+ //          << " RUNTRAILER_OBT=" << (UInt_t)glrun->GetRUNTRAILER_OBT() << "; ";
+ //      //
+ //      if ( IsDebug() ) printf(" Look for the ID of the inserted run: query is \n %s \n",oss.str().c_str());
+ //      result2 = conn->Query(oss.str().c_str());
+ //      //
+ //      if ( !result2 ) throw -4;
+ //      //
+ //      row2 = result2->Next();
+ //      //
+ //      if ( !row2 ) throw -25;
+ //      //
+ //      oss.str("");
+ //      oss << " UPDATE GL_RUN SET ID_RUN_FRAG = " << row2->GetField(0) << " WHERE ID = " << row2->GetField(0);
+ //      if ( IsDebug() ) printf(" Update the ID_RUN_FRAG of the inserted run: query is \n %s \n",oss.str().c_str());
+ //      result2 = conn->Query(oss.str().c_str());
+ //      //
+ //      if ( !result2 ) throw -4;
+         //
+         moved++;
+         //
+       } else {
+         if ( IsDebug() ) printf(" The already exist in the GL_RUN table! \n");
+       };
+       if ( IsDebug() ) printf(" Delete run %s from the GL_RUN_FRAGMENTS table \n",row->GetField(0));
+       //
+       //
+       glrun->DeleteRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN_FRAGMENTS");
+ //      oss.str("");
+ //       oss << " DELETE from GL_RUN_FRAGMENTS where ID = " << row->GetField(0);
+ //       if ( IsDebug() ) printf(" Clean the GL_RUN_FRAGMENTS table: query is \n %s \n",oss.str().c_str());
+ //       result2 = conn->Query(oss.str().c_str());
+ //      //
+ //      if ( !result2 ) throw -4;
+ //      //
+       row = result->Next();
+     };
+   };
+   if ( IsDebug() ) printf(" Moved %u runs\n",moved);
+   return(0);
+ };
+ /**
+  * Check if runs are good, i.e. if the tracker calibration is correctly associated..
+  */
+ Int_t PamelaDBOperations::ValidateRuns(){
+   return(this->ValidateRuns(""));
+ };
+ /**
+  * Check if runs are good, i.e. if the tracker calibration is correctly associated..
+  */
+ Int_t PamelaDBOperations::ValidateRuns(TString valfile){
+   //
+   TSQLResult *result = 0;
+   TSQLRow    *row    = 0;
+   //
+   UInt_t calibtime = 50;
+   //
+   stringstream oss;
+   oss.str("");
+   //
+   // =======================================================
+   // validate runs by checking missing calibrations
+   // =======================================================
+   UInt_t t_stop  = 0;
+   UInt_t t_start = 0;
+   if ( !strcmp(valfile.Data(),"") ) {
+     // --------------------------------------------------------------
+     // 1) get the OBT of the last run inserted after clean-time limit
+     // --------------------------------------------------------------
+     oss.str("");
+     oss << " SELECT * FROM GL_RUN  WHERE INSERT_TIME <= '" << clean_time->AsSQLString()
+         << "' ORDER BY RUNHEADER_TIME DESC LIMIT 1;";
+     if ( IsDebug() ) printf(" Get start validation-time: query is \n %s \n",oss.str().c_str());
+     result = conn->Query(oss.str().c_str());
+     if ( !result ) throw -4;
+     if ( !result->GetRowCount() ) {
+       printf(" No runs to validate \n");
+       return(1);
+     }else{
+       row = result->Next();
+       t_start = (UInt_t)atoll(row->GetField(4));
+     };
+     // --------------------------------------------------------------
+     // 2) get the OBT of the last validated run
+     // --------------------------------------------------------------
+     oss.str("");
+     oss << " SELECT * FROM GL_RUN  WHERE VALIDATION=1 AND RUNHEADER_TIME<="<< t_start
+         <<" ORDER BY RUNHEADER_TIME DESC LIMIT 1;";
+     if ( IsDebug() ) printf(" Get stop validation-time: query is \n %s \n",oss.str().c_str());
+     result = conn->Query(oss.str().c_str());
+     if ( !result ) throw -4;
+     if ( result->GetRowCount() ){
+       row = result->Next();
+       t_stop = (UInt_t)atoll(row->GetField(4));
+     };
+     if ( IsDebug() ) printf("Validation interval: from time %u - to time %u \n\n",t_stop,t_start);
+     // --------------------------------------------------------------
+     // now retrieves runs to be validated
+     // --------------------------------------------------------------
+     oss.str("");
+     oss << " SELECT * FROM GL_RUN  WHERE  RUNHEADER_TIME <=" << t_start;
+     oss << " AND RUNHEADER_TIME >="<< t_stop;
+     oss << " ORDER BY RUNHEADER_TIME DESC;";
+     if ( IsDebug() )printf(" Check runs for validation: query is \n %s \n",oss.str().c_str());
+     result = conn->Query(oss.str().c_str());
+   } else {
+     //
+     stringstream myquery;
+     UInt_t myid = 0;
+     myquery.str("");
+     myquery << " SELECT ID FROM GL_ROOT where NAME='"<<valfile.Data() <<"';";
+     //
+     result = conn->Query(myquery.str().c_str());
+     //
+     row = result->Next();
+     if( !row ){
+       if ( strcmp(valfile.Data(),GetRootName().Data()) ){
+         if ( IsDebug() ) printf(" No file to be validated even if option \"-validate file\" was used!!\n");
+         return(2);
+       };
+       if ( IsDebug() ) printf(" No file to be validated (force mode)! \n");
+       return(0);
+     };
+     myid=(UInt_t)atoll(row->GetField(0));
+     //
+     myquery.str("");
+     myquery << " SELECT MAX(RUNTRAILER_TIME),MIN(RUNHEADER_TIME) FROM GL_RUN WHERE ID_ROOT_L0="<< myid <<";";
+     //
+     result = conn->Query(myquery.str().c_str());
+     //
+     row = result->Next();
+     if( !row->GetField(0) || !row->GetField(1)){
+       //
+       if ( IsDebug() ) printf(" NO RUN ASSOCIATED TO THIS FILE! \n");
+       //
+       return(0);
+       //
+     } else {
+       //
+       UInt_t runhtime = (UInt_t)atoll(row->GetField(0));
+       UInt_t runttime = (UInt_t)atoll(row->GetField(1));
+       UInt_t caltime = 0;
+       //
+       myquery.str("");
+       myquery << " SELECT FROM_TIME FROM GL_TRK_CALIB where FROM_TIME>" <<runhtime;
+       myquery << " order by FROM_TIME asc limit 1;";
+       //
+       if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
+       //
+       //
+       result = conn->Query(myquery.str().c_str());
+       //
+       row = result->Next();
+       if( !row ){
+         caltime = runhtime;
+       } else {
+         caltime = (UInt_t)atoll(row->GetField(0));
+       };
+       //
+       myquery.str("");
+       myquery << " SELECT * from GL_RUN where RUNHEADER_TIME>="<< runttime <<" AND RUNHEADER_TIME<=" ;
+       myquery << caltime << " order by RUNHEADER_TIME DESC";
+       //
+       if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
+       //
+       result = conn->Query(myquery.str().c_str());
+       //
+     };
+   };
+   //
+   if ( !result ) throw -4;
+   if ( !result->GetRowCount() && IsDebug() ) printf(" No runs to validate \n");
+   //
+   Int_t nrow = 0;
+   GL_RUN* this_run = new GL_RUN();
+   GL_RUN* next_run = new GL_RUN();
+   Int_t   nseq_max = 1000;
+ //  UInt_t* sequence = new UInt_t[100];
+   vector<UInt_t> sequence(nseq_max);
+   Int_t   nseq = 0;
+   Bool_t CHECK = false;
+   Bool_t this_ONLINE = false;
+   Bool_t next_ONLINE = false;
+   UInt_t t1=0,t2=0;
+   // ---------------------------------------------------------------------------------
+   // - loop over runs, back in time,
+   // - select sequences of runs close in time (less than calibtime s apart),
+   //   which could be preceeded by a calibration
+   // - check if there might be a missing calibration
+   // ---------------------------------------------------------------------------------
+   while(1){
+           row = result->Next();
+           if( row == NULL ) break;
+           //------------
+           //get run info
+           //------------
+           this_run->Set_GL_RUN(row);
+           Bool_t this_BAD = false;
+           if(this_run->GetTRK_CALIB_USED() == 1 || this_run->GetTRK_CALIB_USED() == 2) this_ONLINE = true;
+           else if (this_run->GetTRK_CALIB_USED() == 104)                          this_ONLINE = false;
+           else{
+ //                printf("Missing or corrupted header!! \n");
+                   this_ONLINE = false;
+                   this_BAD = true;
+           };
+           //-----------------------------------
+           //compare with previous(next in time)
+           //-----------------------------------
+           CHECK = false;
+           UInt_t interval=0;
+           if( nrow != 0){
+                   t1 = this_run->GetRUNTRAILER_TIME();
+                   t2 = next_run->GetRUNHEADER_TIME();
+                   interval = (t2-t1);
+                   if(this_ONLINE && next_ONLINE){                               // this: ON-LINE + next: ON-LINE
+                           if( this_run->ID == next_run->ID_RUN_FRAG ) interval = 0;     //=> run fragments
+                           if( interval >= calibtime )CHECK = true;                      //more than calibtime s => there might be a calibration
+                           if( !CHECK && this_run->VALIDATION ){
+                                   for (Int_t irun = 0; irun < nseq; irun++)assignVALIDATION(sequence[irun],true);
+                                   nseq=0;
+                           }
+                   }else if( !this_ONLINE && next_ONLINE) {              // this: DEFAULT + next:ON-LINE
+                           CHECK = true;
+                   }else if( !next_ONLINE ){                                             // this:ANY + next:DEFAULT
+                           assignVALIDATION(next_run->ID,true);
+                           nseq=0;
+                   }
+           }
+           //----------------------------
+           //check run sequence for calib
+           //----------------------------
+           if( CHECK ){
+                   // check if calibration exists
+                   if ( IsDebug() )printf("DT %i ===> CHECK Missing calibration\n",interval);
+                   Bool_t MISSING = MissingTRK_CALIB(t1,t2);
+                   for (Int_t irun = 0; irun < nseq; irun++)assignVALIDATION(sequence[irun],!MISSING);
+                   nseq=0;
+           };
+           //--------------
+           //store run info
+           //--------------
+           *next_run   = *this_run;
+           next_ONLINE = this_ONLINE;
+           if( !this_BAD ){
+                   if(nseq < nseq_max){
+                           sequence[nseq] = this_run->ID;
+                           nseq++;
+                   }else printf("ValidateRuns ***WARNING*** : run sequence exceed assumed size (%i) \n",nseq_max);
+           };
+           if ( IsDebug() ) printf("%i Run %u \n",nrow,this_run->ID);
+           nrow++;
+   };
+   delete this_run;
+   delete next_run;
+   //
+   return(0);
+ };
+ /**
+  * Check if there might be a missing tracker calibration in a given time interval
+  * @param t1 From absolute time
+  * @param t2 To absolute time
+  * @return true if there might be a missing calibration
+  */
+ Bool_t PamelaDBOperations::MissingTRK_CALIB(UInt_t t1,UInt_t t2){
+         GL_TRK_CALIB* trkcalib = new GL_TRK_CALIB();
+         // get the closest VALIDATED calibration before the run start (t2)
+         if ( trkcalib->Query_GL_TRK_CALIB(t2, conn) )return(true);      //>>> missing
+         if ( trkcalib->TO_TIME  < t2 ) return(true);                                    //>>> missing
+         //==============================================================
+         // Check is done first on the basis of time between calibration,
+         // which should be equal to the time between ascending-nodes.
+         //==============================================================
+         if ( t2 - trkcalib->FROM_TIME > 5700) {
+                 if ( IsDebug() )printf("Long time between calib and run start %u :-( ==> there might be a missing calib \n",t2 - trkcalib->FROM_TIME);
+         //==============================================================
+         // there might be a missing calibration, due to:
+         // - MM full
+         // - corrupted packets
+         // - loss of data
+         // There is an exception in case a download was done during ascending node
+         //==============================================================
+                 Bool_t DOWNLOAD = false;
+                 // check if the calib was skipped becouse of download .... DA FARE!!
+                 if(DOWNLOAD)return(false);
+                 return(true);                                   //>>> missing
+         };
+         //==============================================================
+         // If the last calibration is close to the run less than this time,
+         // it is enough to say that there are no missing calibrations
+         //==============================================================
+         // the long time interval bewteen runs might be due to download
+         if ( IsDebug() )printf("Short time between calib and run start %u :-) ==> OK! \n",t2 - trkcalib->FROM_TIME);
+         return(false);
+ };
+ /**
+  * Assign VALIDATION value to a GL_RUN entry
+  * @param idrun Run ID
+  * @param validation true/false
+  */
+ Int_t PamelaDBOperations::assignVALIDATION(UInt_t idrun, Bool_t validation){
+         TSQLResult *result = 0;
+         stringstream oss;
+         oss.str("");
+         oss << " UPDATE GL_RUN SET VALIDATION="<< (UInt_t)validation <<" WHERE ID= " << idrun << ";";
+         //
+ //      if ( IsDebug() )
+ //      printf(" Set VALIDATION = %i for run %i \n",validation,idrun);
+         if ( IsDebug() )printf(" Query: %s \n",oss.str().c_str());
+         result = conn->Query(oss.str().c_str());
+         if ( !result ) throw -4;
+         return(0);
+ }
+ // Insert TLEs from file tlefilename in the table GL_TLE in the db
+ // opened by conn, sorting them by date from older to newer, if each
+ // TLE has not been alread inserted.
+ Int_t PamelaDBOperations::populateTLE()//(TSQLServer *conn, char *tleFile)
+ {
+   fstream tlefile(tlefilename, ios::in);
+   if ( !tlefile ) throw -7;
+   vector<cTle*> ctles;
+   vector<cTle*>::iterator iter;
+   int present = 0;
+   // Get three lines from tlefile, create a cTle object and put it
+   // into ctles
+   while(1) {
+     cTle *tlef;
+     string str1, str2, str3;
+     getline(tlefile, str1);
+     if(tlefile.eof()) break;
+     getline(tlefile, str2);
+     if(tlefile.eof()) break;
+     getline(tlefile, str3);
+     if(tlefile.eof()) break;
+     // We now have three good lines for a cTle.
+     tlef = new cTle(str1, str2, str3);
+     ctles.push_back(tlef);
+   }
+   tlefile.close();
+   // Sort by date
+   sort(ctles.begin(), ctles.end(), compTLE);
+   // Now we insert each TLE into the db
+   for(iter = ctles.begin(); iter != ctles.end(); iter++) {
+     cTle *tle = *iter;
+     // Do nothing if it's already present in the db.  Just increase
+     // the counter present.
+     if (! isTlePresent(tle))
+       {
+         int status = insertTle(tle);
+         // Insert query failed.  Return 1.
+         if(status == EXIT_FAILURE) {
+           if( IsDebug() ) {
+             cerr << "Error: inserting TLE:" << endl
+                  << tle->getName() << endl
+                  << tle->getLine1() << endl
+                  << tle->getLine2() << endl;
+           }
+           throw -4;
+           return 1;
+         }
+       }
+     else
+       present++;
+   }
+   int inserted = ctles.size() - present;  // Number of inserted TLE.
+   if ( IsDebug() )
+     cout << "\nProcessed TLEs ranging from " << getTleDatetime(ctles[0]) << " to " << getTleDatetime(ctles[ctles.size()-1]) << "." << endl
+          << inserted << " newly inserted TLEs out of " << ctles.size() << " processed." << endl;
+   ctles.clear();
+   // Return 2 if no new TLE has been inserted.  0 otherwise.
+   if(! inserted ) return 2;
+   return 0;
+ }
+ // Insert tle in the table GL_TLE using the connection conn.
+ Int_t PamelaDBOperations::insertTle(cTle *tle)
+ {
+   stringstream oss;
+   TSQLResult *result = 0;
+   oss.str("");
+   oss << " INSERT INTO GL_TLE (TLE1, TLE2, TLE3, FROM_TIME)"
+       << " VALUES ( '"
+       << tle->getName() << "', '"
+       << tle->getLine1() << "', '"
+       << tle->getLine2() << "', '"
+       << getTleDatetime(tle) << "')";
+   //  cout << oss.str().c_str() << endl;
+   result = conn->Query(oss.str().c_str());
+   if (result == NULL)
+     return EXIT_FAILURE;
+   return EXIT_SUCCESS;
+ }
+ // Return whether tle is already in the db connected by conn.
+ bool PamelaDBOperations::isTlePresent(cTle *tle)
+ {
+   stringstream oss;
+   TSQLResult *result = 0;
+   oss.str("");
+   oss << "SELECT * FROM GL_TLE WHERE FROM_TIME = '"
+       << getTleDatetime(tle) << "'";
+   result = conn->Query(oss.str().c_str());
+   if (result == NULL) throw -4;
+   if (result->GetRowCount())
+     return true;
+   else
+     return false;
+ }
+ // Return whether the first TLE is dated early than the second
+ bool compTLE (cTle *tle1, cTle *tle2)
+ {
+   return getTleJulian(tle1) < getTleJulian(tle2);
+ }
+ // Return the date of the tle using the format (year-2000)*1e3 +
+ // julian day.  e.g. 6365 is the 31th Dec 2006.
+ // It does *not* return a cJulian date.
+ float getTleJulian(cTle *tle) {
+   return tle->getField(cTle::FLD_EPOCHYEAR)*1e3 + tle->getField(cTle::FLD_EPOCHDAY);
+ }
+ // Return a string like YYYY-MM-DD hh:mm:ss, usable for mysql datetime
+ // format.
+ string getTleDatetime(cTle *tle)
+ {
+   int year, mon, day, hh, mm, ss;
+   double dom; // day of month (is double!)
+   stringstream date; // date in datetime format
+   // create a cJulian from the date in tle
+   cJulian jdate = cJulian( 2000 + (int) tle->getField(cTle::FLD_EPOCHYEAR), tle->getField(cTle::FLD_EPOCHDAY));
+   // get year, month, day of month
+   jdate.getComponent(&year, &mon, &dom);
+   // build a datetime YYYY-MM-DD hh:mm:ss
+   date.str("");
+   day = (int) floor(dom);
+   hh = (int) floor( (dom - day) * 24);
+   mm = (int) floor( ((dom - day) * 24 - hh) * 60);
+   ss = (int) floor( ((((dom - day) * 24 - hh) * 60 - mm) * 60));
+   //  ms = (int) floor( (((((dom - day) * 24 - hh) * 60 - mm) * 60) - ss) * 1000);
+   date << year << "-" << mon << "-" << day << " " << hh << ":" << mm << ":" << ss;
+   return date.str();
+ }
+ /**
+  * Remove a file from the DB, delete on cascade all entries related to that file
+  * rearrange GL_RUN and GL_XXX_CALIB tables, turn off validation till the following
+  * calibration
+  **/
+ Int_t PamelaDBOperations::removeFile(TString remfile){
+   //
+   // Determine ID_ROOT_L0 and ID_RAW
+   //
+   TSQLResult *pResult;
+   TSQLRow *Row;
+   stringstream myquery;
+   //
+   myquery.str("");
+   myquery << " SELECT ID, ID_RAW FROM GL_ROOT where NAME='"<<remfile.Data() <<"';";
+   //
+   pResult = conn->Query(myquery.str().c_str());
+   //
+   Row = pResult->Next();
+   if( !Row ){
+     if ( strcmp(remfile.Data(),GetRootName().Data()) ){
+       if ( IsDebug() ) printf(" No file to be removed even if option \"-remove file\" was used!!\n");
+       return(1);
+     };
+     if ( IsDebug() ) printf(" No file to be removed (force mode)! \n");
+     return(0);
+   };
+   //
+   this->SetID_ROOT((UInt_t)atoll(Row->GetField(0)));
+   this->SetID_RAW((UInt_t)atoll(Row->GetField(1)));
+   //
+   this->ValidationOFF();
+   //
+   this->RemoveCALIBS();
+   //
+   this->RemoveRUNS();
+   //
+   this->RemoveFILES();
+   //
+   this->SetID_ROOT(0);
+   this->SetID_RAW(0);
+   //
+   return(0);
+ };
+ /**
+  *
+  * Set validation bit to zero for runs following the removing file till
+  * 1) a run with TRK_CALIB_USED=140
+  * 2) a run with VALIDATION = 0
+  * 3) the next calibration
+  *
+  **/
+ void PamelaDBOperations::ValidationOFF(){
+   TSQLResult *pResult;
+   TSQLRow *Row;
+   stringstream myquery;
+   Int_t unv = 0;
+   //select ID from GL_RUN where RUNHEADER_TIME>=1152671382 AND (VALIDATION=0 OR TRK_CALIB_USED=104) order by RUNHEADER_TIME asc limit 1;
+   myquery.str("");
+   myquery << " SELECT MAX(RUNTRAILER_TIME) FROM GL_RUN WHERE ID_ROOT_L0="<< this->GetID_ROOT() <<";";
+   //
+   pResult = conn->Query(myquery.str().c_str());
+   //
+   Row = pResult->Next();
+   if( !Row->GetField(0) ){
+     //
+     if ( IsDebug() ) printf(" NO RUN ASSOCIATED TO THIS FILE! \n");
+     //
+   } else {
+     //
+     UInt_t runhtime = (UInt_t)atoll(Row->GetField(0));
+     UInt_t caltime = 0;
+     //
+     myquery.str("");
+     myquery << " SELECT FROM_TIME FROM GL_TRK_CALIB where FROM_TIME>" <<runhtime;
+     myquery << " order by FROM_TIME asc limit 1;";
+     //
+     if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
+     //
+     //
+     delete pResult;
+     pResult = conn->Query(myquery.str().c_str());
+     //
+     Row = pResult->Next();
+     if( !Row ){
+       caltime = runhtime;
+     } else {
+       caltime = (UInt_t)atoll(Row->GetField(0));
+     };
+     //
+     myquery.str("");
+     myquery << " SELECT ID,RUNHEADER_TIME from GL_RUN where RUNHEADER_TIME>="<< runhtime <<" AND (VALIDATION=0 OR TRK_CALIB_USED=104 OR RUNHEADER_TIME>" ;
+     myquery << caltime << ") order by RUNHEADER_TIME asc LIMIT 1";
+     //
+     if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
+     //
+     pResult = conn->Query(myquery.str().c_str());
+     //
+     Row = pResult->Next();
+     if( !Row ){
+       //
+       if ( IsDebug() ) printf(" NO RUN NEED TO BE UNVALIDATED \n");
+       //
+     } else {
+       myquery.str("");
+       myquery << " SELECT ID from GL_RUN where RUNHEADER_TIME<"<< Row->GetField(1) <<" AND ";
+       myquery << " RUNHEADER_TIME>=" <<runhtime;
+       myquery << " order by RUNHEADER_TIME asc;";
+       //
+       if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
+       //
+       pResult = conn->Query(myquery.str().c_str());
+       //
+       Row = pResult->Next();
+       while ( Row ){
+         //
+         unv++;
+         this->assignVALIDATION((UInt_t)atoll(Row->GetField(0)), false);
+         Row = pResult->Next();
+         //
+       };
+     };
+   };
+   if ( IsDebug() ) printf(" %u runs have been unvalidated \n",unv);
+ };
+ /**
+  *
+  * Rearrange GL_RUN table and remove runs
+  *
+  **/
+ void PamelaDBOperations::RemoveRUNS(){
+   TSQLResult *pResult;
+   TSQLRow *Row;
+   stringstream myquery;
+   UInt_t drun = 0;
+   GL_RUN *delrun = new GL_RUN();
+   //
+   myquery.str("");
+   myquery << " SELECT ID FROM GL_RUN where ID_RUN_FRAG=0 and ID_ROOT_L0=" <<this->GetID_ROOT() <<";";
+   //
+   if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
+   //
+   pResult = conn->Query(myquery.str().c_str());
+   //
+   Row = pResult->Next();
+   //
+   //
+   if ( !Row ){
+     if ( IsDebug() ) printf(" No run with ID_RUN_FRAG=0 belonged to this file \n");
+   } else {
+     if ( IsDebug() ) printf(" Deleting run from GL_RUN table \n");
+     while ( Row ){
+       delrun->DeleteRun(conn,(UInt_t)atoll(Row->GetField(0)),"GL_RUN");
+       if ( IsDebug() ) printf(" del run %u \n",(UInt_t)atoll(Row->GetField(0)));
+       drun++;
+       Row = pResult->Next();
+     };
+   };
+   //
+   //
+   myquery.str("");
+   myquery << " SELECT ID,ID_RUN_FRAG FROM GL_RUN where ID_RUN_FRAG!=0 and ID_ROOT_L0=" <<this->GetID_ROOT() <<";";
+   //
+   if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
+   //
+   pResult = conn->Query(myquery.str().c_str());
+   //
+   Row = pResult->Next();
+   //
+   if ( !Row ){
+     if ( IsDebug() ) printf(" No run with ID_RUN_FRAG!=0 belonged to this file \n");
+   } else {
+     if ( IsDebug() ) printf(" Deleting run fragments from GL_RUN table \n");
+     while ( Row ){
+       if ( IsDebug() ) printf(" restore run %u \n",(UInt_t)atoll(Row->GetField(1)));
+       delrun->RestoreRun(conn,(UInt_t)atoll(Row->GetField(1)),"GL_RUN_FRAGMENTS");
+       if ( IsDebug() ) printf(" del run %u \n",(UInt_t)atoll(Row->GetField(1)));
+       delrun->DeleteRun(conn,(UInt_t)atoll(Row->GetField(1)),"GL_RUN");
+       if ( (UInt_t)atoll(Row->GetField(1)) != (UInt_t)atoll(Row->GetField(0)) ){
+         if ( IsDebug() ) printf(" del run %u \n",(UInt_t)atoll(Row->GetField(0)));
+         delrun->DeleteRun(conn,(UInt_t)atoll(Row->GetField(0)),"GL_RUN");
+       };
+       drun++;
+       Row = pResult->Next();
+     };
+   };
+   //
+   if ( IsDebug() ) printf(" Deleted %i run(s) from GL_RUN table \n",drun);
+   //
+   //
+   //
+   drun = 0;
+   //
+   myquery.str("");
+   myquery << " SELECT ID_TRASH FROM GL_RUN_TRASH where BELONGED_TO='GL_RUN_FRAGMENTS' AND ID_ROOT_L0=" <<this->GetID_ROOT() <<";";
+   //
+   pResult = conn->Query(myquery.str().c_str());
+   //
+   Row = pResult->Next();
+   //
+   if ( !Row ){
+     if ( IsDebug() ) printf(" No run from GL_RUN_FRAGMENTS table in the trash table for this file \n");
+   } else {
+     if ( IsDebug() ) printf(" Deleting run fragments from GL_RUN_TRASH table \n");
+     while ( Row ){
+       if ( IsDebug() ) printf(" del run idtrash %u \n",(UInt_t)atoll(Row->GetField(0)));
+       myquery.str("");
+       myquery << " DELETE FROM GL_RUN_TRASH where ID_TRASH=" << Row->GetField(0) <<";";
+       conn->Query(myquery.str().c_str());
+       drun++;
+       Row = pResult->Next();
+     };
+   };
+   //
+   if ( IsDebug() ) printf(" Deleted %u run(s) from GL_RUN_TRASH table \n",drun);
+   //
+   //
+   //
+   drun = 0;
+   //
+   myquery.str("");
+   myquery << " SELECT ID FROM GL_RUN_FRAGMENTS where ID_ROOT_L0=" <<this->GetID_ROOT() <<";";
+   //
+   pResult = conn->Query(myquery.str().c_str());
+   //
+   Row = pResult->Next();
+   //
+   if ( !Row ){
+     if ( IsDebug() ) printf(" No run in the GL_RUN_FRAGMENTS table for this file \n");
+   } else {
+     if ( IsDebug() ) printf(" Deleting run fragments from GL_RUN_FRAGMENTS table \n");
+     while ( Row ){
+       if ( IsDebug() ) printf(" del run %u \n",(UInt_t)atoll(Row->GetField(0)));
+       myquery.str("");
+       myquery << " DELETE FROM GL_RUN_FRAGMENTS where ID=" << Row->GetField(0) <<";";
+       conn->Query(myquery.str().c_str());
+       drun++;
+       Row = pResult->Next();
+     };
+   };
+   //
+   if ( IsDebug() ) printf(" Deleted %u run(s) from GL_RUN_FRAGMENTS table \n",drun);
+   //
+   //
+   //
+   delete delrun;
+   //
+ };
+ /**
+  *
+  * Rearrange calibration tables
+  *
+  **/
+ void PamelaDBOperations::RemoveFILES(){
+   stringstream myquery;
+   //
+   myquery.str("");
+   myquery << " DELETE FROM GL_RAW WHERE ID=" <<this->GetID_RAW() <<";";
+   //
+   if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
+   //
+   conn->Query(myquery.str().c_str());
+   //
+ };
+ /**
+  *
+  * Rearrange calibration tables
+  *
+  **/
+ void PamelaDBOperations::RemoveCALIBS(){
+   TSQLResult *pResult;
+   TSQLRow *Row;
+   stringstream myquery;
+   //
+   //
+   // Calorimeter
+   //
+   for (Int_t section = 0; section < 4; section++){
+     myquery.str("");
+     myquery << " SELECT MIN(FROM_TIME),MAX(TO_TIME) FROM GL_CALO_CALIB WHERE ID_ROOT_L0="<< this->GetID_ROOT() <<" AND ";
+     myquery << " SECTION=" << section << ";";
+     //
+     pResult = conn->Query(myquery.str().c_str());
+     //
+     Row = pResult->Next();
+     if( !Row->GetField(0) || !Row->GetField(1) ){
+       //
+       if ( IsDebug() ) printf(" NO CALO CALIBRATION SECTION %i ASSOCIATED TO THIS FILE! \n",section);
+       //
+     } else {
+       //
+       myquery.str("");
+       myquery << " UPDATE GL_CALO_CALIB SET TO_TIME=" << Row->GetField(1);
+       myquery << " WHERE TO_TIME="<< Row->GetField(0) << " AND ";
+       myquery << " SECTION=" << section << ";";
+       //
+       pResult = conn->Query(myquery.str().c_str());
+       //
+       if( !pResult ){
+         //
+         if ( IsDebug() ) printf(" ERROR DELETING CALO CALIBRATIONS \n");
+         //
+         throw -4;
+         //
+       };
+       //
+     };
+   };
+   myquery.str("");
+   myquery << " DELETE FROM GL_CALO_CALIB WHERE ID_ROOT_L0=" << this->GetID_ROOT();
+   //
+   pResult = conn->Query(myquery.str().c_str());
+   //
+   if( !pResult ){
+     //
+     if ( IsDebug() ) printf(" ERROR DELETING CALO CALIBRATIONS \n");
+     //
+     throw -4;
+     //
+   };
+   //
+   // Tracker
+   //
+   myquery.str("");
+   myquery << " SELECT MIN(FROM_TIME),MAX(TO_TIME) FROM GL_TRK_CALIB WHERE ID_ROOT_L0="<< this->GetID_ROOT() <<";";
+   //
+   pResult = conn->Query(myquery.str().c_str());
+   //
+   Row = pResult->Next();
+   if( !Row->GetField(0) || !Row->GetField(1) ){
+     //
+     if ( IsDebug() ) printf(" NO TRK CALIBRATION ASSOCIATED TO THIS FILE! \n");
+     //
+   } else {
+     //
+     myquery.str("");
+     myquery << " UPDATE GL_TRK_CALIB SET TO_TIME=" << Row->GetField(1);
+     myquery << " WHERE TO_TIME="<< Row->GetField(0) << ";";
+     //
+     pResult = conn->Query(myquery.str().c_str());
+     //
+     if( !pResult ){
+       //
+       if ( IsDebug() ) printf(" ERROR DELETING TRK CALIBRATIONS \n");
+       //
+       throw -4;
+       //
+     };
+     //
+     myquery.str("");
+     myquery << " DELETE FROM GL_TRK_CALIB WHERE ID_ROOT_L0=" << this->GetID_ROOT();
+     //
+     pResult = conn->Query(myquery.str().c_str());
+     //
+     if( !pResult ){
+       //
+       if ( IsDebug() ) printf(" ERROR DELETING TRK CALIBRATIONS \n");
+       //
+       throw -4;
+       //
+     };
+   };
+   //
+   //
+   // S4
+   //
+   myquery.str("");
+   myquery << " SELECT MIN(FROM_TIME),MAX(TO_TIME) FROM GL_S4_CALIB WHERE ID_ROOT_L0="<< this->GetID_ROOT() <<";";
+   //
+   pResult = conn->Query(myquery.str().c_str());
+   //
+   Row = pResult->Next();
+   if( !Row->GetField(0) || !Row->GetField(1) ){
+     //
+     if ( IsDebug() ) printf(" NO S4 CALIBRATION ASSOCIATED TO THIS FILE! \n");
+     //
+   } else {
+     //
+     myquery.str("");
+     myquery << " UPDATE GL_S4_CALIB SET TO_TIME=" << Row->GetField(1);
+     myquery << " WHERE TO_TIME="<< Row->GetField(0) << ";";
+     //
+     pResult = conn->Query(myquery.str().c_str());
+     //
+     if( !pResult ){
+       //
+       if ( IsDebug() ) printf(" ERROR DELETING S4 CALIBRATIONS \n");
+       //
+       throw -4;
+       //
+     };
+     //
+     myquery.str("");
+     myquery << " DELETE FROM GL_S4_CALIB WHERE ID_ROOT_L0=" << this->GetID_ROOT();
+     //
+     pResult = conn->Query(myquery.str().c_str());
+     //
+     if( !pResult ){
+       //
+       if ( IsDebug() ) printf(" ERROR DELETING S4 CALIBRATIONS \n");
+       //
+       throw -4;
+       //
+     };
+     //
+   };
+ };
+ /**
+  *
+  * Rearrange calibration tables
+  *
+  **/
+ UInt_t PamelaDBOperations::ValidateTrkCalib( CalibTrk1Event* caltrk, EventHeader *eh ){
+     Int_t vorder[]={5,5,3,3,4,4,2,2,1,1,0,0};
+     UInt_t timeaftercalib=120000; //2000;
+ //  ----------
+ //  Check CRCs
+ //  ----------
+     for(Int_t ipkt=0; ipkt<6; ipkt++){
+         if( caltrk->crc_hcal[ipkt] )return 0; // :-(
+         for(Int_t ilad=0; ilad<3; ilad++)if( caltrk->crc_cal[ipkt][ilad] )return 0; // :-(
+     }
+ //  -----------------------
+ //  Check missing packets:
+ //  -----------------------
+ //    Readout order:
+ //    ------------------
+ //    DSP   packet board
+ //    ------------------
+ //    12    0      1
+ //    10    1      1
+ //     8    2      1
+ //     4    3      1
+ //     6    4      1
+ //     2    5      1
+ //    ------------------
+ //    11    0      2
+ //     9    1      2
+ //     7    2      2
+ //     3    3      2
+ //     5    4      2
+ //     1    5      2
+ //    ------------------
+ //  -------------------------------------------------
+ //  Check if it is first or second calibration packet
+ //  -------------------------------------------------
+     UInt_t build=0;
+     TString classname = caltrk->GetName();
+     UInt_t base=0;
+     UInt_t mask=0;
+     if(classname.Contains("CalibTrk1Event")){
+         base=12;
+         mask=0x03F000;
+     }
+     if(classname.Contains("CalibTrk2Event")){
+         base=18;
+         mask=0xFC0000;
+     }
+ //  -------------------------------------------------
+ //  Count number of packets and set build variable
+ //  -------------------------------------------------
+     Int_t  npkts=0;
+     for(Int_t ipkt=0; ipkt<6; ipkt++){
+         if(caltrk->DSPnumber[ipkt]>0 && caltrk->DSPnumber[ipkt]<=12){
+             npkts++;
+             build = build | ( 1<<(base+vorder[caltrk->DSPnumber[ipkt]-1]) );
+         }
+     }
+ //    if( npkts==6 )return 1; // :-)
+ //    cout << classname << " "<<eh->GetPscuHeader()->GetOrbitalTime()<<endl;
+ //  -----------------------------------------------
+ //  If missing packets: check the acq configuration
+ //  (some DSPs might be excluded from acquisition)
+ //  -----------------------------------------------
+ //  -----------------------------------------------
+ //  retrieve the first run header after calib
+ //  -----------------------------------------------
+      PacketType *pctp;
+      EventCounter *cod;
+      cod = eh->GetCounter();
+      Int_t irun = cod->Get(pctp->RunHeader);
+      TTree *rh=(TTree*)file->Get("RunHeader");
+      if ( !rh || rh->IsZombie() ) throw -17;
+      if( rh->GetEntries() == irun ){
+           if ( IsDebug() ) cout << "ValidateTrkCalib: (MISSING VIEW) no runs after calib (1)  -- cannot validate :-( "<<endl;
+          return 0; // :-(
+      }
+      RunHeaderEvent *run  = 0;
+      EventHeader    *hrun = 0;
+      rh->SetBranchAddress("RunHeader", &run);
+      rh->SetBranchAddress("Header", &hrun);
+      rh->GetEntry(irun);
+ //     cout << classname << " "<<eh->GetPscuHeader()->GetOrbitalTime() << " Run " << hrun->GetPscuHeader()->GetOrbitalTime() <<endl;
+      if( OBT(hrun->GetPscuHeader()->GetOrbitalTime()) < OBT(eh->GetPscuHeader()->GetOrbitalTime())){
+           if ( IsDebug() ) cout << "ValidateTrkCalib: (MISSING VIEW) no runs after calib (2) -- cannot validate :-( "<<endl;
+          return 0; // :-(
+      }
+      if( !run->RM_ACQ_AFTER_CALIB ){
+           if ( IsDebug() ) cout << "ValidateTrkCalib: (MISSING VIEW) RM_ACQ_AFTER_CALIB=0    -- cannot validate :-( "<<endl;
+          return 0; // :-(
+      }
+      UInt_t dtime = OBT(hrun->GetPscuHeader()->GetOrbitalTime()) - OBT(eh->GetPscuHeader()->GetOrbitalTime());
+      if( dtime > timeaftercalib ){
+          if ( IsDebug() ) cout << "ValidateTrkCalib: (MISSING VIEW) run after calib too far ( "<<dtime<<"ms ) -- cannot validate :-( "<<endl;
+          return 0; // :-(
+      }
+      if( (run->ACQ_BUILD_INFO & mask) != build ){
+          if ( IsDebug() ) cout << "ValidateTrkCalib: (MISSING VIEW) ACQ_BUILD_INFO= >>> "<<hex << (run->ACQ_BUILD_INFO&mask) << " != "<< build << dec<<endl;
+          return 0; // :-(
+      }
+      return 1; // :-)
+ }
+ /**
+  *
+  * Check the DB (only for overlapping runs at the moment)
+  *
+  **/
+ UInt_t PamelaDBOperations::Check(){
+   //
+   UInt_t test = 0;
+   //
+   UInt_t thisrht = 0;
+   UInt_t thisrtt = 0;
+   UInt_t thisid = 0;
+   UInt_t prevrht = 0;
+   UInt_t prevrtt = 0;
+   UInt_t previd = 0;
+   //
+   UInt_t prevl0id = 0;
+   UInt_t thisl0id = 0;
+   //
+   stringstream oss;
+   TSQLResult *result = 0;
+   TSQLRow    *row    = 0;
+   TSQLResult *result2 = 0;
+   TSQLRow    *row2    = 0;
+   TSQLResult *result3 = 0;
+   TSQLRow    *row3    = 0;
+   oss.str("");
+   oss << "SELECT ID,ID_ROOT_L0,RUNHEADER_TIME,RUNTRAILER_TIME,NEVENTS FROM GL_RUN order by RUNHEADER_TIME asc;";
+   //  oss << "SELECT ID,RUNHEADER_TIME,RUNTRAILER_TIME FROM GL_RUN where ID>10170 and ID<10190 order by RUNHEADER_TIME asc;";
+   result = conn->Query(oss.str().c_str());
+   //
+   if ( !result ) throw -4;;
+   //
+   row = result->Next();
+   //
+   while ( row ){
+     thisid = (UInt_t)atoll(row->GetField(0));
+     thisl0id = (UInt_t)atoll(row->GetField(1));
+     thisrht = (UInt_t)atoll(row->GetField(2));
+     thisrtt = (UInt_t)atoll(row->GetField(3));
+     //
+     if ( (UInt_t)atoll(row->GetField(4)) > 1 ){
+       //
+       //
+       //
+       oss.str("");
+       oss << "SELECT ID,ID_ROOT_L0,RUNHEADER_TIME,RUNTRAILER_TIME FROM GL_RUN WHERE ID!="
+           << thisid << " AND RUNHEADER_TIME="
+           << thisrht << " AND RUNTRAILER_TIME!="
+           << thisrtt << " AND NEVENTS!=0 AND NEVENTS!=1 order by RUNHEADER_TIME asc;";
+       result3 = conn->Query(oss.str().c_str());
+       if ( IsDebug() ) printf(" query is %s \n",oss.str().c_str());
+       if ( result3 ){
+         row3 = result3->Next();
+         //
+         while ( row3 ){
+           //
+           // 2 runs with same runheader
+           //
+           printf(" CHECK n.4 RUNs %u and %u HAVE SAME RUNHEADER \n",thisid,(UInt_t)atoll(row3->GetField(0)));
+           row3 = result3->Next();
+         };
+       };
+       //
+       oss.str("");
+       oss << "SELECT ID,ID_ROOT_L0,RUNHEADER_TIME,RUNTRAILER_TIME FROM GL_RUN WHERE ID!="
+           << thisid << " AND RUNHEADER_TIME!="
+           << thisrht << " AND RUNTRAILER_TIME="
+           << thisrtt << " AND NEVENTS!=0 AND NEVENTS!=1 order by RUNHEADER_TIME asc;";
+       result3 = conn->Query(oss.str().c_str());
+       if ( IsDebug() ) printf(" query is %s \n",oss.str().c_str());
+       if ( result3 ){
+         row3 = result3->Next();
+         //
+         while ( row3 ){
+           //
+           // 2 runs with same runtrailer
+           //
+           printf(" CHECK n.5 RUNs %u and %u HAVE SAME RUNTRAILER \n",thisid,(UInt_t)atoll(row3->GetField(0)));
+           row3 = result3->Next();
+         };
+       };
+       //
+       oss.str("");
+       oss << "SELECT ID,ID_ROOT_L0,RUNHEADER_TIME,RUNTRAILER_TIME FROM GL_RUN WHERE ID!="
+           << thisid << " AND RUNHEADER_TIME>"
+           << thisrht << " AND RUNTRAILER_TIME<"
+           << thisrtt << " order by RUNHEADER_TIME asc;";
+       result3 = conn->Query(oss.str().c_str());
+       if ( result3 ){
+         row3 = result3->Next();
+         //
+         while ( row3 ){
+           //
+           // run contained in the checked one
+           //
+           printf(" CHECK n.6 RUN %u CONTAINS RUN %u  \n",thisid,(UInt_t)atoll(row3->GetField(0)));
+           row3 = result3->Next();
+         };
+       };
+       //
+       oss.str("");
+       oss << "SELECT ID,ID_ROOT_L0,RUNHEADER_TIME,RUNTRAILER_TIME FROM GL_RUN WHERE ID!="
+           << thisid << " AND RUNHEADER_TIME="
+           << thisrht << " AND RUNTRAILER_TIME="
+           << thisrtt << " AND ID_RUN_FRAG!="
+           << thisid << " order by RUNHEADER_TIME asc;";
+       result3 = conn->Query(oss.str().c_str());
+       if ( result3 ){
+         row3 = result3->Next();
+         //
+         while ( row3 ){
+           //
+           // duplicated run
+           //
+           printf(" CHECK n.7 RUNs %u and %u HAVE SAME RUNTRAILER AND RUNHEADER (ARE THE SAME?) \n",thisid,(UInt_t)atoll(row3->GetField(0)));
+           row3 = result3->Next();
+         };
+       };
+     };
+     //
+     //    if ( thisrht < prevrtt || thisrtt < prevrht || thisrht > thisrtt && !(!prevrht && !prevrtt &&!previd) ){
+     //    if ( (thisrht < prevrtt || thisrtt < prevrht || thisrht > thisrtt) && (thisrht != prevrht) ){
+     if ( (thisrht < prevrtt) && (thisrht != prevrht) ){
+       if ( IsDebug() ) printf(" IDprev %u ID %u    prevrht %u prevrtt %u  thisrht %u thisrtt %u \n",previd,thisid,prevrht,prevrtt,thisrht,thisrtt);
+       printf(" CHECK n.1 TIME SCREW of %i s AROUND RUNs %u and %u \n",(thisrht-prevrtt),previd,thisid);
+       TString prevf = "";
+       TString thisf = "";
+       oss.str("");
+       oss << "SELECT NAME FROM GL_ROOT where ID=" << (UInt_t)prevl0id <<";";
+       result2 = conn->Query(oss.str().c_str());
+       if ( !result2 ) throw -4;;
+       row2 = result2->Next();
+       prevf = (TString)row2->GetField(0);
+       oss.str("");
+       oss << "SELECT NAME FROM GL_ROOT where ID=" << (UInt_t)thisl0id <<";";
+       result2 = conn->Query(oss.str().c_str());
+       if ( !result2 ) throw -4;;
+       row2 = result2->Next();
+       thisf = (TString)row2->GetField(0);
+       if ( IsDebug() ) printf(" ==> files %s and %s \n",prevf.Data(),thisf.Data());
+       test = 1;
+     };
+     //
+     if ( (thisrtt < prevrht) && (thisrht != prevrht) ){
+       if ( IsDebug() ) printf(" IDprev %u ID %u    prevrht %u prevrtt %u  thisrht %u thisrtt %u \n",previd,thisid,prevrht,prevrtt,thisrht,thisrtt);
+       printf(" CHECK n.2 TIME SCREW of %i s AROUND RUNs %u and %u \n",(thisrtt-prevrht),previd,thisid);
+       TString prevf = "";
+       TString thisf = "";
+       oss.str("");
+       oss << "SELECT NAME FROM GL_ROOT where ID=" << (UInt_t)prevl0id <<";";
+       result2 = conn->Query(oss.str().c_str());
+       if ( !result2 ) throw -4;
+       row2 = result2->Next();
+       prevf = (TString)row2->GetField(0);
+       oss.str("");
+       oss << "SELECT NAME FROM GL_ROOT where ID=" << (UInt_t)thisl0id <<";";
+       result2 = conn->Query(oss.str().c_str());
+       if ( !result2 ) throw -4;;
+       row2 = result2->Next();
+       thisf = (TString)row2->GetField(0);
+       if ( IsDebug() ) printf(" ==> files %s and %s \n",prevf.Data(),thisf.Data());
+       test = 1;
+     };
+     //
+     if ( (thisrht > thisrtt) && (thisrht != prevrht) ){
+       if ( IsDebug() ) printf(" IDprev %u ID %u    prevrht %u prevrtt %u  thisrht %u thisrtt %u \n",previd,thisid,prevrht,prevrtt,thisrht,thisrtt);
+       printf(" CHECK n.3 TIME SCREW of %i s AROUND RUNs %u and %u \n",(thisrht-thisrtt),previd,thisid);
+       TString prevf = "";
+       TString thisf = "";
+       oss.str("");
+       oss << "SELECT NAME FROM GL_ROOT where ID=" << (UInt_t)prevl0id <<";";
+       result2 = conn->Query(oss.str().c_str());
+       if ( !result2 ) throw -4;;
+       row2 = result2->Next();
+       prevf = (TString)row2->GetField(0);
+       oss.str("");
+       oss << "SELECT NAME FROM GL_ROOT where ID=" << (UInt_t)thisl0id <<";";
+       result2 = conn->Query(oss.str().c_str());
+       if ( !result2 ) throw -4;;
+       row2 = result2->Next();
+       thisf = (TString)row2->GetField(0);
+       if ( IsDebug() ) printf(" ==> files %s and %s \n",prevf.Data(),thisf.Data());
+       test = 1;
+     };
+     //
+     prevrht = thisrht;
+     prevrtt = thisrtt;
+     previd = thisid;
+     prevl0id = thisl0id;
+     row = result->Next();
+   };
+   //
+   return(test);
+   //
  };

 Legend:



Removed from v.1.1
 


changed lines


 
Added in v.1.47
 Legend:



Removed from v.1.1
 


changed lines


 
Added in v.1.47
-Removed from v.1.1
+Added in v.1.47

	ViewVC Help
Powered by ViewVC 1.1.23