/data3/calcul/jacquem/working_dir/Micromegas/micromegasFrameWork/src/parser/DiracReader.cpp

Go to the documentation of this file.

/* @version $Revision: 1328 $ * @modifiedby $Author: jacquem $ * @lastmodified $Date: 2011-10-03 17:04:17 +0200 (Mon, 03 Oct 2011) $ */

////////////////////////////////////////////////////////////////////////
// MICROMEGAS
//
//       EVENT RECONSTRUCTION SOFTWARE FOR DIRAC BOARDS
//
////////////////////////////////////////////////////////////////////////
// v1 26.10.2009
////////////////////////////////////////////////////////////////////////
// timestamp (v1) :
//   t(hit) = t(lecture) - t2 + t3
//   l(lecture) = t0 + (t1 - t10)
//   avec
//     t0 = timestamp unix (32 bits, avec ou sans millisecondes)
//     t1 = BcId absolu (bcId_Abs, 48 bits)
//     t10 = premiere lecture de t1
//     t2 = BcId pour la DIF (bcId_HRHit, 24 bits)
//     t3 = BCId pour la HR (bcId_Hit, 24 bits en CODE GRAY)
////////////////////////////////////////////////////////////////////////

#include <stdio.h>
#include <errno.h>

#include "parser/DiracReader.hh"
#include "parser/AcquisitionParser.hh"

#include "event/Event.hh"

#include "geometry/Chamber.hh"
#include "geometry/DiracChamber1.hh"
#include "geometry/Detector.hh"
#include "geometry/Dif.hh"
#include "geometry/Board.hh"
#include "geometry/Chip.hh"
#include "geometry/DiracChip.hh"

#include "tools/Toolbox.hh"
#include "tools/MicroException.hh"
#include "tools/SteerDesc.hh"
#include "tools/Log.hh"

#include <iostream>
#include <iomanip>
#include <string>

using namespace std;

////////////////////////////////////////////////////////////////////////
//-------------------------------------------------------------------

bool DiracChipConfig::read(unsigned char *buf) {
    // get 23 bytes which are shifted by 4 bits...
    char dataBuf[256];
    char *dataStr = dataBuf;
    // split the string into correct data
    for (int dataNum = 0; dataNum < 23; dataNum++) {
        unsigned int data = *buf++;
        dataStr += sprintf(dataStr, "%02X", data);
    }
    *dataStr = 0;
    dataStr = dataBuf;
    unsigned int data;

    // 4-bit data
    sscanf(dataStr, "%1x", &data);
    dataStr++;
    gain = data & 0x03;
    analogData = (data & 0x08) != 0;

    // 3 thresholds for channels 32-63 (B-data), 8 bits each
    sscanf(dataStr, "%2x", &data);
    dataStr += 2;
    bHiThreshold = data;
    sscanf(dataStr, "%2x", &data);
    dataStr += 2;
    bMidThreshold = data;
    sscanf(dataStr, "%2x", &data);
    dataStr += 2;
    bLoThreshold = data;
    // configuration bits for 32 channels
    for (int bChNum = 63; bChNum >= 32; bChNum -= 4) {
        // 2 bits for each channel
        sscanf(dataStr, "%2x", &data);
        dataStr += 2;
        unsigned char mask = 0x80;
        for (int chNum = 0; chNum <= 3; chNum++) {
            chConfig[bChNum - chNum].test = (data & mask) != 0;
            mask >>= 1;
            chConfig[bChNum - chNum].enable = (data & mask) != 0;
            mask >>= 1;
        }
    }
    // 3 thresholds for channels 31-0 (A-data), 8 bits each
    sscanf(dataStr, "%2x", &data);
    dataStr += 2;
    aHiThreshold = data;
    sscanf(dataStr, "%2x", &data);
    dataStr += 2;
    aMidThreshold = data;
    sscanf(dataStr, "%2x", &data);
    dataStr += 2;
    aLoThreshold = data;
    // configuration bits for 32 channels
    for (int aChNum = 31; aChNum >= 0; aChNum -= 4) {
        // 2 bits for each channel
        sscanf(dataStr, "%2x", &data);
        dataStr += 2;
        unsigned char mask = 0x80;
        for (int chNum = 0; chNum <= 3; chNum++) {
            chConfig[aChNum - chNum].test = (data & mask) != 0;
            mask >>= 1;
            chConfig[aChNum - chNum].enable = (data & mask) != 0;
            mask >>= 1;
        }
    }

    FILE_LOG(logDEBUG1) << "  DiracChipConfig read" << endl;
    return (true);
}; // DiracChipConfig.read

