FakeBkgTools::FinalState Class Reference

#include <FakeBkgInternals.h>

Collaboration diagram for FakeBkgTools::FinalState:

Public Member Functions
	FinalState (size_t h)
	FinalState (size_t h, const unsigned nparticles, const std::string &strSelection, const std::string &strProc, std::string &error)
bool	accept_selection (const FSBitset &tights, const FSBitset &charges) const
	Important: the accept() function doesn't check the selection (for speed reason), this has to be done separately. More...
bool	accept_process (uint8_t nparticles, const FSBitset &reals, const FSBitset &tights) const
FSBitset	retrieveCharges (const std::vector< FakeBkgTools::ParticleData > &particles) const
bool	hasSS () const
bool	hasOS () const
void	setSS (bool set=true)
void	setOS (bool set=true)
bool	hasChargeRequirement () const
bool	operator< (const FinalState &rhs) const

Public Attributes
FSBitset	selection = 0

Private Member Functions
bool	parseProcess (std::string process, std::string &error)
bool	parseSelection (const unsigned short nparticles, std::string strSelection, std::string &error)

Private Attributes
size_t	m_hash
uint32_t	m_wmin = 0x0
uint32_t	m_wmax =0x3FFFFFFF

Detailed Description

Definition at line 97 of file FakeBkgInternals.h.

Constructor & Destructor Documentation

FinalState() [1/2]

FakeBkgTools::FinalState::FinalState ( size_t  h )

inline

Definition at line 101 of file FakeBkgInternals.h.

: m_hash(h) {} // for search by hash

FinalState() [2/2]

FinalState::FinalState	(	size_t	h,
		const unsigned	nparticles,
		const std::string &	strSelection,
		const std::string &	strProc,
		std::string &	error
	)

Definition at line 31 of file FakeBkgInternals.cxx.

                                                                                                                                     : m_hash(h) 
{
    error.clear();
    if(!parseProcess(strProc, error)) return;
    if(!parseSelection(nparticles, strSelection, error)) return;
}

Member Function Documentation

accept_process()

bool FakeBkgTools::FinalState::accept_process ( uint8_t  nparticles, const FSBitset &  reals, const FSBitset &  tights  ) const

inline

4 bits per number + extra bit for carry

Definition at line 112 of file FakeBkgInternals.h.

    {
        auto nT = tights.count();
        auto nR = reals.count(), nRT = (reals&tights).count(), nRL = nR - nRT;
        auto nF = nparticles - nR, nFT = nT - nRT, nFL = nF - nFT;
        uint32_t w = nRT | (nRL<<5) | (nR<<10) | (nFT<<15) | (nFL<<20) | (nF<<25); 
        if((m_wmax-w)&0x21084210 || (w-m_wmin)&0x21084210) return false;
        return true;
    }

accept_selection()

bool FakeBkgTools::FinalState::accept_selection ( const FSBitset &  tights, const FSBitset &  charges  ) const

inline

Important: the accept() function doesn't check the selection (for speed reason), this has to be done separately.

SS tight

OS tight

Definition at line 104 of file FakeBkgInternals.h.

    {
        if(!selection[tights.to_ulong()]) return false;
        auto nT = tights.count();
        if(hasSS() && nT==2 && (tights&charges).count()==1) return false; 
        if(hasOS() && nT>=2 && ((tights&charges).count()%nT)==0) return false; 
        return true;
    }

hasChargeRequirement()

bool FakeBkgTools::FinalState::hasChargeRequirement ( ) const

inline

Definition at line 131 of file FakeBkgInternals.h.

{ return hasOS() || hasSS(); }

hasOS()

bool FakeBkgTools::FinalState::hasOS ( ) const

inline

Definition at line 128 of file FakeBkgInternals.h.

{ return m_wmax & 0x40000000; }

hasSS()

bool FakeBkgTools::FinalState::hasSS ( ) const

inline

Definition at line 127 of file FakeBkgInternals.h.

{ return m_wmin & 0x40000000; }

operator<()

bool FakeBkgTools::FinalState::operator< ( const FinalState &  rhs ) const

inline

Definition at line 132 of file FakeBkgInternals.h.

{ return m_hash < rhs.m_hash; }

parseProcess()

bool FinalState::parseProcess ( std::string  process, std::string &  error  )

private

needs to be kept consistent with format used by acceptCombination() and parseSelection(); said format is the following: uint32_t w = nRT | (nRL<<5) | (nR<<10) | (nFT<<15) | (nFL<<20) | (nF<<25); // 4 bits per number + extra bit for carry

