FitterWorkerGroup.cpp

#include "FitterWorkerGroup.h"
#include "Fitter.h"
#include "FitAlgorithm.h"
#include "FitAlgorithmMap.h"

#include <iomanip>

#include "Sct/SctNames.h"
#include "Sct/IS/IOManagerIS.h"
#include "Sct/ISProxy/IOManagerISProxy.h"
#include "Sct/IS/IONameIS.h"
#include "SctData/FitScanResult.h"
#include "SctData/RawScanResult.h"
#include "SctData/ConfigurationVariable.h"
#include "SctData/NullVariable.h"
#include "Sct/StdExceptionWrapper.h"
#include "ScanResultWriter/dataTypes.h"
#include "CalibrationController/IS/TestData.h"
#include <boost/timer.hpp>
#include "Sct/IS/IONameIS.h"
#include <is/infodictionary.h>

using namespace std;
using namespace SctService;
using boost::shared_ptr;
using boost::timer;
using namespace SctData;
using namespace Sct;
using namespace Sct::IS;

namespace SctFitter {


FitterWorkerGroup::FitterWorkerGroup() : m_calls(0), m_debug(false) {}

FitterWorkerGroup::~FitterWorkerGroup() {}

void FitterWorkerGroup::work(string name) throw() {
  using namespace SctData;
  timer t;
  
  Sct::IS::IONameIS ioname(name);
  
  if (debug()) cout << "Callback on " << name << endl;
  
  try {
    if (ioname.getClassName()=="TestData"){
      recursive_mutex::scoped_lock lock(m_testAccess);
      boost::shared_ptr<TestData> testdata( new TestData() );
      ISInfoDictionary& id = Sct::SctNames::getISDictionary();
      ISInfo::Status result = id.findValue(name, *testdata);
      if (result != ISInfo::Success) {
    throw IsException(result,std::string("Error reading from IS server.  Couldn't read: ")
              + name, __FILE__, __LINE__);
      }
      if (debug()) cout << "... which is a TestData" << endl;
      addTestData(testdata);
      
      if (testdata->analysisAlgorithm==""){
    std::ostringstream message;
    message << "Your TestRequest script [" << name
        << "] has not requested an AnalysisAlgorithm.";
    Sct::SctNames::Mrs() << "FITTING_SERVICE" << MRS_TEXT(message.str()) << MRS_WARNING << ENDM;
      }
    } else if (ioname.getClassName()=="SctData::RawScanResult"){ 


      std::string requestedAlgorithm("");
      {
    // lock the tests access while we look at it
    recursive_mutex::scoped_lock lock(m_testAccess);
    //FIRST find out if we are to do anything with it...

    boost::shared_ptr<const TestData> td = findTestData(ioname.getUniqueID().getRunNumber(), 
                                ioname.getUniqueID().getScanNumber());
    if (td.get()) {
      requestedAlgorithm = td->fitAlgorithm;
      if (debug()) cout << "Requested algorithm = " << requestedAlgorithm  << std::endl;
    }else{
      std::ostringstream message;
      message << "No test matching object " << name;
      Sct::SctNames::Mrs() << "FITTING_SERVICE" << MRS_TEXT(message.str()) << MRS_WARNING << ENDM;
      if (debug()) std::cout << message.str() << std::endl;
    }
    
    if (requestedAlgorithm=="NONE") {
      if (debug()) cout << "Will not fit [" << name  << "]" << std::endl;
      return;
    }
      }

      // ok - so we need to load the data object to investigate further
      shared_ptr<const Serializable> ob ( IOManagerIS::instance().read(name) );
      
      shared_ptr<const RawScanResult> raw = dynamic_pointer_cast<const RawScanResult>(ob);
      if (!raw) throw InvalidArgumentError("Fitter::work(): Not a RawScanResult", __FILE__, __LINE__);
      
      Fitter::instance().addIOTime(t.elapsed());
      t.restart();
      
      // make a cache of the name of this scan:
      Fitter::instance().setLastScanName(raw->getUniqueID());
      
      // if no algorithm is offered, make a guess!
      if (requestedAlgorithm=="") {
    requestedAlgorithm = raw->getHeader().getVariable().getVariableName();
    std::ostringstream message;
    message << "Guessing that algorithm used should be " << requestedAlgorithm;
    Sct::SctNames::Mrs() << "FITTING_SERVICE" << MRS_TEXT(message.str()) << MRS_INFORMATION << ENDM;
      }
      
      const FitAlgorithm& alg = FitAlgorithmMap::instance().getAlgorithm(requestedAlgorithm);
      std::auto_ptr<SctData::FitScanResult> fitted = alg.doFit(*raw);
      
      Fitter::instance().incrementFitsDone();
      m_calls++;
      Fitter::instance().scanDone(t.elapsed());
      t.restart();
      
      //Publish object
      Sct::IS::IOParamsIS params(Sct::SctNames::getFittedDataName());
      Sct::ISProxy::IOManagerISProxy::instance().write(*fitted, &params);   
      Fitter::instance().addIOTime(t.elapsed());
    } else {
      std::cout << "Callback for unknown type: [" << name << "]" << std::endl;
    }
  } catch (Sct::InvalidArgumentError& e) {
    e.sendToMrs();
    Fitter::instance().incrementFitErrors();
  } catch(Sct::Throwable& e) {
    e.sendToMrs(MRS_ERROR);
    Fitter::instance().incrementFitErrors();
  } catch(std::exception& e) {
    StdExceptionWrapper sew(e);
    sew.sendToMrs(MRS_ERROR);
    Fitter::instance().incrementFitErrors();    
  } catch(...) {
    Error e("uncaught unknown exception", __FILE__, __LINE__);
    e.sendToMrs(MRS_ERROR);
    Fitter::instance().incrementFitErrors();    
  }    
}

void FitterWorkerGroup::setDebug(bool value){
  std::cout << "Debugging on" << std::endl;
  m_debug=value;
}

bool FitterWorkerGroup::debug() const{
  return m_debug;
}

shared_ptr<const TestData>& FitterWorkerGroup::findTestData(unsigned long run, unsigned long scan){
  boost::recursive_mutex::scoped_lock lock(m_testAccess);
  for (std::list<boost::shared_ptr<const TestData> >::iterator i=m_tests.begin();
       i!= m_tests.end(); ++i){
    // remove null pointers
    if (!(*i).get()) {
      i=m_tests.erase(i); continue;
    }
    int results_per_scan = ((*i)->options.find("full")==std::string::npos ? 1 :3);
    if (run == (*i)->runNumber && 
    scan >= (*i)->startScanNumber &&
    scan < ((*i)->startScanNumber+(*i)->nScans * results_per_scan) ){
      return (*i);
    }
  }
  shared_ptr<const TestData> null;
  return null;
}

void FitterWorkerGroup::printTests(ostream& os) const{
  boost::recursive_mutex::scoped_lock lock(m_testAccess);
  os << setw(8) << "Run" << setw(8) << "Scan" << setw(8) << "NScans"
     << setw(26) << "Name" << setw(26) << "FitAlg" << endl;
  os << "--------------------------------------------------------------------------------" << endl;
 for (std::list<boost::shared_ptr<const TestData> >::const_iterator i=m_tests.begin();
       i!= m_tests.end(); ++i){
    if ((*i).get()) {
      os << setw(8) << (*i)->runNumber << setw(8) << (*i)->startScanNumber 
     << setw(8) << (*i)->nScans    << setw(26) << (*i)->testName;
      os << setw(26) << (((*i)->fitAlgorithm=="")?"[guess]":(*i)->fitAlgorithm) << endl;
      os << "\toptions=[" << (*i)->options << "]" << std::endl;
    } else{
      os << "\t --> Null pointer to test! <-- \n";
    }
  }
  os << "--------------------------------------------------------------------------------" << endl;
}

void FitterWorkerGroup::addTestData(boost::shared_ptr<const TestData> td){
  using namespace boost;
  recursive_mutex::scoped_lock lock(m_testAccess);
  shared_ptr<const TestData>& previous=findTestData(td->runNumber, td->startScanNumber);
  if (previous.get()) {
    if (debug()) {
      cout << "Replacing TestData for " 
       << td->runNumber << "." << td->startScanNumber << endl
       << " options = " << td->options << std::endl;
    }
    // replace
    previous=td;
    if (debug()) printTests(std::cout);
  } else{
    if (debug()) { 
      cout << "Adding TestData for " 
       << td->runNumber << "." << td->startScanNumber << endl
       << " options = " << td->options << std::endl;
    }
    // add
    m_tests.push_back(td);
  }
}

}// end of namespace SctFitter

---