ReadMezzAFP.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004 by Olivier Stezowski                               *
 *   stezow(AT)ipnl.in2p3.fr                                               *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include <iostream>
#include <iomanip>
#include <fstream>
#include <sstream>
#include <cstdio>
#include <vector>

#include "BufferIO.h"

#include "BashColor.h"
#include "ReadMezzAFP.h"

using namespace ADF;

ReadMezzAFP::ReadMezzAFP():
    NarvalProducer(),
    fSourceOfFrames(aMByte,ConfAgent::kRead),
    fPath("./"),
    fBaseForName("AFP_"),
    fCurrentFile(0x0),
    fCurrentFileNumber(0u),
    fMaxSize(kMaxInt_t),
    fConfMode(-1),
    fListOfFile(),
    fEndOfFrame("EndOfFrame"),
    FirstTimeStamp(0),
    LastTimeStamp(0),
    fFrameCrystal_Out(NULL),
    fTrigger("data:crystal"),
    fdebug(false),
    fBashColor(new BashColor()),
    fUseKeyFilter(false),
    fLastKeyIsRead(false),
    fNEvts(0),
    fNIgnoredEvts(0),
    fBitFlipMezzLength(0),
    fBitFlipTraceLength(0),
    fBitFlipSegId(0),
    fBitFlipTS(0),
    fCrystalName(""),
    TotalEntryFileSize(0),
    ReadEntryFileSize(0),
    LastReadEntryFileSize(0)
{       
    if(fdebug) std::cout<<"\E[31;1m"<<"Construct in"<<"\E[m"<<std::endl;

    Log.GetProcessName() = "ReadMezzAFP"; GetFrameIO().SetName("ReadMezzAFP");

    // to be sure unknown frames are written in the ouput
    GetFrameIO().SetModel(ConfAgent::kSafe);
    // to protect writings in the source of frames
    fSourceOfFrames.SetModeIO(ConfAgent::kRead);

    // the input datablock is owned by BasicAFP
    GetFrameIO().Attach(&fSourceOfFrames,0x0);
    fListOfFile.clear();

    if(fdebug) std::cout<<"\E[31;1m"<<"Construct out"<<"\E[m"<<std::endl;
}

ReadMezzAFP::~ReadMezzAFP()
{  
    // in principle not needed ... just in case reset it has not been called by narval
    unsigned int error = 0u; process_reset(&error) ;

    for(int nn = 0; nn < kNSG; nn++ )
        delete [] SegmentTraces[nn];
    for(int nn = 0; nn < kNCC; nn++ )
        delete [] CoreTraces[nn];
} 

bool ReadMezzAFP::NewFile()
{       
    Log.SetProcessMethod("NewFile");
    bool ok = false;
    NewCrystal = false;

    if ( fConfMode == -1 ) // not properly initialised
        return ok;

    // close the current file
    if ( fCurrentFile )
        ::fclose(fCurrentFile);
    fCurrentFile = 0x0;

    if ( fConfMode == 0 ) {
        // open the first file to be ready to be run
        std::string tmp = fPath;
        if ( tmp.size() > 0 && !(tmp.at(tmp.size()-1) == '/') )
            tmp += '/';

        // try to open the next file
        std::ostringstream filename;
        filename << tmp << fBaseForName
                 << std::setfill('0') << std::setw(4) << fCurrentFileNumber++;

        fCurrentFile = ::fopen(filename.str().data(),"rb");
        if ( fCurrentFile != 0x0 ) {
            Log << "A new input file has just been open "
                << filename.str() << nline;
            fSourceOfFrames.SetFile
                    (fCurrentFile,fMaxSize);
            GetFrameIO().SetStatus
                    (BaseFrameIO::kIdle);
            ok = true;
        }
        else {
            Log << warning << "Cannot open file "
                << filename.str()
                << nline;
            GetFrameIO().SetStatus(BaseFrameIO::kFinished);
        }
    }
    else {
        // try to open the next file
        while ( fCurrentFileNumber < fListOfFile.size() ) {

            fCurrentFile = ::fopen(fListOfFile[fCurrentFileNumber].data(),"rb");
            if ( fCurrentFile == 0x0 ) {
                Log << warning << "File "
                    << fListOfFile[fCurrentFileNumber]
                       << " is not a valid file "
                       << nline ;

                fCurrentFileNumber++;
                continue;
            }
            Log << info << "A new input file has just been open "
                << fListOfFile[fCurrentFileNumber]
                   << nline;
            fSourceOfFrames.SetFile(fCurrentFile,fMaxSize);
            GetFrameIO().SetStatus(BaseFrameIO::kIdle);
            ok = true;

            std::vector<std::string> token2 = split(fListOfFile[fCurrentFileNumber],'/');
            fCrystalName = token2[token2.size()-2];

            if(fCurrentFileNumber > 0)
            {
                std::vector<std::string> token = split(fListOfFile[fCurrentFileNumber-1],'/');
                std::string previouscrystal = token[token.size()-2];

                if(previouscrystal != fCrystalName) NewCrystal = true;

                fCrystalName = previouscrystal;
            }

            fCurrentFileNumber++;

            break;
        }
        if ( !ok )
            GetFrameIO().SetStatus(BaseFrameIO::kFinished);
    }
    // send the log collected in this method
    Log << dolog;

    return ok;
}

