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

Diff of /YodaProfiler/src/PamelaDBOperations.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.3 by mocchiut, Tue Sep 5 10:48:58 2006 UTC revision 1.51 by mocchiut, Fri Oct 19 07:47:52 2007 UTC
# Line 14  Line 14 
14  #include <TSQLRow.h>  #include <TSQLRow.h>
15  #include <TTree.h>  #include <TTree.h>
16  #include <TGraph.h>  #include <TGraph.h>
17  #include <TDatime.h>  #include <TTimeStamp.h>
18  #include <TF1.h>  #include <TF1.h>
19  //  //
20  #include <EventHeader.h>  #include <EventHeader.h>
# Line 31  Line 31 
31  #include <varDump/VarDumpRecord.h>  #include <varDump/VarDumpRecord.h>
32  #include <physics/S4/S4Event.h>  #include <physics/S4/S4Event.h>
33  //  //
34    #include <sgp4.h>
35    
36  #include <PamelaDBOperations.h>  #include <PamelaDBOperations.h>
37  //  //
38  using namespace std;  using namespace std;
39  using namespace pamela;  using namespace pamela;
40    
41    // Some function to work with cTle stuff.
42    bool compTLE(cTle* tle1, cTle *tle2);
43    float getTleJulian(cTle *);
44    string getTleDatetime(cTle*);
45    
46  /**  /**
47   * Constructor.   * Constructor.
48   * @param host         hostname for the SQL connection.   * @param host         hostname for the SQL connection.
# Line 47  using namespace pamela; Line 54  using namespace pamela;
54   * @param obt0         file obt0.   * @param obt0         file obt0.
55   * @param tsync        file timesync.   * @param tsync        file timesync.
56   * @param debug        debug flag.   * @param debug        debug flag.
57     * @param tlefilename  ascii file with TLE 3 line elements.
58   */   */
59  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, Bool_t gpamela){
60    //    //
61      STATIC=false;
62      if ( staticp ) STATIC=true;
63    //    //
64    SetConnection(host,user,password);    SetConnection(host,user,password);
65    //    //
# Line 58  PamelaDBOperations::PamelaDBOperations(T Line 68  PamelaDBOperations::PamelaDBOperations(T
68    glrun = new GL_RUN();    glrun = new GL_RUN();
69    //    //
70    if ( !boot ) SetNOBOOT(false);    if ( !boot ) SetNOBOOT(false);
71    SetBOOTnumber(boot);    SetTsync(tsync,gpamela);
72    SetTsync(tsync);    SetBOOTnumber(boot,gpamela);
73    SetObt0(obt0);    SetObt0(obt0);
74    //    //
75      SetTLEPath(tlefilename);
76    //    //
   SetRootName(filerootname);  
   SetRawName(filerawname);  
77    //    //
78    this->OpenFile();    INSERT_RAW =!filerawname.IsNull();
79      if(INSERT_RAW)SetRawName(filerawname);
80      //
81      INSERT_ROOT = !filerootname.IsNull();
82      if( INSERT_ROOT ){
83        this->SetRootName(filerootname);
84        this->SetOrbitNo(dwinput);
85        file = TFile::Open(this->GetRootName().Data());
86      } else {
87        this->SetRootName("");
88      };
89    //    //
90    this->SetID_RAW(0);    this->SetID_RAW(0);
91    this->SetID_ROOT(0);    this->SetID_ROOT(0);
92    
93      VALIDATE = false;
94      
95    //    //
96  };  };
97    
# Line 78  PamelaDBOperations::PamelaDBOperations(T Line 100  PamelaDBOperations::PamelaDBOperations(T
100   */   */
101  void PamelaDBOperations::Close(){  void PamelaDBOperations::Close(){
102    if( conn && conn->IsConnected() ) conn->Close();    if( conn && conn->IsConnected() ) conn->Close();
103      delete clean_time;
104    delete glrun;    delete glrun;
105    delete this;    delete this;
106  };  };
# Line 86  void PamelaDBOperations::Close(){ Line 109  void PamelaDBOperations::Close(){
109  // SETTERS  // SETTERS
110  //  //
111    
112    //
113    // 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
114    //
115    void PamelaDBOperations::CheckValidate(Long64_t olderthan){
116      clean_time = new TDatime();
117      //
118      if(olderthan >= 0){
119        VALIDATE = true;
120        UInt_t timelim = 0;
121        timelim =  (UInt_t)clean_time->Convert(true) - olderthan;
122        clean_time->Set(timelim,false);
123      };
124    };
125    
126  /**  /**
127   * Open the DB connection   * Open the DB connection
128   * @param host         hostname for the SQL connection.   * @param host         hostname for the SQL connection.
# Line 93  void PamelaDBOperations::Close(){ Line 130  void PamelaDBOperations::Close(){
130   * @param password     password for the SQL connection.   * @param password     password for the SQL connection.
131   */   */
132  void PamelaDBOperations::SetConnection(TString host, TString user, TString password){  void PamelaDBOperations::SetConnection(TString host, TString user, TString password){
133      if ( IsDebug() ) printf(" Connecting using host = %s user = %s password = %s \n",host.Data(),user.Data(),password.Data());
134    conn = TSQLServer::Connect(host.Data(),user.Data(),password.Data());    conn = TSQLServer::Connect(host.Data(),user.Data(),password.Data());
135  };  };
136    
# Line 121  void PamelaDBOperations::SetDebugFlag(Bo Line 159  void PamelaDBOperations::SetDebugFlag(Bo
159  };  };
160    
161  /**  /**
162     * Set the autoboot flag
163     *
164     */
165    void PamelaDBOperations::SetAutoBoot(Bool_t dbg){
166      AUTOBOOT = dbg;
167    };
168    
169    /**
170     * Set the nofrag flag
171     *
172     */
173    void PamelaDBOperations::SetNoFrag(Bool_t nf){
174      NOFRAG = nf;
175    };
176    
177    /**
178   * Store the BOOT number of the RAW file.   * Store the BOOT number of the RAW file.
179   * @param boot    BOOT number of the RAW file   * @param boot    BOOT number of the RAW file
180   */   */
181  void PamelaDBOperations::SetBOOTnumber(UInt_t boot){  void PamelaDBOperations::SetBOOTnumber(UInt_t boot){
182      this->SetBOOTnumber(boot,false);
183    };
184    
185    /**
186     * Store the BOOT number of the RAW file.
187     * @param boot    BOOT number of the RAW file
188     */
189    void PamelaDBOperations::SetBOOTnumber(UInt_t boot, Bool_t gpamela){
190    BOOTNO=boot;    BOOTNO=boot;
191      if ( gpamela ){
192        stringstream oss;
193        TSQLResult *result = 0;
194        TSQLRow    *row    = 0;    
195        if ( !boot ){
196          //
197          BOOTNO = 1;
198          //
199          // look in the DB for the last timesync and the last run
200          //
201          oss.str("");
202          oss << "SELECT BOOT_NUMBER FROM GL_RUN order by RUNHEADER_TIME desc limit 1;";
203          result = conn->Query(oss.str().c_str());
204          if ( result ){
205            row = result->Next();
206            if ( row ){
207              BOOTNO = (UInt_t)atoll(row->GetField(0)) + 1;
208            };
209          };
210        };
211      };
212  };  };
213    
214  /**  /**
# Line 133  void PamelaDBOperations::SetBOOTnumber(U Line 216  void PamelaDBOperations::SetBOOTnumber(U
216   * @param boot    time sync   * @param boot    time sync
217   */   */
218  void PamelaDBOperations::SetTsync(UInt_t ts){  void PamelaDBOperations::SetTsync(UInt_t ts){
219      this->SetTsync(ts,false);
220    };
221    
222    /**
223     * Store the time sync of the RAW file.
224     * @param boot    time sync
225     */
226    void PamelaDBOperations::SetTsync(UInt_t ts, Bool_t gpamela){
227      //
228      // if not gpamela or given tsync file set ts
229      //
230    tsync=ts;    tsync=ts;
231      if ( gpamela ){
232        stringstream oss;
233        TSQLResult *result = 0;
234        TSQLRow    *row    = 0;    
235        TSQLResult *result2 = 0;
236        TSQLRow    *row2    = 0;    
237        if ( !ts ){
238          //
239          tsync = 1;
240          //
241          // look in the DB for the last timesync and the last run
242          //
243          oss.str("");
244          oss << "SELECT TIMESYNC FROM GL_TIMESYNC order by TIMESYNC desc limit 1;";
245          result = conn->Query(oss.str().c_str());
246          if ( result ){
247            row = result->Next();
248            if ( row ){
249              tsync = (UInt_t)atoll(row->GetField(0)) + 1;
250              oss.str("");
251              oss << "SELECT (RUNTRAILER_TIME-RUNHEADER_TIME) FROM GL_RUN order by RUNHEADER_TIME desc limit 1;";
252              result2 = conn->Query(oss.str().c_str());
253              if ( result2 ){
254                row2 = result2->Next();
255                if ( row2 ){
256                  tsync += (UInt_t)atoll(row2->GetField(0));
257                };
258              }
259            };
260          };
261        };
262      };
263  };  };
264    
265  /**  /**
# Line 161  void PamelaDBOperations::SetRootName(TSt Line 287  void PamelaDBOperations::SetRootName(TSt
287  };  };
288    
289  /**  /**
290     * Store the downlink orbit number from filename.
291     */
292    void PamelaDBOperations::SetOrbitNo(UInt_t dwinput){
293      dworbit = 0;
294      //
295      if ( dwinput ){
296        dworbit = dwinput;
297        if ( IsDebug() ) printf(" Downlink orbit given by hand: %i  \n",dworbit);
298        return;
299      };
300      //
301      TString name = this->GetRootFile();
302      Int_t nlength = name.Length();
303      if ( nlength < 5 ) return;
304      TString dwo = 0;
305      for (Int_t i = 0; i<5; i++){
306        dwo.Append(name[i],1);
307      };
308      if ( dwo.IsDigit() ){
309        dworbit = (UInt_t)dwo.Atoi();
310      } else {
311        dwo="";
312        for (Int_t i = 8; i<13; i++){
313          dwo.Append(name[i],1);
314        };    
315        if ( dwo.IsDigit() ) dworbit = (UInt_t)dwo.Atoi();
316      };
317      if ( IsDebug() ) printf(" Downlink orbit is %i (dwo = %s) \n",dworbit,dwo.Data());
318      return;
319    };
320    
321    
322    
323    /**
324   * Store the NOBOOT flag.   * Store the NOBOOT flag.
325   * @param noboot    true/false.   * @param noboot    true/false.
326   */   */
# Line 169  void PamelaDBOperations::SetNOBOOT(Bool_ Line 329  void PamelaDBOperations::SetNOBOOT(Bool_
329  };  };
330    
331  /**  /**
332     * Store path to the TLE file.
333     */
334    void PamelaDBOperations::SetTLEPath(TString str){
335      tlefilename = str;
336    };
337    
338    TString PamelaDBOperations::GetRawPath(){
339      if ( STATIC ){
340        return((TString)gSystem->DirName(filerawname.Data())+'/');
341      } else {
342        return((TString)gSystem->ExpandPathName("$PAM_RAW")+'/');
343      };
344    };
345    
346    TString PamelaDBOperations::GetRootPath(){
347      if ( STATIC ){
348        return((TString)gSystem->DirName(filerootname.Data())+'/');
349      } else {
350        return((TString)gSystem->ExpandPathName("$PAM_L0")+'/');
351      };
352    };
353    
354    /**
355   * Store the olderthan variable   * Store the olderthan variable
356   * @param olderthan   * @param olderthan
357   */   */
358  void PamelaDBOperations::SetOlderThan(Long64_t oldthan){  // void PamelaDBOperations::SetOlderThan(Long64_t oldthan){
359    olderthan = oldthan;  //   olderthan = oldthan;
360  };  // };
361    
362  /**  /**
363   * Retrieve the ID_RAW, if exists, returns NULL if does not exist.   * Retrieve the ID_RAW, if exists, returns NULL if does not exist.
# Line 184  Bool_t PamelaDBOperations::SetID_RAW(){ Line 367  Bool_t PamelaDBOperations::SetID_RAW(){
367    TSQLResult *result = 0;    TSQLResult *result = 0;
368    TSQLRow    *row    = 0;    TSQLRow    *row    = 0;
369    oss.str("");    oss.str("");
370    oss << "SELECT ID FROM GL_RAW WHERE "    if ( STATIC ){
371        << " PATH = '" << this->GetRawPath().Data() << "' AND "      oss << "SELECT ID FROM GL_RAW WHERE "
372        << " NAME = '" << this->GetRawFile().Data() << "' ";          << " PATH = '" << this->GetRawPath().Data() << "' AND "
373            << " NAME = '" << this->GetRawFile().Data() << "' ";  
374      } else {
375        oss << "SELECT ID FROM GL_RAW WHERE "
376            << " PATH = '$PAM_RAW' AND "
377            << " NAME = '" << this->GetRawFile().Data() << "' ";  
378      }
379    result = conn->Query(oss.str().c_str());    result = conn->Query(oss.str().c_str());
380    if ( result == NULL ) throw -4;    if ( result == NULL ) throw -4;
381    row = result->Next();    row = result->Next();
# Line 217  Int_t PamelaDBOperations::SetUpperLimits Line 406  Int_t PamelaDBOperations::SetUpperLimits
406    UInt_t nevent = 0;    UInt_t nevent = 0;
407    UInt_t pktlast = 0;    UInt_t pktlast = 0;
408    UInt_t obtlast = 0;    UInt_t obtlast = 0;
409    UInt_t t_pktlast = 0;    Long64_t t_pktlast = 0LL;
410    UInt_t t_obtlast = 0;    //  UInt_t t_obtlast = 0;
411    UInt_t upperpkt2 = 0;    Long64_t t_obtlast = 0LL;
412    ULong64_t upperobt2 = 0;    Long64_t upperpkt2 = 0LL;
413      Long64_t upperobt2 = 0LL;
414    UInt_t zomp = 0;    UInt_t zomp = 0;
415    UInt_t jump = 50000; // was 5000    UInt_t jump = 50000; // was 5000
416      EventCounter *code=0;
417      //
418      Long64_t deltapkt = 5000LL;
419      Long64_t deltaobt = 50000LL;
420      //
421      pcksList packetsNames;
422      pcksList::iterator Iter;
423      getPacketsNames(packetsNames);
424    //    //
425    pktfirst = 0;    pktfirst = 0;
426    obtfirst = 0;    obtfirst = 0;
427      ppktfirst = 0;
428      pobtfirst = 0;
429    //    //
430    TTree *T = 0;    TTree *T = 0;
431    T = (TTree*)file->Get("Physics");    T = (TTree*)file->Get("Physics");
# Line 239  Int_t PamelaDBOperations::SetUpperLimits Line 439  Int_t PamelaDBOperations::SetUpperLimits
439    ph = eh->GetPscuHeader();    ph = eh->GetPscuHeader();
440    pktfirst = ph->GetCounter();    pktfirst = ph->GetCounter();
441    obtfirst = ph->GetOrbitalTime();      obtfirst = ph->GetOrbitalTime();  
442      ppktfirst = pktfirst;
443      pobtfirst = obtfirst;
444      //
445      code = eh->GetCounter();
446      UInt_t en = 0;
447      for(Iter = packetsNames.begin(); Iter != packetsNames.end(); Iter++){
448        en = code->Get(GetPacketType(*Iter));
449        if ( !strcmp("CalibCalPed",*Iter) || !strcmp("CalibTrk1",*Iter) || !strcmp("CalibTrk2",*Iter) || !strcmp("CalibS4",*Iter) ){
450          if ( IsDebug() ) printf(" We have a calibration before the first physic packet: packet type is %s, entries: %i \n",*Iter,en);
451          //
452          TTree *TC = 0;
453          TC = (TTree*)file->Get("CalibCalPed");
454          if ( !TC || TC->IsZombie() ) throw -16;
455          EventHeader *ehc = 0;
456          PscuHeader *phc = 0;
457          TC->SetBranchAddress("Header", &ehc);
458          TC->GetEntry(0);
459          phc = ehc->GetPscuHeader();
460          pktfirst = phc->GetCounter();
461          obtfirst = phc->GetOrbitalTime();  
462          //
463        };
464      };  
465    //    //
466    T->GetEntry(nevent-1);    T->GetEntry(nevent-1);
467    ph = eh->GetPscuHeader();    ph = eh->GetPscuHeader();
# Line 249  Int_t PamelaDBOperations::SetUpperLimits Line 472  Int_t PamelaDBOperations::SetUpperLimits
472    upperobt = OBT(obtlast);    upperobt = OBT(obtlast);
473    upperentry = nevent-1;    upperentry = nevent-1;
474    //    //
475    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);
476    //    //
477    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);
478    //    //
479    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);
480    //    //
481    if ( !nevent ) return(2);    if ( !nevent ) return(64);
482    //    //
483    if ( nevent < 2 ) return(4);    if ( nevent < 2 ) return(128);
484      if ( nevent < jump ) jump = 1;
485      //  if ( nevent < jump ) jump = int(nevent/10);
486      //  if ( !jump ) jump = 1;
487    //    //
488    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 ){
489        //
490        if ( IsDebug() ) printf(" starting jump %i \n",jump);
491      // go back      // go back
492      zomp = nevent - 2;      zomp = nevent - 2;
493      //      //
# Line 281  Int_t PamelaDBOperations::SetUpperLimits Line 509  Int_t PamelaDBOperations::SetUpperLimits
509          upperpkt2 = PKT(ph->GetCounter());          upperpkt2 = PKT(ph->GetCounter());
510          upperobt2 = OBT(ph->GetOrbitalTime());          upperobt2 = OBT(ph->GetOrbitalTime());
511          //          //
512          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) ){
513              if ( IsDebug() ) printf(" .-. upperpkt2 %lld upperobt2 %lld \n",upperpkt2,upperobt2);  
514              if ( IsDebug() ) printf(" .-. upperpkt %lld t_pktlast %lld upperobt %lld t_obtlast %lld \n",upperpkt,t_pktlast,upperobt,t_obtlast);    
515              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);    
516              throw -13;    
517            };
518          //          //
519          if ( t_pktlast < upperpkt && t_obtlast < upperobt && t_pktlast < upperpkt2 && t_obtlast < upperobt2 ){          if ( t_pktlast < upperpkt && t_obtlast < upperobt && t_pktlast < upperpkt2 && t_obtlast < upperobt2 ){
520            zomp = i + jump + 1;            zomp = i + jump + 1;
521            if ( zomp > nevent-2 ) zomp = nevent - 2;            if ( zomp > nevent-2 ) zomp = nevent - 2;
522            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);
523            break;            break;
524          };          };
525          //          //
# Line 308  Int_t PamelaDBOperations::SetUpperLimits Line 541  Int_t PamelaDBOperations::SetUpperLimits
541    // check if last runtrailer is within limits, if not extend limits (one should check for all packets but we need only runtrailer)    // check if last runtrailer is within limits, if not extend limits (one should check for all packets but we need only runtrailer)
542    //    //
543    PacketType *pctp=0;    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);  
544    TTree *rh=(TTree*)file->Get("RunHeader");    TTree *rh=(TTree*)file->Get("RunHeader");
545    if ( !rh || rh->IsZombie() ) throw -17;    if ( !rh || rh->IsZombie() ) throw -17;
546    TTree *rt=(TTree*)file->Get("RunTrailer");    TTree *rt=(TTree*)file->Get("RunTrailer");
# Line 326  Int_t PamelaDBOperations::SetUpperLimits Line 554  Int_t PamelaDBOperations::SetUpperLimits
554    //    //
555    rhev = rh->GetEntries();    rhev = rh->GetEntries();
556    rtev = rt->GetEntries();    rtev = rt->GetEntries();
557    UInt_t pktt = 0;    Long64_t sobtt = 0LL;
558    ULong64_t obtt = 0;    Long64_t sobth = 0LL;
559    UInt_t pkth = 0;    Long64_t spktt = 0LL;
560    ULong64_t obth = 0;    Long64_t spkth = 0LL;
561      Long64_t pktt = 0LL;
562      Long64_t obtt = 0LL;
563      Long64_t pkth = 0LL;
564      Long64_t obth = 0LL;
565    //    //
566    if ( lasttrail < rtev ){    if ( rhev || rtev ){
567      rt->GetEntry(lasttrail);  
568      pht = eht->GetPscuHeader();      T->GetEntry(upperentry);
569      pktt = PKT(pht->GetCounter());      code = eh->GetCounter();
570      obtt = OBT(pht->GetOrbitalTime());      Int_t lasttrail = code->Get(pctp->RunTrailer);
571        Int_t lasthead = code->Get(pctp->RunHeader);
572        if ( lasttrail < rtev ){
573          rt->GetEntry(lasttrail);
574          pht = eht->GetPscuHeader();
575          pktt = PKT(pht->GetCounter());
576          obtt = OBT(pht->GetOrbitalTime());
577        };
578        //
579        if ( lasthead < rhev ){
580          rh->GetEntry(lasthead);
581          phh = ehh->GetPscuHeader();
582          pkth = PKT(phh->GetCounter());
583          obth = OBT(phh->GetOrbitalTime());
584        };
585        //
586        if ( IsDebug() ) printf(" rhev before %i ph %lld upperp %lld oh %lld uppero %lld \n",rhev,pkth,upperpkt,obth,upperobt);
587        if ( pkth > upperpkt && obth > upperobt ){
588          if ( IsDebug() ) printf(" Upper limits extended to include last header: ph %lld upperp %lld oh %lld uppero %lld \n",pkth,upperpkt,obth,upperobt);
589          upperpkt = pkth;
590          upperobt = obth;
591          rhev = lasthead+1;
592        } else {
593          rhev = lasthead;
594        };
595        if ( IsDebug() ) printf(" rhev after %i ph %lld upperp %lld oh %lld uppero %lld \n",rhev,pkth,upperpkt,obth,upperobt);
596        //
597        if ( IsDebug() ) printf(" rtev beforev %i  pt %lld upperp %lld ot %lld uppero %lld \n",rtev,pktt,upperpkt,obtt,upperobt);
598        if ( pktt > upperpkt && obtt > upperobt ){
599          if ( IsDebug() ) printf(" Upper limits extended to include last trailer: pt %lld upperp %lld ot %lld uppero %lld \n",pktt,upperpkt,obtt,upperobt);
600          upperpkt = pktt;
601          upperobt = obtt;
602          rtev = lasttrail+1;
603        } else {
604          rtev = lasttrail;
605        };
606        if ( IsDebug() ) printf(" rtev after %i  pt %lld upperp %lld ot %lld uppero %lld \n",rtev,pktt,upperpkt,obtt,upperobt);
607        //  goto kikko;
608        //
609        //
610        // Check if runtrailer/runheader are within lower limits
611        //
612        //
613        pkth = 0LL;
614        obth = 0LL;
615        spkth = 0LL;
616        sobth = 0LL;
617        for (Int_t k=0; k<rhev; k++){
618          if ( k > 0 ){
619            spkth = pkth;
620            sobth = obth;
621          };
622          rh->GetEntry(k);
623          phh = ehh->GetPscuHeader();
624          pkth = PKT(phh->GetCounter());
625          obth = OBT(phh->GetOrbitalTime());
626          //
627          //    if ( IsDebug() ) printf(" k %i rhev before %i ph %u upperp %u oh %u uppero %u \n",k,rhev,pkth,spkth,obth,sobth);
628          //
629          if ( pkth < spkth && obth < sobth ){
630            if ( IsDebug() ) printf(" RH PROBLEMS determining the event repetition at the end of the file lasthead %i  \n",rhev);
631            //
632            rhev = k-1;
633            rh->GetEntry(rhev);
634            pkth = spkth;
635            obth = sobth;
636            //
637            UInt_t evbefh = 0;
638            code = ehh->GetCounter();
639            evbefh = code->Get(pctp->Physics);    
640            if ( evbefh >= 0 ){
641              T->GetEntry(evbefh);
642              ph = eh->GetPscuHeader();
643              t_pktlast = PKT(ph->GetCounter());
644              t_obtlast = OBT(ph->GetOrbitalTime());
645              if ( t_pktlast <= spkth && t_obtlast <= sobth ){ // jump
646                upperpkt = pkth;
647                upperobt = obth;
648                upperentry = evbefh-1;
649              } else {
650                while ( t_pktlast > spkth && t_obtlast > sobth && evbefh < nevent ){
651                  evbefh++;
652                  T->GetEntry(evbefh);
653                  ph = eh->GetPscuHeader();
654                  t_pktlast = PKT(ph->GetCounter());
655                  t_obtlast = OBT(ph->GetOrbitalTime());
656                };
657                T->GetEntry(evbefh-1);
658                ph = eh->GetPscuHeader();
659                upperpkt = PKT(ph->GetCounter());
660                upperobt = OBT(ph->GetOrbitalTime());
661                upperentry = evbefh-1;
662              };    
663            };
664            if ( IsDebug() ) printf(" rhev after %i ph %lld upperp %lld oh %lld uppero %lld \n",rhev,pkth,upperpkt,obth,upperobt);
665            goto kikko0;
666          };
667        };
668      kikko0:
669        //
670        //
671        //
672        pktt = 0LL;
673        obtt = 0LL;
674        spktt = 0LL;
675        sobtt = 0LL;
676        for (Int_t k=0; k<rtev; k++){
677          if ( k > 0 ){
678            spktt = pktt;
679            sobtt = obtt;
680          };
681          rt->GetEntry(k);
682          pht = eht->GetPscuHeader();
683          pktt = PKT(pht->GetCounter());
684          obtt = OBT(pht->GetOrbitalTime());
685          //
686          //    if ( IsDebug() ) printf(" k %i rtev beforev %i  pt %i upperp %i ot %llu uppero %llu \n",k,rtev,pktt,spktt,obtt,sobtt);
687          //
688          if ( pktt < spktt && obtt < sobtt ){
689            if ( IsDebug() ) printf(" RT PROBLEMS determining the event repetition at the end of the file lasttrail %i \n",rtev);
690            //
691            rtev = k-1;
692            rt->GetEntry(rtev);
693            pktt = spktt;
694            obtt = sobtt;
695            if ( IsDebug() ) printf(" lasttrail %i pt %lld upperp %lld ot %lld uppero %lld \n",rtev,pktt,upperpkt,obtt,upperobt);
696            //
697            UInt_t evbeft = 0;
698            code = eht->GetCounter();
699            evbeft = code->Get(pctp->Physics);    
700            if ( evbeft >= 0 ){
701              T->GetEntry(evbeft);
702              ph = eh->GetPscuHeader();
703              t_pktlast = PKT(ph->GetCounter());
704              t_obtlast = OBT(ph->GetOrbitalTime());
705              if ( t_pktlast <= spktt && t_obtlast <= sobtt ){ // jump
706                upperpkt = pktt;
707                upperobt = obtt;
708                upperentry = evbeft-1;
709              } else {
710                while ( t_pktlast > spktt && t_obtlast > sobtt && evbeft < nevent ){
711                  evbeft++;
712                  T->GetEntry(evbeft);
713                  ph = eh->GetPscuHeader();
714                  t_pktlast = PKT(ph->GetCounter());
715                  t_obtlast = OBT(ph->GetOrbitalTime());
716                };
717                T->GetEntry(evbeft-1);
718                ph = eh->GetPscuHeader();
719                upperpkt = PKT(ph->GetCounter());
720                upperobt = OBT(ph->GetOrbitalTime());
721                upperentry = evbeft-1;
722              };
723            };
724            if ( IsDebug() ) printf(" rtev after %i  pt %lld upperp %lld ot %lld uppero %lld \n",rtev,pktt,upperpkt,obtt,upperobt);
725            goto kikko;
726            //      break;
727            //
728          };
729          //  
730        };
731        //
732      kikko:
733        //
734        T->GetEntry(upperentry);
735        code = eh->GetCounter();
736        lasttrail = code->Get(pctp->RunTrailer);
737        lasthead = code->Get(pctp->RunHeader);
738        if ( lasttrail < rtev ){
739          rt->GetEntry(lasttrail);
740          pht = eht->GetPscuHeader();
741          pktt = PKT(pht->GetCounter());
742          obtt = OBT(pht->GetOrbitalTime());
743        };
744        //
745        if ( lasthead < rhev ){
746          rh->GetEntry(lasthead);
747          phh = ehh->GetPscuHeader();
748          pkth = PKT(phh->GetCounter());
749          obth = OBT(phh->GetOrbitalTime());
750        };
751        //
752        if ( IsDebug() ) printf(" rhev before %i ph %lld upperp %lld oh %lld uppero %lld \n",rhev,pkth,upperpkt,obth,upperobt);
753        if ( pkth > upperpkt && obth > upperobt ){
754          if ( IsDebug() ) printf(" Upper limits extended to include last header: ph %lld upperp %lld oh %lld uppero %lld \n",pkth,upperpkt,obth,upperobt);
755          upperpkt = pkth;
756          upperobt = obth;
757          rhev = lasthead+1;
758        } else {
759          rhev = lasthead;
760        };
761        if ( IsDebug() ) printf(" rhev after %i ph %lld upperp %lld oh %lld uppero %lld \n",rhev,pkth,upperpkt,obth,upperobt);
762        //
763        if ( IsDebug() ) printf(" rtev beforev %i  pt %lld upperp %lld ot %lld uppero %lld \n",rtev,pktt,upperpkt,obtt,upperobt);
764        if ( pktt > upperpkt && obtt > upperobt ){
765          if ( IsDebug() ) printf(" Upper limits extended to include last trailer: pt %lld upperp %lld ot %lld uppero %lld \n",pktt,upperpkt,obtt,upperobt);
766          upperpkt = pktt;
767          upperobt = obtt;
768          rtev = lasttrail+1;
769        } else {
770          rtev = lasttrail;
771        };
772        if ( IsDebug() ) printf(" rtev after %i  pt %lld upperp %lld ot %lld uppero %lld \n",rtev,pktt,upperpkt,obtt,upperobt);
773        //
774    };    };
775    //    //
776    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);  
777    //    //
778    if ( lasthead < rhev ){    return(0);
779      rh->GetEntry(lasthead);  }
780      phh = ehh->GetPscuHeader();  
781      pkth = PKT(pht->GetCounter());  /**
782      obth = OBT(pht->GetOrbitalTime());   *
783    };   * Trick to have unique RUN ID numbers even when runs are deleted and mysql deamon restarted.
784     * Entries in the _RUNID_GEN table are never deleted.
785     *
786     **/
787    UInt_t PamelaDBOperations::AssignRunID(){
788    //    //
789    if ( IsDebug() ) printf(" rhev before %i ph %i upperp %i oh %llu uppero %llu \n",rhev,pkth,upperpkt,obth,upperobt);    TSQLResult *result = 0;
790    if ( pkth > upperpkt && obth > upperobt ){    TSQLRow *row = 0;
791      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);  
792    //    //
793    if ( IsDebug() ) printf(" Upper limits are: OBT %llu pkt_num %i upper entry %i \n",upperobt,upperpkt,upperentry);    stringstream   oss;
794      //  
795      oss.str("");
796      oss << "INSERT INTO _RUNID_GEN VALUES (NULL);";
797      result = conn->Query(oss.str().c_str());
798      if ( !result ) throw -10;
799      oss.str("");
800      oss << "SELECT ID FROM _RUNID_GEN ORDER BY ID DESC LIMIT 1;";
801      result = conn->Query(oss.str().c_str());
802      if ( !result ) throw -10;
803    //    //
804    return(0);    row = result->Next();
805  }    //
806      if ( !row ) throw -28;
807      //
808      runid = (UInt_t)atoll(row->GetField(0));
809      //
810      return(runid);
811    };
812    
813  //  //
814  // GETTERS  // GETTERS
# Line 447  const PacketType* PamelaDBOperations::Ge Line 885  const PacketType* PamelaDBOperations::Ge
885  // PRIVATE FUNCTIONS  // PRIVATE FUNCTIONS
886  //  //
887    
888  /**  // /**
889   * Open the ROOT filename for reading  // * Open the ROOT filename for reading
890   */  // */
891  void PamelaDBOperations::OpenFile(){  // void PamelaDBOperations::OpenFile(){
892    file = TFile::Open(this->GetRootName().Data());  //   file = TFile::Open(this->GetRootName().Data());
893    //   //
894    
895    void PamelaDBOperations::CheckFile(){  
896      if ( !file ) throw -12;
897  };  };
898    
899    
900  /**  /**
901   * Check if LEVEL0 file and DB connection have really be opened   * Check if LEVEL0 file and DB connection have really be opened
902   */   */
903  void PamelaDBOperations::CheckFile(){    void PamelaDBOperations::CheckConnection(){  
   //  
   if ( !file ) throw -12;  
904    //    //
905    // check connection    // check connection
906    //    //
907    if( !conn ) throw -1;        if( !conn ) throw -1;
908    bool connect = conn->IsConnected();    bool connect = conn->IsConnected();
909    if( !connect ) throw -1;        if( !connect ) throw -1;
910      //
911      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());
912      //
913      if ( !dworbit && strcmp(this->GetRootName().Data(),"") ) throw -27;
914      //
915      // set DB timezone to UTC
916      //
917      stringstream oss;
918      //  
919      oss.str("");
920      oss << "SET time_zone='+0:00';";
921      TSQLResult *result = 0;
922      result = conn->Query(oss.str().c_str());
923      if ( !result ) throw -10;
924      oss.str("");
925      oss << "SET wait_timeout=173000;";
926      conn->Query(oss.str().c_str());
927      //
928  };  };
929    
930  /**  /**
931   * Return the correct packet number if we went back to zero   * Return the correct packet number if we went back to zero
932   */   */
933  UInt_t PamelaDBOperations::PKT(UInt_t pkt_num){    Long64_t PamelaDBOperations::PKT(UInt_t pkt_num){  
934    //    //
935    //  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));
936    //    //
937    if ( pkt_num < (pktfirst/2) && pktfirst > (16777214/2)  ) return((pkt_num+16777215));    if ( pkt_num < (ppktfirst/2) && ppktfirst > (16777214/2)  ){
938        if ( IsDebug() ) printf(" rise up pktnum %lld \n",(Long64_t)pkt_num+16777215LL);
939        return((Long64_t)pkt_num+16777215LL);
940      };
941    //    //
942    if ( pkt_num > pktfirst*2 && pkt_num > (16777214/2) ){    if ( pkt_num > ((Long64_t)ppktfirst*2) && pkt_num > (16777214/2) ){
943      if ( (pkt_num-16777215) < 0 ){      if ( IsDebug() ) printf(" rise down pktnum %lld \n",(Long64_t)pkt_num-16777215LL);
944        return((16777215-pkt_num));      return((Long64_t)pkt_num-16777215LL);
     } else {  
       return((pkt_num-16777215));  
     };  
945    };    };
946    //    //
947    return(pkt_num);    if ( IsDebug() ) printf(" as it is %lld \n",(Long64_t)pkt_num);
948      return((Long64_t)pkt_num);
949    //    //
950  };  };
951    
952  /**  /**
953   * Return the correct On Board Time if we went back to zero   * Return the correct On Board Time if we went back to zero
954   */   */
955  ULong64_t PamelaDBOperations::OBT(UInt_t obt){    Long64_t PamelaDBOperations::OBT(UInt_t obt){  
956    //    //
957    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));
958    //    //
959    if ( obt > (obtfirst*2) && obt > (numeric_limits<UInt_t>::max()/2) ){    if ( obt < (pobtfirst/2) && pobtfirst > (numeric_limits<UInt_t>::max()/2) ){
960      if ( (obt-numeric_limits<UInt_t>::max()) < 0  ){      if ( IsDebug() ) printf(" rise up obt %lld \n",(Long64_t)(obt+numeric_limits<UInt_t>::max()));
961        return((ULong64_t)(numeric_limits<UInt_t>::max()-obt));      return((Long64_t)(obt+numeric_limits<UInt_t>::max()));
962      } else {    };
963        return((ULong64_t)(obt-numeric_limits<UInt_t>::max()));    //
964      };    if ( obt > ((Long64_t)pobtfirst*2) && obt > (numeric_limits<UInt_t>::max()/2) ){
965        if ( IsDebug() ) printf(" pobtfirst*2 %lld \n",((Long64_t)pobtfirst*2));
966        if ( IsDebug() ) printf(" rise down pktnum %lld \n", (Long64_t)obt-(Long64_t)numeric_limits<UInt_t>::max());
967        return((Long64_t)obt-(Long64_t)numeric_limits<UInt_t>::max());
968    };    };
969    //    //
970    return((ULong64_t)obt);    if ( IsDebug() ) printf(" as it is %lld \n",(Long64_t)obt);
971      return((Long64_t)obt);
972  };  };
973    
974  /**  /**
# Line 620  Int_t PamelaDBOperations::insertPamelaRa Line 1083  Int_t PamelaDBOperations::insertPamelaRa
1083    if ( idr ) return(1);    if ( idr ) return(1);
1084    //    //
1085    oss.str("");    oss.str("");
1086    oss << "INSERT INTO GL_RAW (PATH, NAME) VALUES ('"    if ( STATIC ){
1087        << this->GetRawPath().Data() << "', '" << this->GetRawFile().Data() << "')";      oss << "INSERT INTO GL_RAW (PATH, NAME) VALUES ('"
1088            << this->GetRawPath().Data() << "', '" << this->GetRawFile().Data() << "')";
1089      } else {
1090        oss << "INSERT INTO GL_RAW (PATH, NAME) VALUES ('$PAM_RAW', '" << this->GetRawFile().Data() << "')";
1091      };
1092    if ( conn->Query(oss.str().c_str()) == 0 ) throw -4;    if ( conn->Query(oss.str().c_str()) == 0 ) throw -4;
1093    //    //
1094    idr =  this->SetID_RAW();    idr =  this->SetID_RAW();
# Line 640  Int_t PamelaDBOperations::insertPamelaGL Line 1107  Int_t PamelaDBOperations::insertPamelaGL
1107    TSQLResult *result = 0;    TSQLResult *result = 0;
1108    TSQLRow *row = 0;    TSQLRow *row = 0;
1109    UInt_t t0 = 0;    UInt_t t0 = 0;
1110      Int_t signal = 0;
1111      UInt_t idresof = 0;
1112      //
1113      signal = this->SetUpperLimits();
1114    //    //
1115    stringstream   oss;    stringstream   oss;
1116    //      //  
1117    if ( this->GetID_RAW() == 0 )  throw -11;    if ( this->GetID_RAW() == 0 )  throw -11;
1118    //    //
1119    oss.str("");    oss.str("");
1120    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),ID FROM GL_RESURS_OFFSET WHERE SPECIAL_FILE='"
1121        << id << " AND TO_ID_RAW >= "        << this->GetRawFile().Data() << "';";
       << id << ";";  
1122    if ( IsDebug() ) printf(" %s \n",oss.str().c_str());    if ( IsDebug() ) printf(" %s \n",oss.str().c_str());
1123    result = conn->Query(oss.str().c_str());    result = conn->Query(oss.str().c_str());
1124    if ( !result ) throw -10;    if ( !result ) throw -10;
1125    row = result->Next();    row = result->Next();
   if ( !row ) throw -10;  
1126    //    //
1127    t0 = (UInt_t)TDatime(row->GetField(0)).Convert();    if ( !row ){
1128        oss.str("");
1129        oss << "SELECT YEAR(OFFSET_DATE),MONTH(OFFSET_DATE),DAY(OFFSET_DATE),HOUR(OFFSET_DATE),MINUTE(OFFSET_DATE),SECOND(OFFSET_DATE),ID FROM GL_RESURS_OFFSET WHERE FROM_ORBIT< "
1130            << dworbit << " order by FROM_ORBIT desc limit 1;";
1131        if ( IsDebug() ) printf(" %s \n",oss.str().c_str());
1132        result = conn->Query(oss.str().c_str());
1133        if ( !result ) throw -10;
1134        row = result->Next();
1135        if ( !row ) throw -10;
1136      };
1137      //
1138      idresof = (UInt_t)atoll(row->GetField(6));
1139      //
1140      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);
1141      t0 = (UInt_t)tu.GetSec();
1142      if ( IsDebug() ) printf(" t0 is %u ti is %s %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),row->GetField(6));
1143      //
1144    /*    /*
1145     * Verify that the TIMESYNC have been not already processed     * Verify that the TIMESYNC have been not already processed
1146     */     */
# Line 670  Int_t PamelaDBOperations::insertPamelaGL Line 1155  Int_t PamelaDBOperations::insertPamelaGL
1155    if (result == NULL) throw -10;    if (result == NULL) throw -10;
1156    row = result->Next();    row = result->Next();
1157    if ((row != NULL) && ((UInt_t)atoll(row->GetField(0)) > 0)){    if ((row != NULL) && ((UInt_t)atoll(row->GetField(0)) > 0)){
1158        if ( IsDebug() ) printf(" found a timesync t0 is %u \n",t0);
1159      toffset = (UInt_t)atoll(row->GetField(2)) - (UInt_t)(this->OBT((UInt_t)atoll(row->GetField(1)))/1000) + t0;      toffset = (UInt_t)atoll(row->GetField(2)) - (UInt_t)(this->OBT((UInt_t)atoll(row->GetField(1)))/1000) + t0;
1160        //
1161        tsync = (UInt_t)atoll(row->GetField(2));
1162        obt0 = (UInt_t)atoll(row->GetField(1));
1163        //
1164      return(1);      return(1);
1165    };    };
1166    //    //
1167    TTree *T = 0;    TTree *T = 0;
   Int_t signal = 0;  
