/[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.1 by mocchiut, Wed Aug 30 11:18:13 2006 UTC revision 1.45 by mocchiut, Tue Jun 5 07:01:26 2007 UTC
# Line 8  Line 8 
8  #include <list>  #include <list>
9  #include <errno.h>  #include <errno.h>
10  //  //
11    #include <TFile.h>
12    #include <TSystem.h>
13  #include <TSQLResult.h>  #include <TSQLResult.h>
 #include <TRFIOFile.h>  
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 29  Line 30 
30  #include <varDump/VarDumpEvent.h>  #include <varDump/VarDumpEvent.h>
31  #include <varDump/VarDumpRecord.h>  #include <varDump/VarDumpRecord.h>
32  #include <physics/S4/S4Event.h>  #include <physics/S4/S4Event.h>
   
33  //  //
34    #include <sgp4.h>
35    
36  #include <PamelaDBOperations.h>  #include <PamelaDBOperations.h>
37  //  //
38  using namespace std;  using namespace std;
39  using namespace pamela;  using namespace pamela;
40  //using namespace yngn::util;  
41    // Some function to work with cTle stuff.
42    bool compTLE(cTle* tle1, cTle *tle2);
43    float getTleJulian(cTle *);
44    string getTleDatetime(cTle*);
45    
46  /**  /**
47   * Constructor.   * Constructor.
# Line 48  using namespace pamela; Line 54  using namespace pamela;
54   * @param obt0         file obt0.   * @param obt0         file obt0.
55   * @param tsync        file timesync.   * @param tsync        file timesync.
56   * @param debug        debug flag.   * @param debug        debug flag.
57     * @param tlefilename  ascii file with TLE 3 line elements.
58   */   */
59  PamelaDBOperations::PamelaDBOperations(TString host, TString user, TString password, TString filerawname, TString filerootname, UInt_t boot, UInt_t tsync, UInt_t obt0, Bool_t debug){  PamelaDBOperations::PamelaDBOperations(TString host, TString user, TString password, TString filerawname, TString filerootname, UInt_t boot, UInt_t tsync, UInt_t obt0, Bool_t debug, TString tlefilename, UInt_t dwinput, Bool_t staticp){
60    //    //
61      STATIC=false;
62      if ( staticp ) STATIC=true;
63    //    //
64    SetConnection(host,user,password);    SetConnection(host,user,password);
65    //    //
# Line 63  PamelaDBOperations::PamelaDBOperations(T Line 72  PamelaDBOperations::PamelaDBOperations(T
72    SetTsync(tsync);    SetTsync(tsync);
73    SetObt0(obt0);    SetObt0(obt0);
74    //    //
75      SetTLEPath(tlefilename);
76      //
77    //    //
78    SetRootName(filerootname);    INSERT_RAW =!filerawname.IsNull();
79    SetRawName(filerawname);    if(INSERT_RAW)SetRawName(filerawname);
80    //    //
81    this->OpenFile();    INSERT_ROOT = !filerootname.IsNull();
82      if( INSERT_ROOT ){
83        this->SetRootName(filerootname);
84        this->SetOrbitNo(dwinput);
85        file = TFile::Open(this->GetRootName().Data());
86      } else {
87        this->SetRootName("");
88      };
89    //    //
90    this->SetID_RAW(0);    this->SetID_RAW(0);
91    this->SetID_ROOT(0);    this->SetID_ROOT(0);
92    
93      VALIDATE = false;
94      
95    //    //
96  };  };
97    
# Line 79  PamelaDBOperations::PamelaDBOperations(T Line 100  PamelaDBOperations::PamelaDBOperations(T
100   */   */
101  void PamelaDBOperations::Close(){  void PamelaDBOperations::Close(){
102    if( conn && conn->IsConnected() ) conn->Close();    if( conn && conn->IsConnected() ) conn->Close();
103      delete clean_time;
104    delete glrun;    delete glrun;
105    delete this;    delete this;
106  };  };
# Line 87  void PamelaDBOperations::Close(){ Line 109  void PamelaDBOperations::Close(){
109  // SETTERS  // SETTERS
110  //  //
111    
112    //
113    // must be out of the constructor in order to FORCE the validation of the latest runs in case you run the validation together with the latest file
114    //
115    void PamelaDBOperations::CheckValidate(Long64_t olderthan){
116      clean_time = new TDatime();
117      //
118      if(olderthan >= 0){
119        VALIDATE = true;
120        UInt_t timelim = 0;
121        timelim =  (UInt_t)clean_time->Convert(true) - olderthan;
122        clean_time->Set(timelim,false);
123      };
124    };
125    
126  /**  /**
127   * Open the DB connection   * Open the DB connection
128   * @param host         hostname for the SQL connection.   * @param host         hostname for the SQL connection.
# Line 94  void PamelaDBOperations::Close(){ Line 130  void PamelaDBOperations::Close(){
130   * @param password     password for the SQL connection.   * @param password     password for the SQL connection.
131   */   */
132  void PamelaDBOperations::SetConnection(TString host, TString user, TString password){  void PamelaDBOperations::SetConnection(TString host, TString user, TString password){
133      if ( IsDebug() ) printf(" Connecting using host = %s user = %s password = %s \n",host.Data(),user.Data(),password.Data());
134    conn = TSQLServer::Connect(host.Data(),user.Data(),password.Data());    conn = TSQLServer::Connect(host.Data(),user.Data(),password.Data());
135  };  };
136    
# Line 122  void PamelaDBOperations::SetDebugFlag(Bo Line 159  void PamelaDBOperations::SetDebugFlag(Bo
159  };  };
160    
161  /**  /**
162     * Set the autoboot flag
163     *
164     */
165    void PamelaDBOperations::SetAutoBoot(Bool_t dbg){
166      AUTOBOOT = dbg;
167    };
168    
169    /**
170     * Set the nofrag flag
171     *
172     */
173    void PamelaDBOperations::SetNoFrag(Bool_t nf){
174      NOFRAG = nf;
175    };
176    
177    /**
178   * Store the BOOT number of the RAW file.   * Store the BOOT number of the RAW file.
179   * @param boot    BOOT number of the RAW file   * @param boot    BOOT number of the RAW file
180   */   */
# Line 162  void PamelaDBOperations::SetRootName(TSt Line 215  void PamelaDBOperations::SetRootName(TSt
215  };  };
216    
217  /**  /**
218     * Store the downlink orbit number from filename.
219     */
220    void PamelaDBOperations::SetOrbitNo(UInt_t dwinput){
221      dworbit = 0;
222      //
223      if ( dwinput ){
224        dworbit = dwinput;
225        if ( IsDebug() ) printf(" Downlink orbit given by hand: %i  \n",dworbit);
226        return;
227      };
228      //
229      TString name = this->GetRootFile();
230      Int_t nlength = name.Length();
231      if ( nlength < 5 ) return;
232      TString dwo = 0;
233      for (Int_t i = 0; i<5; i++){
234        dwo.Append(name[i],1);
235      };
236      if ( dwo.IsDigit() ){
237        dworbit = (UInt_t)dwo.Atoi();
238      } else {
239        dwo="";
240        for (Int_t i = 8; i<13; i++){
241          dwo.Append(name[i],1);
242        };    
243        if ( dwo.IsDigit() ) dworbit = (UInt_t)dwo.Atoi();
244      };
245      if ( IsDebug() ) printf(" Downlink orbit is %i (dwo = %s) \n",dworbit,dwo.Data());
246      return;
247    };
248    
249    
250    
251    /**
252   * Store the NOBOOT flag.   * Store the NOBOOT flag.
253   * @param noboot    true/false.   * @param noboot    true/false.
254   */   */
# Line 170  void PamelaDBOperations::SetNOBOOT(Bool_ Line 257  void PamelaDBOperations::SetNOBOOT(Bool_
257  };  };
258    
259  /**  /**
260     * Store path to the TLE file.
261     */
262    void PamelaDBOperations::SetTLEPath(TString str){
263      tlefilename = str;
264    };
265    
266    TString PamelaDBOperations::GetRawPath(){
267      if ( STATIC ){
268        return((TString)gSystem->DirName(filerawname.Data())+'/');
269      } else {
270        return((TString)gSystem->ExpandPathName("$PAM_RAW")+'/');
271      };
272    };
273    
274    TString PamelaDBOperations::GetRootPath(){
275      if ( STATIC ){
276        return((TString)gSystem->DirName(filerootname.Data())+'/');
277      } else {
278        return((TString)gSystem->ExpandPathName("$PAM_L0")+'/');
279      };
280    };
281    
282    /**
283     * Store the olderthan variable
284     * @param olderthan
285     */
286    // void PamelaDBOperations::SetOlderThan(Long64_t oldthan){
287    //   olderthan = oldthan;
288    // };
289    
290    /**
291   * Retrieve the ID_RAW, if exists, returns NULL if does not exist.   * Retrieve the ID_RAW, if exists, returns NULL if does not exist.
292   */   */
293  Bool_t PamelaDBOperations::SetID_RAW(){  Bool_t PamelaDBOperations::SetID_RAW(){
# Line 177  Bool_t PamelaDBOperations::SetID_RAW(){ Line 295  Bool_t PamelaDBOperations::SetID_RAW(){
295    TSQLResult *result = 0;    TSQLResult *result = 0;
296    TSQLRow    *row    = 0;    TSQLRow    *row    = 0;
297    oss.str("");    oss.str("");
298    oss << "SELECT ID FROM GL_RAW WHERE "    if ( STATIC ){
299        << " PATH = '" << this->GetRawPath().Data() << "' AND "      oss << "SELECT ID FROM GL_RAW WHERE "
300        << " NAME = '" << this->GetRawFile().Data() << "' ";          << " PATH = '" << this->GetRawPath().Data() << "' AND "
301            << " NAME = '" << this->GetRawFile().Data() << "' ";  
302      } else {
303        oss << "SELECT ID FROM GL_RAW WHERE "
304            << " PATH = '$PAM_RAW' AND "
305            << " NAME = '" << this->GetRawFile().Data() << "' ";  
306      }
307    result = conn->Query(oss.str().c_str());    result = conn->Query(oss.str().c_str());
308    if (result == NULL) throw -4;    if ( result == NULL ) throw -4;
309    row = result->Next();    row = result->Next();
310    if (row == NULL) return false;    if ( !row ) return(false);
311    delete result;    delete result;
312    id = (UInt_t)atoll(row->GetField(0));    id = (UInt_t)atoll(row->GetField(0));
313    return(true);    return(true);
# Line 210  Int_t PamelaDBOperations::SetUpperLimits Line 334  Int_t PamelaDBOperations::SetUpperLimits
334    UInt_t nevent = 0;    UInt_t nevent = 0;
335    UInt_t pktlast = 0;    UInt_t pktlast = 0;
336    UInt_t obtlast = 0;    UInt_t obtlast = 0;
337    UInt_t t_pktlast = 0;    Long64_t t_pktlast = 0LL;
338    UInt_t t_obtlast = 0;    //  UInt_t t_obtlast = 0;
339    UInt_t upperpkt2 = 0;    Long64_t t_obtlast = 0LL;
340    ULong64_t upperobt2 = 0;    Long64_t upperpkt2 = 0LL;
341      Long64_t upperobt2 = 0LL;
342    UInt_t zomp = 0;    UInt_t zomp = 0;
343    UInt_t jump = 50000; // was 5000    UInt_t jump = 50000; // was 5000
344      EventCounter *code=0;
345      //
346      Long64_t deltapkt = 5000LL;
347      Long64_t deltaobt = 50000LL;
348      //
349      pcksList packetsNames;
350      pcksList::iterator Iter;
351      getPacketsNames(packetsNames);
352    //    //
353    pktfirst = 0;    pktfirst = 0;
354    obtfirst = 0;    obtfirst = 0;
355      ppktfirst = 0;
356      pobtfirst = 0;
357    //    //
358    TTree *T = 0;    TTree *T = 0;
359    T = (TTree*)file->Get("Physics");    T = (TTree*)file->Get("Physics");
# Line 232  Int_t PamelaDBOperations::SetUpperLimits Line 367  Int_t PamelaDBOperations::SetUpperLimits
367    ph = eh->GetPscuHeader();    ph = eh->GetPscuHeader();
368    pktfirst = ph->GetCounter();    pktfirst = ph->GetCounter();
369    obtfirst = ph->GetOrbitalTime();      obtfirst = ph->GetOrbitalTime();  
370      ppktfirst = pktfirst;
371      pobtfirst = obtfirst;
372      //
373      code = eh->GetCounter();
374      UInt_t en = 0;
375      for(Iter = packetsNames.begin(); Iter != packetsNames.end(); Iter++){
376        en = code->Get(GetPacketType(*Iter));
377        if ( !strcmp("CalibCalPed",*Iter) || !strcmp("CalibTrk1",*Iter) || !strcmp("CalibTrk2",*Iter) || !strcmp("CalibS4",*Iter) ){
378          if ( IsDebug() ) printf(" We have a calibration before the first physic packet: packet type is %s, entries: %i \n",*Iter,en);
379          //
380          TTree *TC = 0;
381          TC = (TTree*)file->Get("CalibCalPed");
382          if ( !TC || TC->IsZombie() ) throw -16;
383          EventHeader *ehc = 0;
384          PscuHeader *phc = 0;
385          TC->SetBranchAddress("Header", &ehc);
386          TC->GetEntry(0);
387          phc = ehc->GetPscuHeader();
388          pktfirst = phc->GetCounter();
389          obtfirst = phc->GetOrbitalTime();  
390          //
391        };
392      };  
393    //    //
394    T->GetEntry(nevent-1);    T->GetEntry(nevent-1);
395    ph = eh->GetPscuHeader();    ph = eh->GetPscuHeader();
# Line 242  Int_t PamelaDBOperations::SetUpperLimits Line 400  Int_t PamelaDBOperations::SetUpperLimits
400    upperobt = OBT(obtlast);    upperobt = OBT(obtlast);
401    upperentry = nevent-1;    upperentry = nevent-1;
402    //    //
403    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);
404    //    //
405    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);
406    //    //
407    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);
408    //    //
409    if ( !nevent ) return(2);    if ( !nevent ) return(64);
410    //    //
411    if ( nevent < 2 ) return(4);    if ( nevent < 2 ) return(128);
412      if ( nevent < jump ) jump = 1;
413      //  if ( nevent < jump ) jump = int(nevent/10);
414      //  if ( !jump ) jump = 1;
415    //    //
416    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 ){
417        //
418        if ( IsDebug() ) printf(" starting jump %i \n",jump);
419      // go back      // go back
420      zomp = nevent - 2;      zomp = nevent - 2;
421      //      //
# Line 274  Int_t PamelaDBOperations::SetUpperLimits Line 437  Int_t PamelaDBOperations::SetUpperLimits
437          upperpkt2 = PKT(ph->GetCounter());          upperpkt2 = PKT(ph->GetCounter());
438          upperobt2 = OBT(ph->GetOrbitalTime());          upperobt2 = OBT(ph->GetOrbitalTime());
439          //          //
440          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) ){
441              if ( IsDebug() ) printf(" .-. upperpkt2 %lld upperobt2 %lld \n",upperpkt2,upperobt2);  
442              if ( IsDebug() ) printf(" .-. upperpkt %lld t_pktlast %lld upperobt %lld t_obtlast %lld \n",upperpkt,t_pktlast,upperobt,t_obtlast);    
443              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);    
444              throw -13;    
445            };
446          //          //
447          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 ){
448            zomp = i + jump + 1;            zomp = i + jump + 1;
449            if ( zomp > nevent-2 ) zomp = nevent - 2;            if ( zomp > nevent-2 ) zomp = nevent - 2;
450            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);
451            break;            break;
452          };          };
453          //          //
# Line 301  Int_t PamelaDBOperations::SetUpperLimits Line 469  Int_t PamelaDBOperations::SetUpperLimits
469    // 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)
470    //    //
471    PacketType *pctp=0;    PacketType *pctp=0;
   EventCounter *code=0;  
   T->GetEntry(upperentry);  
   code = eh->GetCounter();  
   Int_t lasttrail = code->Get(pctp->RunTrailer);  
   Int_t lasthead = code->Get(pctp->RunHeader);  