////////////////////////////////////////////////////////////////////////
//-------------------------------------------------------------------

bool DiracDifConfig::read(unsigned char *buf) {
    // read 19 bytes of DIF config
    unsigned int data = *buf++; // read 8 bits
    id = data;

    data = *buf++; // read 8 bits
    powerPulsing = (data & 0x40) != 0; // bit 6
    analogReading = (data & 0x20) != 0; // bit 5
    digitalReading = (data & 0x10) != 0; // bit 4
    acqMode = data & 0x0F; // 4 bits (0-3)

    data = *buf++ << 8; // read 16 bits
    data += *buf++;
    lowState = data & 0x03FF; // 10 bits (0-9)

    data = *buf++ << 8; // read 16 bits
    data += *buf++;
    highState = data & 0x03FF; // 10 bits (0-9)
    data = *buf++; // read 8 bits
    afterState = data & 0x3F; // 6 bits (0-5)
    data = *buf++; // read 8 bits
    beforeState = data & 0x3F; // 6 bits (0-5)

    data = *buf++ << 8; // read 16 bits
    data += *buf++;
    inverted = (data & 0x0800) != 0; // bit 11

    ctestEnable = (data & 0x0400) != 0; // bit 10
    ctestPeriod = data & 0x03FF; // 10 bits (0-9)

    data = *buf++ << 8; // read 16 bits
    data += *buf++;
    ctestDelay = data & 0x03FF; // 10 bits(0-9)

    data = *buf++ << 8; // read 16 bits
    data += *buf++;
    ctestWidth = data & 0x03FF; // 10 bits(0-9)

    data = *buf++ << 8; // read 16 bits
    data += *buf++;
    triggerDelay = data & 0x03FF; // 10 bits(0-9)

    data = *buf++ << 24; // read 32 bits
    data += *buf++ << 16;
    data += *buf++ << 8;
    data += *buf++;
    charge = data; // 32 bits

    bcPeriod = (lowState + highState) * 10; // bunch crossing period in nanoseconds
    FILE_LOG(logDEBUG1) << "  DIF #" << id << " : mode " << acqMode << ", BC period = " << bcPeriod << endl;
}; // DiracDifConfig::read

////////////////////////////////////////////////////////////////////////
//-------------------------------------------------------------------

DiracTriggerInfo::DiracTriggerInfo() : bcId(0) {
    for (int chNum = 0; chNum < 64; chNum++)
        data[chNum] = 0;
}; // DiracTriggerInfo

//-------------------------------------------------------------------

bool DiracTriggerInfo::read(unsigned char *buf) {

    // initialize chip data
    bcId = 0;
    for (int chNum = 0; chNum < 64; chNum++)
        data[chNum] = 0;

    // get bcId from DIF (Fpga)
    bcIdFpga = *buf++ << 8; // read 16 bits
    bcIdFpga += *buf++;

    // get absolute bcId - does not work unless data is casted into i64 !
    bcIdAbs = ((i64) (*buf++)) << 40; // read 48 bits
    bcIdAbs += ((i64) (*buf++)) << 32;
    bcIdAbs += ((i64) (*buf++)) << 24;
    bcIdAbs += ((i64) (*buf++)) << 16;
    bcIdAbs += ((i64) (*buf++)) << 8;
    bcIdAbs += ((i64) (*buf++));

    // get last data
    unsigned int data = (*buf++ << 8); // read 16 bits
    data += *buf++;
    reject = (data & 0x0001); // bit 0
    pileUp = (data & 0x003E) >> 1; // 5 bits (1-5)
    trigger = (data & 0xFFC0) >> 6; // 10 bits (6-15)

    FILE_LOG(logDEBUG) << "    bcIdFPGA:" << hex << bcIdFpga
            << ", bcIdAbs:" << hex << bcIdAbs
            << ", data:" << hex << data
            << ", reject:" << hex << reject
            << ", pileUp:" << hex << pileUp
            << ", trigger:" << hex << trigger << endl;

    FILE_LOG(logDEBUG1) << "  DiracTriggerInfo read" << endl;

    return true;
}; // DiracTriggerInfo.read