1168    //    //
1169    UInt_t nevent = 0;    UInt_t nevent = 0;
1170    UInt_t recEntries = 0;    UInt_t recEntries = 0;
# Line 727  Int_t PamelaDBOperations::insertPamelaGL Line 1216  Int_t PamelaDBOperations::insertPamelaGL
1216          //          //
1217          TYPE = 55;//224;          TYPE = 55;//224;
1218          //          //
1219            if ( IsDebug() ) printf("mcmd tsync %i tsync %u obt %u \n",i,TSYNC,OBT);
1220            //
1221          if ( TSYNC && OBT ){          if ( TSYNC && OBT ){
1222            existsts = true;            existsts = true;
1223            goto eout;            goto eout;
# Line 749  Int_t PamelaDBOperations::insertPamelaGL Line 1240  Int_t PamelaDBOperations::insertPamelaGL
1240      //      //
1241      rt->SetBranchAddress("RunTrailer", &runt);      rt->SetBranchAddress("RunTrailer", &runt);
1242      //      //
1243      if ( rhev > 0 ){      Int_t nrhev = rh->GetEntries();
1244        rh->GetEntry(0);      Int_t nrtev = rt->GetEntries();
1245        //      if ( IsDebug() ) printf(" ou nevent %i rhev %i rtev %i \n",nevent,nrhev,nrtev);
1246        TSYNC = runh->LAST_TIME_SYNC_INFO;      //
1247        OBT = runh->OBT_TIME_SYNC * 1000;      if ( nrhev > 0 ){
1248        //        for (Int_t i=0; i<nrhev; i++){
1249        TYPE = 20;          //
1250        //          rh->GetEntry(i);
1251        if ( TSYNC && OBT ){          //
1252          existsts = true;          TSYNC = runh->LAST_TIME_SYNC_INFO;
1253          goto eout;          OBT = runh->OBT_TIME_SYNC * 1000;
1254            //
1255            TYPE = 20;
1256            //
1257            if ( IsDebug() ) printf("runheader %i tsync %u obt %u \n",i,TSYNC,OBT);
1258            //
1259            if ( TSYNC && OBT ){
1260              existsts = true;
1261              goto eout;
1262            };
1263        };        };
1264        //        //
1265      };      };
1266      if ( rtev > 0 ){      if ( nrtev > 0 ){
1267        //        //
1268        if ( IsDebug() ) printf(" No runheader \n");        if ( IsDebug() ) printf(" No runheader \n");
1269        signal = 6;        signal = 6;
1270        //        //
1271        rt->GetEntry(0);        for (Int_t i=0; i<nrtev; i++){
1272        //          //
1273        TSYNC = runt->LAST_TYME_SYNC_INFO;          rt->GetEntry(i);
1274        OBT = runt->OBT_TYME_SYNC * 1000;          //
1275        //          TSYNC = runt->LAST_TYME_SYNC_INFO;
1276        TYPE = 21;          OBT = runt->OBT_TYME_SYNC * 1000;
1277        //          //
1278        if ( TSYNC && OBT ){          TYPE = 21;
1279          existsts = true;          //
1280          goto eout;          if ( IsDebug() ) printf("runtrailer %i tsync %u obt %u \n",i,TSYNC,OBT);
1281            //
1282            if ( TSYNC && OBT ){
1283              existsts = true;
1284              goto eout;
1285            };
1286        };        };
1287        //        //
1288      } else {      } else {
# Line 840  Int_t PamelaDBOperations::insertPamelaGL Line 1345  Int_t PamelaDBOperations::insertPamelaGL
1345    if ( !existsts ) throw -3;    if ( !existsts ) throw -3;
1346    //    //
1347    oss.str("");    oss.str("");
1348    oss << "INSERT INTO GL_TIMESYNC (ID_RAW,TYPE,OBT0,TIMESYNC) VALUES ('"    oss << "INSERT INTO GL_TIMESYNC (ID_RAW,TYPE,OBT0,TIMESYNC,ID_RESURS_OFFSET) VALUES ('"
1349        << this->GetID_RAW() << "','"//224'"        << this->GetID_RAW() << "','"//224'"
1350        << dec << (UInt_t)TYPE << "','"        << dec << (UInt_t)TYPE << "','"
1351        << dec << (UInt_t)OBT << "','"        << dec << (UInt_t)OBT << "','"
1352        << dec << (UInt_t)TSYNC << "');";        << dec << (UInt_t)TSYNC << "','"
1353          << dec << (UInt_t)idresof << "');";
1354    conn->Query(oss.str().c_str());    conn->Query(oss.str().c_str());
1355    if ( IsDebug() ) printf(" Query the GL_TIMESYNC table to fill it:\n %s \n",oss.str().c_str());    if ( IsDebug() ) printf(" Query the GL_TIMESYNC table to fill it:\n %s \n",oss.str().c_str());
1356      if ( conn->GetErrorCode() ){
1357        printf(" OK, you got an error because the database structure you are using is not up to date\n Using backward compability code, hence you can continue safetly \n");
1358        oss.str("");
1359        oss << "INSERT INTO GL_TIMESYNC (ID_RAW,TYPE,OBT0,TIMESYNC) VALUES ('"
1360            << this->GetID_RAW() << "','"//224'"
1361            << dec << (UInt_t)TYPE << "','"
1362            << dec << (UInt_t)OBT << "','"
1363            << dec << (UInt_t)TSYNC << "');";
1364        conn->Query(oss.str().c_str());
1365        if ( IsDebug() ) printf(" Query the GL_TIMESYNC table to fill it:\n %s \n",oss.str().c_str());
1366      };
1367      //
1368      if ( IsDebug() ) printf(" found a timesync t0 is %u \n",t0);
1369    //    //
1370    toffset = (UInt_t)TSYNC - (UInt_t)(this->OBT(OBT)/1000) + t0;    toffset = (UInt_t)TSYNC - (UInt_t)(this->OBT(OBT)/1000) + t0;
1371    //    //
1372      tsync = TSYNC;
1373      obt0 = OBT;
1374      //
1375    delete result;    delete result;
1376    return(signal);    return(signal);
1377  }  }
# Line 865  Int_t PamelaDBOperations::insertPamelaRo Line 1387  Int_t PamelaDBOperations::insertPamelaRo
1387    UInt_t idtimesync = 0;    UInt_t idtimesync = 0;
1388    //    //
1389    oss.str("");    oss.str("");
1390    oss << " SELECT COUNT(GL_ROOT.ID_RAW),GL_RAW.ID,GL_ROOT.ID FROM GL_RAW "    if ( STATIC ){
1391        << " LEFT JOIN GL_ROOT "      oss << " SELECT COUNT(GL_ROOT.ID_RAW),GL_RAW.ID,GL_ROOT.ID FROM GL_RAW "
1392        << " ON GL_RAW.ID = GL_ROOT.ID_RAW "          << " LEFT JOIN GL_ROOT "
1393        << " WHERE GL_RAW.PATH = '" << this->GetRawPath().Data() << "' AND "          << " ON GL_RAW.ID = GL_ROOT.ID_RAW "
1394        << " GL_RAW.NAME = '" << this->GetRawFile().Data() << "' GROUP BY GL_RAW.ID ";          << " WHERE GL_RAW.PATH = '" << this->GetRawPath().Data() << "' AND "
1395            << " GL_RAW.NAME = '" << this->GetRawFile().Data() << "' GROUP BY GL_RAW.ID ";
1396      } else {
1397        oss << " SELECT COUNT(GL_ROOT.ID_RAW),GL_RAW.ID,GL_ROOT.ID FROM GL_RAW "
1398            << " LEFT JOIN GL_ROOT "
1399            << " ON GL_RAW.ID = GL_ROOT.ID_RAW "
1400            << " WHERE GL_RAW.PATH = '$PAM_RAW' AND "
1401            << " GL_RAW.NAME = '" << this->GetRawFile().Data() << "' GROUP BY GL_RAW.ID ";
1402      };
1403    result = conn->Query(oss.str().c_str());    result = conn->Query(oss.str().c_str());
1404    //    //
1405    if ( !result ) throw -12;    if ( !result ) throw -12;
# Line 896  Int_t PamelaDBOperations::insertPamelaRo Line 1426  Int_t PamelaDBOperations::insertPamelaRo
1426    idtimesync = (UInt_t)atoll(row->GetField(0));    idtimesync = (UInt_t)atoll(row->GetField(0));
1427    //    //
1428    oss.str("");    oss.str("");
1429    oss << "INSERT INTO GL_ROOT (ID_RAW, ID_TIMESYNC,PATH, NAME) VALUES ('"    if ( STATIC ){
1430        << this->GetID_RAW() << "', '" << idtimesync << "', '" << this->GetRootPath().Data() << "', '" << this->GetRootFile().Data() << "')";      oss << "INSERT INTO GL_ROOT (ID_RAW, ID_TIMESYNC,PATH, NAME) VALUES ('"
1431            << this->GetID_RAW() << "', '" << idtimesync << "', '" << this->GetRootPath().Data() << "', '" << this->GetRootFile().Data() << "')";
1432      } else {
1433        oss << "INSERT INTO GL_ROOT (ID_RAW, ID_TIMESYNC,PATH, NAME) VALUES ('"
1434            << this->GetID_RAW() << "', '" << idtimesync << "', '$PAM_L0', '" << this->GetRootFile().Data() << "')";
1435      };
1436    //    //
1437    if (conn->Query(oss.str().c_str()) == 0) throw -4;    if (conn->Query(oss.str().c_str()) == 0) throw -4;
1438    //    //
# Line 924  Int_t PamelaDBOperations::assignBOOT_NUM Line 1459  Int_t PamelaDBOperations::assignBOOT_NUM
1459    TSQLResult *result = 0;    TSQLResult *result = 0;
1460    TSQLRow    *row    = 0;    TSQLRow    *row    = 0;
1461    oss.str("");    oss.str("");
1462    oss << "SELECT ID, BOOT_NUMBER FROM GL_RAW WHERE "    if ( STATIC ){
1463        << " PATH = '" << this->GetRawPath().Data() << "' AND "      oss << "SELECT ID, BOOT_NUMBER FROM GL_RAW WHERE "
1464        << " NAME = '" << this->GetRawFile().Data() << "' ";          << " PATH = '" << this->GetRawPath().Data() << "' AND "
1465            << " NAME = '" << this->GetRawFile().Data() << "' ";
1466      } else {
1467        oss << "SELECT ID, BOOT_NUMBER FROM GL_RAW WHERE "
1468            << " PATH = '$PAM_RAW' AND "
1469            << " NAME = '" << this->GetRawFile().Data() << "' ";
1470      };
1471    result = conn->Query(oss.str().c_str());    result = conn->Query(oss.str().c_str());
1472    //    //
1473    if ( !result ) throw -4;;    if ( !result ) throw -4;;
# Line 949  Int_t PamelaDBOperations::assignBOOT_NUM Line 1490  Int_t PamelaDBOperations::assignBOOT_NUM
1490    VarDumpEvent  *vde = 0;    VarDumpEvent  *vde = 0;
1491    VarDumpRecord *vdr = 0;    VarDumpRecord *vdr = 0;
1492    //    //
1493      Bool_t found = false;
1494    trDumpEv->SetBranchAddress("VarDump", &vde);    trDumpEv->SetBranchAddress("VarDump", &vde);
1495    if ( trDumpEv->GetEntries() > 0 ){    if ( trDumpEv->GetEntries() > 0 ){
1496      Bool_t found = false;      found = false;
1497      for ( Int_t i = 0; i < trDumpEv->GetEntries(); i++){      for ( Int_t i = 0; i < trDumpEv->GetEntries(); i++){
1498        trDumpEv->GetEntry(i);        trDumpEv->GetEntry(i);
1499        vde->Records->GetEntries();        //      vde->Records->GetEntries();
1500        if ( vde->Records->GetEntries()>0 ){        if ( vde->Records->GetEntries()>5 ){
1501          found = true;          found = true;
1502          goto fill;          goto fill;
1503        };        };
# Line 968  Int_t PamelaDBOperations::assignBOOT_NUM Line 1510  Int_t PamelaDBOperations::assignBOOT_NUM
1510        this->SetBOOTnumber((Int_t)vdr->VAR_VALUE);        this->SetBOOTnumber((Int_t)vdr->VAR_VALUE);
1511        //        //
1512      } else {      } else {
1513        if ( !this->GetBOOTnumber() ) return(4);        if ( !this->GetBOOTnumber() && !this->AutoBoot()) return(4);
1514        };
1515      } else {
1516        if ( !this->GetBOOTnumber() && !this->AutoBoot()) return(2);
1517      };
1518      //
1519      UInt_t bn = 0;
1520      Bool_t afound = false;
1521      if ( !found && this->AutoBoot()){
1522        afound = true;
1523        //
1524        // Search for other files with similar timesync
1525        //
1526        if ( IsDebug() ) printf(" tsync %u obt0 %u \n",tsync,obt0);
1527        UInt_t upperts = tsync-(obt0/1000)+5;
1528        UInt_t lowerts = tsync-(obt0/1000)-5;
1529        oss.str("");
1530        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)<"
1531            << upperts
1532            << " AND TIMESYNC-(OBT0/1000)>"
1533            << lowerts
1534            << " AND GL_RAW.BOOT_NUMBER>0 GROUP BY GL_TIMESYNC.OBT0;";
1535        result = conn->Query(oss.str().c_str());
1536        if ( IsDebug() ) printf(" Query the GL_TIMESYNC table to find boot number:\n %s \n",oss.str().c_str());
1537        //
1538        if ( !result ) throw -4;;
1539        found = true;
1540        if ( result->GetRowCount()<3 ){
1541          if ( IsDebug() ) printf(" AGH! no results!\n");
1542          found = false;
1543        } else {
1544          row = result->Next();      
1545          bn = (UInt_t)atoll(row->GetField(0));
1546          for ( Int_t r=1; r<result->GetRowCount() ;r++){
1547            if ( !row ) throw -4;
1548            if ( IsDebug() ) printf(" BOOT number is %s \n",row->GetField(0));
1549            if ( bn != (UInt_t)atoll(row->GetField(0)) ){
1550              if ( IsDebug() ) printf(" AGH! bn = %u here instead %u \n",bn,(UInt_t)atoll(row->GetField(0)));
1551              found = false;
1552            };
1553            row = result->Next();
1554          };
1555      };      };
1556      };
1557      //
1558      Int_t sgn = 0;
1559      //
1560      if ( !found && !BOOTNO ){
1561        throw -29;
1562    } else {    } else {
1563      if ( !this->GetBOOTnumber() ) return(2);      if ( afound ){
1564          this->SetBOOTnumber(bn);
1565          sgn = 8;
1566        };
1567    };    };
1568    //    //
1569    oss.str("");    oss.str("");
# Line 981  Int_t PamelaDBOperations::assignBOOT_NUM Line 1573  Int_t PamelaDBOperations::assignBOOT_NUM
1573    conn->Query(oss.str().c_str());          conn->Query(oss.str().c_str());      
1574    //    //
1575    delete result;    delete result;
1576    return(0);    return(sgn);
1577  };  };
1578    
1579  /**  /**
# Line 994  Int_t PamelaDBOperations::insertPamelaRU Line 1586  Int_t PamelaDBOperations::insertPamelaRU
1586    stringstream oss;    stringstream oss;
1587    oss.str("");    oss.str("");
1588    //    //
1589    signal = this->SetUpperLimits();    //  signal = this->SetUpperLimits();
1590    //    //
1591    // loop on runheader and runtrailer events    // loop on runheader and runtrailer events
1592    //    //
# Line 1012  Int_t PamelaDBOperations::insertPamelaRU Line 1604  Int_t PamelaDBOperations::insertPamelaRU
1604    rt->SetBranchAddress("RunTrailer", &runt);    rt->SetBranchAddress("RunTrailer", &runt);
1605    rt->SetBranchAddress("Header", &eht);    rt->SetBranchAddress("Header", &eht);
1606    //    //
1607      TTree *T = (TTree*)file->Get("Physics");
1608      if ( !T || T->IsZombie() ) throw -16;
1609      EventHeader *eh = 0;
1610      T->SetBranchAddress("Header", &eh);
1611      //
1612      if ( !(rh->GetEntries()) && !(rt->GetEntries()) && !(T->GetEntries()) ) return(16);
1613      //
1614    UInt_t obtt = 0;    UInt_t obtt = 0;
1615    UInt_t obth = 0;    UInt_t obth = 0;
1616    UInt_t pktt = 0;    UInt_t pktt = 0;
# Line 1045  Int_t PamelaDBOperations::insertPamelaRU Line 1644  Int_t PamelaDBOperations::insertPamelaRU
1644        //        //
1645        if ( !ptt &&  !(ptht+1) ){        if ( !ptt &&  !(ptht+1) ){
1646          //          //
1647          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);
1648          //          //
1649          this->HandleRunFragments(true,false,0,(evbeft-1));          this->HandleRunFragments(true,false,0,(evbeft-1));
1650          //          //
1651          //          //
1652        } else if ( pth == ptht ){        } else if ( pth == ptht ){
1653          //          //
1654          if ( IsDebug() ) printf(" Missing header %i %i %i\n",ptht,pth,ptt);          if ( IsDebug() ) printf(" Missing header %u %u %u\n",ptht,pth,ptt);
1655          //          //
1656          if ( (ptt-1) < 0 ) throw -15; // should never arrive here!          if ( (ptt-1) < 0 ) throw -15; // should never arrive here!
1657          rt->GetEntry(ptt-1);          rt->GetEntry(ptt-1);
# Line 1061  Int_t PamelaDBOperations::insertPamelaRU Line 1660  Int_t PamelaDBOperations::insertPamelaRU
1660          rt->GetEntry(ptt);          rt->GetEntry(ptt);
1661          pht = eht->GetPscuHeader();          pht = eht->GetPscuHeader();
1662          //          //
1663          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);
1664          if ( IsDebug() ) printf(" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''  %i %i %i \n",pkth,obth,obtt);          if ( IsDebug() ) printf(" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''  %u %u %u \n",pkth,obth,obtt);
1665          //          //
1666          this->HandleMissingHoT(true,false,evbefh,evbeft-1);          this->HandleMissingHoT(true,false,evbefh,evbeft-1);
1667          //          //
1668        } else {        } else {
1669          //          //
1670          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);
1671          //          //
1672          rh->GetEntry(ptht);          rh->GetEntry(ptht);
1673          phh = ehh->GetPscuHeader();          phh = ehh->GetPscuHeader();
# Line 1076  Int_t PamelaDBOperations::insertPamelaRU Line 1675  Int_t PamelaDBOperations::insertPamelaRU
1675          obth = phh->GetOrbitalTime();          obth = phh->GetOrbitalTime();
1676          cod = ehh->GetCounter();          cod = ehh->GetCounter();
1677          evbefh = cod->Get(pctp->Physics);          evbefh = cod->Get(pctp->Physics);
1678          if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' %i %i %i \n",pkth,obth,obtt);          if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' %u %u %u \n",pkth,obth,obtt);
1679          //          //
1680          // handle this run          // handle this run
1681          //          //
# Line 1086  Int_t PamelaDBOperations::insertPamelaRU Line 1685  Int_t PamelaDBOperations::insertPamelaRU
1685          //          //
1686          if ( PKT(pkth)>PKT(pktfirst) && OBT(obth)>OBT(obtfirst) && !ptt ){          if ( PKT(pkth)>PKT(pktfirst) && OBT(obth)>OBT(obtfirst) && !ptt ){
1687            //            //
1688            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));  
1689            //            //
1690              if ( evbefh == 0 ) {
1691                //
1692                signal = 8;
1693                if ( IsDebug() ) printf(" Not supported yet: run with no events, no runtrailer, no runheader \n");
1694                //
1695              } else {
1696                //
1697                this->HandleRunFragments(true,true,0,(evbefh-1));
1698                //
1699              };
1700          };          };
1701          //          //
1702          //          //
1703          if ( (ptht - pth) > 1 ){          if ( (ptht - pth) > 1 ){
1704            //            //
1705            if ( IsDebug() ) printf(" Missing runtrailers! \n");            if ( IsDebug() ) printf(" Missing runtrailers! \n");
1706            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);
1707            // is not the consecutive header            // is not the consecutive header
1708            while ( pth != ptht ){                      while ( pth != ptht ){          
1709              //              //
# Line 1117  Int_t PamelaDBOperations::insertPamelaRU Line 1724  Int_t PamelaDBOperations::insertPamelaRU
1724              obth = phh->GetOrbitalTime();              obth = phh->GetOrbitalTime();
1725              evbefh = cod->Get(pctp->Physics);              evbefh = cod->Get(pctp->Physics);
1726              //              //
1727              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);
1728              if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' %i %i %i \n",pkth,obth,obtt);              if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' %u %u %u \n",pkth,obth,obtt);
1729              //              //
1730              this->HandleMissingHoT(false,true,evbefh,evbeft-1);              this->HandleMissingHoT(false,true,evbefh,evbeft-1);
1731              //              //
# Line 1127  Int_t PamelaDBOperations::insertPamelaRU Line 1734  Int_t PamelaDBOperations::insertPamelaRU
1734          } else if ( !(ptht - pth) ){          } else if ( !(ptht - pth) ){
1735            //            //
1736            if ( IsDebug() ) printf(" Missing runheader! \n");            if ( IsDebug() ) printf(" Missing runheader! \n");
1737            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);
1738            if ( IsDebug() ) printf(" The run should have already been handled by HandleRun() \n");            if ( IsDebug() ) printf(" The run should have already been handled by HandleRun() \n");
1739            //            //
1740          } else {          } else {
# Line 1148  Int_t PamelaDBOperations::insertPamelaRU Line 1755  Int_t PamelaDBOperations::insertPamelaRU
1755            obth = phh->GetOrbitalTime();            obth = phh->GetOrbitalTime();
1756            cod = ehh->GetCounter();            cod = ehh->GetCounter();
1757            evbefh = cod->Get(pctp->Physics);            evbefh = cod->Get(pctp->Physics);
1758            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);
1759            if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''' %i %i %i \n",ptht,pth,ptt);            if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''' %u %u %u \n",ptht,pth,ptt);
1760            if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''' %i \n",rhev);            if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''' %u \n",rhev);
1761            //            //
1762            this->HandleRunFragments(false,true,evbefh,upperentry);            this->HandleRunFragments(false,true,evbefh,upperentry);
1763          } else {          } else {
# Line 1198  Bool_t PamelaDBOperations::IsRunAlreadyI Line 1805  Bool_t PamelaDBOperations::IsRunAlreadyI
1805    //                                  ( runhead_time <= _our_runhead_time &&  runtrail_time >= _our_runtrail_time) &&    //                                  ( runhead_time <= _our_runhead_time &&  runtrail_time >= _our_runtrail_time) &&
1806    //                                  ( runhead_obt <= _our_runheadobt || runhead_pkt <= _our_runheadpkt ) &&    //                                  ( runhead_obt <= _our_runheadobt || runhead_pkt <= _our_runheadpkt ) &&
1807    //                                  ( runtrail_obt <= _our_runtrailobt || runtrail_pkt <= _our_runtrailpkt ) )    //                                  ( runtrail_obt <= _our_runtrailobt || runtrail_pkt <= _our_runtrailpkt ) )
1808      //                                  ||
1809      //                                  ( runhead_time = _our_runhead_time &&  runtrail_time = _our_runtrail_time && nevents > 100 )
1810      //                                  )
1811      //                                  ||
1812      //                                  ( runhead_time = _our_runhead_time &&  runtrail_time > _our_runtrail_time && nevents > 100 )
1813      //                                  )
1814      //                                  ||
1815      //                                  ( runhead_time < _our_runhead_time &&  runtrail_time = _our_runtrail_time && nevents > 100 )
1816    //                                  )    //                                  )
1817    //    //
1818    oss << " SELECT ID,NEVENTS,TRK_CALIB_USED,PKT_COUNTER FROM GL_RUN WHERE "    oss << " SELECT ID,NEVENTS,TRK_CALIB_USED,PKT_COUNTER FROM GL_RUN WHERE "
# Line 1213  Bool_t PamelaDBOperations::IsRunAlreadyI Line 1828  Bool_t PamelaDBOperations::IsRunAlreadyI
1828        << " RUNHEADER_OBT<=" << glrun->GetRUNHEADER_OBT() << " OR "        << " RUNHEADER_OBT<=" << glrun->GetRUNHEADER_OBT() << " OR "
1829        << " RUNHEADER_PKT<=" << glrun->GetRUNHEADER_PKT() << ") AND ("        << " RUNHEADER_PKT<=" << glrun->GetRUNHEADER_PKT() << ") AND ("
1830        << " RUNTRAILER_OBT>=" << glrun->GetRUNTRAILER_OBT() << " OR "        << " RUNTRAILER_OBT>=" << glrun->GetRUNTRAILER_OBT() << " OR "
1831        << " RUNTRAILER_PKT>=" << glrun->GetRUNTRAILER_PKT() << ") ));";        << " RUNTRAILER_PKT>=" << glrun->GetRUNTRAILER_PKT() << ") OR "
1832          << " (RUNHEADER_TIME=" << (UInt_t)glrun->GetRUNHEADER_TIME() << " AND "                //  these two lines in a certain way disable the patch below...
1833          << " RUNTRAILER_TIME=" << (UInt_t)glrun->GetRUNTRAILER_TIME() <<" AND NEVENTS>100) OR"    //
1834          << " (RUNHEADER_TIME=" << (UInt_t)glrun->GetRUNHEADER_TIME() << " AND "                //
1835          << " RUNTRAILER_TIME>" << (UInt_t)glrun->GetRUNTRAILER_TIME() <<" AND NEVENTS>100) OR"    //
1836          << " (RUNHEADER_TIME<" << (UInt_t)glrun->GetRUNHEADER_TIME() << " AND "                //
1837          << " RUNTRAILER_TIME=" << (UInt_t)glrun->GetRUNTRAILER_TIME() <<" AND NEVENTS>100)"    //
1838          << " ));";
1839    //    //
1840    if ( IsDebug() ) printf(" check if run has been inserted: query is \n %s \n",oss.str().c_str());    if ( IsDebug() ) printf(" check if run has been inserted: query is \n %s \n",oss.str().c_str());
1841    result = conn->Query(oss.str().c_str());    result = conn->Query(oss.str().c_str());
# Line 1235  Bool_t PamelaDBOperations::IsRunAlreadyI Line 1857  Bool_t PamelaDBOperations::IsRunAlreadyI
1857      //      //
1858      // the run has already been inserted      // the run has already been inserted
1859      //      //
1860      //    return(true);  //<<<<<<<<<<<<<<<<<<<<<<<< patch follows, uncomment here      if ( signal && IsDebug() ) printf(" The run has already been inserted \n");    
1861        return(true);  //<<<<<<<<<<<<<<<<<<<<<<<< patch follows, uncomment here
1862      //      //
1863      // PATCH!      // PATCH!
1864      // 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      // 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 1244  Bool_t PamelaDBOperations::IsRunAlreadyI Line 1867  Bool_t PamelaDBOperations::IsRunAlreadyI
1867      if ( glrun->GetNEVENTS() > (UInt_t)atoll(row->GetField(1)) ){      if ( glrun->GetNEVENTS() > (UInt_t)atoll(row->GetField(1)) ){
1868        //        //
1869        if ( IsDebug() ) printf(" The new run has more events than the old one \n");        if ( IsDebug() ) printf(" The new run has more events than the old one \n");
1870        oss.str("");        glrun->DeleteRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN");
1871        oss << "DELETE FROM GL_RUN WHERE ID=" << row->GetField(0) <<";";  //       oss.str("");
1872        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) <<";";
1873        conn->Query(oss.str().c_str());  //       if ( IsDebug() ) printf(" delete the run entry: query is \n %s \n",oss.str().c_str());      
1874    //       conn->Query(oss.str().c_str());
1875        if ( signal ) signal = false;        if ( signal ) signal = false;
1876        goto gonext;              goto gonext;      
1877        //        //
# Line 1261  Bool_t PamelaDBOperations::IsRunAlreadyI Line 1885  Bool_t PamelaDBOperations::IsRunAlreadyI
1885        //        //
1886        if ( IsDebug() ) printf(" The new run has the same number of events and the runheader the old one miss the runheader \n");        if ( IsDebug() ) printf(" The new run has the same number of events and the runheader the old one miss the runheader \n");
1887        //        //
1888        oss.str("");        glrun->DeleteRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN");
1889        oss << "DELETE FROM GL_RUN WHERE ID=" << row->GetField(0) <<";";  //       oss.str("");
1890        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) <<";";
1891        conn->Query(oss.str().c_str());  //       if ( IsDebug() ) printf(" delete the run entry: query is \n %s \n",oss.str().c_str());      
1892    //       conn->Query(oss.str().c_str());
1893        //        //
1894        if ( signal ) signal = false;        if ( signal ) signal = false;
1895        goto gonext;        goto gonext;
# Line 1278  Bool_t PamelaDBOperations::IsRunAlreadyI Line 1903  Bool_t PamelaDBOperations::IsRunAlreadyI
1903        //        //
1904        if ( IsDebug() ) printf(" The new run has the same number of events, the runheader and the runtrailer the old one miss the runtrailer \n");        if ( IsDebug() ) printf(" The new run has the same number of events, the runheader and the runtrailer the old one miss the runtrailer \n");
1905        //        //
1906        oss.str("");        glrun->DeleteRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN");
1907        oss << "DELETE FROM GL_RUN WHERE ID=" << row->GetField(0) <<";";  //       oss.str("");
1908        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) <<";";
1909        conn->Query(oss.str().c_str());  //       if ( IsDebug() ) printf(" delete the run entry: query is \n %s \n",oss.str().c_str());      
1910    //       conn->Query(oss.str().c_str());
1911        if ( signal ) signal = false;        if ( signal ) signal = false;
1912        //        //
1913      };      };
# Line 1296  Bool_t PamelaDBOperations::IsRunAlreadyI Line 1922  Bool_t PamelaDBOperations::IsRunAlreadyI
1922    delete result;    delete result;
1923    //    //
1924    if ( signal && IsDebug() ) printf(" The run has already been inserted \n");        if ( signal && IsDebug() ) printf(" The run has already been inserted \n");    
1925      if ( !signal && IsDebug() ) printf(" The run existed and was deleted, fill the DB \n");
1926    return(signal);    return(signal);
1927  };  };
1928    
# Line 1317  void PamelaDBOperations::HandleRun(){   Line 1944  void PamelaDBOperations::HandleRun(){  
1944      //      //
1945      this->FillClass();      this->FillClass();
1946      //      //
1947      if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);      if ( !IsRunAlreadyInserted() ){
1948          glrun->SetID(this->AssignRunID());
1949          glrun->SetID_RUN_FRAG(0);
1950          glrun->Fill_GL_RUN(conn);
1951        };
1952    } else {    } else {
1953      //      //
1954      if ( IsDebug() ) printf(" oh no! the distance between runheader and runtrailer seems wrong: check %llu pktt %llu \n",chkpkt,pktt);      if ( IsDebug() ) printf(" oh no! the distance between runheader and runtrailer seems wrong: check %llu pktt %llu \n",chkpkt,pktt);
# Line 1340  void PamelaDBOperations::HandleRunFragme Line 1971  void PamelaDBOperations::HandleRunFragme
1971    UInt_t rhfirstev = firstev;    UInt_t rhfirstev = firstev;
1972    UInt_t rtlastev = lastev;    UInt_t rtlastev = lastev;
1973    Bool_t found = false;    Bool_t found = false;
1974      Bool_t foundinrun = false;
1975    //    //
1976    TSQLResult *result = 0;    TSQLResult *result = 0;
1977    TSQLRow    *row    = 0;    TSQLRow    *row    = 0;
# Line 1366  void PamelaDBOperations::HandleRunFragme Line 1998  void PamelaDBOperations::HandleRunFragme
1998    //    //
1999    if ( IsDebug() ) printf("The run is good, is it the other piece in the GL_RUN_FRAGMENTS table?\n");    if ( IsDebug() ) printf("The run is good, is it the other piece in the GL_RUN_FRAGMENTS table?\n");
2000    //    //
2001      // First of all insert the run in the fragment table...
2002      //
2003      oss.str("");
2004      oss << " SELECT ID FROM GL_RUN_FRAGMENTS WHERE "
2005          << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND ("
2006          << " (RUNHEADER_TIME>=" << (UInt_t)(glrun->GetRUNHEADER_TIME()-10) << " AND "
2007          << " RUNTRAILER_TIME<=" << (UInt_t)(glrun->GetRUNTRAILER_TIME()+10) << " AND ("
2008          << " RUNHEADER_OBT>=" << glrun->GetRUNHEADER_OBT() << " OR "
2009          << " RUNHEADER_PKT>=" << glrun->GetRUNHEADER_PKT() << ") AND ("
2010          << " RUNTRAILER_OBT<=" << glrun->GetRUNTRAILER_OBT() << " OR "
2011          << " RUNTRAILER_PKT<=" << glrun->GetRUNTRAILER_PKT() << ") ) OR "
2012          << " (RUNHEADER_TIME<=" << (UInt_t)glrun->GetRUNHEADER_TIME() << " AND "
2013          << " RUNTRAILER_TIME>=" << (UInt_t)glrun->GetRUNTRAILER_TIME() <<" AND ("
2014          << " RUNHEADER_OBT<=" << glrun->GetRUNHEADER_OBT() << " OR "
2015          << " RUNHEADER_PKT<=" << glrun->GetRUNHEADER_PKT() << ") AND ("
2016          << " RUNTRAILER_OBT>=" << glrun->GetRUNTRAILER_OBT() << " OR "
2017          << " RUNTRAILER_PKT>=" << glrun->GetRUNTRAILER_PKT() << ") ));";
2018      //
2019      if ( IsDebug() ) printf(" check if run has been inserted: query is \n %s \n",oss.str().c_str());
2020      result = conn->Query(oss.str().c_str());
2021      //
2022      if ( !result ) throw -4;
2023      //
2024      row = result->Next();
2025      //
2026      if ( !row ){
2027        //
2028        // no, insert this run in the GL_RUN_FRAGMENTS table (check if exist before!)
2029        //
2030        if ( IsDebug() ) printf(" The run is new \n");
2031        if ( IsDebug() ) printf(" -> fill the GL_RUNFRAGMENTS table \n");
2032        //
2033        glrun->SetID(this->AssignRunID());
2034        glrun->SetID_RUN_FRAG(0);
2035        glrun->Fill_GL_RUN_FRAGMENTS(conn);
2036        //
2037      } else {
2038        if ( IsDebug() ) printf(" The run is already present in the fragment table \n");
2039        return;
2040      };
2041      //
2042      //
2043    // can we find the other piece of the run in the GL_RUN_FRAGMENTS table?    // can we find the other piece of the run in the GL_RUN_FRAGMENTS table?
2044    //        //    
2045    if ( mishead && rhfirstev == firstev ) { // look for runheader (only when at the beginning of the file, if at the end and the runh is    if ( mishead && rhfirstev == firstev ) { // look for runheader (only when at the beginning of the file, if at the end and the runh is
# Line 1374  void PamelaDBOperations::HandleRunFragme Line 2048  void PamelaDBOperations::HandleRunFragme
2048      oss.str("");      oss.str("");
2049      oss << " SELECT ID,TRK_CALIB_USED,RUNTRAILER_TIME,RUNTRAILER_OBT,RUNHEADER_PKT,RUNTRAILER_PKT FROM GL_RUN_FRAGMENTS WHERE "      oss << " SELECT ID,TRK_CALIB_USED,RUNTRAILER_TIME,RUNTRAILER_OBT,RUNHEADER_PKT,RUNTRAILER_PKT FROM GL_RUN_FRAGMENTS WHERE "
2050          << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND "          << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND "
2051          << " RUNHEADER_TIME <= " << (UInt_t)glrun->GetRUNHEADER_TIME()          << " RUNHEADER_TIME <= " << (UInt_t)glrun->GetRUNHEADER_TIME() << " AND "
2052            << " ID != " << glrun->ID
2053          << " ORDER BY RUNHEADER_TIME DESC LIMIT 1;"; // DESC NOT ASC!!          << " ORDER BY RUNHEADER_TIME DESC LIMIT 1;"; // DESC NOT ASC!!
2054      //      //
2055      if ( IsDebug() ) printf(" look for runheader in the fragments table: query is \n %s \n",oss.str().c_str());      if ( IsDebug() ) printf(" look for runheader in the fragments table: query is \n %s \n",oss.str().c_str());
# Line 1384  void PamelaDBOperations::HandleRunFragme Line 2059  void PamelaDBOperations::HandleRunFragme
2059      //      //
2060      row = result->Next();      row = result->Next();
2061      //      //
2062        if ( !row && NoFrag() ){
2063          //
2064          oss.str("");
2065          oss << " SELECT ID,TRK_CALIB_USED,RUNTRAILER_TIME,RUNTRAILER_OBT,RUNHEADER_PKT,RUNTRAILER_PKT FROM GL_RUN WHERE "
2066              << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND "
2067              << " RUNHEADER_TIME <= " << (UInt_t)glrun->GetRUNHEADER_TIME() << " AND "
2068              << " ID != " << glrun->ID
2069              << " AND ID=ID_RUN_FRAG ORDER BY RUNHEADER_TIME DESC LIMIT 1;"; // DESC NOT ASC!!
2070          //
2071          if ( IsDebug() ) printf(" look for runheader in the GL_RUN table: query is \n %s \n",oss.str().c_str());
2072          result = conn->Query(oss.str().c_str());
2073          //
2074          if ( !result ) throw -4;
2075          //
2076          foundinrun = true;
2077          //
2078          row = result->Next();
2079          //
2080        };
2081        //
2082      if ( !row ){      if ( !row ){
2083        if ( IsDebug() ) printf(" the corresponding piece has NOT been found \n");        if ( IsDebug() ) printf(" the corresponding piece has NOT been found \n");
2084        found = false;        found = false;
# Line 1458  void PamelaDBOperations::HandleRunFragme Line 2153  void PamelaDBOperations::HandleRunFragme
2153        //        //
2154        if ( IsDebug() ) printf(" now you can handle the piece of the run \n ");        if ( IsDebug() ) printf(" now you can handle the piece of the run \n ");
2155        //        //
2156          if ( foundinrun ){
2157            glrun->RestoreRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN_FRAGMENTS");
2158            glrun->DeleteRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN");
2159          };
2160          //
2161        GL_RUN *glrun1 = new GL_RUN();        GL_RUN *glrun1 = new GL_RUN();
2162        //        //
2163        UInt_t idfrag = (UInt_t)atoll(row->GetField(0));        //      UInt_t idfrag = (UInt_t)atoll(row->GetField(0));
2164        //        //
2165        oss.str("");        oss.str("");
2166        oss << " ID="<<row->GetField(0)<<";";        oss << " ID="<<row->GetField(0)<<";";
# Line 1473  void PamelaDBOperations::HandleRunFragme Line 2173  void PamelaDBOperations::HandleRunFragme
2173        ULong64_t aobt = OBT(glrun1->GetRUNTRAILER_OBT());        ULong64_t aobt = OBT(glrun1->GetRUNTRAILER_OBT());
2174        UInt_t bpkt = PKT(glrun->GetRUNHEADER_PKT());        UInt_t bpkt = PKT(glrun->GetRUNHEADER_PKT());
2175        ULong64_t bobt = OBT(glrun->GetRUNHEADER_OBT());        ULong64_t bobt = OBT(glrun->GetRUNHEADER_OBT());
2176        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);
2177        TTree *T= 0;        TTree *T= 0;
2178        T = (TTree*)file->Get("Physics");        T = (TTree*)file->Get("Physics");
2179        if ( !T || T->IsZombie() ) throw -16;        if ( !T || T->IsZombie() ) throw -16;
# Line 1487  void PamelaDBOperations::HandleRunFragme Line 2187  void PamelaDBOperations::HandleRunFragme
2187          bobt = OBT(ph->GetOrbitalTime());                bobt = OBT(ph->GetOrbitalTime());      
2188          firstev++;          firstev++;
2189        };        };
2190        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);
2191        //        //
       glrun1->SetID(0);  
2192        glrun1->SetPKT_COUNTER(glrun->GetPKT_COUNTER());        glrun1->SetPKT_COUNTER(glrun->GetPKT_COUNTER());
2193        glrun1->SetPKT_READY_COUNTER(glrun->GetPKT_READY_COUNTER());        glrun1->SetPKT_READY_COUNTER(glrun->GetPKT_READY_COUNTER());
2194        glrun1->SetRUNTRAILER_TIME(glrun->GetRUNTRAILER_TIME());        glrun1->SetRUNTRAILER_TIME(glrun->GetRUNTRAILER_TIME());
# Line 1498  void PamelaDBOperations::HandleRunFragme Line 2197  void PamelaDBOperations::HandleRunFragme
2197        //        //
2198        glrun->SetEV_FROM(firstev);        glrun->SetEV_FROM(firstev);
2199        glrun->SetNEVENTS(lastev-firstev+1);        glrun->SetNEVENTS(lastev-firstev+1);
2200          //
2201        glrun->SetRUNHEADER_TIME(glrun1->GetRUNHEADER_TIME());        glrun->SetRUNHEADER_TIME(glrun1->GetRUNHEADER_TIME());
2202        glrun->SetRUNHEADER_OBT(glrun1->GetRUNHEADER_OBT());        glrun->SetRUNHEADER_OBT(glrun1->GetRUNHEADER_OBT());
2203        glrun->SetRUNHEADER_PKT(glrun1->GetRUNHEADER_PKT());        glrun->SetRUNHEADER_PKT(glrun1->GetRUNHEADER_PKT());
# Line 1517  void PamelaDBOperations::HandleRunFragme Line 2217  void PamelaDBOperations::HandleRunFragme
2217        //        //
2218        if ( !IsRunAlreadyInserted() ){        if ( !IsRunAlreadyInserted() ){
2219          //          //
2220            //      glrun->SetID(this->AssignRunID());
2221            glrun->SetID_RUN_FRAG(glrun1->GetID());
2222          glrun->Fill_GL_RUN(conn);          glrun->Fill_GL_RUN(conn);
2223          //          //
2224          // 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);  
2225          //          //
2226            glrun1->SetID_RUN_FRAG(glrun->GetID());
2227          glrun1->Fill_GL_RUN(conn);          glrun1->Fill_GL_RUN(conn);
2228          //          //
         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;  
         //  
2229        };        };
       //  
       delete glrun1;  
       //  
2230        // delete old entry in fragment table        // delete old entry in fragment table
2231        //        //
2232        oss.str("");        glrun->DeleteRun(conn,0,"GL_RUN_FRAGMENTS");
2233          glrun1->DeleteRun(conn,0,"GL_RUN_FRAGMENTS");
2234        //        //
2235        oss << " DELETE FROM GL_RUN_FRAGMENTS WHERE ID = " << idfrag << ";";        delete glrun1;
2236        //        //
       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;  
2237        //        //
2238        return;        return;
2239        //        //
# Line 1586  void PamelaDBOperations::HandleRunFragme Line 2242  void PamelaDBOperations::HandleRunFragme
2242    };    };
2243    //    //
2244    if ( mistrail && rtlastev == lastev ) { // look for runtrailer (only when at the end of the file, if at the beginning and the runh is    if ( mistrail && rtlastev == lastev ) { // look for runtrailer (only when at the end of the file, if at the beginning and the runh is
2245                                             // 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
2246      //      //
2247      oss.str("");      oss.str("");
2248      oss << " SELECT ID,PKT_COUNTER,RUNHEADER_TIME,RUNHEADER_OBT,RUNTRAILER_PKT,RUNHEADER_PKT FROM GL_RUN_FRAGMENTS WHERE "      oss << " SELECT ID,PKT_COUNTER,RUNHEADER_TIME,RUNHEADER_OBT,RUNTRAILER_PKT,RUNHEADER_PKT FROM GL_RUN_FRAGMENTS WHERE "
2249          << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND "          << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND "
2250          << " RUNTRAILER_TIME >= " << (UInt_t)glrun->GetRUNTRAILER_TIME()          << " RUNTRAILER_TIME >= " << (UInt_t)glrun->GetRUNTRAILER_TIME() << " AND "
2251            << " ID != " << glrun->ID
2252          << " ORDER BY RUNTRAILER_TIME ASC LIMIT 1;";          << " ORDER BY RUNTRAILER_TIME ASC LIMIT 1;";
2253      //      //
2254      if ( IsDebug() ) printf(" look for runtrailer in the fragments table: query is \n %s \n",oss.str().c_str());      if ( IsDebug() ) printf(" look for runtrailer in the fragments table: query is \n %s \n",oss.str().c_str());
# Line 1601  void PamelaDBOperations::HandleRunFragme Line 2258  void PamelaDBOperations::HandleRunFragme
2258      //      //
2259      row = result->Next();      row = result->Next();
2260      //      //
2261        if ( !row && NoFrag() ){
2262          //
2263          oss.str("");
2264          oss << " SELECT ID,PKT_COUNTER,RUNHEADER_TIME,RUNHEADER_OBT,RUNTRAILER_PKT,RUNHEADER_PKT FROM GL_RUN WHERE "
2265              << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND "
2266              << " RUNTRAILER_TIME >= " << (UInt_t)glrun->GetRUNTRAILER_TIME() << " AND "
2267              << " ID != " << glrun->ID
2268              << " AND ID=ID_RUN_FRAG ORDER BY RUNTRAILER_TIME ASC LIMIT 1;";
2269          //
2270          if ( IsDebug() ) printf(" look for runheader in the GL_RUN table: query is \n %s \n",oss.str().c_str());
2271          result = conn->Query(oss.str().c_str());
2272          //
2273          if ( !result ) throw -4;
2274          //
2275          foundinrun = true;
2276          row = result->Next();
2277          //
2278        };
2279        //
2280      if ( !row ){      if ( !row ){
2281        if ( IsDebug() ) printf(" the corresponding piece has NOT been found \n");        if ( IsDebug() ) printf(" the corresponding piece has NOT been found \n");
2282        found = false;        found = false;
# Line 1674  void PamelaDBOperations::HandleRunFragme Line 2350  void PamelaDBOperations::HandleRunFragme
2350        //        //
2351        if ( IsDebug() ) printf(" now you can handle the piece of the run \n ");        if ( IsDebug() ) printf(" now you can handle the piece of the run \n ");
2352        //        //
2353          if ( foundinrun ){
2354            glrun->RestoreRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN_FRAGMENTS");
2355            glrun->DeleteRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN");
2356          };
2357          //
2358        GL_RUN *glrun1 = new GL_RUN();        GL_RUN *glrun1 = new GL_RUN();
2359        //        //
2360        UInt_t idfrag = (UInt_t)atoll(row->GetField(0));        //      UInt_t idfrag = (UInt_t)atoll(row->GetField(0));
2361        //        //
2362        oss.str("");        oss.str("");
2363        oss << " ID="<<row->GetField(0)<<";";        oss << " ID="<<row->GetField(0)<<";";
# Line 1689  void PamelaDBOperations::HandleRunFragme Line 2370  void PamelaDBOperations::HandleRunFragme
2370        ULong64_t aobt = OBT(glrun->GetRUNTRAILER_OBT());        ULong64_t aobt = OBT(glrun->GetRUNTRAILER_OBT());
2371        UInt_t bpkt = PKT(glrun1->GetRUNHEADER_PKT());        UInt_t bpkt = PKT(glrun1->GetRUNHEADER_PKT());
2372        ULong64_t bobt = OBT(glrun1->GetRUNHEADER_OBT());        ULong64_t bobt = OBT(glrun1->GetRUNHEADER_OBT());
2373        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);
2374        TTree *T= 0;        TTree *T= 0;
2375        T = (TTree*)file->Get("Physics");        T = (TTree*)file->Get("Physics");
2376        if ( !T || T->IsZombie() ) throw -16;        if ( !T || T->IsZombie() ) throw -16;
# Line 1703  void PamelaDBOperations::HandleRunFragme Line 2384  void PamelaDBOperations::HandleRunFragme
2384          aobt = OBT(ph->GetOrbitalTime());                aobt = OBT(ph->GetOrbitalTime());      
2385          lastev--;          lastev--;
2386        };        };
2387        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);
2388        //        //
2389        glrun->SetEV_TO(lastev);        glrun->SetEV_TO(lastev);
2390        glrun->SetNEVENTS(lastev-firstev+1);        glrun->SetNEVENTS(lastev-firstev+1);
# Line 1713  void PamelaDBOperations::HandleRunFragme Line 2394  void PamelaDBOperations::HandleRunFragme
2394        glrun->SetRUNTRAILER_OBT(glrun1->GetRUNTRAILER_OBT());        glrun->SetRUNTRAILER_OBT(glrun1->GetRUNTRAILER_OBT());
2395        glrun->SetRUNTRAILER_PKT(glrun1->GetRUNTRAILER_PKT());        glrun->SetRUNTRAILER_PKT(glrun1->GetRUNTRAILER_PKT());
2396        //        //
       glrun1->SetID(0);  
2397        glrun1->SetRUNHEADER_TIME(glrun->GetRUNHEADER_TIME());        glrun1->SetRUNHEADER_TIME(glrun->GetRUNHEADER_TIME());
2398        glrun1->SetRUNHEADER_OBT(glrun->GetRUNHEADER_OBT());        glrun1->SetRUNHEADER_OBT(glrun->GetRUNHEADER_OBT());
2399        glrun1->SetRUNHEADER_PKT(glrun->GetRUNHEADER_PKT());        glrun1->SetRUNHEADER_PKT(glrun->GetRUNHEADER_PKT());
# Line 1733  void PamelaDBOperations::HandleRunFragme Line 2413  void PamelaDBOperations::HandleRunFragme
2413        //        //
2414        if ( !IsRunAlreadyInserted() ){        if ( !IsRunAlreadyInserted() ){
2415          //          //
2416          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());  
         if ( !result ) throw -4;  
         row = result->Next();  
2417          //          //
2418          UInt_t idrun0 = 0;          glrun->SetID_RUN_FRAG(glrun1->GetID());
2419          if ( !row ){          glrun->Fill_GL_RUN(conn);
           throw -10;  
         } else {  
           idrun0 = (UInt_t)atoll(row->GetField(0));  
         };  
2420          //          //
2421          glrun1->SetID_RUN_FRAG(idrun0);          // set id number
2422          //          //
2423            glrun1->SetID_RUN_FRAG(glrun->GetID());
2424          glrun1->Fill_GL_RUN(conn);          glrun1->Fill_GL_RUN(conn);
2425          //          //
         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;  
         //  
2426        };        };
2427        //        //
2428        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 << ";";  
2429        //        //
2430        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");
2431        result =  conn->Query(oss.str().c_str());        glrun1->DeleteRun(conn,0,"GL_RUN_FRAGMENTS");
       if ( !result ) throw -4;  
2432        //        //
2433          delete glrun1;
2434        //        //
2435        return;        return;
2436        //        //
# Line 1831  void PamelaDBOperations::HandleRunFragme Line 2467  void PamelaDBOperations::HandleRunFragme
2467      //      //
2468      row = result->Next();      row = result->Next();
2469      //      //
2470      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 {  
2471        if ( IsDebug() ) printf(" The run is already present in the GL_RUN table \n");        if ( IsDebug() ) printf(" The run is already present in the GL_RUN table \n");
2472        } else {
2473          if ( NoFrag() ){
2474            glrun->SetID_RUN_FRAG(glrun->GetID());
2475            glrun->Fill_GL_RUN(conn);      
2476            glrun->DeleteRun(conn,0,"GL_RUN_FRAGMENTS");
2477          };    
2478      };      };
2479    };    };
2480    //    //
# Line 1895  void PamelaDBOperations::HandleMissingHo Line 2500  void PamelaDBOperations::HandleMissingHo
2500      //      //
2501      this->FillClass(mishead,mistrail,firstev,lastev);      this->FillClass(mishead,mistrail,firstev,lastev);
2502      //      //
2503      if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);          if ( !IsRunAlreadyInserted() ){
2504          glrun->SetID(this->AssignRunID());
2505          glrun->SetID_RUN_FRAG(0);
2506          glrun->Fill_GL_RUN(conn);    
2507        };
2508      //      //
2509    };    };
2510    //    //
# Line 2062  Bool_t PamelaDBOperations::IsRunConsiste Line 2671  Bool_t PamelaDBOperations::IsRunConsiste
2671            //                  //      
2672            this->SetCommonGLRUN(firstTime,lastTime);            this->SetCommonGLRUN(firstTime,lastTime);
2673            //            //
2674            if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);                  if ( !IsRunAlreadyInserted() ){
2675                glrun->SetID(this->AssignRunID());
2676                glrun->SetID_RUN_FRAG(0);
2677                glrun->Fill_GL_RUN(conn);      
2678              };
2679            //            //
2680            firstevno = lastentry + 1;            firstevno = lastentry + 1;
2681            //            //
# Line 2138  void PamelaDBOperations::HandleSuspiciou Line 2751  void PamelaDBOperations::HandleSuspiciou
2751      if ( IsDebug() ) printf(" Checking but no events in the run! \n");      if ( IsDebug() ) printf(" Checking but no events in the run! \n");
2752      //      //
2753      this->FillClass();      this->FillClass();
2754      if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);          if ( !IsRunAlreadyInserted() ){
2755          glrun->SetID(this->AssignRunID());
2756          glrun->SetID_RUN_FRAG(0);
2757          glrun->Fill_GL_RUN(conn);    
2758        };
2759      //      //
2760    } else {    } else {
2761      //      //
# Line 2166  void PamelaDBOperations::HandleSuspiciou Line 2783  void PamelaDBOperations::HandleSuspiciou
2783        if ( IsDebug() ) printf(" No packets but physics inside the run, I will consider it as good\n");        if ( IsDebug() ) printf(" No packets but physics inside the run, I will consider it as good\n");
2784        //        //
2785        this->FillClass();        this->FillClass();
2786        if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);                if ( !IsRunAlreadyInserted() ){
2787            glrun->SetID(this->AssignRunID());
2788            glrun->SetID_RUN_FRAG(0);
2789            glrun->Fill_GL_RUN(conn);        
2790          };
2791        //        //
2792      } else {      } else {
2793        //        //
# Line 2264  void PamelaDBOperations::HandleSuspiciou Line 2885  void PamelaDBOperations::HandleSuspiciou
2885            //                  //      
2886            this->SetCommonGLRUN(firstTime,lastTime);            this->SetCommonGLRUN(firstTime,lastTime);
2887            //            //
2888            if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);                  if ( !IsRunAlreadyInserted() ){
2889                glrun->SetID(this->AssignRunID());
2890                glrun->SetID_RUN_FRAG(0);
2891                glrun->Fill_GL_RUN(conn);      
2892              };
2893            //            //
2894            if ( i == lastev && checkfirst < check ){ // if the last event gives a wrong check...            if ( i == lastev && checkfirst < check ){ // if the last event gives a wrong check...
2895              //              //
# Line 2299  void PamelaDBOperations::HandleSuspiciou Line 2924  void PamelaDBOperations::HandleSuspiciou
2924              //                  //    
2925              this->SetCommonGLRUN(firstTime,lastTime);              this->SetCommonGLRUN(firstTime,lastTime);
2926              //              //
2927              if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);                    if ( !IsRunAlreadyInserted() ){
2928                  glrun->SetID(this->AssignRunID());
2929                  glrun->SetID_RUN_FRAG(0);
2930                  glrun->Fill_GL_RUN(conn);      
2931                };
2932            };            };
2933            //            //
2934            firstevno = lastentry + 1;            firstevno = lastentry + 1;
# Line 2362  Int_t PamelaDBOperations::insertCALO_CAL Line 2991  Int_t PamelaDBOperations::insertCALO_CAL
2991          fromtime = this->GetAbsTime(ph->GetOrbitalTime());            fromtime = this->GetAbsTime(ph->GetOrbitalTime());  
2992          if ( this->PKT(pkt) >= this->PKT(pktfirst) && this->OBT(obt) >= this->OBT(obtfirst) ){          if ( this->PKT(pkt) >= this->PKT(pktfirst) && this->OBT(obt) >= this->OBT(obtfirst) ){
2993            //            //
2994            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);
2995            //            //
2996            // check if the calibration has already been inserted            // check if the calibration has already been inserted
2997            //            //
# Line 2406  Int_t PamelaDBOperations::insertCALO_CAL Line 3035  Int_t PamelaDBOperations::insertCALO_CAL
3035                // no calibrations in the db contain our calibration                // no calibrations in the db contain our calibration
3036                //                //
3037                if ( IsDebug() ) printf(" Calibration with fromtime lower than others to be inserted in the DB for section %i \n",section);                if ( IsDebug() ) printf(" Calibration with fromtime lower than others to be inserted in the DB for section %i \n",section);
3038                if ( fromtime < 1150863400 ){                if ( fromtime < 1150871000 ){ //1150866904
3039                  if ( IsDebug() ) printf(" First PAMELA flight calibration at time %i \n",fromtime);                  if ( IsDebug() ) printf(" First PAMELA flight calibration at time %u \n",fromtime);
3040                  fromtime = 0;// the first flight calibration was taken at about  1156429100 s, this line allow to analyze first runs in raw mode                  fromtime = 0;// the first flight calibration was taken at about  1156429100 s, this line allow to analyze first runs in raw mode
3041                };                };
3042                //                //
# Line 2469  Int_t PamelaDBOperations::insertCALO_CAL Line 3098  Int_t PamelaDBOperations::insertCALO_CAL
3098            //            //
3099          } else {          } else {
3100            //            //
3101            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);
3102            //            //
3103          };                };      
3104          //                //      
# Line 2551  void PamelaDBOperations::HandleTRK_CALIB Line 3180  void PamelaDBOperations::HandleTRK_CALIB
3180        // no calibrations in the db contain our calibration        // no calibrations in the db contain our calibration
3181        //        //
3182        if ( IsDebug() ) printf(" Calibration with fromtime lower than others to be inserted in the DB\n");        if ( IsDebug() ) printf(" Calibration with fromtime lower than others to be inserted in the DB\n");
3183        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
3184        //        //
3185        oss.str("");        oss.str("");
3186        oss << " SELECT FROM_TIME FROM GL_TRK_CALIB WHERE "        oss << " SELECT FROM_TIME FROM GL_TRK_CALIB WHERE "
# Line 2680  Int_t PamelaDBOperations::insertTRK_CALI Line 3309  Int_t PamelaDBOperations::insertTRK_CALI
3309      pkt1 = ph1->GetCounter();        pkt1 = ph1->GetCounter();  
3310      fromtime = this->GetAbsTime(ph1->GetOrbitalTime());        fromtime = this->GetAbsTime(ph1->GetOrbitalTime());  
3311      //      //
3312      valid = 1;  //     valid = 1;
3313      //  //     //
3314      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
3315      //      //
3316      //      //
3317      if ( this->PKT(pkt1) >= this->PKT(pktfirst) && this->OBT(obt1) >= this->OBT(obtfirst) ){      if ( this->PKT(pkt1) >= this->PKT(pktfirst) && this->OBT(obt1) >= this->OBT(obtfirst) ){
3318        //        //
3319        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);
3320          //      
3321          valid = ValidateTrkCalib( caltrk1, eh1 );
3322          if ( IsDebug() ) cout << " pkt1 validation --> "<<valid<<endl;
3323        //        //
3324        // Do we have the second calibration packet?        // Do we have the second calibration packet?
3325        //        //
# Line 2704  Int_t PamelaDBOperations::insertTRK_CALI Line 3336  Int_t PamelaDBOperations::insertTRK_CALI
3336            obt2 = ph2->GetOrbitalTime();              obt2 = ph2->GetOrbitalTime();  
3337            pkt2 = ph2->GetCounter();              pkt2 = ph2->GetCounter();  
3338            //            //
3339            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
3340            //                  //      
3341          } else {          } else {
3342            //            //
# Line 2727  Int_t PamelaDBOperations::insertTRK_CALI Line 3359  Int_t PamelaDBOperations::insertTRK_CALI
3359          //          //
3360        };        };
3361        //        //
3362        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);
3363        //        //
3364        // The calibration is good        // The calibration is good
3365        //        //
3366        if ( this->PKT(pkt2) == this->PKT(pkt1)+1 ){        if ( this->PKT(pkt2) == this->PKT(pkt1)+1 ){
3367          //          //
3368          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);
3369            //
3370            UInt_t valid2 = ValidateTrkCalib( caltrk2, eh2 );
3371            if ( IsDebug() ) cout << " pkt2 validation --> "<<valid2<<endl;
3372            valid = valid & valid2;
3373          //          //
3374          // Handle good calib          // Handle good calib
3375          //          //
# Line 2743  Int_t PamelaDBOperations::insertTRK_CALI Line 3379  Int_t PamelaDBOperations::insertTRK_CALI
3379          //          //
3380          if ( t2 != pret2+1 ){          if ( t2 != pret2+1 ){
3381            //            //
3382            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);
3383            //            //
3384            while ( t2 > pret2+1 ){            while ( t2 > pret2+1 ){
3385              //              //
# Line 2772  Int_t PamelaDBOperations::insertTRK_CALI Line 3408  Int_t PamelaDBOperations::insertTRK_CALI
3408          //          //
3409          // Check for missing calibtrk2          // Check for missing calibtrk2
3410          //          //
3411          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);
3412          t2 = pret2;          t2 = pret2;
3413          //          //
3414          // handle missing calib2          // handle missing calib2
# Line 2786  Int_t PamelaDBOperations::insertTRK_CALI Line 3422  Int_t PamelaDBOperations::insertTRK_CALI
3422        //        //
3423      } else {      } else {
3424        //        //
3425        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);
3426        //        //
3427      };      };
3428      //          //    
# Line 2811  Int_t PamelaDBOperations::insertTRK_CALI Line 3447  Int_t PamelaDBOperations::insertTRK_CALI
3447      valid = 0;      valid = 0;
3448      if ( this->PKT(pkt2) > this->PKT(pktfirst) || this->OBT(obt2) > this->OBT(obtfirst) ){      if ( this->PKT(pkt2) > this->PKT(pktfirst) || this->OBT(obt2) > this->OBT(obtfirst) ){
3449        //        //
3450        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);
3451        //        //
3452        this->HandleTRK_CALIB(false,true);        this->HandleTRK_CALIB(false,true);
3453        //        //
# Line 2865  Int_t PamelaDBOperations::insertS4_CALIB Line 3501  Int_t PamelaDBOperations::insertS4_CALIB
3501      fromtime = this->GetAbsTime(ph->GetOrbitalTime());        fromtime = this->GetAbsTime(ph->GetOrbitalTime());  
3502      if ( this->PKT(pkt) >= this->PKT(pktfirst) && this->OBT(obt) >= this->OBT(obtfirst) ){      if ( this->PKT(pkt) >= this->PKT(pktfirst) && this->OBT(obt) >= this->OBT(obtfirst) ){
3503        //        //
3504        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);
3505        //        //
3506        // check if the calibration has already been inserted        // check if the calibration has already been inserted
3507        //        //
# Line 2907  Int_t PamelaDBOperations::insertS4_CALIB Line 3543  Int_t PamelaDBOperations::insertS4_CALIB
3543            // no calibrations in the db contain our calibration            // no calibrations in the db contain our calibration
3544            //            //
3545            if ( IsDebug() ) printf(" Calibration with fromtime lower than others to be inserted in the DB \n");            if ( IsDebug() ) printf(" Calibration with fromtime lower than others to be inserted in the DB \n");
3546            if ( fromtime < 1150863400 ){            if ( fromtime < 1150871000 ){  
3547              if ( IsDebug() ) printf(" First PAMELA flight calibration at time %i \n",fromtime);              if ( IsDebug() ) printf(" First PAMELA flight calibration at time %u \n",fromtime);
3548              fromtime = 0;// the first flight calibration was taken at about  1156429100 s, this line allow to analyze first runs in raw mode              fromtime = 0;// the first flight calibration was taken at about  1156429100 s, this line allow to analyze first runs in raw mode
3549            };            };
3550            //            //
# Line 2967  Int_t PamelaDBOperations::insertS4_CALIB Line 3603  Int_t PamelaDBOperations::insertS4_CALIB
3603        //        //
3604      } else {      } else {
3605        //        //
3606        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);
3607        //        //
3608      };            };      
3609      //            //      
# Line 2980  Int_t PamelaDBOperations::insertS4_CALIB Line 3616  Int_t PamelaDBOperations::insertS4_CALIB
3616   * Scan the fragment table and move old fragments to the GL_RUN table   * Scan the fragment table and move old fragments to the GL_RUN table
3617   */   */
3618  Int_t PamelaDBOperations::CleanGL_RUN_FRAGMENTS(){  Int_t PamelaDBOperations::CleanGL_RUN_FRAGMENTS(){
3619      return(this->CleanGL_RUN_FRAGMENTS(""));
3620    };
3621    
3622    /**
3623     * Scan the fragment table and move old fragments to the GL_RUN table
3624     */
3625    Int_t PamelaDBOperations::CleanGL_RUN_FRAGMENTS(TString fcleanfile){
3626    //    //
3627    TSQLResult *result = 0;    TSQLResult *result = 0;
3628    TSQLRow    *row    = 0;    TSQLRow    *row    = 0;
# Line 2987  Int_t PamelaDBOperations::CleanGL_RUN_FR Line 3630  Int_t PamelaDBOperations::CleanGL_RUN_FR
3630    TSQLRow    *row2   = 0;    TSQLRow    *row2   = 0;
3631    //    //
3632    UInt_t moved = 0;    UInt_t moved = 0;
   UInt_t timelim = 0;  
   TDatime *time = new TDatime();  
3633    //    //
3634    stringstream oss;    stringstream oss;
3635    oss.str("");    oss.str("");
3636    //    //
3637    //    if ( !strcmp(fcleanfile.Data(),"") ){
   //  
   if ( olderthan < 0 ){  
     if ( IsDebug() ) printf(" Do not clean GL_RUN_FRAGMENTS table \n");  
     return(1);  
   };  
   //  
   // timelim = now - olderthan  
   //  
   time->Set();  
   timelim =  (UInt_t)time->Convert() - olderthan;  
   time->Set(timelim,false);  
   //  
   // check if there are entries older than "olderthan" seconds from now  
   //  
   oss.str("");  
   oss << " SELECT ID FROM GL_RUN_FRAGMENTS WHERE"  
       << " INSERT_TIME <= '" << time->AsSQLString() << "';";  
   //  
   if ( IsDebug() ) printf(" Select from GL_RUN_FRAGMENTS runs older than %s : query is \n %s \n",time->AsSQLString(),oss.str().c_str());  
   result = conn->Query(oss.str().c_str());  
   //  
   if ( result ){  
3638      //      //
3639      row = result->Next();      // check if there are entries older than "olderthan" seconds from now
3640      //      //
3641      if ( row ){      oss.str("");
3642        //      oss << " SELECT ID FROM GL_RUN_FRAGMENTS WHERE"
3643        oss.str("");          << " INSERT_TIME <= '" << clean_time->AsSQLString() << "';";
3644        oss << " ID= "<< row->GetField(0);      //
3645        if ( IsDebug() ) printf(" Select from GL_RUN_FRAGMENTS runs older than %s : query is \n %s \n",clean_time->AsSQLString(),oss.str().c_str());
3646        result = conn->Query(oss.str().c_str());
3647        //
3648      } else {
3649        oss.str("");
3650        oss << " SELECT ID FROM GL_ROOT WHERE NAME='" << fcleanfile.Data() << "';";
3651        if ( IsDebug() ) printf(" Getting ID_ROOT_L0 query %s \n",oss.str().c_str());
3652        result = conn->Query(oss.str().c_str());
3653        //    
3654        if ( result ){
3655        //        //
3656        glrun->Query_GL_RUN_FRAGMENTS(oss.str().c_str(),conn);          row = result->Next();
3657        //        //
3658        oss.str("");        if ( row ){
3659            oss.str("");
3660            oss << " SELECT ID FROM GL_RUN_FRAGMENTS WHERE"
3661                << " ID_ROOT_L0=" << row->GetField(0) << ";";
3662            //
3663            if ( IsDebug() ) printf(" Select from GL_RUN_FRAGMENTS for ROOT file query is \n %s \n",oss.str().c_str());
3664            result = conn->Query(oss.str().c_str());
3665            //    
3666          };
3667        } else {
3668          return(2);
3669        };
3670      };
3671      //
3672      if ( result ){
3673        //
3674        row = result->Next();
3675        //
3676        while ( row ){
3677          //
3678          oss.str("");
3679          oss << " ID= "<< row->GetField(0);
3680          //
3681          glrun->Query_GL_RUN_FRAGMENTS(oss.str().c_str(),conn);  
3682          //
3683          oss.str("");
3684        oss << " SELECT ID,NEVENTS,TRK_CALIB_USED,PKT_COUNTER FROM GL_RUN WHERE "        oss << " SELECT ID,NEVENTS,TRK_CALIB_USED,PKT_COUNTER FROM GL_RUN WHERE "
3685            << " BOOT_NUMBER=" << glrun->GetBOOT_NUMBER() << " AND ("            << " BOOT_NUMBER=" << glrun->GetBOOT_NUMBER() << " AND ("
3686            << " (RUNHEADER_TIME>=" << (UInt_t)(glrun->GetRUNHEADER_TIME()-10) << " AND "            << " (RUNHEADER_TIME>=" << (UInt_t)(glrun->GetRUNHEADER_TIME()-10) << " AND "
# Line 3054  Int_t PamelaDBOperations::CleanGL_RUN_FR Line 3708  Int_t PamelaDBOperations::CleanGL_RUN_FR
3708          if ( IsDebug() ) printf(" The run is new \n");          if ( IsDebug() ) printf(" The run is new \n");
3709          if ( IsDebug() ) printf(" -> fill the DB \n");                if ( IsDebug() ) printf(" -> fill the DB \n");      
3710          //          //
3711          glrun->SetID(0);          //      glrun->SetID(this->AssignRunID()); we use the old run number!
3712            glrun->SetID_RUN_FRAG(glrun->GetID());
3713          glrun->Fill_GL_RUN(conn);            glrun->Fill_GL_RUN(conn);  
3714          //          //
3715          oss.str("");  //      oss.str("");
3716          oss << " SELECT ID FROM GL_RUN WHERE "  //      oss << " SELECT ID FROM GL_RUN WHERE "
3717              << " BOOT_NUMBER=" << glrun->GetBOOT_NUMBER() << " AND "  //          << " BOOT_NUMBER=" << glrun->GetBOOT_NUMBER() << " AND "
3718              << " RUNHEADER_PKT=" << (UInt_t)glrun->GetRUNHEADER_PKT() << " AND "  //          << " RUNHEADER_PKT=" << (UInt_t)glrun->GetRUNHEADER_PKT() << " AND "
3719              << " RUNTRAILER_PKT=" << (UInt_t)glrun->GetRUNTRAILER_PKT() << " AND "  //          << " RUNTRAILER_PKT=" << (UInt_t)glrun->GetRUNTRAILER_PKT() << " AND "
3720              << " RUNHEADER_OBT=" << (UInt_t)glrun->GetRUNHEADER_OBT() << " AND "  //          << " RUNHEADER_OBT=" << (UInt_t)glrun->GetRUNHEADER_OBT() << " AND "
3721              << " RUNTRAILER_OBT=" << (UInt_t)glrun->GetRUNTRAILER_OBT() << "; ";  //          << " RUNTRAILER_OBT=" << (UInt_t)glrun->GetRUNTRAILER_OBT() << "; ";
3722          //  //      //
3723          if ( IsDebug() ) printf(" Look for the ID of the inserted run: query is \n %s \n",oss.str().c_str());  //      if ( IsDebug() ) printf(" Look for the ID of the inserted run: query is \n %s \n",oss.str().c_str());
3724          result2 = conn->Query(oss.str().c_str());  //      result2 = conn->Query(oss.str().c_str());
3725          //  //      //
3726          if ( !result2 ) throw -4;  //      if ( !result2 ) throw -4;
3727          //  //      //
3728          row2 = result2->Next();  //      row2 = result2->Next();
3729          //  //      //
3730          if ( !row2 ) throw -25;  //      if ( !row2 ) throw -25;
3731          //  //      //
3732          oss.str("");  //      oss.str("");
3733          oss << " UPDATE GL_RUN SET ID_RUN_FRAG = " << row2->GetField(0) << " WHERE ID = " << row2->GetField(0);  //      oss << " UPDATE GL_RUN SET ID_RUN_FRAG = " << row2->GetField(0) << " WHERE ID = " << row2->GetField(0);
3734          if ( IsDebug() ) printf(" Update the ID_RUN_FRAG of the inserted run: query is \n %s \n",oss.str().c_str());  //      if ( IsDebug() ) printf(" Update the ID_RUN_FRAG of the inserted run: query is \n %s \n",oss.str().c_str());
3735          result2 = conn->Query(oss.str().c_str());  //      result2 = conn->Query(oss.str().c_str());
3736          //  //      //
3737          if ( !result2 ) throw -4;  //      if ( !result2 ) throw -4;
3738          //          //
3739          moved++;          moved++;
3740          //          //
# Line 3089  Int_t PamelaDBOperations::CleanGL_RUN_FR Line 3744  Int_t PamelaDBOperations::CleanGL_RUN_FR
3744        if ( IsDebug() ) printf(" Delete run %s from the GL_RUN_FRAGMENTS table \n",row->GetField(0));              if ( IsDebug() ) printf(" Delete run %s from the GL_RUN_FRAGMENTS table \n",row->GetField(0));      
3745        //        //
3746        //        //
3747        oss.str("");        glrun->DeleteRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN_FRAGMENTS");
3748        oss << " DELETE from GL_RUN_FRAGMENTS where ID = " << row->GetField(0);  //      oss.str("");
3749        if ( IsDebug() ) printf(" Clean the GL_RUN_FRAGMENTS table: query is \n %s \n",oss.str().c_str());  //       oss << " DELETE from GL_RUN_FRAGMENTS where ID = " << row->GetField(0);
3750        result2 = conn->Query(oss.str().c_str());  //       if ( IsDebug() ) printf(" Clean the GL_RUN_FRAGMENTS table: query is \n %s \n",oss.str().c_str());
3751        //  //       result2 = conn->Query(oss.str().c_str());
3752        if ( !result2 ) throw -4;  //      //
3753        //  //      if ( !result2 ) throw -4;
3754    //      //
3755          row = result->Next();
3756      };      };
3757    };    };
3758    if ( IsDebug() ) printf(" Moved %u runs\n",moved);    if ( IsDebug() ) printf(" Moved %u runs\n",moved);
# Line 3106  Int_t PamelaDBOperations::CleanGL_RUN_FR Line 3763  Int_t PamelaDBOperations::CleanGL_RUN_FR
3763   * Check if runs are good, i.e. if the tracker calibration is correctly associated..   * Check if runs are good, i.e. if the tracker calibration is correctly associated..
3764   */   */
3765  Int_t PamelaDBOperations::ValidateRuns(){  Int_t PamelaDBOperations::ValidateRuns(){
3766      return(this->ValidateRuns(""));
3767    };
3768    
3769    /**
3770     * Check if runs are good, i.e. if the tracker calibration is correctly associated..
3771     */
3772    Int_t PamelaDBOperations::ValidateRuns(TString valfile){
3773    //    //
3774    TSQLResult *result = 0;    TSQLResult *result = 0;
3775    // TSQLRow    *row    = 0;    TSQLRow    *row    = 0;
3776    //    //
3777    UInt_t timelim = 0;    UInt_t calibtime = 50;
   TDatime *time = new TDatime();  
3778    //    //
3779    stringstream oss;    stringstream oss;
3780    oss.str("");    oss.str("");
3781    //    //
3782      // =======================================================
3783      // validate runs by checking missing calibrations
3784      // =======================================================
3785      UInt_t t_stop  = 0;
3786      UInt_t t_start = 0;
3787      if ( !strcmp(valfile.Data(),"") ) {
3788        // --------------------------------------------------------------
3789        // 1) get the OBT of the last run inserted after clean-time limit
3790        // --------------------------------------------------------------
3791        oss.str("");
3792        oss << " SELECT * FROM GL_RUN  WHERE INSERT_TIME <= '" << clean_time->AsSQLString()
3793            << "' ORDER BY RUNHEADER_TIME DESC LIMIT 1;";
3794        if ( IsDebug() ) printf(" Get start validation-time: query is \n %s \n",oss.str().c_str());
3795        result = conn->Query(oss.str().c_str());
3796        if ( !result ) throw -4;
3797        if ( !result->GetRowCount() ) {
3798          printf(" No runs to validate \n");
3799          return(1);
3800        }else{
3801          row = result->Next();
3802          t_start = (UInt_t)atoll(row->GetField(4));
3803        };  
3804        // --------------------------------------------------------------
3805        // 2) get the OBT of the last validated run
3806        // --------------------------------------------------------------
3807        oss.str("");
3808        oss << " SELECT * FROM GL_RUN  WHERE VALIDATION=1 AND RUNHEADER_TIME<="<< t_start
3809            <<" ORDER BY RUNHEADER_TIME DESC LIMIT 1;";
3810        if ( IsDebug() ) printf(" Get stop validation-time: query is \n %s \n",oss.str().c_str());
3811        result = conn->Query(oss.str().c_str());
3812        if ( !result ) throw -4;
3813        if ( result->GetRowCount() ){
3814          row = result->Next();
3815          t_stop = (UInt_t)atoll(row->GetField(4));
3816        };
3817        if ( IsDebug() ) printf("Validation interval: from time %u - to time %u \n\n",t_stop,t_start);
3818        // --------------------------------------------------------------
3819        // now retrieves runs to be validated
3820        // --------------------------------------------------------------
3821        oss.str("");
3822        oss << " SELECT * FROM GL_RUN  WHERE  RUNHEADER_TIME <=" << t_start;
3823        oss << " AND RUNHEADER_TIME >="<< t_stop;
3824        oss << " ORDER BY RUNHEADER_TIME DESC;";
3825        if ( IsDebug() )printf(" Check runs for validation: query is \n %s \n",oss.str().c_str());
3826        result = conn->Query(oss.str().c_str());
3827      } else {
3828        //
3829        stringstream myquery;
3830        UInt_t myid = 0;
3831        myquery.str("");
3832        myquery << " SELECT ID FROM GL_ROOT where NAME='"<<valfile.Data() <<"';";
3833        //
3834        result = conn->Query(myquery.str().c_str());
3835        //
3836        row = result->Next();      
3837        if( !row ){
3838          if ( strcmp(valfile.Data(),GetRootName().Data()) ){
3839            if ( IsDebug() ) printf(" No file to be validated even if option \"-validate file\" was used!!\n");
3840            return(2);
3841          };
3842          if ( IsDebug() ) printf(" No file to be validated (force mode)! \n");
3843          return(0);
3844        };
3845        myid=(UInt_t)atoll(row->GetField(0));
3846        //
3847        myquery.str("");
3848        myquery << " SELECT MAX(RUNTRAILER_TIME),MIN(RUNHEADER_TIME) FROM GL_RUN WHERE ID_ROOT_L0="<< myid <<";";
3849        //
3850        result = conn->Query(myquery.str().c_str());
3851        //
3852        row = result->Next();      
3853        if( !row->GetField(0) || !row->GetField(1)){
3854          //
3855          if ( IsDebug() ) printf(" NO RUN ASSOCIATED TO THIS FILE! \n");
3856          //
3857          return(0);
3858          //
3859        } else {  
3860          //
3861          UInt_t runhtime = (UInt_t)atoll(row->GetField(0));
3862          UInt_t runttime = (UInt_t)atoll(row->GetField(1));
3863          UInt_t caltime = 0;
3864          //
3865          myquery.str("");
3866          myquery << " SELECT FROM_TIME FROM GL_TRK_CALIB where FROM_TIME>" <<runhtime;
3867          myquery << " order by FROM_TIME asc limit 1;";
3868          //
3869          if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
3870          //
3871          //
3872          result = conn->Query(myquery.str().c_str());
3873          //
3874          row = result->Next();      
3875          if( !row ){
3876            caltime = runhtime;
3877          } else {
3878            caltime = (UInt_t)atoll(row->GetField(0));
3879          };
3880          //
3881          myquery.str("");
3882          myquery << " SELECT * from GL_RUN where RUNHEADER_TIME>="<< runttime <<" AND RUNHEADER_TIME<=" ;
3883          myquery << caltime << " order by RUNHEADER_TIME DESC";
3884          //
3885          if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
3886          //
3887          result = conn->Query(myquery.str().c_str());
3888          //
3889        };
3890      };
3891    //    //
3892      if ( !result ) throw -4;
3893      if ( !result->GetRowCount() && IsDebug() ) printf(" No runs to validate \n");
3894    //    //
3895    if ( olderthan < 0 ){    Int_t nrow = 0;
3896      if ( IsDebug() ) printf(" Do not validate runs \n");    GL_RUN* this_run = new GL_RUN();
3897      return(1);    GL_RUN* next_run = new GL_RUN();
3898      Int_t   nseq_max = 1000;
3899    //  UInt_t* sequence = new UInt_t[100];
3900      vector<UInt_t> sequence(nseq_max);
3901      Int_t   nseq = 0;
3902      Bool_t CHECK = false;
3903      Bool_t this_ONLINE = false;
3904      Bool_t next_ONLINE = false;
3905      UInt_t t1=0,t2=0;
3906      // ---------------------------------------------------------------------------------
3907      // - loop over runs, back in time,
3908      // - select sequences of runs close in time (less than calibtime s apart),
3909      //   which could be preceeded by a calibration
3910      // - check if there might be a missing calibration
3911      // ---------------------------------------------------------------------------------
3912      while(1){
3913              
3914              row = result->Next();
3915              if( row == NULL ) break;
3916              
3917              //------------
3918              //get run info
3919              //------------
3920              this_run->Set_GL_RUN(row);
3921                      
3922              Bool_t this_BAD = false;
3923              if(this_run->GetTRK_CALIB_USED() == 1 || this_run->GetTRK_CALIB_USED() == 2) this_ONLINE = true;
3924              else if (this_run->GetTRK_CALIB_USED() == 104)                          this_ONLINE = false;
3925              else{
3926    //                printf("Missing or corrupted header!! \n");
3927                      this_ONLINE = false;
3928                      this_BAD = true;
3929              };
3930    
3931              //-----------------------------------
3932              //compare with previous(next in time)
3933              //-----------------------------------
3934              CHECK = false;
3935              UInt_t interval=0;
3936              
3937              if( nrow != 0){
3938            
3939                      
3940                      t1 = this_run->GetRUNTRAILER_TIME();
3941                      t2 = next_run->GetRUNHEADER_TIME();
3942                      interval = (t2-t1);
3943                      
3944                      if(this_ONLINE && next_ONLINE){                               // this: ON-LINE + next: ON-LINE
3945                              
3946                              if( this_run->ID == next_run->ID_RUN_FRAG ) interval = 0;     //=> run fragments
3947                              
3948                              if( interval >= calibtime )CHECK = true;                      //more than calibtime s => there might be a calibration
3949                              
3950                              if( !CHECK && this_run->VALIDATION ){
3951                                      for (Int_t irun = 0; irun < nseq; irun++)assignVALIDATION(sequence[irun],true);
3952                                      nseq=0;
3953                              }
3954                      
3955                      }else if( !this_ONLINE && next_ONLINE) {              // this: DEFAULT + next:ON-LINE
3956                              
3957                              CHECK = true;
3958    
3959                      }else if( !next_ONLINE ){                                             // this:ANY + next:DEFAULT
3960                              
3961                              assignVALIDATION(next_run->ID,true);
3962                              nseq=0;
3963                      }
3964              }
3965    
3966              //----------------------------
3967              //check run sequence for calib
3968              //----------------------------
3969              if( CHECK ){
3970                      // check if calibration exists
3971                      if ( IsDebug() )printf("DT %i ===> CHECK Missing calibration\n",interval);
3972                      Bool_t MISSING = MissingTRK_CALIB(t1,t2);
3973                      for (Int_t irun = 0; irun < nseq; irun++)assignVALIDATION(sequence[irun],!MISSING);
3974                      nseq=0;
3975              };
3976              //--------------
3977              //store run info
3978              //--------------
3979              *next_run   = *this_run;
3980              next_ONLINE = this_ONLINE;
3981              if( !this_BAD ){
3982                      if(nseq < nseq_max){
3983                              sequence[nseq] = this_run->ID;
3984                              nseq++;
3985                      }else printf("ValidateRuns ***WARNING*** : run sequence exceed assumed size (%i) \n",nseq_max);
3986              };
3987              
3988              if ( IsDebug() ) printf("%i Run %u \n",nrow,this_run->ID);
3989              nrow++;
3990              
3991    };    };
3992      delete this_run;
3993      delete next_run;
3994    //    //
3995    // timelim = now - olderthan    return(0);
3996    };
3997    /**
3998     * Check if there might be a missing tracker calibration in a given time interval
3999     * @param t1 From absolute time
4000     * @param t2 To absolute time
4001     * @return true if there might be a missing calibration
4002     */
4003    Bool_t PamelaDBOperations::MissingTRK_CALIB(UInt_t t1,UInt_t t2){
4004            
4005            GL_TRK_CALIB* trkcalib = new GL_TRK_CALIB();
4006            
4007            // get the closest VALIDATED calibration before the run start (t2)
4008            if ( trkcalib->Query_GL_TRK_CALIB(t2, conn) )return(true);      //>>> missing
4009            
4010            if ( trkcalib->TO_TIME  < t2 ) return(true);                                    //>>> missing
4011            
4012            //==============================================================
4013            // Check is done first on the basis of time between calibration,
4014            // which should be equal to the time between ascending-nodes.
4015            //==============================================================
4016            if ( t2 - trkcalib->FROM_TIME > 5700) {
4017                    if ( IsDebug() )printf("Long time between calib and run start %u :-( ==> there might be a missing calib \n",t2 - trkcalib->FROM_TIME);
4018            //==============================================================
4019            // there might be a missing calibration, due to:
4020            // - MM full
4021            // - corrupted packets
4022            // - loss of data
4023            // There is an exception in case a download was done during ascending node
4024            //==============================================================
4025                    Bool_t DOWNLOAD = false;
4026                    // check if the calib was skipped becouse of download .... DA FARE!!
4027                    if(DOWNLOAD)return(false);
4028                    
4029                    return(true);                                   //>>> missing
4030                    
4031            };
4032            
4033            //==============================================================
4034            // If the last calibration is close to the run less than this time,
4035            // it is enough to say that there are no missing calibrations
4036            //==============================================================
4037            // the long time interval bewteen runs might be due to download
4038            if ( IsDebug() )printf("Short time between calib and run start %u :-) ==> OK! \n",t2 - trkcalib->FROM_TIME);
4039            return(false);
4040            
4041    };
4042    /**
4043     * Assign VALIDATION value to a GL_RUN entry
4044     * @param idrun Run ID
4045     * @param validation true/false
4046     */
4047    Int_t PamelaDBOperations::assignVALIDATION(UInt_t idrun, Bool_t validation){
4048            TSQLResult *result = 0;
4049            stringstream oss;
4050            oss.str("");
4051            oss << " UPDATE GL_RUN SET VALIDATION="<< (UInt_t)validation <<" WHERE ID= " << idrun << ";";
4052            //
4053    //      if ( IsDebug() )
4054    //      printf(" Set VALIDATION = %i for run %i \n",validation,idrun);
4055            if ( IsDebug() )printf(" Query: %s \n",oss.str().c_str());
4056            result = conn->Query(oss.str().c_str());
4057            if ( !result ) throw -4;
4058            return(0);
4059    }
4060    
4061    
4062    
4063    // Insert TLEs from file tlefilename in the table GL_TLE in the db
4064    // opened by conn, sorting them by date from older to newer, if each
4065    // TLE has not been alread inserted.
4066    Int_t PamelaDBOperations::populateTLE()//(TSQLServer *conn, char *tleFile)
4067    {
4068      fstream tlefile(tlefilename, ios::in);
4069    
4070      if ( !tlefile ) throw -7;
4071    
4072      vector<cTle*> ctles;
4073      vector<cTle*>::iterator iter;
4074      int present = 0;
4075    
4076      // Get three lines from tlefile, create a cTle object and put it
4077      // into ctles
4078      while(1) {
4079        cTle *tlef;
4080        string str1, str2, str3;
4081    
4082        getline(tlefile, str1);
4083        if(tlefile.eof()) break;
4084    
4085        getline(tlefile, str2);
4086        if(tlefile.eof()) break;
4087    
4088        getline(tlefile, str3);
4089        if(tlefile.eof()) break;
4090    
4091        // We now have three good lines for a cTle.
4092        tlef = new cTle(str1, str2, str3);
4093        ctles.push_back(tlef);
4094      }
4095    
4096      tlefile.close();
4097    
4098      // Sort by date
4099      sort(ctles.begin(), ctles.end(), compTLE);
4100    
4101      // Now we insert each TLE into the db
4102      for(iter = ctles.begin(); iter != ctles.end(); iter++) {
4103        cTle *tle = *iter;
4104    
4105        // Do nothing if it's already present in the db.  Just increase
4106        // the counter present.
4107        if (! isTlePresent(tle))
4108          {
4109            int status = insertTle(tle);
4110    
4111            // Insert query failed.  Return 1.
4112            if(status == EXIT_FAILURE) {
4113              
4114              if( IsDebug() ) {
4115                cerr << "Error: inserting TLE:" << endl
4116                     << tle->getName() << endl
4117                     << tle->getLine1() << endl
4118                     << tle->getLine2() << endl;
4119              }
4120    
4121              throw -4;
4122              return 1;
4123            }
4124    
4125          }
4126        else
4127          present++;
4128    
4129      }
4130    
4131      int inserted = ctles.size() - present;  // Number of inserted TLE.
4132      if ( IsDebug() )
4133        cout << "\nProcessed TLEs ranging from " << getTleDatetime(ctles[0]) << " to " << getTleDatetime(ctles[ctles.size()-1]) << "." << endl
4134             << inserted << " newly inserted TLEs out of " << ctles.size() << " processed." << endl;
4135    
4136      ctles.clear();
4137    
4138    
4139      // Return 2 if no new TLE has been inserted.  0 otherwise.
4140      if(! inserted ) return 2;
4141      return 0;
4142    }
4143    
4144    
4145    // Insert tle in the table GL_TLE using the connection conn.
4146    Int_t PamelaDBOperations::insertTle(cTle *tle)
4147    {
4148      stringstream oss;
4149      TSQLResult *result = 0;
4150    
4151      oss.str("");
4152      oss << " INSERT INTO GL_TLE (TLE1, TLE2, TLE3, FROM_TIME)"
4153          << " VALUES ( '"
4154          << tle->getName() << "', '"
4155          << tle->getLine1() << "', '"
4156          << tle->getLine2() << "', '"
4157          << getTleDatetime(tle) << "')";
4158    
4159      //  cout << oss.str().c_str() << endl;
4160      result = conn->Query(oss.str().c_str());
4161      if (result == NULL)
4162        return EXIT_FAILURE;
4163    
4164      return EXIT_SUCCESS;
4165    }
4166    
4167    
4168    // Return whether tle is already in the db connected by conn.
4169    bool PamelaDBOperations::isTlePresent(cTle *tle)
4170    {
4171      stringstream oss;
4172      TSQLResult *result = 0;
4173    
4174      oss.str("");
4175      oss << "SELECT * FROM GL_TLE WHERE FROM_TIME = '"
4176          << getTleDatetime(tle) << "'";
4177    
4178      result = conn->Query(oss.str().c_str());
4179      if (result == NULL) throw -4;
4180    
4181      if (result->GetRowCount())
4182        return true;
4183      else
4184        return false;
4185    }
4186    
4187    
4188    // Return whether the first TLE is dated early than the second
4189    bool compTLE (cTle *tle1, cTle *tle2)
4190    {
4191      return getTleJulian(tle1) < getTleJulian(tle2);
4192    }
4193    
4194    
4195    // Return the date of the tle using the format (year-2000)*1e3 +
4196    // julian day.  e.g. 6365 is the 31th Dec 2006.
4197    // It does *not* return a cJulian date.
4198    float getTleJulian(cTle *tle) {
4199      return tle->getField(cTle::FLD_EPOCHYEAR)*1e3 + tle->getField(cTle::FLD_EPOCHDAY);
4200    }
4201    
4202    
4203    // Return a string like YYYY-MM-DD hh:mm:ss, usable for mysql datetime
4204    // format.
4205    string getTleDatetime(cTle *tle)
4206    {
4207      int year, mon, day, hh, mm, ss;
4208      double dom; // day of month (is double!)
4209      stringstream date; // date in datetime format
4210    
4211      // create a cJulian from the date in tle
4212      cJulian jdate = cJulian( 2000 + (int) tle->getField(cTle::FLD_EPOCHYEAR), tle->getField(cTle::FLD_EPOCHDAY));
4213    
4214      // get year, month, day of month
4215      jdate.getComponent(&year, &mon, &dom);
4216    
4217      // build a datetime YYYY-MM-DD hh:mm:ss
4218      date.str("");
4219      day = (int) floor(dom);
4220      hh = (int) floor( (dom - day) * 24);
4221      mm = (int) floor( ((dom - day) * 24 - hh) * 60);
4222      ss = (int) floor( ((((dom - day) * 24 - hh) * 60 - mm) * 60));
4223      //  ms = (int) floor( (((((dom - day) * 24 - hh) * 60 - mm) * 60) - ss) * 1000);
4224    
4225      date << year << "-" << mon << "-" << day << " " << hh << ":" << mm << ":" << ss;
4226    
4227      return date.str();
4228    }
4229    
4230    /**
4231     * Remove a file from the DB, delete on cascade all entries related to that file
4232     * rearrange GL_RUN and GL_XXX_CALIB tables, turn off validation till the following
4233     * calibration
4234     **/
4235    Int_t PamelaDBOperations::removeFile(TString remfile){
4236    //    //
4237    time->Set();    // Determine ID_ROOT_L0 and ID_RAW
   timelim =  (UInt_t)time->Convert() - olderthan;  
   time->Set(timelim,false);  
4238    //    //
4239    // First of all validate runs with default calibration:    TSQLResult *pResult;
4240      TSQLRow *Row;
4241      stringstream myquery;
4242      //  
4243      myquery.str("");
4244      myquery << " SELECT ID, ID_RAW FROM GL_ROOT where NAME='"<<remfile.Data() <<"';";
4245    //    //
4246    oss.str("");    pResult = conn->Query(myquery.str().c_str());
   oss << " UPDATE GL_RUN SET VALIDATION=1 WHERE"  
       << " VALIDATION = 0 AND TRK_CALIB_USED=104 AND "  
       << " INSERT_TIME <= '" << time->AsSQLString() << "';";  
4247    //    //
4248    if ( IsDebug() ) printf(" Validate runs with trk default calibration inserted before %s : query is \n %s \n",time->AsSQLString(),oss.str().c_str());    Row = pResult->Next();      
4249    result = conn->Query(oss.str().c_str());    if( !Row ){
4250        if ( strcmp(remfile.Data(),GetRootName().Data()) ){
4251          if ( IsDebug() ) printf(" No file to be removed even if option \"-remove file\" was used!!\n");
4252          return(1);
4253        };
4254        if ( IsDebug() ) printf(" No file to be removed (force mode)! \n");
4255        return(0);
4256      };
4257    //    //
4258    if ( !result ) throw -4;    this->SetID_ROOT((UInt_t)atoll(Row->GetField(0)));
4259      this->SetID_RAW((UInt_t)atoll(Row->GetField(1)));
4260      //
4261      this->ValidationOFF();
4262      //
4263      this->RemoveCALIBS();
4264      //
4265      this->RemoveRUNS();
4266      //
4267      this->RemoveFILES();
4268      //
4269      this->SetID_ROOT(0);
4270      this->SetID_RAW(0);
4271    //    //
4272    return(0);    return(0);
4273  };  };
4274    
4275    /**
4276     *
4277     * Set validation bit to zero for runs following the removing file till
4278     * 1) a run with TRK_CALIB_USED=140
4279     * 2) a run with VALIDATION = 0
4280     * 3) the next calibration
4281     *
4282     **/
4283    void PamelaDBOperations::ValidationOFF(){
4284      TSQLResult *pResult;
4285      TSQLRow *Row;
4286      stringstream myquery;
4287      Int_t unv = 0;
4288      //select ID from GL_RUN where RUNHEADER_TIME>=1152671382 AND (VALIDATION=0 OR TRK_CALIB_USED=104) order by RUNHEADER_TIME asc limit 1;
4289      myquery.str("");
4290      myquery << " SELECT MAX(RUNTRAILER_TIME) FROM GL_RUN WHERE ID_ROOT_L0="<< this->GetID_ROOT() <<";";
4291      //
4292      pResult = conn->Query(myquery.str().c_str());
4293      //
4294      Row = pResult->Next();      
4295      if( !Row->GetField(0) ){
4296        //
4297        if ( IsDebug() ) printf(" NO RUN ASSOCIATED TO THIS FILE! \n");
4298        //
4299      } else {  
4300        //
4301        UInt_t runhtime = (UInt_t)atoll(Row->GetField(0));
4302        UInt_t caltime = 0;
4303        //
4304        myquery.str("");
4305        myquery << " SELECT FROM_TIME FROM GL_TRK_CALIB where FROM_TIME>" <<runhtime;
4306        myquery << " order by FROM_TIME asc limit 1;";
4307        //
4308        if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
4309        //
4310        //
4311        delete pResult;
4312        pResult = conn->Query(myquery.str().c_str());
4313        //
4314        Row = pResult->Next();      
4315        if( !Row ){
4316          caltime = runhtime;
4317        } else {
4318          caltime = (UInt_t)atoll(Row->GetField(0));
4319        };
4320        //
4321        myquery.str("");
4322        myquery << " SELECT ID,RUNHEADER_TIME from GL_RUN where RUNHEADER_TIME>="<< runhtime <<" AND (VALIDATION=0 OR TRK_CALIB_USED=104 OR RUNHEADER_TIME>" ;
4323        myquery << caltime << ") order by RUNHEADER_TIME asc LIMIT 1";
4324        //
4325        if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
4326        //
4327        pResult = conn->Query(myquery.str().c_str());
4328        //
4329        Row = pResult->Next();      
4330        if( !Row ){
4331          //
4332          if ( IsDebug() ) printf(" NO RUN NEED TO BE UNVALIDATED \n");
4333          //
4334        } else {
4335          myquery.str("");
4336          myquery << " SELECT ID from GL_RUN where RUNHEADER_TIME<"<< Row->GetField(1) <<" AND ";
4337          myquery << " RUNHEADER_TIME>=" <<runhtime;
4338          myquery << " order by RUNHEADER_TIME asc;";
4339          //
4340          if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
4341          //
4342          pResult = conn->Query(myquery.str().c_str());
4343          //
4344          Row = pResult->Next();  
4345          while ( Row ){
4346            //      
4347            unv++;
4348            this->assignVALIDATION((UInt_t)atoll(Row->GetField(0)), false);
4349            Row = pResult->Next();  
4350            //
4351          };
4352        };
4353      };
4354      if ( IsDebug() ) printf(" %u runs have been unvalidated \n",unv);
4355    };
4356    
4357    /**
4358     *
4359     * Rearrange GL_RUN table and remove runs
4360     *
4361     **/
4362    void PamelaDBOperations::RemoveRUNS(){
4363      TSQLResult *pResult;
4364      TSQLRow *Row;
4365      stringstream myquery;
4366      UInt_t drun = 0;
4367      GL_RUN *delrun = new GL_RUN();
4368      //
4369      myquery.str("");
4370      myquery << " SELECT ID FROM GL_RUN where ID_RUN_FRAG=0 and ID_ROOT_L0=" <<this->GetID_ROOT() <<";";
4371      //
4372      if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
4373      //
4374      pResult = conn->Query(myquery.str().c_str());
4375      //
4376      Row = pResult->Next();    
4377      //
4378      //
4379      if ( !Row ){
4380        if ( IsDebug() ) printf(" No run with ID_RUN_FRAG=0 belonged to this file \n");
4381      } else {
4382        if ( IsDebug() ) printf(" Deleting run from GL_RUN table \n");    
4383        while ( Row ){
4384          delrun->DeleteRun(conn,(UInt_t)atoll(Row->GetField(0)),"GL_RUN");
4385          if ( IsDebug() ) printf(" del run %u \n",(UInt_t)atoll(Row->GetField(0)));
4386          drun++;
4387          Row = pResult->Next();    
4388        };
4389      };
4390      //
4391      //
4392      myquery.str("");
4393      myquery << " SELECT ID,ID_RUN_FRAG FROM GL_RUN where ID_RUN_FRAG!=0 and ID_ROOT_L0=" <<this->GetID_ROOT() <<";";
4394      //
4395      if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
4396      //
4397      pResult = conn->Query(myquery.str().c_str());
4398      //
4399      Row = pResult->Next();    
4400      //
4401      if ( !Row ){
4402        if ( IsDebug() ) printf(" No run with ID_RUN_FRAG!=0 belonged to this file \n");
4403      } else {
4404        if ( IsDebug() ) printf(" Deleting run fragments from GL_RUN table \n");    
4405        while ( Row ){
4406          if ( IsDebug() ) printf(" restore run %u \n",(UInt_t)atoll(Row->GetField(1)));
4407          delrun->RestoreRun(conn,(UInt_t)atoll(Row->GetField(1)),"GL_RUN_FRAGMENTS");
4408          if ( IsDebug() ) printf(" del run %u \n",(UInt_t)atoll(Row->GetField(1)));
4409          delrun->DeleteRun(conn,(UInt_t)atoll(Row->GetField(1)),"GL_RUN");
4410          if ( (UInt_t)atoll(Row->GetField(1)) != (UInt_t)atoll(Row->GetField(0)) ){
4411            if ( IsDebug() ) printf(" del run %u \n",(UInt_t)atoll(Row->GetField(0)));
4412            delrun->DeleteRun(conn,(UInt_t)atoll(Row->GetField(0)),"GL_RUN");
4413          };
4414          drun++;
4415          Row = pResult->Next();    
4416        };
4417      };
4418      //
4419      if ( IsDebug() ) printf(" Deleted %i run(s) from GL_RUN table \n",drun);    
4420      //
4421      //
4422      //
4423      drun = 0;
4424      //
4425      myquery.str("");
4426      myquery << " SELECT ID_TRASH FROM GL_RUN_TRASH where BELONGED_TO='GL_RUN_FRAGMENTS' AND ID_ROOT_L0=" <<this->GetID_ROOT() <<";";
4427      //
4428      pResult = conn->Query(myquery.str().c_str());
4429      //
4430      Row = pResult->Next();    
4431      //
4432      if ( !Row ){
4433        if ( IsDebug() ) printf(" No run from GL_RUN_FRAGMENTS table in the trash table for this file \n");
4434      } else {
4435        if ( IsDebug() ) printf(" Deleting run fragments from GL_RUN_TRASH table \n");    
4436        while ( Row ){
4437          if ( IsDebug() ) printf(" del run idtrash %u \n",(UInt_t)atoll(Row->GetField(0)));
4438          myquery.str("");
4439          myquery << " DELETE FROM GL_RUN_TRASH where ID_TRASH=" << Row->GetField(0) <<";";      
4440          conn->Query(myquery.str().c_str());
4441          drun++;
4442          Row = pResult->Next();    
4443        };
4444      };
4445      //  
4446      if ( IsDebug() ) printf(" Deleted %u run(s) from GL_RUN_TRASH table \n",drun);    
4447      //
4448      //
4449      //
4450      drun = 0;
4451      //
4452      myquery.str("");
4453      myquery << " SELECT ID FROM GL_RUN_FRAGMENTS where ID_ROOT_L0=" <<this->GetID_ROOT() <<";";
4454      //
4455      pResult = conn->Query(myquery.str().c_str());
4456      //
4457      Row = pResult->Next();    
4458      //
4459      if ( !Row ){
4460        if ( IsDebug() ) printf(" No run in the GL_RUN_FRAGMENTS table for this file \n");
4461      } else {
4462        if ( IsDebug() ) printf(" Deleting run fragments from GL_RUN_FRAGMENTS table \n");    
4463        while ( Row ){
4464          if ( IsDebug() ) printf(" del run %u \n",(UInt_t)atoll(Row->GetField(0)));
4465          myquery.str("");
4466          myquery << " DELETE FROM GL_RUN_FRAGMENTS where ID=" << Row->GetField(0) <<";";
4467          conn->Query(myquery.str().c_str());
4468          drun++;
4469          Row = pResult->Next();    
4470        };
4471      };
4472      //  
4473      if ( IsDebug() ) printf(" Deleted %u run(s) from GL_RUN_FRAGMENTS table \n",drun);    
4474      //
4475      //
4476      //
4477      delete delrun;
4478      //
4479    };
4480    
4481    
4482    /**
4483     *
4484     * Rearrange calibration tables
4485     *
4486     **/
4487    void PamelaDBOperations::RemoveFILES(){
4488      stringstream myquery;
4489      //
4490      myquery.str("");
4491      myquery << " DELETE FROM GL_RAW WHERE ID=" <<this->GetID_RAW() <<";";
4492      //
4493      if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
4494      //
4495      conn->Query(myquery.str().c_str());
4496      //
4497    };
4498    
4499    /**
4500     *
4501     * Rearrange calibration tables
4502     *
4503     **/
4504    void PamelaDBOperations::RemoveCALIBS(){
4505      TSQLResult *pResult;
4506      TSQLRow *Row;
4507      stringstream myquery;
4508      //  
4509      //
4510      // Calorimeter
4511      //
4512      for (Int_t section = 0; section < 4; section++){
4513        myquery.str("");
4514        myquery << " SELECT MIN(FROM_TIME),MAX(TO_TIME) FROM GL_CALO_CALIB WHERE ID_ROOT_L0="<< this->GetID_ROOT() <<" AND ";
4515        myquery << " SECTION=" << section << ";";
4516        //
4517        pResult = conn->Query(myquery.str().c_str());
4518        //
4519        Row = pResult->Next();      
4520        if( !Row->GetField(0) || !Row->GetField(1) ){
4521          //
4522          if ( IsDebug() ) printf(" NO CALO CALIBRATION SECTION %i ASSOCIATED TO THIS FILE! \n",section);
4523          //
4524        } else {
4525          //
4526          myquery.str("");
4527          myquery << " UPDATE GL_CALO_CALIB SET TO_TIME=" << Row->GetField(1);
4528          myquery << " WHERE TO_TIME="<< Row->GetField(0) << " AND ";
4529          myquery << " SECTION=" << section << ";";
4530          //
4531          pResult = conn->Query(myquery.str().c_str());
4532          //
4533          if( !pResult ){
4534            //
4535            if ( IsDebug() ) printf(" ERROR DELETING CALO CALIBRATIONS \n");
4536            //
4537            throw -4;
4538            //
4539          };
4540          //
4541        };
4542      };
4543      myquery.str("");
4544      myquery << " DELETE FROM GL_CALO_CALIB WHERE ID_ROOT_L0=" << this->GetID_ROOT();
4545      //
4546      pResult = conn->Query(myquery.str().c_str());
4547      //
4548      if( !pResult ){
4549        //
4550        if ( IsDebug() ) printf(" ERROR DELETING CALO CALIBRATIONS \n");
4551        //
4552        throw -4;
4553        //
4554      };
4555      //
4556      // Tracker
4557      //
4558      myquery.str("");
4559      myquery << " SELECT MIN(FROM_TIME),MAX(TO_TIME) FROM GL_TRK_CALIB WHERE ID_ROOT_L0="<< this->GetID_ROOT() <<";";
4560      //
4561      pResult = conn->Query(myquery.str().c_str());
4562      //
4563      Row = pResult->Next();      
4564      if( !Row->GetField(0) || !Row->GetField(1) ){
4565        //
4566        if ( IsDebug() ) printf(" NO TRK CALIBRATION ASSOCIATED TO THIS FILE! \n");
4567        //
4568      } else {
4569        //
4570        myquery.str("");
4571        myquery << " UPDATE GL_TRK_CALIB SET TO_TIME=" << Row->GetField(1);
4572        myquery << " WHERE TO_TIME="<< Row->GetField(0) << ";";
4573        //
4574        pResult = conn->Query(myquery.str().c_str());
4575        //
4576        if( !pResult ){
4577          //
4578          if ( IsDebug() ) printf(" ERROR DELETING TRK CALIBRATIONS \n");
4579          //
4580          throw -4;
4581          //
4582        };
4583        //
4584        myquery.str("");
4585        myquery << " DELETE FROM GL_TRK_CALIB WHERE ID_ROOT_L0=" << this->GetID_ROOT();
4586        //
4587        pResult = conn->Query(myquery.str().c_str());
4588        //
4589        if( !pResult ){
4590          //
4591          if ( IsDebug() ) printf(" ERROR DELETING TRK CALIBRATIONS \n");
4592          //
4593          throw -4;
4594          //
4595        };
4596      };
4597      //
4598      //
4599      // S4
4600      //
4601      myquery.str("");
4602      myquery << " SELECT MIN(FROM_TIME),MAX(TO_TIME) FROM GL_S4_CALIB WHERE ID_ROOT_L0="<< this->GetID_ROOT() <<";";
4603      //
4604      pResult = conn->Query(myquery.str().c_str());
4605      //
4606      Row = pResult->Next();      
4607      if( !Row->GetField(0) || !Row->GetField(1) ){
4608        //
4609        if ( IsDebug() ) printf(" NO S4 CALIBRATION ASSOCIATED TO THIS FILE! \n");
4610        //
4611      } else {
4612        //
4613        myquery.str("");
4614        myquery << " UPDATE GL_S4_CALIB SET TO_TIME=" << Row->GetField(1);
4615        myquery << " WHERE TO_TIME="<< Row->GetField(0) << ";";
4616        //
4617        pResult = conn->Query(myquery.str().c_str());
4618        //
4619        if( !pResult ){
4620          //
4621          if ( IsDebug() ) printf(" ERROR DELETING S4 CALIBRATIONS \n");
4622          //
4623          throw -4;
4624          //
4625        };
4626        //
4627        myquery.str("");
4628        myquery << " DELETE FROM GL_S4_CALIB WHERE ID_ROOT_L0=" << this->GetID_ROOT();
4629        //
4630        pResult = conn->Query(myquery.str().c_str());
4631        //
4632        if( !pResult ){
4633          //
4634          if ( IsDebug() ) printf(" ERROR DELETING S4 CALIBRATIONS \n");
4635          //
4636          throw -4;
4637          //
4638        };
4639        //
4640      };
4641    };
4642    
4643    /**
4644     *
4645     * Rearrange calibration tables
4646     *
4647     **/
4648    UInt_t PamelaDBOperations::ValidateTrkCalib( CalibTrk1Event* caltrk, EventHeader *eh ){
4649    
4650        Int_t vorder[]={5,5,3,3,4,4,2,2,1,1,0,0};
4651        UInt_t timeaftercalib=120000; //2000;
4652    //  ----------
4653    //  Check CRCs
4654    //  ----------
4655        for(Int_t ipkt=0; ipkt<6; ipkt++){
4656            if( caltrk->crc_hcal[ipkt] )return 0; // :-(
4657            for(Int_t ilad=0; ilad<3; ilad++)if( caltrk->crc_cal[ipkt][ilad] )return 0; // :-(
4658        }
4659    //  -----------------------
4660    //  Check missing packets:
4661    //  -----------------------
4662    //    Readout order:
4663    //    ------------------
4664    //    DSP   packet board
4665    //    ------------------
4666    //    12    0      1
4667    //    10    1      1
4668    //     8    2      1
4669    //     4    3      1
4670    //     6    4      1
4671    //     2    5      1
4672    //    ------------------
4673    //    11    0      2
4674    //     9    1      2
4675    //     7    2      2
4676    //     3    3      2
4677    //     5    4      2
4678    //     1    5      2
4679    //    ------------------
4680    //  -------------------------------------------------
4681    //  Check if it is first or second calibration packet
4682    //  -------------------------------------------------
4683        UInt_t build=0;
4684        TString classname = caltrk->GetName();
4685        UInt_t base=0;
4686        UInt_t mask=0;
4687        if(classname.Contains("CalibTrk1Event")){
4688            base=12;
4689            mask=0x03F000;
4690        }
4691        if(classname.Contains("CalibTrk2Event")){
4692            base=18;
4693            mask=0xFC0000;
4694        }
4695    //  -------------------------------------------------
4696    //  Count number of packets and set build variable
4697    //  -------------------------------------------------
4698        Int_t  npkts=0;
4699        for(Int_t ipkt=0; ipkt<6; ipkt++){
4700            if(caltrk->DSPnumber[ipkt]>0 && caltrk->DSPnumber[ipkt]<=12){
4701                npkts++;
4702                build = build | ( 1<<(base+vorder[caltrk->DSPnumber[ipkt]-1]) );
4703            }
4704        }
4705    //    if( npkts==6 )return 1; // :-)
4706    
4707    //    cout << classname << " "<<eh->GetPscuHeader()->GetOrbitalTime()<<endl;
4708    
4709    //  -----------------------------------------------
4710    //  If missing packets: check the acq configuration
4711    //  (some DSPs might be excluded from acquisition)
4712    //  -----------------------------------------------
4713    
4714    //  -----------------------------------------------
4715    //  retrieve the first run header after calib
4716    //  -----------------------------------------------
4717         PacketType *pctp;
4718         EventCounter *cod;
4719         cod = eh->GetCounter();
4720         Int_t irun = cod->Get(pctp->RunHeader);
4721         TTree *rh=(TTree*)file->Get("RunHeader");
4722         if ( !rh || rh->IsZombie() ) throw -17;
4723         if( rh->GetEntries() == irun ){
4724              if ( IsDebug() ) cout << "ValidateTrkCalib: (MISSING VIEW) no runs after calib (1)  -- cannot validate :-( "<<endl;
4725             return 0; // :-(
4726         }
4727    
4728         RunHeaderEvent *run  = 0;
4729         EventHeader    *hrun = 0;
4730         rh->SetBranchAddress("RunHeader", &run);
4731         rh->SetBranchAddress("Header", &hrun);
4732         rh->GetEntry(irun);
4733    //     cout << classname << " "<<eh->GetPscuHeader()->GetOrbitalTime() << " Run " << hrun->GetPscuHeader()->GetOrbitalTime() <<endl;
4734    
4735         if( OBT(hrun->GetPscuHeader()->GetOrbitalTime()) < OBT(eh->GetPscuHeader()->GetOrbitalTime())){
4736              if ( IsDebug() ) cout << "ValidateTrkCalib: (MISSING VIEW) no runs after calib (2) -- cannot validate :-( "<<endl;
4737             return 0; // :-(
4738         }
4739        
4740         if( !run->RM_ACQ_AFTER_CALIB ){
4741              if ( IsDebug() ) cout << "ValidateTrkCalib: (MISSING VIEW) RM_ACQ_AFTER_CALIB=0    -- cannot validate :-( "<<endl;
4742             return 0; // :-(
4743         }
4744    
4745         UInt_t dtime = OBT(hrun->GetPscuHeader()->GetOrbitalTime()) - OBT(eh->GetPscuHeader()->GetOrbitalTime());
4746         if( dtime > timeaftercalib ){
4747             if ( IsDebug() ) cout << "ValidateTrkCalib: (MISSING VIEW) run after calib too far ( "<<dtime<<"ms ) -- cannot validate :-( "<<endl;
4748             return 0; // :-(
4749         }
4750        
4751    
4752    
4753         if( (run->ACQ_BUILD_INFO & mask) != build ){
4754             if ( IsDebug() ) cout << "ValidateTrkCalib: (MISSING VIEW) ACQ_BUILD_INFO= >>> "<<hex << (run->ACQ_BUILD_INFO&mask) << " != "<< build << dec<<endl;
4755             return 0; // :-(
4756         }
4757         return 1; // :-)
4758    
4759    }
4760    
4761    /**
4762     *
4763     * Check the DB (only for overlapping runs at the moment)
4764     *
4765     **/
4766    UInt_t PamelaDBOperations::Check(){
4767      //
4768      UInt_t test = 0;
4769      //
4770      UInt_t thisrht = 0;
4771      UInt_t thisrtt = 0;
4772      UInt_t thisid = 0;
4773      UInt_t prevrht = 0;
4774      UInt_t prevrtt = 0;
4775      UInt_t previd = 0;
4776      //
4777      UInt_t prevl0id = 0;
4778      UInt_t thisl0id = 0;
4779      //
4780      stringstream oss;
4781      TSQLResult *result = 0;
4782      TSQLRow    *row    = 0;
4783      TSQLResult *result2 = 0;
4784      TSQLRow    *row2    = 0;
4785      TSQLResult *result3 = 0;
4786      TSQLRow    *row3    = 0;
4787      oss.str("");
4788      oss << "SELECT ID,ID_ROOT_L0,RUNHEADER_TIME,RUNTRAILER_TIME,NEVENTS FROM GL_RUN order by RUNHEADER_TIME asc;";
4789      //  oss << "SELECT ID,RUNHEADER_TIME,RUNTRAILER_TIME FROM GL_RUN where ID>10170 and ID<10190 order by RUNHEADER_TIME asc;";
4790      result = conn->Query(oss.str().c_str());
4791      //
4792      if ( !result ) throw -4;;
4793      //
4794      row = result->Next();
4795      UInt_t nid = 0;
4796      //
4797      while ( row ){
4798        nid++;
4799        if ( !(nid%1000) && nid ) printf(" %iK run scanned \n",nid/1000);
4800        thisid = (UInt_t)atoll(row->GetField(0));
4801        thisl0id = (UInt_t)atoll(row->GetField(1));
4802        thisrht = (UInt_t)atoll(row->GetField(2));
4803        thisrtt = (UInt_t)atoll(row->GetField(3));
4804        //
4805        if ( (UInt_t)atoll(row->GetField(4)) > 1 ){
4806          //
4807          //
4808          //
4809          oss.str("");
4810          oss << "SELECT ID,ID_ROOT_L0,RUNHEADER_TIME,RUNTRAILER_TIME FROM GL_RUN WHERE ID!="
4811              << thisid << " AND ( RUNHEADER_TIME="
4812              << thisrht << " OR RUNTRAILER_TIME="
4813              << thisrtt << " ) AND NEVENTS!=0 AND NEVENTS!=1 order by RUNHEADER_TIME asc;";
4814          result3 = conn->Query(oss.str().c_str());
4815          if ( IsDebug() ) printf(" query is %s \n",oss.str().c_str());
4816          if ( result3 ){
4817            //
4818            oss.str("");
4819            oss << "SELECT ID,ID_ROOT_L0,RUNHEADER_TIME,RUNTRAILER_TIME FROM GL_RUN WHERE ID!="
4820                << thisid << " AND RUNHEADER_TIME="
4821                << thisrht << " AND RUNTRAILER_TIME!="
4822                << thisrtt << " AND NEVENTS!=0 AND NEVENTS!=1 order by RUNHEADER_TIME asc;";
4823            result3 = conn->Query(oss.str().c_str());
4824            if ( IsDebug() ) printf(" query is %s \n",oss.str().c_str());
4825            if ( result3 ){
4826              row3 = result3->Next();
4827              //
4828              while ( row3 ){
4829                //
4830                // 2 runs with same runheader
4831                //
4832                printf(" CHECK n.4 RUNs %u and %u HAVE SAME RUNHEADER \n",thisid,(UInt_t)atoll(row3->GetField(0)));  
4833                row3 = result3->Next();
4834              };
4835            };
4836            //
4837            oss.str("");
4838            oss << "SELECT ID,ID_ROOT_L0,RUNHEADER_TIME,RUNTRAILER_TIME FROM GL_RUN WHERE ID!="
4839                << thisid << " AND RUNHEADER_TIME!="
4840                << thisrht << " AND RUNTRAILER_TIME="
4841                << thisrtt << " AND NEVENTS!=0 AND NEVENTS!=1 order by RUNHEADER_TIME asc;";
4842            result3 = conn->Query(oss.str().c_str());
4843            if ( IsDebug() ) printf(" query is %s \n",oss.str().c_str());
4844            if ( result3 ){
4845              row3 = result3->Next();
4846              //
4847              while ( row3 ){
4848                //
4849                // 2 runs with same runtrailer
4850                //
4851                printf(" CHECK n.5 RUNs %u and %u HAVE SAME RUNTRAILER \n",thisid,(UInt_t)atoll(row3->GetField(0)));
4852                row3 = result3->Next();
4853              };
4854            };
4855            //
4856            oss.str("");
4857            oss << "SELECT ID,ID_ROOT_L0,RUNHEADER_TIME,RUNTRAILER_TIME FROM GL_RUN WHERE ID!="
4858                << thisid << " AND RUNHEADER_TIME="
4859                << thisrht << " AND RUNTRAILER_TIME="
4860                << thisrtt << " AND ID_RUN_FRAG!="
4861                << thisid << " order by RUNHEADER_TIME asc;";
4862            result3 = conn->Query(oss.str().c_str());
4863            if ( result3 ){
4864              row3 = result3->Next();
4865              //
4866              while ( row3 ){
4867                //
4868                // duplicated run
4869                //
4870                printf(" CHECK n.7 RUNs %u and %u HAVE SAME RUNTRAILER AND RUNHEADER (ARE THE SAME?) \n",thisid,(UInt_t)atoll(row3->GetField(0)));
4871                row3 = result3->Next();
4872              };
4873            };
4874          };
4875          //
4876          oss.str("");
4877          oss << "SELECT ID,ID_ROOT_L0,RUNHEADER_TIME,RUNTRAILER_TIME FROM GL_RUN WHERE ID!="
4878              << thisid << " AND RUNHEADER_TIME>"
4879              << thisrht << " AND RUNTRAILER_TIME<"
4880              << thisrtt << " order by RUNHEADER_TIME asc;";
4881          result3 = conn->Query(oss.str().c_str());
4882          if ( result3 ){
4883            row3 = result3->Next();
4884            //
4885            while ( row3 ){
4886              //
4887              // run contained in the checked one
4888              //
4889              printf(" CHECK n.6 RUN %u CONTAINS RUN %u  \n",thisid,(UInt_t)atoll(row3->GetField(0)));
4890              row3 = result3->Next();
4891            };
4892          };
4893          //
4894        };
4895        //
4896        //    if ( thisrht < prevrtt || thisrtt < prevrht || thisrht > thisrtt && !(!prevrht && !prevrtt &&!previd) ){
4897        //    if ( (thisrht < prevrtt || thisrtt < prevrht || thisrht > thisrtt) && (thisrht != prevrht) ){
4898        if ( (thisrht < prevrtt) && (thisrht != prevrht) ){
4899          if ( IsDebug() ) printf(" IDprev %u ID %u    prevrht %u prevrtt %u  thisrht %u thisrtt %u \n",previd,thisid,prevrht,prevrtt,thisrht,thisrtt);
4900          printf(" CHECK n.1 TIME SCREW of %i s AROUND RUNs %u and %u \n",(thisrht-prevrtt),previd,thisid);
4901          TString prevf = "";
4902          TString thisf = "";
4903          oss.str("");
4904          oss << "SELECT NAME FROM GL_ROOT where ID=" << (UInt_t)prevl0id <<";";
4905          result2 = conn->Query(oss.str().c_str());
4906          if ( !result2 ) throw -4;;
4907          row2 = result2->Next();
4908          prevf = (TString)row2->GetField(0);
4909          oss.str("");
4910          oss << "SELECT NAME FROM GL_ROOT where ID=" << (UInt_t)thisl0id <<";";
4911          result2 = conn->Query(oss.str().c_str());
4912          if ( !result2 ) throw -4;;
4913          row2 = result2->Next();
4914          thisf = (TString)row2->GetField(0);
4915          if ( IsDebug() ) printf(" ==> files %s and %s \n",prevf.Data(),thisf.Data());
4916          test = 1;
4917        };
4918        //
4919        if ( (thisrtt < prevrht) && (thisrht != prevrht) ){
4920          if ( IsDebug() ) printf(" IDprev %u ID %u    prevrht %u prevrtt %u  thisrht %u thisrtt %u \n",previd,thisid,prevrht,prevrtt,thisrht,thisrtt);
4921          printf(" CHECK n.2 TIME SCREW of %i s AROUND RUNs %u and %u \n",(thisrtt-prevrht),previd,thisid);
4922          TString prevf = "";
4923          TString thisf = "";
4924          oss.str("");
4925          oss << "SELECT NAME FROM GL_ROOT where ID=" << (UInt_t)prevl0id <<";";
4926          result2 = conn->Query(oss.str().c_str());
4927          if ( !result2 ) throw -4;
4928          row2 = result2->Next();
4929          prevf = (TString)row2->GetField(0);
4930          oss.str("");
4931          oss << "SELECT NAME FROM GL_ROOT where ID=" << (UInt_t)thisl0id <<";";
4932          result2 = conn->Query(oss.str().c_str());
4933          if ( !result2 ) throw -4;;
4934          row2 = result2->Next();
4935          thisf = (TString)row2->GetField(0);
4936          if ( IsDebug() ) printf(" ==> files %s and %s \n",prevf.Data(),thisf.Data());
4937          test = 1;
4938        };
4939        //
4940        if ( (thisrht > thisrtt) && (thisrht != prevrht) ){
4941          if ( IsDebug() ) printf(" IDprev %u ID %u    prevrht %u prevrtt %u  thisrht %u thisrtt %u \n",previd,thisid,prevrht,prevrtt,thisrht,thisrtt);
4942          printf(" CHECK n.3 TIME SCREW of %i s AROUND RUNs %u and %u \n",(thisrht-thisrtt),previd,thisid);
4943          TString prevf = "";
4944          TString thisf = "";
4945          oss.str("");
4946          oss << "SELECT NAME FROM GL_ROOT where ID=" << (UInt_t)prevl0id <<";";
4947          result2 = conn->Query(oss.str().c_str());
4948          if ( !result2 ) throw -4;;
4949          row2 = result2->Next();
4950          prevf = (TString)row2->GetField(0);
4951          oss.str("");
4952          oss << "SELECT NAME FROM GL_ROOT where ID=" << (UInt_t)thisl0id <<";";
4953          result2 = conn->Query(oss.str().c_str());
4954          if ( !result2 ) throw -4;;
4955          row2 = result2->Next();
4956          thisf = (TString)row2->GetField(0);
4957          if ( IsDebug() ) printf(" ==> files %s and %s \n",prevf.Data(),thisf.Data());
4958          test = 1;
4959        };
4960    
4961        //
4962        prevrht = thisrht;
4963        prevrtt = thisrtt;
4964        previd = thisid;
4965        prevl0id = thisl0id;
4966        row = result->Next();
4967      };
4968      //
4969      return(test);
4970      //
4971    };

Legend:
Removed from v.1.3  
changed lines
  Added in v.1.51

  ViewVC Help
Powered by ViewVC 1.1.23