472    TTree *rh=(TTree*)file->Get("RunHeader");    TTree *rh=(TTree*)file->Get("RunHeader");
473    if ( !rh || rh->IsZombie() ) throw -17;    if ( !rh || rh->IsZombie() ) throw -17;
474    TTree *rt=(TTree*)file->Get("RunTrailer");    TTree *rt=(TTree*)file->Get("RunTrailer");
# Line 319  Int_t PamelaDBOperations::SetUpperLimits Line 482  Int_t PamelaDBOperations::SetUpperLimits
482    //    //
483    rhev = rh->GetEntries();    rhev = rh->GetEntries();
484    rtev = rt->GetEntries();    rtev = rt->GetEntries();
485    UInt_t pktt = 0;    Long64_t sobtt = 0LL;
486    ULong64_t obtt = 0;    Long64_t sobth = 0LL;
487    UInt_t pkth = 0;    Long64_t spktt = 0LL;
488    ULong64_t obth = 0;    Long64_t spkth = 0LL;
489      Long64_t pktt = 0LL;
490      Long64_t obtt = 0LL;
491      Long64_t pkth = 0LL;
492      Long64_t obth = 0LL;
493    //    //
494    if ( lasttrail < rtev ){    if ( rhev || rtev ){
495      rt->GetEntry(lasttrail);  
496      pht = eht->GetPscuHeader();      T->GetEntry(upperentry);
497      pktt = PKT(pht->GetCounter());      code = eh->GetCounter();
498      obtt = OBT(pht->GetOrbitalTime());      Int_t lasttrail = code->Get(pctp->RunTrailer);
499        Int_t lasthead = code->Get(pctp->RunHeader);
500        if ( lasttrail < rtev ){
501          rt->GetEntry(lasttrail);
502          pht = eht->GetPscuHeader();
503          pktt = PKT(pht->GetCounter());
504          obtt = OBT(pht->GetOrbitalTime());
505        };
506        //
507        if ( lasthead < rhev ){
508          rh->GetEntry(lasthead);
509          phh = ehh->GetPscuHeader();
510          pkth = PKT(phh->GetCounter());
511          obth = OBT(phh->GetOrbitalTime());
512        };
513        //
514        if ( IsDebug() ) printf(" rhev before %i ph %lld upperp %lld oh %lld uppero %lld \n",rhev,pkth,upperpkt,obth,upperobt);
515        if ( pkth > upperpkt && obth > upperobt ){
516          if ( IsDebug() ) printf(" Upper limits extended to include last header: ph %lld upperp %lld oh %lld uppero %lld \n",pkth,upperpkt,obth,upperobt);
517          upperpkt = pkth;
518          upperobt = obth;
519          rhev = lasthead+1;
520        } else {
521          rhev = lasthead;
522        };
523        if ( IsDebug() ) printf(" rhev after %i ph %lld upperp %lld oh %lld uppero %lld \n",rhev,pkth,upperpkt,obth,upperobt);
524        //
525        if ( IsDebug() ) printf(" rtev beforev %i  pt %lld upperp %lld ot %lld uppero %lld \n",rtev,pktt,upperpkt,obtt,upperobt);
526        if ( pktt > upperpkt && obtt > upperobt ){
527          if ( IsDebug() ) printf(" Upper limits extended to include last trailer: pt %lld upperp %lld ot %lld uppero %lld \n",pktt,upperpkt,obtt,upperobt);
528          upperpkt = pktt;
529          upperobt = obtt;
530          rtev = lasttrail+1;
531        } else {
532          rtev = lasttrail;
533        };
534        if ( IsDebug() ) printf(" rtev after %i  pt %lld upperp %lld ot %lld uppero %lld \n",rtev,pktt,upperpkt,obtt,upperobt);
535        //  goto kikko;
536        //
537        //
538        // Check if runtrailer/runheader are within lower limits
539        //
540        //
541        pkth = 0LL;
542        obth = 0LL;
543        spkth = 0LL;
544        sobth = 0LL;
545        for (Int_t k=0; k<rhev; k++){
546          if ( k > 0 ){
547            spkth = pkth;
548            sobth = obth;
549          };
550          rh->GetEntry(k);
551          phh = ehh->GetPscuHeader();
552          pkth = PKT(phh->GetCounter());
553          obth = OBT(phh->GetOrbitalTime());
554          //
555          //    if ( IsDebug() ) printf(" k %i rhev before %i ph %u upperp %u oh %u uppero %u \n",k,rhev,pkth,spkth,obth,sobth);
556          //
557          if ( pkth < spkth && obth < sobth ){
558            if ( IsDebug() ) printf(" RH PROBLEMS determining the event repetition at the end of the file lasthead %i  \n",rhev);
559            //
560            rhev = k-1;
561            rh->GetEntry(rhev);
562            pkth = spkth;
563            obth = sobth;
564            //
565            UInt_t evbefh = 0;
566            code = ehh->GetCounter();
567            evbefh = code->Get(pctp->Physics);    
568            if ( evbefh >= 0 ){
569              T->GetEntry(evbefh);
570              ph = eh->GetPscuHeader();
571              t_pktlast = PKT(ph->GetCounter());
572              t_obtlast = OBT(ph->GetOrbitalTime());
573              if ( t_pktlast <= spkth && t_obtlast <= sobth ){ // jump
574                upperpkt = pkth;
575                upperobt = obth;
576                upperentry = evbefh-1;
577              } else {
578                while ( t_pktlast > spkth && t_obtlast > sobth && evbefh < nevent ){
579                  evbefh++;
580                  T->GetEntry(evbefh);
581                  ph = eh->GetPscuHeader();
582                  t_pktlast = PKT(ph->GetCounter());
583                  t_obtlast = OBT(ph->GetOrbitalTime());
584                };
585                T->GetEntry(evbefh-1);
586                ph = eh->GetPscuHeader();
587                upperpkt = PKT(ph->GetCounter());
588                upperobt = OBT(ph->GetOrbitalTime());
589                upperentry = evbefh-1;
590              };    
591            };
592            if ( IsDebug() ) printf(" rhev after %i ph %lld upperp %lld oh %lld uppero %lld \n",rhev,pkth,upperpkt,obth,upperobt);
593            goto kikko0;
594          };
595        };
596      kikko0:
597        //
598        //
599        //
600        pktt = 0LL;
601        obtt = 0LL;
602        spktt = 0LL;
603        sobtt = 0LL;
604        for (Int_t k=0; k<rtev; k++){
605          if ( k > 0 ){
606            spktt = pktt;
607            sobtt = obtt;
608          };
609          rt->GetEntry(k);
610          pht = eht->GetPscuHeader();
611          pktt = PKT(pht->GetCounter());
612          obtt = OBT(pht->GetOrbitalTime());
613          //
614          //    if ( IsDebug() ) printf(" k %i rtev beforev %i  pt %i upperp %i ot %llu uppero %llu \n",k,rtev,pktt,spktt,obtt,sobtt);
615          //
616          if ( pktt < spktt && obtt < sobtt ){
617            if ( IsDebug() ) printf(" RT PROBLEMS determining the event repetition at the end of the file lasttrail %i \n",rtev);
618            //
619            rtev = k-1;
620            rt->GetEntry(rtev);
621            pktt = spktt;
622            obtt = sobtt;
623            if ( IsDebug() ) printf(" lasttrail %i pt %lld upperp %lld ot %lld uppero %lld \n",rtev,pktt,upperpkt,obtt,upperobt);
624            //
625            UInt_t evbeft = 0;
626            code = eht->GetCounter();
627            evbeft = code->Get(pctp->Physics);    
628            if ( evbeft >= 0 ){
629              T->GetEntry(evbeft);
630              ph = eh->GetPscuHeader();
631              t_pktlast = PKT(ph->GetCounter());
632              t_obtlast = OBT(ph->GetOrbitalTime());
633              if ( t_pktlast <= spktt && t_obtlast <= sobtt ){ // jump
634                upperpkt = pktt;
635                upperobt = obtt;
636                upperentry = evbeft-1;
637              } else {
638                while ( t_pktlast > spktt && t_obtlast > sobtt && evbeft < nevent ){
639                  evbeft++;
640                  T->GetEntry(evbeft);
641                  ph = eh->GetPscuHeader();
642                  t_pktlast = PKT(ph->GetCounter());
643                  t_obtlast = OBT(ph->GetOrbitalTime());
644                };
645                T->GetEntry(evbeft-1);
646                ph = eh->GetPscuHeader();
647                upperpkt = PKT(ph->GetCounter());
648                upperobt = OBT(ph->GetOrbitalTime());
649                upperentry = evbeft-1;
650              };
651            };
652            if ( IsDebug() ) printf(" rtev after %i  pt %lld upperp %lld ot %lld uppero %lld \n",rtev,pktt,upperpkt,obtt,upperobt);
653            goto kikko;
654            //      break;
655            //
656          };
657          //  
658        };
659        //
660      kikko:
661        //
662        T->GetEntry(upperentry);
663        code = eh->GetCounter();
664        lasttrail = code->Get(pctp->RunTrailer);
665        lasthead = code->Get(pctp->RunHeader);
666        if ( lasttrail < rtev ){
667          rt->GetEntry(lasttrail);
668          pht = eht->GetPscuHeader();
669          pktt = PKT(pht->GetCounter());
670          obtt = OBT(pht->GetOrbitalTime());
671        };
672        //
673        if ( lasthead < rhev ){
674          rh->GetEntry(lasthead);
675          phh = ehh->GetPscuHeader();
676          pkth = PKT(phh->GetCounter());
677          obth = OBT(phh->GetOrbitalTime());
678        };
679        //
680        if ( IsDebug() ) printf(" rhev before %i ph %lld upperp %lld oh %lld uppero %lld \n",rhev,pkth,upperpkt,obth,upperobt);
681        if ( pkth > upperpkt && obth > upperobt ){
682          if ( IsDebug() ) printf(" Upper limits extended to include last header: ph %lld upperp %lld oh %lld uppero %lld \n",pkth,upperpkt,obth,upperobt);
683          upperpkt = pkth;
684          upperobt = obth;
685          rhev = lasthead+1;
686        } else {
687          rhev = lasthead;
688        };
689        if ( IsDebug() ) printf(" rhev after %i ph %lld upperp %lld oh %lld uppero %lld \n",rhev,pkth,upperpkt,obth,upperobt);
690        //
691        if ( IsDebug() ) printf(" rtev beforev %i  pt %lld upperp %lld ot %lld uppero %lld \n",rtev,pktt,upperpkt,obtt,upperobt);
692        if ( pktt > upperpkt && obtt > upperobt ){
693          if ( IsDebug() ) printf(" Upper limits extended to include last trailer: pt %lld upperp %lld ot %lld uppero %lld \n",pktt,upperpkt,obtt,upperobt);
694          upperpkt = pktt;
695          upperobt = obtt;
696          rtev = lasttrail+1;
697        } else {
698          rtev = lasttrail;
699        };
700        if ( IsDebug() ) printf(" rtev after %i  pt %lld upperp %lld ot %lld uppero %lld \n",rtev,pktt,upperpkt,obtt,upperobt);
701        //
702    };    };
703    //    //
704    if ( IsDebug() ) printf(" rtev beforev %i  pt %i upperp %i ot %llu uppero %llu \n",rtev,pktt,upperpkt,obtt,upperobt);    if ( IsDebug() ) printf(" Upper limits are: OBT %lld pkt_num %lld upper entry %i \n",upperobt,upperpkt,upperentry);
   if ( pktt > upperpkt && obtt > upperobt ){  
     if ( IsDebug() ) printf(" Upper limits extended to include last trailer: pt %i upperp %i ot %llu uppero %llu \n",pktt,upperpkt,obtt,upperobt);  
     upperpkt = pktt;  
     upperobt = obtt;  
     rtev = lasttrail+1;  
   } else {  
     rtev = lasttrail;  
   };  
   if ( IsDebug() ) printf(" rtev after %i  pt %i upperp %i ot %llu uppero %llu \n",rtev,pktt,upperpkt,obtt,upperobt);  
