FairRoot/PandaRoot
Public Member Functions | Private Attributes | List of all members
PndMvdReadInTBData Class Reference

#include <PndMvdReadInTBData.h>

Public Member Functions

 PndMvdReadInTBData ()
 
virtual ~PndMvdReadInTBData ()
 
void SetFileName (std::vector< TString > fileName)
 
void Init ()
 
Bool_t ReadInData (TClonesArray *sdsDigiContainer, TClonesArray *headerContainer, TClonesArray *allheaderContainer)
 
Bool_t ReadInRawData (std::ifstream *fileHandle, std::vector< ULong64_t > &rawData)
 
void AnalyzeData (std::vector< ULong64_t > &rawData, Double_t clockFrequency)
 
pixel BitAnalyzePixelData (ULong64_t &data)
 
frameHeader BitAnalyzeHeader (ULong64_t &header)
 
frameTrailer BitAnalyzeTrailer (ULong64_t &trailer)
 
std::pair< UInt_t, UInt_t > PixeladdressToMatrixAddress (UInt_t pixelglobaladdress)
 
void SetClockFrequency (Double_t val)
 
void SetFE (Int_t val)
 
UInt_t GetNonSequenctialFC () const
 
UInt_t GetDoubleHeader () const
 
UInt_t GetDoubleTrailer () const
 
UInt_t GetSuperFrameCount () const
 
UInt_t GetTotalHitCount () const
 
UInt_t GetCorrectHitCount () const
 
UInt_t GetPreFrameLossHitCount () const
 
UInt_t GetHammingLossHitCount () const
 
UInt_t GetCRCLossHitCount () const
 
UInt_t GetTotalFrameCount () const
 
UInt_t GetCorrectFrameCount () const
 
UInt_t GetHammingLossFrameCount () const
 
UInt_t GetCRCLossFrameCount () const
 
UInt_t GetTotalHeaderCount () const
 
UInt_t GetTotalTrailerCount () const
 
PndSdsDigiTopix4 ProcessData (ULong64_t &data, frameHeader &header, Double_t &clockFrequency)
 
ULong64_t ReflectBitsStream (ULong64_t crc, int bitnum)
 
ULong64_t CalculateCRCTableFast (std::vector< char > p, ULong64_t len)
 
void GenerateCRCTable ()
 
UShort_t CheckHammingCode (ULong64_t dataword, int dataword_length)
 
ULong64_t ConvertToPix4HammingToStandardHamming (ULong64_t topixhamming)
 
void AnalyzeToPixFrame (Double_t clockFrequency)
 
void SetVerbose (Int_t val)
 

Private Attributes

std::vector< TString > fFileNames
 
std::ifstream * fFileHandle
 
Double_t fClockFrequency
 
TClonesArray * fOutputArray
 
TClonesArray * fOutputArrayHeader
 
TClonesArray * fOutputArrayAllHeader
 
UInt_t fSuperFrameCount
 
UInt_t fOldFrameCount
 
UInt_t fOldAllHeaderCount
 
UInt_t fNonSequentialFC
 
UInt_t fHammingLossFrameCount
 
UInt_t fCRCLossFrameCount
 
UInt_t fTotalHitCount
 
UInt_t fPreFrameLossHitCount
 
UInt_t fHammingLossHitCount
 
UInt_t fCRCLossHitCount
 
UInt_t fCorrectHitCount
 
frameHeader fRecentFrameHeader
 
frameHeader fRecentAllFrameHeader
 
frameTrailer fRecentFrameTrailer
 
Bool_t fFirstHeader
 
Bool_t fHeaderPresent
 
Bool_t fTrailerPresent
 
UInt_t fDoubleHeader
 
UInt_t fDoubleTrailer
 
UInt_t fTotalHeaderCount
 
UInt_t fTotalTrailerCount
 
Int_t fVerbose
 
Int_t fFE
 
Int_t fFileCounter
 
UInt_t fDataCount
 
UInt_t fTotalFrameCount
 
UInt_t fCorrectFrameCount
 
std::vector< ULong64_t > fToPixFrame
 
TClonesArray * fDigiArray
 
const UInt_t fOrder
 
const ULong64_t fPolynom
 
const ULong64_t fCRCXor
 
const UInt_t fRefIn
 
const UInt_t fRefOut
 
ULong64_t fCRCMask
 
ULong64_t fCRCHighBit
 
ULong64_t fCRCInit_direct
 
ULong64_t fCRCTab [256]
 

Detailed Description

Definition at line 48 of file PndMvdReadInTBData.h.

Constructor & Destructor Documentation

PndMvdReadInTBData::PndMvdReadInTBData ( )

Definition at line 17 of file PndMvdReadInTBData.cxx.

References fCRCHighBit, fCRCMask, fOrder, and GenerateCRCTable().

17  : fDigiArray(0), fClockFrequency(0), fSuperFrameCount(0),
18  fOldFrameCount(0), fOldAllHeaderCount(0), fFirstHeader(kTRUE), fFE(-1),
19  fNonSequentialFC(0), fHammingLossFrameCount(0), fCRCLossFrameCount(0),
20  fTotalHitCount(0),fPreFrameLossHitCount(0), fHammingLossHitCount(0), fCRCLossHitCount(0), fCorrectHitCount(0),
21  fHeaderPresent(kFALSE), fTrailerPresent(kFALSE), fDoubleHeader(0), fDoubleTrailer(0), fVerbose(0),
22  fOrder(16), fPolynom(0x8005), fCRCXor(0x0000), fRefIn(0), fRefOut(0), fCRCInit_direct(0), fDataCount(0),
23  fFileCounter(0), fTotalFrameCount(0), fTotalHeaderCount(0), fTotalTrailerCount(0) {
24  // TODO Auto-generated constructor stub
25  fCRCMask = ((((unsigned long)1<<(fOrder-1))-1)<<1)|1;
26  fCRCHighBit = (unsigned long)1<<(fOrder-1);
27 
28  GenerateCRCTable();
29 }
PndMvdReadInTBData::fPolynom
const ULong64_t fPolynom
Definition: PndMvdReadInTBData.h:149
PndMvdReadInTBData::fDigiArray
TClonesArray * fDigiArray
Definition: PndMvdReadInTBData.h:145
PndMvdReadInTBData::fCRCXor
const ULong64_t fCRCXor
Definition: PndMvdReadInTBData.h:150
PndMvdReadInTBData::~PndMvdReadInTBData ( )
virtual

Definition at line 31 of file PndMvdReadInTBData.cxx.

References fFileHandle.

31  {
32  fFileHandle->close();
33  delete(fFileHandle);
34 }
PndMvdReadInTBData::fFileHandle
std::ifstream * fFileHandle
Definition: PndMvdReadInTBData.h:107

Member Function Documentation

void PndMvdReadInTBData::AnalyzeData ( std::vector< ULong64_t > &  rawData,
Double_t  clockFrequency 
)

Definition at line 429 of file PndMvdReadInTBData.cxx.

References AnalyzeToPixFrame(), BitAnalyzeHeader(), frameHeader::fChipAddress, fDoubleHeader, fDoubleTrailer, frameHeader::fECC, fFE, fFirstHeader, frameHeader::fFrameCount, fHeaderPresent, fOldAllHeaderCount, fOutputArrayAllHeader, fPreFrameLossHitCount, fRecentAllFrameHeader, fToPixFrame, fTotalFrameCount, fTotalHeaderCount, fTotalHitCount, fTotalTrailerCount, fTrailerPresent, fVerbose, and i.

Referenced by ReadInData().

