00001
00002
00003
00004
00005
00006
00007 #ifndef TRG_UTIL_2009_HH
00008 #define TRG_UTIL_2009_HH
00009
00010 #include <cstdio>
00011 #include <cassert>
00012 #include <byteswap.h>
00013 #include <algorithm>
00014
00015 using namespace std;
00016
00017 #ifdef __ROOT__
00018 #include "RTS/trg/include/trgDataDefs.h"
00019 #include "RTS/trg/include/trgConfNum.h"
00020 #else
00021 #include "trgDataDefs.h"
00022 #include "trgConfNum.h"
00023 #endif
00024
00025 inline unsigned short bswap16(unsigned short x) { return bswap_16(x); }
00026 inline unsigned int bswap32(unsigned int x) { return bswap_32(x); }
00027
00028 inline void swapTrgOfflen(TrgOfflen& trgOfflen)
00029 {
00030 trgOfflen.offset = bswap32(trgOfflen.offset);
00031 trgOfflen.length = bswap32(trgOfflen.length);
00032 }
00033
00034 inline void swapEvtDescData(EvtDescData& evtDesc)
00035 {
00036 evtDesc.length = bswap32(evtDesc.length);
00037 evtDesc.bunchXing_hi = bswap32(evtDesc.bunchXing_hi);
00038 evtDesc.bunchXing_lo = bswap32(evtDesc.bunchXing_lo);
00039 evtDesc.actionWdDetectorBitMask = bswap16(evtDesc.actionWdDetectorBitMask);
00040 evtDesc.TrgToken = bswap16(evtDesc.TrgToken);
00041 evtDesc.addBits = bswap16(evtDesc.addBits);
00042 evtDesc.DSMInput = bswap16(evtDesc.DSMInput);
00043 evtDesc.externalBusy = bswap16(evtDesc.externalBusy);
00044 evtDesc.internalBusy = bswap16(evtDesc.internalBusy);
00045 evtDesc.physicsWord = bswap16(evtDesc.physicsWord);
00046 evtDesc.TriggerWord = bswap16(evtDesc.TriggerWord);
00047 evtDesc.DSMAddress = bswap16(evtDesc.DSMAddress);
00048 evtDesc.TCU_Mark = bswap16(evtDesc.TCU_Mark);
00049 evtDesc.npre = bswap16(evtDesc.npre);
00050 evtDesc.npost = bswap16(evtDesc.npost);
00051 }
00052
00053 inline void swapL1_DSM_Data(L1_DSM_Data& L1data)
00054 {
00055 L1data.length = bswap32(L1data.length);
00056 transform(L1data.TOF,L1data.TOF+8,L1data.TOF,bswap16);
00057 transform(L1data.VTX,L1data.VTX+8,L1data.VTX,bswap16);
00058 transform(L1data.EMC,L1data.EMC+8,L1data.EMC,bswap16);
00059 transform(L1data.BCdata,L1data.BCdata+16,L1data.BCdata,bswap16);
00060 transform(L1data.specialTriggers,L1data.specialTriggers+8,L1data.specialTriggers,bswap16);
00061 transform(L1data.FPD,L1data.FPD+8,L1data.FPD,bswap16);
00062 transform(L1data.lastDSM,L1data.lastDSM+8,L1data.lastDSM,bswap16);
00063 }
00064
00065 inline void swapTrgSumData(TrgSumData& trgSum)
00066 {
00067 trgSum.length = bswap32(trgSum.length);
00068 transform(trgSum.L1Sum,trgSum.L1Sum+2,trgSum.L1Sum,bswap32);
00069 transform(trgSum.L2Sum,trgSum.L2Sum+2,trgSum.L2Sum,bswap32);
00070 transform(trgSum.L1Result,trgSum.L1Result+32,trgSum.L1Result,bswap32);
00071 transform(trgSum.L2Result,trgSum.L2Result+64,trgSum.L2Result,bswap32);
00072 transform(trgSum.C2Result,trgSum.C2Result+64,trgSum.C2Result,bswap32);
00073 }
00074
00075 inline void swapDataBlock(DataBlock& data)
00076 {
00077 data.length = bswap32(data.length);
00078 }
00079
00080 inline void swapBELayerBlock(BELayerBlock& bc1)
00081 {
00082 bc1.length = bswap32(bc1.length);
00083 transform(bc1.BEMClayer1,bc1.BEMClayer1+48,bc1.BEMClayer1,bswap16);
00084 transform(bc1.EEMClayer1,bc1.EEMClayer1+16,bc1.EEMClayer1,bswap16);
00085 }
00086
00087 inline void swapMIXBlock(MIXBlock& mix)
00088 {
00089 mix.length = bswap32(mix.length);
00090 transform(mix.FPDEastNSLayer1,mix.FPDEastNSLayer1+8,mix.FPDEastNSLayer1,bswap16);
00091 transform(mix.TOFLayer1,mix.TOFLayer1+8,mix.TOFLayer1,bswap16);
00092 transform(mix.TOF,mix.TOF+48,mix.TOF,bswap16);
00093 }
00094
00095 inline void swapBWestBlock(BWestBlock& bcw)
00096 {
00097 bcw.length = bswap32(bcw.length);
00098 }
00099
00100 inline void swapBEastBlock(BEastBlock& bce)
00101 {
00102 bce.length = bswap32(bce.length);
00103 }
00104
00105 inline void swapBBCBlock(BBCBlock& bbc)
00106 {
00107 bbc.length = bswap32(bbc.length);
00108 transform(bbc.BBClayer1,bbc.BBClayer1+16,bbc.BBClayer1,bswap16);
00109 transform(bbc.ZDClayer1,bbc.ZDClayer1+8,bbc.ZDClayer1,bswap16);
00110 transform(bbc.VPD,bbc.VPD+8,bbc.VPD,bswap16);
00111 }
00112
00113 inline void swapFMSBlock(FMSBlock& fms)
00114 {
00115 fms.length = bswap32(fms.length);
00116 }
00117
00118 inline void swapQTBlock(QTBlock& qt)
00119 {
00120 qt.length = bswap32(qt.length);
00121 qt.dataLoss = bswap32(qt.dataLoss);
00122 }
00123
00124 inline void swapDataBlockAtCrate(DataBlock& data, int crate)
00125 {
00126 switch (crate) {
00127 case BC1_CONF_NUM:
00128 {
00129 BELayerBlock* bc1 = (BELayerBlock*)&data;
00130 assert(strncmp(bc1->name, "BC1", 3) == 0);
00131 swapBELayerBlock(*bc1);
00132 break;
00133 }
00134 case MIX_CONF_NUM:
00135 {
00136 MIXBlock* mix = (MIXBlock*)&data;
00137 assert(strncmp(mix->name, "MIX", 3) == 0);
00138 swapMIXBlock(*mix);
00139 break;
00140 }
00141 case BCW_CONF_NUM:
00142 {
00143 BWestBlock* bcw = (BWestBlock*)&data;
00144 assert(strncmp(bcw->name, "BCW", 3) == 0);
00145 swapBWestBlock(*bcw);
00146 break;
00147 }
00148 case BCE_CONF_NUM:
00149 {
00150 BEastBlock* bce = (BEastBlock*)&data;
00151 assert(strncmp(bce->name, "BCE", 3) == 0);
00152 swapBEastBlock(*bce);
00153 break;
00154 }
00155 case BBC_CONF_NUM:
00156 {
00157 BBCBlock* bbc = (BBCBlock*)&data;
00158 assert(strncmp(bbc->name, "BBC", 3) == 0);
00159 swapBBCBlock(*bbc);
00160 break;
00161 }
00162 case FMS_CONF_NUM:
00163 {
00164 FMSBlock* fms = (FMSBlock*)&data;
00165 assert(strncmp(fms->name, "FMS", 3) == 0);
00166 swapFMSBlock(*fms);
00167 break;
00168 }
00169 case QT1_CONF_NUM:
00170 case QT2_CONF_NUM:
00171 case QT3_CONF_NUM:
00172 case QT4_CONF_NUM:
00173 {
00174 QTBlock* qt = (QTBlock*)&data;
00175 assert(strncmp(qt->name, "QT1", 3) == 0 ||
00176 strncmp(qt->name, "QT2", 3) == 0 ||
00177 strncmp(qt->name, "QT3", 3) == 0 ||
00178 strncmp(qt->name, "QT4", 3) == 0);
00179 swapQTBlock(*qt);
00180 break;
00181 }
00182 default:
00183 {
00184 swapDataBlock(data);
00185 break;
00186 }
00187 }
00188 }
00189
00190 inline void swapTriggerDataBlk(TriggerDataBlk& trgData)
00191 {
00192
00193
00194 trgData.FormatVersion = bswap32(trgData.FormatVersion);
00195
00196 trgData.totalTriggerLength = bswap32(trgData.totalTriggerLength);
00197 trgData.eventNumber = bswap32(trgData.eventNumber);
00198
00199
00200
00201 swapTrgOfflen(trgData.EventDesc_ofl);
00202 EvtDescData* evtDesc = (EvtDescData*)((int)&trgData+trgData.EventDesc_ofl.offset);
00203 assert(strncmp(evtDesc->name, "EVD", 3) == 0 || strncmp(evtDesc->name, "EVT", 3) == 0);
00204 swapEvtDescData(*evtDesc);
00205
00206
00207
00208 swapTrgOfflen(trgData.L1_DSM_ofl);
00209 L1_DSM_Data* L1data = (L1_DSM_Data*)((int)&trgData+trgData.L1_DSM_ofl.offset);
00210 assert(strncmp(L1data->name, "L1DS", 4) == 0);
00211 swapL1_DSM_Data(*L1data);
00212
00213
00214
00215 swapTrgOfflen(trgData.Summary_ofl);
00216 TrgSumData* trgSum = (TrgSumData*)((int)&trgData+trgData.Summary_ofl.offset);
00217 assert(strncmp(trgSum->name, "TSUM", 4) == 0);
00218 swapTrgSumData(*trgSum);
00219
00220
00221
00222 for (int crate = 0; crate < MAX_OFFLEN; ++crate) {
00223 swapTrgOfflen(trgData.MainX[crate]);
00224 if (trgData.MainX[crate].offset && trgData.MainX[crate].length) {
00225 DataBlock* data = (DataBlock*)((int)&trgData+trgData.MainX[crate].offset);
00226 swapDataBlockAtCrate(*data, crate);
00227 }
00228 }
00229
00230
00231
00232 const int nentries = evtDesc->npre + evtDesc->npost;
00233
00234 for (int i = 0; i < nentries; ++i) {
00235 trgData.PrePostList[i] = bswap32(trgData.PrePostList[i]);
00236 TrgOfflen* PrePostX = (TrgOfflen*)((int)&trgData+trgData.PrePostList[i]);
00237 for (int crate = 0; crate < MAX_OFFLEN; ++crate) {
00238 swapTrgOfflen(PrePostX[crate]);
00239 if (PrePostX[crate].offset && PrePostX[crate].length) {
00240 DataBlock* data = (DataBlock*)((int)&trgData+PrePostX[crate].offset);
00241 swapDataBlockAtCrate(*data, crate);
00242 }
00243 }
00244 }
00245 }
00246
00247 inline void printName(const char* name)
00248 {
00249 printf("name: ");
00250 for (int i = 0; i < 4; ++i) putchar(name[i]);
00251 printf("\n");
00252 }
00253
00254 inline void printEvtDescData(const EvtDescData& evtDesc)
00255 {
00256 printName(evtDesc.name);
00257 printf("TrgDataFmtVer: 0x%x\n", evtDesc.TrgDataFmtVer);
00258 printf("length: %d\n", evtDesc.length);
00259 printf("bunchXing_hi: %d\n", evtDesc.bunchXing_hi);
00260 printf("bunchXing_lo: %d\n", evtDesc.bunchXing_lo);
00261 printf("actionWdDetectorBitMask: %d\n", evtDesc.actionWdDetectorBitMask);
00262 printf("actionWdTrgCommand: %d\n", evtDesc.actionWdTrgCommand);
00263 printf("actionWdDaqCommand: %d\n", evtDesc.actionWdDaqCommand);
00264 printf("TrgToken: %d\n", evtDesc.TrgToken);
00265 printf("addBits: %d\n", evtDesc.addBits);
00266 printf("DSMInput: %d\n", evtDesc.DSMInput);
00267 printf("externalBusy: %d\n", evtDesc.externalBusy);
00268 printf("internalBusy: %d\n", evtDesc.internalBusy);
00269 printf("physicsWord: %d\n", evtDesc.physicsWord);
00270 printf("TriggerWord: %d\n", evtDesc.TriggerWord);
00271 printf("DSMAddress: %d\n", evtDesc.DSMAddress);
00272 printf("TCU_Mark: %d\n", evtDesc.TCU_Mark);
00273 printf("npre: %d\n", evtDesc.npre);
00274 printf("npost: %d\n", evtDesc.npost);
00275 }
00276
00277 inline void printL1_DSM_Data(const L1_DSM_Data& L1data)
00278 {
00279 printName(L1data.name);
00280 printf("length: %d\n", L1data.length);
00281 printf("TOF: ");
00282 for (int i = 0; i < 8; ++i) printf("%04x ", L1data.TOF[i]);
00283 printf("\n");
00284 printf("VTX: ");
00285 for (int i = 0; i < 8; ++i) printf("%04x ", L1data.VTX[i]);
00286 printf("\n");
00287 printf("EMC: ");
00288 for (int i = 0; i < 8; ++i) printf("%04x ", L1data.EMC[i]);
00289 printf("\n");
00290 printf("BCdata:\n");
00291 for (int i = 0; i < 16; ++i) {
00292 printf("%04x ", L1data.BCdata[i]);
00293 if (i % 8 == 7) printf("\n");
00294 }
00295 printf("specialTriggers: ");
00296 for (int i = 0; i < 8; ++i) printf("%04x ", L1data.specialTriggers[i]);
00297 printf("\n");
00298 printf("FPD: ");
00299 for (int i = 0; i < 8; ++i) printf("%04x ", L1data.FPD[i]);
00300 printf("\n");
00301 printf("lastDSM: ");
00302 for (int i = 0; i < 8; ++i) printf("%04x ", L1data.lastDSM[i]);
00303 printf("\n");
00304 }
00305
00306 inline void printTrgSumData(const TrgSumData& trgSum)
00307 {
00308 printName(trgSum.name);
00309 printf("length: %d\n", trgSum.length);
00310 printf("L1Sum: ");
00311 for (int i = 0; i < 2; ++i) printf("%08x ", trgSum.L1Sum[i]);
00312 printf("\n");
00313 printf("L2Sum: ");
00314 for (int i = 0; i < 2; ++i) printf("%08x ", trgSum.L2Sum[i]);
00315 printf("\n");
00316 printf("L1Result:\n");
00317 for (int i = 0; i < 32; ++i) {
00318 printf("%08x ", trgSum.L1Result[i]);
00319 if (i % 8 == 7) printf("\n");
00320 }
00321 printf("L2Result:\n");
00322 for (int i = 0; i < 64; ++i) {
00323 printf("%08x ", trgSum.L2Result[i]);
00324 if (i %8 == 7) printf("\n");
00325 }
00326 printf("C2Result:\n");
00327 for (int i = 0; i < 64; ++i) {
00328 printf("%08x ", trgSum.C2Result[i]);
00329 if (i % 8 == 7) printf("\n");
00330 }
00331 }
00332
00333 inline void printMIXBlock(const MIXBlock& mix)
00334 {
00335 printName(mix.name);
00336 printf("length: %d\n", mix.length);
00337 printf("FPDEastNSLayer1: ");
00338 for (int i = 0; i < 8; ++i) printf("%04x ", mix.FPDEastNSLayer1[i]);
00339 printf("\n");
00340 printf("MTD_P2PLayer1:\n");
00341 for (int i = 0; i < 16; ++i) {
00342 printf("%x ", mix.MTD_P2PLayer1[i]);
00343 if (i % 8 == 7) printf("\n");
00344 }
00345 printf("TOFLayer1: ");
00346 for (int i = 0; i < 8; ++i) printf("%04x ", mix.TOFLayer1[i]);
00347 printf("\n");
00348 printf("TOF:\n");
00349 for (int i = 0; i < 48; ++i) {
00350 printf("%04x ", mix.TOF[i]);
00351 if (i % 8 == 7) printf("\n");
00352 }
00353 }
00354
00355 inline void printBBCBlock(const BBCBlock& bbc)
00356 {
00357 printName(bbc.name);
00358 printf("length: %d\n", bbc.length);
00359 printf("BBClayer1:\n");
00360 for (int i = 0; i < 16; ++i) {
00361 printf("%04x ", bbc.BBClayer1[i]);
00362 if (i % 8 == 7) printf("\n");
00363 }
00364 printf("ZDClayer1:\n");
00365 for (int i = 0; i < 8; ++i) printf("%04x ", bbc.ZDClayer1[i]);
00366 printf("\n");
00367 printf("VPD:\n");
00368 for (int i = 0; i < 8; ++i) printf("%04x ", bbc.VPD[i]);
00369 printf("\n");
00370 }
00371
00372 inline void printFMSBlock(const FMSBlock& fms)
00373 {
00374 printName(fms.name);
00375 printf("length: %d\n", fms.length);
00376 for (int i = 0; i < 256; ++i) {
00377 printf("%02x ", fms.FMS[i]);
00378 if (i % 16 == 15) printf("\n");
00379 }
00380 }
00381
00382 inline void printQTBlock(const QTBlock& qt)
00383 {
00384 printName(qt.name);
00385 printf("length: %d\n", qt.length);
00386 printf("dataLoss: %d\n", qt.dataLoss);
00387 int len = qt.length-4;
00388 unsigned char* data = (unsigned char*)&qt.data;
00389 for (int i = 0; i < len; ++i) {
00390 printf("%02x ", data[i]);
00391 if (i % 16 == 15) printf("\n");
00392 }
00393 }
00394
00395 inline void printBELayerBlock(const BELayerBlock& bc1)
00396 {
00397 printName(bc1.name);
00398 printf("length: %d\n", bc1.length);
00399 printf("BEMClayer1:\n");
00400 for (int i = 0; i < 48; ++i) {
00401 printf("%04x ", bc1.BEMClayer1[i]);
00402 if (i % 8 == 7) printf("\n");
00403 }
00404 printf("EEMClayer1:\n");
00405 for (int i = 0; i < 16; ++i) {
00406 printf("%04x ", bc1.EEMClayer1[i]);
00407 if (i % 8 == 7) printf("\n");
00408 }
00409 printf("EEMC:\n");
00410 for (int i = 0; i < 144; ++i) {
00411 printf("%02x ", bc1.EEMC[i]);
00412 if (i % 16 == 15) printf("\n");
00413 }
00414 }
00415
00416 inline void printBWestBlock(const BWestBlock& bcw)
00417 {
00418 printName(bcw.name);
00419 printf("length: %d\n", bcw.length);
00420 printf("BEMCWest:\n");
00421 for (int i = 0; i < 240; ++i) {
00422 printf("%02x ", bcw.BEMCWest[i]);
00423 if (i % 16 == 15) printf("\n");
00424 }
00425 }
00426
00427 inline void printBEastBlock(const BEastBlock& bce)
00428 {
00429 printName(bce.name);
00430 printf("length: %d\n", bce.length);
00431 printf("BEMCEast:\n");
00432 for (int i = 0; i < 240; ++i) {
00433 printf("%02x ", bce.BEMCEast[i]);
00434 if (i % 16 == 15) printf("\n");
00435 }
00436 }
00437
00438 inline void printDataBlock(const DataBlock& dataBlock)
00439 {
00440 printName(dataBlock.name);
00441 printf("length: %d\n", dataBlock.length);
00442 }
00443
00444 #endif // TRG_UTIL_2009_HH