////////////////////////////////////////////////////////////////////////

DiracReader::DiracReader(Run& aRun, FILE *aFile, ui32 _firstEventId) : DifReader(aRun, aFile, _firstEventId) {
    reset();
}

//--------------- Destructeur -------------//

DiracReader::~DiracReader() {
} // ~DiracReader

//-------------------------------------------------------------------

void DiracReader::reset() {
    nbDifs = 0;
    CRC = 0;
    bcId_AbsOrg = -1; // the bcId origin
} // DiracReader.reset

//-------------------------------------------------------------------
// get DIF config and fill with other data

int DiracReader::getConfigData() {
    int difId = getBinData(1); // read 8 bits

    for (int difNum = 0; difNum < difConfigs.size(); difNum++) {
        DiracDifConfig& difConfig = difConfigs[difNum];
        if (difConfig.id == difId) {
            difConfig.nbChips = getBinData(1); // read 8 bits

            display();
            FILE_LOG(logDEBUG1) << " DIF #" << difConfig.id << " : " << difConfig.nbChips << " chips" << endl;

            for (int chipNum = 0; chipNum < difConfig.nbChips; chipNum++) {
                DiracChipConfig chipConfig;

                unsigned char buf[24];
                getBinData(23, buf);
                display();
                chipConfig.read(buf);
                // InitGetBits(23);
                // chipconfg.read();   <--- GetBits(n);
                // FinishGetBits();

                difConfig.chipConfigs.push_back(chipConfig);

                const Detector &detector = run.getDetector();
                try
                {
                    Dif& dif = detector.getDifById(difId);
                    BoardMap_t boards = dif.getBoards();
                    for (BoardMap_t::iterator boardIt = boards.begin(); boardIt != boards.end(); boardIt++) {
                        Board& b = *boardIt->second;
                        try
                        {
                            DiracChip& chip = dynamic_cast<DiracChip&> (b.getChipById(chipNum));
                            chip.setBLoThreshold(chipConfig.bLoThreshold);
                            chip.setBMidThreshold(chipConfig.bMidThreshold);
                            chip.setBHiThreshold(chipConfig.bHiThreshold);
                            chip.setALoThreshold(chipConfig.aLoThreshold);
                            chip.setAMidThreshold(chipConfig.aMidThreshold);
                            chip.setAHiThreshold(chipConfig.aHiThreshold);
                            chip.setGain(chipConfig.gain);
                            for (int chNum = 0; chNum < 64; chNum++) {
                                Channel& ch = chip.getChannelById(chNum);
                                ch.setEnable(chipConfig.chConfig[chNum].enable);
                                ch.setStimulate(chipConfig.chConfig[chNum].test);
                            }
                            break;
                        }

                        catch(...) {
                        }
                    }
                }

                catch(...) {
                }
            }

            if (difConfigs.size() > nbDifs) {
                FILE_LOG(logERROR) << "DIF config error" << endl;
                return (0);
            }
            return (1);
        } // if
    } // for

    FILE_LOG(logERROR) << "DIF #" << difId << " not found" << endl;
    return (0);
} // DiracReader.getConfigData

//-------------------------------------------------------------------

