dqm_algorithms::AFP_LBsOutOfRange Class Reference

#include <AFP_LBsOutOfRange.h>

Inheritance diagram for dqm_algorithms::AFP_LBsOutOfRange:

Collaboration diagram for dqm_algorithms::AFP_LBsOutOfRange:

Public Types
using	IOVSet = std::vector<std::pair<int, int>>

Public Member Functions
	AFP_LBsOutOfRange ()
	~AFP_LBsOutOfRange ()
AFP_LBsOutOfRange *	clone () override
dqm_core::Result *	execute (const std::string &name, const TObject &object, const dqm_core::AlgorithmConfig &config) override
void	printDescriptionTo (std::ostream &out) override
const IOVSet &	fetchIOVs (uint32_t run, uint32_t channel)

Private Attributes
std::map< std::pair< uint32_t, uint32_t >, IOVSet >	m_iov_cache

Detailed Description

Definition at line 28 of file AFP_LBsOutOfRange.h.

Member Typedef Documentation

IOVSet

using dqm_algorithms::AFP_LBsOutOfRange::IOVSet = std::vector<std::pair<int, int>>

Definition at line 30 of file AFP_LBsOutOfRange.h.

Constructor & Destructor Documentation

AFP_LBsOutOfRange()

dqm_algorithms::AFP_LBsOutOfRange::AFP_LBsOutOfRange

(

)

Definition at line 45 of file AFP_LBsOutOfRange.cxx.

                                                   {
    dqm_core::AlgorithmManager::instance().registerAlgorithm( "AFP_LBsOutOfRange", this );
}

~AFP_LBsOutOfRange()

dqm_algorithms::AFP_LBsOutOfRange::~AFP_LBsOutOfRange

(

)

Definition at line 49 of file AFP_LBsOutOfRange.cxx.

                                                    {
}

Member Function Documentation

clone()

dqm_algorithms::AFP_LBsOutOfRange * dqm_algorithms::AFP_LBsOutOfRange::clone ( )

override

Definition at line 53 of file AFP_LBsOutOfRange.cxx.

                                       {
    return new AFP_LBsOutOfRange();
}

execute()

dqm_core::Result * dqm_algorithms::AFP_LBsOutOfRange::execute ( const std::string & name, const TObject & object, const dqm_core::AlgorithmConfig & config )

override

Definition at line 119 of file AFP_LBsOutOfRange.cxx.

                                                                                    {
    if ( !object.IsA()->InheritsFrom( "TH1" ) ) {
        throw dqm_core::BadConfig( ERS_HERE, name, "does not inherit from TH1" );
    }
 
    auto histogram = static_cast<const TH1*>( &object );
    
    if ( histogram->GetDimension() > 1 ) {
        throw dqm_core::BadConfig( ERS_HERE, name, "histogram has more than 1 dimension" );
    }
 
    auto gthreshold = static_cast<uint32_t>( dqm_algorithms::tools::GetFromMap( "NbadBins", config.getGreenThresholds() ) );
    auto rthreshold = static_cast<uint32_t>( dqm_algorithms::tools::GetFromMap( "NbadBins", config.getRedThresholds() ) );
    
    auto channel   = static_cast<uint32_t>( dqm_algorithms::tools::GetFirstFromMap( "channel", config.getParameters() ) );
    auto RANGE_D   = static_cast<double>( dqm_algorithms::tools::GetFirstFromMap( "RANGE_D", config.getParameters(), -100 ) );
    auto RANGE_U   = static_cast<double>( dqm_algorithms::tools::GetFirstFromMap( "RANGE_U", config.getParameters(), 100 ) );
    auto ignoreval = static_cast<double>( dqm_algorithms::tools::GetFirstFromMap( "ignoreval", config.getParameters(), 0 ) );
    auto minLBs    = static_cast<uint32_t>( dqm_algorithms::tools::GetFirstFromMap( "MinLBs", config.getParameters(), 0 ) );
    
    auto run   = dqm_algorithms::tools::GetFirstFromMap( "run_number", config.getParameters(), 0 );
    auto& iovs = run > 0 ? fetchIOVs( run, channel ) : IOVSet{ { 0, 0 } };
 
    auto range    = dqm_algorithms::tools::GetBinRange( histogram, config.getParameters() );
    uint32_t xmin = range[ 0 ];
    uint32_t xmax = range[ 1 ] + 1;
    auto xaxis    = histogram->GetXaxis();
    std::vector<uint32_t> badbins;
    uint32_t checkedLBs = 0;
    for ( auto& iov : iovs ) {
        auto xstart = std::max<uint32_t>( xaxis->FindFixBin( iov.first ), xmin );
        auto xend   = std::min<uint32_t>( xaxis->FindFixBin( iov.second ), xmax );
        for ( uint32_t ix = xstart; ix < xend; ++ix ) {
            double binvalue = histogram->GetBinContent( ix );
            if ( binvalue == ignoreval ) continue;
            ++checkedLBs;
            if ( RANGE_D < binvalue && binvalue < RANGE_U ) continue;
            badbins.push_back( ix );
        }
    }
 
    auto publish     = static_cast<bool>( dqm_algorithms::tools::GetFirstFromMap( "PublishBins", config.getParameters(), true ) );
    auto Nmaxpublish = static_cast<uint32_t>( dqm_algorithms::tools::GetFirstFromMap( "MaxPublish", config.getParameters(), 20 ) );
    auto result      = new dqm_core::Result();
 
    // publish problematic bins
    result->tags_[ "NBadBins" ] = badbins.size();
    if ( publish ) {
        auto npublish = std::min<uint32_t>( Nmaxpublish, badbins.size() );
        for ( uint32_t i = 0; i < npublish; ++i ) {
            uint32_t ix = badbins[ i ];
            uint32_t lb = std::floor( xaxis->GetBinCenter( ix ) );
            auto tag    = ( std::ostringstream() << "LB " << lb ).str();
 
            result->tags_[ tag ] = histogram->GetBinContent( ix );
        }
    }
 
    if ( checkedLBs < minLBs )
        result->status_ = dqm_core::Result::Undefined;
    else if ( badbins.size() > rthreshold )
        result->status_ = dqm_core::Result::Red;
    else if ( badbins.size() > gthreshold )
        result->status_ = dqm_core::Result::Yellow;
    else
        result->status_ = dqm_core::Result::Green;
 
    return result;
}