430 {
431  if (fVerbose > 2) std::cout << "PndMvdReadInTBData::AnalyzeData rawData.size(): " << rawData.size() << std::endl;
432  for (int i = 0; i < rawData.size(); i++){
433  ULong_t header = rawData[i] & 0xC000000000;
434  header = header >> 38;
435  if (fFirstHeader) {
436  if (header == 1){
437  fFirstHeader = kFALSE;
438  } else {
439  continue;
440  }
441  }
442 
443  if (header == 1) // header word found
444  {
445  fTotalHeaderCount++;
446 
447  fRecentAllFrameHeader = BitAnalyzeHeader(rawData.at(i));
448 
449  Int_t deltaAllFrameCount = ((int)(fRecentAllFrameHeader.fFrameCount - fOldAllHeaderCount)<0 ?((fRecentAllFrameHeader.fFrameCount - fOldAllHeaderCount)+256) : (fRecentAllFrameHeader.fFrameCount - fOldAllHeaderCount));
450  new ((*fOutputArrayAllHeader)[fOutputArrayAllHeader->GetEntriesFast()]) PndSdsDigiTopix4Header(fRecentAllFrameHeader.fFrameCount, fFE, fRecentAllFrameHeader.fChipAddress, fRecentAllFrameHeader.fECC, fTotalHeaderCount, deltaAllFrameCount, 0, 0 );
451  if (deltaAllFrameCount > 1) std::cout << "-W- deltaAllFrameCount > 1: " << deltaAllFrameCount << std::endl;
452  fOldAllHeaderCount= fRecentAllFrameHeader.fFrameCount;
453 
454  if(fHeaderPresent==kTRUE)
455  {
456  // double header found, cant check previous data without trailer, clear vector
457  fDoubleHeader++;
458 
459  if (fVerbose > 1)
460  {
461  std::cout << "Double Header Found! count: " << fDoubleHeader << "| FE: " << fFE << std::hex << " last ToPixFrame element: "<< fToPixFrame.back()<< " new frame header " << rawData[i] << std::endl;
462  }
463  fPreFrameLossHitCount += fToPixFrame.size() -1;
464  fToPixFrame.clear();
465  // load new header into vector
466  fToPixFrame.push_back(rawData[i]);
467  }
468  else
469  {
470  // header found, start recording topix frame
471  fTrailerPresent=kFALSE;
472  fHeaderPresent=kTRUE;
473  fToPixFrame.push_back(rawData[i]);
474  }
475  }
476 
477  else if(header == 2) // trailer word found
478  {
479  fTotalTrailerCount++;
480  if(fTrailerPresent==kTRUE)
481  {
482  // double trailer found, cant give the hits a valid timestamp without the header, clear vector
483 
484  fToPixFrame.clear();
485  fDoubleTrailer++;
486  if (fVerbose > 1)
487  {
488  std::cout << "Double Trailer Found! Double header counter: " << fDoubleTrailer << std::endl;
489  }
490  }
491  else
492  {
493  if(fHeaderPresent==kTRUE)
494  {
495  // one topix frame found! Go and analyze the vector...
496  fHeaderPresent=kFALSE;
497  fTrailerPresent=kTRUE;
498  fToPixFrame.push_back(rawData[i]);
499  // if (fVerbose > 1)
500  // {
501  // std::cout << "ToPix Frame found! Go and analyze this amont of data: " << fToPixFrame.size() << std::endl;
502  //}
503 
504  fTotalFrameCount++;
505  AnalyzeToPixFrame(clockFrequency);
506  fToPixFrame.clear();
507  }
508  else
509  {
510  if (fVerbose > 1)
511  {
512  std::cout << "Trailer without header found! Double header counter: " << fDoubleHeader << std::endl;
513  }
514  // trailer without header, can happen at the beginning of the file or the header was not detected correctly
515  // this case is in principle impossible to enter
516  fPreFrameLossHitCount += fToPixFrame.size()-1 ;
517  fDoubleTrailer++;
518  fToPixFrame.clear();
519  continue;
520  }
521  }
522  }
523  else if(header==3) // data word found
524  {
525  fTotalHitCount++;
526  if(fHeaderPresent==kTRUE)
527  {
528  // found data while a active header is present, go and save the data
529  fToPixFrame.push_back(rawData[i]);
530 
531  }
532  else
533  {
534  // found data without a valid header, may happen at the beginning of the file or the header was detected
535  fPreFrameLossHitCount++;
536  continue;
537  }
538  }
539  else
540  {
541  // not interessting
542  }
543  }
544 }
i
Int_t i
Definition: run_full.C:25
PndMvdReadInTBData::fToPixFrame
std::vector< ULong64_t > fToPixFrame
Definition: PndMvdReadInTBData.h:143
PndSdsDigiTopix4Header
Data class to store the header of topix4 frames.
Definition: PndSdsDigiTopix4Header.h:23
PndMvdReadInTBData::fRecentAllFrameHeader
frameHeader fRecentAllFrameHeader
Definition: PndMvdReadInTBData.h:126
PndMvdReadInTBData::AnalyzeToPixFrame
void AnalyzeToPixFrame(Double_t clockFrequency)
Definition: PndMvdReadInTBData.cxx:282
PndMvdReadInTBData::fOutputArrayAllHeader
TClonesArray * fOutputArrayAllHeader
Definition: PndMvdReadInTBData.h:111
PndMvdReadInTBData::BitAnalyzeHeader
frameHeader BitAnalyzeHeader(ULong64_t &header)
Definition: PndMvdReadInTBData.cxx:546
void PndMvdReadInTBData::AnalyzeToPixFrame ( Double_t  clockFrequency)

Definition at line 282 of file PndMvdReadInTBData.cxx.

References BitAnalyzeHeader(), BitAnalyzeTrailer(), CalculateCRCTableFast(), CheckHammingCode(), ConvertToPix4HammingToStandardHamming(), frameHeader::fChipAddress, fCorrectHitCount, fCRCLossFrameCount, fCRCLossHitCount, frameHeader::fECC, fFE, frameHeader::fFrameCount, frameTrailer::fFrameCRC, fHammingLossFrameCount, fHammingLossHitCount, frameTrailer::fNEvents, fNonSequentialFC, fOldFrameCount, fOutputArray, fOutputArrayHeader, fRecentFrameHeader, fRecentFrameTrailer, fSuperFrameCount, fToPixFrame, fTotalFrameCount, fVerbose, i, ProcessData(), PndSdsDigiTopix4Header::SetNumberOfEvents(), and y.

Referenced by AnalyzeData().

