aln_scoring.cpp

Go to the documentation of this file.

/*  $Id: aln_scoring.cpp 23124 2011-02-10 17:09:51Z kuznets $
 * ===========================================================================
 *
 *                            PUBLIC DOMAIN NOTICE
 *               National Center for Biotechnology Information
 *
 *  This software/database is a "United States Government Work" under the
 *  terms of the United States Copyright Act.  It was written as part of
 *  the author's official duties as a United States Government employee and
 *  thus cannot be copyrighted.  This software/database is freely available
 *  to the public for use. The National Library of Medicine and the U.S.
 *  Government have not placed any restriction on its use or reproduction.
 *
 *  Although all reasonable efforts have been taken to ensure the accuracy
 *  and reliability of the software and data,  the NLM and the U.S.
 *  Government do not and cannot warrant the performance or results that
 *  may be obtained by using this software or data. The NLM and the U.S.
 *  Government disclaim all warranties,  express or implied,  including
 *  warranties of performance,  merchantability or fitness for any particular
 *  purpose.
 *
 *  Please cite the author in any work or product based on this material.
 *
 * ===========================================================================
 *
 * Authors:  Andrey Yazhuk
 */

#include <ncbi_pch.hpp>

#include <corelib/ncbistd.hpp>
#include <corelib/ncbistl.hpp>
#include <corelib/ncbireg.hpp>
#include <corelib/ncbifile.hpp>

#include <gui/widgets/data/aln_scoring.hpp>

#include <gui/utils/event_translator.hpp>
#include <gui/utils/system_path.hpp>

#include <stdio.h>
#include <math.h>
#include <numeric>

BEGIN_NCBI_SCOPE


///////////////////////////////////////////////////////////////////////////////
/// CScoringParams

CScoringParams::CScoringParams()
: m_Alignment(NULL),
  m_Method(NULL),
  m_GradNumber(16)
{
}


///////////////////////////////////////////////////////////////////////////////
/// CScoreCache

CScoreCache::CScoreCache()
: m_ScoreColls(NULL),
  m_EnBgProcessing(true),
  m_JobID(-1),
  m_HasScores(false)
{
    m_ScoreColls = new TScoreCollVector();
}


CScoreCache::~CScoreCache()
{
    if(x_IsJobRunning())   {
        x_DeleteJob();
    }

    delete m_ScoreColls;
}


BEGIN_EVENT_MAP(CScoreCache, CEventHandler)
    ON_MESSAGE(CAppJobNotification, CAppJobNotification::eStateChanged,
               &CScoreCache::OnAJNotification)
    ON_MESSAGE(CAppJobNotification, CAppJobNotification::eProgress,
               &CScoreCache::OnAJNotification)
END_EVENT_MAP()


void CScoreCache::SetListener(IListener* listener)
{
    m_Listener = listener;
}


void CScoreCache::EnableBackgoundProcessing(bool en)
{
    m_EnBgProcessing = en;
}


void CScoreCache::SetGradNumber(int grad_n)
{
    _ASSERT(grad_n > 1  && grad_n <= 0xFFFF);
    m_Params.m_GradNumber = grad_n;
}


void CScoreCache::SetScoringMethod(IScoringMethod *method)
{
    // changing method requires sopping the running job
    if(x_IsJobRunning())    {
        x_DeleteJob();
    }

    m_Params.m_Method = method;
}


IScoringMethod*    CScoreCache::GetScoringMethod()
{
    return m_Params.m_Method;
}


const IScoringMethod*    CScoreCache::GetScoringMethod() const
{
    return m_Params.m_Method;
}


void CScoreCache::SetAlignment(IScoringAlignment* aln)
{
    m_Params.m_Alignment = aln;
}


const IScoringAlignment* CScoreCache::GetAlignment() const
{
    return m_Params.m_Alignment;
}


