TowerBlockFormatter.cc

Go to the documentation of this file.

#include <memory>
#include <list>

// #include "DataFormats/Common/interface/Handle.h"

#include "EventFilter/EcalDigiToRaw/interface/TowerBlockFormatter.h"

#include "DataFormats/EcalDetId/interface/EBDetId.h"
#include "DataFormats/EcalDetId/interface/EcalDetIdCollections.h"
#include "DataFormats/FEDRawData/interface/FEDNumbering.h"

using namespace std;


TowerBlockFormatter::TowerBlockFormatter() {

}

TowerBlockFormatter::~TowerBlockFormatter() {

}



void TowerBlockFormatter::DigiToRaw(const EBDataFrame& dataframe, FEDRawData& rawdata,
                     const EcalElectronicsMapping* TheMapping)

{

 int bx = *pbx_;
 int lv1 = *plv1_ - 1;


  int rdsize = rawdata.size() / 8;  // size in Word64

        const EBDetId& ebdetid = dataframe.id();

    int DCCid = TheMapping -> DCCid(ebdetid);
    int FEDid = FEDNumbering::MINECALFEDID + DCCid ;


        int nsamples = dataframe.size();
                // -- FE number
        const EcalElectronicsId& elid = TheMapping -> getElectronicsId(ebdetid);
    int iFE = elid.towerId();
        if (iFE <= 0 || iFE > 68)  throw cms::Exception("InvalidFEid") << 
        "TowerBlockFormatter::DigiToRaw : Invalid iFE " << iFE << endl;


        map<int, map<int,int> >::iterator fen = FEDorder -> find(FEDid);
        map<int, map<int,int> >::iterator fed = FEDmap -> find(FEDid);

        if (fen == FEDorder -> end()) {
                if (debug_) cout << "New FED in TowerBlockFormatter " << dec << FEDid << " 0x" << hex << FEDid << endl;
        map<int,int> FEorder;
                pair<map<int, map<int,int> >::iterator, bool> t1 = FEDorder -> insert(map<int, map<int,int> >::value_type(FEDid,FEorder));
        map<int,int> FEmap;
        pair<map<int, map<int,int> >::iterator, bool> t2 = FEDmap -> insert(map<int, map<int,int> >::value_type(FEDid,FEmap));
                fen = t1.first;
        fed = t2.first;
        }

    map<int, int>& FEorder = (*fen).second;
        map<int, int>& FEmap = (*fed).second;

        map<int,int>::iterator fe = FEorder.find(iFE);
    int FE_order;
    int FE_index;
    if (fe != FEorder.end()) {
        FE_order = (*fe).second;
        map<int,int>::iterator ff = FEmap.find(FE_order);
        if (ff == FEmap.end()) cout << "Error with maps... " << endl;
        FE_index = (*ff).second; 
                if (debug_) cout << "FE already there, FE_index = " << dec << FE_index <<  " FEorder " << FE_order << endl;
    }
    else {
                if (debug_) cout << "New FE in TowerBlockFormatter  FE " << dec << iFE << " 0x" << hex << iFE << " in FED id " << dec << FEDid << endl;
        int inser = rdsize;
        int number_FEs = FEorder.size() -1;
                FE_order = number_FEs+1;
        pair<map<int,int>::iterator, bool> t2 = FEorder.insert(map<int,int>::value_type(iFE,FE_order)); 
        if (! t2.second) cout << " FE insertion failed...";
                pair<map<int,int>::iterator, bool> tt = FEmap.insert(map<int,int>::value_type(FE_order,inser));
                fe = tt.first;
        FE_index = (*fe).second;
        if (debug_) cout << "Build the Tower Block header for FE id " << iFE << " start at line " << rdsize << endl;
        if (debug_) cout << "This is the Fe number (order) " << number_FEs+1 << endl;
                rawdata.resize( 8*rdsize + 8);
        unsigned char* pData = rawdata.data();
        pData[8*FE_index] = iFE & 0xFF;
        pData[8*FE_index+1] = (nsamples & 0x7F);
        pData[8*FE_index+2] = bx & 0xFF;
        pData[8*FE_index+3] = (bx >>8) & 0x0F;
                pData[8*FE_index+3] |= 0xa0;
        pData[8*FE_index+4] = lv1 & 0xFF;
        pData[8*FE_index+5] = (lv1 >>8) & 0x0F;
        pData[8*FE_index+6] = 1;
        pData[8*FE_index+7] = 0xc0;
        if (debug_) print(rawdata);

        }


                // -- Crystal number inside the SM :

    int istrip = elid.stripId();
    int ichannel = elid.xtalId();

    if (debug_) cout << "Now add crystal : strip  channel " << dec << istrip << " " << ichannel << endl;


        unsigned char* pData = rawdata.data();

        vector<unsigned char> vv(&pData[0],&pData[rawdata.size()]);


        int n_add = 2 + 2*nsamples;     // 2 bytes per sample, plus 2 bytes before sample 0
        if (n_add % 8 != 0) n_add = n_add/8 +1;
    else
    n_add = n_add/8;
    if (debug_) cout << "will add " << n_add << " lines of 64 bits at line " << (FE_index+1) << endl;
        rawdata.resize( rawdata.size() + 8*n_add );
    unsigned char* ppData = rawdata.data();

        vector<unsigned char>::iterator iter = vv.begin() + 8*(FE_index+1);

    vector<unsigned char> toadd(n_add*8);


        int tzs=0;
    toadd[0] = (istrip & 0x7) + ((ichannel & 0x7)<<4);
    toadd[1] = (tzs & 0x1) <<12;

    for (int isample=0; isample < (n_add*8-2)/2; isample++) {
        if (isample < nsamples) {
                  uint16_t word = (dataframe.sample(isample)).raw();   // 16 bits word corresponding to this sample
          toadd[2 + isample*2] = word & 0x00FF;
          toadd[2 + isample*2 +1] = (word & 0xFF00)>>8; 
        }
        else {
          toadd[2 + isample*2] = 0;
          toadd[2 + isample*2 +1] = 0;
        }
        if (isample % 2 == 0) toadd[2 + isample*2 +1] |= 0xc0;  // need to add the B11 header...
        }

    vv.insert(iter,toadd.begin(),toadd.end());


    // update the pData for this FED :
    for (int i=0; i < (int)vv.size(); i++) {
        ppData[i] = vv[i];
    }

    if (debug_) {
      cout << "pData for this FED is now " << endl;
      print(rawdata);
    }

    // and update the FEmap for this FED :
    for (int i=FE_order+1; i < (int)FEorder.size(); i++) {
        FEmap[i] += n_add;
        if (debug_) cout << "FEmap updated for fe number " << dec << i << endl;
        if (debug_) cout << " FEmap[" << i << "] = " << FEmap[i] << endl;
    }

    // update the block length
    int blocklength = ppData[8*FE_index+6]
                + ((ppData[8*FE_index+7] & 0x1)<<8);
    blocklength += n_add;
    ppData[8*FE_index+6] = blocklength & 0xFF;
    ppData[8*FE_index+7] |= (blocklength & 0x100)>>8;



}