283 {
284  if (fVerbose > 2)
285  {
286  std::cout << fFE << " PndMvdReadInTBData::AnalyzeToPixFrame: fToPixFrame size: " << std::dec << fToPixFrame.size() << " header " << std::hex << fToPixFrame[0] << std::endl;
287  }
288 
289 
290  ULong_t hammingcheck = CheckHammingCode(ConvertToPix4HammingToStandardHamming(fToPixFrame[0]),40);
291  if(hammingcheck!=0)
292  {
293  if (fVerbose > 1)
294  {
295  std::cout << "Wrong Hamming Code found! (Header) : " << std::hex<< fToPixFrame[0] << " Parity bits "<< hammingcheck << std::endl;
296  }
297  fHammingLossFrameCount++;
298  fHammingLossHitCount+= fToPixFrame.size()-2;
299  return;
300  }
301 
302  hammingcheck = CheckHammingCode(ConvertToPix4HammingToStandardHamming(fToPixFrame[fToPixFrame.size()-1]),40);
303  if(hammingcheck!=0)
304  {
305  if (fVerbose > 1)
306  {
307  std::cout << "Wrong Hamming Code found! (Trailer): " << std::hex<< fToPixFrame[0] << " Parity bits "<< hammingcheck << std::endl;
308  }
309  fHammingLossFrameCount++;
310  fHammingLossHitCount+= fToPixFrame.size()-2;
311  return;
312  }
313 
314  PndSdsDigiTopix4 recentPixel;
315 
316  std::vector<char> topix_data; // vector necessary to do crc check
317 
318  for(int i=1; i< fToPixFrame.size()-1;i++)
319  {
320  for(int j=0; j<8 ;j++)
321  {
322  if(j==0 or j==1 or j==2)
323  {
324  topix_data.push_back(0x00);
325  }
326  else
327  {
328  topix_data.push_back((fToPixFrame[i] >> (7-j)*2*4) & 0xff);
329  }
330  }
331  }
332 
333  ULong64_t crc_calculated = CalculateCRCTableFast(topix_data,topix_data.size());
334 
335  if(crc_calculated != ((fToPixFrame.back()>>6) & 0xffff))
336  {
337  fCRCLossFrameCount++;
338  fCRCLossHitCount += fToPixFrame.size()-2;
339  if(fVerbose == -1)
340  {
341  std::cout << fFE << " CRC WRONG! Frame will be deleted. Calculated CRC: " <<std::hex << crc_calculated << " topix CRC: "<< ((fToPixFrame.back()>>6) & 0xffff) << std::endl;
342 
343  for(int y=0; y< fToPixFrame.size(); y++)
344  {
345  if(y==0)
346  {
347  std::cout <<fFE << " " << std::hex << fToPixFrame[y] << " - FCount " << fRecentFrameHeader.fFrameCount << std::endl;
348  }
349  else
350  {
351  std::cout <<fFE << " " << std::hex << fToPixFrame[y] << std::endl;
352  }
353  }
354  std::cout << std::endl;
355  }
356  fToPixFrame.clear(); // delete topix frame due to negative CRC check.
357  return;
358  }
359 
360  for (int i=0; i < fToPixFrame.size(); i++)
361  {
362  ULong64_t header = (fToPixFrame[i] & 0xC000000000) >> 38;
363 
364  switch (header) {
365  case 1 :
366  {
367  fRecentFrameHeader = BitAnalyzeHeader(fToPixFrame[i]);
368 
369  if (fVerbose > 2) std::cout << fFE << " FrameHeader: rawData: " << std::hex << fToPixFrame[i] << " chip " << std::dec << fRecentFrameHeader.fChipAddress << " framecount " << fRecentFrameHeader.fFrameCount << std::endl;
370 
371  if (fOldFrameCount + 1 != fRecentFrameHeader.fFrameCount){
372  if (!(fOldFrameCount == 255 & fRecentFrameHeader.fFrameCount == 0)){
373  if (fVerbose > 1) std::cout << fFE << "-E- non sequential FC: " << fOldFrameCount << " " << fRecentFrameHeader.fFrameCount << std::endl;
374  fNonSequentialFC++;
375  }
376  }
377 
378  if (fOldFrameCount > fRecentFrameHeader.fFrameCount){
379  fSuperFrameCount++;
380  if (fVerbose > 1) std::cout << fFE << " SuperFrameCount increased: " << std::dec<< fSuperFrameCount << " oldFC " << fOldFrameCount << " recent FC " << fRecentFrameHeader.fFrameCount << std::endl;
381  }
382  //fOldFrameCount = fRecentFrameHeader.fFrameCount;
383  Int_t deltaFrameCount = ((int)(fRecentFrameHeader.fFrameCount - fOldFrameCount)<0 ?((fRecentFrameHeader.fFrameCount - fOldFrameCount)+256) : (fRecentFrameHeader.fFrameCount - fOldFrameCount));
384  // new ((*fOutputArrayHeader)[fOutputArrayHeader->GetEntriesFast()]) PndSdsDigiTopix4Header(fRecentFrameHeader.fFrameCount, fFE, fRecentFrameHeader.fChipAddress, fRecentFrameHeader.fECC, fTotalFrameCount,deltaFrameCount, 0, fToPixFrame.size()-2 );
385  new ((*fOutputArrayHeader)[fOutputArrayHeader->GetEntriesFast()]) PndSdsDigiTopix4Header(fRecentFrameHeader.fFrameCount, 0, fFE, fRecentFrameHeader.fECC, fTotalFrameCount,deltaFrameCount, 0, fToPixFrame.size()-2 );
386  if (deltaFrameCount > 1) std::cout << "-W- OutputArrayHeader deltaFrameCount > 1 " << deltaFrameCount << std::endl;
387  fOldFrameCount = fRecentFrameHeader.fFrameCount;
388  }
389  break;
390 
391  case 2 :
392  {
393  fRecentFrameTrailer = BitAnalyzeTrailer(fToPixFrame[i]);
394  if (fRecentFrameTrailer.fFrameCRC !=0 && (fToPixFrame.size() < 20))
395  {
396  // std::cout << fFE << " Frame counter " << fRecentFrameHeader.fFrameCount << std::endl;
397  if(fVerbose ==-1)
398  {
399  for(int y=0; y< fToPixFrame.size(); y++)
400  {
401  if(y==0)
402  {
403  std::cout <<fFE << " " << std::hex << fToPixFrame[y] << " - FCount " << fRecentFrameHeader.fFrameCount << std::endl;
404  }
405  else
406  {
407  std::cout <<fFE << " " << std::hex << fToPixFrame[y] << std::endl;
408  }
409  }
410  std::cout << std::endl;
411  }
412  }
413  if (fVerbose > 2) std::cout << fFE <<" FrameTrailer: nEvents " << fRecentFrameTrailer.fNEvents << " frame CRC: " << fRecentFrameTrailer.fFrameCRC << std::endl;
414 
415  PndSdsDigiTopix4Header * header_trailer =(PndSdsDigiTopix4Header*)(fOutputArrayHeader->Last());
416  header_trailer->SetNumberOfEvents(fRecentFrameTrailer.fNEvents);
417  }
418  break;
419 
420  case 3 : recentPixel = ProcessData(fToPixFrame[i], fRecentFrameHeader, clockFrequency);
421  if (fVerbose > 2) std::cout << fFE << " Pixel: " << recentPixel << std::endl;
422  new ((*fOutputArray)[fOutputArray->GetEntriesFast()]) PndSdsDigiTopix4(recentPixel);
423  fCorrectHitCount++;
424  break;
425  }
426  }
427 }
PndSdsDigiTopix4Header::SetNumberOfEvents
void SetNumberOfEvents(UInt_t noe)
Definition: PndSdsDigiTopix4Header.h:69
i
Int_t i
Definition: run_full.C:25
PndMvdReadInTBData::fOutputArrayHeader
TClonesArray * fOutputArrayHeader
Definition: PndMvdReadInTBData.h:110
PndSdsDigiTopix4
Data class to store the digi output of a pixel module.
Definition: PndSdsDigiTopix4.h:25
PndMvdReadInTBData::CalculateCRCTableFast
ULong64_t CalculateCRCTableFast(std::vector< char > p, ULong64_t len)
Definition: PndMvdReadInTBData.cxx:225
PndMvdReadInTBData::fOutputArray
TClonesArray * fOutputArray
Definition: PndMvdReadInTBData.h:109
PndMvdReadInTBData::ConvertToPix4HammingToStandardHamming
ULong64_t ConvertToPix4HammingToStandardHamming(ULong64_t topixhamming)
Definition: PndMvdReadInTBData.cxx:99
PndMvdReadInTBData::fToPixFrame
std::vector< ULong64_t > fToPixFrame
Definition: PndMvdReadInTBData.h:143
PndMvdReadInTBData::ProcessData
PndSdsDigiTopix4 ProcessData(ULong64_t &data, frameHeader &header, Double_t &clockFrequency)
Definition: PndMvdReadInTBData.cxx:598
PndMvdReadInTBData::fRecentFrameHeader
frameHeader fRecentFrameHeader
Definition: PndMvdReadInTBData.h:125
PndSdsDigiTopix4Header
Data class to store the header of topix4 frames.
Definition: PndSdsDigiTopix4Header.h:23
PndMvdReadInTBData::CheckHammingCode
UShort_t CheckHammingCode(ULong64_t dataword, int dataword_length)
Definition: PndMvdReadInTBData.cxx:65
PndMvdReadInTBData::BitAnalyzeTrailer
frameTrailer BitAnalyzeTrailer(ULong64_t &trailer)
Definition: PndMvdReadInTBData.cxx:560
y
Double_t y
Definition: createRootFscGeometryFile.C:159
PndMvdReadInTBData::fRecentFrameTrailer
frameTrailer fRecentFrameTrailer
Definition: PndMvdReadInTBData.h:127
PndMvdReadInTBData::BitAnalyzeHeader
frameHeader BitAnalyzeHeader(ULong64_t &header)
Definition: PndMvdReadInTBData.cxx:546
frameHeader PndMvdReadInTBData::BitAnalyzeHeader ( ULong64_t &  header)

