/data/git/CMSSW_5_3_11_patch5/src/L1TriggerConfig/L1GtConfigProducers/src/L1GtVhdlWriterBitManager.cc

Go to the documentation of this file.

// this class header
#include "L1TriggerConfig/L1GtConfigProducers/interface/L1GtVhdlWriterBitManager.h"

#include "L1TriggerConfig/L1GtConfigProducers/interface/L1GtVhdlTemplateFile.h"

#include "CondFormats/L1TObjects/interface/L1GtCaloTemplate.h"
#include "CondFormats/L1TObjects/interface/L1GtMuonTemplate.h"
#include "CondFormats/L1TObjects/interface/L1GtEnergySumTemplate.h"

// system include files
#include <iostream>
#include <fstream>
#include <map>
#include <string>
#include <sstream>
#include <vector>
#include <iomanip>

L1GtVhdlWriterBitManager::L1GtVhdlWriterBitManager()
{
        hex2binMap_["0"]="0000";
        hex2binMap_["1"]="0001";
        hex2binMap_["2"]="0010";
        hex2binMap_["3"]="0011";
        hex2binMap_["4"]="0100";
        hex2binMap_["5"]="0101";
        hex2binMap_["6"]="0110";
        hex2binMap_["7"]="0111";
        hex2binMap_["8"]="1000";
        hex2binMap_["9"]="1001";

        hex2binMap_["A"]="1010";
        hex2binMap_["B"]="1011";
        hex2binMap_["C"]="1100";
        hex2binMap_["D"]="1101";
        hex2binMap_["E"]="1110";
        hex2binMap_["F"]="1111";

        hex2binMap_["a"]="1010";
        hex2binMap_["b"]="1011";
        hex2binMap_["c"]="1100";
        hex2binMap_["d"]="1101";
        hex2binMap_["e"]="1110";
        hex2binMap_["f"]="1111";
}


std::string L1GtVhdlWriterBitManager::readMapInverse(std::map<std::string,std::string> map,std::string value)
{
        std::map<std::string,std::string>::iterator iter = map.begin();
        while (iter!=map.end())
        {
                if ((*iter).second == value)
                        return (*iter).first;
                iter++;
        }
        return "";
}


std::string L1GtVhdlWriterBitManager::hex2bin(std::string hexString)
{

        std::string temp;
        for (unsigned int i=0; i<hexString.length(); i++)
        {
                std::string str;
                str=hexString[i];

                temp+=hex2binMap_[str];
        }

        return temp;
}


std::string L1GtVhdlWriterBitManager::bin2hex(std::string binString)
{

        std::string temp;
        for (unsigned int i=1; i<=binString.length(); i++)
        {
                //std::cout<<i%4<<std::endl;
                if(i%4==0)
                {
                        //std::cout<<"I'm here!"<<std::endl;
                        std::string str;
                        str = binString.substr(i-4,4);
                        //std::cout<<str<<std::cout<<std::endl;
                        temp+=readMapInverse(hex2binMap_,str);
                }
        }

        return temp;
}


std::string L1GtVhdlWriterBitManager::mirror(unsigned int offset, std::string hexString, bool hexOutput)
{
        std::string temp,binString;

        char digit;
        bool hexInput=false;

        // check weather input hex or binary
        for(unsigned int i = 0; i<hexString.length(); i++)
        {
                if (hexString[i]!='0' || hexString[i]!='1' )
                {
                        hexInput=true;
                        break;
                }
        }

        if (hexInput)
                binString = hex2bin(hexString);
        else binString=hexString;

        unsigned int i=0, len=0;
        len = binString.length();

        if(offset > len)
                return binString;

        for(i = 0; i < (len - offset)/2; i++)
        {
                digit = binString[i + offset];

                binString[i + offset] = binString[len - 1 - i];
                binString[len - 1 - i] = digit;

        }

        if (hexOutput)
                return bin2hex(binString);
        else return binString;

}


std::string L1GtVhdlWriterBitManager::capitalLetters(std::string hexString)
{

        unsigned int i = 0;
        while(i<hexString.length())
        {
                if(hexString[i] == 'a') hexString[i] = 'A';
                else if(hexString[i] == 'b') hexString[i] = 'B';
                else if(hexString[i] == 'c') hexString[i] = 'C';
                else if(hexString[i] == 'd') hexString[i] = 'D';
                else if(hexString[i] == 'e') hexString[i] = 'E';
                else if(hexString[i] == 'f') hexString[i] = 'F';
                i++;
        }

        return hexString;
}