void CScoreCache::ResetScores()
{
    //LOG_POST("CScoreCache::CalculateScores() - Started ");
    CAppJobDispatcher& disp = CAppJobDispatcher::GetInstance();

    if(m_Job)   {
        // job is already running - delete it
        if (m_EnBgProcessing) {
            disp.DeleteJob(m_JobID);
            m_JobID = -1;
        }
        m_Job.Reset();
    }

    m_HasScores = false;
    m_ScoreColls->clear();
}

/// Calculates scores for the given CAlnVec object and saves results in form of
/// TScoreColl objects.
void CScoreCache::CalculateScores()
{
    ResetScores();

    if(m_Params.m_Method)   {
        m_Job.Reset(new CScoringJob(m_Params));

        if(m_EnBgProcessing)    {
            CAppJobDispatcher& disp = CAppJobDispatcher::GetInstance();
            // use CAppJobDispatcher to execute background jobs
            m_JobID = disp.StartJob(*m_Job, "ThreadPool", *this, 1, true);
        } else {
            // do everything synchronously
            m_JobID = -1;
            m_Job->Run();
            m_HasScores = x_TransferResults(m_Job->GetResult().GetPointer());
            m_Job.Reset();
        }
    }
    //LOG_POST("CScoreCache::CalculateScores() - Finished ");
}


void CScoreCache::OnAJNotification(CEvent* evt)
{
    CAppJobNotification* notn =
        dynamic_cast<CAppJobNotification*>(evt);
    _ASSERT(notn);

    if(notn)    {
        int job_id = notn->GetJobID();
        if(m_JobID != job_id) {
            ERR_POST("CScoringCache::OnAJNotification() - unknown Job ID " << job_id);
        } else {
            switch(notn->GetState())    {
            case IAppJob::eCompleted:
                x_OnJobCompleted(*notn);
                break;
            case IAppJob::eFailed:
                x_OnJobFailed(*notn);
                break;
            case IAppJob::eCanceled:
                x_OnJobCanceled(*notn);
                break;
            case IAppJob::eRunning:
                x_OnJobProgress(*notn);
                break;
            default:
                _ASSERT(false);
            }
        }
    }
}


bool CScoreCache::x_IsJobRunning()
{
    return m_Job.GetPointer() != NULL;
}


void CScoreCache::x_DeleteJob()
{
    if (m_EnBgProcessing) {
        _ASSERT(m_Job  &&  m_JobID != -1);

        CAppJobDispatcher& disp = CAppJobDispatcher::GetInstance();
        disp.DeleteJob(m_JobID);

        m_JobID = -1;
    }

    m_Job.Reset();

    if(m_Listener)  {
        m_Listener->OnScoringFinished();
    }
}


void CScoreCache::x_OnJobCompleted(CAppJobNotification& notn)
{
    CRef<CObject> obj = notn.GetResult();
    x_TransferResults(obj.GetPointer());

    m_JobID = -1;
    m_Job.Reset();

    if(m_Listener)  {
        //LOG_POST("Completed - m_Listener->OnScoringFinished()");
        m_Listener->OnScoringFinished();
    }
}


bool CScoreCache::x_TransferResults(CObject* result)
{
    CScoringJobResult* sc_res = dynamic_cast<CScoringJobResult*>(result);
    if(sc_res) {
        delete m_ScoreColls; // delete old data

        // take ownership of the results
        m_ScoreColls = sc_res->m_ScoreColls;
        sc_res->m_ScoreColls = NULL;

        m_HasScores = true;
        _ASSERT(m_ScoreColls );
        return true;
    } else {
        ERR_POST("CScoreCache::x_TransferResults()  - invalid results!");
        _ASSERT(sc_res);
        return false;
    }
}


void CScoreCache::x_OnJobFailed(CAppJobNotification& notn)
{
    CConstIRef<IAppJobError> err = notn.GetError();
    if(err) {
        //TODO
    } else {
        //TODO
    }

    m_JobID = -1;
    m_Job.Reset();

    if(m_Listener)  {
        //LOG_POST("Failed - m_Listener->OnScoringFinished()");
        m_Listener->OnScoringFinished();
    }
}