Definition at line 546 of file PndMvdReadInTBData.cxx.

References frameHeader::fChipAddress, frameHeader::fECC, and frameHeader::fFrameCount.

Referenced by AnalyzeData(), and AnalyzeToPixFrame().

547 {
548  frameHeader tempHeader;
549  ULong_t temp = header;
550  tempHeader.fECC = temp & 0x3F;
551  temp = temp >> 18;
552  tempHeader.fFrameCount = temp & 0xFF;
553 
554  temp = temp >> 8;
555  tempHeader.fChipAddress = temp & 0xFFF;
556 
557  return tempHeader;
558 }
pixel PndMvdReadInTBData::BitAnalyzePixelData ( ULong64_t &  data)

Definition at line 576 of file PndMvdReadInTBData.cxx.

References pixel::fLeadingEdge, pixel::fPixelAddress, pixel::fTrailingEdge, and mrftools::grayToBin().

Referenced by ProcessData().

577 {
578  //le_dataword = ((dataword & 0x0000000000fff000)>>12);¬
579  //te_dataword = (dataword & 0x0000000000000fff);¬
580  //pixeladdress = ((dataword & 0x0000003fff000000)>>24);¬
581 
582  pixel tempPixel;
583  ULong_t temp = data;
584  tempPixel.fTrailingEdge = mrftools::grayToBin(temp & 0X0000000000000FFF);
585 
586  temp = temp >> 12;
587  tempPixel.fLeadingEdge = mrftools::grayToBin(temp & 0X0000000000000FFF);
588 
589  temp = temp >> 12;
590  tempPixel.fPixelAddress = temp & 0X00000000000003FFF;
591 
592 // if (fVerbose > 1) std::cout << "BitAnalyzePixelData: " << std::hex << data << " pixel " << std::dec << tempPixel.fPixelAddress << " " << tempPixel.fLeadingEdge << " " << tempPixel.fTrailingEdge << std::endl;
593 
594  return tempPixel;
595 
596 }
pixel::fLeadingEdge
UInt_t fLeadingEdge
Definition: PndMvdReadInTBData.h:44
mrftools::grayToBin
UInt_t grayToBin(UInt_t gray)
Converts gray encoded values to bianry values.
Definition: MvdOfflineTBAnalysis_Topix4/mrftools.cxx:73
pixel::fTrailingEdge
UInt_t fTrailingEdge
Definition: PndMvdReadInTBData.h:45
pixel::fPixelAddress
UInt_t fPixelAddress
Definition: PndMvdReadInTBData.h:41
frameTrailer PndMvdReadInTBData::BitAnalyzeTrailer ( ULong64_t &  trailer)

Definition at line 560 of file PndMvdReadInTBData.cxx.

References frameTrailer::fECC, frameTrailer::fFrameCRC, and frameTrailer::fNEvents.

Referenced by AnalyzeToPixFrame().

561 {
562  frameTrailer tempTrailer;
563  ULong_t temp = trailer;
564  tempTrailer.fECC = temp & 0x3F;
565 
566  temp = temp >> 6;
567  tempTrailer.fFrameCRC = temp & 0xFFFF;
568 
569  temp = temp >> 16;
570  tempTrailer.fNEvents = temp & 0xFFFF;
571 
572  return tempTrailer;
573 
574 }
ULong64_t PndMvdReadInTBData::CalculateCRCTableFast ( std::vector< char >  p,
ULong64_t  len 
)

Definition at line 225 of file PndMvdReadInTBData.cxx.

References fCRCInit_direct, fCRCMask, fCRCTab, fCRCXor, fOrder, fRefIn, fRefOut, and ReflectBitsStream().

Referenced by AnalyzeToPixFrame().

225  {
226 
227  // fast lookup table algorithm without augmented zero bytes, e.g. used in pkzip.
228  // only usable with polynom orders of 8, 16, 24 or 32.
229 
230  ULong64_t crc = fCRCInit_direct;
231 
232  std::vector<char>::iterator it=p.begin();
233 
234  if (fRefIn)
235  {
236  crc = ReflectBitsStream(crc, fOrder);
237  }
238 
239  if (!fRefIn)
240  {
241  while (len--)
242  {
243  crc = (crc << 8) ^ fCRCTab[ ((crc >> (fOrder-8)) & 0xff) ^ (*it & 0xff)];
244  it++;
245  }
246  }
247  else
248  {
249  while (len--)
250  {
251  crc = (crc >> 8) ^ fCRCTab[ (crc & 0xff) ^ (*it & 0xff)];
252  it++;
253  }
254  }
255  if (fRefOut^fRefIn)
256  {
257  crc = ReflectBitsStream(crc, fOrder);
258  }
259  crc^= fCRCXor;
260  crc&= fCRCMask;
261 
262  return(crc);
263 }
PndMvdReadInTBData::fCRCTab
ULong64_t fCRCTab[256]
Definition: PndMvdReadInTBData.h:157
p
Double_t p
Definition: anasim.C:58
PndMvdReadInTBData::fCRCXor
const ULong64_t fCRCXor
Definition: PndMvdReadInTBData.h:150
PndMvdReadInTBData::ReflectBitsStream
ULong64_t ReflectBitsStream(ULong64_t crc, int bitnum)
Definition: PndMvdReadInTBData.cxx:265
UShort_t PndMvdReadInTBData::CheckHammingCode ( ULong64_t  dataword,
int  dataword_length 
)

Definition at line 65 of file PndMvdReadInTBData.cxx.

References i.

Referenced by AnalyzeToPixFrame().

66 {
67  // This function expects a standard hamming encoded dataword (including hamming bits at 2^i positions) and returns the hamming bits
68  // If the dataword is correct, the hamming bits are 0
69  // If an error occured, the hamming bits are !=0
70  // If a 1-bit error occured, the hamming bits give the possions of the wrong bit
71 
72  ULong64_t shift=1;
73  ULong64_t hamming_code=0;
74 
75  if(dataword_length > 63)
76  {
77  std::cout << "Error: maximum length of datastream is 63" << std::endl;
78  return 0xffff;
79  }
80 
81  // loop over all hamming bits
82  for (int i = 0; pow(2,i) < dataword_length; ++i)
83  {
84  int start=pow(2,i);
85  int stepwidth=2*start;
86  int parity_bit=0;
87  for (int j = start; j < dataword_length+1; j+=stepwidth)
88  {
89  for (int k = j; k < j+stepwidth/2 && k < dataword_length+1; ++k)
90  {
91  parity_bit ^= ((dataword & (shift <<(k-1)))>> (k-1));
92  }
93  }
94  hamming_code += (parity_bit << i);
95  }
96  return hamming_code;
97 }
i
Int_t i
Definition: run_full.C:25
ULong64_t PndMvdReadInTBData::ConvertToPix4HammingToStandardHamming ( ULong64_t  topixhamming)

Definition at line 99 of file PndMvdReadInTBData.cxx.

Referenced by AnalyzeToPixFrame().