705    //    //
706    if ( lasthead < rhev ){    return(0);
707      rh->GetEntry(lasthead);  }
708      phh = ehh->GetPscuHeader();  
709      pkth = PKT(pht->GetCounter());  /**
710      obth = OBT(pht->GetOrbitalTime());   *
711    };   * Trick to have unique RUN ID numbers even when runs are deleted and mysql deamon restarted.
712     * Entries in the _RUNID_GEN table are never deleted.
713     *
714     **/
715    UInt_t PamelaDBOperations::AssignRunID(){
716    //    //
717    if ( IsDebug() ) printf(" rhev before %i ph %i upperp %i oh %llu uppero %llu \n",rhev,pkth,upperpkt,obth,upperobt);    TSQLResult *result = 0;
718    if ( pkth > upperpkt && obth > upperobt ){    TSQLRow *row = 0;
719      if ( IsDebug() ) printf(" Upper limits extended to include last header: ph %i upperp %i oh %llu uppero %llu \n",pkth,upperpkt,obth,upperobt);    UInt_t runid = 0;
     upperpkt = pkth;  
     upperobt = obth;  
     rhev = lasthead+1;  
   } else {  
     rhev = lasthead;  
   };  
   if ( IsDebug() ) printf(" rhev after %i ph %i upperp %i oh %llu uppero %llu \n",rhev,pkth,upperpkt,obth,upperobt);  
720    //    //
721    if ( IsDebug() ) printf(" Upper limits are: OBT %llu pkt_num %i upper entry %i \n",upperobt,upperpkt,upperentry);    stringstream   oss;
722      //  
723      oss.str("");
724      oss << "INSERT INTO _RUNID_GEN VALUES (NULL);";
725      result = conn->Query(oss.str().c_str());
726      if ( !result ) throw -10;
727      oss.str("");
728      oss << "SELECT ID FROM _RUNID_GEN ORDER BY ID DESC LIMIT 1;";
729      result = conn->Query(oss.str().c_str());
730      if ( !result ) throw -10;
731    //    //
732    return(0);    row = result->Next();
733  }    //
734      if ( !row ) throw -28;
735      //
736      runid = (UInt_t)atoll(row->GetField(0));
737      //
738      return(runid);
739    };
740    
741  //  //
742  // GETTERS  // GETTERS
# Line 440  const PacketType* PamelaDBOperations::Ge Line 813  const PacketType* PamelaDBOperations::Ge
813  // PRIVATE FUNCTIONS  // PRIVATE FUNCTIONS
814  //  //
815    
816  /**  // /**
817   * Open the ROOT filename for reading  // * Open the ROOT filename for reading
818   */  // */
819  void PamelaDBOperations::OpenFile(){  // void PamelaDBOperations::OpenFile(){
820    file = TFile::Open(this->GetRootName().Data());  //   file = TFile::Open(this->GetRootName().Data());
821    //   //
822    
823    void PamelaDBOperations::CheckFile(){  
824      if ( !file ) throw -12;
825  };  };
826    
827    
828  /**  /**
829   * Check if LEVEL0 file and DB connection have really be opened   * Check if LEVEL0 file and DB connection have really be opened
830   */   */
831  void PamelaDBOperations::CheckFile(){    void PamelaDBOperations::CheckConnection(){  
   //  
   if ( !file ) throw -12;  
832    //    //
833    // check connection    // check connection
834    //    //
835    if( !conn ) throw -1;        if( !conn ) throw -1;
836    bool connect = conn->IsConnected();    bool connect = conn->IsConnected();
837    if( !connect ) throw -1;        if( !connect ) throw -1;
838      //
839      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());
840      //
841      if ( !dworbit && strcmp(this->GetRootName().Data(),"") ) throw -27;
842      //
843      // set DB timezone to UTC
844      //
845      stringstream oss;
846      //  
847      oss.str("");
848      oss << "SET time_zone='+0:00';";
849      TSQLResult *result = 0;
850      result = conn->Query(oss.str().c_str());
851      if ( !result ) throw -10;
852      oss.str("");
853      oss << "SET wait_timeout=173000;";
854      conn->Query(oss.str().c_str());
855      //
856  };  };
857    
858  /**  /**
859   * Return the correct packet number if we went back to zero   * Return the correct packet number if we went back to zero
860   */   */
861  UInt_t PamelaDBOperations::PKT(UInt_t pkt_num){    Long64_t PamelaDBOperations::PKT(UInt_t pkt_num){  
862    //    //
863    //  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));
864    //    //
865    if ( pkt_num < (pktfirst/2) && pktfirst > (16777214/2)  ) return((pkt_num+16777215));    if ( pkt_num < (ppktfirst/2) && ppktfirst > (16777214/2)  ){
866        if ( IsDebug() ) printf(" rise up pktnum %lld \n",(Long64_t)pkt_num+16777215LL);
867        return((Long64_t)pkt_num+16777215LL);
868      };
869    //    //
870    if ( pkt_num > pktfirst*2 && pkt_num > (16777214/2) ){    if ( pkt_num > ((Long64_t)ppktfirst*2) && pkt_num > (16777214/2) ){
871      if ( (pkt_num-16777215) < 0 ){      if ( IsDebug() ) printf(" rise down pktnum %lld \n",(Long64_t)pkt_num-16777215LL);
872        return((16777215-pkt_num));      return((Long64_t)pkt_num-16777215LL);
     } else {  
       return((pkt_num-16777215));  
     };  
873    };    };
874    //    //
875    return(pkt_num);    if ( IsDebug() ) printf(" as it is %lld \n",(Long64_t)pkt_num);
876      return((Long64_t)pkt_num);
877    //    //
878  };  };
879    
880  /**  /**
881   * Return the correct On Board Time if we went back to zero   * Return the correct On Board Time if we went back to zero
882   */   */
883  ULong64_t PamelaDBOperations::OBT(UInt_t obt){    Long64_t PamelaDBOperations::OBT(UInt_t obt){  
884    //    //
885    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));
886    //    //
887    if ( obt > (obtfirst*2) && obt > (numeric_limits<UInt_t>::max()/2) ){    if ( obt < (pobtfirst/2) && pobtfirst > (numeric_limits<UInt_t>::max()/2) ){
888      if ( (obt-numeric_limits<UInt_t>::max()) < 0  ){      if ( IsDebug() ) printf(" rise up obt %lld \n",(Long64_t)(obt+numeric_limits<UInt_t>::max()));
889        return((ULong64_t)(numeric_limits<UInt_t>::max()-obt));      return((Long64_t)(obt+numeric_limits<UInt_t>::max()));
890      } else {    };
891        return((ULong64_t)(obt-numeric_limits<UInt_t>::max()));    //
892      };    if ( obt > ((Long64_t)pobtfirst*2) && obt > (numeric_limits<UInt_t>::max()/2) ){
893        if ( IsDebug() ) printf(" pobtfirst*2 %lld \n",((Long64_t)pobtfirst*2));
894        if ( IsDebug() ) printf(" rise down pktnum %lld \n", (Long64_t)obt-(Long64_t)numeric_limits<UInt_t>::max());
895        return((Long64_t)obt-(Long64_t)numeric_limits<UInt_t>::max());
896    };    };
897    //    //
898    return((ULong64_t)obt);    if ( IsDebug() ) printf(" as it is %lld \n",(Long64_t)obt);
899      return((Long64_t)obt);
900  };  };
901    
902  /**  /**
# Line 550  void PamelaDBOperations::FillClass(Bool_ Line 948  void PamelaDBOperations::FillClass(Bool_
948      lastPkt = glrun->GetRUNTRAILER_PKT();      lastPkt = glrun->GetRUNTRAILER_PKT();
949    };    };
950    //    //
951    if ( mishead && mistrail && lastev+1 == firstev ) throw -14; // run with no events, no runtrailer, no runheader... unsupported    if ( mishead && mistrail && lastev+1 == firstev ) throw -14; // run with no events, no runtrailer, no runheader... unsupported should never arrive here
952    //    //
953    if ( mishead ) {    if ( mishead ) {
954      glrun->Set_GL_RUNH0();      glrun->Set_GL_RUNH0();
# Line 613  Int_t PamelaDBOperations::insertPamelaRa Line 1011  Int_t PamelaDBOperations::insertPamelaRa
1011    if ( idr ) return(1);    if ( idr ) return(1);
1012    //    //
1013    oss.str("");    oss.str("");
1014    oss << "INSERT INTO GL_RAW (PATH, NAME) VALUES ('"    if ( STATIC ){
1015        << this->GetRawPath().Data() << "', '" << this->GetRawFile().Data() << "')";      oss << "INSERT INTO GL_RAW (PATH, NAME) VALUES ('"
1016            << this->GetRawPath().Data() << "', '" << this->GetRawFile().Data() << "')";
1017      } else {
1018        oss << "INSERT INTO GL_RAW (PATH, NAME) VALUES ('$PAM_RAW', '" << this->GetRawFile().Data() << "')";
1019      };
1020    if ( conn->Query(oss.str().c_str()) == 0 ) throw -4;    if ( conn->Query(oss.str().c_str()) == 0 ) throw -4;
1021    //    //
1022    idr =  this->SetID_RAW();    idr =  this->SetID_RAW();
# Line 633  Int_t PamelaDBOperations::insertPamelaGL Line 1035  Int_t PamelaDBOperations::insertPamelaGL
1035    TSQLResult *result = 0;    TSQLResult *result = 0;
1036    TSQLRow *row = 0;    TSQLRow *row = 0;
1037    UInt_t t0 = 0;    UInt_t t0 = 0;
1038      Int_t signal = 0;
1039      //
1040      signal = this->SetUpperLimits();
1041    //    //
1042    stringstream   oss;    stringstream   oss;
1043    //      //  
1044    if ( this->GetID_RAW() == 0 )  throw -11;    if ( this->GetID_RAW() == 0 )  throw -11;
1045    //    //
1046    oss.str("");    oss.str("");
1047    oss << "SELECT OFFSET_DATE FROM GL_RESURS_OFFSET WHERE FROM_ID_RAW<= "    oss << "SELECT YEAR(OFFSET_DATE),MONTH(OFFSET_DATE),DAY(OFFSET_DATE),HOUR(OFFSET_DATE),MINUTE(OFFSET_DATE),SECOND(OFFSET_DATE) FROM GL_RESURS_OFFSET WHERE SPECIAL_FILE='"
1048        << id << " AND TO_ID_RAW >= "        << this->GetRawFile().Data() << "';";
       << id << ";";  
1049    if ( IsDebug() ) printf(" %s \n",oss.str().c_str());    if ( IsDebug() ) printf(" %s \n",oss.str().c_str());
1050    result = conn->Query(oss.str().c_str());    result = conn->Query(oss.str().c_str());
1051    if ( !result ) throw -10;    if ( !result ) throw -10;
1052    row = result->Next();    row = result->Next();
   if ( !row ) throw -10;  
1053    //    //
1054    t0 = (UInt_t)TDatime(row->GetField(0)).Convert();    if ( !row ){
1055        oss.str("");
1056        oss << "SELECT YEAR(OFFSET_DATE),MONTH(OFFSET_DATE),DAY(OFFSET_DATE),HOUR(OFFSET_DATE),MINUTE(OFFSET_DATE),SECOND(OFFSET_DATE) FROM GL_RESURS_OFFSET WHERE FROM_ORBIT< "
1057            << dworbit << " order by FROM_ORBIT desc limit 1;";
1058        if ( IsDebug() ) printf(" %s \n",oss.str().c_str());
1059        result = conn->Query(oss.str().c_str());
1060        if ( !result ) throw -10;
1061        row = result->Next();
1062        if ( !row ) throw -10;
1063      };
1064      //
1065      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);
1066      t0 = (UInt_t)tu.GetSec();
1067      if ( IsDebug() ) printf(" t0 is %u ti is %s %s %s %s %s %s\n",t0,row->GetField(0),row->GetField(1),row->GetField(2),row->GetField(3),row->GetField(4),row->GetField(5));
1068      //
1069    /*    /*
1070     * Verify that the TIMESYNC have been not already processed     * Verify that the TIMESYNC have been not already processed
1071     */     */
# Line 663  Int_t PamelaDBOperations::insertPamelaGL Line 1080  Int_t PamelaDBOperations::insertPamelaGL
1080    if (result == NULL) throw -10;    if (result == NULL) throw -10;
1081    row = result->Next();    row = result->Next();
1082    if ((row != NULL) && ((UInt_t)atoll(row->GetField(0)) > 0)){    if ((row != NULL) && ((UInt_t)atoll(row->GetField(0)) > 0)){
1083        if ( IsDebug() ) printf(" found a timesync t0 is %u \n",t0);
1084      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;
1085        //
1086        tsync = (UInt_t)atoll(row->GetField(2));
1087        obt0 = (UInt_t)atoll(row->GetField(1));
1088        //
1089      return(1);      return(1);
1090    };    };
1091    //    //
# Line 719  Int_t PamelaDBOperations::insertPamelaGL Line 1141  Int_t PamelaDBOperations::insertPamelaGL
1141          //          //
1142          TYPE = 55;//224;          TYPE = 55;//224;
1143          //          //
1144            if ( IsDebug() ) printf("mcmd tsync %i tsync %u obt %u \n",i,TSYNC,OBT);
1145            //
1146          if ( TSYNC && OBT ){          if ( TSYNC && OBT ){
1147            existsts = true;            existsts = true;
1148            goto out;            goto eout;
1149          };          };
1150          //          //
1151        };        };
# Line 729  Int_t PamelaDBOperations::insertPamelaGL Line 1153  Int_t PamelaDBOperations::insertPamelaGL
1153    };    };
1154    if ( !existsts ) { // try with runheader and runtrailer    if ( !existsts ) { // try with runheader and runtrailer
1155      //      //
1156        if ( IsDebug() ) printf(" No ts mcmd \n");
1157        signal = 2;
1158        //
1159      TTree *rh=(TTree*)file->Get("RunHeader");      TTree *rh=(TTree*)file->Get("RunHeader");
1160      if ( !rh || rh->IsZombie() ) throw -17;      if ( !rh || rh->IsZombie() ) throw -17;
1161      TTree *rt=(TTree*)file->Get("RunTrailer");      TTree *rt=(TTree*)file->Get("RunTrailer");
# Line 738  Int_t PamelaDBOperations::insertPamelaGL Line 1165  Int_t PamelaDBOperations::insertPamelaGL
1165      //      //
1166      rt->SetBranchAddress("RunTrailer", &runt);      rt->SetBranchAddress("RunTrailer", &runt);
1167      //      //
1168      //    Int_t rhev = rh->GetEntries();      Int_t nrhev = rh->GetEntries();
1169      //    Int_t rtev = rt->GetEntries();      Int_t nrtev = rt->GetEntries();
1170        if ( IsDebug() ) printf(" ou nevent %i rhev %i rtev %i \n",nevent,nrhev,nrtev);
1171      //      //
1172      if ( rhev > 0 ){      if ( nrhev > 0 ){
1173        rh->GetEntry(0);        for (Int_t i=0; i<nrhev; i++){
1174        //          //
1175        TSYNC = runh->LAST_TIME_SYNC_INFO;          rh->GetEntry(i);
1176        OBT = runh->OBT_TIME_SYNC * 1000;          //
1177        //          TSYNC = runh->LAST_TIME_SYNC_INFO;
1178        TYPE = 20;          OBT = runh->OBT_TIME_SYNC * 1000;
1179        //          //
1180        if ( TSYNC && OBT ){          TYPE = 20;
1181          existsts = true;          //
1182          goto out;          if ( IsDebug() ) printf("runheader %i tsync %u obt %u \n",i,TSYNC,OBT);
1183            //
1184            if ( TSYNC && OBT ){
1185              existsts = true;
1186              goto eout;
1187            };
1188        };        };
1189        //        //
1190      };      };
1191      if ( rtev > 0 ){      if ( nrtev > 0 ){
       rt->GetEntry(0);  
1192        //        //
1193        TSYNC = runt->LAST_TYME_SYNC_INFO;        if ( IsDebug() ) printf(" No runheader \n");
1194        OBT = runt->OBT_TYME_SYNC * 1000;        signal = 6;
1195        //        //
1196        TYPE = 21;        for (Int_t i=0; i<nrtev; i++){
1197        //          //
1198        if ( TSYNC && OBT ){          rt->GetEntry(i);
1199          existsts = true;          //
1200          goto out;          TSYNC = runt->LAST_TYME_SYNC_INFO;
1201            OBT = runt->OBT_TYME_SYNC * 1000;
1202            //
1203            TYPE = 21;
1204            //
1205            if ( IsDebug() ) printf("runtrailer %i tsync %u obt %u \n",i,TSYNC,OBT);
1206            //
1207            if ( TSYNC && OBT ){
1208              existsts = true;
1209              goto eout;
1210            };
1211        };        };
1212        //        //
1213        } else {
1214          if ( IsDebug() ) printf(" No runheader \n");
1215      };      };
1216    };    };
1217    //    //
1218    if ( !existsts ){ // try with inclination mcmd    if ( !existsts ){ // try with inclination mcmd
1219        //
1220        if ( IsDebug() ) printf(" No runtrailer \n");
1221        signal = 14;
1222        //
1223      Double_t timesync = 0.;      Double_t timesync = 0.;
1224      for (UInt_t i=0; i<nevent;i++){      for (UInt_t i=0; i<nevent;i++){
1225        //        //
# Line 800  Int_t PamelaDBOperations::insertPamelaGL Line 1248  Int_t PamelaDBOperations::insertPamelaGL
1248        TYPE = 666;        TYPE = 666;
1249        if ( TSYNC && OBT ){        if ( TSYNC && OBT ){
1250          existsts = true;          existsts = true;
1251          goto out;          goto eout;
1252        };        };
1253      };      };
1254    };    };
1255    //    //
1256    if ( !existsts && obt0 ){ // insert timesync by hand    if ( !existsts && obt0 ){ // insert timesync by hand
1257        //
1258        if ( IsDebug() ) printf(" No incl mcmd \n");
1259        signal = 30;
1260        //
1261      OBT = obt0;      OBT = obt0;
1262      TSYNC = tsync;      TSYNC = tsync;
1263      TYPE = 999;      TYPE = 999;
1264      existsts = true;      existsts = true;
1265      goto out;      goto eout;
1266    };    };
1267    //    //
1268   out:   eout:
1269    //    //
1270    if ( !existsts ) throw -3;    if ( !existsts ) throw -3;
1271    //    //
# Line 826  Int_t PamelaDBOperations::insertPamelaGL Line 1278  Int_t PamelaDBOperations::insertPamelaGL
1278    conn->Query(oss.str().c_str());    conn->Query(oss.str().c_str());
1279    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());
1280    //    //
1281      if ( IsDebug() ) printf(" found a timesync t0 is %u \n",t0);
1282    toffset = (UInt_t)TSYNC - (UInt_t)(this->OBT(OBT)/1000) + t0;    toffset = (UInt_t)TSYNC - (UInt_t)(this->OBT(OBT)/1000) + t0;
1283    //    //
1284      tsync = TSYNC;
1285      obt0 = OBT;
1286      //
1287    delete result;    delete result;
1288    return(0);    return(signal);
1289  }  }
1290    
1291  /**  /**
# Line 843  Int_t PamelaDBOperations::insertPamelaRo Line 1299  Int_t PamelaDBOperations::insertPamelaRo
1299    UInt_t idtimesync = 0;    UInt_t idtimesync = 0;
1300    //    //
1301    oss.str("");    oss.str("");
1302    oss << " SELECT COUNT(GL_ROOT.ID_RAW),GL_RAW.ID,GL_ROOT.ID FROM GL_RAW "    if ( STATIC ){
1303        << " LEFT JOIN GL_ROOT "      oss << " SELECT COUNT(GL_ROOT.ID_RAW),GL_RAW.ID,GL_ROOT.ID FROM GL_RAW "
1304        << " ON GL_RAW.ID = GL_ROOT.ID_RAW "          << " LEFT JOIN GL_ROOT "
1305        << " WHERE GL_RAW.PATH = '" << this->GetRawPath().Data() << "' AND "          << " ON GL_RAW.ID = GL_ROOT.ID_RAW "
1306        << " GL_RAW.NAME = '" << this->GetRawFile().Data() << "' GROUP BY GL_RAW.ID ";          << " WHERE GL_RAW.PATH = '" << this->GetRawPath().Data() << "' AND "
1307            << " GL_RAW.NAME = '" << this->GetRawFile().Data() << "' GROUP BY GL_RAW.ID ";
1308      } else {
1309        oss << " SELECT COUNT(GL_ROOT.ID_RAW),GL_RAW.ID,GL_ROOT.ID FROM GL_RAW "
1310            << " LEFT JOIN GL_ROOT "
1311            << " ON GL_RAW.ID = GL_ROOT.ID_RAW "
1312            << " WHERE GL_RAW.PATH = '$PAM_RAW' AND "
1313            << " GL_RAW.NAME = '" << this->GetRawFile().Data() << "' GROUP BY GL_RAW.ID ";
1314      };
1315    result = conn->Query(oss.str().c_str());    result = conn->Query(oss.str().c_str());
1316    //    //
1317    if ( !result ) throw -12;    if ( !result ) throw -12;
# Line 874  Int_t PamelaDBOperations::insertPamelaRo Line 1338  Int_t PamelaDBOperations::insertPamelaRo
1338    idtimesync = (UInt_t)atoll(row->GetField(0));    idtimesync = (UInt_t)atoll(row->GetField(0));
1339    //    //
1340    oss.str("");    oss.str("");
1341    oss << "INSERT INTO GL_ROOT (ID_RAW, ID_TIMESYNC,PATH, NAME) VALUES ('"    if ( STATIC ){
1342        << this->GetID_RAW() << "', '" << idtimesync << "', '" << this->GetRootPath().Data() << "', '" << this->GetRootFile().Data() << "')";      oss << "INSERT INTO GL_ROOT (ID_RAW, ID_TIMESYNC,PATH, NAME) VALUES ('"
1343            << this->GetID_RAW() << "', '" << idtimesync << "', '" << this->GetRootPath().Data() << "', '" << this->GetRootFile().Data() << "')";
1344      } else {
1345        oss << "INSERT INTO GL_ROOT (ID_RAW, ID_TIMESYNC,PATH, NAME) VALUES ('"
1346            << this->GetID_RAW() << "', '" << idtimesync << "', '$PAM_L0', '" << this->GetRootFile().Data() << "')";
1347      };
1348    //    //
1349    if (conn->Query(oss.str().c_str()) == 0) throw -4;    if (conn->Query(oss.str().c_str()) == 0) throw -4;
1350    //    //
# Line 902  Int_t PamelaDBOperations::assignBOOT_NUM Line 1371  Int_t PamelaDBOperations::assignBOOT_NUM
1371    TSQLResult *result = 0;    TSQLResult *result = 0;
1372    TSQLRow    *row    = 0;    TSQLRow    *row    = 0;
1373    oss.str("");    oss.str("");
1374    oss << "SELECT ID, BOOT_NUMBER FROM GL_RAW WHERE "    if ( STATIC ){
1375        << " PATH = '" << this->GetRawPath().Data() << "' AND "      oss << "SELECT ID, BOOT_NUMBER FROM GL_RAW WHERE "
1376        << " NAME = '" << this->GetRawFile().Data() << "' ";          << " PATH = '" << this->GetRawPath().Data() << "' AND "
1377            << " NAME = '" << this->GetRawFile().Data() << "' ";
1378      } else {
1379        oss << "SELECT ID, BOOT_NUMBER FROM GL_RAW WHERE "
1380            << " PATH = '$PAM_RAW' AND "
1381            << " NAME = '" << this->GetRawFile().Data() << "' ";
1382      };
1383    result = conn->Query(oss.str().c_str());    result = conn->Query(oss.str().c_str());
1384    //    //
1385    if ( !result ) return(8);    if ( !result ) throw -4;;
1386    row = result->Next();    row = result->Next();
1387    if ( !row ) return(16);    if ( !row ) return(16);
1388    if ( row->GetField(1) ){    if ( row->GetField(1) ){
1389      this->SetBOOTnumber((UInt_t)atoll(row->GetField(1)));      this->SetBOOTnumber((UInt_t)atoll(row->GetField(1)));
1390      return(1);      return(1);
1391    };    };
1392    if ( !row->GetField(0) ) return(8);    if ( !row->GetField(0) ) throw -26;
1393    //    //
1394    UInt_t idRaw = (UInt_t)atoll(row->GetField(0));    UInt_t idRaw = (UInt_t)atoll(row->GetField(0));
1395    //    //
# Line 924  Int_t PamelaDBOperations::assignBOOT_NUM Line 1399  Int_t PamelaDBOperations::assignBOOT_NUM
1399    trDumpEv = (TTree*)file->Get("VarDump");    trDumpEv = (TTree*)file->Get("VarDump");
1400    if ( !trDumpEv || trDumpEv->IsZombie() ) throw -20;    if ( !trDumpEv || trDumpEv->IsZombie() ) throw -20;
1401    //    //
   if (trDumpEv == NULL) return(2);  
   //      
1402    VarDumpEvent  *vde = 0;    VarDumpEvent  *vde = 0;
1403    VarDumpRecord *vdr = 0;    VarDumpRecord *vdr = 0;
1404    //    //
1405      Bool_t found = false;
1406    trDumpEv->SetBranchAddress("VarDump", &vde);    trDumpEv->SetBranchAddress("VarDump", &vde);
1407    if (trDumpEv->GetEntries() > 0){    if ( trDumpEv->GetEntries() > 0 ){
1408      trDumpEv->GetEntry(0);      found = false;
1409      vde->Records->GetEntries();      for ( Int_t i = 0; i < trDumpEv->GetEntries(); i++){
1410      if ( !vde->Records->GetEntries() ){        trDumpEv->GetEntry(i);
1411        if ( !this->GetBOOTnumber() ) return(4);        //      vde->Records->GetEntries();
1412      } else {        if ( vde->Records->GetEntries()>5 ){
1413            found = true;
1414            goto fill;
1415          };
1416        };
1417      fill:
1418        if ( found ){
1419          //
1420        vdr = (VarDumpRecord*)vde->Records->At(6);        vdr = (VarDumpRecord*)vde->Records->At(6);
1421          //
1422        this->SetBOOTnumber((Int_t)vdr->VAR_VALUE);        this->SetBOOTnumber((Int_t)vdr->VAR_VALUE);
1423          //
1424        } else {
1425          if ( !this->GetBOOTnumber() && !this->AutoBoot()) return(4);
1426      };      };
1427    } else {    } else {
1428      if ( !this->GetBOOTnumber() ) return(2);      if ( !this->GetBOOTnumber() && !this->AutoBoot()) return(2);
1429    };    };
1430    //    //
1431    oss.str("");    UInt_t bn = 0;
1432    oss << " UPDATE GL_RAW "    Bool_t afound = false;
1433        << " SET GL_RAW.BOOT_NUMBER = '" << dec << this->GetBOOTnumber() << "'"    if ( !found && this->AutoBoot()){
1434        << " WHERE GL_RAW.ID = '" << idRaw << "'";      afound = true;
1435    conn->Query(oss.str().c_str());            //
1436    //      // Search for other files with similar timesync
1437    delete result;      //
1438    return(0);      if ( IsDebug() ) printf(" tsync %u obt0 %u \n",tsync,obt0);
1439  };      UInt_t upperts = tsync-(obt0/1000)+5;
1440        UInt_t lowerts = tsync-(obt0/1000)-5;
1441  /**      oss.str("");
1442   * Scan runtrailer packet, fill the GL_RUN table and      oss << "select GL_RAW.BOOT_NUMBER from GL_TIMESYNC LEFT JOIN GL_RAW ON GL_RAW.ID = GL_TIMESYNC.ID_RAW where TIMESYNC-(OBT0/1000)<"
1443   * check for missing and truncated runs          << upperts
1444   */          << " AND TIMESYNC-(OBT0/1000)>"
1445  Int_t PamelaDBOperations::insertPamelaRUN(){          << lowerts
1446            << " AND GL_RAW.BOOT_NUMBER>0 GROUP BY GL_TIMESYNC.OBT0;";
1447        result = conn->Query(oss.str().c_str());
1448        if ( IsDebug() ) printf(" Query the GL_TIMESYNC table to find boot number:\n %s \n",oss.str().c_str());
1449        //
1450        if ( !result ) throw -4;;
1451        found = true;
1452        if ( result->GetRowCount()<3 ){
1453          if ( IsDebug() ) printf(" AGH! no results!\n");
1454          found = false;
1455        } else {
1456          row = result->Next();      
1457          bn = (UInt_t)atoll(row->GetField(0));
1458          for ( Int_t r=1; r<result->GetRowCount() ;r++){
1459            if ( !row ) throw -4;
1460            if ( IsDebug() ) printf(" BOOT number is %s \n",row->GetField(0));
1461            if ( bn != (UInt_t)atoll(row->GetField(0)) ){
1462              if ( IsDebug() ) printf(" AGH! bn = %u here instead %u \n",bn,(UInt_t)atoll(row->GetField(0)));
1463              found = false;
1464            };
1465            row = result->Next();
1466          };
1467        };
1468      };
1469      //
1470      Int_t sgn = 0;
1471      //
1472      if ( !found && !BOOTNO ){
1473        throw -29;
1474      } else {
1475        if ( afound ){
1476          this->SetBOOTnumber(bn);
1477          sgn = 8;
1478        };
1479      };
1480      //
1481      oss.str("");
1482      oss << " UPDATE GL_RAW "
1483          << " SET GL_RAW.BOOT_NUMBER = '" << dec << this->GetBOOTnumber() << "'"
1484          << " WHERE GL_RAW.ID = '" << idRaw << "'";
1485      conn->Query(oss.str().c_str());      
1486      //
1487      delete result;
1488      return(sgn);
1489    };
1490    
1491    /**
1492     * Scan runtrailer packet, fill the GL_RUN table and
1493     * check for missing and truncated runs
1494     */
1495    Int_t PamelaDBOperations::insertPamelaRUN(){
1496    Int_t signal = 0;    Int_t signal = 0;
1497    //    //
1498    stringstream oss;    stringstream oss;
1499    oss.str("");    oss.str("");
1500    //    //
1501    signal = this->SetUpperLimits();    //  signal = this->SetUpperLimits();
1502    //    //
1503    // loop on runheader and runtrailer events    // loop on runheader and runtrailer events
1504    //    //
# Line 981  Int_t PamelaDBOperations::insertPamelaRU Line 1516  Int_t PamelaDBOperations::insertPamelaRU
1516    rt->SetBranchAddress("RunTrailer", &runt);    rt->SetBranchAddress("RunTrailer", &runt);
1517    rt->SetBranchAddress("Header", &eht);    rt->SetBranchAddress("Header", &eht);
1518    //    //
1519      TTree *T = (TTree*)file->Get("Physics");
1520      if ( !T || T->IsZombie() ) throw -16;
1521      EventHeader *eh = 0;
1522      T->SetBranchAddress("Header", &eh);
1523      //
1524      if ( !(rh->GetEntries()) && !(rt->GetEntries()) && !(T->GetEntries()) ) return(16);
1525      //
1526    UInt_t obtt = 0;    UInt_t obtt = 0;
1527    UInt_t obth = 0;    UInt_t obth = 0;
1528    UInt_t pktt = 0;    UInt_t pktt = 0;
# Line 1014  Int_t PamelaDBOperations::insertPamelaRU Line 1556  Int_t PamelaDBOperations::insertPamelaRU
1556        //        //
1557        if ( !ptt &&  !(ptht+1) ){        if ( !ptt &&  !(ptht+1) ){
1558          //          //
1559          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);
1560          //          //
1561          this->HandleRunFragments(true,false,0,(evbeft-1));          this->HandleRunFragments(true,false,0,(evbeft-1));
1562          //          //
1563          //          //
1564        } else if ( pth == ptht ){        } else if ( pth == ptht ){
1565          //          //
1566          if ( IsDebug() ) printf(" Missing header %i %i %i\n",ptht,pth,ptt);          if ( IsDebug() ) printf(" Missing header %u %u %u\n",ptht,pth,ptt);
1567          //          //
1568          if ( (ptt-1) < 0 ) throw -15;          if ( (ptt-1) < 0 ) throw -15; // should never arrive here!
1569          rt->GetEntry(ptt-1);          rt->GetEntry(ptt-1);
1570          cod = eht->GetCounter();          cod = eht->GetCounter();
1571          evbefh = cod->Get(pctp->Physics);          evbefh = cod->Get(pctp->Physics);
1572          rt->GetEntry(ptt);          rt->GetEntry(ptt);
1573          pht = eht->GetPscuHeader();          pht = eht->GetPscuHeader();
1574          //          //
1575          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);
1576          if ( IsDebug() ) printf(" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''  %i %i %i \n",pkth,obth,obtt);          if ( IsDebug() ) printf(" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''  %u %u %u \n",pkth,obth,obtt);
1577          //          //
1578          this->HandleMissingHoT(true,false,evbefh,evbeft-1);          this->HandleMissingHoT(true,false,evbefh,evbeft-1);
1579          //          //
1580        } else {        } else {
1581          //          //
1582          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);
1583          //          //
1584          rh->GetEntry(ptht);          rh->GetEntry(ptht);
1585          phh = ehh->GetPscuHeader();          phh = ehh->GetPscuHeader();
# Line 1045  Int_t PamelaDBOperations::insertPamelaRU Line 1587  Int_t PamelaDBOperations::insertPamelaRU
1587          obth = phh->GetOrbitalTime();          obth = phh->GetOrbitalTime();
1588          cod = ehh->GetCounter();          cod = ehh->GetCounter();
1589          evbefh = cod->Get(pctp->Physics);          evbefh = cod->Get(pctp->Physics);
1590          if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' %i %i %i \n",pkth,obth,obtt);          if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' %u %u %u \n",pkth,obth,obtt);
1591          //          //
1592          // handle this run          // handle this run
1593          //          //
# Line 1055  Int_t PamelaDBOperations::insertPamelaRU Line 1597  Int_t PamelaDBOperations::insertPamelaRU
1597          //          //
1598          if ( PKT(pkth)>PKT(pktfirst) && OBT(obth)>OBT(obtfirst) && !ptt ){          if ( PKT(pkth)>PKT(pktfirst) && OBT(obth)>OBT(obtfirst) && !ptt ){
1599            //            //
1600            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));  
1601            //            //
1602              if ( evbefh == 0 ) {
1603                //
1604                signal = 8;
1605                if ( IsDebug() ) printf(" Not supported yet: run with no events, no runtrailer, no runheader \n");
1606                //
1607              } else {
1608                //
1609                this->HandleRunFragments(true,true,0,(evbefh-1));
1610                //
1611              };
1612          };          };
1613          //          //
1614          //          //
1615          if ( (ptht - pth) > 1 ){          if ( (ptht - pth) > 1 ){
1616            //            //
1617            if ( IsDebug() ) printf(" Missing runtrailers! \n");            if ( IsDebug() ) printf(" Missing runtrailers! \n");
1618            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);
1619            // is not the consecutive header            // is not the consecutive header
1620            while ( pth != ptht ){                      while ( pth != ptht ){          
1621              //              //
# Line 1086  Int_t PamelaDBOperations::insertPamelaRU Line 1636  Int_t PamelaDBOperations::insertPamelaRU
1636              obth = phh->GetOrbitalTime();              obth = phh->GetOrbitalTime();
1637              evbefh = cod->Get(pctp->Physics);              evbefh = cod->Get(pctp->Physics);
1638              //              //
1639              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);
1640              if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' %i %i %i \n",pkth,obth,obtt);              if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' %u %u %u \n",pkth,obth,obtt);
1641              //              //
1642              this->HandleMissingHoT(false,true,evbefh,evbeft-1);              this->HandleMissingHoT(false,true,evbefh,evbeft-1);
1643              //              //
# Line 1096  Int_t PamelaDBOperations::insertPamelaRU Line 1646  Int_t PamelaDBOperations::insertPamelaRU
1646          } else if ( !(ptht - pth) ){          } else if ( !(ptht - pth) ){
1647            //            //
1648            if ( IsDebug() ) printf(" Missing runheader! \n");            if ( IsDebug() ) printf(" Missing runheader! \n");
1649            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);
1650            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");
1651            //            //
1652          } else {          } else {
# Line 1117  Int_t PamelaDBOperations::insertPamelaRU Line 1667  Int_t PamelaDBOperations::insertPamelaRU
1667            obth = phh->GetOrbitalTime();            obth = phh->GetOrbitalTime();
1668            cod = ehh->GetCounter();            cod = ehh->GetCounter();
1669            evbefh = cod->Get(pctp->Physics);            evbefh = cod->Get(pctp->Physics);
1670            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);
1671            if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''' %i %i %i \n",ptht,pth,ptt);            if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''' %u %u %u \n",ptht,pth,ptt);
1672            if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''' %i \n",rhev);            if ( IsDebug() ) printf(" ''''''''''''''''''''''''''''''' %u \n",rhev);
1673            //            //
1674            this->HandleRunFragments(false,true,evbefh,upperentry);            this->HandleRunFragments(false,true,evbefh,upperentry);
1675          } else {          } else {
# Line 1129  Int_t PamelaDBOperations::insertPamelaRU Line 1679  Int_t PamelaDBOperations::insertPamelaRU
1679            if ( (UInt_t)evbeft < upperentry-1 ){            if ( (UInt_t)evbeft < upperentry-1 ){
1680              if ( IsDebug() ) printf(" Piece of run at the end of the file with NO RUNHEADER!\n");              if ( IsDebug() ) printf(" Piece of run at the end of the file with NO RUNHEADER!\n");
1681              //              //
1682              if ( (ptt-1) < 0 ) throw -15;              if ( (ptt-1) < 0 ) throw -15; // should never arrive here!
1683              rt->GetEntry(ptt-1);              rt->GetEntry(ptt-1);
1684              cod = eht->GetCounter();              cod = eht->GetCounter();
1685              evbefh = cod->Get(pctp->Physics);              evbefh = cod->Get(pctp->Physics);
# Line 1213  Bool_t PamelaDBOperations::IsRunAlreadyI Line 1763  Bool_t PamelaDBOperations::IsRunAlreadyI
1763      if ( glrun->GetNEVENTS() > (UInt_t)atoll(row->GetField(1)) ){      if ( glrun->GetNEVENTS() > (UInt_t)atoll(row->GetField(1)) ){
1764        //        //
1765        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");
1766        oss.str("");        glrun->DeleteRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN");
1767        oss << "DELETE FROM GL_RUN WHERE ID=" << row->GetField(0) <<";";  //       oss.str("");
1768        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) <<";";
1769        conn->Query(oss.str().c_str());  //       if ( IsDebug() ) printf(" delete the run entry: query is \n %s \n",oss.str().c_str());      
1770    //       conn->Query(oss.str().c_str());
1771        if ( signal ) signal = false;        if ( signal ) signal = false;
1772        goto gonext;              goto gonext;      
1773        //        //
# Line 1230  Bool_t PamelaDBOperations::IsRunAlreadyI Line 1781  Bool_t PamelaDBOperations::IsRunAlreadyI
1781        //        //
1782        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");
1783        //        //
1784        oss.str("");        glrun->DeleteRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN");
1785        oss << "DELETE FROM GL_RUN WHERE ID=" << row->GetField(0) <<";";  //       oss.str("");
1786        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) <<";";
1787        conn->Query(oss.str().c_str());  //       if ( IsDebug() ) printf(" delete the run entry: query is \n %s \n",oss.str().c_str());      
1788    //       conn->Query(oss.str().c_str());
1789        //        //
1790        if ( signal ) signal = false;        if ( signal ) signal = false;
1791        goto gonext;        goto gonext;
# Line 1247  Bool_t PamelaDBOperations::IsRunAlreadyI Line 1799  Bool_t PamelaDBOperations::IsRunAlreadyI
1799        //        //
1800        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");
1801        //        //
1802        oss.str("");        glrun->DeleteRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN");
1803        oss << "DELETE FROM GL_RUN WHERE ID=" << row->GetField(0) <<";";  //       oss.str("");
1804        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) <<";";
1805        conn->Query(oss.str().c_str());  //       if ( IsDebug() ) printf(" delete the run entry: query is \n %s \n",oss.str().c_str());      
1806    //       conn->Query(oss.str().c_str());
1807        if ( signal ) signal = false;        if ( signal ) signal = false;
1808        //        //
1809      };      };
# Line 1265  Bool_t PamelaDBOperations::IsRunAlreadyI Line 1818  Bool_t PamelaDBOperations::IsRunAlreadyI
1818    delete result;    delete result;
1819    //    //
1820    if ( signal && IsDebug() ) printf(" The run has already been inserted \n");        if ( signal && IsDebug() ) printf(" The run has already been inserted \n");    
1821      if ( !signal && IsDebug() ) printf(" The run existed and was deleted, fill the DB \n");
1822    return(signal);    return(signal);
1823  };  };
1824    
# Line 1286  void PamelaDBOperations::HandleRun(){   Line 1840  void PamelaDBOperations::HandleRun(){  
1840      //      //
1841      this->FillClass();      this->FillClass();
1842      //      //
1843      if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);      if ( !IsRunAlreadyInserted() ){
1844          glrun->SetID(this->AssignRunID());
1845          glrun->SetID_RUN_FRAG(0);
1846          glrun->Fill_GL_RUN(conn);
1847        };
1848    } else {    } else {
1849      //      //
1850      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 1309  void PamelaDBOperations::HandleRunFragme Line 1867  void PamelaDBOperations::HandleRunFragme
1867    UInt_t rhfirstev = firstev;    UInt_t rhfirstev = firstev;
1868    UInt_t rtlastev = lastev;    UInt_t rtlastev = lastev;
1869    Bool_t found = false;    Bool_t found = false;
1870      Bool_t foundinrun = false;
1871    //    //
1872    TSQLResult *result = 0;    TSQLResult *result = 0;
1873    TSQLRow    *row    = 0;    TSQLRow    *row    = 0;
# Line 1335  void PamelaDBOperations::HandleRunFragme Line 1894  void PamelaDBOperations::HandleRunFragme
1894    //    //
1895    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");
1896    //    //
1897      // First of all insert the run in the fragment table...
1898      //
1899      oss.str("");
1900      oss << " SELECT ID FROM GL_RUN_FRAGMENTS WHERE "
1901          << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND ("
1902          << " (RUNHEADER_TIME>=" << (UInt_t)(glrun->GetRUNHEADER_TIME()-10) << " AND "
1903          << " RUNTRAILER_TIME<=" << (UInt_t)(glrun->GetRUNTRAILER_TIME()+10) << " AND ("
1904          << " RUNHEADER_OBT>=" << glrun->GetRUNHEADER_OBT() << " OR "
1905          << " RUNHEADER_PKT>=" << glrun->GetRUNHEADER_PKT() << ") AND ("
1906          << " RUNTRAILER_OBT<=" << glrun->GetRUNTRAILER_OBT() << " OR "
1907          << " RUNTRAILER_PKT<=" << glrun->GetRUNTRAILER_PKT() << ") ) OR "
1908          << " (RUNHEADER_TIME<=" << (UInt_t)glrun->GetRUNHEADER_TIME() << " AND "
1909          << " RUNTRAILER_TIME>=" << (UInt_t)glrun->GetRUNTRAILER_TIME() <<" AND ("
1910          << " RUNHEADER_OBT<=" << glrun->GetRUNHEADER_OBT() << " OR "
1911          << " RUNHEADER_PKT<=" << glrun->GetRUNHEADER_PKT() << ") AND ("
1912          << " RUNTRAILER_OBT>=" << glrun->GetRUNTRAILER_OBT() << " OR "
1913          << " RUNTRAILER_PKT>=" << glrun->GetRUNTRAILER_PKT() << ") ));";
1914      //
1915      if ( IsDebug() ) printf(" check if run has been inserted: query is \n %s \n",oss.str().c_str());
1916      result = conn->Query(oss.str().c_str());
1917      //
1918      if ( !result ) throw -4;
1919      //
1920      row = result->Next();
1921      //
1922      if ( !row ){
1923        //
1924        // no, insert this run in the GL_RUN_FRAGMENTS table (check if exist before!)
1925        //
1926        if ( IsDebug() ) printf(" The run is new \n");
1927        if ( IsDebug() ) printf(" -> fill the GL_RUNFRAGMENTS table \n");
1928        //
1929        glrun->SetID(this->AssignRunID());
1930        glrun->SetID_RUN_FRAG(0);
1931        glrun->Fill_GL_RUN_FRAGMENTS(conn);
1932        //
1933      } else {
1934        if ( IsDebug() ) printf(" The run is already present in the fragment table \n");
1935        return;
1936      };
1937      //
1938      //
1939    // 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?
1940    //        //    
1941    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 1343  void PamelaDBOperations::HandleRunFragme Line 1944  void PamelaDBOperations::HandleRunFragme
1944      oss.str("");      oss.str("");
1945      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 "
1946          << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND "          << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND "
1947          << " RUNHEADER_TIME <= " << (UInt_t)glrun->GetRUNHEADER_TIME()          << " RUNHEADER_TIME <= " << (UInt_t)glrun->GetRUNHEADER_TIME() << " AND "
1948            << " ID != " << glrun->ID
1949          << " ORDER BY RUNHEADER_TIME DESC LIMIT 1;"; // DESC NOT ASC!!          << " ORDER BY RUNHEADER_TIME DESC LIMIT 1;"; // DESC NOT ASC!!
1950      //      //
1951      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 1353  void PamelaDBOperations::HandleRunFragme Line 1955  void PamelaDBOperations::HandleRunFragme
1955      //      //
1956      row = result->Next();      row = result->Next();
1957      //      //
1958        if ( !row && NoFrag() ){
1959          //
1960          oss.str("");
1961          oss << " SELECT ID,TRK_CALIB_USED,RUNTRAILER_TIME,RUNTRAILER_OBT,RUNHEADER_PKT,RUNTRAILER_PKT FROM GL_RUN WHERE "
1962              << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND "
1963              << " RUNHEADER_TIME <= " << (UInt_t)glrun->GetRUNHEADER_TIME() << " AND "
1964              << " ID != " << glrun->ID
1965              << " AND ID=ID_RUN_FRAG ORDER BY RUNHEADER_TIME DESC LIMIT 1;"; // DESC NOT ASC!!
1966          //
1967          if ( IsDebug() ) printf(" look for runheader in the GL_RUN table: query is \n %s \n",oss.str().c_str());
1968          result = conn->Query(oss.str().c_str());
1969          //
1970          if ( !result ) throw -4;
1971          //
1972          foundinrun = true;
1973          //
1974          row = result->Next();
1975          //
1976        };
1977        //
1978      if ( !row ){      if ( !row ){
1979        if ( IsDebug() ) printf(" the corresponding piece has NOT been found \n");        if ( IsDebug() ) printf(" the corresponding piece has NOT been found \n");
1980        found = false;        found = false;
# Line 1427  void PamelaDBOperations::HandleRunFragme Line 2049  void PamelaDBOperations::HandleRunFragme
2049        //        //
2050        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 ");
2051        //        //
2052          if ( foundinrun ){
2053            glrun->RestoreRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN_FRAGMENTS");
2054            glrun->DeleteRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN");
2055          };
2056          //
2057        GL_RUN *glrun1 = new GL_RUN();        GL_RUN *glrun1 = new GL_RUN();
2058        //        //
2059        UInt_t idfrag = (UInt_t)atoll(row->GetField(0));        //      UInt_t idfrag = (UInt_t)atoll(row->GetField(0));
2060        //        //
2061        oss.str("");        oss.str("");
2062        oss << " ID="<<row->GetField(0)<<";";        oss << " ID="<<row->GetField(0)<<";";
# Line 1442  void PamelaDBOperations::HandleRunFragme Line 2069  void PamelaDBOperations::HandleRunFragme
2069        ULong64_t aobt = OBT(glrun1->GetRUNTRAILER_OBT());        ULong64_t aobt = OBT(glrun1->GetRUNTRAILER_OBT());
2070        UInt_t bpkt = PKT(glrun->GetRUNHEADER_PKT());        UInt_t bpkt = PKT(glrun->GetRUNHEADER_PKT());
2071        ULong64_t bobt = OBT(glrun->GetRUNHEADER_OBT());        ULong64_t bobt = OBT(glrun->GetRUNHEADER_OBT());
2072        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);
2073        TTree *T= 0;        TTree *T= 0;
2074        T = (TTree*)file->Get("Physics");        T = (TTree*)file->Get("Physics");
2075        if ( !T || T->IsZombie() ) throw -16;        if ( !T || T->IsZombie() ) throw -16;
# Line 1456  void PamelaDBOperations::HandleRunFragme Line 2083  void PamelaDBOperations::HandleRunFragme
2083          bobt = OBT(ph->GetOrbitalTime());                bobt = OBT(ph->GetOrbitalTime());      
2084          firstev++;          firstev++;
2085        };        };
2086        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);
2087        //        //
       glrun1->SetID(0);  
2088        glrun1->SetPKT_COUNTER(glrun->GetPKT_COUNTER());        glrun1->SetPKT_COUNTER(glrun->GetPKT_COUNTER());
2089        glrun1->SetPKT_READY_COUNTER(glrun->GetPKT_READY_COUNTER());        glrun1->SetPKT_READY_COUNTER(glrun->GetPKT_READY_COUNTER());
2090        glrun1->SetRUNTRAILER_TIME(glrun->GetRUNTRAILER_TIME());        glrun1->SetRUNTRAILER_TIME(glrun->GetRUNTRAILER_TIME());
# Line 1467  void PamelaDBOperations::HandleRunFragme Line 2093  void PamelaDBOperations::HandleRunFragme
2093        //        //
2094        glrun->SetEV_FROM(firstev);        glrun->SetEV_FROM(firstev);
2095        glrun->SetNEVENTS(lastev-firstev+1);        glrun->SetNEVENTS(lastev-firstev+1);
2096          //
2097        glrun->SetRUNHEADER_TIME(glrun1->GetRUNHEADER_TIME());        glrun->SetRUNHEADER_TIME(glrun1->GetRUNHEADER_TIME());
2098        glrun->SetRUNHEADER_OBT(glrun1->GetRUNHEADER_OBT());        glrun->SetRUNHEADER_OBT(glrun1->GetRUNHEADER_OBT());
2099        glrun->SetRUNHEADER_PKT(glrun1->GetRUNHEADER_PKT());        glrun->SetRUNHEADER_PKT(glrun1->GetRUNHEADER_PKT());
# Line 1486  void PamelaDBOperations::HandleRunFragme Line 2113  void PamelaDBOperations::HandleRunFragme
2113        //        //
2114        if ( !IsRunAlreadyInserted() ){        if ( !IsRunAlreadyInserted() ){
2115          //          //
2116            //      glrun->SetID(this->AssignRunID());
2117            glrun->SetID_RUN_FRAG(glrun1->GetID());
2118          glrun->Fill_GL_RUN(conn);          glrun->Fill_GL_RUN(conn);
2119          //          //
2120          // 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);  
2121          //          //
2122            glrun1->SetID_RUN_FRAG(glrun->GetID());
2123          glrun1->Fill_GL_RUN(conn);          glrun1->Fill_GL_RUN(conn);
2124          //          //
         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;  
         //  
2125        };        };
       //  
       delete glrun1;  
       //  
2126        // delete old entry in fragment table        // delete old entry in fragment table
2127        //        //
2128        oss.str("");        glrun->DeleteRun(conn,0,"GL_RUN_FRAGMENTS");
2129          glrun1->DeleteRun(conn,0,"GL_RUN_FRAGMENTS");
2130        //        //
2131        oss << " DELETE FROM GL_RUN_FRAGMENTS WHERE ID = " << idfrag << ";";        delete glrun1;
2132        //        //
       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;  
2133        //        //
2134        return;        return;
2135        //        //
# Line 1555  void PamelaDBOperations::HandleRunFragme Line 2138  void PamelaDBOperations::HandleRunFragme
2138    };    };
2139    //    //
2140    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
2141                                             // 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
2142      //      //
2143      oss.str("");      oss.str("");
2144      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 "
2145          << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND "          << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND "
2146          << " RUNTRAILER_TIME >= " << (UInt_t)glrun->GetRUNTRAILER_TIME()          << " RUNTRAILER_TIME >= " << (UInt_t)glrun->GetRUNTRAILER_TIME() << " AND "
2147            << " ID != " << glrun->ID
2148          << " ORDER BY RUNTRAILER_TIME ASC LIMIT 1;";          << " ORDER BY RUNTRAILER_TIME ASC LIMIT 1;";
2149      //      //
2150      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 1570  void PamelaDBOperations::HandleRunFragme Line 2154  void PamelaDBOperations::HandleRunFragme
2154      //      //
2155      row = result->Next();      row = result->Next();
2156      //      //
2157        if ( !row && NoFrag() ){
2158          //
2159          oss.str("");
2160          oss << " SELECT ID,PKT_COUNTER,RUNHEADER_TIME,RUNHEADER_OBT,RUNTRAILER_PKT,RUNHEADER_PKT FROM GL_RUN WHERE "
2161              << " BOOT_NUMBER=" << this->GetBOOTnumber() << " AND "
2162              << " RUNTRAILER_TIME >= " << (UInt_t)glrun->GetRUNTRAILER_TIME() << " AND "
2163              << " ID != " << glrun->ID
2164              << " AND ID=ID_RUN_FRAG ORDER BY RUNTRAILER_TIME ASC LIMIT 1;";
2165          //
2166          if ( IsDebug() ) printf(" look for runheader in the GL_RUN table: query is \n %s \n",oss.str().c_str());
2167          result = conn->Query(oss.str().c_str());
2168          //
2169          if ( !result ) throw -4;
2170          //
2171          foundinrun = true;
2172          row = result->Next();
2173          //
2174        };
2175        //
2176      if ( !row ){      if ( !row ){
2177        if ( IsDebug() ) printf(" the corresponding piece has NOT been found \n");        if ( IsDebug() ) printf(" the corresponding piece has NOT been found \n");
2178        found = false;        found = false;
# Line 1643  void PamelaDBOperations::HandleRunFragme Line 2246  void PamelaDBOperations::HandleRunFragme
2246        //        //
2247        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 ");
2248        //        //
2249          if ( foundinrun ){
2250            glrun->RestoreRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN_FRAGMENTS");
2251            glrun->DeleteRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN");
2252          };
2253          //
2254        GL_RUN *glrun1 = new GL_RUN();        GL_RUN *glrun1 = new GL_RUN();
2255        //        //
2256        UInt_t idfrag = (UInt_t)atoll(row->GetField(0));        //      UInt_t idfrag = (UInt_t)atoll(row->GetField(0));
2257        //        //
2258        oss.str("");        oss.str("");
2259        oss << " ID="<<row->GetField(0)<<";";        oss << " ID="<<row->GetField(0)<<";";
# Line 1658  void PamelaDBOperations::HandleRunFragme Line 2266  void PamelaDBOperations::HandleRunFragme
2266        ULong64_t aobt = OBT(glrun->GetRUNTRAILER_OBT());        ULong64_t aobt = OBT(glrun->GetRUNTRAILER_OBT());
2267        UInt_t bpkt = PKT(glrun1->GetRUNHEADER_PKT());        UInt_t bpkt = PKT(glrun1->GetRUNHEADER_PKT());
2268        ULong64_t bobt = OBT(glrun1->GetRUNHEADER_OBT());        ULong64_t bobt = OBT(glrun1->GetRUNHEADER_OBT());
2269        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);
2270        TTree *T= 0;        TTree *T= 0;
2271        T = (TTree*)file->Get("Physics");        T = (TTree*)file->Get("Physics");
2272        if ( !T || T->IsZombie() ) throw -16;        if ( !T || T->IsZombie() ) throw -16;
# Line 1672  void PamelaDBOperations::HandleRunFragme Line 2280  void PamelaDBOperations::HandleRunFragme
2280          aobt = OBT(ph->GetOrbitalTime());                aobt = OBT(ph->GetOrbitalTime());      
2281          lastev--;          lastev--;
2282        };        };
2283        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);
2284        //        //
2285        glrun->SetEV_TO(lastev);        glrun->SetEV_TO(lastev);
2286        glrun->SetNEVENTS(lastev-firstev+1);        glrun->SetNEVENTS(lastev-firstev+1);
# Line 1682  void PamelaDBOperations::HandleRunFragme Line 2290  void PamelaDBOperations::HandleRunFragme
2290        glrun->SetRUNTRAILER_OBT(glrun1->GetRUNTRAILER_OBT());        glrun->SetRUNTRAILER_OBT(glrun1->GetRUNTRAILER_OBT());
2291        glrun->SetRUNTRAILER_PKT(glrun1->GetRUNTRAILER_PKT());        glrun->SetRUNTRAILER_PKT(glrun1->GetRUNTRAILER_PKT());
2292        //        //
       glrun1->SetID(0);  
2293        glrun1->SetRUNHEADER_TIME(glrun->GetRUNHEADER_TIME());        glrun1->SetRUNHEADER_TIME(glrun->GetRUNHEADER_TIME());
2294        glrun1->SetRUNHEADER_OBT(glrun->GetRUNHEADER_OBT());        glrun1->SetRUNHEADER_OBT(glrun->GetRUNHEADER_OBT());
2295        glrun1->SetRUNHEADER_PKT(glrun->GetRUNHEADER_PKT());        glrun1->SetRUNHEADER_PKT(glrun->GetRUNHEADER_PKT());
# Line 1702  void PamelaDBOperations::HandleRunFragme Line 2309  void PamelaDBOperations::HandleRunFragme
2309        //        //
2310        if ( !IsRunAlreadyInserted() ){        if ( !IsRunAlreadyInserted() ){
2311          //          //
2312          glrun->Fill_GL_RUN(conn);          //      glrun->SetID(this->AssignRunID());
         //  
         // get id number  
         //  
         oss.str("");  
         oss << " SELECT ID FROM GL_RUN WHERE BOOT_NUMBER="<<this->GetBOOTnumber()<<" AND "  
             << " RUNHEADER_OBT="<<glrun->GetRUNHEADER_OBT()<<" AND "  
             << " RUNTRAILER_OBT="<<glrun->GetRUNTRAILER_OBT()<<";";  
         //  
         if ( IsDebug() ) printf(" search for idrun0 , query is : \n%s\n",oss.str().c_str());  
         //  
         result =  conn->Query(oss.str().c_str());  
         if ( !result ) throw -4;  
         row = result->Next();  
2313          //          //
2314          UInt_t idrun0 = 0;          glrun->SetID_RUN_FRAG(glrun1->GetID());
2315          if ( !row ){          glrun->Fill_GL_RUN(conn);
           throw -10;  
         } else {  
           idrun0 = (UInt_t)atoll(row->GetField(0));  
         };  
2316          //          //
2317          glrun1->SetID_RUN_FRAG(idrun0);          // set id number
2318          //          //
2319            glrun1->SetID_RUN_FRAG(glrun->GetID());
2320          glrun1->Fill_GL_RUN(conn);          glrun1->Fill_GL_RUN(conn);
2321          //          //
         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;  
         //  
2322        };        };
2323        //        //
2324        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 << ";";  
2325        //        //
2326        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");
2327        result =  conn->Query(oss.str().c_str());        glrun1->DeleteRun(conn,0,"GL_RUN_FRAGMENTS");
       if ( !result ) throw -4;  
2328        //        //
2329          delete glrun1;
2330        //        //
2331        return;        return;
2332        //        //
# Line 1800  void PamelaDBOperations::HandleRunFragme Line 2363  void PamelaDBOperations::HandleRunFragme
2363      //      //
2364      row = result->Next();      row = result->Next();
2365      //      //
2366      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 {  
2367        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");
2368        } else {
2369          if ( NoFrag() ){
2370            glrun->SetID_RUN_FRAG(glrun->GetID());
2371            glrun->Fill_GL_RUN(conn);      
2372            glrun->DeleteRun(conn,0,"GL_RUN_FRAGMENTS");
2373          };    
2374      };      };
2375    };    };
2376    //    //
# Line 1864  void PamelaDBOperations::HandleMissingHo Line 2396  void PamelaDBOperations::HandleMissingHo
2396      //      //
2397      this->FillClass(mishead,mistrail,firstev,lastev);      this->FillClass(mishead,mistrail,firstev,lastev);
2398      //      //
2399      if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);          if ( !IsRunAlreadyInserted() ){
2400          glrun->SetID(this->AssignRunID());
2401          glrun->SetID_RUN_FRAG(0);
2402          glrun->Fill_GL_RUN(conn);    
2403        };
2404      //      //
2405    };    };
2406    //    //
# Line 2031  Bool_t PamelaDBOperations::IsRunConsiste Line 2567  Bool_t PamelaDBOperations::IsRunConsiste
2567            //                  //      
2568            this->SetCommonGLRUN(firstTime,lastTime);            this->SetCommonGLRUN(firstTime,lastTime);
2569            //            //
2570            if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);                  if ( !IsRunAlreadyInserted() ){
2571                glrun->SetID(this->AssignRunID());
2572                glrun->SetID_RUN_FRAG(0);
2573                glrun->Fill_GL_RUN(conn);      
2574              };
2575            //            //
2576            firstevno = lastentry + 1;            firstevno = lastentry + 1;
2577            //            //
# Line 2106  void PamelaDBOperations::HandleSuspiciou Line 2646  void PamelaDBOperations::HandleSuspiciou
2646    if ( firstev == lastev+1 ) { // no events inside the run!    if ( firstev == lastev+1 ) { // no events inside the run!
2647      if ( IsDebug() ) printf(" Checking but no events in the run! \n");      if ( IsDebug() ) printf(" Checking but no events in the run! \n");
2648      //      //
     //    if ( IsDebug() ) printf(" -> fill the DB \n");  
     //  
2649      this->FillClass();      this->FillClass();
2650      if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);          if ( !IsRunAlreadyInserted() ){
2651          glrun->SetID(this->AssignRunID());
2652          glrun->SetID_RUN_FRAG(0);
2653          glrun->Fill_GL_RUN(conn);    
2654        };
2655      //      //
2656    } else {    } else {
2657      //      //
# Line 2137  void PamelaDBOperations::HandleSuspiciou Line 2679  void PamelaDBOperations::HandleSuspiciou
2679        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");
2680        //        //
2681        this->FillClass();        this->FillClass();
2682        if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);                if ( !IsRunAlreadyInserted() ){
2683            glrun->SetID(this->AssignRunID());
2684            glrun->SetID_RUN_FRAG(0);
2685            glrun->Fill_GL_RUN(conn);        
2686          };
2687        //        //
2688      } else {      } else {
2689        //        //
# Line 2235  void PamelaDBOperations::HandleSuspiciou Line 2781  void PamelaDBOperations::HandleSuspiciou
2781            //                  //      
2782            this->SetCommonGLRUN(firstTime,lastTime);            this->SetCommonGLRUN(firstTime,lastTime);
2783            //            //
2784            if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);                  if ( !IsRunAlreadyInserted() ){
2785                glrun->SetID(this->AssignRunID());
2786                glrun->SetID_RUN_FRAG(0);
2787                glrun->Fill_GL_RUN(conn);      
2788              };
2789            //            //
2790            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...
2791              //              //
# Line 2270  void PamelaDBOperations::HandleSuspiciou Line 2820  void PamelaDBOperations::HandleSuspiciou
2820              //                  //    
2821              this->SetCommonGLRUN(firstTime,lastTime);              this->SetCommonGLRUN(firstTime,lastTime);
2822              //              //
2823              if ( !IsRunAlreadyInserted() ) glrun->Fill_GL_RUN(conn);                    if ( !IsRunAlreadyInserted() ){
2824                  glrun->SetID(this->AssignRunID());
2825                  glrun->SetID_RUN_FRAG(0);
2826                  glrun->Fill_GL_RUN(conn);      
2827                };
2828            };            };
2829            //            //
2830            firstevno = lastentry + 1;            firstevno = lastentry + 1;
# Line 2318  Int_t PamelaDBOperations::insertCALO_CAL Line 2872  Int_t PamelaDBOperations::insertCALO_CAL
2872    tr->SetBranchAddress("Header", &eh);    tr->SetBranchAddress("Header", &eh);
2873    nevents = tr->GetEntries();    nevents = tr->GetEntries();
2874    //    //
2875    if ( !nevents ) return(0);    if ( !nevents ) return(1);
2876    //    //
2877    for (UInt_t i=0; i < nevents; i++){    for (UInt_t i=0; i < nevents; i++){
2878      tr->GetEntry(i);      tr->GetEntry(i);
# Line 2333  Int_t PamelaDBOperations::insertCALO_CAL Line 2887  Int_t PamelaDBOperations::insertCALO_CAL
2887          fromtime = this->GetAbsTime(ph->GetOrbitalTime());            fromtime = this->GetAbsTime(ph->GetOrbitalTime());  
2888          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) ){
2889            //            //
2890            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);
2891            //            //
2892            // check if the calibration has already been inserted            // check if the calibration has already been inserted
2893            //            //
# Line 2377  Int_t PamelaDBOperations::insertCALO_CAL Line 2931  Int_t PamelaDBOperations::insertCALO_CAL
2931                // no calibrations in the db contain our calibration                // no calibrations in the db contain our calibration
2932                //                //
2933                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);
2934                if ( fromtime < 1150863400 ){                if ( fromtime < 1150871000 ){ //1150866904
2935                  if ( IsDebug() ) printf(" First PAMELA flight calibration at time %i \n",fromtime);                  if ( IsDebug() ) printf(" First PAMELA flight calibration at time %u \n",fromtime);
2936                  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
2937                };                };
2938                //                //
# Line 2440  Int_t PamelaDBOperations::insertCALO_CAL Line 2994  Int_t PamelaDBOperations::insertCALO_CAL
2994            //            //
2995          } else {          } else {
2996            //            //
2997            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);
2998            //            //
2999          };                };      
3000          //                //      
# Line 2522  void PamelaDBOperations::HandleTRK_CALIB Line 3076  void PamelaDBOperations::HandleTRK_CALIB
3076        // no calibrations in the db contain our calibration        // no calibrations in the db contain our calibration
3077        //        //
3078        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");
3079        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
3080        //        //
3081        oss.str("");        oss.str("");
3082        oss << " SELECT FROM_TIME FROM GL_TRK_CALIB WHERE "        oss << " SELECT FROM_TIME FROM GL_TRK_CALIB WHERE "
# Line 2635  Int_t PamelaDBOperations::insertTRK_CALI Line 3189  Int_t PamelaDBOperations::insertTRK_CALI
3189    tr2->SetBranchAddress("Header", &eh2);    tr2->SetBranchAddress("Header", &eh2);
3190    nevents2 = tr2->GetEntries();    nevents2 = tr2->GetEntries();
3191    //    //
3192    if ( !nevents1 && !nevents2 ) return(0);    if ( !nevents1 && !nevents2 ) return(1);
3193    //    //
3194    t2 = -1;    t2 = -1;
3195    Int_t pret2 = 0;    Int_t pret2 = 0;
# Line 2651  Int_t PamelaDBOperations::insertTRK_CALI Line 3205  Int_t PamelaDBOperations::insertTRK_CALI
3205      pkt1 = ph1->GetCounter();        pkt1 = ph1->GetCounter();  
3206      fromtime = this->GetAbsTime(ph1->GetOrbitalTime());        fromtime = this->GetAbsTime(ph1->GetOrbitalTime());  
3207      //      //
3208      valid = 1;  //     valid = 1;
3209      //  //     //
3210      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
3211      //      //
3212      //      //
3213      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) ){
3214        //        //
3215        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);
3216          //      
3217          valid = ValidateTrkCalib( caltrk1, eh1 );
3218          if ( IsDebug() ) cout << " pkt1 validation --> "<<valid<<endl;
3219        //        //
3220        // Do we have the second calibration packet?        // Do we have the second calibration packet?
3221        //        //
# Line 2675  Int_t PamelaDBOperations::insertTRK_CALI Line 3232  Int_t PamelaDBOperations::insertTRK_CALI
3232            obt2 = ph2->GetOrbitalTime();              obt2 = ph2->GetOrbitalTime();  
3233            pkt2 = ph2->GetCounter();              pkt2 = ph2->GetCounter();  
3234            //            //
3235            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
3236            //                  //      
3237          } else {          } else {
3238            //            //
# Line 2698  Int_t PamelaDBOperations::insertTRK_CALI Line 3255  Int_t PamelaDBOperations::insertTRK_CALI
3255          //          //
3256        };        };
3257        //        //
3258        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);
3259        //        //
3260        // The calibration is good        // The calibration is good
3261        //        //
3262        if ( this->PKT(pkt2) == this->PKT(pkt1)+1 ){        if ( this->PKT(pkt2) == this->PKT(pkt1)+1 ){
3263          //          //
3264          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);
3265            //
3266            UInt_t valid2 = ValidateTrkCalib( caltrk2, eh2 );
3267            if ( IsDebug() ) cout << " pkt2 validation --> "<<valid2<<endl;
3268            valid = valid & valid2;
3269          //          //
3270          // Handle good calib          // Handle good calib
3271          //          //
# Line 2714  Int_t PamelaDBOperations::insertTRK_CALI Line 3275  Int_t PamelaDBOperations::insertTRK_CALI
3275          //          //
3276          if ( t2 != pret2+1 ){          if ( t2 != pret2+1 ){
3277            //            //
3278            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);
3279            //            //
3280            while ( t2 > pret2+1 ){            while ( t2 > pret2+1 ){
3281              //              //
# Line 2743  Int_t PamelaDBOperations::insertTRK_CALI Line 3304  Int_t PamelaDBOperations::insertTRK_CALI
3304          //          //
3305          // Check for missing calibtrk2          // Check for missing calibtrk2
3306          //          //
3307          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);
3308          t2 = pret2;          t2 = pret2;
3309          //          //
3310          // handle missing calib2          // handle missing calib2
# Line 2757  Int_t PamelaDBOperations::insertTRK_CALI Line 3318  Int_t PamelaDBOperations::insertTRK_CALI
3318        //        //
3319      } else {      } else {
3320        //        //
3321        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);
3322        //        //
3323      };      };
3324      //          //    
# Line 2782  Int_t PamelaDBOperations::insertTRK_CALI Line 3343  Int_t PamelaDBOperations::insertTRK_CALI
3343      valid = 0;      valid = 0;
3344      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) ){
3345        //        //
3346        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);
3347        //        //
3348        this->HandleTRK_CALIB(false,true);        this->HandleTRK_CALIB(false,true);
3349        //        //
# Line 2807  Int_t PamelaDBOperations::insertS4_CALIB Line 3368  Int_t PamelaDBOperations::insertS4_CALIB
3368    stringstream oss;    stringstream oss;
3369    oss.str("");    oss.str("");
3370    //    //
   CalibS4Event *calibS4    = new  CalibS4Event();  
3371    TTree *tr = 0;    TTree *tr = 0;
3372    EventHeader *eh = 0;    EventHeader *eh = 0;
3373    PscuHeader *ph = 0;    PscuHeader *ph = 0;
# Line 2821  Int_t PamelaDBOperations::insertS4_CALIB Line 3381  Int_t PamelaDBOperations::insertS4_CALIB
3381    tr = (TTree*)file->Get("CalibS4");    tr = (TTree*)file->Get("CalibS4");
3382    if ( !tr || tr->IsZombie() ) throw -24;    if ( !tr || tr->IsZombie() ) throw -24;
3383    //    //
   tr->SetBranchAddress("CalibS4", &calibS4);  
3384    tr->SetBranchAddress("Header", &eh);    tr->SetBranchAddress("Header", &eh);
3385    //    //
3386    nevents = tr->GetEntries();    nevents = tr->GetEntries();
3387    //    //
3388    if ( !nevents ) return(0);    if ( !nevents ) return(1);
3389    //    //
3390    for (UInt_t i = 0; i < nevents; i++){    for (UInt_t i = 0; i < nevents; i++){
3391      //      //
3392      tr->GetEntry(i);      tr->GetEntry(i);
     TArrayD params = S4_paramfit(calibS4);  
3393      //      //
3394      ph = eh->GetPscuHeader();      ph = eh->GetPscuHeader();
3395      obt = ph->GetOrbitalTime();        obt = ph->GetOrbitalTime();  
# Line 2839  Int_t PamelaDBOperations::insertS4_CALIB Line 3397  Int_t PamelaDBOperations::insertS4_CALIB
3397      fromtime = this->GetAbsTime(ph->GetOrbitalTime());        fromtime = this->GetAbsTime(ph->GetOrbitalTime());  
3398      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) ){
3399        //        //
3400        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);
3401        //        //
3402        // check if the calibration has already been inserted        // check if the calibration has already been inserted
3403        //        //
# Line 2881  Int_t PamelaDBOperations::insertS4_CALIB Line 3439  Int_t PamelaDBOperations::insertS4_CALIB
3439            // no calibrations in the db contain our calibration            // no calibrations in the db contain our calibration
3440            //            //
3441            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");
3442            if ( fromtime < 1150863400 ){            if ( fromtime < 1150871000 ){  
3443              if ( IsDebug() ) printf(" First PAMELA flight calibration at time %i \n",fromtime);              if ( IsDebug() ) printf(" First PAMELA flight calibration at time %u \n",fromtime);
3444              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
3445            };            };
3446            //            //
# Line 2921  Int_t PamelaDBOperations::insertS4_CALIB Line 3479  Int_t PamelaDBOperations::insertS4_CALIB
3479          };          };
3480          //          //
3481          oss.str("");          oss.str("");
3482          oss << " INSERT INTO GL_S4_CALIB (ID,ID_ROOT_L0,EV_ROOT,FROM_TIME,TO_TIME,PARAM_FIT0,PARAM_FIT1,OBT,PKT,BOOT_NUMBER,VALIDATION) "          oss << " INSERT INTO GL_S4_CALIB (ID,ID_ROOT_L0,EV_ROOT,FROM_TIME,TO_TIME,OBT,PKT,BOOT_NUMBER) "
3483              << " VALUES (NULL,' "              << " VALUES (NULL,' "
3484              << idroot << "','"              << idroot << "','"
3485              << i << "','"              << i << "','"
3486              << fromtime << "','"              << fromtime << "','"
3487              << totime << "','"              << totime << "','"
             << dec << params.At(0) << "','"  
             << dec << params.At(1) << "','"        
3488              << obt << "','"              << obt << "','"
3489              << pkt << "','"              << pkt << "','"
3490              << this->GetBOOTnumber() << "','"              << this->GetBOOTnumber() << "');";
             << valid << "');";  
3491          //          //
3492          if ( IsDebug() ) printf(" Insert the new calibration: query is \n %s \n",oss.str().c_str());          if ( IsDebug() ) printf(" Insert the new calibration: query is \n %s \n",oss.str().c_str());
3493          //          //
# Line 2944  Int_t PamelaDBOperations::insertS4_CALIB Line 3499  Int_t PamelaDBOperations::insertS4_CALIB
3499        //        //
3500      } else {      } else {
3501        //        //
3502        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);
3503        //        //
3504      };            };      
3505      //            //      
# Line 2953  Int_t PamelaDBOperations::insertS4_CALIB Line 3508  Int_t PamelaDBOperations::insertS4_CALIB
3508    return(0);    return(0);
3509  };  };
3510    
3511    /**
3512  /*   * Scan the fragment table and move old fragments to the GL_RUN table
  * Fit function Received from Valeria Malvezzi 06/02/2006  
3513   */   */
3514  Double_t fitf(Double_t *x, Double_t *par){    Int_t PamelaDBOperations::CleanGL_RUN_FRAGMENTS(){
3515    Double_t fitval =(par[0]*x[0])+par[1];    return(this->CleanGL_RUN_FRAGMENTS(""));
3516    return fitval;  };
 }  
3517    
3518  /*  /**
3519   * Fit the S4 calibration with a straight line - Received from Valeria Malvezzi 06/02/2006   * Scan the fragment table and move old fragments to the GL_RUN table
3520   */   */
3521  TArrayD PamelaDBOperations::S4_paramfit(pamela::CalibS4Event *S4CalibEvent){        Int_t PamelaDBOperations::CleanGL_RUN_FRAGMENTS(TString fcleanfile){
3522      //
3523    //----------- variable initialization -------------------------------------------------    TSQLResult *result = 0;
3524      TSQLRow    *row    = 0;
3525    Double_t mip[3]={1, 30, 300};    TSQLResult *result2 = 0;
3526    Double_t adc[3] = {0.,0.,0.};    TSQLRow    *row2   = 0;
3527        //
3528    TArrayD parametri(2);    UInt_t moved = 0;
3529      //
3530    valid = 1;    stringstream oss;
3531      oss.str("");
3532    //------------ Fit calibrations and find parameters to calibrate data ------------------    //
3533    pamela::S4::S4Event  *s4Record;    if ( !strcmp(fcleanfile.Data(),"") ){
3534        //
3535    for (Int_t j = 0; j < 4; j++){      // check if there are entries older than "olderthan" seconds from now
3536      for (Int_t i = 0; i < 128; i++){      //
3537        s4Record = (pamela::S4::S4Event*)S4CalibEvent->Records->At((j*128 + i));      oss.str("");
3538        switch (j) {      oss << " SELECT ID FROM GL_RUN_FRAGMENTS WHERE"
3539        case 0 :{          << " INSERT_TIME <= '" << clean_time->AsSQLString() << "';";
3540          adc[0]=adc[0]+((s4Record->S4_DATA)-32);      //
3541          break;      if ( IsDebug() ) printf(" Select from GL_RUN_FRAGMENTS runs older than %s : query is \n %s \n",clean_time->AsSQLString(),oss.str().c_str());
3542        };      result = conn->Query(oss.str().c_str());
3543        case 1 :{      //
3544          adc[1]=adc[1]+((s4Record->S4_DATA)-32);    } else {
3545          break;      oss.str("");
3546        };      oss << " SELECT ID FROM GL_ROOT WHERE NAME='" << fcleanfile.Data() << "';";
3547        case 3 :{      if ( IsDebug() ) printf(" Getting ID_ROOT_L0 query %s \n",oss.str().c_str());
3548          adc[2]=adc[2]+((s4Record->S4_DATA)-32);      result = conn->Query(oss.str().c_str());
3549          break;      //    
3550        };      if ( result ){
3551          //
3552          row = result->Next();
3553          //
3554          if ( row ){
3555            oss.str("");
3556            oss << " SELECT ID FROM GL_RUN_FRAGMENTS WHERE"
3557                << " ID_ROOT_L0=" << row->GetField(0) << ";";
3558            //
3559            if ( IsDebug() ) printf(" Select from GL_RUN_FRAGMENTS for ROOT file query is \n %s \n",oss.str().c_str());
3560            result = conn->Query(oss.str().c_str());
3561            //    
3562        };        };
3563        } else {
3564          return(2);
3565      };      };
3566    };    };
3567        //
3568    adc[0]=adc[0]/128;    if ( result ){
3569    adc[1]=adc[1]/128;      //
3570    adc[2]=adc[2]/128;      row = result->Next();
3571          //
3572    TGraph *fitpar = new TGraph (3, adc, mip);      while ( row ){
3573    TF1 *func = new TF1("fitf", fitf, -0., 1000., 2); // definizione della funzione, 2 = num. parametri        //
3574            oss.str("");
3575    func->SetParameters(0.3,1.);        //inizializzazione dei parametri a 1        oss << " ID= "<< row->GetField(0);
3576    func->SetParNames("m","q");      //definisce il nome dei parametri        //
3577    fitpar->Fit(func,"qr");          //fitta fitpar con la funzione func nel range definito nella funzione        glrun->Query_GL_RUN_FRAGMENTS(oss.str().c_str(),conn);  
3578    //fitpar->Fit(func,"r");          //fitta fitpar con la funzione func nel range definito nella funzione        //
3579              oss.str("");
3580    parametri[0] = func -> GetParameter(0);        oss << " SELECT ID,NEVENTS,TRK_CALIB_USED,PKT_COUNTER FROM GL_RUN WHERE "
3581    parametri[1] = func -> GetParameter(1);            << " BOOT_NUMBER=" << glrun->GetBOOT_NUMBER() << " AND ("
3582              << " (RUNHEADER_TIME>=" << (UInt_t)(glrun->GetRUNHEADER_TIME()-10) << " AND "
3583              << " RUNTRAILER_TIME<=" << (UInt_t)(glrun->GetRUNTRAILER_TIME()+10) << " AND ("
3584              << " RUNHEADER_OBT>=" << glrun->GetRUNHEADER_OBT() << " OR "
3585              << " RUNHEADER_PKT>=" << glrun->GetRUNHEADER_PKT() << ") AND ("
3586              << " RUNTRAILER_OBT<=" << glrun->GetRUNTRAILER_OBT() << " OR "
3587              << " RUNTRAILER_PKT<=" << glrun->GetRUNTRAILER_PKT() << ") ) OR "
3588              << " (RUNHEADER_TIME<=" << (UInt_t)glrun->GetRUNHEADER_TIME() << " AND "
3589              << " RUNTRAILER_TIME>=" << (UInt_t)glrun->GetRUNTRAILER_TIME() <<" AND ("
3590              << " RUNHEADER_OBT<=" << glrun->GetRUNHEADER_OBT() << " OR "
3591              << " RUNHEADER_PKT<=" << glrun->GetRUNHEADER_PKT() << ") AND ("
3592              << " RUNTRAILER_OBT>=" << glrun->GetRUNTRAILER_OBT() << " OR "
3593              << " RUNTRAILER_PKT>=" << glrun->GetRUNTRAILER_PKT() << ") ));";
3594          //
3595          if ( IsDebug() ) printf(" check if run has been inserted: query is \n %s \n",oss.str().c_str());
3596          result2 = conn->Query(oss.str().c_str());
3597          //
3598          if ( !result2 ) throw -4;
3599          //
3600          row2 = result2->Next();
3601          //
3602          if ( !row2 ){
3603            //
3604            if ( IsDebug() ) printf(" The run is new \n");
3605            if ( IsDebug() ) printf(" -> fill the DB \n");      
3606            //
3607            //      glrun->SetID(this->AssignRunID()); we use the old run number!
3608            glrun->SetID_RUN_FRAG(glrun->GetID());
3609            glrun->Fill_GL_RUN(conn);  
3610            //
3611    //      oss.str("");
3612    //      oss << " SELECT ID FROM GL_RUN WHERE "
3613    //          << " BOOT_NUMBER=" << glrun->GetBOOT_NUMBER() << " AND "
3614    //          << " RUNHEADER_PKT=" << (UInt_t)glrun->GetRUNHEADER_PKT() << " AND "
3615    //          << " RUNTRAILER_PKT=" << (UInt_t)glrun->GetRUNTRAILER_PKT() << " AND "
3616    //          << " RUNHEADER_OBT=" << (UInt_t)glrun->GetRUNHEADER_OBT() << " AND "
3617    //          << " RUNTRAILER_OBT=" << (UInt_t)glrun->GetRUNTRAILER_OBT() << "; ";
3618    //      //
3619    //      if ( IsDebug() ) printf(" Look for the ID of the inserted run: query is \n %s \n",oss.str().c_str());
3620    //      result2 = conn->Query(oss.str().c_str());
3621    //      //
3622    //      if ( !result2 ) throw -4;
3623    //      //
3624    //      row2 = result2->Next();
3625    //      //
3626    //      if ( !row2 ) throw -25;
3627    //      //
3628    //      oss.str("");
3629    //      oss << " UPDATE GL_RUN SET ID_RUN_FRAG = " << row2->GetField(0) << " WHERE ID = " << row2->GetField(0);
3630    //      if ( IsDebug() ) printf(" Update the ID_RUN_FRAG of the inserted run: query is \n %s \n",oss.str().c_str());
3631    //      result2 = conn->Query(oss.str().c_str());
3632    //      //
3633    //      if ( !result2 ) throw -4;
3634            //
3635            moved++;
3636            //
3637          } else {
3638            if ( IsDebug() ) printf(" The already exist in the GL_RUN table! \n");
3639          };
3640          if ( IsDebug() ) printf(" Delete run %s from the GL_RUN_FRAGMENTS table \n",row->GetField(0));      
3641          //
3642          //
3643          glrun->DeleteRun(conn,(UInt_t)atoll(row->GetField(0)),"GL_RUN_FRAGMENTS");
3644    //      oss.str("");
3645    //       oss << " DELETE from GL_RUN_FRAGMENTS where ID = " << row->GetField(0);
3646    //       if ( IsDebug() ) printf(" Clean the GL_RUN_FRAGMENTS table: query is \n %s \n",oss.str().c_str());
3647    //       result2 = conn->Query(oss.str().c_str());
3648    //      //
3649    //      if ( !result2 ) throw -4;
3650    //      //
3651          row = result->Next();
3652        };
3653      };
3654      if ( IsDebug() ) printf(" Moved %u runs\n",moved);
3655      return(0);
3656    };
3657    
3658    if ( parametri[0] < 0. || parametri[0] > 0.5 || parametri[1] < 0.8 || parametri[1] > 1. ) valid = 0;  /**
3659     * Check if runs are good, i.e. if the tracker calibration is correctly associated..
3660     */
3661    Int_t PamelaDBOperations::ValidateRuns(){
3662      return(this->ValidateRuns(""));
3663    };
3664    
3665    if ( IsDebug() ) printf(" par1 = %g par2 = %g\n",parametri[0],parametri[1]);  /**
3666     * Check if runs are good, i.e. if the tracker calibration is correctly associated..
3667    return parametri;   */
3668    Int_t PamelaDBOperations::ValidateRuns(TString valfile){
3669      //
3670      TSQLResult *result = 0;
3671      TSQLRow    *row    = 0;
3672      //
3673      UInt_t calibtime = 50;
3674      //
3675      stringstream oss;
3676      oss.str("");
3677      //
3678      // =======================================================
3679      // validate runs by checking missing calibrations
3680      // =======================================================
3681      UInt_t t_stop  = 0;
3682      UInt_t t_start = 0;
3683      if ( !strcmp(valfile.Data(),"") ) {
3684        // --------------------------------------------------------------
3685        // 1) get the OBT of the last run inserted after clean-time limit
3686        // --------------------------------------------------------------
3687        oss.str("");
3688        oss << " SELECT * FROM GL_RUN  WHERE INSERT_TIME <= '" << clean_time->AsSQLString()
3689            << "' ORDER BY RUNHEADER_TIME DESC LIMIT 1;";
3690        if ( IsDebug() ) printf(" Get start validation-time: query is \n %s \n",oss.str().c_str());
3691        result = conn->Query(oss.str().c_str());
3692        if ( !result ) throw -4;
3693        if ( !result->GetRowCount() ) {
3694          printf(" No runs to validate \n");
3695          return(1);
3696        }else{
3697          row = result->Next();
3698          t_start = (UInt_t)atoll(row->GetField(4));
3699        };  
3700        // --------------------------------------------------------------
3701        // 2) get the OBT of the last validated run
3702        // --------------------------------------------------------------
3703        oss.str("");
3704        oss << " SELECT * FROM GL_RUN  WHERE VALIDATION=1 AND RUNHEADER_TIME<="<< t_start
3705            <<" ORDER BY RUNHEADER_TIME DESC LIMIT 1;";
3706        if ( IsDebug() ) printf(" Get stop validation-time: query is \n %s \n",oss.str().c_str());
3707        result = conn->Query(oss.str().c_str());
3708        if ( !result ) throw -4;
3709        if ( result->GetRowCount() ){
3710          row = result->Next();
3711          t_stop = (UInt_t)atoll(row->GetField(4));
3712        };
3713        if ( IsDebug() ) printf("Validation interval: from time %u - to time %u \n\n",t_stop,t_start);
3714        // --------------------------------------------------------------
3715        // now retrieves runs to be validated
3716        // --------------------------------------------------------------
3717        oss.str("");
3718        oss << " SELECT * FROM GL_RUN  WHERE  RUNHEADER_TIME <=" << t_start;
3719        oss << " AND RUNHEADER_TIME >="<< t_stop;
3720        oss << " ORDER BY RUNHEADER_TIME DESC;";
3721        if ( IsDebug() )printf(" Check runs for validation: query is \n %s \n",oss.str().c_str());
3722        result = conn->Query(oss.str().c_str());
3723      } else {
3724        //
3725        stringstream myquery;
3726        UInt_t myid = 0;
3727        myquery.str("");
3728        myquery << " SELECT ID FROM GL_ROOT where NAME='"<<valfile.Data() <<"';";
3729        //
3730        result = conn->Query(myquery.str().c_str());
3731        //
3732        row = result->Next();      
3733        if( !row ){
3734          if ( strcmp(valfile.Data(),GetRootName().Data()) ){
3735            if ( IsDebug() ) printf(" No file to be validated even if option \"-validate file\" was used!!\n");
3736            return(2);
3737          };
3738          if ( IsDebug() ) printf(" No file to be validated (force mode)! \n");
3739          return(0);
3740        };
3741        myid=(UInt_t)atoll(row->GetField(0));
3742        //
3743        myquery.str("");
3744        myquery << " SELECT MAX(RUNTRAILER_TIME),MIN(RUNHEADER_TIME) FROM GL_RUN WHERE ID_ROOT_L0="<< myid <<";";
3745        //
3746        result = conn->Query(myquery.str().c_str());
3747        //
3748        row = result->Next();      
3749        if( !row->GetField(0) || !row->GetField(1)){
3750          //
3751          if ( IsDebug() ) printf(" NO RUN ASSOCIATED TO THIS FILE! \n");
3752          //
3753          return(0);
3754          //
3755        } else {  
3756          //
3757          UInt_t runhtime = (UInt_t)atoll(row->GetField(0));
3758          UInt_t runttime = (UInt_t)atoll(row->GetField(1));
3759          UInt_t caltime = 0;
3760          //
3761          myquery.str("");
3762          myquery << " SELECT FROM_TIME FROM GL_TRK_CALIB where FROM_TIME>" <<runhtime;
3763          myquery << " order by FROM_TIME asc limit 1;";
3764          //
3765          if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
3766          //
3767          //
3768          result = conn->Query(myquery.str().c_str());
3769          //
3770          row = result->Next();      
3771          if( !row ){
3772            caltime = runhtime;
3773          } else {
3774            caltime = (UInt_t)atoll(row->GetField(0));
3775          };
3776          //
3777          myquery.str("");
3778          myquery << " SELECT * from GL_RUN where RUNHEADER_TIME>="<< runttime <<" AND RUNHEADER_TIME<=" ;
3779          myquery << caltime << " order by RUNHEADER_TIME DESC";
3780          //
3781          if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
3782          //
3783          result = conn->Query(myquery.str().c_str());
3784          //
3785        };
3786      };
3787      //
3788      if ( !result ) throw -4;
3789      if ( !result->GetRowCount() && IsDebug() ) printf(" No runs to validate \n");
3790      //
3791      Int_t nrow = 0;
3792      GL_RUN* this_run = new GL_RUN();
3793      GL_RUN* next_run = new GL_RUN();
3794      Int_t   nseq_max = 1000;
3795    //  UInt_t* sequence = new UInt_t[100];
3796      vector<UInt_t> sequence(nseq_max);
3797      Int_t   nseq = 0;
3798      Bool_t CHECK = false;
3799      Bool_t this_ONLINE = false;
3800      Bool_t next_ONLINE = false;
3801      UInt_t t1=0,t2=0;
3802      // ---------------------------------------------------------------------------------
3803      // - loop over runs, back in time,
3804      // - select sequences of runs close in time (less than calibtime s apart),
3805      //   which could be preceeded by a calibration
3806      // - check if there might be a missing calibration
3807      // ---------------------------------------------------------------------------------
3808      while(1){
3809              
3810              row = result->Next();
3811              if( row == NULL ) break;
3812              
3813              //------------
3814              //get run info
3815              //------------
3816              this_run->Set_GL_RUN(row);
3817                      
3818              Bool_t this_BAD = false;
3819              if(this_run->GetTRK_CALIB_USED() == 1 || this_run->GetTRK_CALIB_USED() == 2) this_ONLINE = true;
3820              else if (this_run->GetTRK_CALIB_USED() == 104)                          this_ONLINE = false;
3821              else{
3822    //                printf("Missing or corrupted header!! \n");
3823                      this_ONLINE = false;
3824                      this_BAD = true;
3825              };
3826    
3827              //-----------------------------------
3828              //compare with previous(next in time)
3829              //-----------------------------------
3830              CHECK = false;
3831              UInt_t interval=0;
3832              
3833              if( nrow != 0){
3834            
3835                      
3836                      t1 = this_run->GetRUNTRAILER_TIME();
3837                      t2 = next_run->GetRUNHEADER_TIME();
3838                      interval = (t2-t1);
3839                      
3840                      if(this_ONLINE && next_ONLINE){                               // this: ON-LINE + next: ON-LINE
3841                              
3842                              if( this_run->ID == next_run->ID_RUN_FRAG ) interval = 0;     //=> run fragments
3843                              
3844                              if( interval >= calibtime )CHECK = true;                      //more than calibtime s => there might be a calibration
3845                              
3846                              if( !CHECK && this_run->VALIDATION ){
3847                                      for (Int_t irun = 0; irun < nseq; irun++)assignVALIDATION(sequence[irun],true);
3848                                      nseq=0;
3849                              }
3850                      
3851                      }else if( !this_ONLINE && next_ONLINE) {              // this: DEFAULT + next:ON-LINE
3852                              
3853                              CHECK = true;
3854    
3855                      }else if( !next_ONLINE ){                                             // this:ANY + next:DEFAULT
3856                              
3857                              assignVALIDATION(next_run->ID,true);
3858                              nseq=0;
3859                      }
3860              }
3861    
3862              //----------------------------
3863              //check run sequence for calib
3864              //----------------------------
3865              if( CHECK ){
3866                      // check if calibration exists
3867                      if ( IsDebug() )printf("DT %i ===> CHECK Missing calibration\n",interval);
3868                      Bool_t MISSING = MissingTRK_CALIB(t1,t2);
3869                      for (Int_t irun = 0; irun < nseq; irun++)assignVALIDATION(sequence[irun],!MISSING);
3870                      nseq=0;
3871              };
3872              //--------------
3873              //store run info
3874              //--------------
3875              *next_run   = *this_run;
3876              next_ONLINE = this_ONLINE;
3877              if( !this_BAD ){
3878                      if(nseq < nseq_max){
3879                              sequence[nseq] = this_run->ID;
3880                              nseq++;
3881                      }else printf("ValidateRuns ***WARNING*** : run sequence exceed assumed size (%i) \n",nseq_max);
3882              };
3883              
3884              if ( IsDebug() ) printf("%i Run %u \n",nrow,this_run->ID);
3885              nrow++;
3886              
3887      };
3888      delete this_run;
3889      delete next_run;
3890      //
3891      return(0);
3892    };
3893    /**
3894     * Check if there might be a missing tracker calibration in a given time interval
3895     * @param t1 From absolute time
3896     * @param t2 To absolute time
3897     * @return true if there might be a missing calibration
3898     */
3899    Bool_t PamelaDBOperations::MissingTRK_CALIB(UInt_t t1,UInt_t t2){
3900            
3901            GL_TRK_CALIB* trkcalib = new GL_TRK_CALIB();
3902            
3903            // get the closest VALIDATED calibration before the run start (t2)
3904            if ( trkcalib->Query_GL_TRK_CALIB(t2, conn) )return(true);      //>>> missing
3905            
3906            if ( trkcalib->TO_TIME  < t2 ) return(true);                                    //>>> missing
3907            
3908            //==============================================================
3909            // Check is done first on the basis of time between calibration,
3910            // which should be equal to the time between ascending-nodes.
3911            //==============================================================
3912            if ( t2 - trkcalib->FROM_TIME > 5700) {
3913                    if ( IsDebug() )printf("Long time between calib and run start %u :-( ==> there might be a missing calib \n",t2 - trkcalib->FROM_TIME);
3914            //==============================================================
3915            // there might be a missing calibration, due to:
3916            // - MM full
3917            // - corrupted packets
3918            // - loss of data
3919            // There is an exception in case a download was done during ascending node
3920            //==============================================================
3921                    Bool_t DOWNLOAD = false;
3922                    // check if the calib was skipped becouse of download .... DA FARE!!
3923                    if(DOWNLOAD)return(false);
3924                    
3925                    return(true);                                   //>>> missing
3926                    
3927            };
3928            
3929            //==============================================================
3930            // If the last calibration is close to the run less than this time,
3931            // it is enough to say that there are no missing calibrations
3932            //==============================================================
3933            // the long time interval bewteen runs might be due to download
3934            if ( IsDebug() )printf("Short time between calib and run start %u :-) ==> OK! \n",t2 - trkcalib->FROM_TIME);
3935            return(false);
3936            
3937    };
3938    /**
3939     * Assign VALIDATION value to a GL_RUN entry
3940     * @param idrun Run ID
3941     * @param validation true/false
3942     */
3943    Int_t PamelaDBOperations::assignVALIDATION(UInt_t idrun, Bool_t validation){
3944            TSQLResult *result = 0;
3945            stringstream oss;
3946            oss.str("");
3947            oss << " UPDATE GL_RUN SET VALIDATION="<< (UInt_t)validation <<" WHERE ID= " << idrun << ";";
3948            //
3949    //      if ( IsDebug() )
3950    //      printf(" Set VALIDATION = %i for run %i \n",validation,idrun);
3951            if ( IsDebug() )printf(" Query: %s \n",oss.str().c_str());
3952            result = conn->Query(oss.str().c_str());
3953            if ( !result ) throw -4;
3954            return(0);
3955    }
3956    
3957    
3958    
3959    // Insert TLEs from file tlefilename in the table GL_TLE in the db
3960    // opened by conn, sorting them by date from older to newer, if each
3961    // TLE has not been alread inserted.
3962    Int_t PamelaDBOperations::populateTLE()//(TSQLServer *conn, char *tleFile)
3963    {
3964      fstream tlefile(tlefilename, ios::in);
3965    
3966      if ( !tlefile ) throw -7;
3967    
3968      vector<cTle*> ctles;
3969      vector<cTle*>::iterator iter;
3970      int present = 0;
3971    
3972      // Get three lines from tlefile, create a cTle object and put it
3973      // into ctles
3974      while(1) {
3975        cTle *tlef;
3976        string str1, str2, str3;
3977    
3978        getline(tlefile, str1);
3979        if(tlefile.eof()) break;
3980    
3981        getline(tlefile, str2);
3982        if(tlefile.eof()) break;
3983    
3984        getline(tlefile, str3);
3985        if(tlefile.eof()) break;
3986    
3987        // We now have three good lines for a cTle.
3988        tlef = new cTle(str1, str2, str3);
3989        ctles.push_back(tlef);
3990      }
3991    
3992      tlefile.close();
3993    
3994      // Sort by date
3995      sort(ctles.begin(), ctles.end(), compTLE);
3996    
3997      // Now we insert each TLE into the db
3998      for(iter = ctles.begin(); iter != ctles.end(); iter++) {
3999        cTle *tle = *iter;
4000    
4001        // Do nothing if it's already present in the db.  Just increase
4002        // the counter present.
4003        if (! isTlePresent(tle))
4004          {
4005            int status = insertTle(tle);
4006    
4007            // Insert query failed.  Return 1.
4008            if(status == EXIT_FAILURE) {
4009              
4010              if( IsDebug() ) {
4011                cerr << "Error: inserting TLE:" << endl
4012                     << tle->getName() << endl
4013                     << tle->getLine1() << endl
4014                     << tle->getLine2() << endl;
4015              }
4016    
4017              throw -4;
4018              return 1;
4019            }
4020    
4021          }
4022        else
4023          present++;
4024    
4025      }
4026    
4027      int inserted = ctles.size() - present;  // Number of inserted TLE.
4028      if ( IsDebug() )
4029        cout << "\nProcessed TLEs ranging from " << getTleDatetime(ctles[0]) << " to " << getTleDatetime(ctles[ctles.size()-1]) << "." << endl
4030             << inserted << " newly inserted TLEs out of " << ctles.size() << " processed." << endl;
4031    
4032      ctles.clear();
4033    
4034    
4035      // Return 2 if no new TLE has been inserted.  0 otherwise.
4036      if(! inserted ) return 2;
4037      return 0;
4038    }
4039    
4040    
4041    // Insert tle in the table GL_TLE using the connection conn.
4042    Int_t PamelaDBOperations::insertTle(cTle *tle)
4043    {
4044      stringstream oss;
4045      TSQLResult *result = 0;
4046    
4047      oss.str("");
4048      oss << " INSERT INTO GL_TLE (TLE1, TLE2, TLE3, FROM_TIME)"
4049          << " VALUES ( '"
4050          << tle->getName() << "', '"
4051          << tle->getLine1() << "', '"
4052          << tle->getLine2() << "', '"
4053          << getTleDatetime(tle) << "')";
4054    
4055      //  cout << oss.str().c_str() << endl;
4056      result = conn->Query(oss.str().c_str());
4057      if (result == NULL)
4058        return EXIT_FAILURE;
4059    
4060      return EXIT_SUCCESS;
4061    }
4062    
4063    
4064    // Return whether tle is already in the db connected by conn.
4065    bool PamelaDBOperations::isTlePresent(cTle *tle)
4066    {
4067      stringstream oss;
4068      TSQLResult *result = 0;
4069    
4070      oss.str("");
4071      oss << "SELECT * FROM GL_TLE WHERE FROM_TIME = '"
4072          << getTleDatetime(tle) << "'";
4073    
4074      result = conn->Query(oss.str().c_str());
4075      if (result == NULL) throw -4;
4076    
4077      if (result->GetRowCount())
4078        return true;
4079      else
4080        return false;
4081    }
4082    
4083    
4084    // Return whether the first TLE is dated early than the second
4085    bool compTLE (cTle *tle1, cTle *tle2)
4086    {
4087      return getTleJulian(tle1) < getTleJulian(tle2);
4088    }
4089    
4090    
4091    // Return the date of the tle using the format (year-2000)*1e3 +
4092    // julian day.  e.g. 6365 is the 31th Dec 2006.
4093    // It does *not* return a cJulian date.
4094    float getTleJulian(cTle *tle) {
4095      return tle->getField(cTle::FLD_EPOCHYEAR)*1e3 + tle->getField(cTle::FLD_EPOCHDAY);
4096    }
4097    
4098    
4099    // Return a string like YYYY-MM-DD hh:mm:ss, usable for mysql datetime
4100    // format.
4101    string getTleDatetime(cTle *tle)
4102    {
4103      int year, mon, day, hh, mm, ss;
4104      double dom; // day of month (is double!)
4105      stringstream date; // date in datetime format
4106    
4107      // create a cJulian from the date in tle
4108      cJulian jdate = cJulian( 2000 + (int) tle->getField(cTle::FLD_EPOCHYEAR), tle->getField(cTle::FLD_EPOCHDAY));
4109    
4110      // get year, month, day of month
4111      jdate.getComponent(&year, &mon, &dom);
4112    
4113      // build a datetime YYYY-MM-DD hh:mm:ss
4114      date.str("");
4115      day = (int) floor(dom);
4116      hh = (int) floor( (dom - day) * 24);
4117      mm = (int) floor( ((dom - day) * 24 - hh) * 60);
4118      ss = (int) floor( ((((dom - day) * 24 - hh) * 60 - mm) * 60));
4119      //  ms = (int) floor( (((((dom - day) * 24 - hh) * 60 - mm) * 60) - ss) * 1000);
4120    
4121      date << year << "-" << mon << "-" << day << " " << hh << ":" << mm << ":" << ss;
4122    
4123      return date.str();
4124    }
4125    
4126    /**
4127     * Remove a file from the DB, delete on cascade all entries related to that file
4128     * rearrange GL_RUN and GL_XXX_CALIB tables, turn off validation till the following
4129     * calibration
4130     **/
4131    Int_t PamelaDBOperations::removeFile(TString remfile){
4132      //
4133      // Determine ID_ROOT_L0 and ID_RAW
4134      //
4135      TSQLResult *pResult;
4136      TSQLRow *Row;
4137      stringstream myquery;
4138      //  
4139      myquery.str("");
4140      myquery << " SELECT ID, ID_RAW FROM GL_ROOT where NAME='"<<remfile.Data() <<"';";
4141      //
4142      pResult = conn->Query(myquery.str().c_str());
4143      //
4144      Row = pResult->Next();      
4145      if( !Row ){
4146        if ( strcmp(remfile.Data(),GetRootName().Data()) ){
4147          if ( IsDebug() ) printf(" No file to be removed even if option \"-remove file\" was used!!\n");
4148          return(1);
4149        };
4150        if ( IsDebug() ) printf(" No file to be removed (force mode)! \n");
4151        return(0);
4152      };
4153      //
4154      this->SetID_ROOT((UInt_t)atoll(Row->GetField(0)));
4155      this->SetID_RAW((UInt_t)atoll(Row->GetField(1)));
4156      //
4157      this->ValidationOFF();
4158      //
4159      this->RemoveCALIBS();
4160      //
4161      this->RemoveRUNS();
4162      //
4163      this->RemoveFILES();
4164      //
4165      this->SetID_ROOT(0);
4166      this->SetID_RAW(0);
4167      //
4168      return(0);
4169    };
4170    
4171    /**
4172     *
4173     * Set validation bit to zero for runs following the removing file till
4174     * 1) a run with TRK_CALIB_USED=140
4175     * 2) a run with VALIDATION = 0
4176     * 3) the next calibration
4177     *
4178     **/
4179    void PamelaDBOperations::ValidationOFF(){
4180      TSQLResult *pResult;
4181      TSQLRow *Row;
4182      stringstream myquery;
4183      Int_t unv = 0;
4184      //select ID from GL_RUN where RUNHEADER_TIME>=1152671382 AND (VALIDATION=0 OR TRK_CALIB_USED=104) order by RUNHEADER_TIME asc limit 1;
4185      myquery.str("");
4186      myquery << " SELECT MAX(RUNTRAILER_TIME) FROM GL_RUN WHERE ID_ROOT_L0="<< this->GetID_ROOT() <<";";
4187      //
4188      pResult = conn->Query(myquery.str().c_str());
4189      //
4190      Row = pResult->Next();      
4191      if( !Row->GetField(0) ){
4192        //
4193        if ( IsDebug() ) printf(" NO RUN ASSOCIATED TO THIS FILE! \n");
4194        //
4195      } else {  
4196        //
4197        UInt_t runhtime = (UInt_t)atoll(Row->GetField(0));
4198        UInt_t caltime = 0;
4199        //
4200        myquery.str("");
4201        myquery << " SELECT FROM_TIME FROM GL_TRK_CALIB where FROM_TIME>" <<runhtime;
4202        myquery << " order by FROM_TIME asc limit 1;";
4203        //
4204        if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
4205        //
4206        //
4207        delete pResult;
4208        pResult = conn->Query(myquery.str().c_str());
4209        //
4210        Row = pResult->Next();      
4211        if( !Row ){
4212          caltime = runhtime;
4213        } else {
4214          caltime = (UInt_t)atoll(Row->GetField(0));
4215        };
4216        //
4217        myquery.str("");
4218        myquery << " SELECT ID,RUNHEADER_TIME from GL_RUN where RUNHEADER_TIME>="<< runhtime <<" AND (VALIDATION=0 OR TRK_CALIB_USED=104 OR RUNHEADER_TIME>" ;
4219        myquery << caltime << ") order by RUNHEADER_TIME asc LIMIT 1";
4220        //
4221        if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
4222        //
4223        pResult = conn->Query(myquery.str().c_str());
4224        //
4225        Row = pResult->Next();      
4226        if( !Row ){
4227          //
4228          if ( IsDebug() ) printf(" NO RUN NEED TO BE UNVALIDATED \n");
4229          //
4230        } else {
4231          myquery.str("");
4232          myquery << " SELECT ID from GL_RUN where RUNHEADER_TIME<"<< Row->GetField(1) <<" AND ";
4233          myquery << " RUNHEADER_TIME>=" <<runhtime;
4234          myquery << " order by RUNHEADER_TIME asc;";
4235          //
4236          if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
4237          //
4238          pResult = conn->Query(myquery.str().c_str());
4239          //
4240          Row = pResult->Next();  
4241          while ( Row ){
4242            //      
4243            unv++;
4244            this->assignVALIDATION((UInt_t)atoll(Row->GetField(0)), false);
4245            Row = pResult->Next();  
4246            //
4247          };
4248        };
4249      };
4250      if ( IsDebug() ) printf(" %u runs have been unvalidated \n",unv);
4251    };
4252    
4253    /**
4254     *
4255     * Rearrange GL_RUN table and remove runs
4256     *
4257     **/
4258    void PamelaDBOperations::RemoveRUNS(){
4259      TSQLResult *pResult;
4260      TSQLRow *Row;
4261      stringstream myquery;
4262      UInt_t drun = 0;
4263      GL_RUN *delrun = new GL_RUN();
4264      //
4265      myquery.str("");
4266      myquery << " SELECT ID FROM GL_RUN where ID_RUN_FRAG=0 and ID_ROOT_L0=" <<this->GetID_ROOT() <<";";
4267      //
4268      if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
4269      //
4270      pResult = conn->Query(myquery.str().c_str());
4271      //
4272      Row = pResult->Next();    
4273      //
4274      //
4275      if ( !Row ){
4276        if ( IsDebug() ) printf(" No run with ID_RUN_FRAG=0 belonged to this file \n");
4277      } else {
4278        if ( IsDebug() ) printf(" Deleting run from GL_RUN table \n");    
4279        while ( Row ){
4280          delrun->DeleteRun(conn,(UInt_t)atoll(Row->GetField(0)),"GL_RUN");
4281          if ( IsDebug() ) printf(" del run %u \n",(UInt_t)atoll(Row->GetField(0)));
4282          drun++;
4283          Row = pResult->Next();    
4284        };
4285      };
4286      //
4287      //
4288      myquery.str("");
4289      myquery << " SELECT ID,ID_RUN_FRAG FROM GL_RUN where ID_RUN_FRAG!=0 and ID_ROOT_L0=" <<this->GetID_ROOT() <<";";
4290      //
4291      if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
4292      //
4293      pResult = conn->Query(myquery.str().c_str());
4294      //
4295      Row = pResult->Next();    
4296      //
4297      if ( !Row ){
4298        if ( IsDebug() ) printf(" No run with ID_RUN_FRAG!=0 belonged to this file \n");
4299      } else {
4300        if ( IsDebug() ) printf(" Deleting run fragments from GL_RUN table \n");    
4301        while ( Row ){
4302          if ( IsDebug() ) printf(" restore run %u \n",(UInt_t)atoll(Row->GetField(1)));
4303          delrun->RestoreRun(conn,(UInt_t)atoll(Row->GetField(1)),"GL_RUN_FRAGMENTS");
4304          if ( IsDebug() ) printf(" del run %u \n",(UInt_t)atoll(Row->GetField(1)));
4305          delrun->DeleteRun(conn,(UInt_t)atoll(Row->GetField(1)),"GL_RUN");
4306          if ( (UInt_t)atoll(Row->GetField(1)) != (UInt_t)atoll(Row->GetField(0)) ){
4307            if ( IsDebug() ) printf(" del run %u \n",(UInt_t)atoll(Row->GetField(0)));
4308            delrun->DeleteRun(conn,(UInt_t)atoll(Row->GetField(0)),"GL_RUN");
4309          };
4310          drun++;
4311          Row = pResult->Next();    
4312        };
4313      };
4314      //
4315      if ( IsDebug() ) printf(" Deleted %i run(s) from GL_RUN table \n",drun);    
4316      //
4317      //
4318      //
4319      drun = 0;
4320      //
4321      myquery.str("");
4322      myquery << " SELECT ID_TRASH FROM GL_RUN_TRASH where BELONGED_TO='GL_RUN_FRAGMENTS' AND ID_ROOT_L0=" <<this->GetID_ROOT() <<";";
4323      //
4324      pResult = conn->Query(myquery.str().c_str());
4325      //
4326      Row = pResult->Next();    
4327      //
4328      if ( !Row ){
4329        if ( IsDebug() ) printf(" No run from GL_RUN_FRAGMENTS table in the trash table for this file \n");
4330      } else {
4331        if ( IsDebug() ) printf(" Deleting run fragments from GL_RUN_TRASH table \n");    
4332        while ( Row ){
4333          if ( IsDebug() ) printf(" del run idtrash %u \n",(UInt_t)atoll(Row->GetField(0)));
4334          myquery.str("");
4335          myquery << " DELETE FROM GL_RUN_TRASH where ID_TRASH=" << Row->GetField(0) <<";";      
4336          conn->Query(myquery.str().c_str());
4337          drun++;
4338          Row = pResult->Next();    
4339        };
4340      };
4341      //  
4342      if ( IsDebug() ) printf(" Deleted %u run(s) from GL_RUN_TRASH table \n",drun);    
4343      //
4344      //
4345      //
4346      drun = 0;
4347      //
4348      myquery.str("");
4349      myquery << " SELECT ID FROM GL_RUN_FRAGMENTS where ID_ROOT_L0=" <<this->GetID_ROOT() <<";";
4350      //
4351      pResult = conn->Query(myquery.str().c_str());
4352      //
4353      Row = pResult->Next();    
4354      //
4355      if ( !Row ){
4356        if ( IsDebug() ) printf(" No run in the GL_RUN_FRAGMENTS table for this file \n");
4357      } else {
4358        if ( IsDebug() ) printf(" Deleting run fragments from GL_RUN_FRAGMENTS table \n");    
4359        while ( Row ){
4360          if ( IsDebug() ) printf(" del run %u \n",(UInt_t)atoll(Row->GetField(0)));
4361          myquery.str("");
4362          myquery << " DELETE FROM GL_RUN_FRAGMENTS where ID=" << Row->GetField(0) <<";";
4363          conn->Query(myquery.str().c_str());
4364          drun++;
4365          Row = pResult->Next();    
4366        };
4367      };
4368      //  
4369      if ( IsDebug() ) printf(" Deleted %u run(s) from GL_RUN_FRAGMENTS table \n",drun);    
4370      //
4371      //
4372      //
4373      delete delrun;
4374      //
4375    };
4376    
4377    
4378    /**
4379     *
4380     * Rearrange calibration tables
4381     *
4382     **/
4383    void PamelaDBOperations::RemoveFILES(){
4384      stringstream myquery;
4385      //
4386      myquery.str("");
4387      myquery << " DELETE FROM GL_RAW WHERE ID=" <<this->GetID_RAW() <<";";
4388      //
4389      if ( IsDebug() ) printf("  query is \n %s \n",myquery.str().c_str());
4390      //
4391      conn->Query(myquery.str().c_str());
4392      //
4393    };
4394    
4395    /**
4396     *
4397     * Rearrange calibration tables
4398     *
4399     **/
4400    void PamelaDBOperations::RemoveCALIBS(){
4401      TSQLResult *pResult;
4402      TSQLRow *Row;
4403      stringstream myquery;
4404      //  
4405      //
4406      // Calorimeter
4407      //
4408      for (Int_t section = 0; section < 4; section++){
4409        myquery.str("");
4410        myquery << " SELECT MIN(FROM_TIME),MAX(TO_TIME) FROM GL_CALO_CALIB WHERE ID_ROOT_L0="<< this->GetID_ROOT() <<" AND ";
4411        myquery << " SECTION=" << section << ";";
4412        //
4413        pResult = conn->Query(myquery.str().c_str());
4414        //
4415        Row = pResult->Next();      
4416        if( !Row->GetField(0) || !Row->GetField(1) ){
4417          //
4418          if ( IsDebug() ) printf(" NO CALO CALIBRATION SECTION %i ASSOCIATED TO THIS FILE! \n",section);
4419          //
4420        } else {
4421          //
4422          myquery.str("");
4423          myquery << " UPDATE GL_CALO_CALIB SET TO_TIME=" << Row->GetField(1);
4424          myquery << " WHERE TO_TIME="<< Row->GetField(0) << " AND ";
4425          myquery << " SECTION=" << section << ";";
4426          //
4427          pResult = conn->Query(myquery.str().c_str());
4428          //
4429          if( !pResult ){
4430            //
4431            if ( IsDebug() ) printf(" ERROR DELETING CALO CALIBRATIONS \n");
4432            //
4433            throw -4;
4434            //
4435          };
4436          //
4437        };
4438      };
4439      myquery.str("");
4440      myquery << " DELETE FROM GL_CALO_CALIB WHERE ID_ROOT_L0=" << this->GetID_ROOT();
4441      //
4442      pResult = conn->Query(myquery.str().c_str());
4443      //
4444      if( !pResult ){
4445        //
4446        if ( IsDebug() ) printf(" ERROR DELETING CALO CALIBRATIONS \n");
4447        //
4448        throw -4;
4449        //
4450      };
4451      //
4452      // Tracker
4453      //
4454      myquery.str("");
4455      myquery << " SELECT MIN(FROM_TIME),MAX(TO_TIME) FROM GL_TRK_CALIB WHERE ID_ROOT_L0="<< this->GetID_ROOT() <<";";
4456      //
4457      pResult = conn->Query(myquery.str().c_str());
4458      //
4459      Row = pResult->Next();      
4460      if( !Row->GetField(0) || !Row->GetField(1) ){
4461        //
4462        if ( IsDebug() ) printf(" NO TRK CALIBRATION ASSOCIATED TO THIS FILE! \n");
4463        //
4464      } else {
4465        //
4466        myquery.str("");
4467        myquery << " UPDATE GL_TRK_CALIB SET TO_TIME=" << Row->GetField(1);
4468        myquery << " WHERE TO_TIME="<< Row->GetField(0) << ";";
4469        //
4470        pResult = conn->Query(myquery.str().c_str());
4471        //
4472        if( !pResult ){
4473          //
4474          if ( IsDebug() ) printf(" ERROR DELETING TRK CALIBRATIONS \n");
4475          //
4476          throw -4;
4477          //
4478        };
4479        //
4480        myquery.str("");
4481        myquery << " DELETE FROM GL_TRK_CALIB WHERE ID_ROOT_L0=" << this->GetID_ROOT();
4482        //
4483        pResult = conn->Query(myquery.str().c_str());
4484        //
4485        if( !pResult ){
4486          //
4487          if ( IsDebug() ) printf(" ERROR DELETING TRK CALIBRATIONS \n");
4488          //
4489          throw -4;
4490          //
4491        };
4492      };
4493      //
4494      //
4495      // S4
4496      //
4497      myquery.str("");
4498      myquery << " SELECT MIN(FROM_TIME),MAX(TO_TIME) FROM GL_S4_CALIB WHERE ID_ROOT_L0="<< this->GetID_ROOT() <<";";
4499      //
4500      pResult = conn->Query(myquery.str().c_str());
4501      //
4502      Row = pResult->Next();      
4503      if( !Row->GetField(0) || !Row->GetField(1) ){
4504        //
4505        if ( IsDebug() ) printf(" NO S4 CALIBRATION ASSOCIATED TO THIS FILE! \n");
4506        //
4507      } else {
4508        //
4509        myquery.str("");
4510        myquery << " UPDATE GL_S4_CALIB SET TO_TIME=" << Row->GetField(1);
4511        myquery << " WHERE TO_TIME="<< Row->GetField(0) << ";";
4512        //
4513        pResult = conn->Query(myquery.str().c_str());
4514        //
4515        if( !pResult ){
4516          //
4517          if ( IsDebug() ) printf(" ERROR DELETING S4 CALIBRATIONS \n");
4518          //
4519          throw -4;
4520          //
4521        };
4522        //
4523        myquery.str("");
4524        myquery << " DELETE FROM GL_S4_CALIB WHERE ID_ROOT_L0=" << this->GetID_ROOT();
4525        //
4526        pResult = conn->Query(myquery.str().c_str());
4527        //
4528        if( !pResult ){
4529          //
4530          if ( IsDebug() ) printf(" ERROR DELETING S4 CALIBRATIONS \n");
4531          //
4532          throw -4;
4533          //
4534        };
4535        //
4536      };
4537    };
4538    
4539    /**
4540     *
4541     * Rearrange calibration tables
4542     *
4543     **/
4544    UInt_t PamelaDBOperations::ValidateTrkCalib( CalibTrk1Event* caltrk, EventHeader *eh ){
4545    
4546        Int_t vorder[]={5,5,3,3,4,4,2,2,1,1,0,0};
4547        UInt_t timeaftercalib=120000; //2000;
4548    //  ----------
4549    //  Check CRCs
4550    //  ----------
4551        for(Int_t ipkt=0; ipkt<6; ipkt++){
4552            if( caltrk->crc_hcal[ipkt] )return 0; // :-(
4553            for(Int_t ilad=0; ilad<3; ilad++)if( caltrk->crc_cal[ipkt][ilad] )return 0; // :-(
4554        }
4555    //  -----------------------
4556    //  Check missing packets:
4557    //  -----------------------
4558    //    Readout order:
4559    //    ------------------
4560    //    DSP   packet board
4561    //    ------------------
4562    //    12    0      1
4563    //    10    1      1
4564    //     8    2      1
4565    //     4    3      1
4566    //     6    4      1
4567    //     2    5      1
4568    //    ------------------
4569    //    11    0      2
4570    //     9    1      2
4571    //     7    2      2
4572    //     3    3      2
4573    //     5    4      2
4574    //     1    5      2
4575    //    ------------------
4576    //  -------------------------------------------------
4577    //  Check if it is first or second calibration packet
4578    //  -------------------------------------------------
4579        UInt_t build=0;
4580        TString classname = caltrk->GetName();
4581        UInt_t base=0;
4582        UInt_t mask=0;
4583        if(classname.Contains("CalibTrk1Event")){
4584            base=12;
4585            mask=0x03F000;
4586        }
4587        if(classname.Contains("CalibTrk2Event")){
4588            base=18;
4589            mask=0xFC0000;
4590        }
4591    //  -------------------------------------------------
4592    //  Count number of packets and set build variable
4593    //  -------------------------------------------------
4594        Int_t  npkts=0;
4595        for(Int_t ipkt=0; ipkt<6; ipkt++){
4596            if(caltrk->DSPnumber[ipkt]>0 && caltrk->DSPnumber[ipkt]<=12){
4597                npkts++;
4598                build = build | ( 1<<(base+vorder[caltrk->DSPnumber[ipkt]-1]) );
4599            }
4600        }
4601    //    if( npkts==6 )return 1; // :-)
4602    
4603    //    cout << classname << " "<<eh->GetPscuHeader()->GetOrbitalTime()<<endl;
4604    
4605    //  -----------------------------------------------
4606    //  If missing packets: check the acq configuration
4607    //  (some DSPs might be excluded from acquisition)
4608    //  -----------------------------------------------
4609    
4610    //  -----------------------------------------------
4611    //  retrieve the first run header after calib
4612    //  -----------------------------------------------
4613         PacketType *pctp;
4614         EventCounter *cod;
4615         cod = eh->GetCounter();
4616         Int_t irun = cod->Get(pctp->RunHeader);
4617         TTree *rh=(TTree*)file->Get("RunHeader");
4618         if ( !rh || rh->IsZombie() ) throw -17;
4619         if( rh->GetEntries() == irun ){
4620              if ( IsDebug() ) cout << "ValidateTrkCalib: (MISSING VIEW) no runs after calib (1)  -- cannot validate :-( "<<endl;
4621             return 0; // :-(
4622         }
4623    
4624         RunHeaderEvent *run  = 0;
4625         EventHeader    *hrun = 0;
4626         rh->SetBranchAddress("RunHeader", &run);
4627         rh->SetBranchAddress("Header", &hrun);
4628         rh->GetEntry(irun);
4629    //     cout << classname << " "<<eh->GetPscuHeader()->GetOrbitalTime() << " Run " << hrun->GetPscuHeader()->GetOrbitalTime() <<endl;
4630    
4631         if( OBT(hrun->GetPscuHeader()->GetOrbitalTime()) < OBT(eh->GetPscuHeader()->GetOrbitalTime())){
4632              if ( IsDebug() ) cout << "ValidateTrkCalib: (MISSING VIEW) no runs after calib (2) -- cannot validate :-( "<<endl;
4633             return 0; // :-(
4634         }
4635        
4636         if( !run->RM_ACQ_AFTER_CALIB ){
4637              if ( IsDebug() ) cout << "ValidateTrkCalib: (MISSING VIEW) RM_ACQ_AFTER_CALIB=0    -- cannot validate :-( "<<endl;
4638             return 0; // :-(
4639         }
4640    
4641         UInt_t dtime = OBT(hrun->GetPscuHeader()->GetOrbitalTime()) - OBT(eh->GetPscuHeader()->GetOrbitalTime());
4642         if( dtime > timeaftercalib ){
4643             if ( IsDebug() ) cout << "ValidateTrkCalib: (MISSING VIEW) run after calib too far ( "<<dtime<<"ms ) -- cannot validate :-( "<<endl;
4644             return 0; // :-(
4645         }
4646        
4647    
4648    
4649         if( (run->ACQ_BUILD_INFO & mask) != build ){
4650             if ( IsDebug() ) cout << "ValidateTrkCalib: (MISSING VIEW) ACQ_BUILD_INFO= >>> "<<hex << (run->ACQ_BUILD_INFO&mask) << " != "<< build << dec<<endl;
4651             return 0; // :-(
4652         }
4653         return 1; // :-)
4654    
4655    }
4656    
4657    /**
4658     *
4659     * Check the DB (only for overlapping runs at the moment)
4660     *
4661     **/
4662    UInt_t PamelaDBOperations::Check(){
4663      //
4664      UInt_t test = 0;
4665      //
4666      UInt_t thisrht = 0;
4667      UInt_t thisrtt = 0;
4668      UInt_t thisid = 0;
4669      UInt_t prevrht = 0;
4670      UInt_t prevrtt = 0;
4671      UInt_t previd = 0;
4672      //
4673      UInt_t prevl0id = 0;
4674      UInt_t thisl0id = 0;
4675      //
4676      stringstream oss;
4677      TSQLResult *result = 0;
4678      TSQLRow    *row    = 0;
4679      TSQLResult *result2 = 0;
4680      TSQLRow    *row2    = 0;
4681      oss.str("");
4682      oss << "SELECT ID,ID_ROOT_L0,RUNHEADER_TIME,RUNTRAILER_TIME FROM GL_RUN order by RUNHEADER_TIME asc;";
4683      //  oss << "SELECT ID,RUNHEADER_TIME,RUNTRAILER_TIME FROM GL_RUN where ID>10170 and ID<10190 order by RUNHEADER_TIME asc;";
4684      result = conn->Query(oss.str().c_str());
4685      //
4686      if ( !result ) throw -4;;
4687      //
4688      row = result->Next();
4689      //
4690      while ( row ){
4691        thisid = (UInt_t)atoll(row->GetField(0));
4692        thisl0id = (UInt_t)atoll(row->GetField(1));
4693        thisrht = (UInt_t)atoll(row->GetField(2));
4694        thisrtt = (UInt_t)atoll(row->GetField(3));
4695        //
4696        //    if ( thisrht < prevrtt || thisrtt < prevrht || thisrht > thisrtt && !(!prevrht && !prevrtt &&!previd) ){
4697        //    if ( (thisrht < prevrtt || thisrtt < prevrht || thisrht > thisrtt) && (thisrht != prevrht) ){
4698        if ( (thisrht < prevrtt) && (thisrht != prevrht) ){
4699          if ( IsDebug() ) printf(" IDprev %u ID %u    prevrht %u prevrtt %u  thisrht %u thisrtt %u \n",previd,thisid,prevrht,prevrtt,thisrht,thisrtt);
4700          printf(" CHECK n.1 TIME SCREW of %i s AROUND RUNs %u and %u \n",(thisrht-prevrtt),previd,thisid);
4701          TString prevf = "";
4702          TString thisf = "";
4703          oss.str("");
4704          oss << "SELECT NAME FROM GL_ROOT where ID=" << (UInt_t)prevl0id <<";";
4705          result2 = conn->Query(oss.str().c_str());
4706          if ( !result2 ) throw -4;;
4707          row2 = result2->Next();
4708          prevf = (TString)row2->GetField(0);
4709          oss.str("");
4710          oss << "SELECT NAME FROM GL_ROOT where ID=" << (UInt_t)thisl0id <<";";
4711          result2 = conn->Query(oss.str().c_str());
4712          if ( !result2 ) throw -4;;
4713          row2 = result2->Next();
4714          thisf = (TString)row2->GetField(0);
4715          if ( IsDebug() ) printf(" ==> files %s and %s \n",prevf.Data(),thisf.Data());
4716          test = 1;
4717        };
4718        //
4719        if ( (thisrtt < prevrht) && (thisrht != prevrht) ){
4720          if ( IsDebug() ) printf(" IDprev %u ID %u    prevrht %u prevrtt %u  thisrht %u thisrtt %u \n",previd,thisid,prevrht,prevrtt,thisrht,thisrtt);
4721          printf(" CHECK n.2 TIME SCREW of %i s AROUND RUNs %u and %u \n",(thisrtt-prevrht),previd,thisid);
4722          TString prevf = "";
4723          TString thisf = "";
4724          oss.str("");
4725          oss << "SELECT NAME FROM GL_ROOT where ID=" << (UInt_t)prevl0id <<";";
4726          result2 = conn->Query(oss.str().c_str());
4727          if ( !result2 ) throw -4;;
4728          row2 = result2->Next();
4729          prevf = (TString)row2->GetField(0);
4730          oss.str("");
4731          oss << "SELECT NAME FROM GL_ROOT where ID=" << (UInt_t)thisl0id <<";";
4732          result2 = conn->Query(oss.str().c_str());
4733          if ( !result2 ) throw -4;;
4734          row2 = result2->Next();
4735          thisf = (TString)row2->GetField(0);
4736          if ( IsDebug() ) printf(" ==> files %s and %s \n",prevf.Data(),thisf.Data());
4737          test = 1;
4738        };
4739        //
4740        if ( (thisrht > thisrtt) && (thisrht != prevrht) ){
4741          if ( IsDebug() ) printf(" IDprev %u ID %u    prevrht %u prevrtt %u  thisrht %u thisrtt %u \n",previd,thisid,prevrht,prevrtt,thisrht,thisrtt);
4742          printf(" CHECK n.3 TIME SCREW of %i s AROUND RUNs %u and %u \n",(thisrht-thisrtt),previd,thisid);
4743          TString prevf = "";
4744          TString thisf = "";
4745          oss.str("");
4746          oss << "SELECT NAME FROM GL_ROOT where ID=" << (UInt_t)prevl0id <<";";
4747          result2 = conn->Query(oss.str().c_str());
4748          if ( !result2 ) throw -4;;
4749          row2 = result2->Next();
4750          prevf = (TString)row2->GetField(0);
4751          oss.str("");
4752          oss << "SELECT NAME FROM GL_ROOT where ID=" << (UInt_t)thisl0id <<";";
4753          result2 = conn->Query(oss.str().c_str());
4754          if ( !result2 ) throw -4;;
4755          row2 = result2->Next();
4756          thisf = (TString)row2->GetField(0);
4757          if ( IsDebug() ) printf(" ==> files %s and %s \n",prevf.Data(),thisf.Data());
4758          test = 1;
4759        };
4760    
4761        //
4762        prevrht = thisrht;
4763        prevrtt = thisrtt;
4764        previd = thisid;
4765        prevl0id = thisl0id;
4766        row = result->Next();
4767      };
4768      //
4769      return(test);
4770      //
4771  };  };

Legend:
Removed from v.1.1  
changed lines
  Added in v.1.45

  ViewVC Help
Powered by ViewVC 1.1.23