fetchIOVs()

const dqm_algorithms::AFP_LBsOutOfRange::IOVSet & dqm_algorithms::AFP_LBsOutOfRange::fetchIOVs	(	uint32_t	run,
		uint32_t	channel )

Definition at line 58 of file AFP_LBsOutOfRange.cxx.

                                                                           {
    auto& iovs = m_iov_cache[ std::make_pair( run, channel ) ];
    if ( iovs.empty() ) {
        auto& dbService = cool::DatabaseSvcFactory::databaseService();
        // Get map of LB timestamps to LB numbers
        uint64_t runStartTime = 0xFFffFFffFFffFFff;
        uint64_t runEndTime   = 0;
        std::map<uint64_t, uint32_t> lbs;
        {
            auto databaseName = std::string( "COOLONL_TRIGGER/CONDBR2" );
            auto folderName   = std::string( "/TRIGGER/LUMI/LBLB" );
            auto databasePtr  = dbService.openDatabase( databaseName, true );
            auto folderPtr    = databasePtr->getFolder( folderName );
            uint64_t run64    = run;
            auto since        = cool::ValidityKey( run64 << 32 );
            auto until        = cool::ValidityKey( ( run64 + 1 ) << 32 );
            auto iterPtr      = folderPtr->browseObjects( since, until, cool::ChannelSelection::all() );
            while ( iterPtr->goToNext() ) {
                auto& object     = iterPtr->currentRef();
                auto lbStartTime = getStartTime( object );
                auto lbEndTime   = getEndTime( object );
                lbs.emplace( lbStartTime, getLB( object ) );
                if ( lbStartTime < runStartTime ) runStartTime = lbStartTime;
                if ( lbEndTime > runEndTime ) runEndTime = lbEndTime;
            }
            if ( lbs.empty() ) throw afp::CantReadCool( ERS_HERE, std::move(databaseName), std::move(folderName) );
        }
        // Get IOVs where the station was in physics position,
        // merge the neighbouring ones,
        // and translate the timestamps to LB numbers
        {
            auto databaseName = std::string( "COOLOFL_DCS/CONDBR2" );
            auto folderName   = std::string( "/AFP/DCS/STATION" );
            auto databasePtr  = dbService.openDatabase( databaseName, true );
            auto folderPtr    = databasePtr->getFolder( folderName );
            auto iterPtr      = folderPtr->browseObjects( runStartTime, runEndTime, cool::ChannelSelection( channel ) );
            uint64_t since = 0, until = 0;
            iovs.reserve( iterPtr->size() / 2 );
            while ( iterPtr->goToNext() ) {
                auto& object   = iterPtr->currentRef();
                auto inphysics = object.payload()[ "inphysics" ].data<cool::Bool>();
                if ( inphysics ) {
                    if ( since == 0 ) since = object.since();
                    until = object.until();
                } else if ( since != 0 ) {
                    uint32_t start = lbs.lower_bound( since )->second;
                    uint32_t end = ( --lbs.upper_bound( until ) )->second;
                    iovs.emplace_back( start, end );
                    since = 0;
                }
            }
        }
        // Ensure the list is not empty
        if ( iovs.empty() ) {
            iovs.emplace_back( 0u, 0u );
        }
    }
    return iovs;
}

printDescriptionTo()

void dqm_algorithms::AFP_LBsOutOfRange::printDescriptionTo ( std::ostream & out )

override

Definition at line 191 of file AFP_LBsOutOfRange.cxx.

                                                                          {
    out << "AFP_LBsOutOfRange: Print out the bad LBs, during which AFP was in physics position, and which are out of range [RANDE_D,RANGE_U] (default [-100,100])\n"
        << "Required Parameter: channel: channel number of the station in COOLOFL_DCS/CONDBR2 /AFP/DCS/STATION\n"
        << "Optional Parameter: ignoreval: value to be ignored for being processed (default 0)\n"
        << "Optional Parameter: MaxPublish: Max number of bins to save (default 20)\n"
        << "Optional Parameter: MinLBs: Minimum number of LBs in physics with value not equal to ignoreval to assign color (default 0)" << std::endl;
}

Member Data Documentation

m_iov_cache

std::map<std::pair<uint32_t, uint32_t>, IOVSet> dqm_algorithms::AFP_LBsOutOfRange::m_iov_cache

private

Definition at line 42 of file AFP_LBsOutOfRange.h.

---

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

• AFP_LBsOutOfRange.h
• AFP_LBsOutOfRange.cxx