freSetupOptimizationMetricMonitorBase.txx

Go to the documentation of this file.

/*=========================================================================

  Program:   F.R.E.E. - flexible registration evaluation engine
  Version:   v.1.0.0
  Date:      $Date: 2006/09/01 12:00:00 $
  Module:    $RCSfile: freSetupOptimizationMetricMonitorBase.txx,v $
  Language:  C++



  Copyright (c) 2007 Ralf o Floca (Department of Medical Informatics,
  Institute for Medical Biometry and Informatics, University of Heidelberg,
  Germany). All rights reserved.
  See FREECopyright.txt or http://www.mi.med.uni-hd.de/free/copyright.htm
  for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __freSetupOptimizationMetricMonitorBase_txx
#define __freSetupOptimizationMetricMonitorBase_txx

#include "freSetupOptimizationMetricMonitorBase.h"
#include "freExceptions.h"

namespace FREE
{

template <typename TResultClass>
bool
SetupOptimizationMetricMonitorBase<TResultClass>::
GetUnevaluatedAdaptedSetup(const ThreadIDType& threadID, AdaptationIDType& adaptID, Setup::Pointer& smpSetup)
{
  bool bWorkLeft = false;

  if (!this->IsInitialized()) throwExceptionMacro("Error thread #"<<threadID<<" requested a new adaptation, but monitor is not initialized.");

  if (this->ThreadIsProcessing(threadID))
  {
    throwExceptionMacro("Error thread #"<<threadID<<" requested a new adaptation, but is enlisted as have one open task. Ensure that thread has enlisted his last results.");
  }
  else
  { //ok, thread is allowed to get a new task.
    this->m_SetupMutex.Lock();
      AdaptationIDListType pendings = this->GetListOfPendingAdaptations();
      if (pendings.size()>0)
      {
        bWorkLeft = true;
        adaptID = pendings[0];
        this->SetAdaptationState(adaptID,Self::ASProcessing);
        this->EnlistThreadAsProcessing(threadID,adaptID);

        //final generate the adapted setup
        smpSetup = this->m_Adaptor.AdaptSetup(adaptID);

        this->m_EventMutex.Lock();
          if (this->fnOnNextAdaptation.IsNotNull()) this->fnOnNextAdaptation->Execute(adaptID,"thread ID "+Convert::ToStr(threadID),(void*)this,threadID);
        this->m_EventMutex.Unlock();
      }
    this->m_SetupMutex.Unlock();
  }

  return bWorkLeft;
};

template <typename TResultClass>
void
SetupOptimizationMetricMonitorBase<TResultClass>::
NotifyFailedEvaluation(const ThreadIDType& threadID, const std::string& sError)
{
  if (!this->IsInitialized()) throwExceptionMacro("Error thread #"<<threadID<<" notified a failure, but monitor is not initialized.");

  AdaptationIDType adaptID;
  if (!this->GetAdaptionProcessedByThread(threadID,adaptID)) throwExceptionMacro("Error; thread #"<<threadID<<" notified a failure, but has no adaptation enlisted as his task.");

  this->RemoveThreadFromProcessingList(threadID);
  this->SetAdaptationState(adaptID,Self::ASFailed);

  this->m_EventMutex.Lock();
    if (this->fnOnEvaluationFailed.IsNotNull()) this->fnOnEvaluationFailed->Execute(adaptID,sError,(void*)this,threadID);
  this->m_EventMutex.Unlock();
};

template <typename TResultClass>
void
SetupOptimizationMetricMonitorBase<TResultClass>::
NotifyProgress(const ThreadIDType& threadID,
               const ProgressCtrlEventBase::StatusID status,
               const std::string& sComment)
{
  if (!this->IsInitialized()) throwExceptionMacro("Error thread #"<<threadID<<" notified a progress, but monitor is not initialized.");

  AdaptationIDType adaptID;
  if (!this->GetAdaptionProcessedByThread(threadID,adaptID)) throwExceptionMacro("Error; thread #"<<threadID<<" notified a progress, but has no adaptation enlisted as his task.");

  this->m_EventMutex.Lock();
    if (this->fnOnEvaluationProgress.IsNotNull()) this->fnOnEvaluationProgress->Execute(status,sComment,(void*)this,threadID);
  this->m_EventMutex.Unlock();
};

template <typename TResultClass>
void
SetupOptimizationMetricMonitorBase<TResultClass>::
EvaluationFinished(const ThreadIDType& threadID, const ResultType& results)
{
  if (!this->IsInitialized()) throwExceptionMacro("Error thread #"<<threadID<<" wants to enlist results, but monitor is not initialized.");

  AdaptationIDType adaptID;
  if (!this->GetAdaptionProcessedByThread(threadID,adaptID)) throwExceptionMacro("Error; thread #"<<threadID<<" wants to enlist results, but has no adaptation enlisted as his task.");

  //remove the thread from the processing list
  this->RemoveThreadFromProcessingList(threadID);
  this->SetAdaptationState(adaptID,Self::ASEvaluated);

  //now allow to enlist the results
  this->m_ResultMutex.Lock();
    this->m_AdaptOrderMutex.Lock();
      m_AdaptOrder.push_back(adaptID);
    this->m_AdaptOrderMutex.Unlock();

    this->InsertEvaluationResults(results);
  this->m_ResultMutex.Unlock();

  this->m_StatisticMutex.Lock();

    //create new entry
    if (m_pMetricStatistics)
    {
      StatisticEntry* pNewEntry = m_pMetricStatistics->GetData().PostCreateChildEntry(m_pMetricStatistics->GetData().GetCurrentEntryID());
      pNewEntry->SetRefID(1);

      //add adaptation ID
      pNewEntry->AddValue(Convert::ToStr(adaptID),1);

      //enlist the rest of the result   
      this->EnlistResultsToStatistic(results,*pNewEntry);

      //close entry
      pNewEntry->CloseEntry();
    }

    this->m_EventMutex.Lock();
      if (this->fnOnEvaluationDone.IsNotNull()) this->fnOnEvaluationDone->Execute(adaptID,"",(void*)this,threadID);
    this->m_EventMutex.Unlock();
  this->m_StatisticMutex.Unlock();
};

template <typename TResultClass>
void
SetupOptimizationMetricMonitorBase<TResultClass>::
SetMetricStatistic(Statistics* pStatistic)
{
  this->m_StatisticMutex.Lock();
    this->m_pMetricStatistics = pStatistic;
  this->m_StatisticMutex.Unlock();
};

template <typename TResultClass>
Statistics*
SetupOptimizationMetricMonitorBase<TResultClass>::
GetMetricStatistic()
{
  this->m_StatisticMutex.Lock();
  return this->m_pMetricStatistics;
};

template <typename TResultClass>
void
SetupOptimizationMetricMonitorBase<TResultClass>::
ReleaseMetricStatistic()
{
  this->m_StatisticMutex.Unlock();
};

template <typename TResultClass>
void
SetupOptimizationMetricMonitorBase<TResultClass>::
SetGenericSetup(Setup* pSetup)
{
  this->m_SetupMutex.Lock();
    this->m_smpGenericSetup = pSetup;
  this->m_SetupMutex.Unlock();
};

template <typename TResultClass>
void
SetupOptimizationMetricMonitorBase<TResultClass>::
SetAdaptationList(Adaptation::AdaptationList* pAdaptations)
{
  this->m_SetupMutex.Lock();
    this->m_smpAdaptations = pAdaptations;
  this->m_SetupMutex.Unlock();
};

template <typename TResultClass>
bool
SetupOptimizationMetricMonitorBase<TResultClass>::
GetAdaptationResults(const AdaptationIDType& adaptID, ResultType& results) const
{
  if (this->GetAdaptationState(adaptID) != Self::ASEvaluated) return false;

  ResultIndexType index = this->GetResultIndexOfAdaptation(adaptID);

  if (index == -1) return false;

  this->m_ResultMutex.Lock();
    this->CopyAdaptationResults(index,results);
  this->m_ResultMutex.Unlock();

  return true;
};
  
template <typename TResultClass>
typename SetupOptimizationMetricMonitorBase<TResultClass>::AdaptationIDListType
SetupOptimizationMetricMonitorBase<TResultClass>::
GetListOfPendingAdaptations() const
{
  return this->GetListOfAdaptationsByState(Self::ASPending);
};

template <typename TResultClass>
typename SetupOptimizationMetricMonitorBase<TResultClass>::AdaptationIDListType
SetupOptimizationMetricMonitorBase<TResultClass>::
GetListOfProcessedAdaptations() const
{
  return this->GetListOfAdaptationsByState(Self::ASProcessing);
};

template <typename TResultClass>
typename SetupOptimizationMetricMonitorBase<TResultClass>::AdaptationIDListType
SetupOptimizationMetricMonitorBase<TResultClass>::
GetListOfFailedAdaptations() const
{
  return this->GetListOfAdaptationsByState(Self::ASFailed);
};

template <typename TResultClass>
typename SetupOptimizationMetricMonitorBase<TResultClass>::AdaptationIDListType
SetupOptimizationMetricMonitorBase<TResultClass>::
GetListOfEvaluatedAdaptations() const
{
  return this->GetListOfAdaptationsByState(Self::ASEvaluated);
};

template <typename TResultClass>
typename SetupOptimizationMetricMonitorBase<TResultClass>::AdaptationIDListType
SetupOptimizationMetricMonitorBase<TResultClass>::
GetListOfAdaptationsByState(const AdaptationStateType& state) const
{
  AdaptationIDListType result;

  this->m_AdaptStatesMutex.Lock();
    for (AdaptationCountType index = 0; index < m_AdaptStates.size(); index++)
    {
      if (m_AdaptStates[index] == state) result.push_back(index);
    }
  this->m_AdaptStatesMutex.Unlock();

  return result;
};

template <typename TResultClass>
typename SetupOptimizationMetricMonitorBase<TResultClass>::AdaptationStateType
SetupOptimizationMetricMonitorBase<TResultClass>::
GetAdaptationState(const AdaptationIDType& adaptID) const
{
  bool bFound = false;
  AdaptationStateType result;

  this->m_AdaptStatesMutex.Lock();

    if ((adaptID>-1)||(adaptID>=m_AdaptStates.size()))
    {
      result = m_AdaptStates[adaptID];
      bFound =true;
    }

  this->m_AdaptStatesMutex.Unlock();

  if (!bFound) throwExceptionMacro("Error; adaption ID ("<<adaptID<<") is out of bound.");

  return result;
};

template <typename TResultClass>
bool
SetupOptimizationMetricMonitorBase<TResultClass>::
EvaluationIsFinished() const
{
  AdaptationCountType adaptSize;

  this->m_AdaptStatesMutex.Lock();
    adaptSize = this->m_AdaptStates.size();
  this->m_AdaptStatesMutex.Unlock();

  AdaptationCountType failedSize = this->GetListOfFailedAdaptations().size();
  AdaptationCountType evaluatedSize = this->GetListOfEvaluatedAdaptations().size;

  return adaptSize == failedSize+evaluatedSize;
};

template <typename TResultClass>
bool
SetupOptimizationMetricMonitorBase<TResultClass>::
IsInitialized() const
{
  //no mutex safety here because the bool should be equal or less then a
  //processor word. Therefor the returning of the Value is atomar.
  return m_IsInitialized;
};

template <typename TResultClass>
void
SetupOptimizationMetricMonitorBase<TResultClass>::
Initialize()
{
  AdaptationCountType adaptSize = 0;

  this->m_SetupMutex.Lock();
    bool bSetupInit = this->m_smpGenericSetup.IsNotNull();
    bool bAdaptationInit = this->m_smpAdaptations.IsNotNull();

    if (bSetupInit && bAdaptationInit)
    {
      this->m_Adaptor.SetTemplateSetup(this->m_smpGenericSetup);
      this->m_Adaptor.AddAdaptations(* (this->m_smpAdaptations.GetPointer()));
      adaptSize = this->m_smpAdaptations->Size();
    }
  this->m_SetupMutex.Unlock();

  if (!bSetupInit) throwExceptionMacro("Error; cannot initialize monitor, generic setup is not set.");
  if (!bAdaptationInit) throwExceptionMacro("Error; cannot initialize monitor, adaptation list is not set.");

  this->m_StatisticMutex.Lock();
    bool bStatisticInit = this->m_pMetricStatistics != 0;

    if (bStatisticInit)
    {
      this->m_pMetricStatistics->Reset();

      this->m_pMetricStatistics->GetDictionary().AddValueDefinition(this->GetNameOfClass(),"Adaption ID", "ID of the adaption the results are belonging to");
      this->m_pMetricStatistics->GetDictionary().AddEntryDefinition(this->GetNameOfClass(),"AdaptationMetricValues",this->GetNameOfClass(),"Metric values of an adaptation");
      this->EnlistDictionaryEntries(this->m_pMetricStatistics->GetDictionary());
    }
  this->m_StatisticMutex.Unlock();

  if (!bStatisticInit) throwExceptionMacro("Error; cannot initialize monitor, metric statistic is not set.");

  this->m_AdaptStatesMutex.Lock();
    this->m_AdaptStates.assign(adaptSize, Self::ASPending);
  this->m_AdaptStatesMutex.Unlock();

  this->m_AdaptThreadMutex.Lock();
    this->m_AdaptThread.clear();
  this->m_AdaptThreadMutex.Unlock();

  this->m_AdaptOrderMutex.Lock();
    this->m_AdaptOrder.clear();
  this->m_AdaptOrderMutex.Unlock();

  this->m_SetupMutex.Lock();
    this->m_IsInitialized = true;
  this->m_SetupMutex.Unlock();
};

template <typename TResultClass>
typename SetupOptimizationMetricMonitorBase<TResultClass>::AdaptationCountType
SetupOptimizationMetricMonitorBase<TResultClass>::
GetFailureCount() const
{
  return this->GetListOfFailedAdaptations().size();
};

template <typename TResultClass>
SetupOptimizationMetricMonitorBase<TResultClass>::
SetupOptimizationMetricMonitorBase()
{
  this->m_IsInitialized = false;
  this->m_AdaptOrder.clear();
  this->m_AdaptStates.clear();
  this->m_AdaptThread.clear();
  this->m_smpAdaptations = 0;
  this->m_pMetricStatistics = 0;
  this->m_smpGenericSetup = 0;
};

template <typename TResultClass>
SetupOptimizationMetricMonitorBase<TResultClass>::
~SetupOptimizationMetricMonitorBase()
{
};


template <typename TResultClass>
bool
SetupOptimizationMetricMonitorBase<TResultClass>::
GetAdaptionProcessedByThread(const ThreadIDType& threadID, AdaptationIDType& adaptationID) const
{
  bool result = false;

  this->m_AdaptThreadMutex.Lock();

    ThreadMapType::const_iterator finding = this->m_AdaptThread.find(threadID);
    if ( finding != this->m_AdaptThread.end( ) )
    {
      adaptationID = finding->second;
      result = true;
    }

  this->m_AdaptThreadMutex.Unlock();

  return result;
};

template <typename TResultClass>
bool
SetupOptimizationMetricMonitorBase<TResultClass>::
ThreadIsProcessing(const ThreadIDType& threadID) const
{
  AdaptationIDType adaptationID;
  return this->GetAdaptionProcessedByThread(threadID,adaptationID);
};

template <typename TResultClass>
void
SetupOptimizationMetricMonitorBase<TResultClass>::
EnlistThreadAsProcessing(const ThreadIDType& threadID,const AdaptationIDType& adaptationID)
{
  AdaptationIDType usedAdaptationID;
  if (this->GetAdaptionProcessedByThread(threadID,usedAdaptationID)) throwExceptionMacro("Error; tried to enlist thread #"<<threadID<<" for adaptation #"<<adaptationID<<", but thread already is enlisted for adaptation #"<<usedAdaptationID<<".");

  this->m_AdaptThreadMutex.Lock();

    typedef std::pair <ThreadIDType, AdaptationIDType> Map_Pair;
    this->m_AdaptThread.insert ( Map_Pair ( threadID, adaptationID ) );

  this->m_AdaptThreadMutex.Unlock();
};

template <typename TResultClass>
void
SetupOptimizationMetricMonitorBase<TResultClass>::
RemoveThreadFromProcessingList(const ThreadIDType& threadID)
{
  this->m_AdaptThreadMutex.Lock();

    ThreadMapType::iterator finding = this->m_AdaptThread.find(threadID);
    if ( finding != this->m_AdaptThread.end( ) )
    {
      this->m_AdaptThread.erase(finding);
    }

  this->m_AdaptThreadMutex.Unlock();
};

template <typename TResultClass>
typename SetupOptimizationMetricMonitorBase<TResultClass>::ResultIndexType
SetupOptimizationMetricMonitorBase<TResultClass>::
GetResultIndexOfAdaptation(const AdaptationIDType& adaptationID) const
{
  ResultIndexType result = -1;

  this->m_AdaptOrderMutex.Lock();

    for (AdaptationCountType index = 0; index < m_AdaptOrder.size(); index++)
    {
      if (m_AdaptOrder[index] == adaptationID) result = index;
    }

  this->m_AdaptOrderMutex.Unlock();

  return result;
};

template <typename TResultClass>
void
SetupOptimizationMetricMonitorBase<TResultClass>::
SetAdaptationState(const AdaptationIDType& adaptID, const AdaptationStateType& state)
{
  bool bFound = false;

  this->m_AdaptStatesMutex.Lock();

    if ((adaptID>-1)||(adaptID>=m_AdaptStates.size()))
    {
      m_AdaptStates[adaptID] = state;
      bFound =true;
    }

  this->m_AdaptStatesMutex.Unlock();

  if (!bFound) throwExceptionMacro("Error; adaption ID ("<<adaptID<<") is out of bound, state cannot be set.");
};

} // end namespace FREE

#endif

---