YodaProfiler/src/YodaProfiler.cpp

//
#include <iostream>
#include <sstream>
#include <errno.h>
//
#include <TSystem.h>
//
#include <PamelaDBOperations.h>
#include <YodaProfilerVerl2.h>
//
using namespace std;
//
// Usage subroutine
//
void usage(){
  printf("\nUsage:\n");
  printf("\n YodaProfiler [options] -rawFile raw_filename -yodaFile yoda_filename \n");
  printf("\n -rawFile        full path to the raw file\n");
  printf("\n -yodaFile       full path to the YODA file\n");
  printf("\n Options can be: \n");
  printf("\n --version       print informations about compilation and exit\n");
  printf("\n -h | --help     print this help and exit \n");
  printf("\n -v | --verbose  be verbose [default]\n");
  printf("\n -s | --silent   print nothing on STDOUT\n");
  printf("\n -g | --debug    be very verbose [default: no]\n");
  printf("\n -boot number    CPU boot number [default = taken from VarDump]\n");
  printf("\n -tsync number   timesync (s) [default = taken from data]\n");
  printf("\n -obt0 number    obt at timesync (ms) [default = taken from data]\n");
  printf("\n -clean number   number in seconds after which the fragment table\n");
  printf("\n                 can be cleaned and runs validated [default = -1 do not clean],\n");
  printf("\n                 if 0 force cleaning immediatly, if negative do not clean\n");
  printf("\n -host           name for the host [default = $PAM_DBHOST or mysql://localhost/pamelaprod]\n");
  printf("\n -user           username for the DB [default = $PAM_DBUSER or \"anonymous\"] \n");
  printf("\n -psw            password for the DB [default = $PAM_DBPSW or \"\"]\n");
  printf("\n The order of input files and options does not matter. \n");
  printf("\nExample: \n");
  printf("\n YodaProfiler -yodaFile /path/to/raw/files/000_000_00000_cln2.pam -rawFile /path/to/filesfromyoda/000_000_00000_cln2.root -v \n\n");
};
//
int main(int numinp, char *inps[]){
  //
  // Variables booking
  //
  Int_t signal = 0;
  Int_t nul = 0;
  UInt_t boot = 0;
  UInt_t tsync = 0;
  UInt_t obt0 = 0;
  //  Long64_t olderthan = 864000LL;
  Long64_t olderthan = -1LL;
  
  //
  //
  TString filerawname  = "";
  TString filerootname = "";
  //
  TString host = "mysql://localhost/pamelaprod";
  TString user = "anonymous";
  TString password = "";
  //
  const char *pamdbhost=gSystem->Getenv("PAM_DBHOST");
  const char *pamdbuser=gSystem->Getenv("PAM_DBUSER");
  const char *pamdbpsw=gSystem->Getenv("PAM_DBPSW");
  if ( strcmp(pamdbhost,"") ) host = pamdbhost;
  if ( strcmp(pamdbuser,"") ) user = pamdbuser;
  if ( strcmp(pamdbpsw,"") ) password = pamdbpsw;
  //
  //    
  Bool_t beverbose = true;
  Bool_t debug = false;
  Int_t i = 0;
  //
  if ( numinp > 1 ){
    while ( i < numinp ){
      if ( !strcmp(inps[i],"--version") ){
        YodaProfilerInfo(true);
        exit(0);
      };
      if ( !strcmp(inps[i],"-h") || !strcmp(inps[i],"--help") ){

        usage();
        exit(0);
      };
      if ( !strcmp(inps[i],"-rawFile") ) {
        if ( numinp-1 < i+1 ){
          usage();
          exit(1);
        };
        filerawname = (TString)inps[i+1];               
      };
      if ( !strcmp(inps[i],"-yodaFile") ) {
        if ( numinp-1 < i+1 ){
          usage();
          exit(1);
        };
        filerootname = (TString)inps[i+1];      
      };
      if ( !strcmp(inps[i],"-boot") ) {
        if ( numinp-1 < i+1 ){
          usage();
          exit(1);
        };
        boot = atoi(inps[i+1]); 
      };
      if ( !strcmp(inps[i],"-tsync") ) {
        if ( numinp-1 < i+1 ){
          usage();
          exit(1);
        };
        tsync = (UInt_t)atoll(inps[i+1]);       
      };
      if ( !strcmp(inps[i],"-obt0") ) {
        if ( numinp-1 < i+1 ){
          usage();
          exit(1);
        };
        obt0 = (UInt_t)atoll(inps[i+1]);        
      };
      if ( !strcmp(inps[i],"-clean") ) {
        if ( numinp-1 < i+1 ){
          usage();
          exit(1);
        };
        olderthan = (Long64_t)atoll(inps[i+1]); 
      };
      if ( !strcmp(inps[i],"-host") ) {
        if ( numinp-1 < i+1 ){
          usage();
          exit(1);
        };
        host = (TString)inps[i+1];      
      };
      if ( !strcmp(inps[i],"-user") ) {
        if ( numinp-1 < i+1 ){
          usage();
          exit(1);
        };
        user = (TString)inps[i+1];      
      };
      if ( !strcmp(inps[i],"-psw") ) {
        if ( numinp-1 < i+1 ){
          usage();
          exit(1);
        };
        password = (TString)inps[i+1];  
      };
      //
      if ( !strcmp(inps[i],"-v") || !strcmp(inps[i],"--verbose") ) beverbose = true;
      //
      if ( !strcmp(inps[i],"-s") || !strcmp(inps[i],"--silent") ) beverbose = false;
      //
      if ( !strcmp(inps[i],"-g") || !strcmp(inps[i],"--debug") ) debug = true;
      //
      i++;
    };
  } else {
    //
    // no input parameters exit with error, we need at least the run id.
    //
    cout << "\n ERROR: NO INPUT PARAMETERS \n";
    usage();
    exit(1);
  };

  //
  // If not in verbose mode redirect to /dev/null the stdout and stderr
  //
  if ( !beverbose ){
    nul = open("/dev/null", O_CREAT | O_RDWR,S_IREAD | S_IWRITE);
    dup2(nul,1);
    dup2(nul,2);
  };
  //
  // Start:
  //
  TString message;
  char *version = YodaProfilerInfo(false);
  PamelaDBOperations *pamDB = 0;
  UInt_t sizeofwar = 10;
  UInt_t WAR[10];
  memset(WAR, 0, 10*sizeof(UInt_t));
  //
  printf("\n Welcome to the PAMELA YodaProfiler, version %s \n\n",version);
  try{
    //
    //-------------------------------------------------------------------------------------------
    // Create pamDB object and open SQL connection
    //-------------------------------------------------------------------------------------------
    if ( beverbose ) printf(" 1 => Initialize and open SQL connection \n");
    pamDB = new PamelaDBOperations(host,user,password,filerawname,filerootname,boot,tsync,obt0,debug);
    pamDB->CheckConnection();
    //-------------------------------------------------------------------------------------------
    //
 
    if(pamDB->InsertRaw()){
      //-------------------------------------------------------------------------------------------
      //Insert a Raw file in GL_RAW
      //-------------------------------------------------------------------------------------------
      if ( beverbose ) printf(" 2 => Insert a RAW file in GL_RAW \n");
      WAR[0] = pamDB->insertPamelaRawFile(); 
      //-------------------------------------------------------------------------------------------
    };

    if(pamDB->InsertRoot()){
          
      if(!pamDB->InsertRaw())printf("=> RAW file not inserted --- the DB might not ( yet ) be filled correctly \n"); 
      pamDB->CheckFile();
      //-------------------------------------------------------------------------------------------   
      //Update a single GL_RAW record with its BOOT_NUMBER
      //-------------------------------------------------------------------------------------------
      if ( beverbose ) printf(" 3 => Update a single GL_RAW record with its BOOT_NUMBER \n");
      WAR[3] = pamDB->assignBOOT_NUMBER();
      //    if ( WAR[3] ) pamDB->SetNOBOOT(true);
      if ( WAR[3] && WAR[3] != 1 ) throw -9;
      //-------------------------------------------------------------------------------------------
      //
      //-------------------------------------------------------------------------------------------
      //Insert an entry in GL_TIMESYNC
      //-------------------------------------------------------------------------------------------
      if ( beverbose ) printf(" 4 => Insert an entry in GL_TIMESYNC \n");
      WAR[1] = pamDB->insertPamelaGL_TIMESYNC(); 
      //-------------------------------------------------------------------------------------------
      //
      //-------------------------------------------------------------------------------------------
      //Insert unpack ROOT file in GL_ROOT  
      //-------------------------------------------------------------------------------------------
      if ( beverbose ) printf(" 5 => Insert unpack ROOT file in GL_ROOT \n");
      WAR[2] = pamDB->insertPamelaRootFile();
      //-------------------------------------------------------------------------------------------
      //
      //-------------------------------------------------------------------------------------------      
      //Insert in GL_RUN runs information records relative to a single unpack
      //-------------------------------------------------------------------------------------------
      if ( beverbose ) printf(" 6 => Scan physics and store runs in the GL_RUN table\n");
      WAR[4] = pamDB->insertPamelaRUN();
      //-------------------------------------------------------------------------------------------    
        
      //-------------------------------------------------------------------------------------------
      //Insert in GL_CALO_CALIB calibration information records relative to a single unpack
      //-------------------------------------------------------------------------------------------
      if ( beverbose ) printf(" 7 => Insert calorimeter calibrations in the GL_CALO_CALIB table\n");
      WAR[5] = pamDB->insertCALO_CALIB();
      //-------------------------------------------------------------------------------------------    
        
      //-------------------------------------------------------------------------------------------
      //Insert in GL_TRK_CALIB calibration information records relative to a single unpack
      //-------------------------------------------------------------------------------------------
      if ( beverbose ) printf(" 8 => Insert tracker calibrations in the GL_TRK_CALIB table\n");
      WAR[6] = pamDB->insertTRK_CALIB();
      //-------------------------------------------------------------------------------------------    
        
      //-------------------------------------------------------------------------------------------
      //Insert in GL_S4_CALIB calibration information records relative to a single unpack
      //-------------------------------------------------------------------------------------------
      if ( beverbose ) printf(" 9 => Insert S4 calibrations in the GL_S4_CALIB table\n");
      WAR[7] = pamDB->insertS4_CALIB();
      //-------------------------------------------------------------------------------------------    
    };
    //
    pamDB->CheckValidate(olderthan);
    //
    if(pamDB->Validate()){  
      //-------------------------------------------------------------------------------------------
      //Clean the GL_RUN_FRAGMENTS
      //-------------------------------------------------------------------------------------------
      if ( beverbose ) printf(" 10 => Clean the GL_RUN_FRAGMENTS table (earlier than %s) \n",pamDB->GetCleanTime() );
      WAR[8] = pamDB->CleanGL_RUN_FRAGMENTS();
      //-------------------------------------------------------------------------------------------    
        
      //-------------------------------------------------------------------------------------------
      //Validate runs
      //-------------------------------------------------------------------------------------------
      if ( beverbose ) printf(" 11 => Validate runs (earlier than %s)\n",pamDB->GetCleanTime());
      WAR[9] = pamDB->ValidateRuns();
      //-------------------------------------------------------------------------------------------    
    };
        
  } catch (Int_t exc) {
    signal = exc;
    switch(exc){
    case -1: message += " DB connection failure"; break;
    case -2: message += " Connection failure"; break;
    case -3: message += " Cannot determine the timesync, use the -tsync and -obt0 options to override"; break;
    case -4: message += " Error querying DB"; break;
    case -5: message += " Inconsistent OBT/pkt_num"; break;
    case -6: message += " The file is not in the database"; break;
    case -8: message += " Event file is empty"; break;
    case -9: message += " No VarDump no BOOT number, use the -boot option to override"; break;
    case -10: message += " No results from DB"; break;
    case -11: message += " Raw file not found"; break;
    case -12: message += " Cannot open Level0 file"; break;
    case -13: message += " No consistent OBT/PKT_NUM information"; break;
    case -14: message += " Not supported yet: run with no events, no runtrailer, no runheader"; break;
    case -15: message += " Not supported yet: run with no runheader at the beginning/end of file not recognized as run fragment"; break;
    case -16: message += " No Physics tree in Level0 file"; break;
    case -17: message += " No RunHeader tree in Level0 file"; break;
    case -18: message += " No RunTrailer tree in Level0 file"; break;
    case -19: message += " No Mcmd tree in Level0 file"; break;
    case -20: message += " No VarDump tree in Level0 file"; break;
    case -21: message += " No CalibCalPed tree in Level0 file"; break;
    case -22: message += " No CalibTrk1 tree in Level0 file"; break;
    case -23: message += " No CalibTrk2 tree in Level0 file"; break;
    case -24: message += " No CalibS4 tree in Level0 file"; break;
    case -25: message += " Cannot find the run just inserted"; break;
    case -26: message += " Raw file not found looking for VarDump"; break;
    default: message += " Unidentified error"; break;
    };
    printf("\n");
    printf(" ERROR (%i) %s \n",exc,message.Data());
    printf("\n");
  }
  //
  // warnings handlers
  //
  Bool_t printwarning = false;
  message="";
  for (UInt_t j=0; j<sizeofwar; j++){
    if ( WAR[j] ){
      printwarning = true;
      //
      if ( j == 0 ){ // insertPamelaRaw warnings
        for (UInt_t bit=0; bit<32; bit++){
          if ( WAR[j] & (1 << bit) ){
            if ( bit == 0 ) message += "=> RAW file already inserted\n";
            else message += "=> Unidentified insertPamelaRaw warning\n";
          };
        };
      };
      //
      if ( j == 1 ){ // insertTimeSync warnings
        for (UInt_t bit=0; bit<32; bit++){
          if ( WAR[j] & (1 << bit) ){
            if ( bit == 0 ) message += "=> TIMESYNC already inserted\n";
            else if ( bit == 1 ) message += "=> No mcmd timesync in the file\n";
            else if ( bit == 2 ) message += "=> No runheaders in the file\n";
            else if ( bit == 3 ) message += "=> No runtrailers in the file\n";
            else if ( bit == 4 ) message += "=> No mcmd inclination in the file\n";
            else  message += "=> Unidentified insertTimeSync warning\n";
          };
        };
      };
      //
      if ( j == 2 ){ // insertPamelaRoot warnings
        for (UInt_t bit=0; bit<32; bit++){
          if ( WAR[j] & (1 << bit) ){
            if ( bit == 0 ) message += "=> ROOT file already inserted\n";
            else message += "=> Unidentified insertPamelaRoot warning\n";
          };
        };
      };
      //
      if ( j == 3 ){ // assignBOOTnumber warnings
        for (UInt_t bit=0; bit<32; bit++){
          if ( WAR[j] & (1 << bit) ){
            if ( bit == 0 ) message += "=> BOOT number already inserted\n";//
            else if ( bit == 1 ) message += "=> VarDump event tree is empty, use the -boot option to override\n";//
            else if ( bit == 2 ) message += "=> No BOOT number in VarDump(!), use the -boot option to override\n";//
            else if ( bit == 4 ) message += "=> The file is not in the database looking for VarDump, use the -boot option to override\n";//
            else message += "=> Unidentified assignBOOTnumber warning\n";
          };
        };
      };
      //
      if ( j == 4 ){ // insertPamelaRUN
        for (UInt_t bit=0; bit<32; bit++){
          if ( WAR[j] & (1 << bit) ){
            if      ( bit == 0 ) message += "=> Inconsistent PKT/OBT sequence\n";
            else if ( bit == 1 ) message += "=> No physics events in the file\n";
            else if ( bit == 2 ) message += "=> Less than 2 physics events in the file\n";
            else  message += "=> Unidentified insertPamelaRun warning\n";
          };
        };
      };
      //
      if ( j == 5 ){ // insertCALO_CALIB
        for (UInt_t bit=0; bit<32; bit++){
          if ( WAR[j] & (1 << bit) ){
            if      ( bit == 0 ) message += "=> No calorimeter calibrations in the file\n";
            else  message += "=> Unidentified insertCaloCalib warning\n";
          };
        };
      };
      //
      //
      if ( j == 6 ){ // insertTRACKER_CALIB
        for (UInt_t bit=0; bit<32; bit++){
          if ( WAR[j] & (1 << bit) ){
            if      ( bit == 0 ) message += "=> No tracker calibrations in the file\n";
            else  message += "=> Unidentified insertTrkCalib warning\n";
          };
        };
      };
      //
      //
      if ( j == 7 ){ // insertS4_CALIB
        for (UInt_t bit=0; bit<32; bit++){
          if ( WAR[j] & (1 << bit) ){
            if      ( bit == 0 ) message += "=> No s4 calibrations in the file\n";
            else  message += "=> Unidentified insertS4calib warning\n";
          };
        };
      };
      //
      //
      if ( j == 8 ){ // CleanGL_RUN_FRAGMENTS
        for (UInt_t bit=0; bit<32; bit++){
          if ( WAR[j] & (1 << bit) ){
            if      ( bit == 0 ) message += "=> Skip the GL_RUN_FRAGMENTS table cleaning\n";
            else  message += "=> Unidentified CleanGL_RUN_FRAGMENTS warning\n";
          };
        };
      };
      //
      if ( j == 9 ){ // ValidateRuns
        for (UInt_t bit=0; bit<32; bit++){
          if ( WAR[j] & (1 << bit) ){
            if      ( bit == 0 ) message += "=> Skip the run validation \n";
            else  message += "=> Unidentified ValidateRuns warning\n";
          };
        };
      };
    };
  };
  //
  if ( printwarning ){
    printf("\n");
    printf(" WARNING(s):\n%s\n",message.Data());
    printf("\n");
    if ( !signal ) signal = 1;
  };
  //
  //---------------------------------------------------------------------------------------
  // Close and exit
  //---------------------------------------------------------------------------------------
  if ( beverbose ) printf(" 12 => Free objects and close SQL connection \n");
  pamDB->Close();
  //
  printf("\n");
  printf(" Finished, exiting...\n");
  printf("\n");
  //
  // Close redirection if the case.
  //
  if ( !beverbose ) close(nul);
  //
  exit(signal);
  //
}
1	mocchiut	1.1	//
2			#include <iostream>
3			#include <sstream>
4			#include <errno.h>
5			//
6			#include <TSystem.h>
7			//
8			#include <PamelaDBOperations.h>
9			#include <YodaProfilerVerl2.h>
10			//
11			using namespace std;
12			//
13			// Usage subroutine
14			//
15			void usage(){
16			printf("\nUsage:\n");
17	mocchiut	1.2	printf("\n YodaProfiler [options] -rawFile raw_filename -yodaFile yoda_filename \n");
18			printf("\n -rawFile full path to the raw file\n");
19			printf("\n -yodaFile full path to the YODA file\n");
20			printf("\n Options can be: \n");
21	mocchiut	1.1	printf("\n --version print informations about compilation and exit\n");
22			printf("\n -h \| --help print this help and exit \n");
23	mocchiut	1.3	printf("\n -v \| --verbose be verbose [default]\n");
24	mocchiut	1.6	printf("\n -s \| --silent print nothing on STDOUT\n");
25	mocchiut	1.1	printf("\n -g \| --debug be very verbose [default: no]\n");
26			printf("\n -boot number CPU boot number [default = taken from VarDump]\n");
27			printf("\n -tsync number timesync (s) [default = taken from data]\n");
28			printf("\n -obt0 number obt at timesync (ms) [default = taken from data]\n");
29	mocchiut	1.2	printf("\n -clean number number in seconds after which the fragment table\n");
30	mocchiut	1.3	printf("\n can be cleaned and runs validated [default = -1 do not clean],\n");
31	mocchiut	1.2	printf("\n if 0 force cleaning immediatly, if negative do not clean\n");
32	mocchiut	1.3	printf("\n -host name for the host [default = $PAM_DBHOST or mysql://localhost/pamelaprod]\n");
33			printf("\n -user username for the DB [default = $PAM_DBUSER or \"anonymous\"] \n");
34			printf("\n -psw password for the DB [default = $PAM_DBPSW or \"\"]\n");
35	mocchiut	1.2	printf("\n The order of input files and options does not matter. \n");
36			printf("\nExample: \n");
37			printf("\n YodaProfiler -yodaFile /path/to/raw/files/000_000_00000_cln2.pam -rawFile /path/to/filesfromyoda/000_000_00000_cln2.root -v \n\n");
38	mocchiut	1.1	};
39			//
40			int main(int numinp, char *inps[]){
41			//
42			// Variables booking
43			//
44			Int_t signal = 0;
45			Int_t nul = 0;
46			UInt_t boot = 0;
47			UInt_t tsync = 0;
48			UInt_t obt0 = 0;
49	mocchiut	1.3	// Long64_t olderthan = 864000LL;
50			Long64_t olderthan = -1LL;
51	pam-fi	1.5
52	mocchiut	1.1	//
53			//
54	pam-fi	1.5	TString filerawname = "";
55			TString filerootname = "";
56	mocchiut	1.1	//
57	mocchiut	1.3	TString host = "mysql://localhost/pamelaprod";
58			TString user = "anonymous";
59			TString password = "";
60			//
61	mocchiut	1.6	const char *pamdbhost=gSystem->Getenv("PAM_DBHOST");
62	mocchiut	1.3	const char *pamdbuser=gSystem->Getenv("PAM_DBUSER");
63			const char *pamdbpsw=gSystem->Getenv("PAM_DBPSW");
64			if ( strcmp(pamdbhost,"") ) host = pamdbhost;
65			if ( strcmp(pamdbuser,"") ) user = pamdbuser;
66	mocchiut	1.6	if ( strcmp(pamdbpsw,"") ) password = pamdbpsw;
67	mocchiut	1.1	//
68			//
69	mocchiut	1.3	Bool_t beverbose = true;
70	mocchiut	1.1	Bool_t debug = false;
71			Int_t i = 0;
72			//
73			if ( numinp > 1 ){
74			while ( i < numinp ){
75			if ( !strcmp(inps[i],"--version") ){
76			YodaProfilerInfo(true);
77			exit(0);
78			};
79			if ( !strcmp(inps[i],"-h") \|\| !strcmp(inps[i],"--help") ){
80	pam-fi	1.5
81	mocchiut	1.1	usage();
82			exit(0);
83			};
84			if ( !strcmp(inps[i],"-rawFile") ) {
85			if ( numinp-1 < i+1 ){
86			usage();
87			exit(1);
88			};
89			filerawname = (TString)inps[i+1];
90			};
91			if ( !strcmp(inps[i],"-yodaFile") ) {
92			if ( numinp-1 < i+1 ){
93			usage();
94			exit(1);
95			};
96			filerootname = (TString)inps[i+1];
97			};
98			if ( !strcmp(inps[i],"-boot") ) {
99			if ( numinp-1 < i+1 ){
100			usage();
101			exit(1);
102			};
103			boot = atoi(inps[i+1]);
104			};
105			if ( !strcmp(inps[i],"-tsync") ) {
106			if ( numinp-1 < i+1 ){
107			usage();
108			exit(1);
109			};
110	mocchiut	1.2	tsync = (UInt_t)atoll(inps[i+1]);
111	mocchiut	1.1	};
112			if ( !strcmp(inps[i],"-obt0") ) {
113			if ( numinp-1 < i+1 ){
114			usage();
115			exit(1);
116			};
117	mocchiut	1.2	obt0 = (UInt_t)atoll(inps[i+1]);
118			};
119			if ( !strcmp(inps[i],"-clean") ) {
120			if ( numinp-1 < i+1 ){
121			usage();
122			exit(1);
123			};
124			olderthan = (Long64_t)atoll(inps[i+1]);
125	mocchiut	1.1	};
126			if ( !strcmp(inps[i],"-host") ) {
127			if ( numinp-1 < i+1 ){
128			usage();
129			exit(1);
130			};
131			host = (TString)inps[i+1];
132			};
133			if ( !strcmp(inps[i],"-user") ) {
134			if ( numinp-1 < i+1 ){
135			usage();
136			exit(1);
137			};
138			user = (TString)inps[i+1];
139			};
140			if ( !strcmp(inps[i],"-psw") ) {
141			if ( numinp-1 < i+1 ){
142			usage();
143			exit(1);
144			};
145			password = (TString)inps[i+1];
146			};
147			//
148			if ( !strcmp(inps[i],"-v") \|\| !strcmp(inps[i],"--verbose") ) beverbose = true;
149			//
150	mocchiut	1.3	if ( !strcmp(inps[i],"-s") \|\| !strcmp(inps[i],"--silent") ) beverbose = false;
151			//
152	mocchiut	1.1	if ( !strcmp(inps[i],"-g") \|\| !strcmp(inps[i],"--debug") ) debug = true;
153			//
154			i++;
155			};
156			} else {
157			//
158			// no input parameters exit with error, we need at least the run id.
159			//
160			cout << "\n ERROR: NO INPUT PARAMETERS \n";
161			usage();
162			exit(1);
163			};
164
165			//
166			// If not in verbose mode redirect to /dev/null the stdout and stderr
167			//
168			if ( !beverbose ){
169			nul = open("/dev/null", O_CREAT \| O_RDWR,S_IREAD \| S_IWRITE);
170			dup2(nul,1);
171			dup2(nul,2);
172			};
173			//
174			// Start:
175			//
176			TString message;
177			char *version = YodaProfilerInfo(false);
178			PamelaDBOperations *pamDB = 0;
179			UInt_t sizeofwar = 10;
180			UInt_t WAR[10];
181			memset(WAR, 0, 10*sizeof(UInt_t));
182			//
183	mocchiut	1.2	printf("\n Welcome to the PAMELA YodaProfiler, version %s \n\n",version);
184	mocchiut	1.1	try{
185			//
186			//-------------------------------------------------------------------------------------------
187			// Create pamDB object and open SQL connection
188			//-------------------------------------------------------------------------------------------
189	mocchiut	1.2	if ( beverbose ) printf(" 1 => Initialize and open SQL connection \n");
190	mocchiut	1.7	pamDB = new PamelaDBOperations(host,user,password,filerawname,filerootname,boot,tsync,obt0,debug);
191			pamDB->CheckConnection();
192			//-------------------------------------------------------------------------------------------
193	mocchiut	1.1	//
194	mocchiut	1.7
195			if(pamDB->InsertRaw()){
196			//-------------------------------------------------------------------------------------------
197			//Insert a Raw file in GL_RAW
198			//-------------------------------------------------------------------------------------------
199			if ( beverbose ) printf(" 2 => Insert a RAW file in GL_RAW \n");
200			WAR[0] = pamDB->insertPamelaRawFile();
201			//-------------------------------------------------------------------------------------------
202			};
203	mocchiut	1.1
204	mocchiut	1.7	if(pamDB->InsertRoot()){
205
206			if(!pamDB->InsertRaw())printf("=> RAW file not inserted --- the DB might not ( yet ) be filled correctly \n");
207			pamDB->CheckFile();
208			//-------------------------------------------------------------------------------------------
209			//Update a single GL_RAW record with its BOOT_NUMBER
210			//-------------------------------------------------------------------------------------------
211			if ( beverbose ) printf(" 3 => Update a single GL_RAW record with its BOOT_NUMBER \n");
212			WAR[3] = pamDB->assignBOOT_NUMBER();
213			// if ( WAR[3] ) pamDB->SetNOBOOT(true);
214			if ( WAR[3] && WAR[3] != 1 ) throw -9;
215			//-------------------------------------------------------------------------------------------
216			//
217			//-------------------------------------------------------------------------------------------
218			//Insert an entry in GL_TIMESYNC
219			//-------------------------------------------------------------------------------------------
220			if ( beverbose ) printf(" 4 => Insert an entry in GL_TIMESYNC \n");
221			WAR[1] = pamDB->insertPamelaGL_TIMESYNC();
222			//-------------------------------------------------------------------------------------------
223			//
224			//-------------------------------------------------------------------------------------------
225			//Insert unpack ROOT file in GL_ROOT
226			//-------------------------------------------------------------------------------------------
227			if ( beverbose ) printf(" 5 => Insert unpack ROOT file in GL_ROOT \n");
228			WAR[2] = pamDB->insertPamelaRootFile();
229			//-------------------------------------------------------------------------------------------
230			//
231			//-------------------------------------------------------------------------------------------
232			//Insert in GL_RUN runs information records relative to a single unpack
233			//-------------------------------------------------------------------------------------------
234			if ( beverbose ) printf(" 6 => Scan physics and store runs in the GL_RUN table\n");
235			WAR[4] = pamDB->insertPamelaRUN();
236			//-------------------------------------------------------------------------------------------
237	pam-fi	1.5
238	mocchiut	1.7	//-------------------------------------------------------------------------------------------
239			//Insert in GL_CALO_CALIB calibration information records relative to a single unpack
240			//-------------------------------------------------------------------------------------------
241			if ( beverbose ) printf(" 7 => Insert calorimeter calibrations in the GL_CALO_CALIB table\n");
242			WAR[5] = pamDB->insertCALO_CALIB();
243			//-------------------------------------------------------------------------------------------
244	pam-fi	1.5
245	mocchiut	1.7	//-------------------------------------------------------------------------------------------
246			//Insert in GL_TRK_CALIB calibration information records relative to a single unpack
247			//-------------------------------------------------------------------------------------------
248			if ( beverbose ) printf(" 8 => Insert tracker calibrations in the GL_TRK_CALIB table\n");
249			WAR[6] = pamDB->insertTRK_CALIB();
250			//-------------------------------------------------------------------------------------------
251	pam-fi	1.5
252	mocchiut	1.7	//-------------------------------------------------------------------------------------------
253			//Insert in GL_S4_CALIB calibration information records relative to a single unpack
254			//-------------------------------------------------------------------------------------------
255			if ( beverbose ) printf(" 9 => Insert S4 calibrations in the GL_S4_CALIB table\n");
256			WAR[7] = pamDB->insertS4_CALIB();
257			//-------------------------------------------------------------------------------------------
258			};
259			//
260			pamDB->CheckValidate(olderthan);
261			//
262			if(pamDB->Validate()){
263			//-------------------------------------------------------------------------------------------
264			//Clean the GL_RUN_FRAGMENTS
265			//-------------------------------------------------------------------------------------------
266	mocchiut	1.8	if ( beverbose ) printf(" 10 => Clean the GL_RUN_FRAGMENTS table (earlier than %s) \n",pamDB->GetCleanTime() );
267	mocchiut	1.7	WAR[8] = pamDB->CleanGL_RUN_FRAGMENTS();
268			//-------------------------------------------------------------------------------------------
269	pam-fi	1.5
270	mocchiut	1.7	//-------------------------------------------------------------------------------------------
271			//Validate runs
272			//-------------------------------------------------------------------------------------------
273	mocchiut	1.8	if ( beverbose ) printf(" 11 => Validate runs (earlier than %s)\n",pamDB->GetCleanTime());
274	mocchiut	1.7	WAR[9] = pamDB->ValidateRuns();
275			//-------------------------------------------------------------------------------------------
276			};
277	pam-fi	1.5
278	mocchiut	1.1	} catch (Int_t exc) {
279			signal = exc;
280			switch(exc){
281			case -1: message += " DB connection failure"; break;
282			case -2: message += " Connection failure"; break;
283			case -3: message += " Cannot determine the timesync, use the -tsync and -obt0 options to override"; break;
284			case -4: message += " Error querying DB"; break;
285			case -5: message += " Inconsistent OBT/pkt_num"; break;
286			case -6: message += " The file is not in the database"; break;
287			case -8: message += " Event file is empty"; break;
288			case -9: message += " No VarDump no BOOT number, use the -boot option to override"; break;
289			case -10: message += " No results from DB"; break;
290			case -11: message += " Raw file not found"; break;
291			case -12: message += " Cannot open Level0 file"; break;
292			case -13: message += " No consistent OBT/PKT_NUM information"; break;
293			case -14: message += " Not supported yet: run with no events, no runtrailer, no runheader"; break;
294			case -15: message += " Not supported yet: run with no runheader at the beginning/end of file not recognized as run fragment"; break;
295			case -16: message += " No Physics tree in Level0 file"; break;
296			case -17: message += " No RunHeader tree in Level0 file"; break;
297			case -18: message += " No RunTrailer tree in Level0 file"; break;
298			case -19: message += " No Mcmd tree in Level0 file"; break;
299			case -20: message += " No VarDump tree in Level0 file"; break;
300			case -21: message += " No CalibCalPed tree in Level0 file"; break;
301			case -22: message += " No CalibTrk1 tree in Level0 file"; break;
302			case -23: message += " No CalibTrk2 tree in Level0 file"; break;
303			case -24: message += " No CalibS4 tree in Level0 file"; break;
304	mocchiut	1.2	case -25: message += " Cannot find the run just inserted"; break;
305			case -26: message += " Raw file not found looking for VarDump"; break;
306	mocchiut	1.1	default: message += " Unidentified error"; break;
307			};
308			printf("\n");
309			printf(" ERROR (%i) %s \n",exc,message.Data());
310			printf("\n");
311			}
312			//
313			// warnings handlers
314			//
315			Bool_t printwarning = false;
316			message="";
317			for (UInt_t j=0; j<sizeofwar; j++){
318			if ( WAR[j] ){
319			printwarning = true;
320			//
321			if ( j == 0 ){ // insertPamelaRaw warnings
322			for (UInt_t bit=0; bit<32; bit++){
323			if ( WAR[j] & (1 << bit) ){
324			if ( bit == 0 ) message += "=> RAW file already inserted\n";
325	mocchiut	1.2	else message += "=> Unidentified insertPamelaRaw warning\n";
326	mocchiut	1.1	};
327			};
328			};
329			//
330			if ( j == 1 ){ // insertTimeSync warnings
331			for (UInt_t bit=0; bit<32; bit++){
332			if ( WAR[j] & (1 << bit) ){
333			if ( bit == 0 ) message += "=> TIMESYNC already inserted\n";
334	mocchiut	1.2	else if ( bit == 1 ) message += "=> No mcmd timesync in the file\n";
335			else if ( bit == 2 ) message += "=> No runheaders in the file\n";
336			else if ( bit == 3 ) message += "=> No runtrailers in the file\n";
337			else if ( bit == 4 ) message += "=> No mcmd inclination in the file\n";
338			else message += "=> Unidentified insertTimeSync warning\n";
339	mocchiut	1.1	};
340			};
341			};
342			//
343			if ( j == 2 ){ // insertPamelaRoot warnings
344			for (UInt_t bit=0; bit<32; bit++){
345			if ( WAR[j] & (1 << bit) ){
346			if ( bit == 0 ) message += "=> ROOT file already inserted\n";
347	mocchiut	1.2	else message += "=> Unidentified insertPamelaRoot warning\n";
348	mocchiut	1.1	};
349			};
350			};
351			//
352			if ( j == 3 ){ // assignBOOTnumber warnings
353			for (UInt_t bit=0; bit<32; bit++){
354			if ( WAR[j] & (1 << bit) ){
355	mocchiut	1.2	if ( bit == 0 ) message += "=> BOOT number already inserted\n";//
356			else if ( bit == 1 ) message += "=> VarDump event tree is empty, use the -boot option to override\n";//
357			else if ( bit == 2 ) message += "=> No BOOT number in VarDump(!), use the -boot option to override\n";//
358			else if ( bit == 4 ) message += "=> The file is not in the database looking for VarDump, use the -boot option to override\n";//
359			else message += "=> Unidentified assignBOOTnumber warning\n";
360	mocchiut	1.1	};
361			};
362			};
363			//
364			if ( j == 4 ){ // insertPamelaRUN
365			for (UInt_t bit=0; bit<32; bit++){
366			if ( WAR[j] & (1 << bit) ){
367	mocchiut	1.2	if ( bit == 0 ) message += "=> Inconsistent PKT/OBT sequence\n";
368			else if ( bit == 1 ) message += "=> No physics events in the file\n";
369			else if ( bit == 2 ) message += "=> Less than 2 physics events in the file\n";
370			else message += "=> Unidentified insertPamelaRun warning\n";
371	mocchiut	1.1	};
372			};
373			};
374			//
375			if ( j == 5 ){ // insertCALO_CALIB
376			for (UInt_t bit=0; bit<32; bit++){
377			if ( WAR[j] & (1 << bit) ){
378	mocchiut	1.2	if ( bit == 0 ) message += "=> No calorimeter calibrations in the file\n";
379			else message += "=> Unidentified insertCaloCalib warning\n";
380	mocchiut	1.1	};
381			};
382			};
383			//
384			//
385			if ( j == 6 ){ // insertTRACKER_CALIB
386			for (UInt_t bit=0; bit<32; bit++){
387			if ( WAR[j] & (1 << bit) ){
388	mocchiut	1.2	if ( bit == 0 ) message += "=> No tracker calibrations in the file\n";
389			else message += "=> Unidentified insertTrkCalib warning\n";
390	mocchiut	1.1	};
391			};
392			};
393			//
394			//
395			if ( j == 7 ){ // insertS4_CALIB
396			for (UInt_t bit=0; bit<32; bit++){
397			if ( WAR[j] & (1 << bit) ){
398	mocchiut	1.2	if ( bit == 0 ) message += "=> No s4 calibrations in the file\n";
399			else message += "=> Unidentified insertS4calib warning\n";
400			};
401			};
402			};
403			//
404			//
405			if ( j == 8 ){ // CleanGL_RUN_FRAGMENTS
406			for (UInt_t bit=0; bit<32; bit++){
407			if ( WAR[j] & (1 << bit) ){
408			if ( bit == 0 ) message += "=> Skip the GL_RUN_FRAGMENTS table cleaning\n";
409			else message += "=> Unidentified CleanGL_RUN_FRAGMENTS warning\n";
410	mocchiut	1.1	};
411			};
412			};
413			//
414	mocchiut	1.2	if ( j == 9 ){ // ValidateRuns
415			for (UInt_t bit=0; bit<32; bit++){
416			if ( WAR[j] & (1 << bit) ){
417			if ( bit == 0 ) message += "=> Skip the run validation \n";
418			else message += "=> Unidentified ValidateRuns warning\n";
419			};
420			};
421			};
422	mocchiut	1.1	};
423			};
424			//
425			if ( printwarning ){
426			printf("\n");
427			printf(" WARNING(s):\n%s\n",message.Data());
428			printf("\n");
429			if ( !signal ) signal = 1;
430			};
431			//
432			//---------------------------------------------------------------------------------------
433			// Close and exit
434			//---------------------------------------------------------------------------------------
435	mocchiut	1.2	if ( beverbose ) printf(" 12 => Free objects and close SQL connection \n");
436	mocchiut	1.1	pamDB->Close();
437			//
438			printf("\n");
439			printf(" Finished, exiting...\n");
440			printf("\n");
441			//
442			// Close redirection if the case.
443			//
444			if ( !beverbose ) close(nul);
445			//
446			exit(signal);
447			//
448			}