/[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.5 by pam-fi, Fri Sep 8 14:42:48 2006 UTC revision 1.53 by mocchiut, Fri Nov 30 13:17:34 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 24  Line 24 
24  #include <RunHeaderEvent.h>  #include <RunHeaderEvent.h>
25  #include <RunTrailerEvent.h>  #include <RunTrailerEvent.h>
26  #include <CalibCalPedEvent.h>  #include <CalibCalPedEvent.h>
27    #include <CalibCalPulse1Event.h>
28    #include <CalibCalPulse2Event.h>
29  #include <CalibS4Event.h>  #include <CalibS4Event.h>
30  #include <CalibTrk1Event.h>  #include <CalibTrk1Event.h>
31  #include <CalibTrk2Event.h>  #include <CalibTrk2Event.h>
# Line 31  Line 33 
33  #include <varDump/VarDumpRecord.h>  #include <varDump/VarDumpRecord.h>
34  #include <physics/S4/S4Event.h>  #include <physics/S4/S4Event.h>
35  //  //
36    #include <sgp4.h>
37    
38  #include <PamelaDBOperations.h>  #include <PamelaDBOperations.h>
39  //  //
40  using namespace std;  using namespace std;
41  using namespace pamela;  using namespace pamela;
42    
43    // Some function to work with cTle stuff.
44    bool compTLE(cTle* tle1, cTle *tle2);
45    float getTleJulian(cTle *);
46    string getTleDatetime(cTle*);
47    
48  /**  /**
49   * Constructor.   * Constructor.
50   * @param host         hostname for the SQL connection.   * @param host         hostname for the SQL connection.
# Line 47  using namespace pamela; Line 56  using namespace pamela;
56   * @param obt0         file obt0.   * @param obt0         file obt0.
57   * @param tsync        file timesync.   * @param tsync        file timesync.
58   * @param debug        debug flag.   * @param debug        debug flag.
59     * @param tlefilename  ascii file with TLE 3 line elements.
60   */   */
61  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){
62    //    //
63      STATIC=false;
64      if ( staticp ) STATIC=true;
65    //    //
66    SetConnection(host,user,password);    SetConnection(host,user,password);
67    //    //
# Line 58  PamelaDBOperations::PamelaDBOperations(T Line 70  PamelaDBOperations::PamelaDBOperations(T
70    glrun = new GL_RUN();    glrun = new GL_RUN();
71    //    //
72    if ( !boot ) SetNOBOOT(false);    if ( !boot ) SetNOBOOT(false);
73    SetBOOTnumber(boot);    SetTsync(tsync,gpamela);
74    SetTsync(tsync);    SetBOOTnumber(boot,gpamela);
75    SetObt0(obt0);    SetObt0(obt0);
76    //    //
77      SetTLEPath(tlefilename);
78    //    //
   SetRootName(filerootname);  
   SetRawName(filerawname);  
79    //    //
80    this->OpenFile();    INSERT_RAW =!filerawname.IsNull();
81      if(INSERT_RAW)SetRawName(filerawname);
82      //
83      INSERT_ROOT = !filerootname.IsNull();
84      if( INSERT_ROOT ){
85        this->SetRootName(filerootname);
86        this->SetOrbitNo(dwinput);
87        file = TFile::Open(this->GetRootName().Data());
88      } else {
89        this->SetRootName("");
90      };
91    //    //
92    this->SetID_RAW(0);    this->SetID_RAW(0);
93    this->SetID_ROOT(0);    this->SetID_ROOT(0);
94    
95      VALIDATE = false;
96      
97    //    //
98  };  };
99    
# Line 78  PamelaDBOperations::PamelaDBOperations(T Line 102  PamelaDBOperations::PamelaDBOperations(T
102   */   */
103  void PamelaDBOperations::Close(){  void PamelaDBOperations::Close(){
104    if( conn && conn->IsConnected() ) conn->Close();    if( conn && conn->IsConnected() ) conn->Close();
105      delete clean_time;
106    delete glrun;    delete glrun;
107    delete this;    delete this;
108  };  };
# Line 86  void PamelaDBOperations::Close(){ Line 111  void PamelaDBOperations::Close(){
111  // SETTERS  // SETTERS
112  //  //
113    
114    //
115    // 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
116    //
117    void PamelaDBOperations::CheckValidate(Long64_t olderthan){
118      clean_time = new TDatime();
119      //
120      if(olderthan >= 0){
121        VALIDATE = true;
122        UInt_t timelim = 0;
123        timelim =  (UInt_t)clean_time->Convert(true) - olderthan;
124        clean_time->Set(timelim,false);
125      };
126    };
127    
128  /**  /**
129   * Open the DB connection   * Open the DB connection
130   * @param host         hostname for the SQL connection.   * @param host         hostname for the SQL connection.
# Line 93  void PamelaDBOperations::Close(){ Line 132  void PamelaDBOperations::Close(){
132   * @param password     password for the SQL connection.   * @param password     password for the SQL connection.
133   */   */
134  void PamelaDBOperations::SetConnection(TString host, TString user, TString password){  void PamelaDBOperations::SetConnection(TString host, TString user, TString password){
135      if ( IsDebug() ) printf(" Connecting using host = %s user = %s password = %s \n",host.Data(),user.Data(),password.Data());
136    conn = TSQLServer::Connect(host.Data(),user.Data(),password.Data());    conn = TSQLServer::Connect(host.Data(),user.Data(),password.Data());
137  };  };
138    
# Line 121  void PamelaDBOperations::SetDebugFlag(Bo Line 161  void PamelaDBOperations::SetDebugFlag(Bo
161  };  };
162    
163  /**  /**
164     * Set the autoboot flag
165     *
166     */
167    void PamelaDBOperations::SetAutoBoot(Bool_t dbg){
168      AUTOBOOT = dbg;
169    };
170    
171    /**
172     * Set the nofrag flag
173     *
174     */
175    void PamelaDBOperations::SetNoFrag(Bool_t nf){
176      NOFRAG = nf;
177    };
178    
179    /**
180   * Store the BOOT number of the RAW file.   * Store the BOOT number of the RAW file.
181   * @param boot    BOOT number of the RAW file   * @param boot    BOOT number of the RAW file
182   */   */
183  void PamelaDBOperations::SetBOOTnumber(UInt_t boot){  void PamelaDBOperations::SetBOOTnumber(UInt_t boot){
184      this->SetBOOTnumber(boot,false);
185    };
186    
187    /**
188     * Store the BOOT number of the RAW file.
189     * @param boot    BOOT number of the RAW file
190     */
191    void PamelaDBOperations::SetBOOTnumber(UInt_t boot, Bool_t gpamela){
192    BOOTNO=boot;    BOOTNO=boot;
193      if ( gpamela ){
194        stringstream oss;
195        TSQLResult *result = 0;
196        TSQLRow    *row    = 0;    
197        if ( !boot ){
198          //
199          BOOTNO = 1;
200          //
201          // look in the DB for the last timesync and the last run
202          //
203          oss.str("");
204          oss << "SELECT BOOT_NUMBER FROM GL_RUN order by RUNHEADER_TIME desc limit 1;";
205          result = conn->Query(oss.str().c_str());
206          if ( result ){
207            row = result->Next();
208            if ( row ){
209              BOOTNO = (UInt_t)atoll(row->GetField(0)) + 1;
210            };
211          };
212        };
213      };
214  };  };
215    
216  /**  /**
# Line 133  void PamelaDBOperations::SetBOOTnumber(U Line 218  void PamelaDBOperations::SetBOOTnumber(U
218   * @param boot    time sync   * @param boot    time sync
219   */   */
220  void PamelaDBOperations::SetTsync(UInt_t ts){  void PamelaDBOperations::SetTsync(UInt_t ts){
221      this->SetTsync(ts,false);
222    };
223    
224    /**
225     * Store the time sync of the RAW file.
226     * @param boot    time sync
227     */
228    void PamelaDBOperations::SetTsync(UInt_t ts, Bool_t gpamela){
229      //
230      // if not gpamela or given tsync file set ts
231      //
232    tsync=ts;    tsync=ts;
233      if ( gpamela ){
234        stringstream oss;
235        TSQLResult *result = 0;
236        TSQLRow    *row    = 0;    
237        TSQLResult *result2 = 0;
238        TSQLRow    *row2    = 0;    
239        if ( !ts ){
240          //
241          tsync = 1;
242          //
243          // look in the DB for the last timesync and the last run
244          //
245          oss.str("");
246          oss << "SELECT TIMESYNC FROM GL_TIMESYNC order by TIMESYNC desc limit 1;";
247          result = conn->Query(oss.str().c_str());
248          if ( result ){
249            row = result->Next();
250            if ( row ){
251              tsync = (UInt_t)atoll(row->GetField(0)) + 1;
252              oss.str("");
253              oss << "SELECT (RUNTRAILER_TIME-RUNHEADER_TIME) FROM GL_RUN order by RUNHEADER_TIME desc limit 1;";
254              result2 = conn->Query(oss.str().c_str());
255              if ( result2 ){
256                row2 = result2->Next();
257                if ( row2 ){
258                  tsync += (UInt_t)atoll(row2->GetField(0));
259                };
260              }
261            };
262          };
263        };
264      };
265  };  };
266    
267  /**  /**
# Line 161  void PamelaDBOperations::SetRootName(TSt Line 289  void PamelaDBOperations::SetRootName(TSt
289  };  };
290    
291  /**  /**
292     * Store the downlink orbit number from filename.
293     */
294    void PamelaDBOperations::SetOrbitNo(UInt_t dwinput){
295      dworbit = 0;
296      //
297      if ( dwinput ){
298        dworbit = dwinput;
299        if ( IsDebug() ) printf(" Downlink orbit given by hand: %i  \n",dworbit);
300        return;
301      };
302      //
303      TString name = this->GetRootFile();
304      Int_t nlength = name.Length();
305      if ( nlength < 5 ) return;
306      TString dwo = 0;
307      for (Int_t i = 0; i<5; i++){
308        dwo.Append(name[i],1);
309      };
310      if ( dwo.IsDigit() ){
311        dworbit = (UInt_t)dwo.Atoi();
312      } else {
313        dwo="";
314        for (Int_t i = 8; i<13; i++){
315          dwo.Append(name[i],1);
316        };    
317        if ( dwo.IsDigit() ) dworbit = (UInt_t)dwo.Atoi();
318      };
319      if ( IsDebug() ) printf(" Downlink orbit is %i (dwo = %s) \n",dworbit,dwo.Data());
320      return;
321    };
322    
323    
324    
325    /**
326   * Store the NOBOOT flag.   * Store the NOBOOT flag.
327   * @param noboot    true/false.   * @param noboot    true/false.
328   */   */
# Line 169  void PamelaDBOperations::SetNOBOOT(Bool_ Line 331  void PamelaDBOperations::SetNOBOOT(Bool_
331  };  };
332    
333  /**  /**
334     * Store path to the TLE file.
335     */
336    void PamelaDBOperations::SetTLEPath(TString str){
337      tlefilename = str;
338    };
339    
340    TString PamelaDBOperations::GetRawPath(){
341      if ( STATIC ){
342        return((TString)gSystem->DirName(filerawname.Data())+'/');
343      } else {
344        return((TString)gSystem->ExpandPathName("$PAM_RAW")+'/');
345      };
346    };
347    
348    TString PamelaDBOperations::GetRootPath(){
349      if ( STATIC ){
350        return((TString)gSystem->DirName(filerootname.Data())+'/');
351      } else {
352        return((TString)gSystem->ExpandPathName("$PAM_L0")+'/');
353      };
354    };
355    
356    /**
357   * Store the olderthan variable   * Store the olderthan variable
358   * @param olderthan   * @param olderthan
359   */   */
360  void PamelaDBOperations::SetOlderThan(Long64_t oldthan){  // void PamelaDBOperations::SetOlderThan(Long64_t oldthan){
361    olderthan = oldthan;  //   olderthan = oldthan;
362  };  // };
363    
364  /**  /**
365   * 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 369  Bool_t PamelaDBOperations::SetID_RAW(){
369    TSQLResult *result = 0;    TSQLResult *result = 0;
370    TSQLRow    *row    = 0;    TSQLRow    *row    = 0;
371    oss.str("");    oss.str("");
372    oss << "SELECT ID FROM GL_RAW WHERE "    if ( STATIC ){
373        << " PATH = '" << this->GetRawPath().Data() << "' AND "      oss << "SELECT ID FROM GL_RAW WHERE "
374        << " NAME = '" << this->GetRawFile().Data() << "' ";          << " PATH = '" << this->GetRawPath().Data() << "' AND "
375            << " NAME = '" << this->GetRawFile().Data() << "' ";  
376      } else {
377        oss << "SELECT ID FROM GL_RAW WHERE "
378            << " PATH = '$PAM_RAW' AND "
379            << " NAME = '" << this->GetRawFile().Data() << "' ";  
380      }
381    result = conn->Query(oss.str().c_str());    result = conn->Query(oss.str().c_str());
382    if ( result == NULL ) throw -4;    if ( result == NULL ) throw -4;
383    row = result->Next();    row = result->Next();
384    if ( !row ) return(false);    if ( !row ) return(false);
   delete result;  
385    id = (UInt_t)atoll(row->GetField(0));    id = (UInt_t)atoll(row->GetField(0));
386      delete result;
387    return(true);    return(true);
388  }  }
389    
# Line 217  Int_t PamelaDBOperations::SetUpperLimits Line 408  Int_t PamelaDBOperations::SetUpperLimits
408    UInt_t nevent = 0;    UInt_t nevent = 0;
409    UInt_t pktlast = 0;    UInt_t pktlast = 0;
410    UInt_t obtlast = 0;    UInt_t obtlast = 0;
411    UInt_t t_pktlast = 0;    Long64_t t_pktlast = 0LL;
412    UInt_t t_obtlast = 0;    //  UInt_t t_obtlast = 0;
413    UInt_t upperpkt2 = 0;    Long64_t t_obtlast = 0LL;
414    ULong64_t upperobt2 = 0;    Long64_t upperpkt2 = 0LL;
415      Long64_t upperobt2 = 0LL;
416    UInt_t zomp = 0;    UInt_t zomp = 0;
417    UInt_t jump = 50000; // was 5000    UInt_t jump = 50000; // was 5000
418    EventCounter *code=0;    EventCounter *code=0;
419    //    //
420    //   pcksList packetsNames;    Long64_t deltapkt = 5000LL;
421    //   pcksList::iterator Iter;    Long64_t deltaobt = 50000LL;
422    //   getPacketsNames(packetsNames);    //
423      pcksList packetsNames;
424      pcksList::iterator Iter;
425      getPacketsNames(packetsNames);
426    //    //
427    pktfirst = 0;    pktfirst = 0;
428    obtfirst = 0;    obtfirst = 0;
429      ppktfirst = 0;
430      pobtfirst = 0;
431    //    //
432    TTree *T = 0;    TTree *T = 0;
433    T = (TTree*)file->Get("Physics");    T = (TTree*)file->Get("Physics");
# Line 244  Int_t PamelaDBOperations::SetUpperLimits Line 441  Int_t PamelaDBOperations::SetUpperLimits
441    ph = eh->GetPscuHeader();    ph = eh->GetPscuHeader();
442    pktfirst = ph->GetCounter();    pktfirst = ph->GetCounter();
443    obtfirst = ph->GetOrbitalTime();      obtfirst = ph->GetOrbitalTime();  
444      ppktfirst = pktfirst;
445      pobtfirst = obtfirst;
446    //    //
447    //   code = eh->GetCounter();    code = eh->GetCounter();
448    //   UInt_t en = 0;    UInt_t en = 0;
449    //   for(Iter = packetsNames.begin(); Iter != packetsNames.end(); Iter++){    for(Iter = packetsNames.begin(); Iter != packetsNames.end(); Iter++){
450    //     en = code->Get(GetPacketType(*Iter));      en = code->Get(GetPacketType(*Iter));
451    //     if ( en ) printf(" Packet type is %s, entries: %i \n",*Iter,en);      if ( !strcmp("CalibCalPed",*Iter) || !strcmp("CalibTrk1",*Iter) || !strcmp("CalibTrk2",*Iter) || !strcmp("CalibS4",*Iter) ){
452    //};          if ( IsDebug() ) printf(" We have a calibration before the first physic packet: packet type is %s, entries: %i \n",*Iter,en);
453          //
454          TTree *TC = 0;
455          TC = (TTree*)file->Get("CalibCalPed");
456          if ( !TC || TC->IsZombie() ) throw -16;
457          EventHeader *ehc = 0;
458          PscuHeader *phc = 0;
459          TC->SetBranchAddress("Header", &ehc);
460          TC->GetEntry(0);
461          phc = ehc->GetPscuHeader();
462          pktfirst = phc->GetCounter();
463          obtfirst = phc->GetOrbitalTime();  
464          //
465        };
466      };  
467    //    //
468    T->GetEntry(nevent-1);    T->GetEntry(nevent-1);
469    ph = eh->GetPscuHeader();    ph = eh->GetPscuHeader();
# Line 261  Int_t PamelaDBOperations::SetUpperLimits Line 474  Int_t PamelaDBOperations::SetUpperLimits
474    upperobt = OBT(obtlast);    upperobt = OBT(obtlast);
475    upperentry = nevent-1;    upperentry = nevent-1;
476    //    //
477    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);
478    //    //
479    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);
480    //    //
481    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);
482    //    //
483    if ( !nevent ) return(2);    if ( !nevent ) return(64);
484    //    //
485    if ( nevent < 2 ) return(4);    if ( nevent < 2 ) return(128);
486      if ( nevent < jump ) jump = 1;
487      //  if ( nevent < jump ) jump = int(nevent/10);
488      //  if ( !jump ) jump = 1;
489    //    //
490    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 ){
491        //
492        if ( IsDebug() ) printf(" starting jump %i \n",jump);
493      // go back      // go back
494      zomp = nevent - 2;      zomp = nevent - 2;
495      //      //
# Line 293  Int_t PamelaDBOperations::SetUpperLimits Line 511  Int_t PamelaDBOperations::SetUpperLimits
511          upperpkt2 = PKT(ph->GetCounter());          upperpkt2 = PKT(ph->GetCounter());
512          upperobt2 = OBT(ph->GetOrbitalTime());          upperobt2 = OBT(ph->GetOrbitalTime());
513          //          //
514          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) ){
515              if ( IsDebug() ) printf(" .-. upperpkt2 %lld upperobt2 %lld \n",upperpkt2,upperobt2);  
516              if ( IsDebug() ) printf(" .-. upperpkt %lld t_pktlast %lld upperobt %lld t_obtlast %lld \n",upperpkt,t_pktlast,upperobt,t_obtlast);    
517              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);    
518              throw -13;    
519            };
520          //          //
521          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 ){
522            zomp = i + jump + 1;            zomp = i + jump + 1;
523            if ( zomp > nevent-2 ) zomp = nevent - 2;            if ( zomp > nevent-2 ) zomp = nevent - 2;
524            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);
525            break;            break;
526          };          };
527          //          //
# Line 320  Int_t PamelaDBOperations::SetUpperLimits Line 543  Int_t PamelaDBOperations::SetUpperLimits
543    // 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)
544    //    //
545    PacketType *pctp=0;    PacketType *pctp=0;
   T->GetEntry(upperentry);  
   code = eh->GetCounter();  
   Int_t lasttrail = code->Get(pctp->RunTrailer);  
   Int_t lasthead = code->Get(pctp->RunHeader);  
546    TTree *rh=(TTree*)file->Get("RunHeader");    TTree *rh=(TTree*)file->Get("RunHeader");
547    if ( !rh || rh->IsZombie() ) throw -17;    if ( !rh || rh->IsZombie() ) throw -17;
548    TTree *rt=(TTree*)file->Get("RunTrailer");    TTree *rt=(TTree*)file->Get("RunTrailer");
# Line 337  Int_t PamelaDBOperations::SetUpperLimits Line 556  Int_t PamelaDBOperations::SetUpperLimits
556    //    //
557    rhev = rh->GetEntries();    rhev = rh->GetEntries();
558    rtev = rt->GetEntries();    rtev = rt->GetEntries();
559    UInt_t sobtt = 0;    Long64_t sobtt = 0LL;
560    UInt_t sobth = 0;    Long64_t sobth = 0LL;
561    UInt_t spktt = 0;    Long64_t spktt = 0LL;
562    UInt_t spkth = 0;    Long64_t spkth = 0LL;
563    UInt_t pktt = 0;    Long64_t pktt = 0LL;
564    ULong64_t obtt = 0;    Long64_t obtt = 0LL;
565    UInt_t pkth = 0;    Long64_t pkth = 0LL;
566    ULong64_t obth = 0;    Long64_t obth = 0LL;
   //  
   if ( lasttrail < rtev ){  
     rt->GetEntry(lasttrail);  
     pht = eht->GetPscuHeader();  
     pktt = PKT(pht->GetCounter());  
     obtt = OBT(pht->GetOrbitalTime());  
   };  
   //  
   if ( lasthead < rhev ){  
     rh->GetEntry(lasthead);  
     phh = ehh->GetPscuHeader();  
     pkth = PKT(pht->GetCounter());  
     obth = OBT(pht->GetOrbitalTime());  
   };  
   //  
   if ( IsDebug() ) printf(" rhev before %i ph %i upperp %i oh %llu uppero %llu \n",rhev,pkth,upperpkt,obth,upperobt);  
   if ( pkth > upperpkt && obth > upperobt ){  
     if ( IsDebug() ) printf(" Upper limits extended to include last header: ph %i upperp %i oh %llu uppero %llu \n",pkth,upperpkt,obth,upperobt);  
     upperpkt = pkth;  
     upperobt = obth;  
     rhev = lasthead+1;  
   } else {  
     rhev = lasthead;  
   };  
   if ( IsDebug() ) printf(" rhev after %i ph %i upperp %i oh %llu uppero %llu \n",rhev,pkth,upperpkt,obth,upperobt);  
   //  
   if ( IsDebug() ) printf(" rtev beforev %i  pt %i upperp %i ot %llu uppero %llu \n",rtev,pktt,upperpkt,obtt,upperobt);  
   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);  
   //  goto kikko;  
   //  
   //  
   // Check if runtrailer/runheader are within lower limits  
567    //    //
568    //    if ( rhev || rtev ){
569    pkth = 0;  
570    obth = 0;      T->GetEntry(upperentry);
571    spkth = 0;      code = eh->GetCounter();
572    sobth = 0;      Int_t lasttrail = code->Get(pctp->RunTrailer);
573    for (Int_t k=0; k<rhev; k++){      Int_t lasthead = code->Get(pctp->RunHeader);
574      if ( k > 0 ){      if ( lasttrail < rtev ){
575        spkth = pkth;        rt->GetEntry(lasttrail);
576        sobth = obth;        pht = eht->GetPscuHeader();
577      };        pktt = PKT(pht->GetCounter());
578      rh->GetEntry(k);        obtt = OBT(pht->GetOrbitalTime());
579      phh = ehh->GetPscuHeader();      };
580      pkth = PKT(phh->GetCounter());      //
581      obth = OBT(phh->GetOrbitalTime());      if ( lasthead < rhev ){
582      //        rh->GetEntry(lasthead);
583      if ( pkth < spkth && obth < sobth ){        phh = ehh->GetPscuHeader();
584        if ( IsDebug() ) printf(" rhev before %i ph %i upperp %i oh %llu uppero %llu \n",rhev,pkth,upperpkt,obth,upperobt);        pkth = PKT(phh->GetCounter());
585        if ( IsDebug() ) printf(" RH PROBLEMS determining the event repetition at the end of the file lasthead %i  \n",rhev);        obth = OBT(phh->GetOrbitalTime());
586        //      };
587        rhev--;      //
588        rh->GetEntry(rhev);      if ( IsDebug() ) printf(" rhev before %i ph %lld upperp %lld oh %lld uppero %lld \n",rhev,pkth,upperpkt,obth,upperobt);
589        pkth = spkth;      if ( pkth > upperpkt && obth > upperobt ){
590        obth = sobth;        if ( IsDebug() ) printf(" Upper limits extended to include last header: ph %lld upperp %lld oh %lld uppero %lld \n",pkth,upperpkt,obth,upperobt);
591        if ( IsDebug() ) printf(" lasthead %i pt %i p1 %i ot %u o1 %u \n",rhev,pkth,spkth,obth,sobth);        upperpkt = pkth;
592        //        upperobt = obth;
593        UInt_t evbefh = 0;        rhev = lasthead+1;
594        code = ehh->GetCounter();      } else {
595        evbefh = code->Get(pctp->Physics);            rhev = lasthead;
596        if ( evbefh >= 0 ){      };
597          T->GetEntry(evbefh);      if ( IsDebug() ) printf(" rhev after %i ph %lld upperp %lld oh %lld uppero %lld \n",rhev,pkth,upperpkt,obth,upperobt);
598          ph = eh->GetPscuHeader();      //
599          t_pktlast = PKT(ph->GetCounter());      if ( IsDebug() ) printf(" rtev beforev %i  pt %lld upperp %lld ot %lld uppero %lld \n",rtev,pktt,upperpkt,obtt,upperobt);
600          t_obtlast = OBT(ph->GetOrbitalTime());      if ( pktt > upperpkt && obtt > upperobt ){
601          if ( t_pktlast < spkth && t_obtlast < sobth ){ // jump        if ( IsDebug() ) printf(" Upper limits extended to include last trailer: pt %lld upperp %lld ot %lld uppero %lld \n",pktt,upperpkt,obtt,upperobt);
602            upperpkt = pkth;        upperpkt = pktt;
603            upperobt = obth;        upperobt = obtt;
604            upperentry = evbefh-1;        rtev = lasttrail+1;
605          } else {      } else {
606            while ( t_pktlast > spkth && t_obtlast > sobth && evbefh < nevent ){        rtev = lasttrail;
607              evbefh++;        };
608              T->GetEntry(evbefh);      if ( IsDebug() ) printf(" rtev after %i  pt %lld upperp %lld ot %lld uppero %lld \n",rtev,pktt,upperpkt,obtt,upperobt);
609              ph = eh->GetPscuHeader();      //  goto kikko;
610              t_pktlast = PKT(ph->GetCounter());      //
611              t_obtlast = OBT(ph->GetOrbitalTime());      //
612            };      // Check if runtrailer/runheader are within lower limits
613            T->GetEntry(evbefh-1);      //
614        //
615        pkth = 0LL;
616        obth = 0LL;
617        spkth = 0LL;
618        sobth = 0LL;
619        for (Int_t k=0; k<rhev; k++){
620          if ( k > 0 ){
621            spkth = pkth;
622            sobth = obth;
623          };
624          rh->GetEntry(k);
625          phh = ehh->GetPscuHeader();
626          pkth = PKT(phh->GetCounter());
627          obth = OBT(phh->GetOrbitalTime());
628          //
629          //    if ( IsDebug() ) printf(" k %i rhev before %i ph %u upperp %u oh %u uppero %u \n",k,rhev,pkth,spkth,obth,sobth);
630          //
631          if ( pkth < spkth && obth < sobth ){
632            if ( IsDebug() ) printf(" RH PROBLEMS determining the event repetition at the end of the file lasthead %i  \n",rhev);
633            //
634            rhev = k-1;
635            rh->GetEntry(rhev);
636            pkth = spkth;
637            obth = sobth;
638            //
639            UInt_t evbefh = 0;
640            code = ehh->GetCounter();
641            evbefh = code->Get(pctp->Physics);    
642            if ( evbefh >= 0 ){
643              T->GetEntry(evbefh);
644            ph = eh->GetPscuHeader();            ph = eh->GetPscuHeader();
645            upperpkt = PKT(ph->GetCounter());            t_pktlast = PKT(ph->GetCounter());
646            upperobt = OBT(ph->GetOrbitalTime());            t_obtlast = OBT(ph->GetOrbitalTime());
647            upperentry = evbefh-1;            if ( t_pktlast <= spkth && t_obtlast <= sobth ){ // jump
648          };                  upperpkt = pkth;
649        };              upperobt = obth;
650        if ( IsDebug() ) printf(" rhev after %i ph %i upperp %i oh %llu uppero %llu \n",rhev,pkth,upperpkt,obth,upperobt);              upperentry = evbefh-1;
651              } else {
652                while ( t_pktlast > spkth && t_obtlast > sobth && evbefh < nevent ){
653                  evbefh++;
654                  T->GetEntry(evbefh);
655                  ph = eh->GetPscuHeader();
656                  t_pktlast = PKT(ph->GetCounter());
657                  t_obtlast = OBT(ph->GetOrbitalTime());
658                };
659                T->GetEntry(evbefh-1);
660                ph = eh->GetPscuHeader();
661                upperpkt = PKT(ph->GetCounter());
662                upperobt = OBT(ph->GetOrbitalTime());
663                upperentry = evbefh-1;
664              };    
665            };
666            if ( IsDebug() ) printf(" rhev after %i ph %lld upperp %lld oh %lld uppero %lld \n",rhev,pkth,upperpkt,obth,upperobt);
667            goto kikko0;
668          };
669      };      };
670    };    kikko0:
671    //      //
672    //      //
673    //      //
674    pktt = 0;      pktt = 0LL;
675    obtt = 0;      obtt = 0LL;
676    spktt = 0;      spktt = 0LL;
677    sobtt = 0;      sobtt = 0LL;
678    for (Int_t k=0; k<rtev; k++){      for (Int_t k=0; k<rtev; k++){
679      if ( k > 0 ){        if ( k > 0 ){
680        spktt = pktt;          spktt = pktt;
681        sobtt = obtt;          sobtt = obtt;
682      };        };
683      rt->GetEntry(k);        rt->GetEntry(k);
684      pht = eht->GetPscuHeader();        pht = eht->GetPscuHeader();
685      pktt = PKT(pht->GetCounter());        pktt = PKT(pht->GetCounter());
686      obtt = OBT(pht->GetOrbitalTime());        obtt = OBT(pht->GetOrbitalTime());
687      //        //
688      if ( pktt < spktt && obtt < sobtt ){        //    if ( IsDebug() ) printf(" k %i rtev beforev %i  pt %i upperp %i ot %llu uppero %llu \n",k,rtev,pktt,spktt,obtt,sobtt);
689        if ( IsDebug() ) printf(" rtev beforev %i  pt %i upperp %i ot %llu uppero %llu \n",rtev,pktt,upperpkt,obtt,upperobt);        //
690        if ( IsDebug() ) printf(" RT PROBLEMS determining the event repetition at the end of the file lasttrail %i \n",rtev);        if ( pktt < spktt && obtt < sobtt ){
691        //          if ( IsDebug() ) printf(" RT PROBLEMS determining the event repetition at the end of the file lasttrail %i \n",rtev);
692        rtev--;          //
693        rt->GetEntry(rtev);          rtev = k-1;
694        pktt = spktt;          rt->GetEntry(rtev);
695        obtt = sobtt;          pktt = spktt;
696        if ( IsDebug() ) printf(" lasttrail %i pt %i upperp %i ot %llu uppero %llu \n",rtev,pktt,upperpkt,obtt,upperobt);          obtt = sobtt;
697        //          if ( IsDebug() ) printf(" lasttrail %i pt %lld upperp %lld ot %lld uppero %lld \n",rtev,pktt,upperpkt,obtt,upperobt);
698        UInt_t evbeft = 0;          //
699        code = eht->GetCounter();          UInt_t evbeft = 0;
700        evbeft = code->Get(pctp->Physics);              code = eht->GetCounter();
701        if ( evbeft >= 0 ){          evbeft = code->Get(pctp->Physics);    
702          T->GetEntry(evbeft);          if ( evbeft >= 0 ){
703          ph = eh->GetPscuHeader();            T->GetEntry(evbeft);
704          t_pktlast = PKT(ph->GetCounter());            ph = eh->GetPscuHeader();
705          t_obtlast = OBT(ph->GetOrbitalTime());            t_pktlast = PKT(ph->GetCounter());
706          if ( t_pktlast < spktt && t_obtlast < sobtt ){ // jump            t_obtlast = OBT(ph->GetOrbitalTime());
707            upperpkt = pktt;            if ( t_pktlast <= spktt && t_obtlast <= sobtt ){ // jump
708            upperobt = obtt;              upperpkt = pktt;
709            upperentry = evbeft-1;              upperobt = obtt;
710          } else {              upperentry = evbeft-1;
711            while ( t_pktlast > spktt && t_obtlast > sobtt && evbeft < nevent ){            } else {
712              evbeft++;                while ( t_pktlast > spktt && t_obtlast > sobtt && evbeft < nevent ){
713              T->GetEntry(evbeft);                evbeft++;
714                  T->GetEntry(evbeft);
715                  ph = eh->GetPscuHeader();
716                  t_pktlast = PKT(ph->GetCounter());
717                  t_obtlast = OBT(ph->GetOrbitalTime());
718                };
719                T->GetEntry(evbeft-1);
720              ph = eh->GetPscuHeader();              ph = eh->GetPscuHeader();
721              t_pktlast = PKT(ph->GetCounter());              upperpkt = PKT(ph->GetCounter());
722              t_obtlast = OBT(ph->GetOrbitalTime());              upperobt = OBT(ph->GetOrbitalTime());
723                upperentry = evbeft-1;
724            };            };
           T->GetEntry(evbeft-1);  
           ph = eh->GetPscuHeader();  
           upperpkt = PKT(ph->GetCounter());  
           upperobt = OBT(ph->GetOrbitalTime());  
           upperentry = evbeft-1;  
725          };          };
726            if ( IsDebug() ) printf(" rtev after %i  pt %lld upperp %lld ot %lld uppero %lld \n",rtev,pktt,upperpkt,obtt,upperobt);
727            goto kikko;
728            //      break;
729            //
730        };        };
731        if ( IsDebug() ) printf(" rtev after %i  pt %i upperp %i ot %llu uppero %llu \n",rtev,pktt,upperpkt,obtt,upperobt);        //  
732        break;      };
733        //      //
734      kikko:
735        //
736        T->GetEntry(upperentry);
737        code = eh->GetCounter();
738        lasttrail = code->Get(pctp->RunTrailer);
739        lasthead = code->Get(pctp->RunHeader);
740        if ( lasttrail < rtev ){
741          rt->GetEntry(lasttrail);
742          pht = eht->GetPscuHeader();
743          pktt = PKT(pht->GetCounter());
744          obtt = OBT(pht->GetOrbitalTime());
745        };
746        //
747        if ( lasthead < rhev ){
748          rh->GetEntry(lasthead);
749          phh = ehh->GetPscuHeader();
750          pkth = PKT(phh->GetCounter());
751          obth = OBT(phh->GetOrbitalTime());
752        };
753        //
754        if ( IsDebug() ) printf(" rhev before %i ph %lld upperp %lld oh %lld uppero %lld \n",rhev,pkth,upperpkt,obth,upperobt);
755        if ( pkth > upperpkt && obth > upperobt ){
756          if ( IsDebug() ) printf(" Upper limits extended to include last header: ph %lld upperp %lld oh %lld uppero %lld \n",pkth,upperpkt,obth,upperobt);
757          upperpkt = pkth;
758          upperobt = obth;
759          rhev = lasthead+1;
760        } else {
761          rhev = lasthead;
762        };
763        if ( IsDebug() ) printf(" rhev after %i ph %lld upperp %lld oh %lld uppero %lld \n",rhev,pkth,upperpkt,obth,upperobt);
764        //
765        if ( IsDebug() ) printf(" rtev beforev %i  pt %lld upperp %lld ot %lld uppero %lld \n",rtev,pktt,upperpkt,obtt,upperobt);
766        if ( pktt > upperpkt && obtt > upperobt ){
767          if ( IsDebug() ) printf(" Upper limits extended to include last trailer: pt %lld upperp %lld ot %lld uppero %lld \n",pktt,upperpkt,obtt,upperobt);
768          upperpkt = pktt;
769          upperobt = obtt;
770          rtev = lasttrail+1;
771        } else {
772          rtev = lasttrail;
773      };      };
774      //        if ( IsDebug() ) printf(" rtev after %i  pt %lld upperp %lld ot %lld uppero %lld \n",rtev,pktt,upperpkt,obtt,upperobt);
775        //
776    };    };
777    //    //
778    // kikko:    if ( IsDebug() ) printf(" Upper limits are: OBT %lld pkt_num %lld upper entry %i \n",upperobt,upperpkt,upperentry);
   //  
   if ( IsDebug() ) printf(" Upper limits are: OBT %llu pkt_num %i upper entry %i \n",upperobt,upperpkt,upperentry);  
779    //    //
780    return(0);    return(0);
781  }  }
782    
783    /**
784     *
785     * Trick to have unique RUN ID numbers even when runs are deleted and mysql deamon restarted.
786     * Entries in the _RUNID_GEN table are never deleted.
787     *
788     **/
789    UInt_t PamelaDBOperations::AssignRunID(){
790      //
791      TSQLResult *result = 0;
792      TSQLRow *row = 0;
793      UInt_t runid = 0;
794      //
795      stringstream   oss;
796      //  
797      oss.str("");
798      oss << "INSERT INTO _RUNID_GEN VALUES (NULL);";
799      result = conn->Query(oss.str().c_str());
800      if ( !result ) throw -10;
801      oss.str("");
802      oss << "SELECT ID FROM _RUNID_GEN ORDER BY ID DESC LIMIT 1;";
803      result = conn->Query(oss.str().c_str());
804      if ( !result ) throw -10;
805      //
806      row = result->Next();
807      //
808      if ( !row ) throw -28;
809      //
810      runid = (UInt_t)atoll(row->GetField(0));
811      //
812      return(runid);
813    };
814    
815  //  //
816  // GETTERS  // GETTERS
817  //  //
# Line 584  const PacketType* PamelaDBOperations::Ge Line 887  const PacketType* PamelaDBOperations::Ge
887  // PRIVATE FUNCTIONS  // PRIVATE FUNCTIONS
888  //  //
889    
890  /**  // /**
891   * Open the ROOT filename for reading  // * Open the ROOT filename for reading
892   */  // */
893  void PamelaDBOperations::OpenFile(){  // void PamelaDBOperations::OpenFile(){
894    file = TFile::Open(this->GetRootName().Data());  //   file = TFile::Open(this->GetRootName().Data());
895    //   //
896    
897    void PamelaDBOperations::CheckFile(){  
898      if ( !file ) throw -12;
899  };  };
900    
901    
902  /**  /**
903   * Check if LEVEL0 file and DB connection have really be opened   * Check if LEVEL0 file and DB connection have really be opened
904   */   */
905  void PamelaDBOperations::CheckFile(){    void PamelaDBOperations::CheckConnection(){  
   //  
   if ( !file ) throw -12;  
906    //    //
907    // check connection    // check connection
908    //    //
909    if( !conn ) throw -1;        if( !conn ) throw -1;
910    bool connect = conn->IsConnected();    bool connect = conn->IsConnected();
911    if( !connect ) throw -1;        if( !connect ) throw -1;
912      //
913      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());
914      //
915      if ( !dworbit && strcmp(this->GetRootName().Data(),"") ) throw -27;
916      //
917      // set DB timezone to UTC
918      //
919      stringstream oss;
920      //  
921      oss.str("");
922      oss << "SET time_zone='+0:00';";
923      TSQLResult *result = 0;
924      result = conn->Query(oss.str().c_str());
925      if ( !result ) throw -10;
926      oss.str("");
927      oss << "SET wait_timeout=173000;";
928      conn->Query(oss.str().c_str());
929      //
930  };  };
931    
932  /**  /**
933   * Return the correct packet number if we went back to zero   * Return the correct packet number if we went back to zero
934   */   */
935  UInt_t PamelaDBOperations::PKT(UInt_t pkt_num){    Long64_t PamelaDBOperations::PKT(UInt_t pkt_num){  
936    //    //
937    //  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));
938    //    //
939    if ( pkt_num < (pktfirst/2) && pktfirst > (16777214/2)  ) return((pkt_num+16777215));    if ( pkt_num < (ppktfirst/2) && ppktfirst > (16777214/2)  ){
940        if ( IsDebug() ) printf(" rise up pktnum %lld \n",(Long64_t)pkt_num+16777215LL);
941        return((Long64_t)pkt_num+16777215LL);
942      };
943    //    //
944    if ( pkt_num > pktfirst*2 && pkt_num > (16777214/2) ){    if ( pkt_num > ((Long64_t)ppktfirst*2) && pkt_num > (16777214/2) ){
945      if ( (pkt_num-16777215) < 0 ){      if ( IsDebug() ) printf(" rise down pktnum %lld \n",(Long64_t)pkt_num-16777215LL);
946        return((16777215-pkt_num));      return((Long64_t)pkt_num-16777215LL);
     } else {  
       return((pkt_num-16777215));  
     };  
947    };    };
948    //    //
949    return(pkt_num);    if ( IsDebug() ) printf(" as it is %lld \n",(Long64_t)pkt_num);
950      return((Long64_t)pkt_num);
951    //    //
952  };  };
953    
954  /**  /**
955   * Return the correct On Board Time if we went back to zero   * Return the correct On Board Time if we went back to zero
956   */   */
957  ULong64_t PamelaDBOperations::OBT(UInt_t obt){    Long64_t PamelaDBOperations::OBT(UInt_t obt){  
958    //    //
959    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));
960    //    //
961    if ( obt > (obtfirst*2) && obt > (numeric_limits<UInt_t>::max()/2) ){    if ( obt < (pobtfirst/2) && pobtfirst > (numeric_limits<UInt_t>::max()/2) ){
962      if ( (obt-numeric_limits<UInt_t>::max()) < 0  ){      if ( IsDebug() ) printf(" rise up obt %lld \n",(Long64_t)(obt+numeric_limits<UInt_t>::max()));
963        return((ULong64_t)(numeric_limits<UInt_t>::max()-obt));      return((Long64_t)(obt+numeric_limits<UInt_t>::max()));
964      } else {    };
965        return((ULong64_t)(obt-numeric_limits<UInt_t>::max()));    //
966      };    if ( obt > ((Long64_t)pobtfirst*2) && obt > (numeric_limits<UInt_t>::max()/2) ){
967        if ( IsDebug() ) printf(" pobtfirst*2 %lld \n",((Long64_t)pobtfirst*2));
968        if ( IsDebug() ) printf(" rise down pktnum %lld \n", (Long64_t)obt-(Long64_t)numeric_limits<UInt_t>::max());
969        return((Long64_t)obt-(Long64_t)numeric_limits<UInt_t>::max());
970    };    };
971    //    //
972    return((ULong64_t)obt);    if ( IsDebug() ) printf(" as it is %lld \n",(Long64_t)obt);
973      return((Long64_t)obt);
974  };  };
975    
976  /**  /**
# Line 757  Int_t PamelaDBOperations::insertPamelaRa Line 1085  Int_t PamelaDBOperations::insertPamelaRa
1085    if ( idr ) return(1);    if ( idr ) return(1);
1086    //    //
1087    oss.str("");    oss.str("");
1088    oss << "INSERT INTO GL_RAW (PATH, NAME) VALUES ('"    if ( STATIC ){
1089        << this->GetRawPath().Data() << "', '" << this->GetRawFile().Data() << "')";      oss << "INSERT INTO GL_RAW (PATH, NAME) VALUES ('"
1090            << this->GetRawPath().Data() << "', '" << this->GetRawFile().Data() << "')";
1091      } else {
1092        oss << "INSERT INTO GL_RAW (PATH, NAME) VALUES ('$PAM_RAW', '" << this->GetRawFile().Data() << "')";
1093      };
1094    if ( conn->Query(oss.str().c_str()) == 0 ) throw -4;    if ( conn->Query(oss.str().c_str()) == 0 ) throw -4;
1095    //    //
1096    idr =  this->SetID_RAW();    idr =  this->SetID_RAW();
# Line 777  Int_t PamelaDBOperations::insertPamelaGL Line 1109  Int_t PamelaDBOperations::insertPamelaGL
1109    TSQLResult *result = 0;    TSQLResult *result = 0;
1110    TSQLRow *row = 0;    TSQLRow *row = 0;
1111    UInt_t t0 = 0;    UInt_t t0 = 0;
1112      Int_t signal = 0;
1113      UInt_t idresof = 0;
1114      //
1115      signal = this->SetUpperLimits();
1116    //    //
1117    stringstream   oss;    stringstream   oss;
1118    //      //  
1119    if ( this->GetID_RAW() == 0 )  throw -11;    if ( this->GetID_RAW() == 0 )  throw -11;
1120    //    //
1121    oss.str("");    oss.str("");
1122    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='"
1123        << id << " AND TO_ID_RAW >= "        << this->GetRawFile().Data() << "';";
       << id << ";";  
1124    if ( IsDebug() ) printf(" %s \n",oss.str().c_str());    if ( IsDebug() ) printf(" %s \n",oss.str().c_str());
1125    result = conn->Query(oss.str().c_str());    result = conn->Query(oss.str().c_str());
1126    if ( !result ) throw -10;    if ( !result ) throw -10;
1127    row = result->Next();    row = result->Next();
   if ( !row ) throw -10;  
1128    //    //
1129    t0 = (UInt_t)TDatime(row->GetField(0)).Convert();    if ( !row ){
1130        oss.str("");
1131        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< "
1132            << dworbit << " order by FROM_ORBIT desc limit 1;";
1133        if ( IsDebug() ) printf(" %s \n",oss.str().c_str());
1134        result = conn->Query(oss.str().c_str());
1135        if ( !result ) throw -10;
1136        row = result->Next();
1137        if ( !row ) throw -10;
1138      };
1139      //
1140      idresof = (UInt_t)atoll(row->GetField(6));
1141      //
1142      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);
1143      t0 = (UInt_t)tu.GetSec();
1144      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));
1145      //
1146    /*    /*
1147     * Verify that the TIMESYNC have been not already processed     * Verify that the TIMESYNC have been not already processed
1148     */     */
# Line 807  Int_t PamelaDBOperations::insertPamelaGL Line 1157  Int_t PamelaDBOperations::insertPamelaGL
1157    if (result == NULL) throw -10;    if (result == NULL) throw -10;
1158    row = result->Next();    row = result->Next();
1159    if ((row != NULL) && ((UInt_t)atoll(row->GetField(0)) > 0)){    if ((row != NULL) && ((UInt_t)atoll(row->GetField(0)) > 0)){
1160        if ( IsDebug() ) printf(" found a timesync t0 is %u \n",t0);
1161      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;
1162        //
1163        tsync = (UInt_t)atoll(row->GetField(2));
1164        obt0 = (UInt_t)atoll(row->GetField(1));
1165        //
1166      return(1);      return(1);
1167    };    };
1168    //    //
1169    TTree *T = 0;    TTree *T = 0;
   Int_t signal = 0;  