std::string L1GtVhdlWriterBitManager::shiftLeft(std::string hexString)
{
        std::string binString = hex2bin(hexString);

        binString.erase(0,1);
        binString+="0";

        return bin2hex(binString);
}


std::string L1GtVhdlWriterBitManager::buildEtaMuon(const std::vector<L1GtMuonTemplate::ObjectParameter>* op, const unsigned int &num, const unsigned int &counter)
{
        std::ostringstream ossEta;

        ossEta
                <<counter
                <<" => X\"";

        for (unsigned int i =0; i<num; i++)
        {
                std::ostringstream ossEtaRange;
                ossEtaRange << std::hex<< std::setw(16)<<std::setfill('0')<<(*op).at(i).etaRange<<std::dec;

                /*
                ossEta
                        <<mirror(32,ossEtaRange.str());
                */
                
                ossEta << ossEtaRange.str();
                
                if (num>0 && i!=num-1) ossEta <<"_";

        }

        ossEta<<"\",\n";
        return ossEta.str();

}


std::string L1GtVhdlWriterBitManager::buildEtaCalo(const std::vector<L1GtCaloTemplate::ObjectParameter>* op, const unsigned int &num, const unsigned int &counter)
{
        std::ostringstream ossEta;

        ossEta
                <<counter
                <<" => X\"";

        // loop over all relevant components of object parameters

        for (unsigned int i =0; i<num; i++)
        {
                std::ostringstream ossEtaRange;

                ossEtaRange << std::hex <<std::setw(4)<<std::setfill('0')<< (*op).at(i).etaRange<<std::dec;

                /*
                std::string tempstr=hex2bin(ossEtaRange.str());
                tempstr[0]='0';
                tempstr[15]='0';
                */
                
                //ossEta<<std::setw(4)<<std::setfill('0')<<mirror(8,bin2hex(tempstr));

                ossEta << ossEtaRange.str();
                
                if (num>0 && i!=num-1) ossEta <<"_";

        }

        ossEta<<"\",\n";
        return ossEta.str();
}


std::string L1GtVhdlWriterBitManager::buildPhiCalo(const std::vector<L1GtCaloTemplate::ObjectParameter>* op, const unsigned int &num, const unsigned int &counter)
{
        std::ostringstream ossPhi;

        ossPhi
                <<counter
                <<" => X\"";

        for (unsigned int i =0; i<num; i++)
        {
                ossPhi << std::hex<< std::setw(8)<<std::setfill('0')<<(*op).at(i).phiRange<<std::dec;

                if (num>0 && i!=num-1) ossPhi <<"_";
        }

        ossPhi<<"\",\n";
        return capitalLetters(ossPhi.str());
}


std::string L1GtVhdlWriterBitManager::buildPhiEnergySum(const std::vector<L1GtEnergySumTemplate::ObjectParameter>* op, const unsigned int &num, const unsigned int &counter)
{
        std::ostringstream ossPhi,count;

        if ((*op).at(0).phiRange0Word!=0)
        {
                ossPhi << "000000000000000000"<<std::hex<<(*op).at(0).phiRange1Word<<(*op).at(0).phiRange0Word<<std::dec;

                count<<counter;

                return (count.str()+" => X\""+capitalLetters(ossPhi.str())+"\",\n");

        } else
        return "";
}


std::string L1GtVhdlWriterBitManager::buildPhiMuon(const std::vector<L1GtMuonTemplate::ObjectParameter>* op, const unsigned int &num, const unsigned int &counter,bool high)
{
        std::ostringstream ossPhi;

        ossPhi
                <<counter
                <<" => X\"";

        for (unsigned int i =0; i<num; i++)
        {
                if (high)
                        ossPhi << std::hex<< std::setw(2)<<std::setfill('0')<<(*op).at(i).phiHigh<<std::dec;
                else
                        ossPhi << std::hex<< std::setw(2)<<std::setfill('0')<<(*op).at(i).phiLow<<std::dec;

                if (num>0 && i!=num-1) ossPhi <<"_";
        }

        ossPhi<<"\",\n";
        return capitalLetters(ossPhi.str());

}