int DiracReader::getAcqData() {
    acqDifId = getBinData(1); // read 8 bits
    unsigned int nbTotalTrigger = getBinData(4);
    unsigned int nbTrigger = getBinData(4);
    display();

    FILE_LOG(logDEBUG) << "  data for DIF #" << acqDifId << ", " << nbTotalTrigger << " total, " << nbTrigger << " triggers" << endl;

    // look for current DIF configuration
    for (int difNum = 0; difNum < difConfigs.size(); difNum++) {
        const DiracDifConfig& difConfig = difConfigs[difNum];
        if (difConfig.id == acqDifId) {
            // read 8 trigger informations (10 bytes each)
            for (int trigInfoNum = 0; trigInfoNum < 8; trigInfoNum++) {
                unsigned char buf[11];
                getBinData(10, buf);
                display();
                trigInfos[trigInfoNum].read(buf);
            }

            // set the origin for absolute bcId
            //      if (bcId_AbsOrg == -1) {
            //        // set the absolute bcId origin
            //        bcId_AbsOrg = trigInfos[0].bcIdAbs;
            //        FILE_LOG(logDEBUG)   << "    set bc origin         " << bcId_AbsOrg << endl;
            //      }
            bcId_AbsOrg = getbcIdAbsOrg(acqDifId, trigInfos[0].bcIdAbs);
            FILE_LOG(logDEBUG) << " getbcIdAbsOrg(" << acqDifId << " , trigInfos[0].bcIdAbs)  " << getbcIdAbsOrg(acqDifId, trigInfos[0].bcIdAbs) << endl;

            // the following is sent for every chip for the given DIF
            for (int chipNum = 0; chipNum < difConfig.nbChips; chipNum++) {
                unsigned int header = getBinData(1);
                if (header != 0xB4) {
                    FILE_LOG(logERROR) << "parsing file error : header 0xB4 not found" << endl;
                    return (0);
                }
                display(+1);

                // get 8 bcIds (96 bits = 12 bytes) <-> 8 triggers * 12-bit bcId
                for (int bitNum = 11; bitNum >= 0; bitNum--) {
                    const unsigned int data = getBinData(1);
                    unsigned int mask = 0x80;
                    for (int trigNum = 0; trigNum < 8; trigNum++, mask >>= 1) {
                        DiracTriggerInfo& trigInfo = trigInfos[trigNum];
                        unsigned int bit = ((data & mask) != 0) ? 1 : 0;
                        trigInfo.bcId |= bit << bitNum;
                    }
                }
                display();

                // get 8 channel data (1024 bits = 128 bytes) <-> 8 triggers * 64 channels * 2-bit data
                for (int chNum = 63; chNum >= 0; chNum--) {
                    for (int bitNum = 0; bitNum < 2; bitNum++) {
                        const unsigned int data = getBinData(1);
                        unsigned int mask = 0x80;
                        for (int trigNum = 0; trigNum < 8; trigNum++, mask >>= 1) {
                            DiracTriggerInfo& trigInfo = trigInfos[trigNum];
                            unsigned int bit = ((data & mask) != 0) ? 1 : 0;
                            trigInfo.data[chNum] |= bit << bitNum;
                        }
                    }
                    if (chNum == 32)
                        display();
                }
                display();

                header = getBinData(1);
                display(-1);
                if (header != 0xA3) {
                    FILE_LOG(logERROR) << "parsing file error : trailer 0xA3 not found" << endl;
                    return (0);
                }
            } // for chipNum

            return (1);
        } // if
    } // for difNum

    return (0);
} // DiracReader.getAcqData

//-------------------------------------------------------------------

