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 #include "ISSummaryWriter/ISSummaryManager.h"
00019
00020 #include <boost/date_time/posix_time/posix_time_types.hpp>
00021 #include <sstream>
00022 #include <string>
00023
00024 using namespace std;
00025 using namespace boost;
00026 using namespace Sct;
00027 using namespace SctData;
00028 using namespace Sct::IS;
00029 using namespace boost::posix_time;
00030
00031 namespace SctAnalysis {
00032
00033 AnalysisAlgorithm::AnalysisAlgorithm() : prototype(*this), ioTime(0), analysisTime(0),
00034 overheadTime(0), nCalls(0), nAnalyses(0) {
00035 }
00036
00037 AnalysisAlgorithm::AnalysisAlgorithm(shared_ptr<const TestData> testData, const string& moduleName, const AnalysisAlgorithm& prototype) throw()
00038 : m_modulename(moduleName), m_test(testData), m_done(false), prototype(prototype),
00039 ioTime(0), analysisTime(0), overheadTime(0), nCalls(0), nAnalyses(0) {
00040 scanData.resize(getTestData()->nScans);
00041 }
00042
00043 AnalysisAlgorithm::~AnalysisAlgorithm() throw() {
00044 boost::recursive_mutex::scoped_lock lock(m_access);
00045
00046 m_result.reset();
00047 }
00048
00049 shared_ptr<const TestData> AnalysisAlgorithm::getTestData() const {
00050 if (!m_test.get()) throw Sct::InvariantViolatedError("Attempt to retrieve null TestData - probably from prototype algorithm",__FILE__,__LINE__);
00051 return m_test;
00052 }
00053
00054 void AnalysisAlgorithm::checkTestResultExists() {
00055 if (m_result.get()==0){
00056 m_result = createTestResult();
00057 if (m_result.get()==0)
00058 throw IllegalStateError("AnalysisAlgorithm cannot initialize - no test exists", __FILE__, __LINE__);
00059 initializeTestResult();
00060 }
00061 }
00062
00063 void AnalysisAlgorithm::initializeTestResult() {
00064 m_result->setRunNumber(getTestData()->runNumber);
00065 m_result->setModuleName(m_modulename);
00066 m_result->setTestVariable(*SctData::ConfigurationVariableIOHelper::getFromTypeRep(getTestData()->testVariable));
00067 m_result->getHeader().setStartTimeString(getTestData()->startTime);
00068
00069
00070 for (unsigned int i=0; i<getTestData()->testPoints_size; ++i) {
00071 m_result->addScan(getTestData()->startScanNumber+i, getTestData()->testPoints[i]);
00072
00073 }
00074 }
00075
00076 void AnalysisAlgorithm::addFitScanResult(shared_ptr<Sct::IOName> name) {
00077 UniqueID id(name->getUniqueID());
00078 unsigned int index = id.getScanNumber() - getTestData()->startScanNumber;
00079 scanData[index].fitAvailable = true;
00080 scanData[index].fitName = name->getIOName();
00081 }
00082
00083 void AnalysisAlgorithm::addRawScanResult(shared_ptr<Sct::IOName> name) {
00084 UniqueID id(name->getUniqueID());
00085 unsigned int index = id.getScanNumber() - getTestData()->startScanNumber;
00086 scanData[index].rawAvailable = true;
00087 scanData[index].rawName = name->getIOName();
00088 }
00089
00090 void AnalysisAlgorithm::setFit(unsigned index, const std::string& fit){
00091 scanData[index].fitName=fit;
00092 scanData[index].fitAvailable=true;
00093 }
00094
00095 void AnalysisAlgorithm::setRaw(unsigned index, const std::string& raw){
00096 scanData[index].rawName=raw;
00097 scanData[index].fitAvailable=true;
00098 }
00099
00100 bool AnalysisAlgorithm::hasAllRaws() const {
00101 for (unsigned int i=0; i<scanData.size(); ++i) {
00102 if (!scanData[i].rawAvailable) return false;
00103 }
00104 return true;
00105 }
00106
00107 bool AnalysisAlgorithm::hasAllFits() const {
00108 for (unsigned int i=0; i<scanData.size(); ++i) {
00109 if (!scanData[i].fitAvailable) return false;
00110 }
00111 return true;
00112 }
00113
00114 void AnalysisAlgorithm::loadAllRaws() {
00115 for (unsigned int i=0; i<scanData.size(); ++i) {
00116 if (scanData[i].rawAvailable && !scanData[i].raw)
00117 scanData[i].raw = dynamic_pointer_cast<RawScanResult>(IOManagerIS::instance().read(scanData[i].rawName, 0));
00118 }
00119 }
00120
00121
00122 void AnalysisAlgorithm::loadAllFits() {
00123 for (unsigned int i=0; i<scanData.size(); ++i) {
00124 if (scanData[i].fitAvailable && !scanData[i].fit)
00125 scanData[i].fit = dynamic_pointer_cast<FitScanResult>(IOManagerIS::instance().read(scanData[i].fitName, 0));
00126 }
00127 }
00128
00129 shared_ptr<RawScanResult> AnalysisAlgorithm::getRaw(unsigned int index) const {
00130 if (!scanData[index].rawAvailable || !scanData[index].raw) throw IllegalStateError("AnalysisAlgorithm::getRaw. RawScanResult not available", __FILE__, __LINE__);
00131 return scanData[index].raw;
00132 }
00133
00134 shared_ptr<FitScanResult> AnalysisAlgorithm::getFit(unsigned int index) const {
00135 if (!scanData[index].fitAvailable || !scanData[index].fit) throw IllegalStateError("AnalysisAlgorithm::getFit. FitScanResult not available", __FILE__, __LINE__);
00136 return scanData[index].fit;
00137 }
00138
00139 void AnalysisAlgorithm::checkForZeroTriggerBins(){
00140 for (unsigned int iscan=0; iscan<scanData.size(); ++iscan) {
00141 if (scanData[iscan].raw) {
00142 bool problem=false;
00143 const ScanPoints& points = scanData[iscan].raw->getPoints();
00144 for (unsigned ipoint=0; ipoint<points.getNPoints(); ++ipoint){
00145 if (points.getNEvents(ipoint)==0) problem=true;
00146 }
00147 if (problem) {
00148 ostringstream comment;
00149 comment << "Problem: zero-trigger bin(s) in " << iscan << " scan";
00150 if (m_result) {
00151 m_result->setProblem(true);
00152 m_result->addComment(comment.str());
00153 }else{
00154 throw Sct::IllegalStateError("No test result available ",__FILE__,__LINE__);
00155 }
00156 }
00157 }
00158 }
00159 }
00160
00161 void AnalysisAlgorithm::mergeDefects() {
00162 if (!m_result) return;
00163 for (unsigned int i=0; i<scanData.size(); ++i) {
00164 if (scanData[i].fit) {
00165 m_result->getDefects() += scanData[i].fit->getDefects();
00166 }
00167 }
00168 }
00169
00170 void AnalysisAlgorithm::finish() {
00171 checkTestResultExists();
00172 checkForZeroTriggerBins();
00173 m_done=true;
00174 m_result->getHeader().setEndTime(second_clock::universal_time());
00175
00176 m_result->getPassed() ? addPass() : addFailure();
00177
00178 std::string options("SCAN_OPTIONS:");
00179 options+=getTestData()->options;
00180 m_result->addComment(options);
00181
00182
00183 try {
00184 Sct::IS::IOParamsIS param(AnalysisService::instance().getOutputISServerName());
00185 Sct::ISProxy::IOManagerISProxy::instance().write(*m_result, ¶m);
00186
00187 } catch (Throwable& e) {
00188 e.sendToMrs(MRS_ERROR);
00189 }
00190
00191 try{
00192 TestSummaryIS t;
00193 t.dataString = SctData::TestSummary::SummaryManager::instance().write(*m_result);
00194 string name = AnalysisService::instance().getOutputISServerName();
00195 name += ".";
00196 name += "Summary.";
00197 name += (string) m_result->getUniqueID();
00198 Sct::ISUtilities::addOrUpdateOrThrow(name, t, __FILE__, __LINE__, MRS_ERROR);
00199 } catch (Throwable& e) {
00200 e.sendToMrs(MRS_ERROR);
00201 }
00202
00203 try{
00204
00205
00206 if ((m_result->getClassName()=="SctData::NPtGainTestResult") || (m_result->getClassName()=="SctData::NoiseOccupancyTestResult")) {
00207 SctData::ISTestSummary::ISSummaryManager::instance().write(*m_result);
00208 }
00209 } catch (Throwable& e) {
00210 e.sendToMrs(MRS_ERROR);
00211 }
00212
00213 }
00214
00215 AnalysisAlgorithm::ScanData::ScanData() : rawAvailable(false), fitAvailable(false){
00216 }
00217
00218 string AnalysisAlgorithm::getStatus() const {
00219 boost::recursive_mutex::scoped_lock lock(m_status_access);
00220 ostringstream oss;
00221 oss << "Status: \n" << nAnalyses << " analyses done in " << analysisTime << "s\n"
00222 << "I/O: " << ioTime << "s. Overhead time: " << overheadTime << "s and called " << nCalls << " times\n"
00223 << "Total time: " << (analysisTime+ioTime+overheadTime) << "s average: " << ((analysisTime+ioTime+overheadTime)/nAnalyses) << endl;
00224 oss << "Passed : " << prototype.nPassed << ", Failed : " << prototype.nFailed << endl;
00225 return oss.str();
00226 }
00227 }