void ReadMezzAFP::process_config (const char *directory_path, unsigned int *error_code)
{       
    // first init narval and ADF stuff (if required)
    NarvalInterface::process_config(directory_path,error_code);

    if ( (*error_code) == 0u ) { // now init your stuff
    }
}

unsigned int ReadMezzAFP::ProcessBlock(ADF::FrameBlock &out)
{ 
    if(fdebug) std::cout<<"\E[31;1m"<<"ProcessBlock in"<<"\E[m"<<std::endl;

    // attach the input/output buffer to the FrameIO system

    GetFrameIO().Attach(NULL, &out);

    // start the processing

    Frame *frame_out = fFrameCrystal_Out->GetFrame();
    CrystalInterface *cdata = GetDataPointer<CrystalInterface>(frame_out);

    frame_out->Write(); 

    unsigned int EventLenght = frame_out->GetLength();

    while(out.Reserve(EventLenght,true))
    {
        frame_out->Reset();

        int ok = ReadEvent();

        if(ok!=1)
        {
            if(ok==2) continue; //bad event
            //else end of file
            if(NewFile())
            {
                if(NewCrystal)
                {
                    PrintStats();
                    ResetStats();
                }
                continue;
            }
            else
            {
                std::cout<<std::endl;
                PrintStats();
                out.SetEoB(true);
                break;
            }
        }

        if(fLastKeyIsRead)
        {
            out.SetEoB(true);
            break;
        }

        fNEvts++;

        if( fUseKeyFilter)
        {
            if(evnumber == fNextEvtNbr)
            {
                //                fBashColor->SetInfoOut();
                //                std::cout<<"Evt Number = "<<evnumber<<" ; Ref Evt Nbr = "<<fNextEvtNbr<<std::endl;
                //                std::cout<<"TimeStamp = "<<timestamp<<" ; Ref TimeStamp = "<<fNextTS<<std::endl;
                //                fBashColor->ResetColor();
                NextKeyToFind();
            }
            else
            {
                //                fBashColor->SetWarningOut();
                //                std::cout<<"Evt Number = "<<evnumber<<" ignored, looking for Evt Nbr = "<<fNextEvtNbr<<std::endl;
                //                std::cout<<"TimeStamp = "<<timestamp<<" ignored, looking for TimeStamp = "<<fNextTS<<std::endl;
                //                fBashColor->ResetColor();
                fNIgnoredEvts++;
                continue;
            }
        }

        for(int i = 0; i < kNSG; i++) {
            segMezz = cdata->GetSegment(i);
            segMezz->GetSignal()->Set(SegmentTraces[i], fTraceLengthRaw);
            segMezz->SetE(SegE[i]);
            segMezz->SetStatus(SegStatus[i]);
            segMezz->SetID(SegID[i]);
        }
        for(int i = 0; i < kNCC; i++) {
            coreMezz = cdata->GetCore(i);
            coreMezz->GetSignal()->Set(CoreTraces[i], fTraceLengthRaw);
            coreMezz->SetE(CoreE[i]);
            coreMezz->SetStatus(CoreStatus[i]);
            coreMezz->SetID(CoreID[i]);
            coreMezz->SetT(0);
        }

        // Insert timestamp and event number
        ( ( AgataKey * ) frame_out->GetKey() )->SetTimeStamp( timestamp );
        ( ( AgataKey * ) frame_out->GetKey() )->SetEventNumber( evnumber );
        crystal_status = 0;       // all "normal" events are good

        frame_out->Write();

        fTrigger.Fired(true);
        GetFrameIO().Record();
    }

    double Ratio = ((double)ReadEntryFileSize)/((double)TotalEntryFileSize)*100.;
    double LastRatio = ((double)LastReadEntryFileSize)/((double)TotalEntryFileSize)*100.;

    std::ostringstream toto;
    toto<<TotalEntryFileSize;
    int NDigits = toto.str().length();

    if(((int)Ratio) != ((int)LastRatio))
        std::cout<<"\r"<<"Analysis progress : "<<std::setw(3)<<(int)(Ratio+0.5)<<" %"<<" ("<<std::setw(NDigits)<<ReadEntryFileSize<<"/"<<std::setw(NDigits)<<TotalEntryFileSize<<" bytes)"<<std::flush;


    LastReadEntryFileSize = ReadEntryFileSize;

    GetFrameIO().Detach(NULL, &out);

    if(fdebug) std::cout<<"\E[31;1m"<<"ProcessBlock out"<<"\E[m"<<std::endl;

    if ( GetFrameIO().GetStatus() == BaseFrameIO::kFinished || fLastKeyIsRead)
        return 1u;
    else return 0u;
}       