void TowerBlockFormatter::EndEvent(FEDRawDataCollection* productRawData) {

// -- Need to reorder the FE's in teh TowerBlock. They come in the right
//    order when reading the unsuppressed digis, but ganz durcheinander 
//    when reading the SelectiveReadout_Suppressed digis.

  if (debug_) cout << "enter in TowerBlockFormatter::EndEvent. First reorder the FE's. " << endl;

  for (int idcc=1; idcc <= 54; idcc++) {

    // debug_ = (idcc == 34);

    //if (idcc != 34) continue;

    int FEDid = FEDNumbering::MINECALFEDID + idcc;
    // cout << "Process FED " << FEDid << endl;
    FEDRawData& fedData = productRawData -> FEDData(FEDid);
    if (fedData.size() <= 16) continue;

    if (debug_) cout << "This is FEDid = " << FEDid << endl;

    unsigned char * pData = fedData.data();
    // Word64* words = reinterpret_cast<Word64*>(const_cast<unsigned char*>(pData));
    Word64* words = reinterpret_cast<Word64*>(pData);

    int length = fedData.size() / 8;
        int iDAQ_header(-1), iDCC_header(-1), iTCCBlock_header(-1),
                iSRBlock_header(-1), iTowerBlock_header(-1), iDAQ_trailer(-1);

        for (int i=length-1; i > -1; i--) {
        if (  ( (words[i] >> 60) & 0xF) == 0x5 ) iDAQ_header=i;
        if (  ( (words[i] >> 62) & 0x3) == 0x0 ) iDCC_header=i;
        if (  ( (words[i] >> 61) & 0x7) == 0x3 ) iTCCBlock_header=i;
        if (  ( (words[i] >> 61) & 0x7) == 0x4 ) iSRBlock_header=i;
        if (  ( (words[i] >> 62) & 0x3) == 0x3 ) iTowerBlock_header=i;
        if (  ( (words[i] >> 60) & 0xF) == 0xA ) iDAQ_trailer=i;
        }

        if (iTowerBlock_header < 0) iTowerBlock_header = iDAQ_trailer;
        if (iSRBlock_header < 0) iSRBlock_header = iTowerBlock_header;
        if (iTCCBlock_header < 0) iTCCBlock_header = iSRBlock_header;

    if (debug_) {
        cout << "iDAQ_header = " << iDAQ_header << endl;
        cout << " iDCC_header = " << iDCC_header << endl;
        cout << " iTCCBlock_header = " << iTCCBlock_header << endl;
        cout << " iSRBlock_header = " << iSRBlock_header << endl;
        cout << " iTowerBlock_header = " << iTowerBlock_header << endl;
        cout << " iDAQ_trailer = " << iDAQ_trailer << endl;
    }

    std::map<int, int> FrontEnd;
    std::map<int, std::vector<Word64> > Map_xtal_data;

    int iTowerBlock_header_keep = iTowerBlock_header;
    
    while (iTowerBlock_header < iDAQ_trailer) {
            int fe = words[iTowerBlock_header] & 0xFF;
        int nlines = (words[iTowerBlock_header] >> 48) & 0x1FF;
        if (debug_) cout << "This is FE number " << fe << "needs nlines = " << nlines << endl;
        FrontEnd[fe] = nlines;
        std::vector<Word64> xtal_data;
        for (int j=0; j < nlines; j++) {
            Word64 ww = words[iTowerBlock_header+j];
            xtal_data.push_back(ww);
        }
        Map_xtal_data[fe] = xtal_data;
        iTowerBlock_header += nlines;
    }

    if (debug_) {
        cout << "vector of FrontEnd : " << FrontEnd.size() << endl;
        for (std::map<int, int>::const_iterator it=FrontEnd.begin();
                        it != FrontEnd.end(); it++) {
            int fe = it -> first;
            int l = it -> second;
            cout << "FE line " << fe << " " << l << endl;
        }
    }

    iTowerBlock_header = iTowerBlock_header_keep;
    for (std::map<int, int>::const_iterator it=FrontEnd.begin();
            it != FrontEnd.end(); it++) {
        int fe = it -> first;
        int nlines = it -> second;
        if (debug_) cout << "iTowerBlock_header = " << iTowerBlock_header << endl;
        vector<Word64> xtal_data = Map_xtal_data[fe];
        for (int j=0; j < nlines; j++) {
            words[iTowerBlock_header+j] = xtal_data[j];
            if (debug_) cout << "update line " << iTowerBlock_header+j << endl;
        }
        if (debug_) {
            int jFE = pData[8*(iTowerBlock_header)];
            cout << "Front End on RD : " << jFE << endl; 
        }
        iTowerBlock_header += nlines;
    }

    // -- now the FEs are ordered. STill need to order the xtals within FEs;
    //    need : xtal 1,2,3,4, 5 in strip 1, xtal 1,2,3,4,5 in strip 2 etc..
    //    with possibly missing ones.

    if (debug_) cout << "now reorder the xtals within the FEs" << endl;

    iTowerBlock_header = iTowerBlock_header_keep;

        for (std::map<int, int>::const_iterator it=FrontEnd.begin();
                        it != FrontEnd.end(); it++) {

        int fe = it -> first;
        if (fe > 68) cout << "Problem... fe = " << fe << " in FEDid = " << FEDid << endl;
        if (debug_) cout << " This is for FE = " << fe << endl;
        int nlines = it -> second;
        int timesamples = pData[8*iTowerBlock_header+1] & 0x7F;
        int n4=timesamples-3;
            int n_lines4 = n4/4;
            if ( n4 % 4 != 0) n_lines4 ++;
            if (n_lines4<0) n_lines4=0;
            int Nxtal_max = (nlines-1)/(1+n_lines4);
        int Nxtal = 0;

        map< int, map<int, vector<Word64> > > Strip_Map;

        while (Nxtal < Nxtal_max) {

            int i_xtal = iTowerBlock_header+1 + Nxtal*(1+n_lines4);
            int strip = words[i_xtal] & 0x7;
            int xtal  = ( words[i_xtal] >>4) & 0x7;

            map< int, map<int, vector<Word64> > >::iterator iit = Strip_Map.find(strip);

            map<int, vector<Word64> > NewMap;
            map<int, vector<Word64> > Xtal_Map;

            if (iit == Strip_Map.end()) {            // new strip
                Xtal_Map = NewMap;
            }
            else {
                Xtal_Map = iit -> second;
            }

            std::vector<Word64> xtal_data;
            for (int j=0; j < n_lines4 +1; j++) {
                                Word64 ww = words[i_xtal +j];
                                xtal_data.push_back(ww);
                        }
                        Xtal_Map[xtal] = xtal_data;
                        Strip_Map[strip] = Xtal_Map;

            Nxtal ++;
        }

        // now, update the xtals for this FE :

        int idx = 0;
        for (map< int, map<int, vector<Word64> > >::const_iterator jt = Strip_Map.begin();
            jt != Strip_Map.end(); jt++) {

            int strip = jt -> first;
            if (debug_) cout << "   this is strip number " << strip << endl;
            map<int, vector<Word64> > Xtal_Map = jt -> second;

            for (map<int, vector<Word64> >::const_iterator kt = Xtal_Map.begin();
                kt != Xtal_Map.end(); kt++) {
                int xtal = kt -> first;
                if (debug_) cout << "       this is xtal number " << xtal << endl;
                vector<Word64> xtal_data = kt -> second;

                int mlines = (int)xtal_data.size();
                if (debug_) cout << "     mlines = " << mlines << endl;
                for (int j=0; j < mlines; j++) {
                    int line = iTowerBlock_header+1+idx+j;
                    if (line >= iDAQ_trailer) cout << "smth wrong... line " << line << " trailer " << iDAQ_trailer << endl;
                    words[line] = xtal_data[j] ;
                    if (debug_) cout << "      updated line " << iTowerBlock_header+idx+j << endl;
                }
                idx += mlines; 

            }  // end loop on xtals
            Xtal_Map.clear();

        }  // end loop on strips

        Strip_Map.clear();

        iTowerBlock_header += nlines;
    }  // end loop on FEs

    
    if (debug_) cout << " DONE FOR FED " << FEDid << endl;
    FrontEnd.clear();
    Map_xtal_data.clear();

  }  // end loop on DCC

  // cout << " finished reorder, now clean up " << endl;

// -- clean up

 // FEDmap -> empty();
 // FEDorder -> empty();
 FEDmap -> clear();
 FEDorder -> clear();
 delete FEDmap;
 delete FEDorder;
 FEDmap = 0;
 FEDorder = 0;

 debug_ = false;

 // cout << "end of EndEvent " << endl;
}