Replace the 4-bits digit at position 'offset' by the new value (nmin/nmax):

clear carry bits

clear carry bits

Definition at line 38 of file FakeBkgInternals.cxx.

{
    strProc.erase(std::remove_if(strProc.begin(), strProc.end(),
            [](char c){ return std::isspace(c); }), strProc.end());
    std::stringstream ss(strProc);
    std::string token;
    std::regex rx0("([<>]=?)([0-9])([FR])(?:\\[(L|!?T)\\])?");
    std::regex rx1("=?([0-9])(-[0-9])?([FR])(?:\\[(L|!?T)\\])?");
    std::smatch sm;
    bool empty = true;
    m_wmin = 0x0;
    m_wmax = 0x3FFFFFFF;
    while(std::getline(ss,token,','))
    {
        uint8_t nmin = 0, nmax = 0x7F;
        empty = false;
        if(std::regex_match(token, sm, rx0))
        {
            bool strict = (sm[1].str()[1] != '=');
            if(sm[1].str()[0]=='>') nmin = sm[2].str()[0] - '0' + strict*1;
            else
            {
                nmax = sm[2].str()[0] - '0';
                if(strict && !nmax)
                {
                    error = "number of leptons constrained to be negative in the 'process' argument: \"" + strProc + "\"";
                }
                nmax -= strict*1;
            }
        }
        else if(std::regex_match(token, sm, rx1))
        {
            nmin = sm[1].str()[0] - '0';
            if(sm[2].length()) nmax = sm[2].str()[1] - '0';
            else nmax = nmin;
        }
        else
        {
            error = "unable to understand the specified 'process' argument: \"" + strProc + "\"";
            return false;
        }
        unsigned char offset = ((sm[3]=="F")? 15 : 0);
        if(sm[4] == "!T") offset += 5;
        else if(sm[4] == "L") offset += 10;
        nmin  = std::max(nmin, uint8_t((m_wmin>>offset)&0xF));
        nmax = std::min(nmax, uint8_t((m_wmax>>offset)&0xF));
        m_wmin = (m_wmin&~(0xF<<offset)) | (nmin<<offset);
        m_wmax = (m_wmax&~(0xF<<offset)) | (nmax<<offset);
        if(nmin > nmax)
        {
            error = "unexpected error (nmin>nmax) while parsing the specified 'process' argument: \"" + strProc + "\"";
            return false;
        }
    }
    if(empty)
    {
        error = "the 'process' argument is empty";
        return false;
    }
    m_wmin &= ~0x21084210; 
    m_wmax &= ~0x21084210; 
    return true;
}

parseSelection()

bool FinalState::parseSelection ( const unsigned short  nparticles, std::string  strSelection, std::string &  error  )

private

Note: it is important that parseProcess() is called before this function!

replace all "!T" by "A"

Partial check that the selection and process arguments are consistent

Definition at line 105 of file FakeBkgInternals.cxx.