100 {
101  // The ToPix header and trailer data word consists of 34 data bits and 6 hamming bits.
102  // bit no: 39 38 37 36 35 9 8 7 6 5 4 3 2 1 0
103  // In a ToPix4 dataword the hamming bits are at the end of the word: (d34)(d33)(d32)(d31)(d30) ... (d04)(d03)(d02)(d01)(H 6)(H 5)(H 4)(H 3)(H 2)(H 1)
104  // At the standard hamming encoding the hamming bits are at the 2^i positions (d34)(d33)(d32)(d31)(d30) ... (d07)(d06)(d05)(d04)(H 3)(d03)(d02)(d01)(H 2)(H 1)
105  // This function expects a ToPix4 encoded dataword and moves the hamming bits at the end to the defined positions.
106 
107  ULong64_t standard_hamming = 0;
108 
109  standard_hamming = ( topixhamming & 0xff00000000);
110  standard_hamming += ((topixhamming & 0x00fffe0000) >> 1 );
111  standard_hamming += ((topixhamming & 0x000001fc00) >> 2 );
112  standard_hamming += ((topixhamming & 0x0000000380) >> 3 );
113  standard_hamming += ((topixhamming & 0x0000000040) >> 4 );
114 
115  standard_hamming += ((topixhamming & 0x0000000020) << 26 );
116  standard_hamming += ((topixhamming & 0x0000000010) << 11 );
117  standard_hamming += ((topixhamming & 0x0000000008) << 4 );
118  standard_hamming += ((topixhamming & 0x0000000004) << 1 );
119  standard_hamming += ( topixhamming & 0x0000000002);
120  standard_hamming += ( topixhamming & 0x0000000001);
121 
122  return standard_hamming;
123 }
void PndMvdReadInTBData::GenerateCRCTable ( )

Definition at line 36 of file PndMvdReadInTBData.cxx.

References fCRCHighBit, fCRCMask, fCRCTab, fOrder, fPolynom, fRefIn, i, and ReflectBitsStream().

Referenced by PndMvdReadInTBData().

36  {
37  // make CRC lookup table used by table algorithms
38  ULong64_t bit, crc;
39  for (int i=0; i<256; i++) {
40  crc=(ULong64_t)i;
41  if (fRefIn)
42  {
43  crc=ReflectBitsStream(crc, 8);
44  }
45  crc<<= fOrder-8;
46 
47  for (int j=0; j<8; j++)
48  {
49  bit = crc & fCRCHighBit;
50  crc<<= 1;
51  if (bit)
52  {
53  crc^= fPolynom;
54  }
55  }
56  if (fRefIn)
57  {
58  crc = ReflectBitsStream(crc, fOrder);
59  }
60  crc&= fCRCMask;
61  fCRCTab[i]= crc;
62  }
63 }
PndMvdReadInTBData::fPolynom
const ULong64_t fPolynom
Definition: PndMvdReadInTBData.h:149
i
Int_t i
Definition: run_full.C:25
PndMvdReadInTBData::fCRCTab
ULong64_t fCRCTab[256]
Definition: PndMvdReadInTBData.h:157
PndMvdReadInTBData::ReflectBitsStream
ULong64_t ReflectBitsStream(ULong64_t crc, int bitnum)
Definition: PndMvdReadInTBData.cxx:265
UInt_t PndMvdReadInTBData::GetCorrectFrameCount ( ) const
inline

Definition at line 89 of file PndMvdReadInTBData.h.

References fCorrectFrameCount.

89 {return fCorrectFrameCount;}
UInt_t PndMvdReadInTBData::GetCorrectHitCount ( ) const
inline

Definition at line 83 of file PndMvdReadInTBData.h.

References fCorrectHitCount.

83 {return fCorrectHitCount;}
UInt_t PndMvdReadInTBData::GetCRCLossFrameCount ( ) const
inline

Definition at line 91 of file PndMvdReadInTBData.h.

References fCRCLossFrameCount.

91 {return fCRCLossFrameCount;}
UInt_t PndMvdReadInTBData::GetCRCLossHitCount ( ) const
inline

Definition at line 86 of file PndMvdReadInTBData.h.

References fCRCLossHitCount.

86 {return fCRCLossHitCount;}
UInt_t PndMvdReadInTBData::GetDoubleHeader ( ) const
inline

Definition at line 77 of file PndMvdReadInTBData.h.

References fDoubleHeader.

77 {return fDoubleHeader;}
UInt_t PndMvdReadInTBData::GetDoubleTrailer ( ) const
inline

Definition at line 78 of file PndMvdReadInTBData.h.

References fDoubleTrailer.

78 {return fDoubleTrailer;}
UInt_t PndMvdReadInTBData::GetHammingLossFrameCount ( ) const
inline

Definition at line 90 of file PndMvdReadInTBData.h.

References fHammingLossFrameCount.

90 {return fHammingLossFrameCount;}
UInt_t PndMvdReadInTBData::GetHammingLossHitCount ( ) const
inline

Definition at line 85 of file PndMvdReadInTBData.h.

References fHammingLossHitCount.

85 {return fHammingLossHitCount;}
UInt_t PndMvdReadInTBData::GetNonSequenctialFC ( ) const
inline

Definition at line 76 of file PndMvdReadInTBData.h.

References fNonSequentialFC.

76 {return fNonSequentialFC;}
UInt_t PndMvdReadInTBData::GetPreFrameLossHitCount ( ) const
inline

Definition at line 84 of file PndMvdReadInTBData.h.

References fPreFrameLossHitCount.

84 {return fPreFrameLossHitCount;}
UInt_t PndMvdReadInTBData::GetSuperFrameCount ( ) const
inline

Definition at line 79 of file PndMvdReadInTBData.h.

References fSuperFrameCount.

79 {return fSuperFrameCount;}
UInt_t PndMvdReadInTBData::GetTotalFrameCount ( ) const
inline

Definition at line 88 of file PndMvdReadInTBData.h.

References fTotalFrameCount.

88 {return fTotalFrameCount;}
UInt_t PndMvdReadInTBData::GetTotalHeaderCount ( ) const
inline

Definition at line 93 of file PndMvdReadInTBData.h.

References fTotalHeaderCount.

93 {return fTotalHeaderCount;}
UInt_t PndMvdReadInTBData::GetTotalHitCount ( ) const
inline

Definition at line 82 of file PndMvdReadInTBData.h.

References fTotalHitCount.

82 {return fTotalHitCount;}
UInt_t PndMvdReadInTBData::GetTotalTrailerCount ( ) const
inline

Definition at line 94 of file PndMvdReadInTBData.h.

References fTotalTrailerCount.

94 {return fTotalTrailerCount;}
void PndMvdReadInTBData::Init ( )

Definition at line 125 of file PndMvdReadInTBData.cxx.

References fFileCounter, fFileHandle, and fFileNames.

125  {
126  //std::cout << "PndMvdReadInTBData::Init called" << std::endl;
127 // for (int i = 0; i < fFileName.size(); i++){
128  std::ifstream* ifs = new std::ifstream(fFileNames[fFileCounter], std::ios::binary);
129  std::cout << "File: " << fFileNames[fFileCounter] << " is good: " << ifs->good() << std::endl;
130  fFileCounter++;
131  fFileHandle=ifs;
132 // }
133 }
PndMvdReadInTBData::fFileHandle
std::ifstream * fFileHandle
Definition: PndMvdReadInTBData.h:107
PndMvdReadInTBData::fFileNames
std::vector< TString > fFileNames
Definition: PndMvdReadInTBData.h:106
std::pair< UInt_t, UInt_t > PndMvdReadInTBData::PixeladdressToMatrixAddress ( UInt_t  pixelglobaladdress)

Definition at line 612 of file PndMvdReadInTBData.cxx.

Referenced by ProcessData().