void TowerBlockFormatter::StartEvent() {

 FEDmap = new map<int, map<int,int> >;
 FEDorder = new map<int, map<int,int> >;
 
}




void TowerBlockFormatter::DigiToRaw(const EEDataFrame& dataframe, FEDRawData& rawdata, const EcalElectronicsMapping* TheMapping)

    // -- now that we have the EcalElectronicsMapping, this method could probably be
    //    merged with DigiToRaw(EBdataframe).
    //    Keep as it is for the while...
{

 // debug_ = false;

 int bx = *pbx_;
 int lv1 = *plv1_;


  int rdsize = rawdata.size() / 8;  // size in Word64

        const EEDetId& eedetid = dataframe.id();
    EcalElectronicsId elid = TheMapping -> getElectronicsId(eedetid);
        int DCCid = elid.dccId();
    int FEDid = FEDNumbering::MINECALFEDID + DCCid ;
    int iFE = elid.towerId();

    if (debug_) cout << "enter in TowerBlockFormatter::DigiToRaw DCCid FEDid iFE " <<
    dec << DCCid << " " << FEDid << " " << iFE << endl;

        int nsamples = dataframe.size();

        if (iFE <= 0 || iFE > 68)  {
        cout << "invalid iFE for EndCap DCCid iFE " << DCCid << " " << iFE << endl;
        return;
    }


        map<int, map<int,int> >::iterator fen = FEDorder -> find(FEDid);
        map<int, map<int,int> >::iterator fed = FEDmap -> find(FEDid);

        if (fen == FEDorder -> end()) {
                if (debug_) cout << "New FED in TowerBlockFormatter " << dec << FEDid << " 0x" << hex << FEDid << endl;
                map<int,int> FEorder;
                pair<map<int, map<int,int> >::iterator, bool> t1 = FEDorder -> insert(map<int, map<int,int> >::value_type(FEDid,FEorder));
                map<int,int> FEmap;
                pair<map<int, map<int,int> >::iterator, bool> t2 = FEDmap -> insert(map<int, map<int,int> >::value_type(FEDid,FEmap));
                fen = t1.first;
                fed = t2.first;
        }

        map<int, int>& FEorder = (*fen).second;
        map<int, int>& FEmap = (*fed).second;

        map<int,int>::iterator fe = FEorder.find(iFE);
        int FE_order;
        int FE_index;
        if (fe != FEorder.end()) {
                FE_order = (*fe).second;
                map<int,int>::iterator ff = FEmap.find(FE_order);
                if (ff == FEmap.end()) cout << "Error with maps... " << endl;
                FE_index = (*ff).second;
                if (debug_) cout << "FE already there, FE_index = " << dec << FE_index <<  " FEorder " << FE_order << endl;
        }
        else {
                if (debug_) cout << "New FE in TowerBlockFormatter  FE " << dec << iFE << " 0x" << hex << iFE << " in FED id " << dec << FEDid << endl;
                int inser = rdsize;
                int number_FEs = FEorder.size() -1;
                FE_order = number_FEs+1;
                pair<map<int,int>::iterator, bool> t2 = FEorder.insert(map<int,int>::value_type(iFE,FE_order));
                if (! t2.second) cout << " FE insertion failed...";
                pair<map<int,int>::iterator, bool> tt = FEmap.insert(map<int,int>::value_type(FE_order,inser));
                fe = tt.first;
                FE_index = (*fe).second;
                if (debug_) cout << "Build the Tower Block header for FE id " << iFE << " start at line " << rdsize << endl;
                if (debug_) cout << "This is the Fe number (order) " << number_FEs+1 << endl;
                rawdata.resize( 8*rdsize + 8);
                unsigned char* pData = rawdata.data();

                pData[8*FE_index] = iFE & 0xFF;
                pData[8*FE_index+1] = (nsamples & 0x7F);
                pData[8*FE_index+2] = bx & 0xFF;
        pData[8*FE_index+3] = (bx >>8) & 0x0F;
                pData[8*FE_index+3] |= 0xa0;
                pData[8*FE_index+4] = lv1 & 0xFF;
                pData[8*FE_index+5] = (lv1 >>8) & 0x0F;
                pData[8*FE_index+6] = 1;
                pData[8*FE_index+7] = 0xc0;
                if (debug_) print(rawdata);

        }



                // -- Crystal number inside the SM :
    int istrip = elid.stripId();
    int ichannel = elid.xtalId();

        if (debug_) cout << "Now add crystal  strip  channel " << dec << istrip << " " << ichannel << endl;

        unsigned char* pData = rawdata.data();

        vector<unsigned char> vv(&pData[0],&pData[rawdata.size()]);


        int n_add = 2 + 2*nsamples;     // 2 bytes per sample, plus 2 bytes before sample 0
        if (n_add % 8 != 0) n_add = n_add/8 +1;
        else
        n_add = n_add/8;
    if (debug_) cout << "nsamples = " << dec << nsamples << endl;
        if (debug_) cout << "will add " << n_add << " lines of 64 bits at line " << (FE_index+1) << endl;
        rawdata.resize( rawdata.size() + 8*n_add );
        unsigned char* ppData = rawdata.data();

        vector<unsigned char>::iterator iter = vv.begin() + 8*(FE_index+1);

        vector<unsigned char> toadd(n_add*8);


        int tzs=0;
        toadd[0] = (istrip & 0x7) + ((ichannel & 0x7)<<4);
        toadd[1] = (tzs & 0x1) <<12;

        for (int isample=0; isample < (n_add*8-2)/2; isample++) {
                if (isample < nsamples) {
                  uint16_t word = (dataframe.sample(isample)).raw();   // 16 bits word corresponding to this sample
                  toadd[2 + isample*2] = word & 0x00FF;
                  toadd[2 + isample*2 +1] = (word & 0xFF00)>>8;
                }
                else {
                  toadd[2 + isample*2] = 0;
                  toadd[2 + isample*2 +1] = 0;
                }
                if (isample % 2 == 0) toadd[2 + isample*2 +1] |= 0xc0;  // need to add the B11 header...
        }

        vv.insert(iter,toadd.begin(),toadd.end());


        // update the pData for this FED :
        for (int i=0; i < (int)vv.size(); i++) {
                ppData[i] = vv[i];
        }

        if (debug_) {
          cout << "pData for this FED is now " << endl;
          print(rawdata);
        }

        // and update the FEmap for this FED :
        for (int i=FE_order+1; i < (int)FEorder.size(); i++) {
                FEmap[i] += n_add;
                if (debug_) cout << "FEmap updated for fe number " << dec << i << endl;
                if (debug_) cout << " FEmap[" << i << "] = " << FEmap[i] << endl;
        }

        // update the block length
        int blocklength = ppData[8*FE_index+6]
                        + ((ppData[8*FE_index+7] & 0x1)<<8);
        blocklength += n_add;
        ppData[8*FE_index+6] = blocklength & 0xFF;
        ppData[8*FE_index+7] |= (blocklength & 0x100)>>8;


}