void CScoreCache::x_OnJobCanceled(CAppJobNotification& /*notn*/)
{
    m_JobID = -1;
    m_Job.Reset();

    if(m_Listener)  {
        //LOG_POST("Canceled - m_Listener->OnScoringFinished()");
        m_Listener->OnScoringFinished();
    }
}


void CScoreCache::x_OnJobProgress(CAppJobNotification& notn)
{
    CConstIRef<IAppJobProgress> prg = notn.GetProgress();
    if(prg) {

        if(m_Listener)  {
            float norm_done = prg->GetNormDone();
            m_Listener->OnScoringProgress(norm_done, "Calculating alignment coloration...");
        }
    }
}


bool    CScoreCache::HasScores() const
{
    return m_HasScores;
}


const CRgbaColor& CScoreCache::GetColorForNoScore(IScoringMethod::EColorType type) const
{
    return m_Params.m_Method->GetColorForNoScore(type);
}


const CScoreCache::TScoreColl&   CScoreCache::GetScores(TNumrow row) const
{
    _ASSERT(m_ScoreColls  &&  row >= 0  && row < (TNumrow) m_ScoreColls->size());

    return (*m_ScoreColls)[row];
}



///////////////////////////////////////////////////////////////////////////////
/// CScoringJob

CScoringJob::CScoringJob(CScoringParams& params)
:   m_ScoreColls(NULL),
    m_BufferStart(0),
    m_RowLength(0)
{
    m_Params.m_Alignment = params.m_Alignment;

    CIRef<IUITool> tool(params.m_Method->Clone()); // make a copy
    IScoringMethod* method = dynamic_cast<IScoringMethod*>(tool.GetPointer());
    _ASSERT(method);
    m_Params.m_Method.Reset(method);

    m_Params.m_GradNumber = params.m_GradNumber;

    m_ScoreColls = new TScoreCollVector();
    _ASSERT(m_Params.m_Method  &&  m_Params.m_Alignment);

    m_Descr = "Alignment Scoring Job, method " + m_Params.m_Method->GetName();
    //LOG_POST("CScoringJob::CScoringJob()  " << m_Descr);
}


CScoringJob::~CScoringJob()
{
    //LOG_POST("CScoringJob::~CScoringJob() Destructor  " << m_Descr);
    delete m_ScoreColls;
}


IAppJob::EJobState CScoringJob::Run()
{
/*
    LOG_POST(Info << "CScoringJob::Run()  Started  " << m_Descr
                  << " BufferStart=" << m_BufferStart
                  << " RowLength="   << m_RowLength
                  << " m_vRows.size()= " << m_vRows.size()
        );
*/
    m_Result.Reset();
    m_Error.Reset();
    m_StopRequested.Set(0);

    if(Calculate()) {
        // trnasfer collection onwership to the result
        m_Result.Reset(new CScoringJobResult(m_ScoreColls));
        m_ScoreColls = NULL;
        return eCompleted;
    }
    //LOG_POST("CScoringJob::Run()  Finished  " << m_Descr);
    return eFailed;
}



CConstIRef<IAppJobProgress> CScoringJob::GetProgress()
{
    CAppJobProgress* prg = new CAppJobProgress(m_NormDone, "");
    return CConstIRef<IAppJobProgress>(prg);
}


CRef<CObject> CScoringJob::GetResult()
{
    return CRef<CObject>(m_Result.GetPointer());
}


CConstIRef<IAppJobError> CScoringJob::GetError()
{
    return CConstIRef<IAppJobError>(m_Error.GetPointer());
}


string CScoringJob::GetDescr() const
{
    return m_Descr;
}