void ReadMezzAFP::process_initialise (unsigned int *error_code)
{
    if(fdebug) std::cout<<"\E[31;1m"<<"process_initialise in"<<"\E[m"<<std::endl;

    std::string tmp, option;

    *error_code = 0u; Log.ClearMessage(); Log.SetProcessMethod("process_initialise");

    // read an input file to get the base filename and the path
    std::string conffile = GetConfPath();
    conffile += "ReadMezzAFP.conf";

    fCurrentFileNumber = 0u;

    std::ifstream filein(conffile.data());
    if ( filein.is_open() == true ) {
        getline(filein,tmp);
        tmp += " ";
        while ( filein.good() && !filein.eof() ) { // read input stream line by line
            if ( tmp[0] == '#' ) {
                getline(filein,tmp);
                tmp += " ";
                continue;
            } // this line is a comment

            std::istringstream decode(tmp);

            if( tmp[0] == 'b' ){ // to emulate a BasicAFP

                std::string pathforfiles, basename;
                unsigned int starting_number;
                decode >> option >> pathforfiles >> basename >> starting_number;

                if ( decode.good() ) {

                    fPath = pathforfiles;
                    fBaseForName = basename;
                    fCurrentFileNumber = starting_number;

                    fConfMode = 0;
                }
            }
            if( tmp[0] == 'l' ) { // the .conf file contains the list of file to be read

                std::string filename;
                decode >> option >> filename;
                if( decode.good() )
                {
                    std::vector<std::string> token = split(filename,'/');

                    fPath = filename;
                    replace(fPath,token[token.size()-1],"");

                    fListOfFile.push_back(filename);
                }

                fConfMode = 1;
            }
            if( tmp[0] == 'r' ) { // the .conf contains a range of files to be read
                unsigned int starting_number, ending_number;
                std::string pathforfiles, basename;
                decode >> option >> pathforfiles >> basename >> starting_number >> ending_number;
                if( decode.good() && starting_number < ending_number ){

                    fPath = pathforfiles;
                    fBaseForName = basename;

                    for( unsigned int number = starting_number; number <= ending_number; number++ ){
                        std::ostringstream osfilename;
                        osfilename  << pathforfiles << basename << std::setfill('0') << std::setw(4) << number;
                        fListOfFile.push_back(osfilename.str());
                    }
                }
                fConfMode = 2;
            }
            if( tmp[0] == 'f' ) { // the .conf contains a key filter
                std::string pathforfilter;
                decode >> option >> pathforfilter;
                if(decode.good()){
                    fKeyFilterFile = 0x0;
                    fKeyFilterFile = ::fopen(pathforfilter.data(),"rb");
                    if(fKeyFilterFile == 0x0)
                    {
                        fBashColor->SetErrorOut();
                        std::cout<<"Key filter file not found, key filter ignored !"<<std::endl;
                        fBashColor->ResetColor();
                    }
                    else
                    {
                        fBashColor->SetInfoOut();
                        std::cout<<"Key filter file : "<<pathforfilter<<" will be used !"<<std::endl;
                        fBashColor->ResetColor();

                        ::fseek(fKeyFilterFile, 0, SEEK_END);
                        long size = ::ftell(fKeyFilterFile);

                        ::rewind(fKeyFilterFile);

                        fKeyFilterBuffer = new BufferIO(size);

                        fKeyFilterBuffer->Import(fKeyFilterFile,size);
                        fKeyFilterBuffer->SetOffset();

                        const ADF::FactoryItem item("Agata","data:psa",ADF::Version(4,0));

                        fKeyToLink = (AgataKey*)MainKeyFactory::theMainFactory().New(item);

                        NextKeyToFind();

                        fUseKeyFilter = true;
                    }
                }
            }
            getline(filein,tmp);
            tmp += " ";
        }
    }
    else
    {
        std::cout<<"\E[31;1m"<<conffile.data()<<" not found !"<<"\E[m"<<std::endl;
        *error_code = 1u;
    }
    filein.close();

    switch (fConfMode) {
    case -1:
        *error_code = 1u;
        Log << error << "Not properly initialised" << nline ;
        break;
    case 0:
        Log << info << "Init in BasicAFP mode" << nline ;
        break;
    case 1:
        for(unsigned int i=0 ; i<fListOfFile.size() ; i++)
        {
            std::ifstream afile(fListOfFile[i].data(), std::ios_base::binary);
            afile.seekg( 0 , std::ios_base::end );
            unsigned long size = afile.tellg() ;
            afile.close();
            TotalEntryFileSize += size;
        }
    case 2:
        Log << info << "List of file to be read is " << fListOfFile.size() << nline ;
        break;
    default:
        break;
    }

    // Read the crystal producer conf file

    std::string ConfFilePath = fPath;

    std::vector<std::string> token = split(ConfFilePath,'/');

    replace(ConfFilePath,(std::string)"/" + token[token.size()-3] + "/","/Conf/");

    ConfFilePath += "CrystalProducer.conf";

    std::ifstream ProdConfFile(ConfFilePath.data());
    if ( ProdConfFile.is_open() == true )
    {
        std::string Line;

        while(ProdConfFile)
        {
            getline(ProdConfFile,Line);

            std::vector<std::string> token = split(Line,' ');

            unsigned int val;
            std::istringstream ( token[token.size()-1] ) >> val;

            if(contains(Line,"TraceLength")) fTraceLengthRaw = (unsigned int) val;
            if(contains(Line,"CrystalID")) crystal_id = (unsigned int) val;
        }
    }
    else
    {
        std::cout<<"\E[31;1m"<<ConfFilePath.data()<<" not found !"<<"\E[m"<<std::endl;
        *error_code = 1u;
        return;
    }

    ADF::CrystalInterface::kDefaultLength = fTraceLengthRaw;

    fFrameCrystal_Out = fTrigger.SetOutputFrame("Agata", "data:crystal");

    if(fFrameCrystal_Out) {
        // link named items with local variables.
        GObject *glob = GetDataPointer<CrystalInterface>(fFrameCrystal_Out)->Global();
        glob->LinkItem("CrystalID",     &crystal_id);
        glob->LinkItem("CrystalStatus", &crystal_status);
    }

    GetFrameIO().Register(&fTrigger);

    GetFrameIO().SetModel(ConfAgent::kSafe);

    // initialise the internal structures

    evnumber = 0;
    timestamp = 0;

    for(int atseg = 0; atseg < kNSG; atseg++) {
        SegmentTraces[atseg] = new unsigned short[fTraceLengthRaw];
        memset(SegmentTraces[atseg], 0, sizeof(unsigned short)*fTraceLengthRaw);
        SegE[atseg] = 0;
        SegID[atseg] = 0;
        SegStatus[atseg] = 0;
    }
    for(int atcore = 0; atcore < kNCC; atcore++) {
        CoreTraces[atcore] = new unsigned short[fTraceLengthRaw];
        memset(CoreTraces[atcore], 0, sizeof(unsigned short)*fTraceLengthRaw);
        CoreE[atcore] = 0;
        CoreID[atcore] = 0;
        CoreStatus[atcore] = 0;
    }

    // open the first file
    if ( *error_code == 0u )
        if ( !NewFile() )
            *error_code = 2u;

    Log << dolog;

    if(fdebug) std::cout<<"\E[31;1m"<<"process_initialise out"<<"\E[m"<<std::endl;
}