int DiracReader::storeHits(Event& event) {
    int nbHits = 0;

    for (int difNum = 0; difNum < difConfigs.size(); difNum++) {
        const DiracDifConfig& difConfig = difConfigs[difNum];
        if (difConfig.id == acqDifId) {
            for (int chipNum = 0; chipNum < difConfig.nbChips; chipNum++) {

                for (int trigNum = 0; trigNum < 8; trigNum++) {
                    const DiracTriggerInfo& trigInfo = trigInfos[trigNum];

                    for (int chNum = 0; chNum < 64; chNum++) {
                        if (trigInfo.data[chNum]) {
                            if (newHit(event, difConfig, trigInfo, chipNum, chNum))
                                nbHits++;
                        }
                    }
                }
            } // for chipNum

            if (nbHits) {
                // CREATE EVENT for current Run
                event.setId(++lastEventId);
                FILE_LOG(logDEBUG1) << "  STORE EVENT " << lastEventId << ", " << nbHits << " hits" << endl;
            } else
                FILE_LOG(logDEBUG) << "  EMPTY EVENT" << endl;
            return (nbHits);
        } // if
    } // for difNum

    return (0);
} // DiracReader.storeHits

//-------------------------------------------------------------------

ChannelHit *DiracReader::newHit(Event& event, const DiracDifConfig& difConfig, const DiracTriggerInfo& trigInfo, const int chipNum, const int chNum) {
    const Detector &detector = run.getDetector();
    const ChamberMap_t &chambers = detector.getChambers();
    for (ChamberMap_t::const_iterator it = chambers.begin(); it != chambers.end(); ++it) {
        try
        {
            DiracChamber1& chamber = dynamic_cast<DiracChamber1&> (*(it->second));
            const BoardMap_t& boards = chamber.getBoardsByDifId(difConfig.id);
            // store new event data
            try
            {
                const Channel& channel = chamber.getChannelById(chNum, chipNum, difConfig.id);
                const int data = trigInfo.data[chNum];
                ChannelHit *hit = new ChannelHit(channel, data, 0);
                // all in bcPeriods - this depends on the acquisition mode
                i64 bcId_Abs; // absolute bc Id for current DIF ALWAYS @5MHz
                i64 bcId_Dif; // current bcId for current DIF
                i64 bcId_Hit; // bcId of current hit
                i64 bcId_Hit_Fine = trigInfos[0].trigger;

                //        if (difConfig.acqMode == 0x0A) {
                bcId_Abs = trigInfos[0].bcIdAbs;
                bcId_Dif = trigInfos[0].bcIdFpga;
                //        }
                //        else {
                //          bcId_Abs = trigInfo.bcIdAbs;
                //          bcId_Dif = trigInfo.bcIdFpga;
                //        }

                bcId_Hit = trigInfo.bcId;

                hit->setHardrocTime(globalTime, bcId_Abs, bcId_Dif, bcId_Hit,bcId_Hit_Fine);
                event.insertHit(chamber, hit);
                i64 timeStamp = (globalTime * 1000) // all in milliseconds
                        + ((trigInfo.bcIdAbs - bcId_AbsOrg) / 5000000) // ALWAYS @5MHz
                        + (((trigInfo.bcId - trigInfo.bcIdFpga) * difConfig.bcPeriod) / 1000);
                event.setTimeStamp(timeStamp);
                FILE_LOG(logDEBUG) << "bcId_Abs[" << bcId_Abs << "] - bcId_AbsOrg[" << bcId_AbsOrg << "] = [" << bcId_Abs - bcId_AbsOrg << "]" << endl;
                FILE_LOG(logDEBUG) << "  new Hit : ch " << chNum << ", chip " << chipNum << ", dif " << difConfig.id
                        << ", Time=" << timeStamp << "ms, bcId:abs=" << (bcId_Abs - bcId_AbsOrg) << ",dif=" << bcId_Dif << ",hit=" << bcId_Hit << " Data=" << data << endl;
                return (hit);
            }

            catch(MicroException & e) {
                FILE_LOG(logERROR) << "ch " << chNum << ", chip " << chipNum << ", dif " << difConfig.id << " : " << e.getMessage() << endl;
                return (0);
            }
        }

        catch(...) {
            continue;
        }

    } // for
    FILE_LOG(logERROR) << "ch " << chNum << ", chip " << chipNum << ", dif " << difConfig.id << " : geometry element not found" << endl;
    return (0);
} // DiracReader.newHit

//-------------------------------------------------------------------