1170    //    //
1171    UInt_t nevent = 0;    UInt_t nevent = 0;
1172    UInt_t recEntries = 0;    UInt_t recEntries = 0;
# Line 864  Int_t PamelaDBOperations::insertPamelaGL Line 1218  Int_t PamelaDBOperations::insertPamelaGL
1218          //          //
1219          TYPE = 55;//224;          TYPE = 55;//224;
1220          //          //
1221            if ( IsDebug() ) printf("mcmd tsync %i tsync %u obt %u \n",i,TSYNC,OBT);
1222            //
1223          if ( TSYNC && OBT ){          if ( TSYNC && OBT ){
1224            existsts = true;            existsts = true;
1225            goto eout;            goto eout;
# Line 886  Int_t PamelaDBOperations::insertPamelaGL Line 1242  Int_t PamelaDBOperations::insertPamelaGL
1242      //      //
1243      rt->SetBranchAddress("RunTrailer", &runt);      rt->SetBranchAddress("RunTrailer", &runt);
1244      //      //
1245      if ( rhev > 0 ){      Int_t nrhev = rh->GetEntries();
1246        rh->GetEntry(0);      Int_t nrtev = rt->GetEntries();
1247        if ( IsDebug() ) printf(" ou nevent %i rhev %i rtev %i \n",nevent,nrhev,nrtev);
1248        //
1249        if ( nrhev > 0 ){
1250          for (Int_t i=0; i<nrhev; i++){
1251            //
1252            rh->GetEntry(i);
1253            //
1254            TSYNC = runh->LAST_TIME_SYNC_INFO;
1255            OBT = runh->OBT_TIME_SYNC * 1000;
1256            //
1257            TYPE = 20;
1258            //
1259            if ( IsDebug() ) printf("runheader %i tsync %u obt %u \n",i,TSYNC,OBT);
1260            //
1261            if ( TSYNC && OBT ){
1262              existsts = true;
1263              goto eout;
1264            };
1265          };
1266        //        //
1267        TSYNC = runh->LAST_TIME_SYNC_INFO;      };
1268        OBT = runh->OBT_TIME_SYNC * 1000;      if ( nrtev > 0 ){
1269        //        //
1270        TYPE = 20;        if ( IsDebug() ) printf(" No runheader \n");
1271          signal = 6;
1272        //        //
1273        if ( TSYNC && OBT ){        for (Int_t i=0; i<nrtev; i++){
1274          existsts = true;          //
1275          goto eout;          rt->GetEntry(i);
1276        };          //
1277        //          TSYNC = runt->LAST_TYME_SYNC_INFO;
1278      };          OBT = runt->OBT_TYME_SYNC * 1000;
1279      if ( rtev > 0 ){          //
1280        //          TYPE = 21;
1281        if ( IsDebug() ) printf(" No runheader \n");          //
1282        signal = 6;          if ( IsDebug() ) printf("runtrailer %i tsync %u obt %u \n",i,TSYNC,OBT);
1283        //          //
1284        rt->GetEntry(0);          if ( TSYNC && OBT ){
1285        //            existsts = true;
1286        TSYNC = runt->LAST_TYME_SYNC_INFO;            goto eout;
1287        OBT = runt->OBT_TYME_SYNC * 1000;          };
       //  
       TYPE = 21;  
       //  
       if ( TSYNC && OBT ){  
         existsts = true;  
         goto eout;  
1288        };        };
1289        //        //
1290      } else {      } else {
# Line 977  Int_t PamelaDBOperations::insertPamelaGL Line 1347  Int_t PamelaDBOperations::insertPamelaGL
1347    if ( !existsts ) throw -3;    if ( !existsts ) throw -3;
1348    //    //
1349    oss.str("");    oss.str("");
1350    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 ('"
1351        << this->GetID_RAW() << "','"//224'"        << this->GetID_RAW() << "','"//224'"
1352        << dec << (UInt_t)TYPE << "','"        << dec << (UInt_t)TYPE << "','"
1353        << dec << (UInt_t)OBT << "','"        << dec << (UInt_t)OBT << "','"
1354        << dec << (UInt_t)TSYNC << "');";        << dec << (UInt_t)TSYNC << "','"
1355          << dec << (UInt_t)idresof << "');";
1356    conn->Query(oss.str().c_str());    conn->Query(oss.str().c_str());
1357    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());
1358      if ( conn->GetErrorCode() ){
1359        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");
1360        oss.str("");
1361        oss << "INSERT INTO GL_TIMESYNC (ID_RAW,TYPE,OBT0,TIMESYNC) VALUES ('"
1362            << this->GetID_RAW() << "','"//224'"
1363            << dec << (UInt_t)TYPE << "','"
1364            << dec << (UInt_t)OBT << "','"
1365            << dec << (UInt_t)TSYNC << "');";
1366        conn->Query(oss.str().c_str());
1367        if ( IsDebug() ) printf(" Query the GL_TIMESYNC table to fill it:\n %s \n",oss.str().c_str());
1368      };
1369      //
1370      if ( IsDebug() ) printf(" found a timesync t0 is %u \n",t0);
1371    //    //
1372    toffset = (UInt_t)TSYNC - (UInt_t)(this->OBT(OBT)/1000) + t0;    toffset = (UInt_t)TSYNC - (UInt_t)(this->OBT(OBT)/1000) + t0;
1373    //    //
1374      tsync = TSYNC;
1375      obt0 = OBT;
1376      //
1377    delete result;    delete result;
1378    return(signal);    return(signal);
1379  }  }
# Line 1002  Int_t PamelaDBOperations::insertPamelaRo Line 1389  Int_t PamelaDBOperations::insertPamelaRo
1389    UInt_t idtimesync = 0;    UInt_t idtimesync = 0;
1390    //    //
1391    oss.str("");    oss.str("");
1392    oss << " SELECT COUNT(GL_ROOT.ID_RAW),GL_RAW.ID,GL_ROOT.ID FROM GL_RAW "    if ( STATIC ){
1393        << " LEFT JOIN GL_ROOT "      oss << " SELECT COUNT(GL_ROOT.ID_RAW),GL_RAW.ID,GL_ROOT.ID FROM GL_RAW "
1394        << " ON GL_RAW.ID = GL_ROOT.ID_RAW "          << " LEFT JOIN GL_ROOT "
1395        << " WHERE GL_RAW.PATH = '" << this->GetRawPath().Data() << "' AND "          << " ON GL_RAW.ID = GL_ROOT.ID_RAW "
1396        << " GL_RAW.NAME = '" << this->GetRawFile().Data() << "' GROUP BY GL_RAW.ID ";          << " WHERE GL_RAW.PATH = '" << this->GetRawPath().Data() << "' AND "
1397            << " GL_RAW.NAME = '" << this->GetRawFile().Data() << "' GROUP BY GL_RAW.ID ";
1398      } else {
1399        oss << " SELECT COUNT(GL_ROOT.ID_RAW),GL_RAW.ID,GL_ROOT.ID FROM GL_RAW "
1400            << " LEFT JOIN GL_ROOT "
1401            << " ON GL_RAW.ID = GL_ROOT.ID_RAW "
1402            << " WHERE GL_RAW.PATH = '$PAM_RAW' AND "
1403            << " GL_RAW.NAME = '" << this->GetRawFile().Data() << "' GROUP BY GL_RAW.ID ";
1404      };
1405    result = conn->Query(oss.str().c_str());    result = conn->Query(oss.str().c_str());
1406    //    //
1407    if ( !result ) throw -12;    if ( !result ) throw -12;
# Line 1033  Int_t PamelaDBOperations::insertPamelaRo Line 1428  Int_t PamelaDBOperations::insertPamelaRo
1428    idtimesync = (UInt_t)atoll(row->GetField(0));    idtimesync = (UInt_t)atoll(row->GetField(0));
1429    //    //
1430    oss.str("");    oss.str("");
1431    oss << "INSERT INTO GL_ROOT (ID_RAW, ID_TIMESYNC,PATH, NAME) VALUES ('"    if ( STATIC ){
1432        << this->GetID_RAW() << "', '" << idtimesync << "', '" << this->GetRootPath().Data() << "', '" << this->GetRootFile().Data() << "')";      oss << "INSERT INTO GL_ROOT (ID_RAW, ID_TIMESYNC,PATH, NAME) VALUES ('"
1433            << this->GetID_RAW() << "', '" << idtimesync << "', '" << this->GetRootPath().Data() << "', '" << this->GetRootFile().Data() << "')";
1434      } else {
1435        oss << "INSERT INTO GL_ROOT (ID_RAW, ID_TIMESYNC,PATH, NAME) VALUES ('"
1436            << this->GetID_RAW() << "', '" << idtimesync << "', '$PAM_L0', '" << this->GetRootFile().Data() << "')";
1437      };
1438    //    //
1439    if (conn->Query(oss.str().c_str()) == 0) throw -4;    if (conn->Query(oss.str().c_str()) == 0) throw -4;
1440    //    //
# Line 1061  Int_t PamelaDBOperations::assignBOOT_NUM Line 1461  Int_t PamelaDBOperations::assignBOOT_NUM
1461    TSQLResult *result = 0;    TSQLResult *result = 0;
1462    TSQLRow    *row    = 0;    TSQLRow    *row    = 0;
1463    oss.str("");    oss.str("");
1464    oss << "SELECT ID, BOOT_NUMBER FROM GL_RAW WHERE "    if ( STATIC ){
1465        << " PATH = '" << this->GetRawPath().Data() << "' AND "      oss << "SELECT ID, BOOT_NUMBER FROM GL_RAW WHERE "
1466        << " NAME = '" << this->GetRawFile().Data() << "' ";          << " PATH = '" << this->GetRawPath().Data() << "' AND "
1467            << " NAME = '" << this->GetRawFile().Data() << "' ";
1468      } else {
1469        oss << "SELECT ID, BOOT_NUMBER FROM GL_RAW WHERE "
1470            << " PATH = '$PAM_RAW' AND "
1471            << " NAME = '" << this->GetRawFile().Data() << "' ";
1472      };
1473    result = conn->Query(oss.str().c_str());    result = conn->Query(oss.str().c_str());
1474    //    //
1475    if ( !result ) throw -4;;    if ( !result ) throw -4;;
# Line 1086  Int_t PamelaDBOperations::assignBOOT_NUM Line 1492  Int_t PamelaDBOperations::assignBOOT_NUM
1492    VarDumpEvent  *vde = 0;    VarDumpEvent  *vde = 0;
1493    VarDumpRecord *vdr = 0;    VarDumpRecord *vdr = 0;
1494    //    //
1495      Bool_t found = false;
1496    trDumpEv->SetBranchAddress("VarDump", &vde);    trDumpEv->SetBranchAddress("VarDump", &vde);
1497    if ( trDumpEv->GetEntries() > 0 ){    if ( trDumpEv->GetEntries() > 0 ){
1498      Bool_t found = false;      found = false;
1499      for ( Int_t i = 0; i < trDumpEv->GetEntries(); i++){      for ( Int_t i = 0; i < trDumpEv->GetEntries(); i++){
1500        trDumpEv->GetEntry(i);        trDumpEv->GetEntry(i);
1501        vde->Records->GetEntries();        //      vde->Records->GetEntries();
1502        if ( vde->Records->GetEntries()>0 ){        if ( vde->Records->GetEntries()>5 ){
1503          found = true;          found = true;
1504          goto fill;          goto fill;
1505        };        };
# Line 1105  Int_t PamelaDBOperations::assignBOOT_NUM Line 1512  Int_t PamelaDBOperations::assignBOOT_NUM
1512        this->SetBOOTnumber((Int_t)vdr->VAR_VALUE);        this->SetBOOTnumber((Int_t)vdr->VAR_VALUE);
1513        //        //
1514      } else {      } else {
1515        if ( !this->GetBOOTnumber() ) return(4);        if ( !this->GetBOOTnumber() && !this->AutoBoot()) return(4);
1516        };
1517      } else {
1518        if ( !this->GetBOOTnumber() && !this->AutoBoot()) return(2);
1519      };
1520      //
1521      UInt_t bn = 0;
1522      Bool_t afound = false;
1523      if ( !found && this->AutoBoot()){
1524        afound = true;
1525        //
1526        // Search for other files with similar timesync
1527        //
1528        if ( IsDebug() ) printf(" tsync %u obt0 %u \n",tsync,obt0);
1529        UInt_t upperts = tsync-(obt0/1000)+5;
1530        UInt_t lowerts = tsync-(obt0/1000)-5;
1531        oss.str("");
1532        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)<"
1533            << upperts
1534            << " AND TIMESYNC-(OBT0/1000)>"
1535            << lowerts
1536            << " AND GL_RAW.BOOT_NUMBER>0 GROUP BY GL_TIMESYNC.OBT0;";
1537        result = conn->Query(oss.str().c_str());
1538        if ( IsDebug() ) printf(" Query the GL_TIMESYNC table to find boot number:\n %s \n",oss.str().c_str());
1539        //
1540        if ( !result ) throw -4;;
1541        found = true;
1542        if ( result->GetRowCount()<3 ){
1543          if ( IsDebug() ) printf(" AGH! no results!\n");
1544          found = false;
1545        } else {
1546          row = result->Next();      
1547          bn = (UInt_t)atoll(row->GetField(0));
1548          for ( Int_t r=1; r<result->GetRowCount() ;r++){
1549            if ( !row ) throw -4;
1550            if ( IsDebug() ) printf(" BOOT number is %s \n",row->GetField(0));
1551            if ( bn != (UInt_t)atoll(row->GetField(0)) ){
1552              if ( IsDebug() ) printf(" AGH! bn = %u here instead %u \n",bn,(UInt_t)atoll(row->GetField(0)));
1553              found = false;
1554            };
1555            row = result->Next();
1556          };
1557      };      };
1558      };
1559      //
1560      Int_t sgn = 0;
1561      //
1562      if ( !found && !BOOTNO ){
1563        throw -29;
1564    } else {    } else {
1565      if ( !this->GetBOOTnumber() ) return(2);      if ( afound ){
1566          this->SetBOOTnumber(bn);
1567          sgn = 8;
1568        };
1569    };    };
1570    //    //
1571    oss.str("");    oss.str("");
# Line 1118  Int_t PamelaDBOperations::assignBOOT_NUM Line 1575  Int_t PamelaDBOperations::assignBOOT_NUM
1575    conn->Query(oss.str().c_str());          conn->Query(oss.str().c_str());      
1576    //    //
1577    delete result;    delete result;
1578    return(0);    return(sgn);
1579  };  };
1580    
1581  /**  /**
# Line 1131  Int_t PamelaDBOperations::insertPamelaRU Line 1588  Int_t PamelaDBOperations::insertPamelaRU
1588    stringstream oss;    stringstream oss;
1589    oss.str("");    oss.str("");
1590    //    //
1591    signal = this->SetUpperLimits();    //  signal = this->SetUpperLimits();
1592    //    //
1593    // loop on runheader and runtrailer events    // loop on runheader and runtrailer events
1594    //    //
# Line 1149  Int_t PamelaDBOperations::insertPamelaRU Line 1606  Int_t PamelaDBOperations::insertPamelaRU
1606    rt->SetBranchAddress("RunTrailer", &runt);    rt->SetBranchAddress("RunTrailer", &runt);
1607    rt->SetBranchAddress("Header", &eht);    rt->SetBranchAddress("Header", &eht);
1608    //    //
1609      TTree *T = (TTree*)file->Get("Physics");
1610      if ( !T || T->IsZombie() ) throw -16;
1611      EventHeader *eh = 0;
1612      T->SetBranchAddress("Header", &eh);
1613      //
1614      if ( !(rh->GetEntries()) && !(rt->GetEntries()) && !(T->GetEntries()) ) return(16);
1615      //
1616    UInt_t obtt = 0;    UInt_t obtt = 0;
1617    UInt_t obth = 0;    UInt_t obth = 0;
1618    UInt_t pktt = 0;    UInt_t pktt = 0;
# Line 1182  Int_t PamelaDBOperations::insertPamelaRU Line 1646  Int_t PamelaDBOperations::insertPamelaRU
1646        //        //
1647        if ( !ptt &&  !(ptht+1) ){        if ( !ptt &&  !(ptht+1) ){
1648          //          //
1649          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);
1650          //          //
1651          this->HandleRunFragments(true,false,0,(evbeft-1));          this->HandleRunFragments(true,false,0,(evbeft-1));
1652          //          //
1653          //          //
1654        } else if ( pth == ptht ){        } else if ( pth == ptht ){
1655          //          //
1656          if ( IsDebug() ) printf(" Missing header %i %i %i\n",ptht,pth,ptt);          if ( IsDebug() ) printf(" Missing header %u %u %u\n",ptht,pth,ptt);
1657          //          //
1658          if ( (ptt-1) < 0 ) throw -15; // should never arrive here!          if ( (ptt-1) < 0 ) throw -15; // should never arrive here!
1659          rt->GetEntry(ptt-1);          rt->GetEntry(ptt-1);
# Line 1198  Int_t PamelaDBOperations::insertPamelaRU Line 1662  Int_t PamelaDBOperations::insertPamelaRU
1662          rt->GetEntry(ptt);          rt->GetEntry(ptt);
1663          pht = eht->GetPscuHeader();          pht = eht->GetPscuHeader();
1664          //          //
1665          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);
1666          if ( IsDebug() ) printf(" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''  %i %i %i \n",pkth,obth,obtt);          if ( IsDebug() ) printf(" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''  %u %u %u \n",pkth,obth,obtt);
1667          //          //
1668          this->HandleMissingHoT(true,false,evbefh,evbeft-1);          this->HandleMissingHoT(true,false,evbefh,evbeft-1);
1669          //          //
1670        } else {        } else {
1671          //          //
1672          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);
1673          //          //
1674          rh->GetEntry(ptht);          rh->GetEntry(ptht);
1675          phh = ehh->GetPscuHeader();          phh = ehh->GetPscuHeader();
# Line 1213  Int_t PamelaDBOperations::insertPamelaRU Line 1677  Int_t PamelaDBOperations::insertPamelaRU
1677          obth = phh->GetOrbitalTime();          obth = phh->GetOrbitalTime();
1678          cod = ehh->GetCounter();          cod = ehh->GetCounter();
1679          evbefh = cod->Get(pctp->Physics);          evbefh = cod->Get(pctp->Physics);
1680          if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' %i %i %i \n",pkth,obth,obtt);          if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' %u %u %u \n",pkth,obth,obtt);
1681          //          //
1682          // handle this run          // handle this run
1683          //          //
# Line 1223  Int_t PamelaDBOperations::insertPamelaRU Line 1687  Int_t PamelaDBOperations::insertPamelaRU
1687          //          //
1688          if ( PKT(pkth)>PKT(pktfirst) && OBT(obth)>OBT(obtfirst) && !ptt ){          if ( PKT(pkth)>PKT(pktfirst) && OBT(obth)>OBT(obtfirst) && !ptt ){
1689            //            //
1690            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));  
1691            //            //
1692              if ( evbefh == 0 ) {
1693                //
1694                signal = 8;
1695                if ( IsDebug() ) printf(" Not supported yet: run with no events, no runtrailer, no runheader \n");
1696                //
1697              } else {
1698                //
1699                this->HandleRunFragments(true,true,0,(evbefh-1));
1700                //
1701              };
1702          };          };
1703          //          //
1704          //          //
1705          if ( (ptht - pth) > 1 ){          if ( (ptht - pth) > 1 ){
1706            //            //
1707            if ( IsDebug() ) printf(" Missing runtrailers! \n");            if ( IsDebug() ) printf(" Missing runtrailers! \n");
1708            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);
1709            // is not the consecutive header            // is not the consecutive header
1710            while ( pth != ptht ){                      while ( pth != ptht ){          
1711              //              //
# Line 1254  Int_t PamelaDBOperations::insertPamelaRU Line 1726  Int_t PamelaDBOperations::insertPamelaRU
1726              obth = phh->GetOrbitalTime();              obth = phh->GetOrbitalTime();
1727              evbefh = cod->Get(pctp->Physics);              evbefh = cod->Get(pctp->Physics);
1728              //              //
1729              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);
1730              if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' %i %i %i \n",pkth,obth,obtt);              if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' %u %u %u \n",pkth,obth,obtt);
1731              //              //
1732              this->HandleMissingHoT(false,true,evbefh,evbeft-1);              this->HandleMissingHoT(false,true,evbefh,evbeft-1);
1733              //              //
# Line 1264  Int_t PamelaDBOperations::insertPamelaRU Line 1736  Int_t PamelaDBOperations::insertPamelaRU
1736          } else if ( !(ptht - pth) ){          } else if ( !(ptht - pth) ){
1737            //            //
1738            if ( IsDebug() ) printf(" Missing runheader! \n");            if ( IsDebug() ) printf(" Missing runheader! \n");
1739            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);
1740            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");
1741            //            //
1742          } else {          } else {
# Line 1285  Int_t PamelaDBOperations::insertPamelaRU Line 1757  Int_t PamelaDBOperations::insertPamelaRU
1757            obth = phh->GetOrbitalTime();            obth = phh->GetOrbitalTime();
1758            cod = ehh->GetCounter();            cod = ehh->GetCounter();
1759            evbefh = cod->Get(pctp->Physics);            evbefh = cod->Get(pctp->Physics);
1760            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);
1761            if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''' %i %i %i \n",ptht,pth,ptt);            if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''' %u %u %u \n",ptht,pth,ptt);
1762            if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''' %i \n",rhev);            if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''' %u \n",rhev);
1763            //            //
1764            this->HandleRunFragments(false,true,evbefh,upperentry);            this->HandleRunFragments(false,true,evbefh,upperentry);
1765          } else {          } else {
# Line 1335  Bool_t PamelaDBOperations::IsRunAlreadyI Line 1807  Bool_t PamelaDBOperations::IsRunAlreadyI
1807    //                                  ( runhead_time <= _our_runhead_time &&  runtrail_time >= _our_runtrail_time) &&    //                                  ( runhead_time <= _our_runhead_time &&  runtrail_time >= _our_runtrail_time) &&
1808    //                                  ( runhead_obt <= _our_runheadobt || runhead_pkt <= _our_runheadpkt ) &&    //                                  ( runhead_obt <= _our_runheadobt || runhead_pkt <= _our_runheadpkt ) &&
1809    //                                  ( runtrail_obt <= _our_runtrailobt || runtrail_pkt <= _our_runtrailpkt ) )    //                                  ( runtrail_obt <= _our_runtrailobt || runtrail_pkt <= _our_runtrailpkt ) )
1810      //                                  ||
1811      //                                  ( runhead_time = _our_runhead_time &&  runtrail_time = _our_runtrail_time && nevents > 100 )
1812      //                                  )
1813      //                                  ||
1814      //                                  ( runhead_time = _our_runhead_time &&  runtrail_time > _our_runtrail_time && nevents > 100 )
1815      //                                  )
1816      //                                  ||
1817      //                                  ( runhead_time < _our_runhead_time &&  runtrail_time = _our_runtrail_time && nevents > 100 )
1818    //                                  )    //                                  )
1819    //    //
1820    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 1350  Bool_t PamelaDBOperations::IsRunAlreadyI Line 1830  Bool_t PamelaDBOperations::IsRunAlreadyI
1830        << " RUNHEADER_OBT<=" << glrun->GetRUNHEADER_OBT() << " OR "        << " RUNHEADER_OBT<=" << glrun->GetRUNHEADER_OBT() << " OR "
1831        << " RUNHEADER_PKT<=" << glrun->GetRUNHEADER_PKT() << ") AND ("        << " RUNHEADER_PKT<=" << glrun->GetRUNHEADER_PKT() << ") AND ("
1832        << " RUNTRAILER_OBT>=" << glrun->GetRUNTRAILER_OBT() << " OR "        << " RUNTRAILER_OBT>=" << glrun->GetRUNTRAILER_OBT() << " OR "
1833        << " RUNTRAILER_PKT>=" << glrun->GetRUNTRAILER_PKT() << ") ));";        << " RUNTRAILER_PKT>=" << glrun->GetRUNTRAILER_PKT() << ") OR "
1834          << " (RUNHEADER_TIME=" << (UInt_t)glrun->GetRUNHEADER_TIME() << " AND "                //  these two lines in a certain way disable the patch below...
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) OR"    //
1838          << " (RUNHEADER_TIME<" << (UInt_t)glrun->GetRUNHEADER_TIME() << " AND "                //
1839          << " RUNTRAILER_TIME=" << (UInt_t)glrun->GetRUNTRAILER_TIME() <<" AND NEVENTS>100)"    //
1840          << " ));";
1841    //    //
1842    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());
1843    result = conn->Query(oss.str().c_str());    result = conn->Query(oss.str().c_str());
# Line 1372  Bool_t PamelaDBOperations::IsRunAlreadyI Line 1859  Bool_t PamelaDBOperations::IsRunAlreadyI
1859      //      //
1860      // the run has already been inserted      // the run has already been inserted
1861      //      //
1862      //    return(true);  //<<<<<<<<<<<<<<<<<<<<<<<< patch follows, uncomment here      if ( signal && IsDebug() ) printf(" The run has already been inserted \n");    
1863        return(true);  //<<<<<<<<<<<<<<<<<<<<<<<< patch follows, uncomment here
1864      //      //
1865      // PATCH!      // PATCH!
1866      // 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 1381  Bool_t PamelaDBOperations::IsRunAlreadyI Line 1869  Bool_t PamelaDBOperations::IsRunAlreadyI
1869      if ( glrun->GetNEVENTS() > (UInt_t)atoll(row->GetField(1)) ){      if ( glrun->GetNEVENTS() > (UInt_t)atoll(row->GetField(1)) ){
1870        //        //
1871        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");
1872        oss.str("");        glrun->DeleteRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN");
1873        oss << "DELETE FROM GL_RUN WHERE ID=" << row->GetField(0) <<";";  //       oss.str("");
1874        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) <<";";
1875        conn->Query(oss.str().c_str());  //       if ( IsDebug() ) printf(" delete the run entry: query is \n %s \n",oss.str().c_str());      
1876    //       conn->Query(oss.str().c_str());
1877        if ( signal ) signal = false;        if ( signal ) signal = false;
1878        goto gonext;              goto gonext;      
1879        //        //
# Line 1398  Bool_t PamelaDBOperations::IsRunAlreadyI Line 1887  Bool_t PamelaDBOperations::IsRunAlreadyI
1887        //        //
1888        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");
1889        //        //
1890        oss.str("");        glrun->DeleteRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN");
1891        oss << "DELETE FROM GL_RUN WHERE ID=" << row->GetField(0) <<";";  //       oss.str("");
1892        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) <<";";
1893        conn->Query(oss.str().c_str());  //       if ( IsDebug() ) printf(" delete the run entry: query is \n %s \n",oss.str().c_str());      
1894    //       conn->Query(oss.str().c_str());
1895        //        //
1896        if ( signal ) signal = false;        if ( signal ) signal = false;
1897        goto gonext;        goto gonext;
# Line 1415  Bool_t PamelaDBOperations::IsRunAlreadyI Line 1905  Bool_t PamelaDBOperations::IsRunAlreadyI
1905        //        //
1906        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");
1907        //        //
1908        oss.str("");        glrun->DeleteRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN");
1909        oss << "DELETE FROM GL_RUN WHERE ID=" << row->GetField(0) <<";";  //       oss.str("");
1910        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) <<";";
1911        conn->Query(oss.str().c_str());  //       if ( IsDebug() ) printf(" delete the run entry: query is \n %s \n",oss.str().c_str());      
1912    //       conn->Query(oss.str().c_str());
1913        if ( signal ) signal = false;        if ( signal ) signal = false;
1914        //        //
1915      };      };
# Line 1433  Bool_t PamelaDBOperations::IsRunAlreadyI Line 1924  Bool_t PamelaDBOperations::IsRunAlreadyI
1924    delete result;    delete result;
1925    //    //
1926    if ( signal && IsDebug() ) printf(" The run has already been inserted \n");        if ( signal && IsDebug() ) printf(" The run has already been inserted \n");    
1927      if ( !signal && IsDebug() ) printf(" The run existed and was deleted, fill the DB \n");
1928    return(signal);    return(signal);
1929  };  };
1930    
# Line 1454  void PamelaDBOperations::HandleRun(){   Line 1946  void PamelaDBOperations::HandleRun(){  
1946      //      //
1947      this->FillClass();      this->FillClass();
1948      //      //
1949      if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);      if ( !IsRunAlreadyInserted() ){
1950          glrun->SetID(this->AssignRunID());
1951          glrun->SetID_RUN_FRAG(0);
1952          glrun->Fill_GL_RUN(conn);
1953        };
1954    } else {    } else {
1955      //      //
1956      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 1477  void PamelaDBOperations::HandleRunFragme Line 1973  void PamelaDBOperations::HandleRunFragme
1973    UInt_t rhfirstev = firstev;    UInt_t rhfirstev = firstev;
1974    UInt_t rtlastev = lastev;    UInt_t rtlastev = lastev;
1975    Bool_t found = false;    Bool_t found = false;
1976      Bool_t foundinrun = false;
1977    //    //
1978    TSQLResult *result = 0;    TSQLResult *result = 0;
1979    TSQLRow    *row    = 0;    TSQLRow    *row    = 0;
# Line 1503  void PamelaDBOperations::HandleRunFragme Line 2000  void PamelaDBOperations::HandleRunFragme
2000    //    //
2001    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");
2002    //    //
2003      // First of all insert the run in the fragment table...
2004      //
2005      oss.str("");
2006      oss << " SELECT ID FROM GL_RUN_FRAGMENTS WHERE "
2007          << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND ("
2008          << " (RUNHEADER_TIME>=" << (UInt_t)(glrun->GetRUNHEADER_TIME()-10) << " AND "
2009          << " RUNTRAILER_TIME<=" << (UInt_t)(glrun->GetRUNTRAILER_TIME()+10) << " AND ("
2010          << " RUNHEADER_OBT>=" << glrun->GetRUNHEADER_OBT() << " OR "
2011          << " RUNHEADER_PKT>=" << glrun->GetRUNHEADER_PKT() << ") AND ("
2012          << " RUNTRAILER_OBT<=" << glrun->GetRUNTRAILER_OBT() << " OR "
2013          << " RUNTRAILER_PKT<=" << glrun->GetRUNTRAILER_PKT() << ") ) OR "
2014          << " (RUNHEADER_TIME<=" << (UInt_t)glrun->GetRUNHEADER_TIME() << " AND "
2015          << " RUNTRAILER_TIME>=" << (UInt_t)glrun->GetRUNTRAILER_TIME() <<" AND ("
2016          << " RUNHEADER_OBT<=" << glrun->GetRUNHEADER_OBT() << " OR "
2017          << " RUNHEADER_PKT<=" << glrun->GetRUNHEADER_PKT() << ") AND ("
2018          << " RUNTRAILER_OBT>=" << glrun->GetRUNTRAILER_OBT() << " OR "
2019          << " RUNTRAILER_PKT>=" << glrun->GetRUNTRAILER_PKT() << ") ));";
2020      //
2021      if ( IsDebug() ) printf(" check if run has been inserted: query is \n %s \n",oss.str().c_str());
2022      result = conn->Query(oss.str().c_str());
2023      //
2024      if ( !result ) throw -4;
2025      //
2026      row = result->Next();
2027      //
2028      if ( !row ){
2029        //
2030        // no, insert this run in the GL_RUN_FRAGMENTS table (check if exist before!)
2031        //
2032        if ( IsDebug() ) printf(" The run is new \n");
2033        if ( IsDebug() ) printf(" -> fill the GL_RUNFRAGMENTS table \n");
2034        //
2035        glrun->SetID(this->AssignRunID());
2036        glrun->SetID_RUN_FRAG(0);
2037        glrun->Fill_GL_RUN_FRAGMENTS(conn);
2038        //
2039      } else {
2040        if ( IsDebug() ) printf(" The run is already present in the fragment table \n");
2041        return;
2042      };
2043      //
2044      //
2045    // 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?
2046    //        //    
2047    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 1511  void PamelaDBOperations::HandleRunFragme Line 2050  void PamelaDBOperations::HandleRunFragme
2050      oss.str("");      oss.str("");
2051      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 "
2052          << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND "          << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND "
2053          << " RUNHEADER_TIME <= " << (UInt_t)glrun->GetRUNHEADER_TIME()          << " RUNHEADER_TIME <= " << (UInt_t)glrun->GetRUNHEADER_TIME() << " AND "
2054            << " ID != " << glrun->ID
2055          << " ORDER BY RUNHEADER_TIME DESC LIMIT 1;"; // DESC NOT ASC!!          << " ORDER BY RUNHEADER_TIME DESC LIMIT 1;"; // DESC NOT ASC!!
2056      //      //
2057      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 1521  void PamelaDBOperations::HandleRunFragme Line 2061  void PamelaDBOperations::HandleRunFragme
2061      //      //
2062      row = result->Next();      row = result->Next();
2063      //      //
2064        if ( !row && NoFrag() ){
2065          //
2066          oss.str("");
2067          oss << " SELECT ID,TRK_CALIB_USED,RUNTRAILER_TIME,RUNTRAILER_OBT,RUNHEADER_PKT,RUNTRAILER_PKT FROM GL_RUN WHERE "
2068              << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND "
2069              << " RUNHEADER_TIME <= " << (UInt_t)glrun->GetRUNHEADER_TIME() << " AND "
2070              << " ID != " << glrun->ID
2071              << " AND ID=ID_RUN_FRAG ORDER BY RUNHEADER_TIME DESC LIMIT 1;"; // DESC NOT ASC!!
2072          //
2073          if ( IsDebug() ) printf(" look for runheader in the GL_RUN table: query is \n %s \n",oss.str().c_str());
2074          result = conn->Query(oss.str().c_str());
2075          //
2076          if ( !result ) throw -4;
2077          //
2078          foundinrun = true;
2079          //
2080          row = result->Next();
2081          //
2082        };
2083        //
2084      if ( !row ){      if ( !row ){
2085        if ( IsDebug() ) printf(" the corresponding piece has NOT been found \n");        if ( IsDebug() ) printf(" the corresponding piece has NOT been found \n");
2086        found = false;        found = false;
# Line 1595  void PamelaDBOperations::HandleRunFragme Line 2155  void PamelaDBOperations::HandleRunFragme
2155        //        //
2156        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 ");
2157        //        //
2158          if ( foundinrun ){
2159            glrun->RestoreRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN_FRAGMENTS");
2160            glrun->DeleteRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN");
2161          };
2162          //
2163        GL_RUN *glrun1 = new GL_RUN();        GL_RUN *glrun1 = new GL_RUN();
2164        //        //
2165        UInt_t idfrag = (UInt_t)atoll(row->GetField(0));        //      UInt_t idfrag = (UInt_t)atoll(row->GetField(0));
2166        //        //
2167        oss.str("");        oss.str("");
2168        oss << " ID="<<row->GetField(0)<<";";        oss << " ID="<<row->GetField(0)<<";";
# Line 1610  void PamelaDBOperations::HandleRunFragme Line 2175  void PamelaDBOperations::HandleRunFragme
2175        ULong64_t aobt = OBT(glrun1->GetRUNTRAILER_OBT());        ULong64_t aobt = OBT(glrun1->GetRUNTRAILER_OBT());
2176        UInt_t bpkt = PKT(glrun->GetRUNHEADER_PKT());        UInt_t bpkt = PKT(glrun->GetRUNHEADER_PKT());
2177        ULong64_t bobt = OBT(glrun->GetRUNHEADER_OBT());        ULong64_t bobt = OBT(glrun->GetRUNHEADER_OBT());
2178        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);
2179        TTree *T= 0;        TTree *T= 0;
2180        T = (TTree*)file->Get("Physics");        T = (TTree*)file->Get("Physics");
2181        if ( !T || T->IsZombie() ) throw -16;        if ( !T || T->IsZombie() ) throw -16;
# Line 1624  void PamelaDBOperations::HandleRunFragme Line 2189  void PamelaDBOperations::HandleRunFragme
2189          bobt = OBT(ph->GetOrbitalTime());                bobt = OBT(ph->GetOrbitalTime());      
2190          firstev++;          firstev++;
2191        };        };
2192        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);
2193        //        //
       glrun1->SetID(0);  
2194        glrun1->SetPKT_COUNTER(glrun->GetPKT_COUNTER());        glrun1->SetPKT_COUNTER(glrun->GetPKT_COUNTER());
2195        glrun1->SetPKT_READY_COUNTER(glrun->GetPKT_READY_COUNTER());        glrun1->SetPKT_READY_COUNTER(glrun->GetPKT_READY_COUNTER());
2196        glrun1->SetRUNTRAILER_TIME(glrun->GetRUNTRAILER_TIME());        glrun1->SetRUNTRAILER_TIME(glrun->GetRUNTRAILER_TIME());
# Line 1635  void PamelaDBOperations::HandleRunFragme Line 2199  void PamelaDBOperations::HandleRunFragme
2199        //        //
2200        glrun->SetEV_FROM(firstev);        glrun->SetEV_FROM(firstev);
2201        glrun->SetNEVENTS(lastev-firstev+1);        glrun->SetNEVENTS(lastev-firstev+1);
2202          //
2203        glrun->SetRUNHEADER_TIME(glrun1->GetRUNHEADER_TIME());        glrun->SetRUNHEADER_TIME(glrun1->GetRUNHEADER_TIME());
2204        glrun->SetRUNHEADER_OBT(glrun1->GetRUNHEADER_OBT());        glrun->SetRUNHEADER_OBT(glrun1->GetRUNHEADER_OBT());
2205        glrun->SetRUNHEADER_PKT(glrun1->GetRUNHEADER_PKT());        glrun->SetRUNHEADER_PKT(glrun1->GetRUNHEADER_PKT());
# Line 1654  void PamelaDBOperations::HandleRunFragme Line 2219  void PamelaDBOperations::HandleRunFragme
2219        //        //
2220        if ( !IsRunAlreadyInserted() ){        if ( !IsRunAlreadyInserted() ){
2221          //          //
2222            //      glrun->SetID(this->AssignRunID());
2223            glrun->SetID_RUN_FRAG(glrun1->GetID());
2224          glrun->Fill_GL_RUN(conn);          glrun->Fill_GL_RUN(conn);
2225          //          //
2226          // 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);  
2227          //          //
2228            glrun1->SetID_RUN_FRAG(glrun->GetID());
2229          glrun1->Fill_GL_RUN(conn);          glrun1->Fill_GL_RUN(conn);
2230          //          //
         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;  
         //  
2231        };        };
       //  
       delete glrun1;  
       //  
2232        // delete old entry in fragment table        // delete old entry in fragment table
2233        //        //
2234        oss.str("");        glrun->DeleteRun(conn,0,"GL_RUN_FRAGMENTS");
2235          glrun1->DeleteRun(conn,0,"GL_RUN_FRAGMENTS");
2236        //        //
2237        oss << " DELETE FROM GL_RUN_FRAGMENTS WHERE ID = " << idfrag << ";";        delete glrun1;
2238        //        //
       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;  
2239        //        //
2240        return;        return;
2241        //        //
# Line 1723  void PamelaDBOperations::HandleRunFragme Line 2244  void PamelaDBOperations::HandleRunFragme
2244    };    };
2245    //    //
2246    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
2247                                             // 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
2248      //      //
2249      oss.str("");      oss.str("");
2250      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 "
2251          << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND "          << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND "
2252          << " RUNTRAILER_TIME >= " << (UInt_t)glrun->GetRUNTRAILER_TIME()          << " RUNTRAILER_TIME >= " << (UInt_t)glrun->GetRUNTRAILER_TIME() << " AND "
2253            << " ID != " << glrun->ID
2254          << " ORDER BY RUNTRAILER_TIME ASC LIMIT 1;";          << " ORDER BY RUNTRAILER_TIME ASC LIMIT 1;";
2255      //      //
2256      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 1738  void PamelaDBOperations::HandleRunFragme Line 2260  void PamelaDBOperations::HandleRunFragme
2260      //      //
2261      row = result->Next();      row = result->Next();
2262      //      //
2263        if ( !row && NoFrag() ){
2264          //
2265          oss.str("");
2266          oss << " SELECT ID,PKT_COUNTER,RUNHEADER_TIME,RUNHEADER_OBT,RUNTRAILER_PKT,RUNHEADER_PKT FROM GL_RUN WHERE "
2267              << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND "
2268              << " RUNTRAILER_TIME >= " << (UInt_t)glrun->GetRUNTRAILER_TIME() << " AND "
2269              << " ID != " << glrun->ID
2270              << " AND ID=ID_RUN_FRAG ORDER BY RUNTRAILER_TIME ASC LIMIT 1;";
2271          //
2272          if ( IsDebug() ) printf(" look for runheader in the GL_RUN table: query is \n %s \n",oss.str().c_str());
2273          result = conn->Query(oss.str().c_str());
2274          //
2275          if ( !result ) throw -4;
2276          //
2277          foundinrun = true;
2278          row = result->Next();
2279          //
2280        };
2281        //
2282      if ( !row ){      if ( !row ){
2283        if ( IsDebug() ) printf(" the corresponding piece has NOT been found \n");        if ( IsDebug() ) printf(" the corresponding piece has NOT been found \n");
2284        found = false;        found = false;
# Line 1811  void PamelaDBOperations::HandleRunFragme Line 2352  void PamelaDBOperations::HandleRunFragme
2352        //        //
2353        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 ");
2354        //        //
2355          if ( foundinrun ){
2356            glrun->RestoreRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN_FRAGMENTS");
2357            glrun->DeleteRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN");
2358          };
2359          //
2360        GL_RUN *glrun1 = new GL_RUN();        GL_RUN *glrun1 = new GL_RUN();
2361        //        //
2362        UInt_t idfrag = (UInt_t)atoll(row->GetField(0));        //      UInt_t idfrag = (UInt_t)atoll(row->GetField(0));
2363        //        //
2364        oss.str("");        oss.str("");
2365        oss << " ID="<<row->GetField(0)<<";";        oss << " ID="<<row->GetField(0)<<";";
# Line 1826  void PamelaDBOperations::HandleRunFragme Line 2372  void PamelaDBOperations::HandleRunFragme
2372        ULong64_t aobt = OBT(glrun->GetRUNTRAILER_OBT());        ULong64_t aobt = OBT(glrun->GetRUNTRAILER_OBT());
2373        UInt_t bpkt = PKT(glrun1->GetRUNHEADER_PKT());        UInt_t bpkt = PKT(glrun1->GetRUNHEADER_PKT());
2374        ULong64_t bobt = OBT(glrun1->GetRUNHEADER_OBT());        ULong64_t bobt = OBT(glrun1->GetRUNHEADER_OBT());
2375        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);
2376        TTree *T= 0;        TTree *T= 0;
2377        T = (TTree*)file->Get("Physics");        T = (TTree*)file->Get("Physics");
2378        if ( !T || T->IsZombie() ) throw -16;        if ( !T || T->IsZombie() ) throw -16;
# Line 1840  void PamelaDBOperations::HandleRunFragme Line 2386  void PamelaDBOperations::HandleRunFragme
2386          aobt = OBT(ph->GetOrbitalTime());                aobt = OBT(ph->GetOrbitalTime());      
2387          lastev--;          lastev--;
2388        };        };
2389        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);
2390        //        //
2391        glrun->SetEV_TO(lastev);        glrun->SetEV_TO(lastev);
2392        glrun->SetNEVENTS(lastev-firstev+1);        glrun->SetNEVENTS(lastev-firstev+1);
# Line 1850  void PamelaDBOperations::HandleRunFragme Line 2396  void PamelaDBOperations::HandleRunFragme
2396        glrun->SetRUNTRAILER_OBT(glrun1->GetRUNTRAILER_OBT());        glrun->SetRUNTRAILER_OBT(glrun1->GetRUNTRAILER_OBT());
2397        glrun->SetRUNTRAILER_PKT(glrun1->GetRUNTRAILER_PKT());        glrun->SetRUNTRAILER_PKT(glrun1->GetRUNTRAILER_PKT());
2398        //        //
       glrun1->SetID(0);  
2399        glrun1->SetRUNHEADER_TIME(glrun->GetRUNHEADER_TIME());        glrun1->SetRUNHEADER_TIME(glrun->GetRUNHEADER_TIME());
2400        glrun1->SetRUNHEADER_OBT(glrun->GetRUNHEADER_OBT());        glrun1->SetRUNHEADER_OBT(glrun->GetRUNHEADER_OBT());
2401        glrun1->SetRUNHEADER_PKT(glrun->GetRUNHEADER_PKT());        glrun1->SetRUNHEADER_PKT(glrun->GetRUNHEADER_PKT());
# Line 1870  void PamelaDBOperations::HandleRunFragme Line 2415  void PamelaDBOperations::HandleRunFragme
2415        //        //
2416        if ( !IsRunAlreadyInserted() ){        if ( !IsRunAlreadyInserted() ){
2417          //          //
2418          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());  
2419          //          //
2420          result =  conn->Query(oss.str().c_str());          glrun->SetID_RUN_FRAG(glrun1->GetID());
2421          if ( !result ) throw -4;          glrun->Fill_GL_RUN(conn);
         row = result->Next();  
         //  
         UInt_t idrun0 = 0;  
         if ( !row ){  
           throw -10;  
         } else {  
           idrun0 = (UInt_t)atoll(row->GetField(0));  
         };  
2422          //          //
2423          glrun1->SetID_RUN_FRAG(idrun0);          // set id number
2424          //          //
2425            glrun1->SetID_RUN_FRAG(glrun->GetID());
2426          glrun1->Fill_GL_RUN(conn);          glrun1->Fill_GL_RUN(conn);
2427          //          //
         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;  
         //  
2428        };        };
2429        //        //
2430        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 << ";";  
2431        //        //
2432        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");
2433        result =  conn->Query(oss.str().c_str());        glrun1->DeleteRun(conn,0,"GL_RUN_FRAGMENTS");
       if ( !result ) throw -4;  
2434        //        //
2435          delete glrun1;
2436        //        //
2437        return;        return;
2438        //        //
# Line 1968  void PamelaDBOperations::HandleRunFragme Line 2469  void PamelaDBOperations::HandleRunFragme
2469      //      //
2470      row = result->Next();      row = result->Next();
2471      //      //
2472      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 {  
2473        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");
2474        } else {
2475          if ( NoFrag() ){
2476            glrun->SetID_RUN_FRAG(glrun->GetID());
2477            glrun->Fill_GL_RUN(conn);      
2478            glrun->DeleteRun(conn,0,"GL_RUN_FRAGMENTS");
2479          };    
2480      };      };
2481    };    };
2482    //    //
# Line 2032  void PamelaDBOperations::HandleMissingHo Line 2502  void PamelaDBOperations::HandleMissingHo
2502      //      //
2503      this->FillClass(mishead,mistrail,firstev,lastev);      this->FillClass(mishead,mistrail,firstev,lastev);
2504      //      //
2505      if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);          if ( !IsRunAlreadyInserted() ){
2506          glrun->SetID(this->AssignRunID());
2507          glrun->SetID_RUN_FRAG(0);
2508          glrun->Fill_GL_RUN(conn);    
2509        };
2510      //      //
2511    };    };
2512    //    //
# Line 2199  Bool_t PamelaDBOperations::IsRunConsiste Line 2673  Bool_t PamelaDBOperations::IsRunConsiste
2673            //                  //      
2674            this->SetCommonGLRUN(firstTime,lastTime);            this->SetCommonGLRUN(firstTime,lastTime);
2675            //            //
2676            if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);                  if ( !IsRunAlreadyInserted() ){
2677                glrun->SetID(this->AssignRunID());
2678                glrun->SetID_RUN_FRAG(0);
2679                glrun->Fill_GL_RUN(conn);      
2680              };
2681            //            //
2682            firstevno = lastentry + 1;            firstevno = lastentry + 1;
2683            //            //
# Line 2275  void PamelaDBOperations::HandleSuspiciou Line 2753  void PamelaDBOperations::HandleSuspiciou
2753      if ( IsDebug() ) printf(" Checking but no events in the run! \n");      if ( IsDebug() ) printf(" Checking but no events in the run! \n");
2754      //      //
2755      this->FillClass();      this->FillClass();
2756      if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);          if ( !IsRunAlreadyInserted() ){
2757          glrun->SetID(this->AssignRunID());
2758          glrun->SetID_RUN_FRAG(0);
2759          glrun->Fill_GL_RUN(conn);    
2760        };
2761      //      //
2762    } else {    } else {
2763      //      //
# Line 2303  void PamelaDBOperations::HandleSuspiciou Line 2785  void PamelaDBOperations::HandleSuspiciou
2785        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");
2786        //        //
2787        this->FillClass();        this->FillClass();
2788        if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);                if ( !IsRunAlreadyInserted() ){
2789            glrun->SetID(this->AssignRunID());
2790            glrun->SetID_RUN_FRAG(0);
2791            glrun->Fill_GL_RUN(conn);        
2792          };
2793        //        //
2794      } else {      } else {
2795        //        //
# Line 2401  void PamelaDBOperations::HandleSuspiciou Line 2887  void PamelaDBOperations::HandleSuspiciou
2887            //                  //      
2888            this->SetCommonGLRUN(firstTime,lastTime);            this->SetCommonGLRUN(firstTime,lastTime);
2889            //            //
2890            if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);                  if ( !IsRunAlreadyInserted() ){
2891                glrun->SetID(this->AssignRunID());
2892                glrun->SetID_RUN_FRAG(0);
2893                glrun->Fill_GL_RUN(conn);      
2894              };
2895            //            //
2896            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...
2897              //              //
# Line 2436  void PamelaDBOperations::HandleSuspiciou Line 2926  void PamelaDBOperations::HandleSuspiciou
2926              //                  //    
2927              this->SetCommonGLRUN(firstTime,lastTime);              this->SetCommonGLRUN(firstTime,lastTime);
2928              //              //
2929              if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);                    if ( !IsRunAlreadyInserted() ){
2930                  glrun->SetID(this->AssignRunID());
2931                  glrun->SetID_RUN_FRAG(0);
2932                  glrun->Fill_GL_RUN(conn);      
2933                };
2934            };            };
2935            //            //
2936            firstevno = lastentry + 1;            firstevno = lastentry + 1;
# Line 2499  Int_t PamelaDBOperations::insertCALO_CAL Line 2993  Int_t PamelaDBOperations::insertCALO_CAL
2993          fromtime = this->GetAbsTime(ph->GetOrbitalTime());            fromtime = this->GetAbsTime(ph->GetOrbitalTime());  
2994          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) ){
2995            //            //
2996            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);
2997            //            //
2998            // check if the calibration has already been inserted            // check if the calibration has already been inserted
2999            //            //
# Line 2543  Int_t PamelaDBOperations::insertCALO_CAL Line 3037  Int_t PamelaDBOperations::insertCALO_CAL
3037                // no calibrations in the db contain our calibration                // no calibrations in the db contain our calibration
3038                //                //
3039                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);
3040                if ( fromtime < 1150863400 ){                if ( fromtime < 1150871000 ){ //1150866904
3041                  if ( IsDebug() ) printf(" First PAMELA flight calibration at time %i \n",fromtime);                  if ( IsDebug() ) printf(" First PAMELA flight calibration at time %u \n",fromtime);
3042                  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
3043                };                };
3044                //                //
# Line 2606  Int_t PamelaDBOperations::insertCALO_CAL Line 3100  Int_t PamelaDBOperations::insertCALO_CAL
3100            //            //
3101          } else {          } else {
3102            //            //
3103            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);
3104            //            //
3105          };                };      
3106          //                //      
# Line 2617  Int_t PamelaDBOperations::insertCALO_CAL Line 3111  Int_t PamelaDBOperations::insertCALO_CAL
3111    return(0);    return(0);
3112  };  };
3113    
3114    
3115  /**  /**
3116   * Fill the GL_TRK_CALIB table   * Scan calorimeter calibrations packets, fill the GL_CALO_CALIB table
3117   */   */
3118  void PamelaDBOperations::HandleTRK_CALIB(Bool_t pk1, Bool_t pk2){  Int_t PamelaDBOperations::insertCALOPULSE_CALIB(){
3119    //    //
3120    TSQLResult *result = 0;    TSQLResult *result = 0;
3121    TSQLRow    *row    = 0;    TSQLRow    *row    = 0;
# Line 2628  void PamelaDBOperations::HandleTRK_CALIB Line 3123  void PamelaDBOperations::HandleTRK_CALIB
3123    stringstream oss;    stringstream oss;
3124    oss.str("");    oss.str("");
3125    //    //
3126    UInt_t totime = 0;    oss << " DESCRIBE GL_CALOPULSE_CALIB;";
3127      if ( IsDebug() ) printf(" Check if the GL_CALOPULSE_CALIB table exists: query is \n %s \n",oss.str().c_str());
3128      result = conn->Query(oss.str().c_str());
3129    //    //
3130    if ( !pk1 && !pk2 ){    if ( conn->GetErrorCode() ){
3131      if ( IsDebug() ) printf(" Cannot handle trk calibration with both packet missing!\n");      if ( IsDebug() ) printf(" The GL_CALOPULSE_CALIB table does not exists! \n");
3132        throw -30;
3133    };    };
3134    //    //
3135    // check if the calibration has already been inserted    // CaloPulse1
3136    //    //
3137    oss.str("");    CalibCalPulse1Event *cp1 = 0;
3138      TTree *tr = 0;
3139      EventHeader *eh = 0;
3140      PscuHeader *ph = 0;
3141      //
3142      UInt_t nevents = 0;
3143      UInt_t fromtime = 0;
3144      UInt_t totime = 0;
3145      UInt_t obt = 0;
3146      UInt_t pkt = 0;
3147      //
3148      tr = (TTree*)file->Get("CalibCalPulse1");
3149      if ( !tr || tr->IsZombie() ) throw -31;
3150      //
3151      tr->SetBranchAddress("CalibCalPulse1", &cp1);
3152      tr->SetBranchAddress("Header", &eh);
3153      nevents = tr->GetEntries();
3154      //
3155      if ( nevents > 0 ){
3156        //
3157        for (UInt_t i=0; i < nevents; i++){
3158          tr->GetEntry(i);
3159          for (UInt_t section = 0; section < 4; section++){
3160            //
3161            if ( cp1->pstwerr[section] && cp1->unpackError == 0 ){
3162              valid = 1;
3163              if ( cp1->pperror[section] ) valid = 0;
3164              ph = eh->GetPscuHeader();
3165              obt = ph->GetOrbitalTime();  
3166              pkt = ph->GetCounter();  
3167              fromtime = this->GetAbsTime(ph->GetOrbitalTime());  
3168              if ( this->PKT(pkt) >= this->PKT(pktfirst) && this->OBT(obt) >= this->OBT(obtfirst) ){
3169                //
3170                if ( IsDebug() ) printf(" Calo pulse1 calibration for section %i at time %u obt %u pkt %u \n",section,fromtime,obt,pkt);
3171                //
3172                // check if the calibration has already been inserted
3173                //
3174                oss.str("");
3175                oss << " SELECT ID FROM GL_CALOPULSE_CALIB WHERE "
3176                    << " SECTION = "<< section << " AND "
3177                    << " PULSE_AMPLITUDE = 0 AND "
3178                    << " BOOT_NUMBER = "<< this->GetBOOTnumber() << " AND "
3179                    << " OBT = "<< obt << " AND "
3180                    << " PKT = "<< pkt << ";";
3181                //
3182                if ( IsDebug() ) printf(" Check if the calo pulse1 calibration has already been inserted: query is \n %s \n",oss.str().c_str());
3183                result = conn->Query(oss.str().c_str());
3184                //
3185                if ( !result ) throw -4;
3186                //
3187                row = result->Next();
3188                //
3189                if ( row ){
3190                  //
3191                  if ( IsDebug() ) printf(" Calo pulse1 calibration already inserted in the DB\n");
3192                  //
3193                } else {
3194                  //
3195                  // we have to insert a new calibration, check where to place it
3196                  //
3197                  oss.str("");
3198                  oss << " SELECT ID,TO_TIME FROM GL_CALOPULSE_CALIB WHERE "
3199                      << " SECTION = "<< section << " AND "
3200                      << " PULSE_AMPLITUDE = 0 AND "
3201                      << " SECTION = "<< section << " AND "
3202                      << " FROM_TIME < "<< fromtime << " AND "
3203                      << " TO_TIME > "<< fromtime << ";";
3204                  //
3205                  if ( IsDebug() ) printf(" Check where to place the pulse1 calo calibration: query is \n %s \n",oss.str().c_str());
3206                  result = conn->Query(oss.str().c_str());
3207                  //
3208                  if ( !result ) throw -4;
3209                  //
3210                  row = result->Next();
3211                  //
3212                  if ( !row ){
3213                    //
3214                    // no calibrations in the db contain our calibration
3215                    //
3216                    if ( IsDebug() ) printf(" Pulse1 calibration with fromtime lower than others to be inserted in the DB for section %i \n",section);
3217                    if ( fromtime < 1150871000 ){ //1150866904
3218                      if ( IsDebug() ) printf(" First PAMELA flight calibration at time %u \n",fromtime);
3219                      fromtime = 0;// the first flight calibration was taken at about  1156429100 s, this line allow to analyze first runs in raw mode
3220                    };
3221                    //
3222                    oss.str("");
3223                    oss << " SELECT FROM_TIME FROM GL_CALOPULSE_CALIB WHERE "
3224                        << " PULSE_AMPLITUDE = 0 AND "
3225                        << " SECTION = "<< section << " AND "
3226                        << " FROM_TIME > "<< fromtime << " ORDER BY FROM_TIME ASC LIMIT 1;";
3227                    //
3228                    if ( IsDebug() ) printf(" Check the upper limit for pulse1 calibration: query is \n %s \n",oss.str().c_str());
3229                    result = conn->Query(oss.str().c_str());
3230                    //
3231                    if ( !result ) throw -4;
3232                    //
3233                    row = result->Next();
3234                    if ( !row ){
3235                      totime = numeric_limits<UInt_t>::max();
3236                    } else {
3237                      totime = (UInt_t)atoll(row->GetField(0));
3238                    };
3239                    //
3240                  } else {
3241                    //
3242                    // determine upper and lower limits and make space for the new calibration
3243                    //
3244                    totime = (UInt_t)atoll(row->GetField(1));
3245                    //
3246                    oss.str("");
3247                    oss << " UPDATE GL_CALOPULSE_CALIB SET "  
3248                        << " TO_TIME = "<< fromtime << " WHERE "  // NOTICE: to_time is equal to from_time of the calibration before, so the interval is: [from_time,to_time[
3249                        << " ID = "<< row->GetField(0) << ";";
3250                    //
3251                    if ( IsDebug() ) printf(" Make space for the new pulse1 calibration: query is \n %s \n",oss.str().c_str());
3252                    result = conn->Query(oss.str().c_str());
3253                    //
3254                    if ( !result ) throw -4;
3255                    //
3256                  };
3257                  //
3258                  oss.str("");
3259                  oss << " INSERT INTO GL_CALOPULSE_CALIB (ID,ID_ROOT_L0,EV_ROOT,FROM_TIME,TO_TIME,SECTION,PULSED_STRIP,PULSE_AMPLITUDE,OBT,PKT,BOOT_NUMBER,VALIDATION) "
3260                      << " VALUES (NULL,' "
3261                      << idroot << "','"
3262                      << i << "','"
3263                      << fromtime << "','"
3264                      << totime << "','"
3265                      << section << "',NULL,'0','"
3266                      << obt << "','"
3267                      << pkt << "','"
3268                      << this->GetBOOTnumber() << "','"
3269                      << valid << "');";
3270                  //
3271                  if ( IsDebug() ) printf(" Insert the new pulse1 calibration: query is \n %s \n",oss.str().c_str());
3272                  //
3273                  result = conn->Query(oss.str().c_str());
3274                  //
3275                  if ( !result ) throw -4;
3276                  //
3277                };
3278                //
3279              } else {
3280                //
3281                if ( IsDebug() ) printf(" Repeated pulse1 calo calibration for section %i at time %u obt %u pkt %u \n",section,fromtime,obt,pkt);
3282                //
3283              };      
3284              //      
3285            };
3286          };
3287        };
3288      };
3289      //
3290      // CaloPulse2
3291      //
3292      tr->Reset();
3293      CalibCalPulse2Event *cp2 = 0;
3294      tr = 0;
3295      //
3296      nevents = 0;
3297      fromtime = 0;
3298      totime = 0;
3299      obt = 0;
3300      pkt = 0;
3301      //
3302      tr = (TTree*)file->Get("CalibCalPulse2");
3303      if ( !tr || tr->IsZombie() ) throw -32;
3304      //
3305      tr->SetBranchAddress("CalibCalPulse2", &cp2);
3306      tr->SetBranchAddress("Header", &eh);
3307      nevents = tr->GetEntries();
3308      //
3309      if ( nevents > 0 ){
3310        //
3311        for (UInt_t i=0; i < nevents; i++){
3312          tr->GetEntry(i);
3313          for (UInt_t section = 0; section < 4; section++){
3314            //
3315            if ( cp2->pstwerr[section] && cp2->unpackError == 0 ){
3316              valid = 1;
3317              if ( cp2->pperror[section] ) valid = 0;
3318              ph = eh->GetPscuHeader();
3319              obt = ph->GetOrbitalTime();  
3320              pkt = ph->GetCounter();  
3321              fromtime = this->GetAbsTime(ph->GetOrbitalTime());  
3322              if ( this->PKT(pkt) >= this->PKT(pktfirst) && this->OBT(obt) >= this->OBT(obtfirst) ){
3323                //
3324                if ( IsDebug() ) printf(" Calo pulse2 calibration for section %i at time %u obt %u pkt %u \n",section,fromtime,obt,pkt);
3325                //
3326                // check if the calibration has already been inserted
3327                //
3328                oss.str("");
3329                oss << " SELECT ID FROM GL_CALOPULSE_CALIB WHERE "
3330                    << " SECTION = "<< section << " AND "
3331                    << " PULSE_AMPLITUDE != 0 AND "
3332                    << " BOOT_NUMBER = "<< this->GetBOOTnumber() << " AND "
3333                    << " OBT = "<< obt << " AND "
3334                    << " PKT = "<< pkt << ";";
3335                //
3336                if ( IsDebug() ) printf(" Check if the calo pulse2 calibration has already been inserted: query is \n %s \n",oss.str().c_str());
3337                result = conn->Query(oss.str().c_str());
3338                //
3339                if ( !result ) throw -4;
3340                //
3341                row = result->Next();
3342                //
3343                if ( row ){
3344                  //
3345                  if ( IsDebug() ) printf(" Calo pulse2 calibration already inserted in the DB\n");
3346                  //
3347                } else {
3348                  //
3349                  // we have to insert a new calibration
3350                  //
3351                  //
3352                  // Determine the amplitude of the pulse
3353                  //
3354                  UInt_t pampli = 1;
3355                  UInt_t pstrip = 0;
3356                  UInt_t se = 0;
3357                  if ( section == 1 ) se = 2;
3358                  if ( section == 2 ) se = 3;
3359                  if ( section == 3 ) se = 1;
3360                  for (Int_t ii=0;ii<16;ii++){
3361                    if ( cp2->calpuls[se][0][ii] > 10000. ){
3362                      pampli = 2;
3363                      pstrip = ii;
3364                    };
3365                  };
3366                  if ( pampli == 1 ){
3367                    Bool_t found = false;
3368                    Float_t delta=0.;
3369                    UInt_t cstr = 0;
3370                    while ( !found && cstr < 16 ){
3371                      for (Int_t ii=0;ii<16;ii++){
3372                        delta = cp2->calpuls[se][0][ii] - cp2->calpuls[se][0][cstr];
3373                        if ( IsDebug() ) printf(" cstr is %u ii is %i delta is %f \n",cstr,ii,delta);
3374                        if ( delta > 500. ){
3375                          pampli = 1;
3376                          pstrip = ii;
3377                          found = true;
3378                          if ( IsDebug() ) printf(" FOUND cstr is %u ii is %i delta is %f \n",cstr,ii,delta);
3379                        };
3380                      };
3381                      cstr++;
3382                    };
3383                    if ( !found ) pstrip = 100;
3384                  };
3385                  if ( IsDebug() ) printf(" The amplitude of the pulser is %u (where 1 = low pulse, 2 = high pulse), pulsed strip is %u \n",pampli,pstrip);
3386                  //
3387                  // we have to insert a new calibration, check where to place it
3388                  //
3389                  oss.str("");
3390                  oss << " SELECT ID,TO_TIME FROM GL_CALOPULSE_CALIB WHERE "
3391                      << " SECTION = "<< section << " AND "
3392                      << " PULSE_AMPLITUDE = " << pampli << " AND "
3393                      << " SECTION = "<< section << " AND "
3394                      << " FROM_TIME < "<< fromtime << " AND "
3395                      << " TO_TIME > "<< fromtime << ";";
3396                  //
3397                  if ( IsDebug() ) printf(" Check where to place the pulse2 calo calibration: query is \n %s \n",oss.str().c_str());
3398                  result = conn->Query(oss.str().c_str());
3399                  //
3400                  if ( !result ) throw -4;
3401                  //
3402                  row = result->Next();
3403                  //
3404                  if ( !row ){
3405                    //
3406                    // no calibrations in the db contain our calibration
3407                    //
3408                    if ( IsDebug() ) printf(" Pulse2 calibration with fromtime lower than others to be inserted in the DB for section %i \n",section);
3409                    if ( fromtime < 1150871000 ){ //1150866904
3410                      if ( IsDebug() ) printf(" First PAMELA flight calibration at time %u \n",fromtime);
3411                      fromtime = 0;// the first flight calibration was taken at about  1156429100 s, this line allow to analyze first runs in raw mode
3412                    };
3413                    //
3414                    oss.str("");
3415                    oss << " SELECT FROM_TIME FROM GL_CALOPULSE_CALIB WHERE "
3416                        << " PULSE_AMPLITUDE = " << pampli << " AND "
3417                        << " SECTION = "<< section << " AND "
3418                        << " FROM_TIME > "<< fromtime << " ORDER BY FROM_TIME ASC LIMIT 1;";
3419                    //
3420                    if ( IsDebug() ) printf(" Check the upper limit for pulse2 calibration: query is \n %s \n",oss.str().c_str());
3421                    result = conn->Query(oss.str().c_str());
3422                    //
3423                    if ( !result ) throw -4;
3424                    //
3425                    row = result->Next();
3426                    if ( !row ){
3427                      totime = numeric_limits<UInt_t>::max();
3428                    } else {
3429                      totime = (UInt_t)atoll(row->GetField(0));
3430                    };
3431                    //
3432                  } else {
3433                    //
3434                    // determine upper and lower limits and make space for the new calibration
3435                    //
3436                    totime = (UInt_t)atoll(row->GetField(1));
3437                    //
3438                    oss.str("");
3439                    oss << " UPDATE GL_CALOPULSE_CALIB SET "  
3440                        << " TO_TIME = "<< fromtime << " WHERE "  // NOTICE: to_time is equal to from_time of the calibration before, so the interval is: [from_time,to_time[
3441                        << " ID = "<< row->GetField(0) << ";";
3442                    //
3443                    if ( IsDebug() ) printf(" Make space for the new pulse2 calibration: query is \n %s \n",oss.str().c_str());
3444                    result = conn->Query(oss.str().c_str());
3445                    //
3446                    if ( !result ) throw -4;
3447                    //
3448                  };
3449                  //
3450                  // Fill the DB
3451                  //
3452                  oss.str("");
3453                  //              oss << " INSERT INTO GL_CALOPULSE_CALIB (ID,ID_ROOT_L0,EV_ROOT,FROM_TIME,TO_TIME,SECTION,OBT,PKT,BOOT_NUMBER,VALIDATION) "
3454                  oss << " INSERT INTO GL_CALOPULSE_CALIB (ID,ID_ROOT_L0,EV_ROOT,FROM_TIME,TO_TIME,SECTION,PULSED_STRIP,PULSE_AMPLITUDE,OBT,PKT,BOOT_NUMBER,VALIDATION) "
3455                      << " VALUES (NULL,' "
3456                      << idroot << "','"
3457                      << i << "','"
3458                      << fromtime << "','"
3459                      << totime << "','"
3460                      << section << "','"
3461                      << pstrip << "','"
3462                      << pampli << "','"
3463                      << obt << "','"
3464                      << pkt << "','"
3465                      << this->GetBOOTnumber() << "','"
3466                      << valid << "');";
3467                  //
3468                  if ( IsDebug() ) printf(" Insert the new pulse2 calibration: query is \n %s \n",oss.str().c_str());
3469                  //
3470                  result = conn->Query(oss.str().c_str());
3471                  //
3472                  if ( !result ) throw -4;
3473                  //
3474                };
3475                //
3476              } else {
3477                //
3478                if ( IsDebug() ) printf(" Repeated pulse2 calo calibration for section %i at time %u obt %u pkt %u \n",section,fromtime,obt,pkt);
3479                //
3480              };      
3481              //      
3482            };
3483          };
3484        };
3485      };
3486      //
3487      return(0);
3488    };
3489    
3490    /**
3491     * Fill the GL_TRK_CALIB table
3492     */
3493    void PamelaDBOperations::HandleTRK_CALIB(Bool_t pk1, Bool_t pk2){
3494      //
3495      TSQLResult *result = 0;
3496      TSQLRow    *row    = 0;
3497      //
3498      stringstream oss;
3499      oss.str("");
3500      //
3501      UInt_t totime = 0;
3502      //
3503      if ( !pk1 && !pk2 ){
3504        if ( IsDebug() ) printf(" Cannot handle trk calibration with both packet missing!\n");
3505      };
3506      //
3507      // check if the calibration has already been inserted
3508      //
3509      oss.str("");
3510    oss << " SELECT ID FROM GL_TRK_CALIB WHERE "    oss << " SELECT ID FROM GL_TRK_CALIB WHERE "
3511        << " BOOT_NUMBER = "<< this->GetBOOTnumber(); //        << " BOOT_NUMBER = "<< this->GetBOOTnumber(); //
3512    oss << " AND ( ( ";      oss << " AND ( ( ";  
# Line 2688  void PamelaDBOperations::HandleTRK_CALIB Line 3558  void PamelaDBOperations::HandleTRK_CALIB
3558        // no calibrations in the db contain our calibration        // no calibrations in the db contain our calibration
3559        //        //
3560        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");
3561        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
3562        //        //
3563        oss.str("");        oss.str("");
3564        oss << " SELECT FROM_TIME FROM GL_TRK_CALIB WHERE "        oss << " SELECT FROM_TIME FROM GL_TRK_CALIB WHERE "
# Line 2817  Int_t PamelaDBOperations::insertTRK_CALI Line 3687  Int_t PamelaDBOperations::insertTRK_CALI
3687      pkt1 = ph1->GetCounter();        pkt1 = ph1->GetCounter();  
3688      fromtime = this->GetAbsTime(ph1->GetOrbitalTime());        fromtime = this->GetAbsTime(ph1->GetOrbitalTime());  
3689      //      //
3690      valid = 1;  //     valid = 1;
3691      //  //     //
3692      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
3693      //      //
3694      //      //
3695      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) ){
3696        //        //
3697        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);
3698          //      
3699          valid = ValidateTrkCalib( caltrk1, eh1 );
3700          if ( IsDebug() ) cout << " pkt1 validation --> "<<valid<<endl;
3701        //        //
3702        // Do we have the second calibration packet?        // Do we have the second calibration packet?
3703        //        //
# Line 2841  Int_t PamelaDBOperations::insertTRK_CALI Line 3714  Int_t PamelaDBOperations::insertTRK_CALI
3714            obt2 = ph2->GetOrbitalTime();              obt2 = ph2->GetOrbitalTime();  
3715            pkt2 = ph2->GetCounter();              pkt2 = ph2->GetCounter();  
3716            //            //
3717            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
3718            //                  //      
3719          } else {          } else {
3720            //            //
# Line 2864  Int_t PamelaDBOperations::insertTRK_CALI Line 3737  Int_t PamelaDBOperations::insertTRK_CALI
3737          //          //
3738        };        };
3739        //        //
3740        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);
3741        //        //
3742        // The calibration is good        // The calibration is good
3743        //        //
3744        if ( this->PKT(pkt2) == this->PKT(pkt1)+1 ){        if ( this->PKT(pkt2) == this->PKT(pkt1)+1 ){
3745          //          //
3746          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);
3747            //
3748            UInt_t valid2 = ValidateTrkCalib( caltrk2, eh2 );
3749            if ( IsDebug() ) cout << " pkt2 validation --> "<<valid2<<endl;
3750            valid = valid & valid2;
3751          //          //
3752          // Handle good calib          // Handle good calib
3753          //          //
# Line 2880  Int_t PamelaDBOperations::insertTRK_CALI Line 3757  Int_t PamelaDBOperations::insertTRK_CALI
3757          //          //
3758          if ( t2 != pret2+1 ){          if ( t2 != pret2+1 ){
3759            //            //
3760            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);
3761            //            //
3762            while ( t2 > pret2+1 ){            while ( t2 > pret2+1 ){
3763              //              //
# Line 2909  Int_t PamelaDBOperations::insertTRK_CALI Line 3786  Int_t PamelaDBOperations::insertTRK_CALI
3786          //          //
3787          // Check for missing calibtrk2          // Check for missing calibtrk2
3788          //          //
3789          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);
3790          t2 = pret2;          t2 = pret2;
3791          //          //
3792          // handle missing calib2          // handle missing calib2
# Line 2923  Int_t PamelaDBOperations::insertTRK_CALI Line 3800  Int_t PamelaDBOperations::insertTRK_CALI
3800        //        //
3801      } else {      } else {
3802        //        //
3803        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);
3804        //        //
3805      };      };
3806      //          //    
# Line 2948  Int_t PamelaDBOperations::insertTRK_CALI Line 3825  Int_t PamelaDBOperations::insertTRK_CALI
3825      valid = 0;      valid = 0;
3826      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) ){
3827        //        //
3828        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);
3829        //        //
3830        this->HandleTRK_CALIB(false,true);        this->HandleTRK_CALIB(false,true);
3831        //        //
# Line 3002  Int_t PamelaDBOperations::insertS4_CALIB Line 3879  Int_t PamelaDBOperations::insertS4_CALIB
3879      fromtime = this->GetAbsTime(ph->GetOrbitalTime());        fromtime = this->GetAbsTime(ph->GetOrbitalTime());  
3880      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) ){
3881        //        //
3882        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);
3883        //        //
3884        // check if the calibration has already been inserted        // check if the calibration has already been inserted
3885        //        //
# Line 3044  Int_t PamelaDBOperations::insertS4_CALIB Line 3921  Int_t PamelaDBOperations::insertS4_CALIB
3921            // no calibrations in the db contain our calibration            // no calibrations in the db contain our calibration
3922            //            //
3923            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");
3924            if ( fromtime < 1150863400 ){            if ( fromtime < 1150871000 ){  
3925              if ( IsDebug() ) printf(" First PAMELA flight calibration at time %i \n",fromtime);              if ( IsDebug() ) printf(" First PAMELA flight calibration at time %u \n",fromtime);
3926              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
3927            };            };
3928            //            //
# Line 3104  Int_t PamelaDBOperations::insertS4_CALIB Line 3981  Int_t PamelaDBOperations::insertS4_CALIB
3981        //        //
3982      } else {      } else {
3983        //        //
3984        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);
3985        //        //
3986      };            };      
3987      //            //      
# Line 3117  Int_t PamelaDBOperations::insertS4_CALIB Line 3994  Int_t PamelaDBOperations::insertS4_CALIB
3994   * 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
3995   */   */
3996  Int_t PamelaDBOperations::CleanGL_RUN_FRAGMENTS(){  Int_t PamelaDBOperations::CleanGL_RUN_FRAGMENTS(){
3997      return(this->CleanGL_RUN_FRAGMENTS(""));
3998    };
3999    
4000    /**
4001     * Scan the fragment table and move old fragments to the GL_RUN table
4002     */
4003    Int_t PamelaDBOperations::CleanGL_RUN_FRAGMENTS(TString fcleanfile){
4004    //    //
4005    TSQLResult *result = 0;    TSQLResult *result = 0;
4006    TSQLRow    *row    = 0;    TSQLRow    *row    = 0;
# Line 3124  Int_t PamelaDBOperations::CleanGL_RUN_FR Line 4008  Int_t PamelaDBOperations::CleanGL_RUN_FR
4008    TSQLRow    *row2   = 0;    TSQLRow    *row2   = 0;
4009    //    //
4010    UInt_t moved = 0;    UInt_t moved = 0;
   UInt_t timelim = 0;  
   TDatime *time = new TDatime();  
4011    //    //
4012    stringstream oss;    stringstream oss;
4013    oss.str("");    oss.str("");
4014    //    //
4015    //    if ( !strcmp(fcleanfile.Data(),"") ){
4016    //      //
4017    if ( olderthan < 0 ){      // check if there are entries older than "olderthan" seconds from now
4018      if ( IsDebug() ) printf(" Do not clean GL_RUN_FRAGMENTS table \n");      //
4019      return(1);      oss.str("");
4020        oss << " SELECT ID FROM GL_RUN_FRAGMENTS WHERE"
4021            << " INSERT_TIME <= '" << clean_time->AsSQLString() << "';";
4022        //
4023        if ( IsDebug() ) printf(" Select from GL_RUN_FRAGMENTS runs older than %s : query is \n %s \n",clean_time->AsSQLString(),oss.str().c_str());
4024        result = conn->Query(oss.str().c_str());
4025        //
4026      } else {
4027        oss.str("");
4028        oss << " SELECT ID FROM GL_ROOT WHERE NAME='" << fcleanfile.Data() << "';";
4029        if ( IsDebug() ) printf(" Getting ID_ROOT_L0 query %s \n",oss.str().c_str());
4030        result = conn->Query(oss.str().c_str());
4031        //    
4032        if ( result ){
4033          //
4034          row = result->Next();
4035          //
4036          if ( row ){
4037            oss.str("");
4038            oss << " SELECT ID FROM GL_RUN_FRAGMENTS WHERE"
4039                << " ID_ROOT_L0=" << row->GetField(0) << ";";
4040            //
4041            if ( IsDebug() ) printf(" Select from GL_RUN_FRAGMENTS for ROOT file query is \n %s \n",oss.str().c_str());
4042            result = conn->Query(oss.str().c_str());
4043            //    
4044          };
4045        } else {
4046          return(2);
4047        };
4048    };    };
4049    //    //
   // 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());  
   //  
4050    if ( result ){    if ( result ){
4051      //      //
4052      row = result->Next();      row = result->Next();
4053      //      //
4054      if ( row ){      while ( row ){
4055        //        //
4056        oss.str("");        oss.str("");
4057        oss << " ID= "<< row->GetField(0);        oss << " ID= "<< row->GetField(0);
# Line 3191  Int_t PamelaDBOperations::CleanGL_RUN_FR Line 4086  Int_t PamelaDBOperations::CleanGL_RUN_FR
4086          if ( IsDebug() ) printf(" The run is new \n");          if ( IsDebug() ) printf(" The run is new \n");
4087          if ( IsDebug() ) printf(" -> fill the DB \n");                if ( IsDebug() ) printf(" -> fill the DB \n");      
4088          //          //
4089          glrun->SetID(0);          //      glrun->SetID(this->AssignRunID()); we use the old run number!
4090            glrun->SetID_RUN_FRAG(glrun->GetID());
4091          glrun->Fill_GL_RUN(conn);            glrun->Fill_GL_RUN(conn);  
4092          //          //
4093          oss.str("");  //      oss.str("");
4094          oss << " SELECT ID FROM GL_RUN WHERE "  //      oss << " SELECT ID FROM GL_RUN WHERE "
4095              << " BOOT_NUMBER=" << glrun->GetBOOT_NUMBER() << " AND "  //          << " BOOT_NUMBER=" << glrun->GetBOOT_NUMBER() << " AND "
4096              << " RUNHEADER_PKT=" << (UInt_t)glrun->GetRUNHEADER_PKT() << " AND "  //          << " RUNHEADER_PKT=" << (UInt_t)glrun->GetRUNHEADER_PKT() << " AND "
4097              << " RUNTRAILER_PKT=" << (UInt_t)glrun->GetRUNTRAILER_PKT() << " AND "  //          << " RUNTRAILER_PKT=" << (UInt_t)glrun->GetRUNTRAILER_PKT() << " AND "
4098              << " RUNHEADER_OBT=" << (UInt_t)glrun->GetRUNHEADER_OBT() << " AND "  //          << " RUNHEADER_OBT=" << (UInt_t)glrun->GetRUNHEADER_OBT() << " AND "
4099              << " RUNTRAILER_OBT=" << (UInt_t)glrun->GetRUNTRAILER_OBT() << "; ";  //          << " RUNTRAILER_OBT=" << (UInt_t)glrun->GetRUNTRAILER_OBT() << "; ";
4100          //  //      //
4101          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());
4102          result2 = conn->Query(oss.str().c_str());  //      result2 = conn->Query(oss.str().c_str());
4103          //  //      //
4104          if ( !result2 ) throw -4;  //      if ( !result2 ) throw -4;
4105          //  //      //
4106          row2 = result2->Next();  //      row2 = result2->Next();
4107          //  //      //
4108          if ( !row2 ) throw -25;  //      if ( !row2 ) throw -25;
4109          //  //      //
4110          oss.str("");  //      oss.str("");
4111          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);
4112          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());
4113          result2 = conn->Query(oss.str().c_str());  //      result2 = conn->Query(oss.str().c_str());
4114          //  //      //
4115          if ( !result2 ) throw -4;  //      if ( !result2 ) throw -4;
4116          //          //
4117          moved++;          moved++;
4118          //          //
# Line 3226  Int_t PamelaDBOperations::CleanGL_RUN_FR Line 4122  Int_t PamelaDBOperations::CleanGL_RUN_FR
4122        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));      
4123        //        //
4124        //        //
4125        oss.str("");        glrun->DeleteRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN_FRAGMENTS");
4126        oss << " DELETE from GL_RUN_FRAGMENTS where ID = " << row->GetField(0);  //      oss.str("");
4127        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);
4128        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());
4129        //  //       result2 = conn->Query(oss.str().c_str());
4130        if ( !result2 ) throw -4;  //      //
4131        //  //      if ( !result2 ) throw -4;
4132    //      //
4133          row = result->Next();
4134      };      };
4135    };    };
4136    if ( IsDebug() ) printf(" Moved %u runs\n",moved);    if ( IsDebug() ) printf(" Moved %u runs\n",moved);
# Line 3243  Int_t PamelaDBOperations::CleanGL_RUN_FR Line 4141  Int_t PamelaDBOperations::CleanGL_RUN_FR
4141   * 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..
4142   */   */
4143  Int_t PamelaDBOperations::ValidateRuns(){  Int_t PamelaDBOperations::ValidateRuns(){
4144      return(this->ValidateRuns(""));
4145    };
4146    
4147    /**
4148     * Check if runs are good, i.e. if the tracker calibration is correctly associated..
4149     */
4150    Int_t PamelaDBOperations::ValidateRuns(TString valfile){
4151    //    //
4152    TSQLResult *result = 0;    TSQLResult *result = 0;
4153    TSQLRow    *row    = 0;    TSQLRow    *row    = 0;
4154    //    //
4155    UInt_t timelim = 0;    UInt_t calibtime = 50;
   TDatime *time = new TDatime();  
4156    //    //
4157    stringstream oss;    stringstream oss;
4158    oss.str("");    oss.str("");
4159    //    //
   //  
   //  
   if ( olderthan < 0 ){  
     if ( IsDebug() ) printf(" Do not validate runs \n");  
     return(1);  
   };  
   //  
   // timelim = now - olderthan  
   //  
   time->Set();  
   timelim =  (UInt_t)time->Convert() - olderthan;  
   time->Set(timelim,false);  
   
   printf("Validate runs older than %s \n",time->AsSQLString());  
   
4160    // =======================================================    // =======================================================
4161    // validate runs by checking missing calibrations    // validate runs by checking missing calibrations
4162    // =======================================================    // =======================================================
4163    UInt_t t_stop  = 0;    UInt_t t_stop  = 0;
4164    UInt_t t_start = 0;    UInt_t t_start = 0;
4165    // --------------------------------------------------------------    if ( !strcmp(valfile.Data(),"") ) {
4166    // 1) get the OBT of the last run inserted after clean-time limit      // --------------------------------------------------------------
4167    // --------------------------------------------------------------      // 1) get the OBT of the last run inserted after clean-time limit
4168    oss.str("");      // --------------------------------------------------------------
4169    oss << " SELECT * FROM GL_RUN  WHERE INSERT_TIME <= '" << time->AsSQLString()      oss.str("");
4170        << "' ORDER BY INSERT_TIME DESC LIMIT 1;";      oss << " SELECT * FROM GL_RUN  WHERE INSERT_TIME <= '" << clean_time->AsSQLString()
4171    printf(" Get start validation-time: query is \n %s \n",oss.str().c_str());          << "' ORDER BY RUNHEADER_TIME DESC LIMIT 1;";
4172    result = conn->Query(oss.str().c_str());      if ( IsDebug() ) printf(" Get start validation-time: query is \n %s \n",oss.str().c_str());
4173        result = conn->Query(oss.str().c_str());
4174        if ( !result ) throw -4;
4175        if ( !result->GetRowCount() ) {
4176          printf(" No runs to validate \n");
4177          return(1);
4178        }else{
4179          row = result->Next();
4180          t_start = (UInt_t)atoll(row->GetField(4));
4181        };  
4182        // --------------------------------------------------------------
4183        // 2) get the OBT of the last validated run
4184        // --------------------------------------------------------------
4185        oss.str("");
4186        oss << " SELECT * FROM GL_RUN  WHERE VALIDATION=1 AND RUNHEADER_TIME<="<< t_start
4187            <<" ORDER BY RUNHEADER_TIME DESC LIMIT 1;";
4188        if ( IsDebug() ) printf(" Get stop validation-time: query is \n %s \n",oss.str().c_str());
4189        result = conn->Query(oss.str().c_str());
4190        if ( !result ) throw -4;
4191        if ( result->GetRowCount() ){
4192          row = result->Next();
4193          t_stop = (UInt_t)atoll(row->GetField(4));
4194        };
4195        if ( IsDebug() ) printf("Validation interval: from time %u - to time %u \n\n",t_stop,t_start);
4196        // --------------------------------------------------------------
4197        // now retrieves runs to be validated
4198        // --------------------------------------------------------------
4199        oss.str("");
4200        oss << " SELECT * FROM GL_RUN  WHERE  RUNHEADER_TIME <=" << t_start;
4201        oss << " AND RUNHEADER_TIME >="<< t_stop;
4202        oss << " ORDER BY RUNHEADER_TIME DESC;";
4203        if ( IsDebug() )printf(" Check runs for validation: query is \n %s \n",oss.str().c_str());
4204        result = conn->Query(oss.str().c_str());
4205      } else {
4206        //
4207        stringstream myquery;
4208        UInt_t myid = 0;
4209        myquery.str("");
4210        myquery << " SELECT ID FROM GL_ROOT where NAME='"<<valfile.Data() <<"';";
4211        //
4212        result = conn->Query(myquery.str().c_str());
4213        //
4214        row = result->Next();      
4215        if( !row ){
4216          if ( strcmp(valfile.Data(),GetRootName().Data()) ){
4217            if ( IsDebug() ) printf(" No file to be validated even if option \"-validate file\" was used!!\n");
4218            return(2);
4219          };
4220          if ( IsDebug() ) printf(" No file to be validated (force mode)! \n");
4221          return(0);
4222        };
4223        myid=(UInt_t)atoll(row->GetField(0));
4224        //
4225        myquery.str("");
4226        myquery << " SELECT MAX(RUNTRAILER_TIME),MIN(RUNHEADER_TIME) FROM GL_RUN WHERE ID_ROOT_L0="<< myid <<";";
4227        //
4228        result = conn->Query(myquery.str().c_str());
4229        //
4230        row = result->Next();      
4231        if( !row->GetField(0) || !row->GetField(1)){
4232          //
4233          if ( IsDebug() ) printf(" NO RUN ASSOCIATED TO THIS FILE! \n");
4234          //
4235          return(0);
4236          //
4237        } else {  
4238          //
4239          UInt_t runhtime = (UInt_t)atoll(row->GetField(0));
4240          UInt_t runttime = (UInt_t)atoll(row->GetField(1));
4241          UInt_t caltime = 0;
4242          //
4243          myquery.str("");
4244          myquery << " SELECT FROM_TIME FROM GL_TRK_CALIB where FROM_TIME>" <<runhtime;
4245          myquery << " order by FROM_TIME asc limit 1;";
4246          //
4247          if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
4248          //
4249          //
4250          result = conn->Query(myquery.str().c_str());
4251          //
4252          row = result->Next();      
4253          if( !row ){
4254            caltime = runhtime;
4255          } else {
4256            caltime = (UInt_t)atoll(row->GetField(0));
4257          };
4258          //
4259          myquery.str("");
4260          myquery << " SELECT * from GL_RUN where RUNHEADER_TIME>="<< runttime <<" AND RUNHEADER_TIME<=" ;
4261          myquery << caltime << " order by RUNHEADER_TIME DESC";
4262          //
4263          if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
4264          //
4265          result = conn->Query(myquery.str().c_str());
4266          //
4267        };
4268      };
4269      //
4270    if ( !result ) throw -4;    if ( !result ) throw -4;
4271    if ( !result->GetRowCount() ) {    if ( !result->GetRowCount() && IsDebug() ) printf(" No runs to validate \n");
4272            printf(" No runs to validate \n");    //
           return(1);  
   }else{  
         row = result->Next();  
         t_start = (UInt_t)atoll(row->GetField(4));  
         printf("t_start %i\n",t_start);  
   };    
   // --------------------------------------------------------------  
   // 2) get the OBT of the last validated run  
   // --------------------------------------------------------------  
   oss.str("");  
   oss << " SELECT * FROM GL_RUN  WHERE VALIDATION=1 AND RUNHEADER_TIME<="<< t_start  
       <<" ORDER BY RUNHEADER_TIME DESC LIMIT 1;";  
   printf(" Get stop validation-time: query is \n %s \n",oss.str().c_str());  
   result = conn->Query(oss.str().c_str());  
   if ( !result ) throw -4;  
   if ( result->GetRowCount() ){  
           row = result->Next();  
           t_stop = (UInt_t)atoll(row->GetField(4));  
   };  
   printf("t_stop %i\n",t_stop);  
   // --------------------------------------------------------------  
   // now retrieves runs to be validated  
   // --------------------------------------------------------------  
   oss.str("");  
   oss << " SELECT * FROM GL_RUN  WHERE  RUNHEADER_TIME <=" << t_start;  
   oss << " AND RUNHEADER_TIME >="<< t_stop;  
   oss << " ORDER BY RUNHEADER_TIME DESC;";  
 //  if ( IsDebug() )  
   printf(" Check runs for validation: query is \n %s \n",oss.str().c_str());  
   result = conn->Query(oss.str().c_str());  
   if ( !result ) throw -4;  
   if ( !result->GetRowCount() ) printf(" No runs to validate \n");  
   printf("------------------------------------------------------------------------------- \n");  
     
4273    Int_t nrow = 0;    Int_t nrow = 0;
4274    GL_RUN* this_run = new GL_RUN();    GL_RUN* this_run = new GL_RUN();
4275    GL_RUN* next_run = new GL_RUN();    GL_RUN* next_run = new GL_RUN();
4276    Int_t   nseq_max = 100;    Int_t   nseq_max = 1000;
4277  //  UInt_t* sequence = new UInt_t[100];  //  UInt_t* sequence = new UInt_t[100];
4278    vector<UInt_t> sequence(nseq_max);    vector<UInt_t> sequence(nseq_max);
4279    Int_t   nseq = 0;    Int_t   nseq = 0;
# Line 3331  Int_t PamelaDBOperations::ValidateRuns() Line 4283  Int_t PamelaDBOperations::ValidateRuns()
4283    UInt_t t1=0,t2=0;    UInt_t t1=0,t2=0;
4284    // ---------------------------------------------------------------------------------    // ---------------------------------------------------------------------------------
4285    // - loop over runs, back in time,    // - loop over runs, back in time,
4286    // - select sequences of runs close in time (less than 60 s apart),    // - select sequences of runs close in time (less than calibtime s apart),
4287    //   which could be preceeded by a calibration    //   which could be preceeded by a calibration
4288    // - check if there might be a missing calibration    // - check if there might be a missing calibration
4289    // ---------------------------------------------------------------------------------    // ---------------------------------------------------------------------------------
# Line 3344  Int_t PamelaDBOperations::ValidateRuns() Line 4296  Int_t PamelaDBOperations::ValidateRuns()
4296            //get run info            //get run info
4297            //------------            //------------
4298            this_run->Set_GL_RUN(row);            this_run->Set_GL_RUN(row);
4299                                
           printf(" RUN ID %i --- TRK_CALIB_USED %i --- RM_ACQ_AFTER_CALIB %i --- TIME %i %i \n",this_run->ID,this_run->TRK_CALIB_USED,this_run->RM_ACQ_AFTER_CALIB,this_run->RUNHEADER_TIME, this_run->RUNTRAILER_TIME);  
             
4300            Bool_t this_BAD = false;            Bool_t this_BAD = false;
4301            if(this_run->GetTRK_CALIB_USED() == 1 || this_run->GetTRK_CALIB_USED() == 2) this_ONLINE = true;            if(this_run->GetTRK_CALIB_USED() == 1 || this_run->GetTRK_CALIB_USED() == 2) this_ONLINE = true;
4302            else if (this_run->GetTRK_CALIB_USED() == 104)                          this_ONLINE = false;            else if (this_run->GetTRK_CALIB_USED() == 104)                          this_ONLINE = false;
4303            else{            else{
4304                    printf("Missing or corrupted header!! \n");  //                printf("Missing or corrupted header!! \n");
4305                    this_ONLINE = false;                    this_ONLINE = false;
4306                    this_BAD = true;                    this_BAD = true;
4307            };            };
# Line 3373  Int_t PamelaDBOperations::ValidateRuns() Line 4323  Int_t PamelaDBOperations::ValidateRuns()
4323                                                        
4324                            if( this_run->ID == next_run->ID_RUN_FRAG ) interval = 0;     //=> run fragments                            if( this_run->ID == next_run->ID_RUN_FRAG ) interval = 0;     //=> run fragments
4325                                                        
4326                            if( interval >= 60 )CHECK = true;                     //more than 60 s => there might be a calibration                            if( interval >= calibtime )CHECK = true;                      //more than calibtime s => there might be a calibration
                             
 /*                        if( CHECK && !next_run->GetRM_ACQ_AFTER_CALIB() )  
                                   printf(" ValidateRuns ***WARNING*** : DT = %i but RM_ACQ_AFTER_CALIB = %i \n",(t2-t1),next_run->GetRM_ACQ_AFTER_CALIB());*/  
                                                     
4327                                                        
4328                            if( !CHECK && this_run->VALIDATION ){                            if( !CHECK && this_run->VALIDATION ){
4329                                    for (Int_t irun = 0; irun < nseq; irun++)assignVALIDATION(sequence[irun],true);                                    for (Int_t irun = 0; irun < nseq; irun++)assignVALIDATION(sequence[irun],true);
# Line 3387  Int_t PamelaDBOperations::ValidateRuns() Line 4333  Int_t PamelaDBOperations::ValidateRuns()
4333                    }else if( !this_ONLINE && next_ONLINE) {              // this: DEFAULT + next:ON-LINE                    }else if( !this_ONLINE && next_ONLINE) {              // this: DEFAULT + next:ON-LINE
4334                                                        
4335                            CHECK = true;                            CHECK = true;
 //                        if( interval < 60 ) printf(" ValidateRuns ***WARNING*** : kkkkkk DT = %i \n",interval);  
4336    
4337                    }else if( !next_ONLINE ){                                             // this:ANY + next:DEFAULT                    }else if( !next_ONLINE ){                                             // this:ANY + next:DEFAULT
4338                                                        
# Line 3401  Int_t PamelaDBOperations::ValidateRuns() Line 4346  Int_t PamelaDBOperations::ValidateRuns()
4346            //----------------------------            //----------------------------
4347            if( CHECK ){            if( CHECK ){
4348                    // check if calibration exists                    // check if calibration exists
4349                    printf("DT %i ===> CHECK Missing calibration\n",interval);                    if ( IsDebug() )printf("DT %i ===> CHECK Missing calibration\n",interval);
4350                    Bool_t MISSING = MissingTRK_CALIB(t1,t2);                    Bool_t MISSING = MissingTRK_CALIB(t1,t2);
4351                    for (Int_t irun = 0; irun < nseq; irun++)assignVALIDATION(sequence[irun],!MISSING);                    for (Int_t irun = 0; irun < nseq; irun++)assignVALIDATION(sequence[irun],!MISSING);
4352                    nseq=0;                    nseq=0;
4353            } else printf("DT %i\n",interval);            };
4354            //--------------            //--------------
4355            //store run info            //store run info
4356            //--------------            //--------------
# Line 3418  Int_t PamelaDBOperations::ValidateRuns() Line 4363  Int_t PamelaDBOperations::ValidateRuns()
4363                    }else printf("ValidateRuns ***WARNING*** : run sequence exceed assumed size (%i) \n",nseq_max);                    }else printf("ValidateRuns ***WARNING*** : run sequence exceed assumed size (%i) \n",nseq_max);
4364            };            };
4365                        
4366              if ( IsDebug() ) printf("%i Run %u \n",nrow,this_run->ID);
4367            nrow++;            nrow++;
4368                        
4369    };    };
# Line 3446  Bool_t PamelaDBOperations::MissingTRK_CA Line 4392  Bool_t PamelaDBOperations::MissingTRK_CA
4392          // which should be equal to the time between ascending-nodes.          // which should be equal to the time between ascending-nodes.
4393          //==============================================================          //==============================================================
4394          if ( t2 - trkcalib->FROM_TIME > 5700) {          if ( t2 - trkcalib->FROM_TIME > 5700) {
4395                  printf("Long time to previous calib %i :-( \n",t2 - trkcalib->FROM_TIME);                  if ( IsDebug() )printf("Long time between calib and run start %u :-( ==> there might be a missing calib \n",t2 - trkcalib->FROM_TIME);
4396          //==============================================================          //==============================================================
4397          // there might be a missing calibration, due to:          // there might be a missing calibration, due to:
4398          // - MM full          // - MM full
# Line 3467  Bool_t PamelaDBOperations::MissingTRK_CA Line 4413  Bool_t PamelaDBOperations::MissingTRK_CA
4413          // it is enough to say that there are no missing calibrations          // it is enough to say that there are no missing calibrations
4414          //==============================================================          //==============================================================
4415          // the long time interval bewteen runs might be due to download          // the long time interval bewteen runs might be due to download
4416          printf("Short time to previous calib %i :-) \n",t2 - trkcalib->FROM_TIME);          if ( IsDebug() )printf("Short time between calib and run start %u :-) ==> OK! \n",t2 - trkcalib->FROM_TIME);
4417          return(false);          return(false);
4418                    
4419  };  };
# Line 3480  Int_t PamelaDBOperations::assignVALIDATI Line 4426  Int_t PamelaDBOperations::assignVALIDATI
4426          TSQLResult *result = 0;          TSQLResult *result = 0;
4427          stringstream oss;          stringstream oss;
4428          oss.str("");          oss.str("");
4429          oss << " UPDATE GL_RUN SET VALIDATION="<< (UInt_t)validation <<" WHERE ID= " << idrun << "';";          oss << " UPDATE GL_RUN SET VALIDATION="<< (UInt_t)validation <<" WHERE ID= " << idrun << ";";
4430          //          //
4431  //      if ( IsDebug() )  //      if ( IsDebug() )
4432          printf(" Set VALIDATION = %i for run %i \n",validation,idrun);  //      printf(" Set VALIDATION = %i for run %i \n",validation,idrun);
4433  //      printf(" Set VALIDATION = %i for run %i : query is \n %s \n",validation,idrun,oss.str().c_str());          if ( IsDebug() )printf(" Query: %s \n",oss.str().c_str());
4434  //      result = conn->Query(oss.str().c_str());          result = conn->Query(oss.str().c_str());
4435  //      if ( !result ) throw -4;          if ( !result ) throw -4;
4436          return(0);          return(0);
4437  }  }
4438    
4439    
4440    
4441    // Insert TLEs from file tlefilename in the table GL_TLE in the db
4442    // opened by conn, sorting them by date from older to newer, if each
4443    // TLE has not been alread inserted.
4444    Int_t PamelaDBOperations::populateTLE()//(TSQLServer *conn, char *tleFile)
4445    {
4446      fstream tlefile(tlefilename, ios::in);
4447    
4448      if ( !tlefile ) throw -7;
4449    
4450      vector<cTle*> ctles;
4451      vector<cTle*>::iterator iter;
4452      int present = 0;
4453    
4454      // Get three lines from tlefile, create a cTle object and put it
4455      // into ctles
4456      while(1) {
4457        cTle *tlef;
4458        string str1, str2, str3;
4459    
4460        getline(tlefile, str1);
4461        if(tlefile.eof()) break;
4462    
4463        getline(tlefile, str2);
4464        if(tlefile.eof()) break;
4465    
4466        getline(tlefile, str3);
4467        if(tlefile.eof()) break;
4468    
4469        // We now have three good lines for a cTle.
4470        tlef = new cTle(str1, str2, str3);
4471        ctles.push_back(tlef);
4472      }
4473    
4474      tlefile.close();
4475    
4476      // Sort by date
4477      sort(ctles.begin(), ctles.end(), compTLE);
4478    
4479      // Now we insert each TLE into the db
4480      for(iter = ctles.begin(); iter != ctles.end(); iter++) {
4481        cTle *tle = *iter;
4482    
4483        // Do nothing if it's already present in the db.  Just increase
4484        // the counter present.
4485        if (! isTlePresent(tle))
4486          {
4487            int status = insertTle(tle);
4488    
4489            // Insert query failed.  Return 1.
4490            if(status == EXIT_FAILURE) {
4491              
4492              if( IsDebug() ) {
4493                cerr << "Error: inserting TLE:" << endl
4494                     << tle->getName() << endl
4495                     << tle->getLine1() << endl
4496                     << tle->getLine2() << endl;
4497              }
4498    
4499              throw -4;
4500              return 1;
4501            }
4502    
4503          }
4504        else
4505          present++;
4506    
4507      }
4508    
4509      int inserted = ctles.size() - present;  // Number of inserted TLE.
4510      if ( IsDebug() )
4511        cout << "\nProcessed TLEs ranging from " << getTleDatetime(ctles[0]) << " to " << getTleDatetime(ctles[ctles.size()-1]) << "." << endl
4512             << inserted << " newly inserted TLEs out of " << ctles.size() << " processed." << endl;
4513    
4514      ctles.clear();
4515    
4516    
4517      // Return 2 if no new TLE has been inserted.  0 otherwise.
4518      if(! inserted ) return 2;
4519      return 0;
4520    }
4521    
4522    
4523    // Insert tle in the table GL_TLE using the connection conn.
4524    Int_t PamelaDBOperations::insertTle(cTle *tle)
4525    {
4526      stringstream oss;
4527      TSQLResult *result = 0;
4528    
4529      oss.str("");
4530      oss << " INSERT INTO GL_TLE (TLE1, TLE2, TLE3, FROM_TIME)"
4531          << " VALUES ( '"
4532          << tle->getName() << "', '"
4533          << tle->getLine1() << "', '"
4534          << tle->getLine2() << "', '"
4535          << getTleDatetime(tle) << "')";
4536    
4537      //  cout << oss.str().c_str() << endl;
4538      result = conn->Query(oss.str().c_str());
4539      if (result == NULL)
4540        return EXIT_FAILURE;
4541    
4542      return EXIT_SUCCESS;
4543    }
4544    
4545    
4546    // Return whether tle is already in the db connected by conn.
4547    bool PamelaDBOperations::isTlePresent(cTle *tle)
4548    {
4549      stringstream oss;
4550      TSQLResult *result = 0;
4551    
4552      oss.str("");
4553      oss << "SELECT * FROM GL_TLE WHERE FROM_TIME = '"
4554          << getTleDatetime(tle) << "'";
4555    
4556      result = conn->Query(oss.str().c_str());
4557      if (result == NULL) throw -4;
4558    
4559      if (result->GetRowCount())
4560        return true;
4561      else
4562        return false;
4563    }
4564    
4565    
4566    // Return whether the first TLE is dated early than the second
4567    bool compTLE (cTle *tle1, cTle *tle2)
4568    {
4569      return getTleJulian(tle1) < getTleJulian(tle2);
4570    }
4571    
4572    
4573    // Return the date of the tle using the format (year-2000)*1e3 +
4574    // julian day.  e.g. 6365 is the 31th Dec 2006.
4575    // It does *not* return a cJulian date.
4576    float getTleJulian(cTle *tle) {
4577      return tle->getField(cTle::FLD_EPOCHYEAR)*1e3 + tle->getField(cTle::FLD_EPOCHDAY);
4578    }
4579    
4580    
4581    // Return a string like YYYY-MM-DD hh:mm:ss, usable for mysql datetime
4582    // format.
4583    string getTleDatetime(cTle *tle)
4584    {
4585      int year, mon, day, hh, mm, ss;
4586      double dom; // day of month (is double!)
4587      stringstream date; // date in datetime format
4588    
4589      // create a cJulian from the date in tle
4590      cJulian jdate = cJulian( 2000 + (int) tle->getField(cTle::FLD_EPOCHYEAR), tle->getField(cTle::FLD_EPOCHDAY));
4591    
4592      // get year, month, day of month
4593      jdate.getComponent(&year, &mon, &dom);
4594    
4595      // build a datetime YYYY-MM-DD hh:mm:ss
4596      date.str("");
4597      day = (int) floor(dom);
4598      hh = (int) floor( (dom - day) * 24);
4599      mm = (int) floor( ((dom - day) * 24 - hh) * 60);
4600      ss = (int) floor( ((((dom - day) * 24 - hh) * 60 - mm) * 60));
4601      //  ms = (int) floor( (((((dom - day) * 24 - hh) * 60 - mm) * 60) - ss) * 1000);
4602    
4603      date << year << "-" << mon << "-" << day << " " << hh << ":" << mm << ":" << ss;
4604    
4605      return date.str();
4606    }
4607    
4608    /**
4609     * Remove a file from the DB, delete on cascade all entries related to that file
4610     * rearrange GL_RUN and GL_XXX_CALIB tables, turn off validation till the following
4611     * calibration
4612     **/
4613    Int_t PamelaDBOperations::removeFile(TString remfile){
4614      //
4615      // Determine ID_ROOT_L0 and ID_RAW
4616      //
4617      TSQLResult *pResult;
4618      TSQLRow *Row;
4619      stringstream myquery;
4620      //  
4621      myquery.str("");
4622      myquery << " SELECT ID, ID_RAW FROM GL_ROOT where NAME='"<<remfile.Data() <<"';";
4623      //
4624      pResult = conn->Query(myquery.str().c_str());
4625      //
4626      Row = pResult->Next();      
4627      if( !Row ){
4628        if ( strcmp(remfile.Data(),GetRootName().Data()) ){
4629          if ( IsDebug() ) printf(" No file to be removed even if option \"-remove file\" was used!!\n");
4630          return(1);
4631        };
4632        if ( IsDebug() ) printf(" No file to be removed (force mode)! \n");
4633        return(0);
4634      };
4635      //
4636      this->SetID_ROOT((UInt_t)atoll(Row->GetField(0)));
4637      this->SetID_RAW((UInt_t)atoll(Row->GetField(1)));
4638      //
4639      this->ValidationOFF();
4640      //
4641      this->RemoveCALIBS();
4642      //
4643      this->RemoveRUNS();
4644      //
4645      this->RemoveFILES();
4646      //
4647      this->SetID_ROOT(0);
4648      this->SetID_RAW(0);
4649      //
4650      return(0);
4651    };
4652    
4653    /**
4654     *
4655     * Set validation bit to zero for runs following the removing file till
4656     * 1) a run with TRK_CALIB_USED=140
4657     * 2) a run with VALIDATION = 0
4658     * 3) the next calibration
4659     *
4660     **/
4661    void PamelaDBOperations::ValidationOFF(){
4662      TSQLResult *pResult;
4663      TSQLRow *Row;
4664      stringstream myquery;
4665      Int_t unv = 0;
4666      //select ID from GL_RUN where RUNHEADER_TIME>=1152671382 AND (VALIDATION=0 OR TRK_CALIB_USED=104) order by RUNHEADER_TIME asc limit 1;
4667      myquery.str("");
4668      myquery << " SELECT MAX(RUNTRAILER_TIME) FROM GL_RUN WHERE ID_ROOT_L0="<< this->GetID_ROOT() <<";";
4669      //
4670      pResult = conn->Query(myquery.str().c_str());
4671      //
4672      Row = pResult->Next();      
4673      if( !Row->GetField(0) ){
4674        //
4675        if ( IsDebug() ) printf(" NO RUN ASSOCIATED TO THIS FILE! \n");
4676        //
4677      } else {  
4678        //
4679        UInt_t runhtime = (UInt_t)atoll(Row->GetField(0));
4680        UInt_t caltime = 0;
4681        //
4682        myquery.str("");
4683        myquery << " SELECT FROM_TIME FROM GL_TRK_CALIB where FROM_TIME>" <<runhtime;
4684        myquery << " order by FROM_TIME asc limit 1;";
4685        //
4686        if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
4687        //
4688        //
4689        delete pResult;
4690        pResult = conn->Query(myquery.str().c_str());
4691        //
4692        Row = pResult->Next();      
4693        if( !Row ){
4694          caltime = runhtime;
4695        } else {
4696          caltime = (UInt_t)atoll(Row->GetField(0));
4697        };
4698        //
4699        myquery.str("");
4700        myquery << " SELECT ID,RUNHEADER_TIME from GL_RUN where RUNHEADER_TIME>="<< runhtime <<" AND (VALIDATION=0 OR TRK_CALIB_USED=104 OR RUNHEADER_TIME>" ;
4701        myquery << caltime << ") order by RUNHEADER_TIME asc LIMIT 1";
4702        //
4703        if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
4704        //
4705        pResult = conn->Query(myquery.str().c_str());
4706        //
4707        Row = pResult->Next();      
4708        if( !Row ){
4709          //
4710          if ( IsDebug() ) printf(" NO RUN NEED TO BE UNVALIDATED \n");
4711          //
4712        } else {
4713          myquery.str("");
4714          myquery << " SELECT ID from GL_RUN where RUNHEADER_TIME<"<< Row->GetField(1) <<" AND ";
4715          myquery << " RUNHEADER_TIME>=" <<runhtime;
4716          myquery << " order by RUNHEADER_TIME asc;";
4717          //
4718          if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
4719          //
4720          pResult = conn->Query(myquery.str().c_str());
4721          //
4722          Row = pResult->Next();  
4723          while ( Row ){
4724            //      
4725            unv++;
4726            this->assignVALIDATION((UInt_t)atoll(Row->GetField(0)), false);
4727            Row = pResult->Next();  
4728            //
4729          };
4730        };
4731      };
4732      if ( IsDebug() ) printf(" %u runs have been unvalidated \n",unv);
4733    };
4734    
4735    /**
4736     *
4737     * Rearrange GL_RUN table and remove runs
4738     *
4739     **/
4740    void PamelaDBOperations::RemoveRUNS(){
4741      TSQLResult *pResult;
4742      TSQLRow *Row;
4743      stringstream myquery;
4744      UInt_t drun = 0;
4745      GL_RUN *delrun = new GL_RUN();
4746      //
4747      myquery.str("");
4748      myquery << " SELECT ID FROM GL_RUN where ID_RUN_FRAG=0 and ID_ROOT_L0=" <<this->GetID_ROOT() <<";";
4749      //
4750      if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
4751      //
4752      pResult = conn->Query(myquery.str().c_str());
4753      //
4754      Row = pResult->Next();    
4755      //
4756      //
4757      if ( !Row ){
4758        if ( IsDebug() ) printf(" No run with ID_RUN_FRAG=0 belonged to this file \n");
4759      } else {
4760        if ( IsDebug() ) printf(" Deleting run from GL_RUN table \n");    
4761        while ( Row ){
4762          delrun->DeleteRun(conn,(UInt_t)atoll(Row->GetField(0)),"GL_RUN");
4763          if ( IsDebug() ) printf(" del run %u \n",(UInt_t)atoll(Row->GetField(0)));
4764          drun++;
4765          Row = pResult->Next();    
4766        };
4767      };
4768      //
4769      //
4770      myquery.str("");
4771      myquery << " SELECT ID,ID_RUN_FRAG FROM GL_RUN where ID_RUN_FRAG!=0 and ID_ROOT_L0=" <<this->GetID_ROOT() <<";";
4772      //
4773      if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
4774      //
4775      pResult = conn->Query(myquery.str().c_str());
4776      //
4777      Row = pResult->Next();    
4778      //
4779      if ( !Row ){
4780        if ( IsDebug() ) printf(" No run with ID_RUN_FRAG!=0 belonged to this file \n");
4781      } else {
4782        if ( IsDebug() ) printf(" Deleting run fragments from GL_RUN table \n");    
4783        while ( Row ){
4784          if ( IsDebug() ) printf(" restore run %u \n",(UInt_t)atoll(Row->GetField(1)));
4785          delrun->RestoreRun(conn,(UInt_t)atoll(Row->GetField(1)),"GL_RUN_FRAGMENTS");
4786          if ( IsDebug() ) printf(" del run %u \n",(UInt_t)atoll(Row->GetField(1)));
4787          delrun->DeleteRun(conn,(UInt_t)atoll(Row->GetField(1)),"GL_RUN");
4788          if ( (UInt_t)atoll(Row->GetField(1)) != (UInt_t)atoll(Row->GetField(0)) ){
4789            if ( IsDebug() ) printf(" del run %u \n",(UInt_t)atoll(Row->GetField(0)));
4790            delrun->DeleteRun(conn,(UInt_t)atoll(Row->GetField(0)),"GL_RUN");
4791          };
4792          drun++;
4793          Row = pResult->Next();    
4794        };
4795      };
4796      //
4797      if ( IsDebug() ) printf(" Deleted %i run(s) from GL_RUN table \n",drun);    
4798      //
4799      //
4800      //
4801      drun = 0;
4802      //
4803      myquery.str("");
4804      myquery << " SELECT ID_TRASH FROM GL_RUN_TRASH where BELONGED_TO='GL_RUN_FRAGMENTS' AND ID_ROOT_L0=" <<this->GetID_ROOT() <<";";
4805      //
4806      pResult = conn->Query(myquery.str().c_str());
4807      //
4808      Row = pResult->Next();    
4809      //
4810      if ( !Row ){
4811        if ( IsDebug() ) printf(" No run from GL_RUN_FRAGMENTS table in the trash table for this file \n");
4812      } else {
4813        if ( IsDebug() ) printf(" Deleting run fragments from GL_RUN_TRASH table \n");    
4814        while ( Row ){
4815          if ( IsDebug() ) printf(" del run idtrash %u \n",(UInt_t)atoll(Row->GetField(0)));
4816          myquery.str("");
4817          myquery << " DELETE FROM GL_RUN_TRASH where ID_TRASH=" << Row->GetField(0) <<";";      
4818          conn->Query(myquery.str().c_str());
4819          drun++;
4820          Row = pResult->Next();    
4821        };
4822      };
4823      //  
4824      if ( IsDebug() ) printf(" Deleted %u run(s) from GL_RUN_TRASH table \n",drun);    
4825      //
4826      //
4827      //
4828      drun = 0;
4829      //
4830      myquery.str("");
4831      myquery << " SELECT ID FROM GL_RUN_FRAGMENTS where ID_ROOT_L0=" <<this->GetID_ROOT() <<";";
4832      //
4833      pResult = conn->Query(myquery.str().c_str());
4834      //
4835      Row = pResult->Next();    
4836      //
4837      if ( !Row ){
4838        if ( IsDebug() ) printf(" No run in the GL_RUN_FRAGMENTS table for this file \n");
4839      } else {
4840        if ( IsDebug() ) printf(" Deleting run fragments from GL_RUN_FRAGMENTS table \n");    
4841        while ( Row ){
4842          if ( IsDebug() ) printf(" del run %u \n",(UInt_t)atoll(Row->GetField(0)));
4843          myquery.str("");
4844          myquery << " DELETE FROM GL_RUN_FRAGMENTS where ID=" << Row->GetField(0) <<";";
4845          conn->Query(myquery.str().c_str());
4846          drun++;
4847          Row = pResult->Next();    
4848        };
4849      };
4850      //  
4851      if ( IsDebug() ) printf(" Deleted %u run(s) from GL_RUN_FRAGMENTS table \n",drun);    
4852      //
4853      //
4854      //
4855      delete delrun;
4856      //
4857    };
4858    
4859    
4860    /**
4861     *
4862     * Rearrange calibration tables
4863     *
4864     **/
4865    void PamelaDBOperations::RemoveFILES(){
4866      stringstream myquery;
4867      //
4868      myquery.str("");
4869      myquery << " DELETE FROM GL_RAW WHERE ID=" <<this->GetID_RAW() <<";";
4870      //
4871      if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
4872      //
4873      conn->Query(myquery.str().c_str());
4874      //
4875    };
4876    
4877    /**
4878     *
4879     * Rearrange calibration tables
4880     *
4881     **/
4882    void PamelaDBOperations::RemoveCALIBS(){
4883      TSQLResult *pResult;
4884      TSQLRow *Row;
4885      stringstream myquery;
4886      //  
4887      //
4888      // Calorimeter
4889      //
4890      for (Int_t section = 0; section < 4; section++){
4891        myquery.str("");
4892        myquery << " SELECT MIN(FROM_TIME),MAX(TO_TIME) FROM GL_CALO_CALIB WHERE ID_ROOT_L0="<< this->GetID_ROOT() <<" AND ";
4893        myquery << " SECTION=" << section << ";";
4894        //
4895        pResult = conn->Query(myquery.str().c_str());
4896        //
4897        Row = pResult->Next();      
4898        if( !Row->GetField(0) || !Row->GetField(1) ){
4899          //
4900          if ( IsDebug() ) printf(" NO CALO CALIBRATION SECTION %i ASSOCIATED TO THIS FILE! \n",section);
4901          //
4902        } else {
4903          //
4904          myquery.str("");
4905          myquery << " UPDATE GL_CALO_CALIB SET TO_TIME=" << Row->GetField(1);
4906          myquery << " WHERE TO_TIME="<< Row->GetField(0) << " AND ";
4907          myquery << " SECTION=" << section << ";";
4908          //
4909          pResult = conn->Query(myquery.str().c_str());
4910          //
4911          if( !pResult ){
4912            //
4913            if ( IsDebug() ) printf(" ERROR DELETING CALO CALIBRATIONS \n");
4914            //
4915            throw -4;
4916            //
4917          };
4918          //
4919        };
4920      };
4921      Bool_t OLDDB = false;
4922      for (Int_t section = 0; section < 4; section++){
4923        myquery.str("");
4924        myquery << " SELECT MIN(FROM_TIME),MAX(TO_TIME) FROM GL_CALOPULSE_CALIB WHERE ID_ROOT_L0="<< this->GetID_ROOT() <<" AND ";
4925        myquery << " SECTION=" << section << ";";
4926        //
4927        pResult = conn->Query(myquery.str().c_str());
4928        //
4929        if ( conn->GetErrorCode() ){
4930          printf(" Section %i : warning, old databse structure no GL_CALOPULSE_CALIB table!\n",section);
4931          OLDDB=true;
4932        } else {
4933          Row = pResult->Next();      
4934          if( !Row->GetField(0) || !Row->GetField(1) ){
4935            //
4936            if ( IsDebug() ) printf(" NO PULSE CALO CALIBRATION SECTION %i ASSOCIATED TO THIS FILE! \n",section);
4937            //
4938          } else {
4939            //
4940            myquery.str("");
4941            myquery << " UPDATE GL_CALOPULSE_CALIB SET TO_TIME=" << Row->GetField(1);
4942            myquery << " WHERE TO_TIME="<< Row->GetField(0) << " AND ";
4943            myquery << " SECTION=" << section << ";";
4944            //
4945            pResult = conn->Query(myquery.str().c_str());
4946            //
4947            if( !pResult ){
4948              //
4949              if ( IsDebug() ) printf(" ERROR DELETING CALO PULSE CALIBRATIONS \n");
4950              //
4951              throw -4;
4952              //
4953            };
4954            //
4955          };
4956        };
4957      };
4958      myquery.str("");
4959      myquery << " DELETE FROM GL_CALO_CALIB WHERE ID_ROOT_L0=" << this->GetID_ROOT() << ";";
4960      //
4961      pResult = conn->Query(myquery.str().c_str());
4962      //
4963      if( !pResult ){
4964        //
4965        if ( IsDebug() ) printf(" ERROR DELETING CALO CALIBRATIONS \n");
4966        //
4967        throw -4;
4968        //
4969      };
4970      //
4971      myquery.str("");
4972      myquery << " DELETE FROM GL_CALOPULSE_CALIB WHERE ID_ROOT_L0=" << this->GetID_ROOT() << ";";
4973      //
4974      pResult = conn->Query(myquery.str().c_str());
4975      if ( IsDebug() ) printf(" Delete from GL_CALOPULSE_CALIB query is %s \n",myquery.str().c_str());
4976      if ( !OLDDB ){
4977        //
4978        if( !pResult ){
4979          //
4980          if ( IsDebug() ) printf(" ERROR DELETING PULSE CALO CALIBRATIONS \n");
4981          //
4982          throw -4;
4983          //
4984        };
4985      };
4986      //
4987      // Tracker
4988      //
4989      myquery.str("");
4990      myquery << " SELECT MIN(FROM_TIME),MAX(TO_TIME) FROM GL_TRK_CALIB WHERE ID_ROOT_L0="<< this->GetID_ROOT() <<";";
4991      //
4992      pResult = conn->Query(myquery.str().c_str());
4993      //
4994      Row = pResult->Next();      
4995      if( !Row->GetField(0) || !Row->GetField(1) ){
4996        //
4997        if ( IsDebug() ) printf(" NO TRK CALIBRATION ASSOCIATED TO THIS FILE! \n");
4998        //
4999      } else {
5000        //
5001        myquery.str("");
5002        myquery << " UPDATE GL_TRK_CALIB SET TO_TIME=" << Row->GetField(1);
5003        myquery << " WHERE TO_TIME="<< Row->GetField(0) << ";";
5004        //
5005        pResult = conn->Query(myquery.str().c_str());
5006        //
5007        if( !pResult ){
5008          //
5009          if ( IsDebug() ) printf(" ERROR DELETING TRK CALIBRATIONS \n");
5010          //
5011          throw -4;
5012          //
5013        };
5014        //
5015        myquery.str("");
5016        myquery << " DELETE FROM GL_TRK_CALIB WHERE ID_ROOT_L0=" << this->GetID_ROOT() << ";";
5017        //
5018        pResult = conn->Query(myquery.str().c_str());
5019        //
5020        if( !pResult ){
5021          //
5022          if ( IsDebug() ) printf(" ERROR DELETING TRK CALIBRATIONS \n");
5023          //
5024          throw -4;
5025          //
5026        };
5027      };
5028      //
5029      //
5030      // S4
5031      //
5032      myquery.str("");
5033      myquery << " SELECT MIN(FROM_TIME),MAX(TO_TIME) FROM GL_S4_CALIB WHERE ID_ROOT_L0="<< this->GetID_ROOT() <<";";
5034      //
5035      pResult = conn->Query(myquery.str().c_str());
5036      //
5037      Row = pResult->Next();      
5038      if( !Row->GetField(0) || !Row->GetField(1) ){
5039        //
5040        if ( IsDebug() ) printf(" NO S4 CALIBRATION ASSOCIATED TO THIS FILE! \n");
5041        //
5042      } else {
5043        //
5044        myquery.str("");
5045        myquery << " UPDATE GL_S4_CALIB SET TO_TIME=" << Row->GetField(1);
5046        myquery << " WHERE TO_TIME="<< Row->GetField(0) << ";";
5047        //
5048        pResult = conn->Query(myquery.str().c_str());
5049        //
5050        if( !pResult ){
5051          //
5052          if ( IsDebug() ) printf(" ERROR DELETING S4 CALIBRATIONS \n");
5053          //
5054          throw -4;
5055          //
5056        };
5057        //
5058        myquery.str("");
5059        myquery << " DELETE FROM GL_S4_CALIB WHERE ID_ROOT_L0=" << this->GetID_ROOT() << ";";
5060        //
5061        pResult = conn->Query(myquery.str().c_str());
5062        //
5063        if( !pResult ){
5064          //
5065          if ( IsDebug() ) printf(" ERROR DELETING S4 CALIBRATIONS \n");
5066          //
5067          throw -4;
5068          //
5069        };
5070        //
5071      };
5072    };
5073    
5074    /**
5075     *
5076     * Rearrange calibration tables
5077     *
5078     **/
5079    UInt_t PamelaDBOperations::ValidateTrkCalib( CalibTrk1Event* caltrk, EventHeader *eh ){
5080    
5081        Int_t vorder[]={5,5,3,3,4,4,2,2,1,1,0,0};
5082        UInt_t timeaftercalib=120000; //2000;
5083    //  ----------
5084    //  Check CRCs
5085    //  ----------
5086        for(Int_t ipkt=0; ipkt<6; ipkt++){
5087            if( caltrk->crc_hcal[ipkt] )return 0; // :-(
5088            for(Int_t ilad=0; ilad<3; ilad++)if( caltrk->crc_cal[ipkt][ilad] )return 0; // :-(
5089        }
5090    //  -----------------------
5091    //  Check missing packets:
5092    //  -----------------------
5093    //    Readout order:
5094    //    ------------------
5095    //    DSP   packet board
5096    //    ------------------
5097    //    12    0      1
5098    //    10    1      1
5099    //     8    2      1
5100    //     4    3      1
5101    //     6    4      1
5102    //     2    5      1
5103    //    ------------------
5104    //    11    0      2
5105    //     9    1      2
5106    //     7    2      2
5107    //     3    3      2
5108    //     5    4      2
5109    //     1    5      2
5110    //    ------------------
5111    //  -------------------------------------------------
5112    //  Check if it is first or second calibration packet
5113    //  -------------------------------------------------
5114        UInt_t build=0;
5115        TString classname = caltrk->GetName();
5116        UInt_t base=0;
5117        UInt_t mask=0;
5118        if(classname.Contains("CalibTrk1Event")){
5119            base=12;
5120            mask=0x03F000;
5121        }
5122        if(classname.Contains("CalibTrk2Event")){
5123            base=18;
5124            mask=0xFC0000;
5125        }
5126    //  -------------------------------------------------
5127    //  Count number of packets and set build variable
5128    //  -------------------------------------------------
5129        Int_t  npkts=0;
5130        for(Int_t ipkt=0; ipkt<6; ipkt++){
5131            if(caltrk->DSPnumber[ipkt]>0 && caltrk->DSPnumber[ipkt]<=12){
5132                npkts++;
5133                build = build | ( 1<<(base+vorder[caltrk->DSPnumber[ipkt]-1]) );
5134            }
5135        }
5136    //    if( npkts==6 )return 1; // :-)
5137    
5138    //    cout << classname << " "<<eh->GetPscuHeader()->GetOrbitalTime()<<endl;
5139    
5140    //  -----------------------------------------------
5141    //  If missing packets: check the acq configuration
5142    //  (some DSPs might be excluded from acquisition)
5143    //  -----------------------------------------------
5144    
5145    //  -----------------------------------------------
5146    //  retrieve the first run header after calib
5147    //  -----------------------------------------------
5148         PacketType *pctp;
5149         EventCounter *cod;
5150         cod = eh->GetCounter();
5151         Int_t irun = cod->Get(pctp->RunHeader);
5152         TTree *rh=(TTree*)file->Get("RunHeader");
5153         if ( !rh || rh->IsZombie() ) throw -17;
5154         if( rh->GetEntries() == irun ){
5155              if ( IsDebug() ) cout << "ValidateTrkCalib: (MISSING VIEW) no runs after calib (1)  -- cannot validate :-( "<<endl;
5156             return 0; // :-(
5157         }
5158    
5159         RunHeaderEvent *run  = 0;
5160         EventHeader    *hrun = 0;
5161         rh->SetBranchAddress("RunHeader", &run);
5162         rh->SetBranchAddress("Header", &hrun);
5163         rh->GetEntry(irun);
5164    //     cout << classname << " "<<eh->GetPscuHeader()->GetOrbitalTime() << " Run " << hrun->GetPscuHeader()->GetOrbitalTime() <<endl;
5165    
5166         if( OBT(hrun->GetPscuHeader()->GetOrbitalTime()) < OBT(eh->GetPscuHeader()->GetOrbitalTime())){
5167              if ( IsDebug() ) cout << "ValidateTrkCalib: (MISSING VIEW) no runs after calib (2) -- cannot validate :-( "<<endl;
5168             return 0; // :-(
5169         }
5170        
5171         if( !run->RM_ACQ_AFTER_CALIB ){
5172              if ( IsDebug() ) cout << "ValidateTrkCalib: (MISSING VIEW) RM_ACQ_AFTER_CALIB=0    -- cannot validate :-( "<<endl;
5173             return 0; // :-(
5174         }
5175    
5176         UInt_t dtime = OBT(hrun->GetPscuHeader()->GetOrbitalTime()) - OBT(eh->GetPscuHeader()->GetOrbitalTime());
5177         if( dtime > timeaftercalib ){
5178             if ( IsDebug() ) cout << "ValidateTrkCalib: (MISSING VIEW) run after calib too far ( "<<dtime<<"ms ) -- cannot validate :-( "<<endl;
5179             return 0; // :-(
5180         }
5181        
5182    
5183    
5184         if( (run->ACQ_BUILD_INFO & mask) != build ){
5185             if ( IsDebug() ) cout << "ValidateTrkCalib: (MISSING VIEW) ACQ_BUILD_INFO= >>> "<<hex << (run->ACQ_BUILD_INFO&mask) << " != "<< build << dec<<endl;
5186             return 0; // :-(
5187         }
5188         return 1; // :-)
5189    
5190    }
5191    
5192    /**
5193     *
5194     * Check the DB (only for overlapping runs at the moment)
5195     *
5196     **/
5197    UInt_t PamelaDBOperations::Check(){
5198      //
5199      UInt_t test = 0;
5200      //
5201      UInt_t thisrht = 0;
5202      UInt_t thisrtt = 0;
5203      UInt_t thisid = 0;
5204      UInt_t prevrht = 0;
5205      UInt_t prevrtt = 0;
5206      UInt_t previd = 0;
5207      //
5208      UInt_t prevl0id = 0;
5209      UInt_t thisl0id = 0;
5210      //
5211      stringstream oss;
5212      TSQLResult *result = 0;
5213      TSQLRow    *row    = 0;
5214      TSQLResult *result2 = 0;
5215      TSQLRow    *row2    = 0;
5216      TSQLResult *result3 = 0;
5217      TSQLRow    *row3    = 0;
5218      oss.str("");
5219      oss << "SELECT ID,ID_ROOT_L0,RUNHEADER_TIME,RUNTRAILER_TIME,NEVENTS FROM GL_RUN order by RUNHEADER_TIME asc;";
5220      //  oss << "SELECT ID,RUNHEADER_TIME,RUNTRAILER_TIME FROM GL_RUN where ID>10170 and ID<10190 order by RUNHEADER_TIME asc;";
5221      result = conn->Query(oss.str().c_str());
5222      //
5223      if ( !result ) throw -4;;
5224      //
5225      row = result->Next();
5226      UInt_t nid = 0;
5227      //
5228      while ( row ){
5229        nid++;
5230        if ( !(nid%1000) && nid ) printf(" %iK run scanned \n",nid/1000);
5231        thisid = (UInt_t)atoll(row->GetField(0));
5232        thisl0id = (UInt_t)atoll(row->GetField(1));
5233        thisrht = (UInt_t)atoll(row->GetField(2));
5234        thisrtt = (UInt_t)atoll(row->GetField(3));
5235        //
5236        if ( (UInt_t)atoll(row->GetField(4)) > 1 ){
5237          //
5238          //
5239          //
5240          oss.str("");
5241          oss << "SELECT ID,ID_ROOT_L0,RUNHEADER_TIME,RUNTRAILER_TIME FROM GL_RUN WHERE ID!="
5242              << thisid << " AND ( RUNHEADER_TIME="
5243              << thisrht << " OR RUNTRAILER_TIME="
5244              << thisrtt << " ) AND NEVENTS!=0 AND NEVENTS!=1 order by RUNHEADER_TIME asc;";
5245          result3 = conn->Query(oss.str().c_str());
5246          if ( IsDebug() ) printf(" query is %s \n",oss.str().c_str());
5247          if ( result3 ){
5248            //
5249            oss.str("");
5250            oss << "SELECT ID,ID_ROOT_L0,RUNHEADER_TIME,RUNTRAILER_TIME FROM GL_RUN WHERE ID!="
5251                << thisid << " AND RUNHEADER_TIME="
5252                << thisrht << " AND RUNTRAILER_TIME!="
5253                << thisrtt << " AND NEVENTS!=0 AND NEVENTS!=1 order by RUNHEADER_TIME asc;";
5254            result3 = conn->Query(oss.str().c_str());
5255            if ( IsDebug() ) printf(" query is %s \n",oss.str().c_str());
5256            if ( result3 ){
5257              row3 = result3->Next();
5258              //
5259              while ( row3 ){
5260                //
5261                // 2 runs with same runheader
5262                //
5263                printf(" CHECK n.4 RUNs %u and %u HAVE SAME RUNHEADER \n",thisid,(UInt_t)atoll(row3->GetField(0)));  
5264                row3 = result3->Next();
5265              };
5266            };
5267            //
5268            oss.str("");
5269            oss << "SELECT ID,ID_ROOT_L0,RUNHEADER_TIME,RUNTRAILER_TIME FROM GL_RUN WHERE ID!="
5270                << thisid << " AND RUNHEADER_TIME!="
5271                << thisrht << " AND RUNTRAILER_TIME="
5272                << thisrtt << " AND NEVENTS!=0 AND NEVENTS!=1 order by RUNHEADER_TIME asc;";
5273            result3 = conn->Query(oss.str().c_str());
5274            if ( IsDebug() ) printf(" query is %s \n",oss.str().c_str());
5275            if ( result3 ){
5276              row3 = result3->Next();
5277              //
5278              while ( row3 ){
5279                //
5280                // 2 runs with same runtrailer
5281                //
5282                printf(" CHECK n.5 RUNs %u and %u HAVE SAME RUNTRAILER \n",thisid,(UInt_t)atoll(row3->GetField(0)));
5283                row3 = result3->Next();
5284              };
5285            };
5286            //
5287            oss.str("");
5288            oss << "SELECT ID,ID_ROOT_L0,RUNHEADER_TIME,RUNTRAILER_TIME FROM GL_RUN WHERE ID!="
5289                << thisid << " AND RUNHEADER_TIME="
5290                << thisrht << " AND RUNTRAILER_TIME="
5291                << thisrtt << " AND ID_RUN_FRAG!="
5292                << thisid << " order by RUNHEADER_TIME asc;";
5293            result3 = conn->Query(oss.str().c_str());
5294            if ( result3 ){
5295              row3 = result3->Next();
5296              //
5297              while ( row3 ){
5298                //
5299                // duplicated run
5300                //
5301                printf(" CHECK n.7 RUNs %u and %u HAVE SAME RUNTRAILER AND RUNHEADER (ARE THE SAME?) \n",thisid,(UInt_t)atoll(row3->GetField(0)));
5302                row3 = result3->Next();
5303              };
5304            };
5305          };
5306          //
5307          oss.str("");
5308          oss << "SELECT ID,ID_ROOT_L0,RUNHEADER_TIME,RUNTRAILER_TIME FROM GL_RUN WHERE ID!="
5309              << thisid << " AND RUNHEADER_TIME>"
5310              << thisrht << " AND RUNTRAILER_TIME<"
5311              << thisrtt << " order by RUNHEADER_TIME asc;";
5312          result3 = conn->Query(oss.str().c_str());
5313          if ( result3 ){
5314            row3 = result3->Next();
5315            //
5316            while ( row3 ){
5317              //
5318              // run contained in the checked one
5319              //
5320              printf(" CHECK n.6 RUN %u CONTAINS RUN %u  \n",thisid,(UInt_t)atoll(row3->GetField(0)));
5321              row3 = result3->Next();
5322            };
5323          };
5324          //
5325        };
5326        //
5327        //    if ( thisrht < prevrtt || thisrtt < prevrht || thisrht > thisrtt && !(!prevrht && !prevrtt &&!previd) ){
5328        //    if ( (thisrht < prevrtt || thisrtt < prevrht || thisrht > thisrtt) && (thisrht != prevrht) ){
5329        if ( (thisrht < prevrtt) && (thisrht != prevrht) ){
5330          if ( IsDebug() ) printf(" IDprev %u ID %u    prevrht %u prevrtt %u  thisrht %u thisrtt %u \n",previd,thisid,prevrht,prevrtt,thisrht,thisrtt);
5331          printf(" CHECK n.1 TIME SCREW of %i s AROUND RUNs %u and %u \n",(thisrht-prevrtt),previd,thisid);
5332          TString prevf = "";
5333          TString thisf = "";
5334          oss.str("");
5335          oss << "SELECT NAME FROM GL_ROOT where ID=" << (UInt_t)prevl0id <<";";
5336          result2 = conn->Query(oss.str().c_str());
5337          if ( !result2 ) throw -4;;
5338          row2 = result2->Next();
5339          prevf = (TString)row2->GetField(0);
5340          oss.str("");
5341          oss << "SELECT NAME FROM GL_ROOT where ID=" << (UInt_t)thisl0id <<";";
5342          result2 = conn->Query(oss.str().c_str());
5343          if ( !result2 ) throw -4;;
5344          row2 = result2->Next();
5345          thisf = (TString)row2->GetField(0);
5346          if ( IsDebug() ) printf(" ==> files %s and %s \n",prevf.Data(),thisf.Data());
5347          test = 1;
5348        };
5349        //
5350        if ( (thisrtt < prevrht) && (thisrht != prevrht) ){
5351          if ( IsDebug() ) printf(" IDprev %u ID %u    prevrht %u prevrtt %u  thisrht %u thisrtt %u \n",previd,thisid,prevrht,prevrtt,thisrht,thisrtt);
5352          printf(" CHECK n.2 TIME SCREW of %i s AROUND RUNs %u and %u \n",(thisrtt-prevrht),previd,thisid);
5353          TString prevf = "";
5354          TString thisf = "";
5355          oss.str("");
5356          oss << "SELECT NAME FROM GL_ROOT where ID=" << (UInt_t)prevl0id <<";";
5357          result2 = conn->Query(oss.str().c_str());
5358          if ( !result2 ) throw -4;
5359          row2 = result2->Next();
5360          prevf = (TString)row2->GetField(0);
5361          oss.str("");
5362          oss << "SELECT NAME FROM GL_ROOT where ID=" << (UInt_t)thisl0id <<";";
5363          result2 = conn->Query(oss.str().c_str());
5364          if ( !result2 ) throw -4;;
5365          row2 = result2->Next();
5366          thisf = (TString)row2->GetField(0);
5367          if ( IsDebug() ) printf(" ==> files %s and %s \n",prevf.Data(),thisf.Data());
5368          test = 1;
5369        };
5370        //
5371        if ( (thisrht > thisrtt) && (thisrht != prevrht) ){
5372          if ( IsDebug() ) printf(" IDprev %u ID %u    prevrht %u prevrtt %u  thisrht %u thisrtt %u \n",previd,thisid,prevrht,prevrtt,thisrht,thisrtt);
5373          printf(" CHECK n.3 TIME SCREW of %i s AROUND RUNs %u and %u \n",(thisrht-thisrtt),previd,thisid);
5374          TString prevf = "";
5375          TString thisf = "";
5376          oss.str("");
5377          oss << "SELECT NAME FROM GL_ROOT where ID=" << (UInt_t)prevl0id <<";";
5378          result2 = conn->Query(oss.str().c_str());
5379          if ( !result2 ) throw -4;;
5380          row2 = result2->Next();
5381          prevf = (TString)row2->GetField(0);
5382          oss.str("");
5383          oss << "SELECT NAME FROM GL_ROOT where ID=" << (UInt_t)thisl0id <<";";
5384          result2 = conn->Query(oss.str().c_str());
5385          if ( !result2 ) throw -4;;
5386          row2 = result2->Next();
5387          thisf = (TString)row2->GetField(0);
5388          if ( IsDebug() ) printf(" ==> files %s and %s \n",prevf.Data(),thisf.Data());
5389          test = 1;
5390        };
5391    
5392        //
5393        prevrht = thisrht;
5394        prevrtt = thisrtt;
5395        previd = thisid;
5396        prevl0id = thisl0id;
5397        row = result->Next();
5398      };
5399      //
5400      return(test);
5401      //
5402    };
Legend:
Removed from v.1.5  
changed lines
  Added in v.1.53
  ViewVC Help
Powered by ViewVC 1.1.23