613 {
614  // Matrix: 32 columns x 20 rows
615 
616  UInt_t double_column_address =0;
617  UInt_t double_column_side=0;
618  UInt_t pixel_address=0;
619 
620  UInt_t matrix_column, matrix_row;
621 
622  UInt_t temp = pixelglobaladdress;
623 
624  pixel_address= temp & 0x7f; //todo check if this conversion is correct!
625  temp = temp >> 7;
626  double_column_side= temp & 0x1;
627  temp = temp >> 1;
628  double_column_address= temp & 0x3f;
629  temp = temp >> 6;
630 
631  // if (pixel_address > 127) {
632  // std::cout << "-E- PndMvdReadInTBData::PixeladdressToMatrixAddress PixelAddress > 128 " << pixel_address << std::endl;
633  // }
634 
635 
636 
637  // temp = temp >> 6;
638 
639 
640 
641  // if (fVerbose > 1) std::cout << "PixeladdressToMatrix rawData " << pixelglobaladdress << " dc " << double_column_address << " dcs " << double_column_side << " pixel " << pixel_address << std::endl;
642 
643  UInt_t sel = (double_column_address<<1) | (double_column_side);
644 
645  if(sel == 0)
646  {
647  matrix_row = pixel_address;
648  matrix_column = 1;
649  }
650  else if(sel ==1)
651  {
652  matrix_row = pixel_address;
653  matrix_column = 0;
654  }
655  else if(sel == 6)
656  {
657  matrix_row = pixel_address;
658  matrix_column = 19;
659  }
660  else if(sel == 7)
661  {
662  matrix_row = pixel_address;
663  matrix_column = 18;
664  }
665  else if (sel==2)
666  {
667  if (pixel_address <32)
668  {
669  matrix_row = pixel_address;
670  matrix_column = 3;
671  }
672  else if (pixel_address < 64)
673  {
674  matrix_row = 31 - (pixel_address-32);
675  matrix_column = 4;
676  }
677  else if (pixel_address < 96)
678  {
679  matrix_row = (pixel_address-64);
680  matrix_column = 7;
681  }
682  else if (pixel_address < 128)
683  {
684  matrix_row = 31 - (pixel_address-96);
685  matrix_column = 8;
686  }
687  }
688  else if (sel==3)
689  {
690  if (pixel_address <32)
691  {
692  matrix_row = pixel_address;
693  matrix_column = 2;
694  }
695  else if (pixel_address < 64)
696  {
697  matrix_row = 31 - (pixel_address-32);
698  matrix_column = 5;
699  }
700  else if (pixel_address < 96)
701  {
702  matrix_row = (pixel_address-64);
703  matrix_column = 6;
704  }
705  else if (pixel_address < 128)
706  {
707  matrix_row = 31 - (pixel_address-96);
708  matrix_column = 9;
709  }
710  }
711  else if (sel==4)
712  {
713  if (pixel_address < 32)
714  {
715  matrix_row = pixel_address;
716  matrix_column = 10;
717  }
718  else if (pixel_address < 64)
719  {
720  matrix_row = 31 - (pixel_address-32);
721  matrix_column = 13;
722  }
723  else if (pixel_address < 96)
724  {
725  matrix_row = (pixel_address-64);
726  matrix_column = 14;
727  }
728  else if (pixel_address < 128)
729  {
730  matrix_row = 31 - (pixel_address-96);
731  matrix_column = 17;
732  }
733  }
734  else if (sel==5)
735  {
736  if (pixel_address < 32)
737  {
738  matrix_row = pixel_address;
739  matrix_column = 11;
740  }
741  else if (pixel_address < 64)
742  {
743  matrix_row = 31 - (pixel_address-32);
744  matrix_column = 12;
745  }
746  else if (pixel_address < 96)
747  {
748  matrix_row = (pixel_address-64);
749  matrix_column = 15;
750  }
751  else if (pixel_address < 128)
752  {
753  matrix_row = 31 - (pixel_address-96);
754  matrix_column = 16;
755  }
756  }
757 
758  return std::pair<UInt_t, UInt_t>(matrix_column, matrix_row);
759 }
PndSdsDigiTopix4 PndMvdReadInTBData::ProcessData ( ULong64_t &  data,
frameHeader &  header,
Double_t &  clockFrequency 
)

Definition at line 598 of file PndMvdReadInTBData.cxx.

References BitAnalyzePixelData(), Double_t, fCorrectHitCount, fFE, frameHeader::fFrameCount, pixel::fLeadingEdge, pixel::fPixelAddress, fSuperFrameCount, fTotalHeaderCount, fTotalHitCount, pixel::fTrailingEdge, fVerbose, and PixeladdressToMatrixAddress().

Referenced by AnalyzeToPixFrame().

599 {
600  if (fVerbose > 1) std::cout << "PndMvdReadInTBData::ProcessData raw Data: " << data << std::endl;
601  pixel pixelData = BitAnalyzePixelData(data);
602  std::pair<UInt_t, UInt_t> pixelAddress = PixeladdressToMatrixAddress(pixelData.fPixelAddress);
603  Double_t timestamp = ((Double_t)fSuperFrameCount * 256. * 4096. + (Double_t)header.fFrameCount * 4096. + (Double_t)pixelData.fLeadingEdge)/clockFrequency * 1000.;
604  Double_t timestamp_independent = ((Double_t) fTotalHeaderCount * 4096. + (Double_t)pixelData.fLeadingEdge)/clockFrequency * 1000.;
605 
606  std::vector<Int_t> indices; // just for compatibility with PndSdsDigiPixel
607 // return PndSdsDigiTopix4(indices, 0, 0, fFE, pixelAddress.first, pixelAddress.second, pixelData.fLeadingEdge, pixelData.fTrailingEdge, header.fFrameCount, timestamp, fCorrectHitCount,fTotalHitCount, timestamp_independent);
608  return PndSdsDigiTopix4(indices, 0, fFE - 1, 0, pixelAddress.first, pixelAddress.second, pixelData.fLeadingEdge, pixelData.fTrailingEdge, header.fFrameCount, timestamp, fCorrectHitCount,fTotalHitCount, timestamp_independent);
609 
610 }
PndSdsDigiTopix4
Data class to store the digi output of a pixel module.
Definition: PndSdsDigiTopix4.h:25
pixel::fLeadingEdge
UInt_t fLeadingEdge
Definition: PndMvdReadInTBData.h:44
pixel::fTrailingEdge
UInt_t fTrailingEdge
Definition: PndMvdReadInTBData.h:45
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
PndMvdReadInTBData::PixeladdressToMatrixAddress
std::pair< UInt_t, UInt_t > PixeladdressToMatrixAddress(UInt_t pixelglobaladdress)
Definition: PndMvdReadInTBData.cxx:612
PndMvdReadInTBData::BitAnalyzePixelData
pixel BitAnalyzePixelData(ULong64_t &data)
Definition: PndMvdReadInTBData.cxx:576
pixel::fPixelAddress
UInt_t fPixelAddress
Definition: PndMvdReadInTBData.h:41
Bool_t PndMvdReadInTBData::ReadInData ( TClonesArray *  sdsDigiContainer,
TClonesArray *  headerContainer,
TClonesArray *  allheaderContainer 
)

Definition at line 135 of file PndMvdReadInTBData.cxx.

References AnalyzeData(), Bool_t, fClockFrequency, fFileHandle, fOutputArray, fOutputArrayAllHeader, fOutputArrayHeader, and ReadInRawData().

135  {
136  TMrfData_8b* tempdata;
137  tempdata = new TMrfData_8b;
138  ULong_t dataword=0;
139  Bool_t endOfFile = kFALSE;
140 
141  fOutputArray = sdsDigiContainer;
142  fOutputArrayHeader = headerContainer;
143  fOutputArrayAllHeader = allheaderContainer;
144  std::vector<ULong64_t> rawArray;
145  endOfFile |= ReadInRawData(fFileHandle, rawArray);
146  AnalyzeData(rawArray, fClockFrequency);
147  return endOfFile;
148 }
PndMvdReadInTBData::ReadInRawData
Bool_t ReadInRawData(std::ifstream *fileHandle, std::vector< ULong64_t > &rawData)
Definition: PndMvdReadInTBData.cxx:150
PndMvdReadInTBData::fOutputArrayHeader
TClonesArray * fOutputArrayHeader
Definition: PndMvdReadInTBData.h:110
PndMvdReadInTBData::fOutputArray
TClonesArray * fOutputArray
Definition: PndMvdReadInTBData.h:109
PndMvdReadInTBData::fFileHandle
std::ifstream * fFileHandle
Definition: PndMvdReadInTBData.h:107
TMrfData_8b
Base interface class for data storage and manipulation. Compatible with IO classes from MRF Suite...
Definition: MvdOfflineTBAnalysis_Topix4/mrfdata_8b.h:38
PndMvdReadInTBData::fOutputArrayAllHeader
TClonesArray * fOutputArrayAllHeader
Definition: PndMvdReadInTBData.h:111
PndMvdReadInTBData::AnalyzeData
void AnalyzeData(std::vector< ULong64_t > &rawData, Double_t clockFrequency)
Definition: PndMvdReadInTBData.cxx:429
Bool_t PndMvdReadInTBData::ReadInRawData ( std::ifstream *  fileHandle,
std::vector< ULong64_t > &  rawData 
)

