PndMvdReadInToPix4TBData Class Reference

#include <PndMvdReadInToPix4TBData.h>

Public Types
enum	{   SuperFrameCount = 0, NonSequentialFC, HammingLossFrameCount, CRCLossFrameCount,   TotalHitCount, PreFrameLossHitCount, HammingLossHitCount, CRCLossHitCount,   CorrectHitCount, DoubleHeader, DoubleTrailer, TotalHeaderCount,   TotalTrailerCount, TotalFrameCount, NFilteredHits, Last }

Public Member Functions
	PndMvdReadInToPix4TBData ()
virtual	~PndMvdReadInToPix4TBData ()
void	SetFileName (std::vector< std::string > fileName)
void	SetFileName (std::string fileName)
void	Init ()
Bool_t	ReadInData (std::vector< std::vector< PndSdsDigiTopix4 > > &data)
virtual Bool_t	ReadInDataFromFile (TMrfData_8b *&data)
std::vector< std::vector < PndSdsDigiTopix4 > >	AnalyzeData (std::vector< ULong64_t > &rawData, Double_t clockFrequency)
bool	BuildFrame (ULong64_t &rawData)
Int_t	GetDeltaFrameCount ()
PndSdsDigiTopix4	ProcessData (ULong64_t &data, ToPix4::frameHeader &header, Double_t &clockFrequency)
std::vector< PndSdsDigiTopix4 >	AnalyzeToPixFrame (Double_t clockFrequency)
bool	CheckDataIntegrity (std::vector< ULong64_t > topix4Frame)
void	SetClockFrequency (Double_t val)
void	SetTimeStampCorrection (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
std::vector< int >	GetStatusValues () const
Int_t	GetNFilteredHits ()
Bool_t	HitToFilter (PndSdsDigiTopix4 &hit)
void	SetFilter (Bool_t val)
void	SetVerbose (Int_t val)

Private Attributes
std::vector< std::string >	fFileNames
std::ifstream *	fFileHandle
Double_t	fClockFrequency
Double_t	fTimeStampCorrection
std::vector< int >	fStatusValues
UInt_t	fOldFrameCount
UInt_t	fOldAllHeaderCount
UInt_t	fSuperFrameCount
UInt_t	fNonSequentialFC
UInt_t	fHammingLossFrameCount
UInt_t	fCRCLossFrameCount
UInt_t	fTotalHitCount
UInt_t	fPreFrameLossHitCount
UInt_t	fHammingLossHitCount
UInt_t	fCRCLossHitCount
UInt_t	fCorrectHitCount
Bool_t	fFilter
UInt_t	fNFilteredHits
ToPix4::frameHeader	fRecentFrameHeader
ToPix4::frameHeader	fRecentAllFrameHeader
ToPix4::frameTrailer	fRecentFrameTrailer
Bool_t	fFirstHeader
Bool_t	fHeaderPresent
Bool_t	fTrailerPresent
UInt_t	fDoubleHeader
UInt_t	fDoubleTrailer
UInt_t	fTotalHeaderCount
UInt_t	fTotalTrailerCount
UInt_t	fTotalFrameCount
UInt_t	fCorrectFrameCount
Int_t	fVerbose
Int_t	fFE
Int_t	fFileCounter
std::vector< ULong64_t >	fToPixFrame
PndTopix4	fTopix
PndHammingDecoder	fHamming

Detailed Description

Definition at line 33 of file PndMvdReadInToPix4TBData.h.

Member Enumeration Documentation

anonymous enum

Enumerator
SuperFrameCount
NonSequentialFC
HammingLossFrameCount
CRCLossFrameCount
TotalHitCount
PreFrameLossHitCount
HammingLossHitCount
CRCLossHitCount
CorrectHitCount
DoubleHeader
DoubleTrailer
TotalHeaderCount
TotalTrailerCount
TotalFrameCount
NFilteredHits
Last

Definition at line 35 of file PndMvdReadInToPix4TBData.h.

             {
                SuperFrameCount = 0,
                NonSequentialFC,
                HammingLossFrameCount,
                CRCLossFrameCount,
                TotalHitCount,
                PreFrameLossHitCount,
                HammingLossHitCount,
                CRCLossHitCount,
                CorrectHitCount,
                DoubleHeader,
                DoubleTrailer,
                TotalHeaderCount,
                TotalTrailerCount,
                TotalFrameCount,
                NFilteredHits,
                Last
        };

Constructor & Destructor Documentation

PndMvdReadInToPix4TBData::PndMvdReadInToPix4TBData

(

)

Definition at line 21 of file PndMvdReadInToPix4TBData.cxx.

References fStatusValues, and Last.

                                                   : fClockFrequency(0), fSuperFrameCount(0),
                                           fOldFrameCount(0), fOldAllHeaderCount(0), fFirstHeader(kTRUE), fFE(-1),
                                           fNonSequentialFC(0), fHammingLossFrameCount(0), fCRCLossFrameCount(0),
                                           fTotalHitCount(0),fPreFrameLossHitCount(0), fHammingLossHitCount(0), fCRCLossHitCount(0), fCorrectHitCount(0),
                                           fHeaderPresent(kFALSE), fTrailerPresent(kFALSE), fDoubleHeader(0), fDoubleTrailer(0), fVerbose(0),
                                           fFileCounter(0), fTotalFrameCount(0), fTotalHeaderCount(0), fTotalTrailerCount(0), fFileHandle(0),
                                           fTimeStampCorrection(0.0), fFilter(kFALSE), fNFilteredHits(0)
{
        fStatusValues.resize(Last, 0);
}

PndMvdReadInToPix4TBData::~PndMvdReadInToPix4TBData ( )

virtual

Definition at line 32 of file PndMvdReadInToPix4TBData.cxx.

References fFileHandle.

{
  if (fFileHandle != 0){
          fFileHandle->close();
          delete(fFileHandle);
  }
}

Member Function Documentation

std::vector< std::vector< PndSdsDigiTopix4 > > PndMvdReadInToPix4TBData::AnalyzeData	(	std::vector< ULong64_t > &	rawData,
		Double_t	clockFrequency
	)

Definition at line 206 of file PndMvdReadInToPix4TBData.cxx.

References AnalyzeToPixFrame(), BuildFrame(), DEBUG, fToPixFrame, fVerbose, and i.

Referenced by PndMQTopix4ProcessorTask::Exec(), ReadInData(), and PndMQTopix4Processor::Run().

                                                                                                                                         {
        std::vector<std::vector<PndSdsDigiTopix4> > result;
        if (fVerbose > 2)
                LOG(DEBUG) << "PndMvdReadInToPix4TBData::AnalyzeData rawData.size(): " << rawData.size();
        for (int i = 0; i < rawData.size(); i++) {
                if (BuildFrame(rawData[i]) == true){            //a frame was found
                        std::vector<PndSdsDigiTopix4> hitList = AnalyzeToPixFrame(clockFrequency);
                        //LOG(INFO) << "TestData: " << hitList.front() << std::endl;
                        result.push_back(hitList);
                        fToPixFrame.clear();
                }
        }
        return result;
}

std::vector< PndSdsDigiTopix4 > PndMvdReadInToPix4TBData::AnalyzeToPixFrame

(

Double_t

clockFrequency

)

Definition at line 322 of file PndMvdReadInToPix4TBData.cxx.

References PndTopix4::BitAnalyzeHeader(), PndTopix4::BitAnalyzeTrailer(), CheckDataIntegrity(), CorrectHitCount, ToPix4::frameHeader::fChipAddress, fCorrectHitCount, fFE, fFilter, ToPix4::frameHeader::fFrameCount, ToPix4::frameTrailer::fFrameCRC, ToPix4::frameTrailer::fNEvents, fNFilteredHits, fNonSequentialFC, fOldFrameCount, fRecentFrameHeader, fRecentFrameTrailer, fStatusValues, fSuperFrameCount, fTopix, fToPixFrame, fVerbose, GetDeltaFrameCount(), PndTopix4::GetType(), HitToFilter(), i, NFilteredHits, NonSequentialFC, ProcessData(), SuperFrameCount, and y.

Referenced by AnalyzeData().

                                                                                               {
        std::vector<PndSdsDigiTopix4> hitList;
        if (fVerbose > 2) {
                std::cout << fFE << " PndMvdReadInToPix4TBData::AnalyzeToPixFrame: fToPixFrame size: "
                                << std::dec << fToPixFrame.size() << " header " << std::hex << fToPixFrame[0] << std::endl;
        }

        if (CheckDataIntegrity(fToPixFrame) != true){
                fToPixFrame.clear();
                return hitList;
        }

        for (int i = 0; i < fToPixFrame.size(); i++) {
                ULong64_t header = fTopix.GetType(fToPixFrame[i]);

                switch (header) {
                case 1: {
                        fRecentFrameHeader = fTopix.BitAnalyzeHeader(fToPixFrame[i]);

                        if (fVerbose > 2)
                                std::cout << fFE << " FrameHeader: rawData: " << std::hex
                                                << fToPixFrame[i] << " chip " << std::dec
                                                << fRecentFrameHeader.fChipAddress << " framecount "
                                                << fRecentFrameHeader.fFrameCount << std::endl;

                        Int_t deltaFrameCount = GetDeltaFrameCount();
                        if (deltaFrameCount > 1){
                                if (fVerbose > 1)
                                        std::cout << fFE << "-E- non sequential FC: " << fOldFrameCount << " " << fRecentFrameHeader.fFrameCount << std::endl;
                                fNonSequentialFC++;
                                fStatusValues[NonSequentialFC]++;
                        }

                        if (fOldFrameCount > fRecentFrameHeader.fFrameCount) {
                                fSuperFrameCount++;
                                fStatusValues[SuperFrameCount]++;
                                if (fVerbose > 1)
                                        std::cout << fFE << " SuperFrameCount increased: " << std::dec << fSuperFrameCount << " oldFC "
                                                        << fOldFrameCount << " recent FC " << fRecentFrameHeader.fFrameCount << std::endl;
                        }
                        //fOldFrameCount = fRecentFrameHeader.fFrameCount;

                        //  new ((*fOutputArrayHeader)[fOutputArrayHeader->GetEntriesFast()]) PndSdsDigiTopix4Header(fRecentFrameHeader.fFrameCount, fFE, fRecentFrameHeader.fChipAddress, fRecentFrameHeader.fECC, fTotalFrameCount,deltaFrameCount, 0, fToPixFrame.size()-2 );
                        //new ((*fOutputArrayHeader)[fOutputArrayHeader->GetEntriesFast()]) PndSdsDigiTopix4Header(fRecentFrameHeader.fFrameCount, 0, fFE,
                        //              fRecentFrameHeader.fECC, fTotalFrameCount, deltaFrameCount, 0, fToPixFrame.size() - 2);

                        fOldFrameCount = fRecentFrameHeader.fFrameCount;
                }
                        break;

                case 2: {
                        fRecentFrameTrailer = fTopix.BitAnalyzeTrailer(fToPixFrame[i]);
                        if (fRecentFrameTrailer.fFrameCRC != 0 && (fToPixFrame.size() < 20)) {
                                // std::cout << fFE << " Frame counter " << fRecentFrameHeader.fFrameCount << std::endl;
                                if (fVerbose == -1) {
                                        for (int y = 0; y < fToPixFrame.size(); y++) {
                                                if (y == 0) {
                                                        std::cout << fFE << " " << std::hex << fToPixFrame[y] << " - FCount " << fRecentFrameHeader.fFrameCount << std::endl;
                                                } else {
                                                        std::cout << fFE << " " << std::hex << fToPixFrame[y] << std::endl;
                                                }
                                        }
                                        std::cout << std::endl;
                                }
                        }
                        if (fVerbose > 2)
                                std::cout << fFE << " FrameTrailer: nEvents " << fRecentFrameTrailer.fNEvents << " frame CRC: "
                                                << fRecentFrameTrailer.fFrameCRC << std::endl;

                        //PndSdsDigiTopix4Header * header_trailer = (PndSdsDigiTopix4Header*) (fOutputArrayHeader->Last());
                        //header_trailer->SetNumberOfEvents(fRecentFrameTrailer.fNEvents);
                }
                        break;

                case 3:
                        PndSdsDigiTopix4 recentPixel = ProcessData(fToPixFrame[i], fRecentFrameHeader, clockFrequency);
                        if (fVerbose > 1)
                                LOG(INFO) << "RecentPixel: " << recentPixel;
                        if (fFilter == kTRUE){
                                if (HitToFilter(recentPixel) == true){
                                        //LOG(INFO) << "Hit to Filter found!";
                                        fNFilteredHits++;
                                        fStatusValues[NFilteredHits]++;
                                        break;
                                }
                        }
                        hitList.push_back(recentPixel);
                        if (fVerbose > 2)
                                std::cout << fFE << " Pixel: " << recentPixel << std::endl;
                        //WriteoutToPix4Digi(recentPixel);
                        fCorrectHitCount++;
                        fStatusValues[CorrectHitCount]++;
                        break;
                }
        }
        return hitList;
}

bool PndMvdReadInToPix4TBData::BuildFrame

(

ULong64_t &

rawData

)

Definition at line 221 of file PndMvdReadInToPix4TBData.cxx.

References PndTopix4::BitAnalyzeHeader(), DoubleHeader, DoubleTrailer, fDoubleHeader, fDoubleTrailer, fFE, fFirstHeader, ToPix4::frameHeader::fFrameCount, fHeaderPresent, fOldAllHeaderCount, fPreFrameLossHitCount, fStatusValues, fTopix, fToPixFrame, fTotalHitCount, fTotalTrailerCount, fTrailerPresent, fVerbose, PndTopix4::GetType(), PreFrameLossHitCount, TotalFrameCount, TotalHeaderCount, TotalHitCount, and TotalTrailerCount.

Referenced by AnalyzeData().

{
        int header = fTopix.GetType(rawData);
        if (fFirstHeader) {     // if data stream does not start with a header all data is thrown away until a header is present
                if (header == 1) {
                        fFirstHeader = kFALSE;
                } else {
                        return false;
                }
        }

        if (header == 1) // header word found
        {
                fStatusValues[TotalHeaderCount]++;

                ToPix4::frameHeader frameHeader = fTopix.BitAnalyzeHeader(rawData);

                Int_t deltaAllFrameCount = ((int) (frameHeader.fFrameCount - fOldAllHeaderCount) < 0 ?
                                                ((frameHeader.fFrameCount       - fOldAllHeaderCount) + 256) :
                                                (frameHeader.fFrameCount - fOldAllHeaderCount));
//              new ((*fOutputArrayAllHeader)[fOutputArrayAllHeader->GetEntriesFast()]) PndSdsDigiTopix4Header(frameHeader.fFrameCount, fFE,
//                              frameHeader.fChipAddress, frameHeader.fECC, fTotalHeaderCount, deltaAllFrameCount, 0, 0);
                if (deltaAllFrameCount > 1 && fVerbose > 0)
                        std::cout << "-W- deltaAllFrameCount > 1: "     << deltaAllFrameCount << std::endl;
                fOldAllHeaderCount = frameHeader.fFrameCount;

                if (fHeaderPresent == kTRUE) {
                        // double header found, cannot check previous data without trailer, clear vector
                        fDoubleHeader++;
                        fStatusValues[DoubleHeader]++;

                        if (fVerbose > 1) {
                                std::cout << "Double Header Found! count: " << fDoubleHeader << "| FE: " << fFE << std::hex << " last ToPixFrame element: "
                                                << fToPixFrame.back() << " new frame header " << rawData << std::endl;
                        }
                        fPreFrameLossHitCount += fToPixFrame.size() - 1;
                        fToPixFrame.clear();
                        // load new header into vector
                        fToPixFrame.push_back(rawData);
                } else {
                        // header found, start recording topix frame
                        fTrailerPresent = kFALSE;
                        fHeaderPresent = kTRUE;
                        fToPixFrame.push_back(rawData);
                }
        }

        else if (header == 2) // trailer word found
        {
                fTotalTrailerCount++;
                fStatusValues[TotalTrailerCount]++;
                if (fTrailerPresent == kTRUE) {
                        // double trailer found, cannot give the hits a valid timestamp without the header, clear vector

                        fToPixFrame.clear();
                        fStatusValues[DoubleTrailer]++;

                        if (fVerbose > 1) {
                                std::cout << "Double Trailer Found! Double header counter: " << fDoubleTrailer << std::endl;
                        }
                } else {
                        if (fHeaderPresent == kTRUE) {
                                // one topix frame found! Go and analyze the vector...
                                fHeaderPresent = kFALSE;
                                fTrailerPresent = kTRUE;
                                fToPixFrame.push_back(rawData);
                                //  if (fVerbose > 1)
                                //  {
                                //      std::cout << "ToPix Frame found! Go and analyze this amount of data: " << fToPixFrame.size() << std::endl;
                                //}

                                fStatusValues[TotalFrameCount]++;
                                //AnalyzeToPixFrame(clockFrequency);
                                return true;
                        } else {
                                if (fVerbose > 1) {
                                        std::cout << "Trailer without header found! Double header counter: " << fDoubleHeader << std::endl;
                                }
                                // trailer without header, can happen at the beginning of the file or the header was not detected correctly
                                // this case is in principle impossible to enter
                                fPreFrameLossHitCount += fToPixFrame.size() - 1;
                                fDoubleTrailer++;
                                fStatusValues[DoubleTrailer]++;
                                fToPixFrame.clear();
                        }
                }
        } else if (header == 3) // data word found
                        {
                fTotalHitCount++;
                fStatusValues[TotalHitCount]++;
                if (fHeaderPresent == kTRUE) { // found data while a active header is present, go and save the data
                        fToPixFrame.push_back(rawData);
                } else { // found data without a valid header, may happen at the beginning of the file or the header was detected
                        fPreFrameLossHitCount++;
                        fStatusValues[PreFrameLossHitCount]++;
                }
        }
        return false;
}

bool PndMvdReadInToPix4TBData::CheckDataIntegrity

(

std::vector< ULong64_t >

topix4Frame

)

Definition at line 438 of file PndMvdReadInToPix4TBData.cxx.

References PndHammingDecoder::CalculateCRCTableFast(), PndHammingDecoder::CheckHammingCode(), PndHammingDecoder::ConvertData(), PndTopix4::ConvertToPix4HammingToStandardHamming(), CRCLossFrameCount, CRCLossHitCount, fCRCLossFrameCount, fCRCLossHitCount, fFE, ToPix4::frameHeader::fFrameCount, fHamming, fHammingLossFrameCount, fHammingLossHitCount, fRecentFrameHeader, fStatusValues, fTopix, fVerbose, HammingLossFrameCount, HammingLossHitCount, and y.

Referenced by AnalyzeToPixFrame().

{
        ULong_t hammingcheck = fHamming.CheckHammingCode(fTopix.ConvertToPix4HammingToStandardHamming(topix4Frame[0]), 40); // check hamming of header
        if (hammingcheck != 0) {
                if (fVerbose > 1) {
                        std::cout << "Wrong Hamming Code found! (Header) : " << std::hex<< topix4Frame[0] << " Parity bits " << hammingcheck << std::endl;
                }
                fHammingLossFrameCount++;
                fStatusValues[HammingLossFrameCount]++;
                fHammingLossHitCount += topix4Frame.size() - 2;
                fStatusValues[HammingLossHitCount] += topix4Frame.size() - 2;
                return false;
        }

        hammingcheck = fHamming.CheckHammingCode(fTopix.ConvertToPix4HammingToStandardHamming(topix4Frame[topix4Frame.size() - 1]), 40); // check hamming of trailer
        if (hammingcheck != 0) {
                if (fVerbose > 1) {
                        std::cout << "Wrong Hamming Code found! (Trailer): " << std::hex << topix4Frame[0] << " Parity bits " << hammingcheck << std::endl;
                }
                fHammingLossFrameCount++;
                fStatusValues[HammingLossFrameCount]++;
                fHammingLossHitCount += topix4Frame.size() - 2;
                fStatusValues[HammingLossHitCount] += topix4Frame.size() - 2;
                return false;
        }

        std::vector<char> topix_data = fHamming.ConvertData(topix4Frame);
        ULong64_t crc_calculated = fHamming.CalculateCRCTableFast(topix_data, topix_data.size());

        if (crc_calculated != ((topix4Frame.back() >> 6) & 0xffff)) {
                fCRCLossFrameCount++;
                fStatusValues[CRCLossFrameCount]++;
                fCRCLossHitCount += topix4Frame.size() - 2;
                fStatusValues[CRCLossHitCount] += topix4Frame.size() - 2;
                if (fVerbose == -1) {
                        std::cout << fFE << " CRC WRONG! Frame will be deleted. Calculated CRC: " << std::hex << crc_calculated <<
                                        " topix CRC: " << ((topix4Frame.back() >> 6) & 0xffff) << std::endl;

                        for (int y = 0; y < topix4Frame.size(); y++) {
                                if (y == 0) {
                                        std::cout << fFE << " " << std::hex << topix4Frame[y] << " - FCount " << fRecentFrameHeader.fFrameCount << std::endl;
                                } else {
                                        std::cout << fFE << " " << std::hex << topix4Frame[y] << std::endl;
                                }
                        }
                        std::cout << std::endl;
                }
                topix4Frame.clear(); // delete topix frame due to negative CRC check.
                return false;
        }
        return true;
}

UInt_t PndMvdReadInToPix4TBData::GetCorrectFrameCount ( ) const

inline

Definition at line 107 of file PndMvdReadInToPix4TBData.h.

References fCorrectFrameCount.

{return fCorrectFrameCount;}

UInt_t PndMvdReadInToPix4TBData::GetCorrectHitCount ( ) const

inline

Definition at line 101 of file PndMvdReadInToPix4TBData.h.

References fCorrectHitCount.

{return fCorrectHitCount;}

UInt_t PndMvdReadInToPix4TBData::GetCRCLossFrameCount ( ) const

inline

Definition at line 109 of file PndMvdReadInToPix4TBData.h.

References fCRCLossFrameCount.

{return fCRCLossFrameCount;}

UInt_t PndMvdReadInToPix4TBData::GetCRCLossHitCount ( ) const

inline

Definition at line 104 of file PndMvdReadInToPix4TBData.h.

References fCRCLossHitCount.

{return fCRCLossHitCount;}

Int_t PndMvdReadInToPix4TBData::GetDeltaFrameCount

(

)

Definition at line 431 of file PndMvdReadInToPix4TBData.cxx.

References ToPix4::frameHeader::fFrameCount, fOldFrameCount, and fRecentFrameHeader.

Referenced by AnalyzeToPixFrame().

{
        return ((int) (fRecentFrameHeader.fFrameCount - fOldFrameCount) < 0 ?
                                ((fRecentFrameHeader.fFrameCount - fOldFrameCount) + 256) :
                                (fRecentFrameHeader.fFrameCount - fOldFrameCount));
}

UInt_t PndMvdReadInToPix4TBData::GetDoubleHeader ( ) const

inline

Definition at line 95 of file PndMvdReadInToPix4TBData.h.

References fDoubleHeader.

{return fDoubleHeader;}

UInt_t PndMvdReadInToPix4TBData::GetDoubleTrailer ( ) const

inline

Definition at line 96 of file PndMvdReadInToPix4TBData.h.

References fDoubleTrailer.

{return fDoubleTrailer;}

UInt_t PndMvdReadInToPix4TBData::GetHammingLossFrameCount ( ) const

inline

Definition at line 108 of file PndMvdReadInToPix4TBData.h.

References fHammingLossFrameCount.

{return fHammingLossFrameCount;}

UInt_t PndMvdReadInToPix4TBData::GetHammingLossHitCount ( ) const

inline

Definition at line 103 of file PndMvdReadInToPix4TBData.h.

References fHammingLossHitCount.

{return fHammingLossHitCount;}

Int_t PndMvdReadInToPix4TBData::GetNFilteredHits ( )

inline

Definition at line 116 of file PndMvdReadInToPix4TBData.h.

References fNFilteredHits.

{ return fNFilteredHits;}

UInt_t PndMvdReadInToPix4TBData::GetNonSequenctialFC ( ) const

inline

Definition at line 94 of file PndMvdReadInToPix4TBData.h.

References fNonSequentialFC.

{return fNonSequentialFC;}

UInt_t PndMvdReadInToPix4TBData::GetPreFrameLossHitCount ( ) const

inline

Definition at line 102 of file PndMvdReadInToPix4TBData.h.

References fPreFrameLossHitCount.

{return fPreFrameLossHitCount;}

std::vector<int> PndMvdReadInToPix4TBData::GetStatusValues ( ) const

inline

Definition at line 114 of file PndMvdReadInToPix4TBData.h.

References fStatusValues.

Referenced by PndMQTopix4Processor::Run().

{return fStatusValues;}

UInt_t PndMvdReadInToPix4TBData::GetSuperFrameCount ( ) const

inline

Definition at line 97 of file PndMvdReadInToPix4TBData.h.

References fSuperFrameCount.

{return fSuperFrameCount;}

UInt_t PndMvdReadInToPix4TBData::GetTotalFrameCount ( ) const

inline

Definition at line 106 of file PndMvdReadInToPix4TBData.h.

References fTotalFrameCount.

{return fTotalFrameCount;}

UInt_t PndMvdReadInToPix4TBData::GetTotalHeaderCount ( ) const

inline

Definition at line 111 of file PndMvdReadInToPix4TBData.h.

References fTotalHeaderCount.

{return fTotalHeaderCount;}

UInt_t PndMvdReadInToPix4TBData::GetTotalHitCount ( ) const

inline

Definition at line 100 of file PndMvdReadInToPix4TBData.h.

References fTotalHitCount.

{return fTotalHitCount;}

UInt_t PndMvdReadInToPix4TBData::GetTotalTrailerCount ( ) const

inline

Definition at line 112 of file PndMvdReadInToPix4TBData.h.

References fTotalTrailerCount.

{return fTotalTrailerCount;}

Bool_t PndMvdReadInToPix4TBData::HitToFilter

(

PndSdsDigiTopix4 &

hit

)

Definition at line 420 of file PndMvdReadInToPix4TBData.cxx.

References PndSdsDigiTopix4::GetLeadingEdge(), and PndSdsDigiTopix4::GetTrailingEdge().

Referenced by AnalyzeToPixFrame().

{
        int leadingEdge = hit.GetLeadingEdge();
        int trailingEdge = hit.GetTrailingEdge();
        if (leadingEdge == 2729 || leadingEdge == 2730)
                return true;
        if (trailingEdge == 2730 || trailingEdge == 2731)
                return true;
        return false;
}

void PndMvdReadInToPix4TBData::Init

(

)

Definition at line 41 of file PndMvdReadInToPix4TBData.cxx.

References fFileCounter, fFileHandle, and fFileNames.

Referenced by PndMQTopix4Sampler::Init().

                                   {
        //std::cout << "PndMvdReadInToPix4TBData::Init called" << std::endl;
//      for (int i = 0; i < fFileName.size(); i++){
         std::ifstream* ifs = new std::ifstream(fFileNames[fFileCounter], std::ios::binary);
         if (ifs->good() == kFALSE)
                 LOG(ERROR) << "File: " << fFileNames[fFileCounter] << " is good: " << ifs->good();
         fFileCounter++;
         fFileHandle=ifs;
//      }
}

PndSdsDigiTopix4 PndMvdReadInToPix4TBData::ProcessData	(	ULong64_t &	data,
		ToPix4::frameHeader &	header,
		Double_t &	clockFrequency
	)

todo: check if sqrt(12) has to be added

Definition at line 492 of file PndMvdReadInToPix4TBData.cxx.

References PndTopix4::BitAnalyzePixelData(), Double_t, fCorrectHitCount, fFE, ToPix4::frameHeader::fFrameCount, ToPix4::pixel::fLeadingEdge, ToPix4::pixel::fPixelNumber, fSuperFrameCount, fTimeStampCorrection, fTopix, fTotalHeaderCount, fTotalHitCount, ToPix4::pixel::fTrailingEdge, fVerbose, and PndTopix4::PixelNumberToMatrixAddress().

Referenced by AnalyzeToPixFrame().

{
        if (fVerbose > 1) std::cout  << "PndMvdReadInToPix4TBData::ProcessData raw Data: " << data << std::endl;
        pixel pixelData = fTopix.BitAnalyzePixelData(data);
        std::pair<UInt_t, UInt_t> pixelAddress = fTopix.PixelNumberToMatrixAddress(pixelData.fPixelNumber);

        Int_t frameCountHeader = header.fFrameCount;
        if (pixelData.fLeadingEdge > pixelData.fTrailingEdge){
                frameCountHeader--;
                //std::cout << "PndMvdReadInToPix4TBData::ProcessData frameCount corrected" << std::endl;
        }
        Double_t timestamp = ((Double_t)fSuperFrameCount * 256. * 4096. + (Double_t)frameCountHeader * 4096. + (Double_t)pixelData.fLeadingEdge)/clockFrequency * 1000.;
        timestamp += fTimeStampCorrection;
        Double_t timestamp_independent = ((Double_t) fTotalHeaderCount * 4096. + (Double_t)pixelData.fLeadingEdge)/clockFrequency * 1000.;

        std::vector<Int_t> indices; // just for compatibility with PndSdsDigiPixel
//      return PndSdsDigiTopix4(indices, 0, 0, fFE, pixelAddress.first, pixelAddress.second, pixelData.fLeadingEdge, pixelData.fTrailingEdge, header.fFrameCount, timestamp, fCorrectHitCount,fTotalHitCount, timestamp_independent);
        PndSdsDigiTopix4 result(indices, 0, fFE - 1, 0, pixelAddress.first, pixelAddress.second, pixelData.fLeadingEdge, pixelData.fTrailingEdge, header.fFrameCount, timestamp, fCorrectHitCount,fTotalHitCount, timestamp_independent);
        result.SetTimeStampError(1/clockFrequency * 1000);  
        return result;

}

Bool_t PndMvdReadInToPix4TBData::ReadInData

(

std::vector< std::vector< PndSdsDigiTopix4 > > &

data

)

Definition at line 52 of file PndMvdReadInToPix4TBData.cxx.

References AnalyzeData(), Bool_t, fClockFrequency, fTopix, PndTopix4::GetRawData(), and ReadInDataFromFile().

                                                                                        {
        ULong_t dataword=0;
        Bool_t endOfFile = kFALSE;

//      fOutputArrayAllHeader = allheaderContainer;
        std::vector<ULong64_t> rawArray;
        TMrfData_8b* mrfData = 0;
        endOfFile |= ReadInDataFromFile(mrfData);
        if (mrfData != 0){
                rawArray = fTopix.GetRawData(mrfData);
                delete(mrfData);
        }
//      endOfFile |= ReadInRawData(fFileHandle, rawArray);
        data = AnalyzeData(rawArray, fClockFrequency);
        return endOfFile;
}

Bool_t PndMvdReadInToPix4TBData::ReadInDataFromFile ( TMrfData_8b *&  data )

virtual

Definition at line 69 of file PndMvdReadInToPix4TBData.cxx.

References Bool_t, DEBUG, fFE, fFileCounter, fFileHandle, fFileNames, and fVerbose.

Referenced by ReadInData(), and PndMQTopix4Sampler::Run().

{
        Bool_t endOfFile = kFALSE;

        if (fFileHandle->good()) {
                if (fVerbose > 1)
                        LOG(DEBUG) << "PndMvdReadInToPix4TBData::ReadInRawData reading file ";
                try {
                        boost::archive::binary_iarchive iar(*fFileHandle); //this line causes an "Invalid Signature Error" at the end of the file but the file is still good
                        iar >> data;
                } catch (boost::archive::archive_exception& exception) {
                        LOG(WARN) << "PndMvdReadInToPix4TBData::ReadInRawData: Error found in reading file "
                                                << " : " << fFileHandle->good() << " " << fFileHandle->eof() << " Exception: "
                                                << exception.code << " " << exception.what();

                        if (exception.code == 3) {
                                if (fFileCounter < fFileNames.size()) {
                                        LOG(INFO) << fFE << " open new file " << fFileNames[fFileCounter];
                                        fFileHandle->close();
                                        delete (fFileHandle);
                                        std::ifstream* ifs = new std::ifstream(fFileNames[fFileCounter], std::ios::binary);
                                        fFileHandle = ifs;
                                        fFileCounter++;
                                        return endOfFile;
                                } else {
                                        LOG(INFO) << fFE << " All files read! Finishing FE ";
                                        endOfFile = kTRUE;
                                        return endOfFile;
                                }
                        }
                        return kTRUE;
                }
        } else {
                LOG(ERROR) << fFE << " An error occured ";
                LOG(ERROR) << fFE << " fFileHandle->good() " << fFileHandle->good();
                LOG(ERROR) << fFE << " fFileHandle->eof()  " << fFileHandle->eof();
                LOG(ERROR) << fFE << " fFileHandle->fail() " << fFileHandle->fail();
                LOG(ERROR) << fFE << " fFileHandle->bad()  " << fFileHandle->bad();

                endOfFile = kTRUE;
                return endOfFile;
        }
        return endOfFile;
}

void PndMvdReadInToPix4TBData::SetClockFrequency ( Double_t  val )

inline

Definition at line 91 of file PndMvdReadInToPix4TBData.h.

References fClockFrequency, and val.

{fClockFrequency = val;}

void PndMvdReadInToPix4TBData::SetFE ( Int_t  val )

inline

Definition at line 93 of file PndMvdReadInToPix4TBData.h.

References fFE, and val.

Referenced by PndMQTopix4Processor::SetProperty().

{fFE = val;}

void PndMvdReadInToPix4TBData::SetFileName ( std::vector< std::string >  fileName )

inline

Definition at line 56 of file PndMvdReadInToPix4TBData.h.

References fFileNames, and i.

Referenced by SetFileName().

                                                       {
          
          std::cout << "number of entires " << fileName.size() << std::endl;
          for(int i=0; i < fileName.size();i++)
            {
              std::cout << i<< " " << fileName[i] << std::endl;
            }
          fFileNames= fileName;
        }

void PndMvdReadInToPix4TBData::SetFileName ( std::string  fileName )

inline

Definition at line 66 of file PndMvdReadInToPix4TBData.h.

References SetFileName().

                                            {
                std::vector<std::string> names;
                names.push_back(fileName);
                SetFileName(names);
        }

void PndMvdReadInToPix4TBData::SetFilter ( Bool_t  val )

inline

Definition at line 118 of file PndMvdReadInToPix4TBData.h.

References fFilter, and val.

Referenced by PndMQTopix4Processor::Run(), and PndMQTopix4Processor::SetFilter().

{ fFilter = val;}

void PndMvdReadInToPix4TBData::SetTimeStampCorrection ( Double_t  val )

inline

Definition at line 92 of file PndMvdReadInToPix4TBData.h.

References fTimeStampCorrection, and val.

{fTimeStampCorrection = val;}

void PndMvdReadInToPix4TBData::SetVerbose ( Int_t  val )

inline

Definition at line 121 of file PndMvdReadInToPix4TBData.h.

References fVerbose, and val.

{fVerbose = val;}

Member Data Documentation

Double_t PndMvdReadInToPix4TBData::fClockFrequency

private

Definition at line 126 of file PndMvdReadInToPix4TBData.h.

Referenced by ReadInData(), and SetClockFrequency().

UInt_t PndMvdReadInToPix4TBData::fCorrectFrameCount

private

Definition at line 162 of file PndMvdReadInToPix4TBData.h.

Referenced by GetCorrectFrameCount().

UInt_t PndMvdReadInToPix4TBData::fCorrectHitCount

private

Definition at line 143 of file PndMvdReadInToPix4TBData.h.

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

UInt_t PndMvdReadInToPix4TBData::fCRCLossFrameCount

private

Definition at line 137 of file PndMvdReadInToPix4TBData.h.

Referenced by CheckDataIntegrity(), and GetCRCLossFrameCount().

UInt_t PndMvdReadInToPix4TBData::fCRCLossHitCount

private

Definition at line 142 of file PndMvdReadInToPix4TBData.h.

Referenced by CheckDataIntegrity(), and GetCRCLossHitCount().

UInt_t PndMvdReadInToPix4TBData::fDoubleHeader

private

Definition at line 155 of file PndMvdReadInToPix4TBData.h.

Referenced by BuildFrame(), and GetDoubleHeader().

UInt_t PndMvdReadInToPix4TBData::fDoubleTrailer

private

Definition at line 156 of file PndMvdReadInToPix4TBData.h.

Referenced by BuildFrame(), and GetDoubleTrailer().

Int_t PndMvdReadInToPix4TBData::fFE

private

Definition at line 165 of file PndMvdReadInToPix4TBData.h.

Referenced by AnalyzeToPixFrame(), BuildFrame(), CheckDataIntegrity(), ProcessData(), ReadInDataFromFile(), and SetFE().

Int_t PndMvdReadInToPix4TBData::fFileCounter

private

Definition at line 166 of file PndMvdReadInToPix4TBData.h.

Referenced by Init(), and ReadInDataFromFile().

std::ifstream* PndMvdReadInToPix4TBData::fFileHandle

private

Definition at line 125 of file PndMvdReadInToPix4TBData.h.

Referenced by Init(), ReadInDataFromFile(), and ~PndMvdReadInToPix4TBData().

std::vector<std::string> PndMvdReadInToPix4TBData::fFileNames

private

Definition at line 124 of file PndMvdReadInToPix4TBData.h.

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

Bool_t PndMvdReadInToPix4TBData::fFilter

private

Definition at line 145 of file PndMvdReadInToPix4TBData.h.

Referenced by AnalyzeToPixFrame(), and SetFilter().

Bool_t PndMvdReadInToPix4TBData::fFirstHeader

private

Definition at line 151 of file PndMvdReadInToPix4TBData.h.

Referenced by BuildFrame().

PndHammingDecoder PndMvdReadInToPix4TBData::fHamming

private

Definition at line 170 of file PndMvdReadInToPix4TBData.h.

Referenced by CheckDataIntegrity().

UInt_t PndMvdReadInToPix4TBData::fHammingLossFrameCount

private

Definition at line 136 of file PndMvdReadInToPix4TBData.h.

Referenced by CheckDataIntegrity(), and GetHammingLossFrameCount().

UInt_t PndMvdReadInToPix4TBData::fHammingLossHitCount

private

Definition at line 141 of file PndMvdReadInToPix4TBData.h.

Referenced by CheckDataIntegrity(), and GetHammingLossHitCount().

Bool_t PndMvdReadInToPix4TBData::fHeaderPresent

private

Definition at line 152 of file PndMvdReadInToPix4TBData.h.

Referenced by BuildFrame().

UInt_t PndMvdReadInToPix4TBData::fNFilteredHits

private

Definition at line 146 of file PndMvdReadInToPix4TBData.h.

Referenced by AnalyzeToPixFrame(), and GetNFilteredHits().

UInt_t PndMvdReadInToPix4TBData::fNonSequentialFC

private

Definition at line 135 of file PndMvdReadInToPix4TBData.h.

Referenced by AnalyzeToPixFrame(), and GetNonSequenctialFC().

UInt_t PndMvdReadInToPix4TBData::fOldAllHeaderCount

private

Definition at line 132 of file PndMvdReadInToPix4TBData.h.

Referenced by BuildFrame().

UInt_t PndMvdReadInToPix4TBData::fOldFrameCount

private

Definition at line 131 of file PndMvdReadInToPix4TBData.h.

Referenced by AnalyzeToPixFrame(), and GetDeltaFrameCount().

UInt_t PndMvdReadInToPix4TBData::fPreFrameLossHitCount

private

Definition at line 140 of file PndMvdReadInToPix4TBData.h.

Referenced by BuildFrame(), and GetPreFrameLossHitCount().

ToPix4::frameHeader PndMvdReadInToPix4TBData::fRecentAllFrameHeader

private

Definition at line 149 of file PndMvdReadInToPix4TBData.h.

ToPix4::frameHeader PndMvdReadInToPix4TBData::fRecentFrameHeader

private

Definition at line 148 of file PndMvdReadInToPix4TBData.h.

Referenced by AnalyzeToPixFrame(), CheckDataIntegrity(), and GetDeltaFrameCount().

ToPix4::frameTrailer PndMvdReadInToPix4TBData::fRecentFrameTrailer

private

Definition at line 150 of file PndMvdReadInToPix4TBData.h.

Referenced by AnalyzeToPixFrame().

std::vector<int> PndMvdReadInToPix4TBData::fStatusValues

private

Definition at line 129 of file PndMvdReadInToPix4TBData.h.

Referenced by AnalyzeToPixFrame(), BuildFrame(), CheckDataIntegrity(), GetStatusValues(), and PndMvdReadInToPix4TBData().

UInt_t PndMvdReadInToPix4TBData::fSuperFrameCount

private

Definition at line 134 of file PndMvdReadInToPix4TBData.h.

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

Double_t PndMvdReadInToPix4TBData::fTimeStampCorrection

private

Definition at line 127 of file PndMvdReadInToPix4TBData.h.

Referenced by ProcessData(), and SetTimeStampCorrection().

PndTopix4 PndMvdReadInToPix4TBData::fTopix

private

Definition at line 169 of file PndMvdReadInToPix4TBData.h.

Referenced by AnalyzeToPixFrame(), BuildFrame(), CheckDataIntegrity(), ProcessData(), and ReadInData().

std::vector<ULong64_t> PndMvdReadInToPix4TBData::fToPixFrame

private

Definition at line 168 of file PndMvdReadInToPix4TBData.h.

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

UInt_t PndMvdReadInToPix4TBData::fTotalFrameCount

private

Definition at line 161 of file PndMvdReadInToPix4TBData.h.

Referenced by GetTotalFrameCount().

UInt_t PndMvdReadInToPix4TBData::fTotalHeaderCount

private

Definition at line 158 of file PndMvdReadInToPix4TBData.h.

Referenced by GetTotalHeaderCount(), and ProcessData().

UInt_t PndMvdReadInToPix4TBData::fTotalHitCount

private

Definition at line 139 of file PndMvdReadInToPix4TBData.h.

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

UInt_t PndMvdReadInToPix4TBData::fTotalTrailerCount

private

Definition at line 159 of file PndMvdReadInToPix4TBData.h.

Referenced by BuildFrame(), and GetTotalTrailerCount().

Bool_t PndMvdReadInToPix4TBData::fTrailerPresent

private

Definition at line 153 of file PndMvdReadInToPix4TBData.h.

Referenced by BuildFrame().

Int_t PndMvdReadInToPix4TBData::fVerbose

private

Definition at line 164 of file PndMvdReadInToPix4TBData.h.

Referenced by AnalyzeData(), AnalyzeToPixFrame(), BuildFrame(), CheckDataIntegrity(), ProcessData(), ReadInDataFromFile(), and SetVerbose().

---

The documentation for this class was generated from the following files:

• PndMvdReadInToPix4TBData.h
• PndMvdReadInToPix4TBData.cxx