{
    const unsigned nc = (1 << nparticles);
    selection.reset();
    strSelection.erase(std::remove_if(strSelection.begin(), strSelection.end(),
            [](char c){ return std::isspace(c); }), strSelection.end());
    std::stringstream ss(strSelection);
 
    std::string word = "(?:!?T){" + std::to_string(nparticles) + "}(\\+(?:!?T){" + std::to_string(nparticles) + "})*";
 
    if(std::regex_match(strSelection, std::regex(word)))
    {
        while(std::getline(ss, word, '+'))
        {
            if(!word.length()) continue;
            std::size_t pos;
            while((pos=word.find("!T")) != std::string::npos) word.replace(pos, 2, 1, 'A'); 
            std::reverse(word.begin(), word.end());
            std::bitset<FakeBkgTools::maxParticles()> combination(word, 0, std::string::npos, 'A', 'T');
            selection.set(combination.to_ulong());
        }
        return true;
    }
 
    std::regex rx0("([<>]=?)([0-9])(!?T)");
    std::regex rx1("=?([0-9])(-[0-9])?(!?T)");
    std::regex rx2("(OS|SS)");
    std::smatch sm;
    for(unsigned i=0;i<nc;++i) selection.set(i);
    bool empty = true;
    uint8_t maxT=15, maxL=15, minT=0, minL=0;
    while(std::getline(ss, word, ','))
    {
        uint8_t nmin = 0, nmax = 0x7F;
        if(std::regex_match(word, sm, rx0))
        {
            uint8_t o = (sm[1].length()<=1)? 1 : 0;
            if(sm[1].str()[0]=='>') nmin = sm[2].str()[0] - '0' + o;
            else
            {
                nmax = sm[2].str()[0] - '0';
                if(o && !nmax)
                {
                    error = "number of leptons constrained to be negative in the 'selection' argument: \"" + strSelection + "\"";
                    selection.reset();
                    return false;
                }
                nmax -= o;
            }
        }
        else if(std::regex_match(word, sm, rx1))
        {
            nmin = sm[1].str()[0] - '0';
            if(sm[2].length()) nmax = sm[2].str()[1] - '0';
            else nmax = nmin;
        }
        else if(std::regex_match(word, sm, rx2))
        {
            if(hasChargeRequirement())
            {
                error = "both OS and SS requirements were specifed in the 'selection' argument: \"" + strSelection + "\"; this is not allowed";
                selection.reset();
                return false;
            }
            if(sm[0].str()[0]=='S') setSS();
            else setOS();
            continue;
        }
        else
        {
            error = "unable to understand the specified 'selection' argument: \"" + strSelection + "\"";
            selection.reset();
            return false;
        }
        if(nmin > nmax)
        {
            error = "unexpected error (nmin>nmax) while parsing the specified 'selection' argument: \"" + strSelection + "\"";
            selection.reset();
            return false;
        }
        bool count_loose = sm[sm.size()-1] == "!T";
        if(count_loose)
        {
            minL = std::max(minL, nmin);
            maxL = std::min(maxL, nmax);
        }
        else
        {
            minT = std::max(minT, nmin);
            maxT = std::min(maxT, nmax);
        }
        for(unsigned i=0;i<nc;++i)
        {
            auto n = FSBitset(i).count();
            if(count_loose) n = nparticles - n;
            if(n<nmin || n>nmax) selection.reset(i);
        }
        empty = false;
    }
    if(empty)
    {
        error = "the 'selection' argument is empty";
        selection.reset();
        return false;
    }
    
    if((((m_wmin+(m_wmin>>15))&0x1F) > maxT) // minRT + minFT > maxT
        || (((m_wmax+(m_wmax>>15))&0x1F) < minT) // maxRT + maxFT < minT
        || ((((m_wmin>>5)+(m_wmin>>20))&0x1F) > maxL) // minRL + minFL > maxL
        || ((((m_wmax>>5)+(m_wmax>>20))&0x1F) < minL) // maxRL + maxFL < maxL
        || ((((m_wmin>>10)+(m_wmin>>25))&0x1F) > maxL+maxT) // minR + minF > maxL + maxT
        ||((((m_wmax>>10)+(m_wmax>>25))&0x1F) < minL+minT)) // maxR + maxF < minL + minT
    {
        error = "the specified 'selection' and 'process' arguments are not consistent";
        selection.reset();
        return false;
    }
 
    return true;
}

retrieveCharges()

FSBitset FakeBkgTools::FinalState::retrieveCharges ( const std::vector< FakeBkgTools::ParticleData > &  particles ) const

inline

Definition at line 121 of file FakeBkgInternals.h.

    {
        FSBitset charges{0};
        for(unsigned i=0;i<particles.size();++i) charges.set(i, particles[i].charge>0);
        return charges;
    }

setOS()

void FakeBkgTools::FinalState::setOS ( bool  set = true )

inline

Definition at line 130 of file FakeBkgInternals.h.

{ m_wmax = set? (m_wmax|0x40000000) : m_wmax&~0x40000000; }

setSS()

void FakeBkgTools::FinalState::setSS ( bool  set = true )

inline

Definition at line 129 of file FakeBkgInternals.h.

{ m_wmin = set? (m_wmin|0x40000000) : m_wmin&~0x40000000; }

Member Data Documentation

m_hash

size_t FakeBkgTools::FinalState::m_hash

private

Definition at line 134 of file FakeBkgInternals.h.

m_wmax

uint32_t FakeBkgTools::FinalState::m_wmax =0x3FFFFFFF

private

Definition at line 135 of file FakeBkgInternals.h.

m_wmin

uint32_t FakeBkgTools::FinalState::m_wmin = 0x0

private

Definition at line 135 of file FakeBkgInternals.h.

selection

FSBitset FakeBkgTools::FinalState::selection = 0

Definition at line 100 of file FakeBkgInternals.h.

---

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

• FakeBkgInternals.h
• FakeBkgInternals.cxx