bool CScoringJob::Calculate()
{
    _ASSERT(m_ScoreColls);

    if(m_Params.m_Method  &&  m_Params.m_Alignment)   {
        CStopWatch sw;
        sw.Start();

        TNumrow row_n = m_Params.m_Alignment->GetNumRows();
        m_ScoreColls->resize(row_n);

        IRowScoringMethod* row_method = dynamic_cast<IRowScoringMethod*>(m_Params.m_Method.GetPointer());
        if(row_method)  {
            x_CalculateSequenceScores(*row_method);
        } else {
            IColumnScoringMethod* col_method =
                dynamic_cast<IColumnScoringMethod*>(m_Params.m_Method.GetPointer());

            if(col_method)  {
                if(col_method->CanCalculateScores(*m_Params.m_Alignment)) {
                    x_CalculateAlignmentScores(*col_method);
                } else {
                    return false;
                }

            } else  {
                _ASSERT(false); // invalid method
            }
        }
        IWindowScoringMethod * win_method
            = dynamic_cast<IWindowScoringMethod*>(m_Params.m_Method.GetPointer());
        if (win_method  &&  win_method->GetWindowSize() > 0) {
            x_WindowAvgScores(win_method->GetWindowSize());
        }
    }
    return true;
}


CScoringJob::TScoreCollVector* CScoringJob::GetResults()
{
    TScoreCollVector* res = m_ScoreColls;
    m_ScoreColls = NULL;
    return res;
}


///////////////////////////////////////////////////////////////////////////////
/// Sequence buffer management routins

inline char CScoringJob::x_BufferGetSeq(TSeqPos pos,  TNumrow row) const
{
    _ASSERT(pos >= m_BufferStart  &&  pos < m_BufferStart + m_RowLength);
    _ASSERT(row >= 0  &&  row < (TNumrow) m_vRows.size());

    return m_vRows[row][pos - m_BufferStart];
}


void CScoringJob::x_AllocBuffer(TSeqPos row_len)
{
    _ASSERT(m_Params.m_Alignment);

    int rows_n = m_Params.m_Alignment->GetNumRows();
    if(rows_n != (TNumrow) m_vRows.size()  ||  m_RowLength != row_len)    {
        m_RowLength = row_len;

        m_vRows.resize(rows_n);
        NON_CONST_ITERATE(vector<string>,  itR,  m_vRows)   {
            itR->resize(m_RowLength);
        }
    }
}


void CScoringJob::x_FreeBuffer()
{
    m_vRows.clear();
}


void CScoringJob::x_UpdateBuffer(TSeqPos start, TSeqPos stop)
{
    _ASSERT(m_Params.m_Alignment);
    _ASSERT( (stop - start + 1) <= m_RowLength);

    m_BufferStart = start;

    TNumrow row_n = (TNumrow) m_vRows.size();
    for( TNumrow r = 0;  r < row_n; r++ )  {
        m_Params.m_Alignment->GetAlnSeqString(r, m_vRows[r], IAlnExplorer::TSignedRange(start, stop));
    }
}


void CScoringJob::x_BufferGetColumn(TSeqPos pos, string& column) const
{
    _ASSERT(pos >= m_BufferStart  && pos < m_BufferStart + m_RowLength);

    size_t col = pos - m_BufferStart;
    for(  size_t row = 0;  row < m_vRows.size();  row++ )   {
       column[row] = m_vRows[row][col];
    }
}


void CScoringJob::x_CalculateSequenceScores(IRowScoringMethod& method)
{
    TNumrow row_n = m_Params.m_Alignment->GetNumRows();
    for(TNumrow r = 0;  r < row_n  &&  ! x_IsCanceled();  r++ )  {
        m_NormDone = float(r) / row_n;
        method.CalculateScores(r,  *m_Params.m_Alignment,  (*m_ScoreColls)[r]);
        //Sleep(1000);
    }
}