Definition at line 150 of file PndMvdReadInTBData.cxx.

References Bool_t, fFE, fFileCounter, fFileHandle, fFileNames, fVerbose, TMrfData_8b::getNumWords(), TMrfData_8b::getWord(), and i.

Referenced by ReadInData().

150  {
151  TMrfData_8b* tempdata;
152  tempdata = new TMrfData_8b;
153  ULong_t dataword=0;
154  Bool_t endOfFile = kFALSE;
155  if(fileHandle->good())
156  {
157  if (fVerbose > 2)
158  {
159  std::cout << std::endl;
160  std::cout << "PndMvdReadInTBData::ReadInRawData reading file " << std::endl;
161  }
162  try
163  {
164  boost::archive::binary_iarchive iar(*fileHandle); //this line causes an "Invalid Signature Error" at the end of the file but the file is still good
165  iar >> tempdata;
166  }
167  catch (boost::archive::archive_exception& exception){
168  if (fVerbose > 1)
169  {
170  std::cout << "PndMvdReadInTBData::ReadInRawData: Error found in reading file " << " : " << fileHandle->good() << " " << fileHandle->eof() << " Exception: " << exception.code << std::endl;
171  }
172  if (fVerbose > 1)
173  {
174  std::cout << exception.what() << std::endl;
175  }
176  if (exception.code == 3)
177  {
178  if(fFileCounter < fFileNames.size())
179  {
180  std::cout <<fFE << " open new file " << fFileNames[fFileCounter] << std::endl;
181  fileHandle->close();
182  delete(fFileHandle);
183  std::ifstream* ifs = new std::ifstream(fFileNames[fFileCounter], std::ios::binary);
184  fFileCounter++;
185  return endOfFile;
186  }
187  else
188  {
189  std::cout <<fFE << " All files read! Finishing FE " << std::endl;
190  endOfFile = kTRUE;
191  return endOfFile;
192  }
193  }
194  }
195  if (fVerbose > 2) std::cout << fFE << " PndMvdReadInTBData::ReadInRawData: NWords: " << tempdata->getNumWords() << std::endl;
196  for (UInt_t i=0;i < tempdata->getNumWords();i+=5)
197  {
198  dataword=0;
199  for(uint j=0; j< 5 ; j++)
200  {
201  dataword = dataword << 8;
202  dataword += tempdata->getWord(i+j);
203  }
204  rawData.push_back(dataword);
205  ULong_t frameCount = dataword & 0x3FC0000;
206  frameCount = frameCount >> 18;
207  if (fVerbose > 2) std::cout << std::dec << "dataword No "<< i/5<< "/"<< tempdata->getNumWords()/5 << ": "<<std::hex << dataword << " " << std::dec << frameCount << std::endl;
208 
209  }
210  }
211  else
212  {
213  std::cout << fFE << " An error occured " << std::endl;
214  std::cout << fFE << " fileHandle->good() " << fileHandle->good() << std::endl;
215  std::cout << fFE << " fileHandle->eof() " << fileHandle->eof() << std::endl;
216  std::cout << fFE << " fileHandle->fail() " << fileHandle->fail() << std::endl;
217  std::cout << fFE << " fileHandle->bad() " << fileHandle->bad() << std::endl;
218 
219  endOfFile = kFALSE;
220  return endOfFile;
221  }
222  return endOfFile;
223 }
i
Int_t i
Definition: run_full.C:25
PndMvdReadInTBData::fFileHandle
std::ifstream * fFileHandle
Definition: PndMvdReadInTBData.h:107
TMrfData_8b
Base interface class for data storage and manipulation. Compatible with IO classes from MRF Suite...
Definition: MvdOfflineTBAnalysis_Topix4/mrfdata_8b.h:38
PndMvdReadInTBData::fFileNames
std::vector< TString > fFileNames
Definition: PndMvdReadInTBData.h:106
TMrfData_8b::getWord
const UChar_t & getWord(const UInt_t &position) const
Retrieves the word found at position.
Definition: MvdOfflineTBAnalysis_Topix4/mrfdata_8b.cxx:145
TMrfData_8b::getNumWords
const UInt_t & getNumWords() const
Retrieves the length of the register in words.
Definition: MvdOfflineTBAnalysis_Topix4/mrfdata_8b.cxx:57
ULong64_t PndMvdReadInTBData::ReflectBitsStream ( ULong64_t  crc,
int  bitnum 
)

Definition at line 265 of file PndMvdReadInTBData.cxx.

References i.

Referenced by CalculateCRCTableFast(), and GenerateCRCTable().

265  {
266 
267  // reflects the lower 'bitnum' bits of 'crc'
268 
269  ULong64_t i, j=1, crcout=0;
270 
271  for (i=(ULong64_t)1<<(bitnum-1); i; i>>=1)
272  {
273  if (crc & i)
274  {
275  crcout|=j;
276  }
277  j<<= 1;
278  }
279  return (crcout);
280 }
i
Int_t i
Definition: run_full.C:25
void PndMvdReadInTBData::SetClockFrequency ( Double_t  val)
inline

Definition at line 74 of file PndMvdReadInTBData.h.

References fClockFrequency, and val.

74 {fClockFrequency = val;}
val
Double_t val[nBoxes][nFEBox]
Definition: createCalib.C:11
void PndMvdReadInTBData::SetFE ( Int_t  val)
inline

Definition at line 75 of file PndMvdReadInTBData.h.

References fFE, and val.

75 {fFE = val;}
val
Double_t val[nBoxes][nFEBox]
Definition: createCalib.C:11
void PndMvdReadInTBData::SetFileName ( std::vector< TString >  fileName)
inline

Definition at line 52 of file PndMvdReadInTBData.h.

References fFileNames, and i.

52  {
53 
54  std::cout << "number of entires " << fileName.size() << std::endl;
55  for(int i=0; i < fileName.size();i++)
56  {
57  std::cout << i<< " " << fileName[i] << std::endl;
58  }
59  fFileNames= fileName;
60  }
i
Int_t i
Definition: run_full.C:25
PndMvdReadInTBData::fFileNames
std::vector< TString > fFileNames
Definition: PndMvdReadInTBData.h:106
void PndMvdReadInTBData::SetVerbose ( Int_t  val)
inline

Definition at line 103 of file PndMvdReadInTBData.h.

References fVerbose, and val.

103 {fVerbose = val;}
val
Double_t val[nBoxes][nFEBox]
Definition: createCalib.C:11

Member Data Documentation

Double_t PndMvdReadInTBData::fClockFrequency
private

Definition at line 108 of file PndMvdReadInTBData.h.

Referenced by ReadInData(), and SetClockFrequency().

UInt_t PndMvdReadInTBData::fCorrectFrameCount
private

Definition at line 142 of file PndMvdReadInTBData.h.

Referenced by GetCorrectFrameCount().

UInt_t PndMvdReadInTBData::fCorrectHitCount
private

Definition at line 123 of file PndMvdReadInTBData.h.

Referenced by AnalyzeToPixFrame(), GetCorrectHitCount(), and ProcessData().

ULong64_t PndMvdReadInTBData::fCRCHighBit
private

Definition at line 155 of file PndMvdReadInTBData.h.

Referenced by GenerateCRCTable(), and PndMvdReadInTBData().

ULong64_t PndMvdReadInTBData::fCRCInit_direct
private

Definition at line 156 of file PndMvdReadInTBData.h.

Referenced by CalculateCRCTableFast().