void DiracReader::storeDifInfo(const int difId) {
    const Detector &detector = run.getDetector();
    try
    {
        Dif& dif = detector.getDifById(difId);
        for (int difNum = 0; difNum < difConfigs.size(); difNum++) {
            DiracDifConfig& difConfig = difConfigs[difNum];
            if (difConfig.id == difId) {
                dif.setAcqMode(difConfig.acqMode);
                dif.setLowRegister(difConfig.lowState);
                dif.setHighRegister(difConfig.highState);
                dif.setAfterRegister(difConfig.afterState);
                dif.setBeforeRegister(difConfig.beforeState);
                return;
            }
        }
    }

    catch(...) {
    };
}; // DiracReader.storeDifInfo

//-------------------------------------------------------------------
// LOOP over the data Files, returns after each event
//      called for every dif found in the data file.

int DiracReader::getNextEvent(Event& event) {
    // Start data reconstruction
    Level(0);

                i16 dataFormat = run.getDataFormat();
    if (dataFormat == -1) {
        // first read of the file
        try
        {
            bcIdDifAbsOrgMap.clear();
        }

        catch(exception & e) {
            FILE_LOG(logERROR) << "bcIdDifAbsOrgMap.clear():" << e.what() << endl;
        }
        // read file header
        dataFormat = getBinData(1);
                                run.setDataFormat(dataFormat);
        if (fileError == EOF) {
            FILE_LOG(logDEBUG) << "end of file found" << endl;
            reset();
            return (LAST_FILE_EVENT);
        }

        if (dataFormat != 1) {
            // unknown format
            FILE_LOG(logERROR) << "DIRAC data format " << dataFormat << " is not implemented" << endl;
            reset();
            return (LAST_FILE_EVENT);
        }

        nbDifs = getBinData(1);
        display(+1);
        FILE_LOG(logDEBUG) << "DIRAC data format : " << dataFormat << ", nb Dif = " << nbDifs << endl;

        for (int difNum = 0; difNum < nbDifs; difNum++) {
            // read DIF configuration
            DiracDifConfig difConfig;
            unsigned char buf[21];
            getBinData(20, buf);
            display();

            difConfig.read(buf);
            difConfigs.push_back(difConfig);

            // store data into Run info
            storeDifInfo(difConfig.id);

            // store info for the whole run
            run.setInjectedCharge(difConfigs[0].charge);
            run.setWidthCtest(difConfigs[0].ctestWidth);
            run.setPeriodCtest(difConfigs[0].ctestPeriod);
            run.setDelayCtest(difConfigs[0].ctestDelay);
            run.setDelayTrigger(difConfigs[0].triggerDelay);
        }
        display(-1);

        // get unix timestamp for the whole file (seconds since jan 1st, 1970)
        globalTime = getBinData(4);
        display();
        FILE_LOG(logDEBUG1) << "global time : " << globalTime << endl;
        return NEW_CONFIG;
    }

    for (unsigned int nbHits = 0; !nbHits;) {
        unsigned char header = getBinData(1);
        if (fileError == EOF) {
            FILE_LOG(logDEBUG) << "  END OF DATA FILE" << endl;
            reset();
            return (LAST_FILE_EVENT);
        }

        if (header == 0xB1) {
            // store all configuration data
            display(+1);
            getConfigData();
            if (getBinData(1) != 0xA1) {
                display(-1);
                FILE_LOG(logERROR) << "    frame trailer A1 not found" << endl;
                break;
            }
            display(-1);
        } else if (header == 0xB0) {
            // store all acquisition data
            display(+1);
            getAcqData();
            if (getBinData(1) != 0xA0) {
                display(-1);
                FILE_LOG(logERROR) << "    frame trailer A0 not found" << endl;
                break;
            }
            display(-1);
            CRC = getBinData(2);
            display();

            // then store all data
            nbHits = storeHits(event);
        } else {
            display();
            FILE_LOG(logERROR) << "    expected header not found" << endl;
        }

        if (fileError == EOF)
            break;
    }

    return EVENT_CORRECT;
} // DiracReader.getNextEvent

---