void ReadMezzAFP::process_reset (unsigned int *error_code)
{
    *error_code = 0u;
    Log.ClearMessage(); Log.SetProcessMethod("process_reset");

    if ( fCurrentFile )
        ::fclose(fCurrentFile);
    fCurrentFileNumber = 0u;
    fConfMode = -1;

    GetFrameIO().Print( Log() );

    Log << dolog;
}

std::vector<std::string> ReadMezzAFP::split(std::string s, char c)
{
    const char* str = s.c_str();

    std::vector<std::string> result;

    do
    {
        const char *begin = str;

        while(*str != c && *str)
            str++;

        result.push_back(std::string(begin,str));
    }
    while (0 != *str++);

    return result;
}

bool ReadMezzAFP::replace(std::string& str, const std::string& from, const std::string& to)
{
    size_t start_pos = str.find(from);
    if(start_pos == std::string::npos) return false;
    str.replace(start_pos,from.length(), to);
    return true;
}


bool ReadMezzAFP::contains(std::string s1, std::string s2)
{
    if(s1.find(s2) != std::string::npos) return true;
    else return false;
}

unsigned int ReadMezzAFP::uncompress_single_trace_AB(unsigned char* compr, unsigned int csize, unsigned short* trace)
{
    unsigned char* compressed = compr;
    unsigned char* c_end = compr + csize;

    // first trace point is verbatim (little endian)
    unsigned char p1 = *compressed++, p2 = *compressed++;
    unsigned short ref = p2<<8 | p1;
    trace[0] = ref^0x2000;

    unsigned int midx;
    for(midx=1; compressed<c_end && midx<fTraceLengthRaw; ++midx) {
        const unsigned char packed = *compressed++;
        if( (packed & 0x80) == 0 ) {
            // three trace points as two differences
            const unsigned char p2 = *compressed++;
            const unsigned short packed2 = packed<<8 | p2;
            const int diff1 = ((packed2>>10) & 0x1F) - 15;
            const int diff2 = ((packed2>> 5) & 0x1F) - 15;
            const int diff3 = ( packed2      & 0x1F) - 15;
            ref += diff1;
            trace[midx++] = ref^0x2000;
            ref += diff2;
            trace[midx++] = ref^0x2000;
            ref += diff3;
        } else if( (packed & 0xC0) == 0xC0 ) {
            if( compressed>=c_end )
                return false;
            // one trace point as copy
            ref = (packed&0x3F)<<8 | *compressed++;
        } else {
            // one trace point as difference to previous
            const int diff1 = (packed & 0x3F) + MIN_1x6;
            ref += diff1;
        }
        trace[midx] = ref^0x2000;
    }
    return midx;
}