UInt_t PndMvdReadInTBData::fCRCLossFrameCount
private

Definition at line 117 of file PndMvdReadInTBData.h.

Referenced by AnalyzeToPixFrame(), and GetCRCLossFrameCount().

UInt_t PndMvdReadInTBData::fCRCLossHitCount
private

Definition at line 122 of file PndMvdReadInTBData.h.

Referenced by AnalyzeToPixFrame(), and GetCRCLossHitCount().

ULong64_t PndMvdReadInTBData::fCRCMask
private

Definition at line 154 of file PndMvdReadInTBData.h.

Referenced by CalculateCRCTableFast(), GenerateCRCTable(), and PndMvdReadInTBData().

ULong64_t PndMvdReadInTBData::fCRCTab[256]
private

Definition at line 157 of file PndMvdReadInTBData.h.

Referenced by CalculateCRCTableFast(), and GenerateCRCTable().

const ULong64_t PndMvdReadInTBData::fCRCXor
private

Definition at line 150 of file PndMvdReadInTBData.h.

Referenced by CalculateCRCTableFast().

UInt_t PndMvdReadInTBData::fDataCount
private

Definition at line 140 of file PndMvdReadInTBData.h.

TClonesArray* PndMvdReadInTBData::fDigiArray
private

Definition at line 145 of file PndMvdReadInTBData.h.

UInt_t PndMvdReadInTBData::fDoubleHeader
private

Definition at line 131 of file PndMvdReadInTBData.h.

Referenced by AnalyzeData(), and GetDoubleHeader().

UInt_t PndMvdReadInTBData::fDoubleTrailer
private

Definition at line 132 of file PndMvdReadInTBData.h.

Referenced by AnalyzeData(), and GetDoubleTrailer().

Int_t PndMvdReadInTBData::fFE
private

Definition at line 138 of file PndMvdReadInTBData.h.

Referenced by AnalyzeData(), AnalyzeToPixFrame(), ProcessData(), ReadInRawData(), and SetFE().

Int_t PndMvdReadInTBData::fFileCounter
private

Definition at line 139 of file PndMvdReadInTBData.h.

Referenced by Init(), and ReadInRawData().

std::ifstream* PndMvdReadInTBData::fFileHandle
private

Definition at line 107 of file PndMvdReadInTBData.h.

Referenced by Init(), ReadInData(), ReadInRawData(), and ~PndMvdReadInTBData().

std::vector<TString> PndMvdReadInTBData::fFileNames
private

Definition at line 106 of file PndMvdReadInTBData.h.

Referenced by Init(), ReadInRawData(), and SetFileName().

Bool_t PndMvdReadInTBData::fFirstHeader
private

Definition at line 128 of file PndMvdReadInTBData.h.

Referenced by AnalyzeData().

UInt_t PndMvdReadInTBData::fHammingLossFrameCount
private

Definition at line 116 of file PndMvdReadInTBData.h.

Referenced by AnalyzeToPixFrame(), and GetHammingLossFrameCount().

UInt_t PndMvdReadInTBData::fHammingLossHitCount
private

Definition at line 121 of file PndMvdReadInTBData.h.

Referenced by AnalyzeToPixFrame(), and GetHammingLossHitCount().

Bool_t PndMvdReadInTBData::fHeaderPresent
private

Definition at line 129 of file PndMvdReadInTBData.h.

Referenced by AnalyzeData().

UInt_t PndMvdReadInTBData::fNonSequentialFC
private

Definition at line 115 of file PndMvdReadInTBData.h.

Referenced by AnalyzeToPixFrame(), and GetNonSequenctialFC().

UInt_t PndMvdReadInTBData::fOldAllHeaderCount
private

Definition at line 114 of file PndMvdReadInTBData.h.

Referenced by AnalyzeData().

UInt_t PndMvdReadInTBData::fOldFrameCount
private

Definition at line 113 of file PndMvdReadInTBData.h.

Referenced by AnalyzeToPixFrame().

const UInt_t PndMvdReadInTBData::fOrder
private

Definition at line 148 of file PndMvdReadInTBData.h.

Referenced by CalculateCRCTableFast(), GenerateCRCTable(), and PndMvdReadInTBData().

TClonesArray* PndMvdReadInTBData::fOutputArray
private

Definition at line 109 of file PndMvdReadInTBData.h.

Referenced by AnalyzeToPixFrame(), and ReadInData().

TClonesArray* PndMvdReadInTBData::fOutputArrayAllHeader
private

Definition at line 111 of file PndMvdReadInTBData.h.

Referenced by AnalyzeData(), and ReadInData().

TClonesArray* PndMvdReadInTBData::fOutputArrayHeader
private

Definition at line 110 of file PndMvdReadInTBData.h.

Referenced by AnalyzeToPixFrame(), and ReadInData().

const ULong64_t PndMvdReadInTBData::fPolynom
private

Definition at line 149 of file PndMvdReadInTBData.h.

Referenced by GenerateCRCTable().

UInt_t PndMvdReadInTBData::fPreFrameLossHitCount
private

Definition at line 120 of file PndMvdReadInTBData.h.

Referenced by AnalyzeData(), and GetPreFrameLossHitCount().

frameHeader PndMvdReadInTBData::fRecentAllFrameHeader
private

Definition at line 126 of file PndMvdReadInTBData.h.

Referenced by AnalyzeData().

frameHeader PndMvdReadInTBData::fRecentFrameHeader
private

Definition at line 125 of file PndMvdReadInTBData.h.

Referenced by AnalyzeToPixFrame().

frameTrailer PndMvdReadInTBData::fRecentFrameTrailer
private

Definition at line 127 of file PndMvdReadInTBData.h.

Referenced by AnalyzeToPixFrame().

const UInt_t PndMvdReadInTBData::fRefIn
private

Definition at line 151 of file PndMvdReadInTBData.h.

Referenced by CalculateCRCTableFast(), and GenerateCRCTable().

const UInt_t PndMvdReadInTBData::fRefOut
private

Definition at line 152 of file PndMvdReadInTBData.h.

Referenced by CalculateCRCTableFast().

UInt_t PndMvdReadInTBData::fSuperFrameCount
private

Definition at line 112 of file PndMvdReadInTBData.h.

Referenced by AnalyzeToPixFrame(), GetSuperFrameCount(), and ProcessData().

std::vector<ULong64_t> PndMvdReadInTBData::fToPixFrame
private

Definition at line 143 of file PndMvdReadInTBData.h.

Referenced by AnalyzeData(), and AnalyzeToPixFrame().

UInt_t PndMvdReadInTBData::fTotalFrameCount
private

Definition at line 141 of file PndMvdReadInTBData.h.

Referenced by AnalyzeData(), AnalyzeToPixFrame(), and GetTotalFrameCount().

UInt_t PndMvdReadInTBData::fTotalHeaderCount
private

Definition at line 134 of file PndMvdReadInTBData.h.

Referenced by AnalyzeData(), GetTotalHeaderCount(), and ProcessData().

UInt_t PndMvdReadInTBData::fTotalHitCount
private

Definition at line 119 of file PndMvdReadInTBData.h.

Referenced by AnalyzeData(), GetTotalHitCount(), and ProcessData().

UInt_t PndMvdReadInTBData::fTotalTrailerCount
private

Definition at line 135 of file PndMvdReadInTBData.h.

Referenced by AnalyzeData(), and GetTotalTrailerCount().

Bool_t PndMvdReadInTBData::fTrailerPresent
private

Definition at line 130 of file PndMvdReadInTBData.h.

Referenced by AnalyzeData().

Int_t PndMvdReadInTBData::fVerbose
private

Definition at line 137 of file PndMvdReadInTBData.h.

Referenced by AnalyzeData(), AnalyzeToPixFrame(), ProcessData(), ReadInRawData(), and SetVerbose().

The documentation for this class was generated from the following files:
Generated on Sun Aug 18 2019 03:03:55 for FairRoot/PandaRoot by   doxygen 1.8.8