00001 #include "AnalysisAlgorithm.h"
00002 #include "AnalysisService.h"
00003 #include "SctData/TestResult.h"
00004 #include "SctData/FitScanResult.h"
00005 #include "SctData/RawScanResult.h"
00006 #include "Sct/UniqueID.h"
00007 #include "SctData/ConfigurationVariable.h"
00008 #include "Sct/SctNames.h"
00009 #include "Sct/LogicErrors.h"
00010 #include "Sct/IOName.h"
00011 #include "Sct/IS/IOManagerIS.h"
00012 #include "Sct/ISProxy/IOManagerISProxy.h"
00013 #include "Sct/ISUtilities.h"
00014 #include "SummaryWriter/SummaryManager.h"
00015 #include "SummaryWriter/SummaryWriter.h"
00016 #include "CalibrationController/IS/TestData.h"
00017 #include "SummaryWriter/TestSummaryIS.h"
00018
00019 #include <boost/date_time/posix_time/posix_time_types.hpp>
00020 #include <sstream>
00021 #include <string>
00022
00023 using namespace std;
00024 using namespace boost;
00025 using namespace Sct;
00026 using namespace SctData;
00027 using namespace Sct::IS;
00028 using namespace boost::posix_time;
00029
00030 namespace SctAnalysis {
00031
00032 AnalysisAlgorithm::AnalysisAlgorithm() : m_test(*new TestData), prototype(*this), ioTime(0), analysisTime(0),
00033 overheadTime(0), nCalls(0), nAnalyses(0) {
00034 }
00035
00036 AnalysisAlgorithm::AnalysisAlgorithm(const TestData& testData, const string& moduleName, const AnalysisAlgorithm& prototype) throw()
00037 : m_modulename(moduleName), m_test(testData), scanData(testData.nScans), m_done(false), prototype(prototype),
00038 ioTime(0), analysisTime(0), overheadTime(0), nCalls(0), nAnalyses(0) {
00039 }
00040
00041 AnalysisAlgorithm::~AnalysisAlgorithm() throw() {
00042 boost::recursive_mutex::scoped_lock lock(m_access);
00043
00044 m_result.reset();
00045 }
00046
00047 void AnalysisAlgorithm::checkTestResultExists() {
00048 if (m_result.get()==0){
00049 m_result = createTestResult();
00050 if (m_result.get()==0)
00051 throw IllegalStateError("AnalysisAlgorithm cannot initialize - no test exists", __FILE__, __LINE__);
00052 initializeTestResult();
00053 }
00054 }
00055
00056 void AnalysisAlgorithm::initializeTestResult() {
00057 m_result->setRunNumber(m_test.runNumber);
00058 m_result->setModuleName(m_modulename);
00059 m_result->setTestVariable(*SctData::ConfigurationVariableIOHelper::getFromTypeRep(m_test.testVariable));
00060 m_result->getHeader().setStartTimeString(m_test.startTime);
00061
00062
00063 for (unsigned int i=0; i<m_test.testPoints_size; ++i) {
00064 m_result->addScan(m_test.startScanNumber+i, m_test.testPoints[i]);
00065
00066 }
00067 }
00068
00069 void AnalysisAlgorithm::addFitScanResult(shared_ptr<Sct::IOName> name) {
00070 UniqueID id(name->getUniqueID());
00071 unsigned int index = id.getScanNumber() - getTestData().startScanNumber;
00072 scanData[index].fitAvailable = true;
00073 scanData[index].fitName = name->getIOName();
00074 }
00075
00076 void AnalysisAlgorithm::addRawScanResult(shared_ptr<Sct::IOName> name) {
00077 UniqueID id(name->getUniqueID());
00078 unsigned int index = id.getScanNumber() - getTestData().startScanNumber;
00079 scanData[index].rawAvailable = true;
00080 scanData[index].rawName = name->getIOName();
00081 }
00082
00083 void AnalysisAlgorithm::setFit(unsigned index, const std::string& fit){
00084 scanData[index].fitName=fit;
00085 scanData[index].fitAvailable=true;
00086 }
00087
00088 void AnalysisAlgorithm::setRaw(unsigned index, const std::string& raw){
00089 scanData[index].rawName=raw;
00090 scanData[index].fitAvailable=true;
00091 }
00092
00093 bool AnalysisAlgorithm::hasAllRaws() const {
00094 for (unsigned int i=0; i<scanData.size(); ++i) {
00095 if (!scanData[i].rawAvailable) return false;
00096 }
00097 return true;
00098 }
00099
00100 bool AnalysisAlgorithm::hasAllFits() const {
00101 for (unsigned int i=0; i<scanData.size(); ++i) {
00102 if (!scanData[i].fitAvailable) return false;
00103 }
00104 return true;
00105 }
00106
00107 void AnalysisAlgorithm::loadAllRaws() {
00108 for (unsigned int i=0; i<scanData.size(); ++i) {
00109 if (scanData[i].rawAvailable && !scanData[i].raw)
00110 scanData[i].raw = dynamic_pointer_cast<RawScanResult>(IOManagerIS::instance().read(scanData[i].rawName, 0));
00111 }
00112 }
00113
00114
00115 void AnalysisAlgorithm::loadAllFits() {
00116 for (unsigned int i=0; i<scanData.size(); ++i) {
00117 if (scanData[i].fitAvailable && !scanData[i].fit)
00118 scanData[i].fit = dynamic_pointer_cast<FitScanResult>(IOManagerIS::instance().read(scanData[i].fitName, 0));
00119 }
00120 }
00121
00122 shared_ptr<RawScanResult> AnalysisAlgorithm::getRaw(unsigned int index) const {
00123 if (!scanData[index].rawAvailable || !scanData[index].raw) throw IllegalStateError("AnalysisAlgorithm::getRaw. RawScanResult not available", __FILE__, __LINE__);
00124 return scanData[index].raw;
00125 }
00126
00127 shared_ptr<FitScanResult> AnalysisAlgorithm::getFit(unsigned int index) const {
00128 if (!scanData[index].fitAvailable || !scanData[index].fit) throw IllegalStateError("AnalysisAlgorithm::getFit. FitScanResult not available", __FILE__, __LINE__);
00129 return scanData[index].fit;
00130 }
00131
00132 void AnalysisAlgorithm::mergeDefects() {
00133 if (!m_result) return;
00134 for (unsigned int i=0; i<scanData.size(); ++i) {
00135 if (scanData[i].fit) {
00136 m_result->getDefects() += scanData[i].fit->getDefects();
00137 }
00138 }
00139 }
00140
00141 void AnalysisAlgorithm::finish() {
00142 checkTestResultExists();
00143 m_done=true;
00144 m_result->getHeader().setEndTime(second_clock::universal_time());
00145
00146 m_result->getPassed() ? addPass() : addFailure();
00147
00148
00149 try {
00150 Sct::IS::IOParamsIS param(AnalysisService::instance().getOutputISServerName());
00151 Sct::ISProxy::IOManagerISProxy::instance().write(*m_result, ¶m);
00152
00153 } catch (Throwable& e) {
00154 e.sendToMrs(MRS_ERROR);
00155 }
00156
00157 try{
00158 TestSummaryIS t;
00159 t.dataString = SctData::TestSummary::SummaryManager::instance().write(*m_result);
00160 string name = AnalysisService::instance().getOutputISServerName();
00161 name += ".";
00162 name += "Summary.";
00163 name += (string) m_result->getUniqueID();
00164 Sct::ISUtilities::addOrUpdateOrThrow(name, t, __FILE__, __LINE__, MRS_ERROR);
00165 } catch (Throwable& e) {
00166 e.sendToMrs(MRS_ERROR);
00167 }
00168 }
00169
00170 AnalysisAlgorithm::ScanData::ScanData() : rawAvailable(false), fitAvailable(false){
00171 }
00172
00173 string AnalysisAlgorithm::getStatus() const {
00174 boost::recursive_mutex::scoped_lock lock(m_status_access);
00175 ostringstream oss;
00176 oss << "Status: \n" << nAnalyses << " analyses done in " << analysisTime << "s\n"
00177 << "I/O: " << ioTime << "s. Overhead time: " << overheadTime << "s and called " << nCalls << " times\n"
00178 << "Total time: " << (analysisTime+ioTime+overheadTime) << "s average: " << ((analysisTime+ioTime+overheadTime)/nAnalyses) << endl;
00179 oss << "Passed : " << prototype.nPassed << ", Failed : " << prototype.nFailed << endl;
00180 return oss.str();
00181 }
00182 }