00001
00002
00003
00004
00005
00006
00007
00008 #include "StBemcTablesWriter.h"
00009
00010 #include "TSystem.h"
00011 #include "TFile.h"
00012 #include "TDatime.h"
00013
00014 #include "TUnixTime.h"
00015 #include "StDaqLib/EMC/StEmcDecoder.h"
00016 #include "StMessMgr.h"
00017
00018 #include "StEmcRawMaker/defines.h"
00019
00020 ClassImp(StBemcTablesWriter)
00021
00022 StBemcTablesWriter::StBemcTablesWriter() : StBemcTables() {
00023 mDbTables["bemcPed"] = NULL;
00024 mDbTables["bprsPed"] = NULL;
00025 mDbTables["bsmdePed"] = NULL;
00026 mDbTables["bsmdpPed"] = NULL;
00027
00028 mDbTables["bemcStatus"] = NULL;
00029 mDbTables["bprsStatus"] = NULL;
00030 mDbTables["bsmdeStatus"] = NULL;
00031 mDbTables["bsmdpStatus"] = NULL;
00032
00033 mDbTables["bemcCalib"] = NULL;
00034 mDbTables["bprsCalib"] = NULL;
00035 mDbTables["bsmdeCalib"] = NULL;
00036 mDbTables["bsmdpCalib"] = NULL;
00037
00038 mDbTables["bemcGain"] = NULL;
00039 mDbTables["bprsGain"] = NULL;
00040 mDbTables["bsmdeGain"] = NULL;
00041 mDbTables["bsmdpGain"] = NULL;
00042
00043 mDbTables["bemcTriggerPed"] = NULL;
00044 mDbTables["bemcTriggerStatus"]= NULL;
00045 mDbTables["bemcTriggerLUT"] = NULL;
00046
00047 mDbHandler = new StEmcDbHandler();
00048 }
00049
00050 StBemcTablesWriter::~StBemcTablesWriter() {
00051 for(map<string, StDbTable*>::iterator it=mDbTables.begin(); it!=mDbTables.end(); it++) {
00052 if (it->second) delete it->second;
00053 }
00054 mDbTables.clear();
00055
00056 if(mDbHandler) delete mDbHandler;
00057 }
00058
00059 void StBemcTablesWriter::loadTables(const char * sqlTime, const char * flavor) {
00060 TDatime dt(sqlTime);
00061 TUnixTime ut(dt, 1);
00062
00063 if (mDecoder) mDecoder->SetDateTime(dt.GetDate(), dt.GetTime());
00064
00065
00066
00067 if(dt.GetDate() >= 20060101) mBtowMapFix = kFALSE;
00068
00069 for(map<string, StDbTable*>::iterator it = mDbTables.begin(); it!=mDbTables.end(); it++) {
00070 string tableName = it->first;
00071 StDbTable * t = it->second;
00072 if( (!t) || (ut() < t->getBeginTime()) || (ut() >= t->getEndTime()) ) {
00073 if (mDbHandler) {
00074 mDbHandler->setTimeStamp(sqlTime);
00075 mDbHandler->setFlavor(flavor);
00076 mDbHandler->setTableName((char*)tableName.c_str());
00077 it->second = mDbHandler->getDbTable();
00078 }
00079 t = it->second;
00080
00081 if (t) {
00082 string beginTime = StEmcDbHandler::timeToSqlTime(t->getBeginDateTime());
00083 string endTime = StEmcDbHandler::timeToSqlTime(t->getEndDateTime());
00084 map<string, pair<string, string> >::iterator iter = mValidRanges.find(tableName);
00085 if(iter == mValidRanges.end()) {
00086 mValidRanges[tableName] = make_pair(beginTime, endTime);
00087 LOG_INFO << Form("loaded a new %20s table with beginTime %s and endTime %s", tableName.c_str(), beginTime.c_str(), endTime.c_str()) << endm;
00088 } else if( beginTime != (iter->second).first ) {
00089 (iter->second).first = beginTime;
00090 (iter->second).second = endTime;
00091 LOG_INFO << Form("loaded a new %20s table with beginTime %s and endTime %s", tableName.c_str(), beginTime.c_str(), endTime.c_str()) << endm;
00092 }
00093 }
00094 }
00095 }
00096
00097 if(mBtowP) delete mBtowP;
00098 mBtowP = mDbTables["bemcPed"] ? (emcPed_st*) mDbTables["bemcPed"]->GetTableCpy() : 0;
00099
00100 if(mBprsP) delete mBprsP;
00101 mBprsP = mDbTables["bprsPed"] ? (emcPed_st*) mDbTables["bprsPed"]->GetTableCpy() : 0;
00102
00103 if(mSmdeP) delete mSmdeP;
00104 mSmdeP = mDbTables["bsmdePed"] ? (smdPed_st*) mDbTables["bsmdePed"]->GetTableCpy() : 0;
00105
00106 if(mSmdpP) delete mSmdpP;
00107 mSmdpP = mDbTables["bsmdpPed"] ? (smdPed_st*) mDbTables["bsmdpPed"]->GetTableCpy() : 0;
00108
00109
00110 if(mBtowS) delete mBtowS;
00111 mBtowS = mDbTables["bemcStatus"] ? (emcStatus_st*) mDbTables["bemcStatus"]->GetTableCpy() : 0;
00112
00113 if(mBprsS) delete mBprsS;
00114 mBprsS = mDbTables["bprsStatus"] ? (emcStatus_st*) mDbTables["bprsStatus"]->GetTableCpy() : 0;
00115
00116 if(mSmdeS) delete mSmdeS;
00117 mSmdeS = mDbTables["bsmdeStatus"] ? (smdStatus_st*) mDbTables["bsmdeStatus"]->GetTableCpy() : 0;
00118
00119 if(mSmdpS) delete mSmdpS;
00120 mSmdpS = mDbTables["bsmdpStatus"] ? (smdStatus_st*) mDbTables["bsmdpStatus"]->GetTableCpy() : 0;
00121
00122
00123 if(mBtowC) delete mBtowC;
00124 mBtowC = mDbTables["bemcCalib"] ? (emcCalib_st*) mDbTables["bemcCalib"]->GetTableCpy() : 0;
00125
00126 if(mBprsC) delete mBprsC;
00127 mBprsC = mDbTables["bprsCalib"] ? (emcCalib_st*) mDbTables["bprsCalib"]->GetTableCpy() : 0;
00128
00129 if(mSmdeC) delete mSmdeC;
00130 mSmdeC = mDbTables["bsmdeCalib"] ? (smdCalib_st*) mDbTables["bsmdeCalib"]->GetTableCpy() : 0;
00131
00132 if(mSmdpC) delete mSmdpC;
00133 mSmdpC = mDbTables["bsmdpCalib"] ? (smdCalib_st*) mDbTables["bsmdpCalib"]->GetTableCpy() : 0;
00134
00135
00136 if(mBtowG) delete mBtowG;
00137 mBtowG = mDbTables["bemcGain"] ? (emcGain_st*) mDbTables["bemcGain"]->GetTableCpy() : 0;
00138
00139 if(mBprsG) delete mBprsG;
00140 mBprsG = mDbTables["bprsGain"] ? (emcGain_st*) mDbTables["bprsGain"]->GetTableCpy() : 0;
00141
00142 if(mSmdeG) delete mSmdeG;
00143 mSmdeG = mDbTables["bsmdeGain"] ? (smdGain_st*) mDbTables["bsmdeGain"]->GetTableCpy() : 0;
00144
00145 if(mSmdpG) delete mSmdpG;
00146 mSmdpG = mDbTables["bsmdpGain"] ? (smdGain_st*) mDbTables["bsmdpGain"]->GetTableCpy() : 0;
00147
00148
00149 if(mTrigS) delete mTrigS;
00150 mTrigS = mDbTables["bemcTriggerStatus"] ? (emcTriggerStatus_st*) mDbTables["bemcTriggerStatus"]->GetTableCpy() : 0;
00151
00152 if(mTrigP) delete mTrigP;
00153 mTrigP = mDbTables["bemcTriggerPed"] ? (emcTriggerPed_st*) mDbTables["bemcTriggerPed"]->GetTableCpy() : 0;
00154
00155 if(mTrigL) delete mTrigL;
00156 mTrigL = mDbTables["bemcTriggerLUT"] ? (emcTriggerLUT_st*) mDbTables["bemcTriggerLUT"]->GetTableCpy() : 0;
00157 }
00158
00159 void StBemcTablesWriter::setCalib(int det, int softId, int power, float val) {
00160 switch(det) {
00161 case BTOW:
00162 if (mBtowC) mBtowC->AdcToE[softId-1][power] = val;
00163 break;
00164
00165 case BPRS:
00166 if (mBprsC) mBprsC->AdcToE[softId-1][power] = val;
00167 break;
00168
00169 case BSMDE:
00170 if (mSmdeC) mSmdeC->AdcToE[softId-1][power] = val;
00171 break;
00172
00173 case BSMDP:
00174 if (mSmdpC) mSmdpC->AdcToE[softId-1][power] = val;
00175 break;
00176 }
00177 }
00178
00179 void StBemcTablesWriter::setPedestal(int det, int softId, int cap, float val) {
00180 short packedValue = static_cast<short>(val*100.0);
00181 switch(det) {
00182 case BTOW:
00183 if (mBtowP) mBtowP->AdcPedestal[softId-1] = packedValue;
00184 break;
00185
00186 case BPRS:
00187 if (mBprsP) mBprsP->AdcPedestal[softId-1] = packedValue;
00188 break;
00189
00190 case BSMDE:
00191 if (mSmdeP) mSmdeP->AdcPedestal[softId-1][cap] = packedValue;
00192 break;
00193
00194 case BSMDP:
00195 if (mSmdpP) mSmdpP->AdcPedestal[softId-1][cap] = packedValue;
00196 break;
00197 }
00198 }
00199
00200 void StBemcTablesWriter::setPedestalRMS(int det, int softId, int cap, float val) {
00201 short packedValue = static_cast<short>(val*100.0);
00202 switch(det) {
00203 case BTOW:
00204 if (mBtowP) mBtowP->AdcPedestalRMS[softId-1] = packedValue;
00205 break;
00206
00207 case BPRS:
00208 if (mBprsP) mBprsP->AdcPedestalRMS[softId-1] = packedValue;
00209 break;
00210
00211 case BSMDE:
00212 if (mSmdeP) mSmdeP->AdcPedestalRMS[softId-1][cap] = packedValue;
00213 break;
00214
00215 case BSMDP:
00216 if (mSmdpP) mSmdpP->AdcPedestalRMS[softId-1][cap] = packedValue;
00217 break;
00218 }
00219 }
00220
00221 void StBemcTablesWriter::setGain(int det, int softId, float val) {
00222 switch(det) {
00223 case BTOW:
00224 if (mBtowG) mBtowG->Gain[softId-1] = val;
00225 break;
00226
00227 case BPRS:
00228 if (mBprsG) mBprsG->Gain[softId-1] = val;
00229 break;
00230
00231 case BSMDE:
00232 if (mSmdeG) mSmdeG->Gain[softId-1] = val;
00233 break;
00234
00235 case BSMDP:
00236 if (mSmdpG) mSmdpG->Gain[softId-1] = val;
00237 break;
00238 }
00239 }
00240
00241 void StBemcTablesWriter::setStatus(int det, int softId, unsigned short val) {
00242 if(val > 255) {
00243 cout << "status must be between 0 and 255 -- you supplied " << val << endl;
00244 return;
00245 }
00246
00247 switch(det) {
00248 case BTOW:
00249 if (mBtowS) mBtowS->Status[softId-1] = val;
00250 break;
00251
00252 case BPRS:
00253 if (mBprsS) mBprsS->Status[softId-1] = val;
00254 break;
00255
00256 case BSMDE:
00257 if (mSmdeS) mSmdeS->Status[softId-1] = val;
00258 break;
00259
00260 case BSMDP:
00261 if (mSmdpS) mSmdpS->Status[softId-1] = val;
00262 break;
00263 }
00264 }
00265
00266 void StBemcTablesWriter::setCalibStatus(int det, int softId, unsigned short val) {
00267 if(val > 255) {
00268 cout << "status must be between 0 and 255 -- you supplied " << val << endl;
00269 return;
00270 }
00271
00272 switch(det) {
00273 case BTOW:
00274 if (mBtowC) mBtowC->Status[softId-1] = val;
00275 break;
00276
00277 case BPRS:
00278 if (mBprsC) mBprsC->Status[softId-1] = val;
00279 break;
00280
00281 case BSMDE:
00282 if (mSmdeC) mSmdeC->Status[softId-1] = val;
00283 break;
00284
00285 case BSMDP:
00286 if (mSmdpC) mSmdpC->Status[softId-1] = val;
00287 break;
00288 }
00289 }
00290
00291 void StBemcTablesWriter::setPedestalStatus(int det, int softId, unsigned short val) {
00292 if(val > 255) {
00293 cout << "status must be between 0 and 255 -- you supplied " << val << endl;
00294 return;
00295 }
00296
00297 switch(det) {
00298 case BTOW:
00299 if (mBtowP) mBtowP->Status[softId-1] = val;
00300 break;
00301
00302 case BPRS:
00303 if (mBprsP) mBprsP->Status[softId-1] = val;
00304 break;
00305
00306 case BSMDE:
00307 if (mSmdeP) mSmdeP->Status[softId-1] = val;
00308 break;
00309
00310 case BSMDP:
00311 if (mSmdpP) mSmdpP->Status[softId-1] = val;
00312 break;
00313 }
00314 }
00315
00316 void StBemcTablesWriter::setGainStatus(int det, int softId, unsigned short val) {
00317 if(val > 255) {
00318 cout << "status must be between 0 and 255 -- you supplied " << val << endl;
00319 return;
00320 }
00321
00322 switch(det) {
00323 case BTOW:
00324 if (mBtowG) mBtowG->Status[softId-1] = val;
00325 break;
00326
00327 case BPRS:
00328 if (mBprsG) mBprsG->Status[softId-1] = val;
00329 break;
00330
00331 case BSMDE:
00332 if (mSmdeG) mSmdeG->Status[softId-1] = val;
00333 break;
00334
00335 case BSMDP:
00336 if (mSmdpG) mSmdpG->Status[softId-1] = val;
00337 break;
00338 }
00339 }
00340
00341 void StBemcTablesWriter::writeToDb(const char * tableName, const char * timeStamp, const char * flavor) {
00342 if (!mDbHandler) return;
00343
00344 mDbHandler->setTableName(tableName);
00345 mDbHandler->setTimeStamp(timeStamp);
00346 mDbHandler->setFlavor(flavor);
00347
00348 if(!strcmp(tableName, "bemcCalib")) { mDbHandler->writeToDb(reinterpret_cast<char*>(mBtowC)); return; }
00349 if(!strcmp(tableName, "bprsCalib")) { mDbHandler->writeToDb(reinterpret_cast<char*>(mBprsC)); return; }
00350 if(!strcmp(tableName, "bsmdeCalib")) { mDbHandler->writeToDb(reinterpret_cast<char*>(mSmdeC)); return; }
00351 if(!strcmp(tableName, "bsmdpCalib")) { mDbHandler->writeToDb(reinterpret_cast<char*>(mSmdpC)); return; }
00352
00353 if(!strcmp(tableName, "bemcPed")) { mDbHandler->writeToDb(reinterpret_cast<char*>(mBtowP)); return; }
00354 if(!strcmp(tableName, "bprsPed")) { mDbHandler->writeToDb(reinterpret_cast<char*>(mBprsP)); return; }
00355 if(!strcmp(tableName, "bsmdePed")) { mDbHandler->writeToDb(reinterpret_cast<char*>(mSmdeP)); return; }
00356 if(!strcmp(tableName, "bsmdpPed")) { mDbHandler->writeToDb(reinterpret_cast<char*>(mSmdpP)); return; }
00357
00358 if(!strcmp(tableName, "bemcGain")) { mDbHandler->writeToDb(reinterpret_cast<char*>(mBtowG)); return; }
00359 if(!strcmp(tableName, "bprsGain")) { mDbHandler->writeToDb(reinterpret_cast<char*>(mBprsG)); return; }
00360 if(!strcmp(tableName, "bsmdeGain")) { mDbHandler->writeToDb(reinterpret_cast<char*>(mSmdeG)); return; }
00361 if(!strcmp(tableName, "bsmdpGain")) { mDbHandler->writeToDb(reinterpret_cast<char*>(mSmdpG)); return; }
00362
00363 if(!strcmp(tableName, "bemcStatus")) { mDbHandler->writeToDb(reinterpret_cast<char*>(mBtowS)); return; }
00364 if(!strcmp(tableName, "bprsStatus")) { mDbHandler->writeToDb(reinterpret_cast<char*>(mBprsS)); return; }
00365 if(!strcmp(tableName, "bsmdeStatus")) { mDbHandler->writeToDb(reinterpret_cast<char*>(mSmdeS)); return; }
00366 if(!strcmp(tableName, "bsmdpStatus")) { mDbHandler->writeToDb(reinterpret_cast<char*>(mSmdpS)); return; }
00367
00368 if(!strcmp(tableName, "bemcTriggerPed")) { mDbHandler->writeToDb(reinterpret_cast<char*>(mTrigP)); return; }
00369 if(!strcmp(tableName, "bemcTriggerStatus")) { mDbHandler->writeToDb(reinterpret_cast<char*>(mTrigS)); return; }
00370 if(!strcmp(tableName, "bemcTriggerLUT")) { mDbHandler->writeToDb(reinterpret_cast<char*>(mTrigL)); return; }
00371
00372
00373
00374 LOG_ERROR << "Can't upload a table with name = " << tableName << endm;
00375 }
00376
00377 void StBemcTablesWriter::writeToFile(const char * fileName) {
00378 TFile *f = new TFile(fileName,"recreate");
00379 if (f) {
00380 string baseName = gSystem->BaseName(fileName);
00381
00382 if(baseName.find("bemcCalib") == 0) {
00383 St_emcCalib* table = new St_emcCalib("bemcCalib",1);
00384 if (table && mBtowC) {
00385 table->AddAt(static_cast<void*>(mBtowC),0);
00386 table->Write();
00387 }
00388 }
00389 else if(baseName.find("bprsCalib") == 0) {
00390 St_emcCalib* table = new St_emcCalib("bprsCalib",1);
00391 if (table && mBprsC) {
00392 table->AddAt(static_cast<void*>(mBprsC),0);
00393 table->Write();
00394 }
00395 }
00396 else if(baseName.find("bsmdeCalib") == 0) {
00397 St_smdCalib* table = new St_smdCalib("bsmdeCalib",1);
00398 if (table && mSmdeC) {
00399 table->AddAt(static_cast<void*>(mSmdeC),0);
00400 table->Write();
00401 }
00402 }
00403 else if(baseName.find("bsmdpCalib") == 0) {
00404 St_smdCalib* table = new St_smdCalib("bsmdpCalib",1);
00405 if (table && mSmdpC) {
00406 table->AddAt(static_cast<void*>(mSmdpC),0);
00407 table->Write();
00408 }
00409 }
00410
00411 else if(baseName.find("bemcPed") == 0) {
00412 St_emcPed* table = new St_emcPed("bemcPed",1);
00413 if (table && mBtowP) {
00414 table->AddAt(static_cast<void*>(mBtowP),0);
00415 table->Write();
00416 }
00417 }
00418 else if(baseName.find("bprsPed") == 0) {
00419 St_emcPed* table = new St_emcPed("bprsPed",1);
00420 if (table && mBprsP) {
00421 table->AddAt(static_cast<void*>(mBprsP),0);
00422 table->Write();
00423 }
00424 }
00425 else if(baseName.find("bsmdePed") == 0) {
00426 St_smdPed* table = new St_smdPed("bsmdePed",1);
00427 if (table && mSmdeP) {
00428 table->AddAt(static_cast<void*>(mSmdeP),0);
00429 table->Write();
00430 }
00431 }
00432 else if(baseName.find("bsmdpPed") == 0) {
00433 St_smdPed* table = new St_smdPed("bsmdpPed",1);
00434 if (table && mSmdpP) {
00435 table->AddAt(static_cast<void*>(mSmdpP),0);
00436 table->Write();
00437 }
00438 }
00439
00440 else if(baseName.find("bemcGain") == 0) {
00441 St_emcGain* table = new St_emcGain("bemcGain",1);
00442 if (table && mBtowG) {
00443 table->AddAt(static_cast<void*>(mBtowG),0);
00444 table->Write();
00445 }
00446 }
00447 else if(baseName.find("bprsGain") == 0) {
00448 St_emcGain* table = new St_emcGain("bprsGain",1);
00449 if (table && mBprsG) {
00450 table->AddAt(static_cast<void*>(mBprsG),0);
00451 table->Write();
00452 }
00453 }
00454 else if(baseName.find("bsmdeGain") == 0) {
00455 St_smdGain* table = new St_smdGain("bsmdeGain",1);
00456 if (table && mSmdeG) {
00457 table->AddAt(static_cast<void*>(mSmdeG),0);
00458 table->Write();
00459 }
00460 }
00461 else if(baseName.find("bsmdpGain") == 0) {
00462 St_smdGain* table = new St_smdGain("bsmdpGain",1);
00463 if (table && mSmdpG) {
00464 table->AddAt(static_cast<void*>(mSmdpG),0);
00465 table->Write();
00466 }
00467 }
00468
00469 else if(baseName.find("bemcStatus") == 0) {
00470 St_emcStatus* table = new St_emcStatus("bemcStatus",1);
00471 if (table && mBtowS) {
00472 table->AddAt(static_cast<void*>(mBtowS),0);
00473 table->Write();
00474 }
00475 }
00476 else if(baseName.find("bprsStatus") == 0) {
00477 St_emcStatus* table = new St_emcStatus("bprsStatus",1);
00478 if (table && mBprsS) {
00479 table->AddAt(static_cast<void*>(mBprsS),0);
00480 table->Write();
00481 }
00482 }
00483 else if(baseName.find("bsmdeStatus") == 0) {
00484 St_smdStatus* table = new St_smdStatus("bsmdeStatus",1);
00485 if (table && mSmdeS) {
00486 table->AddAt(static_cast<void*>(mSmdeS),0);
00487 table->Write();
00488 }
00489 }
00490 else if(baseName.find("bsmdpStatus") == 0) {
00491 St_smdStatus* table = new St_smdStatus("bsmdpStatus",1);
00492 if (table && mSmdpS) {
00493 table->AddAt(static_cast<void*>(mSmdpS),0);
00494 table->Write();
00495 }
00496 }
00497
00498 else if(baseName.find("bemcTriggerPed") == 0) {
00499 St_emcTriggerPed* table = new St_emcTriggerPed("bemcTriggerPed",1);
00500 if (table && mTrigP) {
00501 table->AddAt(static_cast<void*>(mTrigP),0);
00502 table->Write();
00503 }
00504 }
00505 else if(baseName.find("bemcTriggerStatus") == 0) {
00506 St_emcTriggerStatus* table = new St_emcTriggerStatus("bemcTriggerStatus",1);
00507 if (table && mTrigS) {
00508 table->AddAt(static_cast<void*>(mTrigS),0);
00509 table->Write();
00510 }
00511 }
00512 else if(baseName.find("bemcTriggerLUT") == 0) {
00513 St_emcTriggerLUT* table = new St_emcTriggerLUT("bemcTriggerLUT",1);
00514 if (table && mTrigL) {
00515 table->AddAt(static_cast<void*>(mTrigL),0);
00516 table->Write();
00517 }
00518 }
00519
00520 f->Close();
00521 }
00522 }
00523
00524 void StBemcTablesWriter::loadTableFromFile(TFile *f) {
00525 string fileName = gSystem->BaseName(f->GetName());
00526
00527 if(fileName.find("bemcPed") == 0) {
00528 if(mBtowP) delete mBtowP;
00529 mBtowP = f->Get("bemcPed") ? ((St_emcPed*)f->Get("bemcPed"))->GetTable() : 0;
00530 }
00531 else if(fileName.find("bprsPed") == 0) {
00532 if(mBprsP) delete mBprsP;
00533 mBprsP = f->Get("bprsPed") ? ((St_emcPed*)f->Get("bprsPed"))->GetTable() : 0;
00534 }
00535 else if(fileName.find("bsmdePed") == 0) {
00536 if(mSmdeP) delete mSmdeP;
00537 mSmdeP = f->Get("bsmdePed") ? ((St_smdPed*)f->Get("bsmdePed"))->GetTable() : 0;
00538 }
00539 else if(fileName.find("bsmdpPed") == 0) {
00540 if(mSmdpP) delete mSmdpP;
00541 mSmdpP = f->Get("bsmdpPed") ? ((St_smdPed*)f->Get("bsmdpPed"))->GetTable() : 0;
00542 }
00543 else if(fileName.find("bemcStatus") == 0) {
00544 if(mBtowS) delete mBtowS;
00545 mBtowS = f->Get("bemcStatus") ? ((St_emcStatus*)f->Get("bemcStatus"))->GetTable() : 0;
00546 }
00547 else if(fileName.find("bprsStatus") == 0) {
00548 if(mBprsS) delete mBprsS;
00549 mBprsS = f->Get("bprsStatus") ? ((St_emcStatus*)f->Get("bprsStatus"))->GetTable() : 0;
00550 }
00551 else if(fileName.find("bsmdeStatus") == 0) {
00552 if(mSmdeS) delete mSmdeS;
00553 mSmdeS = f->Get("bsmdeStatus") ? ((St_smdStatus*)f->Get("bsmdeStatus"))->GetTable() : 0;
00554 }
00555 else if(fileName.find("bsmdpStatus") == 0) {
00556 if(mSmdpS) delete mSmdpS;
00557 mSmdpS = f->Get("bsmdpStatus") ? ((St_smdStatus*)f->Get("bsmdpStatus"))->GetTable() : 0;
00558 }
00559 else if(fileName.find("bemcCalib") == 0) {
00560 if(mBtowC) delete mBtowC;
00561 mBtowC = f->Get("bemcCalib") ? ((St_emcCalib*)f->Get("bemcCalib"))->GetTable() : 0;
00562 }
00563 else if(fileName.find("bprsCalib") == 0) {
00564 if(mBprsC) delete mBprsC;
00565 mBprsC = f->Get("bprsCalib") ? ((St_emcCalib*)f->Get("bprsCalib"))->GetTable() : 0;
00566 }
00567 else if(fileName.find("bsmdeCalib") == 0) {
00568 if(mSmdeC) delete mSmdeC;
00569 mSmdeC = f->Get("bsmdeCalib") ? ((St_smdCalib*)f->Get("bsmdeCalib"))->GetTable() : 0;
00570 }
00571 else if(fileName.find("bsmdpCalib") == 0) {
00572 if(mSmdpC) delete mSmdpC;
00573 mSmdpC = f->Get("bsmdpCalib") ? ((St_smdCalib*)f->Get("bsmdpCalib"))->GetTable() : 0;
00574 }
00575 else if(fileName.find("bemcGain") == 0) {
00576 if(mBtowG) delete mBtowG;
00577 mBtowG = f->Get("bemcGain") ? ((St_emcGain*)f->Get("bemcGain"))->GetTable() : 0;
00578 }
00579 else if(fileName.find("bprsGain") == 0) {
00580 if(mBprsG) delete mBprsG;
00581 mBprsG = f->Get("bprsGain") ? ((St_emcGain*)f->Get("bprsGain"))->GetTable() : 0;
00582 }
00583 else if(fileName.find("bsmdeGain") == 0) {
00584 if(mSmdeG) delete mSmdeG;
00585 mSmdeG = f->Get("bsmdeGain") ? ((St_smdGain*)f->Get("bsmdeGain"))->GetTable() : 0;
00586 }
00587 else if(fileName.find("bsmdpGain") == 0) {
00588 if(mSmdpG) delete mSmdpG;
00589 mSmdpG = f->Get("bsmdpGain") ? ((St_smdGain*)f->Get("bsmdpGain"))->GetTable() : 0;
00590 }
00591 else if(fileName.find("bemcTriggerStatus") == 0) {
00592 if(mTrigS) delete mTrigS;
00593 mTrigS = f->Get("bemcTriggerStatus") ? ((St_emcTriggerStatus*)f->Get("bemcTriggerStatus"))->GetTable() : 0;
00594 }
00595 else if(fileName.find("bemcTriggerPed") == 0) {
00596 if(mTrigP) delete mTrigP;
00597 mTrigP = f->Get("bemcTriggerPed") ? ((St_emcTriggerPed*)f->Get("bemcTriggerPed"))->GetTable() : 0;
00598 }
00599 else if(fileName.find("bemcTriggerLUT") == 0) {
00600 if(mTrigL) delete mTrigL;
00601 mTrigL = f->Get("bemcTriggerLUT") ? ((St_emcTriggerLUT*)f->Get("bemcTriggerLUT"))->GetTable() : 0;
00602 }
00603 }
00604
00605 void StBemcTablesWriter::setTable(const char * tableName, void * data) {
00606 if (!tableName || !data) return;
00607 string myName(tableName);
00608
00609 if(myName.find("bemcPed") == 0) {
00610 if (mBtowP) memcpy(mBtowP, data, sizeof(emcPed_st));
00611 }
00612 else if(myName.find("bprsPed") == 0) {
00613 if (mBprsP) memcpy(mBprsP, data, sizeof(emcPed_st));
00614 }
00615 else if(myName.find("bsmdePed") == 0) {
00616 if (mSmdeP) memcpy(mSmdeP, data, sizeof(smdPed_st));
00617 }
00618 else if(myName.find("bsmdpPed") == 0) {
00619 if (mSmdpP) memcpy(mSmdpP, data, sizeof(smdPed_st));
00620 }
00621 else if(myName.find("bemcStatus") == 0) {
00622 if (mBtowS) memcpy(mBtowS, data, sizeof(emcStatus_st));
00623 }
00624 else if(myName.find("bprsStatus") == 0) {
00625 if (mBprsS) memcpy(mBprsS, data, sizeof(emcStatus_st));
00626 }
00627 else if(myName.find("bsmdeStatus") == 0) {
00628 if (mSmdeS) memcpy(mSmdeS, data, sizeof(smdStatus_st));
00629 }
00630 else if(myName.find("bsmdpStatus") == 0) {
00631 if (mSmdpS) memcpy(mSmdpS, data, sizeof(smdStatus_st));
00632 }
00633 else if(myName.find("bemcCalib") == 0) {
00634 if (mBtowC) memcpy(mBtowC, data, sizeof(emcCalib_st));
00635 }
00636 else if(myName.find("bprsCalib") == 0) {
00637 if (mBprsC) memcpy(mBprsC, data, sizeof(emcCalib_st));
00638 }
00639 else if(myName.find("bsmdeCalib") == 0) {
00640 if (mSmdeC) memcpy(mSmdeC, data, sizeof(smdCalib_st));
00641 }
00642 else if(myName.find("bsmdpCalib") == 0) {
00643 if (mSmdpC) memcpy(mSmdpC, data, sizeof(smdCalib_st));
00644 }
00645 else if(myName.find("bemcGain") == 0) {
00646 if (mBtowG) memcpy(mBtowG, data, sizeof(emcGain_st));
00647 }
00648 else if(myName.find("bprsGain") == 0) {
00649 if (mBprsG) memcpy(mBprsG, data, sizeof(emcGain_st));
00650 }
00651 else if(myName.find("bsmdeGain") == 0) {
00652 if (mSmdeG) memcpy(mSmdeG, data, sizeof(smdGain_st));
00653 }
00654 else if(myName.find("bsmdpGain") == 0) {
00655 if (mSmdpG) memcpy(mSmdpG, data, sizeof(smdGain_st));
00656 }
00657 else if(myName.find("bemcTriggerStatus") == 0) {
00658 if (mTrigS) memcpy(mTrigS, data, sizeof(emcTriggerStatus_st));
00659 }
00660 else if(myName.find("bemcTriggerPed") == 0) {
00661 if (mTrigP) memcpy(mTrigP, data, sizeof(emcTriggerPed_st));
00662 }
00663 else if(myName.find("bemcTriggerLUT") == 0) {
00664 if (mTrigL) memcpy(mTrigL, data, sizeof(emcTriggerLUT_st));
00665 }
00666 }
00667
00668
00669
00670
00671
00672
00673
00674
00675
00676
00677
00678
00679
00680
00681
00682
00683
00684
00685
00686
00687
