AnalysisAlgorithm.cpp

#include "AnalysisAlgorithm.h"
#include "AnalysisService.h"
#include "SctData/TestResult.h"
#include "SctData/FitScanResult.h"
#include "SctData/RawScanResult.h"
#include "Sct/UniqueID.h"
#include "SctData/ConfigurationVariable.h"
#include "Sct/SctNames.h"
#include "Sct/LogicErrors.h"
#include "Sct/IOName.h"
#include "Sct/IS/IOManagerIS.h"
#include "Sct/ISProxy/IOManagerISProxy.h"
#include "Sct/ISUtilities.h"
#include "SummaryWriter/SummaryManager.h"
#include "SummaryWriter/SummaryWriter.h"
#include "CalibrationController/IS/TestData.h"
#include "SummaryWriter/TestSummaryIS.h"
#include "ISSummaryWriter/ISSummaryManager.h"

#include <boost/date_time/posix_time/posix_time_types.hpp>
#include <sstream>
#include <string>

using namespace std;
using namespace boost;
using namespace Sct;
using namespace SctData;
using namespace Sct::IS;
using namespace boost::posix_time;

namespace SctAnalysis {

AnalysisAlgorithm::AnalysisAlgorithm() : prototype(*this), ioTime(0), analysisTime(0), 
    overheadTime(0), nCalls(0), nAnalyses(0) {
}

AnalysisAlgorithm::AnalysisAlgorithm(shared_ptr<const TestData> testData, const string& moduleName, const AnalysisAlgorithm& prototype) throw()
    : m_modulename(moduleName), m_test(testData), m_done(false),  prototype(prototype),
    ioTime(0), analysisTime(0), overheadTime(0), nCalls(0), nAnalyses(0) {
  int results_per_scan = (getTestData()->options.find("full")==std::string::npos) ? 1 : 3;
  scanData.resize(getTestData()->nScans * results_per_scan);
}

AnalysisAlgorithm::~AnalysisAlgorithm() throw() {
    boost::recursive_mutex::scoped_lock lock(m_access);
    //Need to explicitly delete so that lock is in force
    m_result.reset();
}

shared_ptr<const TestData> AnalysisAlgorithm::getTestData() const {
  if (!m_test.get()) throw Sct::InvariantViolatedError("Attempt to retrieve null TestData - probably from prototype algorithm",__FILE__,__LINE__);
  return m_test;
}

void AnalysisAlgorithm::setTestData(shared_ptr<const TestData> testdata){
  if (!m_test.get()) throw Sct::InvariantViolatedError("Attempt to set null TestData",__FILE__,__LINE__);
  m_test = testdata;
}

void AnalysisAlgorithm::checkTestResultExists() {
    if (m_result.get()==0){
    m_result = createTestResult();
    if (m_result.get()==0)
        throw IllegalStateError("AnalysisAlgorithm cannot initialize - no test exists", __FILE__, __LINE__);
    initializeTestResult();
    }
}

void AnalysisAlgorithm::initializeTestResult() {
    m_result->setRunNumber(getTestData()->runNumber);
    m_result->setModuleName(m_modulename);
    m_result->setTestVariable(*SctData::ConfigurationVariableIOHelper::getFromTypeRep(getTestData()->testVariable));
    m_result->getHeader().setStartTimeString(getTestData()->startTime);

    //Now add all the scans:
    for (unsigned int i=0; i<getTestData()->testPoints_size; ++i) {
        m_result->addScan(getTestData()->startScanNumber+i, getTestData()->testPoints[i]);
        //cout << "Analysis algorithm adding scan number ... "<<m_test->startScanNumber+i<<" to test"<<endl;
    }
}

void AnalysisAlgorithm::addFitScanResult(shared_ptr<Sct::IOName> name) {
    UniqueID id(name->getUniqueID());
    unsigned int index = id.getScanNumber() - getTestData()->startScanNumber;
    scanData[index].fitAvailable = true;
    scanData[index].fitName = name->getIOName();
}

void AnalysisAlgorithm::addRawScanResult(shared_ptr<Sct::IOName> name) {
    UniqueID id(name->getUniqueID());
    unsigned int index = id.getScanNumber() - getTestData()->startScanNumber;
    scanData[index].rawAvailable = true;
    scanData[index].rawName = name->getIOName();
}

void AnalysisAlgorithm::setFit(unsigned index, const std::string& fit){
    scanData[index].fitName=fit;
    scanData[index].fitAvailable=true;
}

void AnalysisAlgorithm::setRaw(unsigned index, const std::string& raw){
    scanData[index].rawName=raw;
    scanData[index].fitAvailable=true;
}

bool AnalysisAlgorithm::hasAllRaws() const {
    for (unsigned int i=0; i<scanData.size(); ++i) {
    if (!scanData[i].rawAvailable) return false;
    }
    return true;
}

bool AnalysisAlgorithm::hasAllFits() const {
    for (unsigned int i=0; i<scanData.size(); ++i) {
    if (!scanData[i].fitAvailable) return false;
    }
    return true;
}

void AnalysisAlgorithm::loadAllRaws() {
    for (unsigned int i=0; i<scanData.size(); ++i) {
    if (scanData[i].rawAvailable && !scanData[i].raw) 
        scanData[i].raw = dynamic_pointer_cast<RawScanResult>(IOManagerIS::instance().read(scanData[i].rawName, 0));
    }
}


void AnalysisAlgorithm::loadAllFits() {
    for (unsigned int i=0; i<scanData.size(); ++i) {
    if (scanData[i].fitAvailable && !scanData[i].fit) 
        scanData[i].fit = dynamic_pointer_cast<FitScanResult>(IOManagerIS::instance().read(scanData[i].fitName, 0));
    }
}

shared_ptr<RawScanResult> AnalysisAlgorithm::getRaw(unsigned int index) const {
    if (!scanData[index].rawAvailable || !scanData[index].raw) throw IllegalStateError("AnalysisAlgorithm::getRaw.  RawScanResult not available", __FILE__, __LINE__);
    return scanData[index].raw;
}

shared_ptr<FitScanResult> AnalysisAlgorithm::getFit(unsigned int index) const {
    if (!scanData[index].fitAvailable || !scanData[index].fit) throw IllegalStateError("AnalysisAlgorithm::getFit.  FitScanResult not available", __FILE__, __LINE__);
    return scanData[index].fit;
}

void AnalysisAlgorithm::checkForZeroTriggerBins(){
  for (unsigned int iscan=0; iscan<scanData.size(); ++iscan) {
    if (scanData[iscan].raw) {
      bool problem=false;
      const ScanPoints& points = scanData[iscan].raw->getPoints();
      for (unsigned ipoint=0; ipoint<points.getNPoints(); ++ipoint){
    if (points.getNEvents(ipoint)==0) problem=true; 
      }
      if (problem) {
    ostringstream comment;
    comment << "Problem: zero-trigger bin(s) in scan " << iscan << "\n"; 
    if (m_result) { 
      m_result->setProblem(true);
      m_result->addComment(comment.str());
    }else{
      throw Sct::IllegalStateError("No test result available ",__FILE__,__LINE__); 
    }
      }
    }
  }
}

void AnalysisAlgorithm::mergeDefects() {
    if (!m_result) return;
    for (unsigned int i=0; i<scanData.size(); ++i) {
    if (scanData[i].fit) {
        m_result->getDefects() += scanData[i].fit->getDefects();
    }
    }
}

void AnalysisAlgorithm::finish() {
    checkTestResultExists();
    checkForZeroTriggerBins();
    m_done=true;
    m_result->getHeader().setEndTime(second_clock::universal_time());

    m_result->getPassed() ? addPass() : addFailure();

    std::string options("SCAN_OPTIONS:");
    options+=getTestData()->options;
    m_result->addComment(options);

    //cout <<"Algorithm done"<<endl;
    try {
        Sct::IS::IOParamsIS param(AnalysisService::instance().getOutputISServerName());
        Sct::ISProxy::IOManagerISProxy::instance().write(*m_result, &param);
        //cout <<"TestResult published"<<endl;
    } catch (Throwable& e) {
        e.sendToMrs(MRS_ERROR);
    }

    try{
        TestSummaryIS t;
        t.dataString = SctData::TestSummary::SummaryManager::instance().write(*m_result);
        string name = AnalysisService::instance().getOutputISServerName();
        name += ".";
        name += "Summary.";
        name += (string) m_result->getUniqueID();
    Sct::ISUtilities::addOrUpdateOrThrow(name, t, __FILE__, __LINE__, MRS_ERROR);
    } catch (Throwable& e) {
        e.sendToMrs(MRS_ERROR);
    }

    try{

      //  This is a temporary workaround... just for testing purposes. BD 
      if ((m_result->getClassName()=="SctData::NPtGainTestResult") || (m_result->getClassName()=="SctData::NoiseOccupancyTestResult")) {
    SctData::ISTestSummary::ISSummaryManager::instance().write(*m_result);
      }
    } catch (Throwable& e) {
      e.sendToMrs(MRS_ERROR);
    }

}
 
 AnalysisAlgorithm::ScanData::ScanData() : rawAvailable(false), fitAvailable(false){
 }
    
string AnalysisAlgorithm::getStatus() const {
  boost::recursive_mutex::scoped_lock lock(m_status_access);
    ostringstream oss;
    oss << "Status: \n" << nAnalyses << " analyses done in " << analysisTime << "s\n" 
    << "I/O: " << ioTime << "s.  Overhead time: " << overheadTime << "s and called " << nCalls << " times\n"
    << "Total time: " << (analysisTime+ioTime+overheadTime) << "s average: " << ((analysisTime+ioTime+overheadTime)/nAnalyses) << endl;
    oss << "Passed : " << prototype.nPassed << ", Failed : " << prototype.nFailed << endl;
    return oss.str();
}
}

---