ReAnalyse.cpp

#include "ReAnalyse.h"
#include "AnalysisAlgorithmMap.h"
#include <boost/lexical_cast.hpp>
#include "CalibrationController/IS/TestData.h"
using namespace std;
using boost::lexical_cast;

namespace SctAnalysis{

void ReAnalyse::printHelp() const{
  cerr << "Usage: ReAnalyse -t <test> -m <module1> <module2> -r <run> -s <scan1> <scan2> [-v] [-n] ..." << endl;
  cerr << "-t <test_name> name of test to analyse (one only)" << endl;
  cerr << "-m <module1> [<module2> ...] list of modules to analyse" << endl;
  cerr << "-r <run> set run number (can be used more than once)" << endl;
  cerr << "-s <scan1> [<scan2> ...] list of scans for current run number" << endl;
  cerr << "-p <testpoint1> [<testpoint2> ... ]  list of values of test points" << endl;
  cerr << "-v verbose mode - print debug information";
  cerr << "-n dont actually do the analysis, just parse the arguments and print" << endl;
  cerr << "--help print this help message" << endl;
  throw Sct::IoException("Print Help", __FILE__, __LINE__);
}

ReAnalyse::ReAnalyse(int argc, char** argv){
  if (argc<2) printHelp();
  verbosity=0;
  m_option_n=false;
  string lastswitch;
  bool haverun=false;
  unsigned long lastrun=0;
  for (int i=1; i<argc; ++i) {
    //cout << "i=" << i << " " << argv[i] << endl;
    string current=argv[i];
    if (current == "--help") {
       printHelp();
    } else if (current=="-v") {
       verbosity=1;
    } else if (current=="-n") {
       verbosity=1;
       m_option_n=true;
    } else if (current=="-t") {
      if (m_testName!=""){
    cerr << "Only one -t argument allowed: already have " << m_testName << endl;
    printHelp();
      }
      if (i+1 >= argc) {
    cerr << "Invalid arguments for option -t" << endl;
    printHelp();
      }
      m_testName=argv[i+1];
      i++;
    } else if (current=="-m" || current=="-r" || current=="-s" || current =="-p") {
      if (i+1 >= argc) {
    cerr << "Invalid arguments for option " << current << endl;
    printHelp();
      }else{
    lastswitch=current;
      }
    }else if (lastswitch=="-m"){
      m_modules.push_back(current);
    }else if (lastswitch=="-p"){
      try {
    m_testPoints.push_back(lexical_cast<double>(current));
      }catch(std::exception& e){
    cerr << "Can't interpret ``" << current << "'' as a test point value" << endl;
    printHelp();
      }
    }else if (lastswitch=="-r"){
      try{
    lastrun=lexical_cast<long unsigned>(current);
    haverun=true;
      }catch(std::exception& e){
       cerr << "Can't interpret ``" << current << "'' as a run number" << endl;
       printHelp();
      }
    }else if (lastswitch=="-s"){
      if (!haverun) {
         cerr << "Please set run number before listing scans" << endl;
         printHelp();
      }
      try{
    long unsigned scan=lexical_cast<long unsigned>(current);
    m_runScan.push_back( make_pair(lastrun, scan) );
      }catch (std::exception& e){
        cerr << "Can't interpret ``" << current << "'' as a scan number" << endl;
        printHelp();
      }
    }else{
      cerr << "I dont understand ``" << current << "''" << endl;
      printHelp();
    }
  }
  if (m_modules.empty()) {
     cerr << "No modules listed" << endl;
     printHelp();
  }
  if (m_runScan.empty()){
    cerr << "No scans listed" << endl;
    printHelp();
  }
  if (m_testPoints.size()!=m_runScan.size()){
    cerr << "You should give exactly one test point per scan!" << endl;
    printHelp();
  }
}

void ReAnalyse::print(std::ostream& os) const{
  os << "ReAnalyse test named: " << m_testName << endl;
  os << "Modules:" << endl;
  for (list<string>::const_iterator i=m_modules.begin(); i!=m_modules.end(); ++i ){
     os << "\t" << *i << endl;
  }
  os << "Run, Scan, TestPoint sets:" << endl;
  list<double>::const_iterator ipt=m_testPoints.begin();
  for (list<pair<long unsigned, long unsigned> >::const_iterator i= m_runScan.begin(); i!= m_runScan.end(); ++i){
    os << "\t" << (*i).first << ", " << (*i).second <<  " -> " << (*ipt)<< endl;
    ++ipt;
  }
}

inline bool pairWiseLessThan(pair<unsigned long, unsigned long> a, 
                     pair<unsigned long, unsigned long> b ){
     if (a.first==b.first) {
       return a.second<b.second;
     } else {
       return a.first<b.first; 
     } 
}

void ReAnalyse::go(){
  // sort by run and then scan 
  // m_runScan.sort(pairWiseLessThan);
  // print if necessary
  if (verbosity>0) print(cout);
  
  // need to make up a TestData object
  TestData td;
  td.testName=m_testName;
  td.runNumber=(*m_runScan.begin()).first;
  td.nScans=m_runScan.size();
  td.startScanNumber=(*m_runScan.begin()).second;
  td.testVariable=0;
  td.startTime="";
  td.endTime="";
  td.modules = new std::string[m_modules.size()];
  td.modules_size = m_modules.size();
  td.testPoints_size=m_runScan.size();
  td.testPoints = new double[m_runScan.size()];

  // copy users test points into testPoints
  std::list<double>::iterator ipt=m_testPoints.begin();
  for (unsigned i=0; i<m_runScan.size(); ++i){
    td.testPoints[i]=(*ipt); ipt++;
  }
  // CreateAnalysisAlgorithms
  try {
    unsigned icount=0;
    for (list<string>::const_iterator i=m_modules.begin(); i!= m_modules.end(); ++i ){
      td.modules[icount]=*i;
      shared_ptr<const TestData> tdclone(new TestData(td));
      m_algorithms.push_back(AnalysisAlgorithmMap::instance().getAlgorithm(tdclone, *i));
      ++icount;
    }
  } catch(Sct::Throwable& e){
    e.sendToMrs();
    cerr << e.what() << endl;
    return;
  }

  // if set to not analyse, return
  if (m_option_n) return;
  // Set AnalysisAlgorithms to work!
  for (list<shared_ptr<AnalysisAlgorithm> >::iterator ialg=m_algorithms.begin(); ialg!= m_algorithms.end(); ++ialg){
    try{
      unsigned ictrs=0;
      for (list<pair<long unsigned,long unsigned> >::const_iterator irs=m_runScan.begin() ; irs!=m_runScan.end(); ++irs){
        std::ostringstream ossfit, ossraw; 
    ossfit << "FittedData.SctData::FitScanResult." << (*irs).first << "." << (*irs).second << "." << (*ialg)->getModuleName();
        ossraw << "EventData.SctData::RawScanResult." << (*irs).first << "." << (*irs).second << "." << (*ialg)->getModuleName();
    (*ialg)->setFit(ictrs, ossfit.str());
    (*ialg)->setRaw(ictrs, ossraw.str());
        ictrs++;
      }
      (*ialg)->checkTestResultExists();
      if (!(*ialg)->canAnalyze()) throw Sct::IllegalStateError("Internal error - cant analyze - dont have all data", __FILE__, __LINE__);
      if (verbosity>0) std::cout << "Load " << (*ialg)->getModuleName() << endl;
      (*ialg)->loadData();
      if (verbosity>0) std::cout << "Analyse " << (*ialg)->getModuleName() << endl;
      (*ialg)->analyze();
      if (verbosity>0) std::cout << "Write " << (*ialg)->getModuleName() << endl;
      (*ialg)->finish();
      if (verbosity>0) std::cout << "Done " << (*ialg)->getModuleName() << endl;
    }catch(Sct::Throwable& e){
      e.sendToMrs();
      cerr << e.what() << endl;
    }
  } 
}
}

---