StRoot: StDaqLib/FPD/FPD_Reader.cxx Source File

00001 /***************************************************************************
00002 * $Id: FPD_Reader.cxx,v 1.4 2007/12/24 06:04:11 fine Exp $
00003 * Author: Akio Ogawa
00004 ***************************************************************************
00005 * Description:  FPD Event Reader
00006 ***************************************************************************
00007 * $Log: FPD_Reader.cxx,v $
00008 * Revision 1.4  2007/12/24 06:04:11  fine
00009 * introduce OLDEVP namespace to allow ole and new EVP library concurrently
00010 *
00011 * Revision 1.3  2003/10/02 22:33:35  jeromel
00012 * Cosmetic change
00013 *
00014 * Revision 1.2  2003/05/22 20:48:17  perev
00015 * method added to remove unprintef chars
00016 *
00017 * Revision 1.1  2002/01/17 17:19:58  akio
00018 * First version of FPD daq reader
00019 *
00020 **************************************************************************/
00021 #include "FPD_Reader.hh"
00022 
00023 using namespace OLDEVP;
00024 
00025 void FPD_Reader::ProcessEvent(const Bank_FPDP * FpdPTR) {
00026   unsigned short numberOfDataWords;
00027   int dataDWord;
00028   //FpdPTR->print();
00029   unsigned short Token = FpdPTR->header.Token;
00030   if (Token==0){
00031     cout << "FPD_Reader: do not know how to handle token==0"<<endl;
00032     //return;
00033   }
00034   mTheFpdArray.EventNumber = Token;
00035   mTheFpdArray.ByteSwapped = 0x04030201;
00036 
00037   //Read ADC Bank
00038   FPDDATA * FpdAdcD;
00039   if (FpdPTR->AdcPTR.length>0) {
00040     FpdAdcD = (FPDDATA *) ((unsigned long *)FpdPTR + FpdPTR->AdcPTR.offset);
00041     //FpdAdcD->print();
00042 
00043     FpdAdcD->swap();
00044     cout << "FPD_Reader(FPDADCD): Got a bank named " << FpdAdcD->bankTypeString() << endl;
00045     if (FpdAdcD->header.Token!=Token){
00046       cout << "FPD_Reader: Token mismatch FPDP "<< Token<<" "
00047            << " FPDADCD " << FpdAdcD->header.Token << endl;
00048       mTheFpdArray.EventNumber=0;
00049     }
00050     numberOfDataWords=FpdAdcD->header.BankLength - (INT32)sizeof(FpdAdcD->header)/4;
00051     if (numberOfDataWords!=FPDP_NUM_ADC_CHANNELS/2){
00052       cout << "FPD_Reader: ADCD #channels mismatch " << numberOfDataWords  << endl;
00053       if (numberOfDataWords>FPDP_NUM_ADC_CHANNELS/2) numberOfDataWords=FPDP_NUM_ADC_CHANNELS/2;
00054     }
00055     // decode and fill data structure
00056     for (dataDWord=0; dataDWord < numberOfDataWords*2; dataDWord++) {
00057       mTheFpdArray.AdcData[dataDWord]=FpdAdcD->data[dataDWord];
00058     }    
00059   }
00060 
00061   //Read TDC Bank
00062   FPDDATA * FpdTdcD;
00063   if (FpdPTR->TdcPTR.length>0) {
00064     FpdTdcD = (FPDDATA *) ((unsigned long *)FpdPTR + FpdPTR->TdcPTR.offset);
00065     //FpdTdcD->print();
00066     FpdTdcD->swap();
00067     cout << "FPD_Reader(FPDTDCD): Got a bank named " << FpdTdcD->bankTypeString() << endl;
00068     if (FpdTdcD->header.Token!=Token){
00069       cout << "FPD_Reader: Token mismatch FPDP "<< Token 
00070            << " FPDTDCD " << FpdTdcD->header.Token << endl;
00071       mTheFpdArray.EventNumber=0;
00072     }
00073     numberOfDataWords=FpdTdcD->header.BankLength - (INT32)sizeof(FpdTdcD->header)/4;
00074     if (numberOfDataWords!=FPDP_NUM_TDC_CHANNELS/2){
00075       cout << "FPD_Reader: TDCD #channels mismatch " << numberOfDataWords  << endl;
00076       if (numberOfDataWords>FPDP_NUM_TDC_CHANNELS/2) numberOfDataWords=FPDP_NUM_TDC_CHANNELS/2;
00077     }
00078     // decode and fill data structure
00079     for (dataDWord=0; dataDWord < numberOfDataWords*2; dataDWord++) {
00080       mTheFpdArray.TdcData[dataDWord]=FpdTdcD->data[dataDWord];
00081     }    
00082   }
00083 
00084   //Read REG Bank...
00085   FPDDATA * FpdRegD;
00086   if (FpdPTR->RegPTR.length>0) {
00087     FpdRegD = (FPDDATA *) ((unsigned long *)FpdPTR + FpdPTR->RegPTR.offset);
00088     //FpdRegD->print();
00089     FpdRegD->swap();
00090     cout << "FPD_Reader(FPDREGD): Got a bank named " << FpdRegD->bankTypeString() << endl;
00091     if (FpdRegD->header.Token!=Token){
00092       cout << "FPD_Reader: Token mismatch FPDP "<< Token 
00093            << " FPDREGD " << FpdRegD->header.Token << endl;
00094       mTheFpdArray.EventNumber=0;
00095     }
00096     numberOfDataWords=FpdRegD->header.BankLength - (INT32)sizeof(FpdRegD->header)/4;
00097     if (numberOfDataWords!=FPDP_NUM_REG_CHANNELS/2){
00098       cout << "FPD_Reader: REGD #channels mismatch " << numberOfDataWords  << endl;
00099       if (numberOfDataWords>FPDP_NUM_REG_CHANNELS/2) numberOfDataWords=FPDP_NUM_REG_CHANNELS/2;
00100     }
00101     // decode and fill data structure
00102     for (dataDWord=0; dataDWord < numberOfDataWords*2; dataDWord++) {
00103       mTheFpdArray.RegData[dataDWord]=FpdRegD->data[dataDWord];
00104     }    
00105   }
00106 
00107   //Read PED Bank
00108   FPDDATA * FpdPedD;
00109   if (FpdPTR->PedPTR.length>0) {
00110     FpdPedD = (FPDDATA *) ((unsigned long *)FpdPTR + FpdPTR->PedPTR.offset);
00111     //FpdPedD->print();
00112     FpdPedD->swap();
00113     cout << "FPD_Reader(FPDPEDD): Got a bank named " << FpdPedD->bankTypeString() << endl;
00114     if (FpdPedD->header.Token!=Token){
00115       cout << "FPD_Reader: Token mismatch FPDP "<< Token 
00116            << " FPDPEDD " << FpdPedD->header.Token << endl;
00117       mTheFpdArray.EventNumber=0;
00118     }
00119     numberOfDataWords=FpdPedD->header.BankLength - (INT32)sizeof(FpdPedD->header)/4;
00120     if (numberOfDataWords!=FPDP_NUM_PED_CHANNELS/2){
00121       cout << "FPD_Reader: PEDD #channels mismatch " << numberOfDataWords  << endl;
00122       if (numberOfDataWords>FPDP_NUM_PED_CHANNELS/2) numberOfDataWords=FPDP_NUM_PED_CHANNELS/2;
00123     }
00124     // decode and fill data structure
00125     for (dataDWord=0; dataDWord < numberOfDataWords*2; dataDWord++) {
00126       mTheFpdArray.PedData[dataDWord]=FpdPedD->data[dataDWord];
00127     }
00128   }
00129 
00130   //Read SCL Bank
00131   FPDSCLDATA * FpdSclD;
00132   if (FpdPTR->SclPTR.length>0) {
00133     FpdSclD = (FPDSCLDATA *) ((unsigned long *)FpdPTR + FpdPTR->SclPTR.offset);
00134     //FpdSclD->print();
00135     FpdSclD->swap();
00136     cout << "FPD_Reader(FPDSCL): Got a bank named " << FpdSclD->bankTypeString() << endl;
00137     if (FpdSclD->header.Token!=Token){
00138       cout << "FPD_Reader: Token mismatch FPDP "<< Token 
00139            << " FPDSCL " << FpdSclD->header.Token << endl;
00140       mTheFpdArray.EventNumber=0;
00141     }
00142     numberOfDataWords=FpdSclD->header.BankLength - (INT32)sizeof(FpdSclD->header)/4;
00143     if (numberOfDataWords!=FPDP_NUM_SCL_CHANNELS){
00144       cout << "FPD_Reader: SCLD #channels mismatch " << numberOfDataWords  << endl;
00145       if (numberOfDataWords>FPDP_NUM_SCL_CHANNELS) numberOfDataWords=FPDP_NUM_SCL_CHANNELS;
00146     }
00147     // decode and fill data structure
00148     for (dataDWord=0; dataDWord < numberOfDataWords; dataDWord++) {
00149       mTheFpdArray.SclData[dataDWord]=FpdSclD->data[dataDWord];
00150     }
00151   }
00152 
00153   //Read BBC ADC Bank
00154   FPDDATA * BbcAdcD;
00155   if (FpdPTR->BbcAdcPTR.length>0) {
00156     BbcAdcD = (FPDDATA *) ((unsigned long *)FpdPTR + FpdPTR->BbcAdcPTR.offset);
00157     //FpdPedD->print();
00158     BbcAdcD->swap();
00159     cout << "FPD_Reader(BBCDAT): Got a bank named " << BbcAdcD->bankTypeString() << endl;
00160     if (BbcAdcD->header.Token!=Token){
00161       cout << "FPD_Reader: Token mismatch FPDP "<< Token 
00162            << " BBCDAT " << BbcAdcD->header.Token << endl;
00163       mTheFpdArray.EventNumber=0;
00164     }
00165     numberOfDataWords=BbcAdcD->header.BankLength - (INT32)sizeof(BbcAdcD->header)/4;
00166     if (numberOfDataWords!=FPDP_BBC_NUM_ADC_CHANNELS/2){
00167       cout << "FPD_Reader: BBCDAT #channels mismatch " << numberOfDataWords  << endl;
00168       if (numberOfDataWords>FPDP_BBC_NUM_ADC_CHANNELS/2) numberOfDataWords=FPDP_BBC_NUM_ADC_CHANNELS/2;
00169     }
00170     // decode and fill data structure
00171     for (dataDWord=0; dataDWord < numberOfDataWords*2; dataDWord++) {
00172       mTheFpdArray.BbcAdcData[dataDWord]=BbcAdcD->data[dataDWord];
00173     }
00174   }
00175 
00176   //Read BBC Pedestal Bank
00177   FPDDATA * BbcPedD;
00178   if (FpdPTR->BbcPedPTR.length>0) {
00179     BbcPedD = (FPDDATA *) ((unsigned long *)FpdPTR + FpdPTR->BbcPedPTR.offset);
00180     //FpdPedD->print();
00181     BbcPedD->swap();
00182     cout << "FPD_Reader(BBCPED): Got a bank named " << BbcPedD->bankTypeString() << endl;
00183     if (BbcPedD->header.Token!=Token){
00184       cout << "FPD_Reader: Token mismatch FPDP "<< Token 
00185            << " BBCPED " << BbcPedD->header.Token << endl;
00186       mTheFpdArray.EventNumber=0;
00187     }
00188     numberOfDataWords=BbcPedD->header.BankLength - (INT32)sizeof(BbcPedD->header)/4;
00189     if (numberOfDataWords!=FPDP_BBC_NUM_PED_CHANNELS/2){
00190       cout << "FPD_Reader: BBCPED #channels mismatch " << numberOfDataWords  << endl;
00191       if (numberOfDataWords>FPDP_BBC_NUM_PED_CHANNELS/2) numberOfDataWords=FPDP_BBC_NUM_PED_CHANNELS/2;
00192     }
00193     // decode and fill data structure
00194     for (dataDWord=0; dataDWord < numberOfDataWords*2; dataDWord++) {
00195       mTheFpdArray.BbcPedData[dataDWord]=BbcPedD->data[dataDWord];
00196     }
00197   }
00198   //Read BBC Scalar Bank
00199   FPDSCLDATA * BbcSclD;
00200   if (FpdPTR->BbcSclPTR.length>0) {
00201     BbcSclD = (FPDSCLDATA *) ((unsigned long *)FpdPTR + FpdPTR->BbcSclPTR.offset);
00202     //FpdPedD->print();
00203     BbcSclD->swap();
00204     cout << "FPD_Reader(BBCSCL): Got a bank named " << BbcSclD->bankTypeString() << endl;
00205     if (BbcSclD->header.Token!=Token){
00206       cout << "FPD_Reader: Token mismatch FPDP "<< Token 
00207            << " BBCSCLD " << BbcSclD->header.Token << endl;
00208       mTheFpdArray.EventNumber=0;
00209     }
00210     numberOfDataWords=BbcSclD->header.BankLength - (INT32)sizeof(BbcSclD->header)/4;
00211     if (numberOfDataWords!=FPDP_BBC_NUM_SCL_CHANNELS){
00212       cout << "FPD_Reader: BBCSCL #channels mismatch " << numberOfDataWords  << endl;
00213       if (numberOfDataWords>FPDP_BBC_NUM_SCL_CHANNELS) numberOfDataWords=FPDP_BBC_NUM_SCL_CHANNELS/2;
00214     }
00215     // decode and fill data structure
00216     for (dataDWord=0; dataDWord < numberOfDataWords; dataDWord++) {
00217       mTheFpdArray.BbcSclData[dataDWord]=BbcSclD->data[dataDWord];
00218     }
00219   }
00220 
00221 }
00222 
00223 FPD_Reader::FPD_Reader(EventReader *er, Bank_FPDP *pFPDP)
00224 {
00225   pBankFPDP = pFPDP; 
00226   ercpy = er;
00227   if (!pBankFPDP->test_CRC()) {
00228     printf("CRC error in FPDP: %s %d\n",__FILE__,__LINE__) ;
00229   }
00230   if (pBankFPDP->swap() < 0) {
00231     printf("swap error in FPDP: %s %d\n",__FILE__,__LINE__) ;
00232   }
00233 
00234   pBankFPDP->header.CRC = 0;
00235   int Token = pBankFPDP->header.Token;
00236   Bank_DATAP *dp = (Bank_DATAP *)ercpy->getDATAP();
00237   if(Token != dp->header.Token){
00238     printf("Token mismatch between global %d and FPD %d\n",dp->header.Token,Token);
00239   }
00240   ProcessEvent(pBankFPDP);
00241 }
00242 
00243 
00244 unsigned short FPD_Reader::GetAdc(int id){
00245   if ((id<0) || (id>FPDP_NUM_ADC_CHANNELS-1)){
00246     cout << "FPD_Reader::GetAdc id out of range " << id << endl;
00247     return 0;
00248   }
00249   return mTheFpdArray.AdcData[id];
00250 }
00251 
00252 
00253 unsigned short FPD_Reader::GetTdc(int id){
00254   if ((id<0) || (id>FPDP_NUM_TDC_CHANNELS-1)){
00255     cout << "FPD_Reader::GetTdc id out of range " << id << endl;
00256     return 0;
00257   }
00258   return mTheFpdArray.TdcData[id];
00259 }
00260 
00261 unsigned short FPD_Reader::GetReg(int id){
00262   if ((id<0) || (id>FPDP_NUM_REG_CHANNELS-1)){
00263     cout << "FPD_Reader::GetReg id out of range " << id << endl;
00264     return 0;
00265   }
00266   return mTheFpdArray.RegData[id];
00267 }
00268 
00269 unsigned short FPD_Reader::GetPed(int id){
00270   if ((id<0) || (id>FPDP_NUM_PED_CHANNELS-1)){
00271     cout << "FPD_Reader::GetPed id out of range " << id << endl;
00272     return 0;
00273   }
00274   return mTheFpdArray.PedData[id];
00275 }
00276 
00277 unsigned int FPD_Reader::GetScl(int id){
00278   if ((id<0) || (id>FPDP_NUM_SCL_CHANNELS-1)){
00279     cout << "FPD_Reader::GetScl id out of range " << id << endl;
00280     return 0;
00281   }
00282   return mTheFpdArray.SclData[id];
00283 }
00284 
00285 unsigned short FPD_Reader::GetBbcAdc(int id){
00286   if ((id<0) || (id>FPDP_BBC_NUM_ADC_CHANNELS-1)){
00287     cout << "FPD_Reader::GetBbcAdc id out of range " << id << endl;
00288     return 0;
00289   }
00290   return mTheFpdArray.BbcAdcData[id];
00291 }
00292 
00293 unsigned short FPD_Reader::GetBbcPed(int id){
00294   if ((id<0) || (id>FPDP_BBC_NUM_PED_CHANNELS-1)){
00295     cout << "FPD_Reader::GetBbcPed id out of range " << id << endl;
00296     return 0;
00297   }
00298   return mTheFpdArray.BbcPedData[id];
00299 }
00300 
00301 unsigned int FPD_Reader::GetBbcScl(int id){
00302   if ((id<0) || (id>FPDP_BBC_NUM_SCL_CHANNELS-1)){
00303     cout << "FPD_Reader::GetBbcScl id out of range " << id << endl;
00304     return 0;
00305   }
00306   return mTheFpdArray.BbcSclData[id];
00307 }
00308 
00309 unsigned int FPD_Reader::GetEventNumber(){
00310   return mTheFpdArray.EventNumber;
00311 }
00312 
00313 void FPD_Reader::printRawData(){
00314   cout << "StDaqLib/FPD/FPD_Reader  Printing Raw Data...";
00315   cout << "\n --- ADCD: ";
00316   for (int i=0;i<FPDP_NUM_ADC_CHANNELS;i++) cout << " " << mTheFpdArray.AdcData[i];
00317   cout << "\n --- TDCD: ";
00318   for (int i=0;i<FPDP_NUM_TDC_CHANNELS;i++) cout << " " << mTheFpdArray.TdcData[i];
00319   cout << "\n --- REG: ";
00320   for (int i=0;i<FPDP_NUM_REG_CHANNELS;i++) cout << " " << mTheFpdArray.RegData[i];
00321   cout << "\n --- PED: ";
00322   for (int i=0;i<FPDP_NUM_PED_CHANNELS;i++) cout << " " << mTheFpdArray.PedData[i];
00323   cout << "\n --- SCL: ";
00324   for (int i=0;i<FPDP_NUM_SCL_CHANNELS;i++) cout << " " << mTheFpdArray.SclData[i];
00325   cout << "\n --- BBC ADC: ";
00326   for (int i=0;i<FPDP_BBC_NUM_ADC_CHANNELS;i++) cout << " " << mTheFpdArray.BbcAdcData[i];
00327   cout << "\n --- BBC Ped: ";
00328   for (int i=0;i<FPDP_BBC_NUM_PED_CHANNELS;i++) cout << " " << mTheFpdArray.BbcPedData[i];
00329   cout << "\n --- BBC ADC: ";
00330   for (int i=0;i<FPDP_BBC_NUM_SCL_CHANNELS;i++) cout << " " << mTheFpdArray.BbcSclData[i];
00331   cout << "\nStDaqLib/FPD/FPD_Reader  Done Printing Raw Data..." << endl;
00332 }