void CScoringJob::x_CalculateAlignmentScores(IColumnScoringMethod& method)
{
    _ASSERT(m_ScoreColls);

    TSeqPos start = m_Params.m_Alignment->GetAlnStart();
    TSeqPos stop = m_Params.m_Alignment->GetAlnStop();
    TNumrow row_n = m_Params.m_Alignment->GetNumRows();

    // preparing score collections
    NON_CONST_ITERATE(TScoreCollVector,  itC,  *m_ScoreColls)  {
        itC->SetFrom(start); // clear and initialize
    }
    string column(row_n,  '\0');
    TScore col_score = 0;
    TScoreVector v_col_scores(row_n,  0.0);

    const TSeqPos kPageSize = 256;
    x_AllocBuffer(kPageSize);

    TScore grad_n = (TScore) m_Params.m_GradNumber;

    TNumrow cons_row = m_Params.m_Alignment->GetAnchor();

    // iterate from "start" to "stop" using "sliding buffer"
    for( TSeqPos pos = start;  pos < stop  &&  ! x_IsCanceled(); )    {
        m_NormDone = float(pos - start) / (stop - start); // update progress

        TSeqPos pos_stop = min(pos + kPageSize -1,  stop);
        x_UpdateBuffer(pos,  pos_stop); // fetch next page in Seq Buffer

        for( TSeqPos p = pos;  p <= pos_stop ;  p++ )    { // for each column
            x_BufferGetColumn(p,  column);
            char cons = (cons_row > -1) ? column[cons_row] : 0;
            method.CalculateScores(cons,  column,  col_score,  v_col_scores);

            // append scores to collections
            for(TNumrow r = 0;  r < row_n;  r++ )  {
                TScore sc = v_col_scores[r];
                sc = ((int) (sc * grad_n)) / grad_n;
                (*m_ScoreColls)[r].push_back(sc);
            }
        }
        pos = pos_stop + 1;
        //Sleep(1000);
    }
}


void CScoringJob::x_WindowAvgScores(size_t window_size)
{
    typedef TScoreColl::const_pos_iterator TPosIt;

    for( size_t i = 0;  i < m_ScoreColls->size()  &&  ! x_IsCanceled();  i++) {
        m_NormDone = float(i) / m_ScoreColls->size();

        TScoreColl&  score_row = (*m_ScoreColls)[i];
        TScoreColl avgd_score_row;
        TPosIt itC = score_row.begin_pos();
        TPosIt itC_end = score_row.end_pos();

        // Min/Max before and after averaging to
        // renormalise values afterwards.
        TScore old_min = numeric_limits<TScore>::max();
        TScore old_max = numeric_limits<TScore>::min();
        ITERATE(TScoreColl, it_sc, score_row) {
            TScore this_score = it_sc->GetAttr();
            if (this_score < old_min) old_min = this_score;
            if (this_score > old_max) old_max = this_score;
        }
        TScore new_min = numeric_limits<TScore>::max();
        TScore new_max = numeric_limits<TScore>::min();

        // calculate our first windowed average.
        TPosIt win_begin = itC;
        TPosIt win_end = itC_end;
        if (window_size < score_row.GetLength()) {
            win_end = itC + 1 + int(window_size);
        }

        TScore win_sum = (TScore) accumulate(win_begin, win_end, (TScore)0);
        TScore win_score = win_sum / (win_end - win_begin);
        avgd_score_row.push_back(win_score);
        if (win_score < new_min) {
            new_min = win_score;
        }
        if (win_score > new_max) {
            new_max = win_score;
        }

        if(x_IsCanceled()) {
            return;
        }

        for(  ++itC;  itC != itC_end;  ++itC  ) {
            // Move the window & update the average.
            if ((itC - win_begin) > (int) window_size) {
                // move the beginning of the window, the trailing edge.
                win_sum -= *win_begin;
                ++win_begin;
            }
            if (win_end < itC_end) {
                // move the end of the window, the leading edge.
                win_sum += *win_end;
                ++win_end;
            }
            win_score = win_sum/(win_end - win_begin);
            avgd_score_row.push_back(win_score);
            if (win_score < new_min) new_min = win_score;
            if (win_score > new_max) new_max = win_score;
        }

        if(x_IsCanceled()) {
            return;
        }

        // renormalize scores back to the dynamic range they had
        // before we averaged them.
        TScoreColl norm_score_row;
        TScore norm_slope = (old_max - old_min) / (new_max - new_min);
        ITERATE(TScoreColl, it_sc, avgd_score_row) {
            norm_score_row.push_back(
                    (it_sc->GetAttr() - new_min) * norm_slope + old_min,
                    it_sc->GetLength() );
        }
        score_row.swap(norm_score_row);
    }
}


END_NCBI_SCOPE