---

AnalysisAlgorithm.cpp

Go to the documentation of this file.

#include "AnalysisAlgorithm.h"
#include "SctData/TestResult.h"
#include "SctData/FitScanResult.h"
#include "SctData/RawScanResult.h"
#include "SctData/ConfigurationVariable.h"
#include "Sct/SctNames.h"
#include "Sct/IS/IOManagerIS.h"
#include "SummaryWriter/SummaryManager.h"
#include "SummaryWriter/SummaryWriter.h"
#include "CalibrationController/IS/TestData.h"
#include "TestSummaryIS.h"
#include <sstream>
#include <string>

using namespace SctData;
using std::string;

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

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

    void AnalysisAlgorithm::initializeTestResult() throw(Sct::LogicError) {
    checkTestResultExists();

    m_result->setRunNumber(m_test.runNumber);
    m_result->setModuleName(m_modulename);
    m_result->setTestVariable(*SctData::ConfigurationVariableIOHelper::getFromTypeRep(m_test.testVariable));
    
    //Now add all the scans:
    for (unsigned int i=0; i<m_test.testPoints_size; ++i) {
        m_result->addScan(m_test.startScanNumber+i, m_test.testPoints[i]);
        //cout << "Analysis algorithm adding scan number ... "<<m_test->startScanNumber+i<<" to test"<<endl;
    }
    }

    void AnalysisAlgorithm::addFit(const string& name) throw(Sct::LogicError, Sct::IoError) {
    boost::recursive_mutex::scoped_lock lock(m_access);
    checkTestResultExists();
    //cerr << "adding fit "<<name<<endl;
    Sct::IS::IOParamsIS param(Sct::SctNames::getFittedDataName());
    boost::shared_ptr<const Sct::Streamable> ob = Sct::IS::IOManagerIS::instance().read(name, &param);
    boost::shared_ptr<const FitScanResult> fit = boost::dynamic_pointer_cast<const FitScanResult>(ob);
    if (!fit) throw InvalidArgumentError("AnalsisAlogrithm::addFit: " + name + " is not a valid FitScanResult", __FILE__, __LINE__);
    getTestResult()->addFit(fit);
    }

    void AnalysisAlgorithm::addRaw(const string& name) throw(Sct::LogicError, Sct::IoError) {
    boost::recursive_mutex::scoped_lock lock(m_access);
    checkTestResultExists();
    //cerr << "adding raw "<<name<<endl;
    Sct::IS::IOParamsIS param(Sct::SctNames::getEventDataName());
    boost::shared_ptr<const Sct::Streamable> ob = Sct::IS::IOManagerIS::instance().read(name, &param);
    boost::shared_ptr<const RawScanResult> raw = boost::dynamic_pointer_cast<const RawScanResult>(ob);
    if (!raw) throw InvalidArgumentError("AnalsisAlogrithm::addRaw: " + name + " is not a valid RawScanResult", __FILE__, __LINE__);
    getTestResult()->addRaw(raw);
    }
    
    void AnalysisAlgorithm::finish() throw(Sct::IoError, Sct::LogicError) {
    checkTestResultExists();
    m_done=true;
    cout <<"Algorithm done"<<endl;
    try {
        Sct::IS::IOParamsIS param(Sct::SctNames::getTestDataName());
        Sct::IS::IOManagerIS::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 = SctNames::getTestDataName();
        name += ".";
        name += "Summary.";
        name += m_result->getUniqueID();
        ISInfoDictionary& is = SctNames::getISDictionary();
        ISInfo::Status stat;
        
        if (is.contains(name.c_str())) {
        stat = is.update(name.c_str(), t);
        } else {
        stat = is.insert(name.c_str(), t);
        }
    } catch (Throwable& e) {
        e.sendToMrs(MRS_ERROR); 
    }
    }
}

---