int ReadMezzAFP::ReadEvent()
{
    int lenChanData;      // MAX number of samples
    int lenChanTotal;     // lenChanHeader + lenChanData
    int lenMezzTotal;     // lenMezzHeader + lenChanTotaln*Chan
    int NChan = 6;

    lenChanData   = fTraceLengthRaw;
    lenChanTotal  = mezzanineChanHeader + lenChanData;
    lenMezzTotal  = mezzanineMezzHeader + lenChanTotal*NChan;

    std::vector < std::pair < unsigned long long, unsigned short > > ListOfTS;

    for(int mezz=0 ; mezz<7 ; mezz++)
    {
        unsigned short* BuffChannHead = new unsigned short[mezzanineMezzHeader];
        memset(BuffChannHead, 0, sizeof(unsigned short)*mezzanineMezzHeader);

        fread((void *)BuffChannHead, sizeof(unsigned short), mezzanineMezzHeader, fCurrentFile);
        ReadEntryFileSize += mezzanineMezzHeader*sizeof(unsigned short);

        unsigned short SlotId = BuffChannHead[0] & 0x0F ;
        evnumber = (unsigned int) BuffChannHead[1] | (unsigned int) BuffChannHead[2] << 16;
        timestamp = (unsigned long long)BuffChannHead[3] | (unsigned long long)BuffChannHead[4] << 16 | (unsigned long long)BuffChannHead[5] << 32;

        unsigned short TraceLen = BuffChannHead[6];
        unsigned short MezzLen= BuffChannHead[7];
        unsigned short DomainId = BuffChannHead[8] & 0xFF;
        unsigned int ActMezzLen = BuffChannHead[15];

        bool alreadyseen = false;

        for(unsigned int itest=0 ; itest<ListOfTS.size() ; itest++)
        {
            std::pair < unsigned long long, unsigned short > *a_pair = &ListOfTS[itest];
            if(timestamp == a_pair->first)
            {
                a_pair->second = a_pair->second+1;
                alreadyseen = true;
            }
        }

        if(!alreadyseen)
        {
            std::pair < unsigned long long, unsigned short > a_pair;
            a_pair.first = timestamp;
            a_pair.second = 1;

            ListOfTS.push_back(a_pair);
        }

        if(::feof(fCurrentFile))
        {
            if(SlotId != 0 && fdebug)
            {
                fBashColor->SetWarningOut();
                std::cout<<"File stoped after reading the header of mezzanine ID : "<<SlotId<<std::endl;
                std::cout<<"Timestamp = "<<timestamp<<std::endl;
                std::cout<<"Event number = "<<evnumber<<std::endl;
                fBashColor->ResetColor();
            }

            delete [] BuffChannHead;
            return 0;
        }

        if(SlotId<1 || SlotId>7)
        {
            std::cout<<"\E[31;1m"<<"Bad Header, SlotID = "<<SlotId<<"\E[m"<<std::endl;
        }

        if(TraceLen!=fTraceLengthRaw)
        {
            fBitFlipTraceLength++;

            if(fdebug)
            {
                unsigned int NormalTraceLength = 100;
                std::cout<<"Normal TraceLength "<<std::setw(4)<<NormalTraceLength<<std::setw(6)<<std::hex<<NormalTraceLength<<std::dec<<std::setw(20)<<ConvertToBinary(NormalTraceLength)<<std::endl;
                std::cout<<"Actual TraceLength "<<std::setw(4)<<TraceLen<<std::setw(6)<<std::hex<<TraceLen<<std::dec<<std::setw(20)<<ConvertToBinary(TraceLen)<<std::endl;

                std::cout<<"\E[31;1m"<<"Number of samples different from configuration file"<<"\E[m"<<std::endl;
                std::cout<<"TraceLen = "<<TraceLen<<std::endl;
            }
        }

        // read and decompress
        int toread = ActMezzLen;

        if(toread==0) //not compressed
        {
            toread = MezzLen;
            if(toread == 0) // initial format did not contain total length
                toread = (TraceLen+mezzanineChanHeader)*NChan + mezzanineMezzHeader;
        }

        unsigned short *compBuffer = new unsigned short[toread];
        memset(compBuffer, 0, sizeof(unsigned short)*toread);

        toread -= mezzanineMezzHeader;

        fread(compBuffer, sizeof(unsigned short), toread, fCurrentFile);
        ReadEntryFileSize += toread*sizeof(unsigned short);

        if(::feof(fCurrentFile))
        {
            if(SlotId != 7 && fdebug)
            {
                fBashColor->SetWarningOut();
                std::cout<<"File stoped after reading the traces of mezzanine ID : "<<SlotId<<std::endl;
                std::cout<<"Timestamp = "<<timestamp<<std::endl;
                std::cout<<"Event number = "<<evnumber<<std::endl;
                fBashColor->ResetColor();
            }
            delete [] BuffChannHead;
            delete [] compBuffer;
            return 0;
        }

        int numchan = (MezzLen-mezzanineMezzHeader)/(TraceLen+mezzanineChanHeader);

        if(numchan!=NChan)
        {
            fBitFlipMezzLength++;

            if(fdebug)
            {
                unsigned int NormalLength = 664;
                std::cout<<"Normal MezzLength "<<std::setw(4)<<NormalLength<<std::setw(6)<<std::hex<<NormalLength<<std::dec<<std::setw(20)<<ConvertToBinary(NormalLength)<<std::endl;
                std::cout<<"Actual MezzLength "<<std::setw(4)<<MezzLen<<std::setw(6)<<std::hex<<MezzLen<<std::dec<<std::setw(20)<<ConvertToBinary(MezzLen)<<std::endl;

                fBashColor->SetWarningOut();
                std::cout<<"\E[31;1m"<<"Number of channels non equal to "<<NChan<<"\E[m"<<std::endl;
                std::cout<<"numchan = "<<numchan<<std::endl;
                fBashColor->ResetColor();
            }
        }

        unsigned short* dbuffer = new unsigned short[lenMezzTotal];
        memset(dbuffer, 0, sizeof(unsigned short)*lenMezzTotal);
        unsigned int PosInBuff=0;

        memcpy(dbuffer, BuffChannHead, sizeof(unsigned short)*mezzanineMezzHeader);

        delete [] BuffChannHead;

        unsigned short *pD = dbuffer + mezzanineMezzHeader;
        unsigned short *pC = compBuffer;

        dbuffer += mezzanineMezzHeader;
        PosInBuff += mezzanineMezzHeader;

        for(int nn = 0; nn < NChan; nn++) {

            memcpy(pD, pC, sizeof(unsigned short)*mezzanineChanHeader);
            pC += mezzanineChanHeader;
            pD += mezzanineChanHeader;
            unsigned int csize = pD[-1];
            unsigned int ctype = pD[-2] & 0xF;
            int ll = 0;

            if(ctype==0) //no compression
            {
                memcpy(dbuffer, compBuffer, sizeof(unsigned short)*toread);
                break;
            }
            else if(ctype==1)
            {
                ll = uncompress_single_trace_AB((unsigned char *)pC, 2*csize, pD);
            }
            else
            {
                std::cout<<"WARNING : Compression type unkown : "<<ctype<<std::endl;

                std::cout<<"Mezzanine Header :"<<std::endl;
                std::cout<<"SlotId = "<<SlotId<<std::endl;
                std::cout<<"EvNumb = "<<evnumber<<std::endl;
                std::cout<<"Tstamp = "<<timestamp<<std::endl;
                std::cout<<"TraceLen = "<<TraceLen<<std::endl;
                std::cout<<"MezzLen = "<<MezzLen<<std::endl;
                std::cout<<"DomainId = "<<DomainId<<std::endl;
                std::cout<<"ActMezzLen = "<<ActMezzLen<<std::endl<<std::endl;
                std::cout<<std::endl;

                delete [] compBuffer;
                dbuffer -= PosInBuff;
                delete [] dbuffer;

                return 2;
            }
            pD[-1] = 0; // remove compression tags
            pD[-2] = 0;
            pC += csize;;
            pD += ll;
        }

        if(fdebug)
        {
            std::cout<<"Mezzanine Header :"<<std::endl;
            std::cout<<"SlotId = "<<SlotId<<std::endl;
            std::cout<<"EvNumb = "<<evnumber<<std::endl;
            std::cout<<"Tstamp = "<<timestamp<<std::endl;
            std::cout<<"TraceLen = "<<TraceLen<<std::endl;
            std::cout<<"MezzLen = "<<MezzLen<<std::endl;
            std::cout<<"DomainId = "<<DomainId<<std::endl;
            std::cout<<"ActMezzLen = "<<ActMezzLen<<std::endl<<std::endl;
            std::cout<<std::endl;
        }

        for(int i=0 ; i<NChan ; i++)
        {
            if(dbuffer[0] > 7) fBitFlipSegId++;

            int ID = dbuffer[0];// & 7; /// & 7 to put a mask only on the 3 first bits, to avoid bit flipping

            if(ID != i )
            {
                fBitFlipSegId++;
            }

            ID = i;

            int ener32 = dbuffer[2];
            ener32 = (ener32 << 16) | dbuffer[1];

            int SegId = (SlotId-2)*6+(5-ID);
            if((SegId<0 || SegId  >37) && SlotId>1)
            {
                std::cout<<std::endl;
                std::cout<<"SegID = "<<SegId<<std::endl;
                std::cout<<"SlotId = "<<SlotId<<std::endl;
                std::cout<<"ID = "<<ID<<std::endl;
            }

            float Ener = float(ener32)/(1<<16);
            int Status = dbuffer[3];
            int CompType = dbuffer[6];
            int CompTraceLen = dbuffer[7];

            if(SlotId==1 && (ID==0 || ID==1))
            {
                CoreE[ID] = Ener;
                CoreStatus[ID] = Status;
                CoreID[ID] = ID;
            }
            else if(SlotId==1) {;}
            else
            {
                SegE[SegId] = Ener;
                SegStatus[SegId] = Status;
                SegID[SegId] = SegId;
            }

            if(fdebug)
            {
                if(SlotId==1 && !(ID==0 || ID==1)) break;

                fBashColor->SetInfoOut();
                std::cout<<std::endl;
                if(SlotId!=1)
                {
                    std::cout<<"trace ID = "<<ID<<std::endl;
                    std::cout<<"Seg ID = "<<SegId<<std::endl;
                }
                else std::cout<<"core ID = "<<ID<<std::endl;
                std::cout<<"Ener = "<<Ener<<std::endl;
                std::cout<<"Status = "<<Status<<std::endl;
                std::cout<<"CompType = "<<CompType<<std::endl;
                std::cout<<"CompTraceLen = "<<CompTraceLen<<std::endl;
                std::cout<<std::endl;
                fBashColor->ResetColor();
            }

            dbuffer += mezzanineChanHeader;
            PosInBuff += mezzanineChanHeader;

            unsigned short tmp16;

            for(unsigned int j=0 ; j<fTraceLengthRaw ; j++)
            {
                tmp16  = dbuffer[j];
                tmp16 &= 0x3FFF;                        // keep 14 bits
                tmp16 ^= 0x2000;                        // reverse highest ADC bit
                //            tmp16  = 0x3FFF - tmp16;                // change sign

                if(Status==0) break;

                if(SlotId==1 && (ID==0 || ID==1)) CoreTraces[ID][j] = tmp16;
                else if(SlotId==1) break;
                else SegmentTraces[SegId][j] = tmp16;
            }

            dbuffer += fTraceLengthRaw;
            PosInBuff += fTraceLengthRaw;
        }

        delete [] compBuffer;
        dbuffer -= PosInBuff;
        delete [] dbuffer;
    }


    if(ListOfTS.size() !=1 )
    {
        int NViews = 0;

        fBitFlipTS++;

        for(unsigned int itest=0 ; itest<ListOfTS.size() ; itest++)
        {
            std::pair < unsigned long long, unsigned short > a_pair = ListOfTS[itest];
            if(a_pair.second>NViews)
            {
                NViews = a_pair.second;
                timestamp = a_pair.first;
            }
        }
    }

    if(FirstTimeStamp == 0 ) FirstTimeStamp = timestamp;
    LastTimeStamp = timestamp;

    return 1;
}

