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