StRoot: StEmcUtil/database/StEmcMappingDb.cxx Source File

00001 // $Id: StEmcMappingDb.cxx,v 1.9 2010/01/28 13:45:06 mattheww Exp $
00002 
00003 #include "StEmcMappingDb.h"
00004 
00005 #include "TUnixTime.h"
00006 #include "StMessMgr.h"
00007 #include "StMaker.h"
00008 #include "St_db_Maker/St_db_Maker.h"
00009 
00010 #include "StDbLib/StDbManager.hh"
00011 #include "StDbLib/StDbConfigNode.hh"
00012 #include "StDbLib/StDbTable.h"
00013 
00014 #include "tables/St_bemcMap_Table.h"
00015 #include "tables/St_bprsMap_Table.h"
00016 #include "tables/St_bsmdeMap_Table.h"
00017 #include "tables/St_bsmdpMap_Table.h"
00018 
00019 ClassImp(StEmcMappingDb);
00020 
00021 StEmcMappingDb* StEmcMappingDb::mInstance = NULL;
00022     
00023 StEmcMappingDb::StEmcMappingDb(int date, int time) : mBemcTTable(NULL),
00024     mBprsTTable(NULL), mSmdeTTable(NULL), mSmdpTTable(NULL), mBemcValidity(-2),
00025     mBprsValidity(-2), mSmdeValidity(-2), mSmdpValidity(-2), mBemcTable(NULL),
00026     mBprsTable(NULL), mSmdeTable(NULL), mSmdpTable(NULL), mBemcDirty(true),
00027     mBprsDirty(true), mSmdeDirty(true), mSmdpDirty(true)
00028 {
00029     mChain = StMaker::GetChain();
00030     
00031     reset_bemc_cache();
00032     reset_bprs_cache();
00033     reset_smde_cache();
00034     reset_smdp_cache();
00035     
00036     if(!mChain) {
00037         StDbManager *mgr = StDbManager::Instance();
00038         StDbConfigNode *db = mgr ? mgr->initConfig("Calibrations_emc") : 0;
00039         if (db) {
00040             mBemcTable = db->addDbTable("bemcMap");
00041             mSmdeTable = db->addDbTable("bsmdeMap");
00042             mSmdpTable = db->addDbTable("bsmdpMap");
00043             mBprsTable = db->addDbTable("bprsMap");
00044         
00045             int elements[18000]; for(int i=0; i<18000; i++) elements[i] = i+1;
00046         
00047             mBemcTable->resizeElementID(4800);
00048             mBemcTable->setElementID(elements, 4800);
00049         
00050             mBprsTable->resizeElementID(4800);
00051             mBprsTable->setElementID(elements, 4800);
00052         
00053             mSmdeTable->resizeElementID(18000);
00054             mSmdeTable->setElementID(elements, 18000);
00055         
00056             mSmdpTable->resizeElementID(18000);
00057             mSmdpTable->setElementID(elements, 18000);
00058         
00059             mBemcTTable = new St_bemcMap();
00060             mBemcTTable->Adopt(4800, mBemcTable->GetTable());
00061         
00062             mBprsTTable = new St_bprsMap();
00063             mBprsTTable->Adopt(4800, mBprsTable->GetTable());
00064         
00065             mSmdeTTable = new St_bsmdeMap();
00066             mSmdeTTable->Adopt(18000, mSmdeTable->GetTable());
00067         
00068             mSmdpTTable = new St_bsmdpMap();
00069             mSmdpTTable->Adopt(18000, mSmdpTable->GetTable());
00070         }
00071         SetDateTime(date, time);
00072     }
00073 }
00074 
00075 StEmcMappingDb::~StEmcMappingDb() {
00076     // I'm intentionally not deleting the TTables created on the heap above.  If
00077     // I tried to delete them I'd end up with a double-delete of the mapping 
00078     // memory, since the StDbTables already own it.  I don't want to copy the
00079     // data because it's ~6 MB or so.  Each TTable only has 2 Long_ts and an
00080     // Int_t; I think this should be OK.
00081 }
00082 
00083 StEmcMappingDb* StEmcMappingDb::instance() {
00084     if(!mInstance) mInstance = new StEmcMappingDb();
00085     return mInstance;
00086 }
00087 
00088 void StEmcMappingDb::SetDateTime(int date, int time) {
00089     if(mChain) {
00090         LOG_DEBUG << "StEmcMappingDb::SetDateTime is illegal in a chain" << endm;
00091     }
00092     else {
00093         mBeginTime.Set(date, time);
00094         unsigned unix = TUnixTime::Convert(mBeginTime, true);
00095         if(mBemcTable && !(mBemcTable->getBeginTime() < unix && unix < mBemcTable->getEndTime()) ) {
00096             mBemcDirty = true;
00097             reset_bemc_cache();
00098         }
00099         if(mBprsTable && !(mBprsTable->getBeginTime() < unix && unix < mBprsTable->getEndTime()) ) {
00100             mBprsDirty = true;
00101             reset_bprs_cache();
00102         }
00103         if( mSmdeTable && !(mSmdeTable->getBeginTime() < unix && unix < mSmdeTable->getEndTime()) ) {
00104             mSmdeDirty = true;
00105             reset_smde_cache();
00106         }
00107         if(mSmdpTable && !(mSmdpTable->getBeginTime() < unix && unix < mSmdpTable->getEndTime()) ) {
00108             mSmdpDirty = true;
00109             reset_smdp_cache();
00110         }
00111     }
00112 }
00113 
00114 void StEmcMappingDb::SetFlavor(const char *flavor, const char *tablename) {
00115     if(mChain) {
00116         LOG_DEBUG << "StEmcMappingDb::SetFlavor is illegal in a chain" << endm;
00117     }
00118     else {
00119         if(!tablename || !strcmp(tablename, "bemcMap"))  {
00120             if(mBemcTable && strcmp(mBemcTable->getFlavor(), flavor)) {
00121                 mBemcTable->setFlavor(flavor);
00122                 mBemcDirty = true;
00123                 reset_bemc_cache();
00124             }
00125         }
00126         if(!tablename || !strcmp(tablename, "bprsMap")) {
00127             if(mBprsTable && strcmp(mBprsTable->getFlavor(), flavor)) {
00128                 mBprsTable->setFlavor(flavor);
00129                 mBprsDirty = true;
00130                 reset_bprs_cache();
00131             }
00132         }
00133         if(!tablename || !strcmp(tablename, "bsmdeMap")) {
00134             if(mSmdeTable && strcmp(mSmdeTable->getFlavor(), flavor)) {
00135                 mSmdeTable->setFlavor(flavor);
00136                 mSmdeDirty = true;
00137                 reset_smde_cache();
00138             }
00139         }
00140         if(!tablename || !strcmp(tablename, "bsmdpMap")) {
00141             if(mSmdpTable && strcmp(mSmdpTable->getFlavor(), flavor)) {
00142                 mSmdpTable->setFlavor(flavor);
00143                 mSmdpDirty = true;
00144                 reset_smdp_cache();
00145             }
00146         }
00147     }
00148 }
00149 
00150 void StEmcMappingDb::SetMaxEntryTime(int date, int time) {
00151     if(mChain) {
00152         LOG_DEBUG << "StEmcMappingDb::SetMaxEntryTime is illegal in a chain" << endm;
00153     }
00154     else {
00155         unsigned unixMax = TUnixTime::Convert(TDatime(date,time), true);
00156         if(mBemcTable && (mBemcTable->getProdTime() != unixMax)) {
00157             mBemcTable->setProdTime(unixMax);
00158             mBemcDirty = true;
00159             reset_bemc_cache();
00160         }
00161         if(mBprsTable && (mBprsTable->getProdTime() != unixMax)) {
00162             mBprsTable->setProdTime(unixMax);
00163             mBprsDirty = true;
00164             reset_bprs_cache();
00165         }
00166         if(mSmdeTable && (mSmdeTable->getProdTime() != unixMax)) {
00167             mSmdeTable->setProdTime(unixMax);
00168             mSmdeDirty = true;
00169             reset_smde_cache();
00170         }
00171         if(mSmdpTable && (mSmdpTable->getProdTime() != unixMax)) {
00172             mSmdpTable->setProdTime(unixMax);
00173             mSmdpDirty = true;
00174             reset_smdp_cache();
00175         }        
00176     }
00177 }
00178 
00179 // struct declaration auto-generated at $STAR/include/bemcMap.h
00180 const bemcMap_st* StEmcMappingDb::bemc() const {
00181     maybe_reload(kBarrelEmcTowerId);
00182     return mBemcTTable ? mBemcTTable->GetTable() : 0;
00183 }
00184 
00185 // struct declaration auto-generated at $STAR/include/bprsMap.h
00186 const bprsMap_st* StEmcMappingDb::bprs() const {
00187     maybe_reload(kBarrelEmcPreShowerId);
00188     return mBprsTTable ? mBprsTTable->GetTable() : 0;
00189 }
00190 
00191 // struct declaration auto-generated at $STAR/include/bsmdeMap.h
00192 const bsmdeMap_st* StEmcMappingDb::bsmde() const {
00193     maybe_reload(kBarrelSmdEtaStripId);
00194     return mSmdeTTable ? mSmdeTTable->GetTable() : 0;
00195 }
00196 
00197 // struct declaration auto-generated at $STAR/include/bsmdpMap.h
00198 const bsmdpMap_st* StEmcMappingDb::bsmdp() const {
00199     maybe_reload(kBarrelSmdPhiStripId);
00200     return mSmdpTTable ? mSmdpTTable->GetTable() : 0;
00201 }
00202 
00203 int 
00204 StEmcMappingDb::softIdFromMES(StDetectorId det, int m, int e, int s) const {
00205     switch(det) {
00206         case kBarrelEmcTowerId:
00207         case kBarrelEmcPreShowerId:
00208         return 40*(m-1) + 20*(s-1) + e;
00209         
00210         case kBarrelSmdEtaStripId:
00211         return 150*(m-1) + 150*(s-1) + e;
00212         
00213         case kBarrelSmdPhiStripId:
00214         return 150*(m-1) + 10*(s-1) + e;
00215         
00216         default: break;
00217     }
00218     return 0;
00219 }
00220 
00221 int 
00222 StEmcMappingDb::softIdFromCrate(StDetectorId det, int crate, int channel) const {
00223     if(det == kBarrelEmcTowerId) {
00224         const bemcMap_st* map = bemc();
00225         if (!map) return 0;
00226         if(!mCacheCrate[crate-1][channel]) {
00227             for(int i=0; i<4800; ++i) {
00228                 mCacheCrate[map[i].crate-1][map[i].crateChannel] = i+1;
00229             }
00230         }
00231         
00232         // confirm that cache is still valid
00233         short id = mCacheCrate[crate-1][channel];
00234         if(map[id-1].crate == crate && map[id-1].crateChannel == channel) {
00235             return id;
00236         } else {
00237             reset_bemc_cache();
00238             return softIdFromCrate(det, crate, channel);
00239         }
00240     }
00241     return 0;
00242 }
00243 
00244 int 
00245 StEmcMappingDb::softIdFromDaqId(StDetectorId det, int daqID) const {
00246     if(det == kBarrelEmcTowerId) {
00247         const bemcMap_st* map = bemc();
00248         if (!map) return 0;
00249         if(!mCacheDaqId[daqID]) {
00250             for(int i=0; i<4800; ++i) {
00251                 mCacheDaqId[map[i].daqID] = i+1;
00252             }
00253         }
00254         
00255         // confirm that cache is still valid
00256         if(map[mCacheDaqId[daqID]-1].daqID == daqID) {
00257             return mCacheDaqId[daqID];
00258         } else {
00259             reset_bemc_cache();
00260             return softIdFromDaqId(det, daqID);
00261         }
00262     }
00263     return 0;
00264 }
00265 
00266 int 
00267 StEmcMappingDb::softIdFromTDC(StDetectorId det, int TDC, int channel) const {
00268     if(det == kBarrelEmcTowerId) {
00269         const bemcMap_st* map = bemc();
00270         if (!map) return 0;
00271         if(!mCacheTDC[TDC][channel]) {
00272             for(int i=0; i<4800; ++i) {
00273                 mCacheTDC[map[i].TDC][map[i].crateChannel] = i+1;
00274             }
00275         }
00276         
00277         // confirm that cache is still valid
00278         short id = mCacheTDC[TDC][channel];
00279         if(map[id-1].TDC == TDC && map[id-1].crateChannel == channel) {
00280             return id;
00281         } else {
00282             reset_bemc_cache();
00283             return softIdFromTDC(det, TDC, channel);
00284         }
00285     }
00286     return 0;
00287 }
00288 
00289 int 
00290 StEmcMappingDb::softIdFromRDO(StDetectorId det, int rdo, int channel) const {
00291     short id;
00292     switch(det) {
00293         case kBarrelEmcPreShowerId:
00294           {
00295             const bprsMap_st* prs = bprs();
00296             if (!prs) return 0;
00297             if(mCacheBprsRdo[rdo][channel] == -1) {
00298               for(int i=0; i<4800; i++) {
00299                 if(prs[i].rdo == rdo && prs[i].rdoChannel == channel) {
00300                   mCacheBprsRdo[rdo][channel] = i+1;
00301                   return i+1;
00302                 }
00303               }
00304             }
00305 
00306             switch((id = mCacheBprsRdo[rdo][channel])) {
00307             // didn't find it on a linear search, must be empty channel
00308             case -1:
00309               mCacheBprsRdo[rdo][channel] = 0;
00310               return 0;
00311             
00312             // check cache validity before accepting an empty channel
00313             case 0:
00314               if(maybe_reset_cache(kBarrelEmcPreShowerId))
00315                 return softIdFromRDO(det, rdo, channel);
00316               else return 0;
00317             
00318             default:
00319               if(prs[id-1].rdo == rdo && prs[id-1].rdoChannel == channel){
00320                 return id;
00321               } else {
00322                 reset_bprs_cache();
00323                 return softIdFromRDO(det, rdo, channel);
00324               }
00325             }
00326           }
00327 
00328         case kBarrelSmdEtaStripId: case kBarrelSmdPhiStripId:
00329           {
00330             const bsmdeMap_st *smde = bsmde();
00331             const bsmdpMap_st *smdp = bsmdp();
00332             if (!smde || !smdp) return 0;
00333             if(mCacheSmdRdo[rdo][channel] == -1) {
00334               for(int i=0; i<18000; i++) {
00335                 if(smde[i].rdo == rdo && smde[i].rdoChannel == channel) {
00336                   mCacheSmdRdo[rdo][channel] = i+1;
00337                   if(det == kBarrelSmdEtaStripId) return i+1;
00338                 }
00339                 else if(smdp[i].rdo == rdo && smdp[i].rdoChannel == channel){
00340                   mCacheSmdRdo[rdo][channel] = i+1;
00341                   if(det == kBarrelSmdPhiStripId) return i+1;
00342                 }
00343               }
00344             }
00345         
00346             switch((id = mCacheSmdRdo[rdo][channel])) {
00347             // didn't find it on a linear search, must be empty channel
00348             case -1:
00349               mCacheSmdRdo[rdo][channel] = 0;
00350               return 0;
00351             
00352             // check cache validity before accepting an empty channel
00353             case 0:
00354               if(maybe_reset_cache(det))
00355                 return softIdFromRDO(det, rdo, channel);
00356               else return 0;
00357             
00358             // confirm result
00359             default:
00360               if(smde[id-1].rdo == rdo && smde[id-1].rdoChannel == channel){
00361                 if(det == kBarrelSmdEtaStripId) return id;
00362                 return 0;
00363               }
00364               else if(smdp[id-1].rdo == rdo && smdp[id-1].rdoChannel == channel){
00365                 if(det == kBarrelSmdPhiStripId) return id;
00366                 return 0;
00367               }
00368               else{
00369                 reset_smde_cache(); // also resets smdp cache
00370                 return softIdFromRDO(det, rdo, channel);
00371               }
00372             }
00373           }
00374     default: break;
00375     }
00376     return 0;
00377 }
00378 
00379 /* Private methods used for caching SQL query results */
00380 void StEmcMappingDb::maybe_reload(StDetectorId det) const {
00381     switch(det) {
00382         case kBarrelEmcTowerId:
00383         if(mChain) {
00384             if(!mBemcTTable) {
00385                 TDataSet *DB = mChain->GetInputDB("Calibrations/emc/map");
00386                 if(DB) mBemcTTable = static_cast<St_bemcMap*>(DB->Find("bemcMap"));
00387             }
00388         } else {
00389             if(mBemcDirty) reload_dbtable(mBemcTable);
00390             mBemcDirty = false;
00391         }
00392         break;
00393         
00394         case kBarrelEmcPreShowerId:
00395         if(mChain) {
00396             if(!mBprsTTable) {
00397                 TDataSet *DB = mChain->GetInputDB("Calibrations/emc/map");
00398                 if(DB) mBprsTTable = static_cast<St_bprsMap*>(DB->Find("bprsMap"));
00399             }
00400         } else {
00401             if(mBprsDirty) reload_dbtable(mBprsTable);
00402             mBprsDirty = false;
00403         }
00404         break;
00405         
00406         case kBarrelSmdEtaStripId:
00407         if(mChain) {
00408             if(!mSmdeTTable) {
00409                 TDataSet *DB = mChain->GetInputDB("Calibrations/emc/map");
00410                 if(DB) mSmdeTTable = static_cast<St_bsmdeMap*>(DB->Find("bsmdeMap"));
00411             }
00412         } else {
00413             if(mSmdeDirty) reload_dbtable(mSmdeTable);
00414             mSmdeDirty = false;
00415         }
00416         break;
00417         
00418         case kBarrelSmdPhiStripId:
00419         if(mChain) {
00420             if(!mSmdpTTable) {
00421                 TDataSet *DB = mChain->GetInputDB("Calibrations/emc/map");
00422                 if(DB) mSmdpTTable = static_cast<St_bsmdpMap*>(DB->Find("bsmdpMap"));
00423             }
00424         } else {
00425             if(mSmdpDirty) reload_dbtable(mSmdpTable);
00426             mSmdpDirty = false;
00427         }
00428         default: break;
00429     }
00430 }
00431 
00432 void StEmcMappingDb::reload_dbtable(StDbTable* table) const {
00433     if (!table) return;
00434     LOG_DEBUG << "(re)loading mapping table using StDbManager" << endm;
00435     StDbManager *mgr = StDbManager::Instance();
00436     if (mgr) { 
00437         mgr->setVerbose(false);
00438         mgr->setRequestTime(mBeginTime.AsSQLString());
00439         mgr->fetchDbTable(table);
00440     }
00441 }
00442 
00443 bool StEmcMappingDb::maybe_reset_cache(StDetectorId det) const {
00444     // caches are proactively reset when flipping dirty flags, so ...
00445     if(!mChain) return false;
00446     
00447     Int_t version;
00448     switch(det) {
00449         case kBarrelEmcTowerId:
00450         if((version = St_db_Maker::GetValidity(mBemcTTable,NULL)) != mBemcValidity) {
00451             mBemcValidity = version;
00452             reset_bemc_cache();
00453             return true;
00454         }
00455         break;
00456         
00457         case kBarrelEmcPreShowerId:
00458         if((version = St_db_Maker::GetValidity(mBprsTTable,NULL)) != mBprsValidity) {
00459             mBprsValidity = version;
00460             reset_bprs_cache();
00461             return true;
00462         }
00463         break;
00464         
00465         case kBarrelSmdEtaStripId:
00466         if((version = St_db_Maker::GetValidity(mSmdeTTable,NULL)) != mSmdeValidity) {
00467             mSmdeValidity = version;
00468             reset_smde_cache();
00469             return true;
00470         }
00471         break;
00472         
00473         case kBarrelSmdPhiStripId:
00474         if((version = St_db_Maker::GetValidity(mSmdpTTable,NULL)) != mSmdpValidity) {
00475             mSmdpValidity = version;
00476             reset_smdp_cache();
00477             return true;
00478         }
00479         default: break;
00480     }
00481     return false;
00482 }
00483 
00484 void StEmcMappingDb::reset_bemc_cache() const {
00485     memset(mCacheCrate, 0, sizeof(mCacheCrate));
00486     memset(mCacheDaqId, 0, sizeof(mCacheDaqId));
00487     memset(mCacheTDC, 0, sizeof(mCacheTDC));
00488 }
00489 
00490 void StEmcMappingDb::reset_bprs_cache() const {
00491     memset(mCacheBprsRdo, -1, sizeof(mCacheBprsRdo));
00492 }
00493 
00494 void StEmcMappingDb::reset_smde_cache() const {
00495     memset(mCacheSmdRdo, -1, sizeof(mCacheSmdRdo));
00496 }
00497 
00498 void StEmcMappingDb::reset_smdp_cache() const {
00499     memset(mCacheSmdRdo, -1, sizeof(mCacheSmdRdo));
00500 }
00501 
00502 /*****************************************************************************
00503  * $Log: StEmcMappingDb.cxx,v $
00504  * Revision 1.9  2010/01/28 13:45:06  mattheww
00505  * update from Oleksandr to protect against NULL pointers
00506  *
00507  * Revision 1.7  2009/11/17 14:19:28  mattheww
00508  * fixed bug in some if statements
00509  *
00510  * Revision 1.6  2009/04/20 16:38:57  mattheww
00511  * fixed case statements so that we can compile SL305
00512  *
00513  * Revision 1.5  2009/02/01 17:34:52  kocolosk
00514  * more caching and optimization.
00515  *
00516  * Last StEmcMapping commit was bad and left header, implementation
00517  * inconsistent.  This commit fixes the AutoBuild.
00518  *
00519  * Revision 1.1  2009/01/08 02:16:18  kocolosk
00520  * move StEmcMappingDb/StEmcDecoder to StEmcUtil/database
00521  *
00522  * Revision 2.1  2008/12/05 19:05:32  kocolosk
00523  * new DB-backed implementation of StEmcDecoder
00524  *
00525  *****************************************************************************/