void ReadMezzAFP::NextKeyToFind()
{
    if(fKeyFilterBuffer->FreeSize()==0)
    {
        fBashColor->SetInfoOut();
        std::cout<<"The last key of the key filter file has been read."<<std::endl;
        fBashColor->ResetColor();
        fLastKeyIsRead = true;
        return;
    }

    fKeyToLink->Link((*fKeyFilterBuffer),fKeyFilterBuffer->Offset(),fKeyToLink->GetKeyLength());

    fKeyFilterBuffer->SetOffset(fKeyFilterBuffer->Offset()+fKeyToLink->GetKeyLength());

    fNextTS = fKeyToLink->GetTimeStamp();
    fNextEvtNbr = fKeyToLink->GetEventNumber();

    //        fBashColor->SetColor(BashColor::kRed);
    //        std::cout<<"timestamp = "<<fNextTS<<std::endl;
    //        std::cout<<"EventNumber = "<<fNextEvtNbr<<std::endl;
    //        std::cout<<AgataKeyFactory::theFactory()->GetMessage(fKeyToLink->GetMessage());
    //        fBashColor->ResetColor();
}

void ReadMezzAFP::PrintStats()
{
    fBashColor->SetInfoOut();

    std::cout<<"********  MezzAFP producer stats:  ********"<<std::endl<<std::endl;

    std::cout<<"Crystal: "<<fCrystalName<<std::endl;

    std::cout<<"Number of imput events             : "<<fNEvts<<std::endl;
    std::cout<<"First TimeStamp seen               : "<<FirstTimeStamp<<std::endl;
    std::cout<<"Last TimeStamp seen                : "<<LastTimeStamp<<std::endl;

    double TotalTimeInS = (LastTimeStamp-FirstTimeStamp)*10.*1e-9;

    int TH = (int)(TotalTimeInS/3600.);
    int TMin = (int)((TotalTimeInS/3600.-TH)*60.);
    int TSec = (int)(((TotalTimeInS/3600.-TH)*60.-TMin)*60.);

    std::cout<<"Elapsed time (s)                   : "<<TotalTimeInS<<" ( "<<TH<<"h"<<TMin<<"'"<<TSec<<"'' )"<<std::endl<<std::endl;

    if(fUseKeyFilter)
    {
        std::cout<<"Number of filtered events          : "<<fNEvts-fNIgnoredEvts<<" ( "<<((float)(fNEvts-fNIgnoredEvts))/((float)fNEvts)*100.<<"\% )"<<std::endl;
        std::cout<<"Number of ignored events           : "<<fNIgnoredEvts<<" ( "<<((float)fNIgnoredEvts)/((float)fNEvts)*100.<<"% )"<<std::endl;
    }

    fBashColor->SetErrorOut();
    if(fBitFlipMezzLength>0)  std::cout<<"Number of MezzLength flipped bits  : "<<fBitFlipMezzLength<<std::endl;
    if(fBitFlipTraceLength>0) std::cout<<"Number of TraceLength flipped bits : "<<fBitFlipTraceLength<<std::endl;
    if(fBitFlipSegId>0)       std::cout<<"Number of SegId flipped bits       : "<<fBitFlipSegId<<std::endl;
    if(fBitFlipTS>0)          std::cout<<"Number of Timestamp flipped bits   : "<<fBitFlipTS<<std::endl;
    fBashColor->SetInfoOut();

    std::cout<<std::endl<<"*******************************************"<<std::endl;

    fBashColor->ResetColor();
    return;
}

void ReadMezzAFP::ResetStats()
{
    fNEvts=0;
    fNIgnoredEvts=0;

    fBitFlipMezzLength = 0;
    fBitFlipTraceLength = 0;
    fBitFlipSegId = 0;
    fBitFlipTS = 0;

    FirstTimeStamp = 0;
    LastTimeStamp = 0;
}

std::string ReadMezzAFP::ConvertToBinary(unsigned long long n)
{
    std::ostringstream *bin = new std::ostringstream();

    ProcessConvToBinary(n, bin);

    std::string binvalue = ((std::string)(*bin).str());
    delete bin;

    return binvalue;
}

void ReadMezzAFP::ProcessConvToBinary(unsigned long long n, std::ostringstream *str)
{
    if (n / 2 != 0) {
        ProcessConvToBinary(n / 2, str);
    }
    (*str)<<(int)(n % 2);
}