std::string L1GtVhdlWriterBitManager::buildDeltaEtaCalo(const L1GtCaloTemplate::CorrelationParameter* &cp,const unsigned int &counter)
{
        std::ostringstream deltaEtaRange, dEta,res;

        //std::cout<<"b:"<<.hex2bin("00383800")<<std::endl;

        deltaEtaRange << std::hex<< std::setw(4)<<std::setfill('0')<<(*cp).deltaEtaRange<<std::dec;

        // mirror deltaEtaRang and shift the mirrored value to the left by one bit;
        // add the original value to the calculated value
        dEta<<hex2bin(shiftLeft(mirror(0,deltaEtaRange.str())))<<hex2bin(deltaEtaRange.str());

        std::string result = capitalLetters(bin2hex(dEta.str()));

        res<<counter<<" => X\""<<result<<"\",\n";

        return res.str();

}


std::string L1GtVhdlWriterBitManager::buildDeltaEtaMuon(const L1GtMuonTemplate::CorrelationParameter* &cp,const unsigned int &counter)
{
        std::ostringstream deltaEtaRange, dEta;
        deltaEtaRange << std::hex<< std::setw(16)<<std::setfill('0')<<(*cp).deltaEtaRange<<std::dec;

        // mirror deltaEtaRang and shift the mirrored value to the left by one bit;
        // add the original value to the calculated value

        std::string result = capitalLetters((shiftLeft(mirror(0,deltaEtaRange.str()))+deltaEtaRange.str()));

        dEta<<counter<<" => X\""<<result<<"\",\n";

        return dEta.str();

}


std::string L1GtVhdlWriterBitManager::buildDeltaPhiCalo(const L1GtCaloTemplate::CorrelationParameter* &cp,const unsigned int &counter)
{
        std::ostringstream dPhi,deltaPhiRange, result;
        //std::cout<<.hex2bin("03E0000000000F81")<<std::endl;
        //std::cout<<.hex2bin("0080000000000200")<<std::endl;

        deltaPhiRange << std::hex<<std::setw(3)<<std::setfill('0')<<(*cp).deltaPhiRange<<std::dec;

        std::string binString = hex2bin(deltaPhiRange.str());

        //std::cout <<"========================" <<std::endl;

        std::string help2 = binString.substr(2,binString.length()-2);
        std::string help1 = help2.substr(1);
        help1 = mirror(0,bin2hex(help1),false);

        // here delta phi is built
        result<<help1;

        // might be wrong - has to be tested with more reference values!
        result<<help2.substr(0,8);
        result<<"0";

        result<<"00000000000000000000000000000";

        result<<help1;

        result<<binString.substr(2,binString.length()-2);

        dPhi<<counter<<" => X\""<<bin2hex(result.str())<<"\",\n";

        //std::cout<<result<<std::endl;

        /*
         * Code from old GTS:
          bm_dphi = bm_dphi.Get(2);
          BitMngr help1, help2 = bm_dphi;
          help2.SetAt(9, '\0');
          help1 = help2.Get(1);
          help1.Mirror();
          BitMngr nuller;
          nuller.InitBin("00 00 00 00 00 00 00 00 00 00 00 00 00 00 0");
          BitMngr result;
          result = result + help1 + help2 + nuller + help1 + bm_dphi;
        dphi = result.GetHex();
        */

        return capitalLetters(dPhi.str());
}


std::string L1GtVhdlWriterBitManager::buildDeltaPhiMuon(const L1GtMuonTemplate::CorrelationParameter* &cp,const unsigned int &counter)
{
        std::ostringstream dPhi,deltaPhiRange0,deltaPhiRange1,temp,result ;
        std::string tempstr;

        deltaPhiRange0 << std::hex<< std::setw(16)<<std::setfill('0')<<(*cp).deltaPhiRange0Word<<std::dec;
        //deltaPhiRange1  /*<< std::hex<< std::setw(3)<<std::setfill('0')*/<<(*cp).deltaPhiRange1Word<<std::dec;

        //mirror deltaPhiRange, shift the mirrored value left and convert it to binary format
        temp<<hex2bin(shiftLeft(mirror(0,deltaPhiRange0.str())));
        tempstr=temp.str();
        // set last bit of tempstr to one;
        tempstr[tempstr.length()-1]='1';

        // build delta eta as stringstreamtau
        result
                <<tempstr
        // insert 16 ones
                <<hex2bin("FFFF")
                <<hex2bin(deltaPhiRange0.str());

        dPhi<<counter<<" => X\""<<bin2hex(result.str())<<"\",\n";

        return dPhi.str();

}