CalibrationControllerImpl.cpp

#include "CalibrationControllerImpl.h"
#include "ScanLibraryImpl.h"
#include "TestLibraryImpl.h"
#include "SequenceLibraryImpl.h"
#include "SequenceRequestWorker.h"
#include "RunController.h"
#include "SctApiAccessException.h"
#include "ipc/SequenceRequest.h"
#include "scripts/DefaultSequence.h"
#include "scripts/DefaultTest.h"
#include "Sequence.h"
#include "Test.h"
#include "SctApiCall.h"
#include "ConfigUpdater/ConfigUpdaterManager.h"

#include "Sct/SctNames.h"
#include "Sct/LogicErrors.h"
#include "Sct/IoExceptions.h"
#include "Sct/ISUtilities.h"
#include "Sct/CorbaExceptionWrapper.h"
#include "Sct/StdExceptionWrapper.h"
#include "Sct/IS/IOManagerIS.h"
#include "Sct/IS/IONameIS.h"
#include "Sct/OmniMarshalling.h"
#include "SctData/TestResult.h"
#include "Sct/UniqueID.h"
#include <ipc/server.h>
#include <is/infoT.h>
#include <is/infodictionary.h>
#include <is/infoiterator.h>
#include <is/inforeceiver.h>
//#include <ilu/iluxport.h>
#include <boost/utility.hpp>
#include <unistd.h>
#include <iostream>
#include "Sct/BugReport.h"
#include "Sct/CorbaExceptionWrapper.h"
#include "Sct/MultiMessageDebugStream.h"

#ifndef __Sct_SctApi_H_
#include "Sct_SctApi/SctApi.hh"
#endif


using namespace std;
using namespace Sct;
using namespace SctData;

namespace SctCalibrationController {

using namespace Scripts;

CalibrationControllerImpl::CalibrationControllerImpl(RunControl& rc) : rc(rc), runNumber(0), 
    nextScanNumber(0), abortNow(false), abortRightNow(false) {
    status.currentScanIndex = 0;
    publish();
    updateStatus();
}

CalibrationControllerImpl::~CalibrationControllerImpl() {
    withdraw();

    //Remove status from IS:
    string name = SctNames::getControlDataName();
    name += ".Status";
    ISInfoDictionary& is = SctNames::getISDictionary();
    is.remove(name.c_str());
    inst->_destroy();
}

Sct_SctApi::SctApiIPC_ptr CalibrationControllerImpl::getApi() {
  if (CORBA::is_nil(m_api)){
    // get new handle...
    m_api=SctNames::getPartition().lookup<Sct_SctApi::SctApiIPC>(Sct_SctApi::SctApiIPC::instanceName);
    if (CORBA::is_nil(m_api)) {
      SctNames::Mrs() << "CC" << MRS_TEXT("Calibration Controller failed to find SctApi") << MRS_ERROR << ENDM;
    } else {
      SctNames::Mrs() << "CC" << MRS_TEXT("Calibration Controller refreshed SctApi handle") << MRS_DIAGNOSTIC << ENDM;
    }
  }
  Sct_SctApi::SctApiIPC_ptr ret = Sct_SctApi::SctApiIPC::_duplicate(m_api);
  if (CORBA::is_nil(ret)) {
      SctNames::Mrs() << "CC" << MRS_TEXT("Calibration Controller failed to duplicate handle") << MRS_ERROR << ENDM;    
  };
  return ret;
}

void CalibrationControllerImpl::setApi(Sct_SctApi::SctApiIPC_ptr api) {
    this->m_api = Sct_SctApi::SctApiIPC::_duplicate(api);
}

void CalibrationControllerImpl::reset() {
    SctNames::Mrs() << "CC_RESET" << MRS_TEXT("Calibration controller was reset") << MRS_DIAGNOSTIC << ENDM;
    status.status = status.LOADED;
    updateStatus();
    m_api = Sct_SctApi::SctApiIPC::_nil();
}

void CalibrationControllerImpl::sctApiError(SctApiAccessException& e) {
  rc.sctApiError(e.what());
  updateStatus();
}

void CalibrationControllerImpl::takeControl(unsigned int runNumber) {
    if (status.status != status.LOADED || CORBA::is_nil(m_api) )
        return;
    this->runNumber = runNumber;
    nextScanNumber = 0;
    status.status = status.INCONTROL;
    
    SctNames::Mrs() << "CC_START" << MRS_TEXT("Calibration Controller taking control") << MRS_INFORMATION << ENDM;
    updateStatus();
}

void CalibrationControllerImpl::giveupControl() {
    if (status.status == status.INCONTROL) {
    SctNames::Mrs() << "CC_END" << MRS_TEXT("Calibration Controller giving up control") << MRS_INFORMATION << ENDM;

        status.status = status.LOADED;
        updateStatus();
    }
}

bool CalibrationControllerImpl::isInControl() {
    return status.status == status.INCONTROL;
}

bool CalibrationControllerImpl::isBusy() {
    return status.status == status.BUSY;
}

void CalibrationControllerImpl::setBusy(bool busy) {
    if (busy && status.status == status.INCONTROL)
        status.status = status.BUSY;
    else if (!busy && status.status == status.BUSY)
        status.status = status.INCONTROL;
    updateStatus();
}

unsigned int CalibrationControllerImpl::getRunNumber() const {
    return runNumber;
}

unsigned int CalibrationControllerImpl::getNextScanNumber() const {
    return nextScanNumber;
}

void CalibrationControllerImpl::setNextScanNumber(unsigned int scanNumber) {
    nextScanNumber = scanNumber;
    Sct_SctApi::SctApiIPC_var api = getApi();
    APICALL(api, setScanNumber(scanNumber), "setScanNumber failed in setNextScanNumber")
}

void CalibrationControllerImpl::abort() {
    if (status.status != status.BUSY) return;

    abortNow = true;
    //Notify MRS
    SctNames::Mrs() << "CC_ABORT" << MRS_TEXT("User requested abort Sequence") << MRS_INFORMATION << ENDM;

    //See if SctApi is responding, if not, then abortRightNow!
    //Use pid as an example...
    try{
      Sct_SctApi::SctApiIPC_var api = getApi();
      ipc::servant::info_var info = api->information();
    }catch(CORBA::Exception& e){
      abortRightNow = true;
    }
}

void CalibrationControllerImpl::executeSequence(Sct_CalibrationController::SequenceRequest_ptr sr) {
    SctNames::Mrs() << "CC_SEQ_START" << MRS_TEXT("Calibration Controller starting sequence") << MRS_INFORMATION << ENDM;

    string name;
    Sct_SctApi::SctApiIPC_var api = getApi();

    try {
      if (CORBA::is_nil(sr)) {
        throw Sct::IllegalStateError("Null Sequence pointer ", __FILE__, __LINE__);
      };
//First up, synchronise our scanNumber with SctApi's
      APIRETCALL(api, nextScanNumber, getScanNumber(), "Couldn't synchronise scan numbers")
      //The call startSequence
      CORBA::String_var corbaname = sr->startSequence(api);
      name = corbaname;
      std::cout << "CC: name of sequence is : " << name << std::endl;
    } catch (SctApiAccessException& e) {
      sctApiError(e);
      throw;    //Drop through
    } catch (CorbaExceptionWrapper& e) {
      e.sendToMrs();
      return;
    }

    shared_ptr<Sequence> s;
    try {
        sctConf::ModuleList_var mlist;
    std::cout << "CC Getting module List" << std::endl;
        APIRETCALL(api, mlist, getModuleList(), "Couldn't get module list")
    std::cout << "CC Got module List" << std::endl;

        list<string> list = copyCorbaToList<sctConf::ModuleList, string>(&(mlist.in()));
        s = Sequence::create(name, runNumber, nextScanNumber, list);

        status.currentSequence = s->getUniqueID();
        updateStatus();

        Sct_CalibrationController::TestRequest_var tr = Sct_CalibrationController::TestRequest::_nil();
        unsigned long index = 0;

    do {
        tr = sr->getNextTest(index);
        if (!CORBA::is_nil(tr)) {
        unsigned firstScanInTest = getNextScanNumber();
        unsigned runNumber = getRunNumber();
        s->addTest(executeTest(tr, s));

        //Check we didn't fail somewhere
        if (s->getTest(index)->getData().status != TestData::COMPLETED) {
            SctNames::Mrs() << "CC_SEQ_END" << MRS_TEXT("Calibration Controller aborting sequence") << MRS_INFORMATION << ENDM;
            s->setStatus(SequenceData::ABORTED);
            return; //All done!
        }
        {
          Sct_SctApi::BankList banks;
          banks.length(1);
          banks[0]=Sct_SctApi::SCAN_CONFIG;
          APICALL(api, copyABCDModules(Sct_SctApi::CALIBRATION_CONFIG, banks), "copyABCDModules failed before update");
          APICALL(api, getABCDModules(Sct_SctApi::CALIBRATION_CONFIG), "getABCDModules failed before update");
        }
        if (tr->canFeedback()) {
                    // Save any changes that have been made (into the CALIBRATION and SCAN banks)
            Sct_SctApi::BankList banks;
            banks.length(2);
            banks[0]=Sct_SctApi::CALIBRATION_CONFIG;
            banks[1]=Sct_SctApi::SCAN_CONFIG;

            // keep CALIBRATION and SCAN bank up to date if possible.
            APICALL(api, setAutoUpdateBanks(banks), "setAutoUpdateBanks failed");
            
                    std::list<std::string> moduleList = s->getModuleList();
                    applyChanges(runNumber, firstScanInTest, moduleList);
                    APICALL(api, setABCDModules(banks), "setABCDModules failed after update");
        }
        {
          // no longer keep banks up to date
          Sct_SctApi::BankList banks;
          banks.length(0);
          APICALL(api, setAutoUpdateBanks(banks), "setAutoUpdateBanks failed");
        }
        }
        ++index;
    } while (!CORBA::is_nil(tr));
    SctNames::Mrs() << "CC_SEQ_END" << MRS_TEXT("Calibration Controller ending sequence") << MRS_INFORMATION << ENDM;
    sr->endSequence();
    s->setStatus(SequenceData::COMPLETED);
    } catch (SctApiAccessException& e) {
    sctApiError(e);
    throw;  //Drop through
    } catch (Throwable& e) {
    e.sendToMrs(MRS_INFORMATION);
    if (s) s->setStatus(SequenceData::ABORTED);
    } catch (std::exception& e){
        StdExceptionWrapper(e,__FILE__,__LINE__).sendToMrs(MRS_INFORMATION);
        if (s) s->setStatus(SequenceData::ABORTED);
    } catch (...){
        SctNames::Mrs() << "CC_SEQ_ERROR" << MRS_TEXT("Calibration Controller caught unknown exception during sequence") 
                << MRS_ERROR << ENDM;
        if (s) s->setStatus(SequenceData::ABORTED);
    }
}
void CalibrationControllerImpl::applyChanges(const unsigned long runNumber, const unsigned long scanNumber, const std::list<std::string>& modulelist ) {
    Sct_SctApi::SctApiIPC_var api = getApi();

    cout << "Update option = " << status.updateOption << endl;

    bool printed=false;
    while (status.updateOption=="WAIT") {
        if (!printed)
            cerr << "CalibrationController awaiting instructions as to whether to apply changes" << endl;
        printed=true;
    }

    //status.updateOption can be changed by other IPC method
    if (status.updateOption!="UPDATE")
        return;

    cout << "updating " << modulelist.size() << "" << " modules" << endl;

    std::ostringstream regexp;
    regexp << ".*TestResult\\." << runNumber << "\\." << scanNumber << "\\..*";
    cout << "Cal Controller looking for " << regexp.str() << endl;

    unsigned nprinted=0;

    // make another list which we can remove things from:
    std::list<std::string> mylist=modulelist;

    while (!mylist.empty() && status.updateOption=="UPDATE") {
        ISInfoIterator ii(SctNames::getPartition(),
                          SctNames::getTestDataName().c_str(),
                          regexp.str().c_str() );

        while (ii() && status.updateOption=="UPDATE") {
            if (nprinted<10)
                cout << "    checking " << ii.name() << endl;


            // make an IONameIS which allows us to interpret the IS name
            Sct::IS::IONameIS isname(ii.name());
            std::string moduleName=isname.getUniqueID().getModule();

            // look for the module name in our list
            std::list<string>::iterator it = std::find( mylist.begin(), mylist.end(), moduleName);
            // if its there, then update that module, and remove it from our list.
            if ( it != mylist.end() ) {
                shared_ptr<const Serializable> ob ( Sct::IS::IOManagerIS::instance().read(ii.name()) );
                shared_ptr<const SctData::TestResult> testResult = boost::dynamic_pointer_cast<const SctData::TestResult>(ob);
                if (!testResult)
                    throw Sct::InvalidArgumentError("Fitter::applyChangesCallback not a SctData::TestResult.", __FILE__, __LINE__);

                cout << "about to update " << moduleName << endl;
        ConfigUpdaterManager::instance().update(*testResult, api);

                it=mylist.erase(it);
            }
        } // end of loop over currently available TestResult

        usleep(500000);

        if (nprinted<10) {
            cout << "Cal Controller waiting for TestResults (have "
            << mylist.size() << " still to go)" << endl;
        }
        nprinted ++;
    }
}

void CalibrationControllerImpl::updateWith(const char * testResultInIs, bool force){
  setBusy(true);
  try{
    Sct_SctApi::SctApiIPC_var api = getApi();
    shared_ptr<const TestResult> tr = dynamic_pointer_cast<const TestResult> ( Sct::IS::IOManagerIS::instance().read(testResultInIs) );
    if (!tr.get()) throw Sct::IoException(string("Couldnt retrieve ")+testResultInIs , __FILE__, __LINE__);
    ConfigUpdaterManager::instance().update(*tr, api, force);
  }catch(Sct::Throwable& e){
    e.sendToMrs();
  }catch(std::exception& e){
    Sct::StdExceptionWrapper(e, __FILE__, __LINE__).sendToMrs();
  }
  setBusy(false);
}

void CalibrationControllerImpl::setUpdateOption(Sct_CalibrationController::CalibrationController::UpdateOption opt) {
    cout << "CalibrationContrllerImpl: resetting update option to " << opt;
    switch (opt) {
    case Sct_CalibrationController::CalibrationController::update : {
        status.updateOption="UPDATE";
        SctNames::Mrs() << "CC_UPDATE_CHANGE"
            << MRS_TEXT("CalibrationControllerImpl setting updateOption=UPDATE") << MRS_DIAGNOSTIC << ENDM;
        break;
    }
    case Sct_CalibrationController::CalibrationController::noupdate : {
    status.updateOption="NOUPDATE";
    SctNames::Mrs() << "CC_UPDATE_CHANGE"
            << MRS_TEXT("CalibrationControllerImpl setting updateOption=NOUPDATE")  << MRS_DIAGNOSTIC << ENDM;
    break;
    }
    case Sct_CalibrationController::CalibrationController::wait : {
    status.updateOption="WAIT";
    SctNames::Mrs() << "CC_UPDATE_CHANGE"
            << MRS_TEXT("CalibrationControllerImpl setting updateOption=WAIT")  << MRS_DIAGNOSTIC << ENDM;
    break;
    }
    default : {
    IllegalStateError e("CalibrationControllerImpl updateOption UNKNOWN", __FILE__, __LINE__);
    e.sendToMrs(MRS_DIAGNOSTIC);
    break;
    }
    }
    updateStatus();
}

void listScanOptions(Sct_SctApi::Scan_ptr scan, ostream& os){
  os << "SCAN:";
  using namespace Sct_SctApi;
  for (unsigned ioption=0; ioption<(int)Scan::endoptions; ++ioption){  
    int value = scan->getOption(Scan::ScanOptions(ioption));
    if(value){
      string name;
      switch (ioption){
      case Scan::full: name="full"; break;
      case Scan::bits32: name="bits32"; break;
      case Scan::loopCalLine: name="loopCalLine"; break;
      case Scan::distSlave: name="distSlave"; break;
      case Scan::debug: name="debug"; break;
      case Scan::tim: name="tim"; break;
      case Scan::nth: name="nth"; break;
      case Scan::nth_rem: name="nth_rem"; break;
      case Scan::enableDataMode: name="enableDataMode"; break;
      case Scan::ccode: name="ccode"; break;
      case Scan::ope: name="ope"; break;
      default: name= "unknown option!"; break;
      }
      os << "," << name << "=" << value;
    }
  }
  os << ";";
}

auto_ptr<Test> CalibrationControllerImpl::executeTest(Sct_CalibrationController::TestRequest_ptr tr, shared_ptr<const Sequence> s) {
    TestData data;
    ostringstream testdataoptions;
    
    if (CORBA::is_nil(tr)) {
      throw IllegalStateError("Test request pointer was nill", __FILE__, __LINE__);
    };

    SctNames::Mrs() << "CC_TEST_START" << MRS_TEXT("Calibration Controller starting test") << MRS_INFORMATION << ENDM;
    Sct_SctApi::SctApiIPC_var api = getApi();

    //AJB APICALL(api, setABCDModules(banks contains Sct_SctApi::CALIBRATION_CONFIG), "setABCDModules failed")

    data.runNumber = runNumber;
    data.startScanNumber = nextScanNumber;

    data.fitAlgorithm = tr->getFitAlgorithm();
    data.analysisAlgorithm = tr->getAnalysisAlgorithm();

    {
      Sct_CalibrationController::TestPoints_var testPointsOut;
      {
        //TestRequestAdapter tra(tr);
        CORBA::String_var testNameOut;
        CORBA::UShort testVariableOut;
    
    //Keep SCAN bank up to date
    {
      Sct_SctApi::BankList banks;
      banks.length(1);
      banks[0]=Sct_SctApi::SCAN_CONFIG;
      APICALL(api, setAutoUpdateBanks(banks), "setAutoUpdateBanks failed");
    }

        CORBA::ULong nScansOut;
        tr->startTest(api, testNameOut, testVariableOut, nScansOut, testPointsOut);
        if (CORBA::is_nil(tr)) {
          throw IllegalStateError("Test request pointer was accidentally made nill at ", __FILE__, __LINE__);
        };
        data.testName = testNameOut;
        data.testVariable = testVariableOut;
        data.nScans = nScansOut;
      };
      
      data.testPoints = new double[testPointsOut->length()];
      data.testPoints_size = testPointsOut->length();
      for (unsigned int i=0; i<testPointsOut->length(); ++i) {
        data.testPoints[i] = testPointsOut[i];
      }
    };

    auto_ptr<Test> test (new Test(data, s->getModuleList()));

    status.currentTest = test->getUniqueID();
    updateStatus();

    bool full_mode_scans=false;

    try {
        unsigned int i=0;
    bool errorFlag=false;
    for (; i<data.nScans; ++i) {
        Sct_CalibrationController::ScanRequest_var scan = tr->getNextScan(i);
        if (CORBA::is_nil(scan)) {
              throw IllegalStateError("getNextScan returned zero!", __FILE__, __LINE__);
            };
        if (CORBA::is_nil(scan->getScanCorba())) {
              throw IllegalStateError("ScanRequest.getScan returned zero!", __FILE__, __LINE__);
            };
        
        test->addScan(scan->getScanCorba());
        if (abortNow) {
        abortNow = false;
        abortRightNow = false;
        break;
        }
        try{
          full_mode_scans |= (scan->getScanCorba()->getOption(::Sct_SctApi::Scan::full));
          listScanOptions(scan->getScanCorba(), testdataoptions);
          test->setOptions(testdataoptions.str());
          std::cout << "scan options : " << data.options << std::endl;
          executeScan(scan, i);
        }catch(CORBA::Exception& e){
          throw CorbaExceptionWrapper(e,"Exception in executeScan", __FILE__, __LINE__);
        }
    }
    if (i == data.nScans && !errorFlag) {
        SctNames::Mrs() << "CC_TEST_END" << MRS_TEXT("Calibration Controller ending test") << MRS_INFORMATION << ENDM;
        test->setStatus(TestData::COMPLETED);
    } else {
        SctNames::Mrs() << "CC_TEST_ABORT" << MRS_TEXT("Calibration Controller aborting test") << MRS_INFORMATION << ENDM;
        test->setStatus(TestData::ABORTED);
        const TestData& testData = test->getData();
        setNextScanNumber(testData.startScanNumber + testData.nScans * (full_mode_scans?3:1));
    }
    } catch (SctApiAccessException& e) {
      sctApiError(e);
      throw;    //Drop through
    } catch (CorbaExceptionWrapper& e) {
    SctNames::Mrs() << "CC_TEST_ABORT" << MRS_TEXT("Calibration Controller aborting test") << MRS_INFORMATION << ENDM;
    test->setStatus(TestData::ABORTED);
    e.sendToMrs(MRS_INFORMATION);

    //Try an increment the scan number to the end of the test
    const TestData& testData = test->getData();
    setNextScanNumber(testData.startScanNumber + testData.nScans * (full_mode_scans?3:1) );
    }

    //End the test
    try {
        tr->endTest();
    } catch (CorbaExceptionWrapper& e) {
    e.sendToMrs(MRS_DIAGNOSTIC);
    }

    try{
      // Stop keeping the scan bank up to date.
      Sct_SctApi::BankList banks;
      banks.length(0);
      APICALL(api, setAutoUpdateBanks(banks), "setAutoUpdateBanks failed");
    } catch (SctApiAccessException& e) {
      sctApiError(e);
      e.sendToMrs(MRS_ERROR);
    }

    //Reset the module configurations to the original
    try {
      APICALL(api, sendABCDModules(Sct_SctApi::PHYSICS_CONFIG), "sendABCDModules failed")
    } catch (SctApiAccessException& e) {
      sctApiError(e);
      e.sendToMrs(MRS_ERROR);
    }
    return test;
}
  
void CalibrationControllerImpl::executeScan(Sct_CalibrationController::ScanRequest_ptr scan, unsigned int index) {
    Sct_SctApi::SctApiIPC_var api = getApi();
    ++nextScanNumber;
    SctNames::Mrs() << "CC_SCAN_START" << MRS_TEXT("Calibration Controller starting scan") << MRS_INFORMATION << ENDM;

    status.currentScanIndex = index;
    updateStatus();

    if ( scan->isRawCorba() ){
      APICALL(api, doRawScan(scan->getScanCorba(), scan->delayCorba(), scan->widthCorba(), scan->configureModulesCorba(), scan->clockByTwoCorba()  ), "doRawScan failed");
    }else{
      APICALL(api, doScan(scan->getScanCorba() ), "doScan failed");
    }

    // Perhaps the next few lines could be replaced by an APICALL to awaitScan ??   CGL: 2004/01/24
    // No, awaitScan has no timeout, or other get out (except at CORBA level)
    // CalibrationController may want to give more feedback here about what is going on. BJG: 2004/01/25
    // Also would be place to put APICALL to abortScan, once implemented properly? 


    {
      // nInitialSleeps no longer needed
      bool hasFinScanning;
      APIRETCALL(api, hasFinScanning, hasFinishedScanning(), "Couldn't determine whether or not scanning had finished!");
      while (!hasFinScanning) {
    usleep(500000); // check 2 times per second, or thereabouts.
    if (abortRightNow) {
      abortRightNow = false;
      abortNow = false;
      IoException erm("Abort called and SctApi not responding, doScan failed", __FILE__, __LINE__);
      throw erm;
    }
    APIRETCALL(api, hasFinScanning, hasFinishedScanning(), "Couldn't determine whether or not scanning had finished later on!");
      };
    };

    SctNames::Mrs() << "CC_SCAN_END" << MRS_TEXT("Calibration Controller ending scan") << MRS_INFORMATION << ENDM;
}

CalibrationControllerImpl & CalibrationControllerImpl::initialize(RunControl& rc) {
    inst = new CalibrationControllerImpl(rc);
    return *inst;
}

Sct_CalibrationController::CalibrationController_ptr CalibrationControllerImpl::instance() {
    if (!inst)
    throw InvariantViolatedError("Need to call CalibrationControllerImpl::initialize first!", __FILE__, __LINE__);
    return inst->_this();
}

Sct_CalibrationController::ScanLibrary_ptr CalibrationControllerImpl::getScanLibrary() {
    return ScanLibraryImpl::instance();
}

Sct_CalibrationController::TestLibrary_ptr CalibrationControllerImpl::getTestLibrary() {
    return TestLibraryImpl::instance();
}

Sct_CalibrationController::SequenceLibrary_ptr CalibrationControllerImpl::getSequenceLibrary() {
    cout << "Get Sequence Library" << endl;
    return SequenceLibraryImpl::instance();
}

void CalibrationControllerImpl::doScan(Sct_CalibrationController::ScanRequest_ptr scan) {
    doTest(DefaultTest::instance(scan));
}

void CalibrationControllerImpl::doTest (Sct_CalibrationController::TestRequest_ptr t) {
    doSequence(DefaultSequence::instance(t));
}

void CalibrationControllerImpl::doSequence (Sct_CalibrationController::SequenceRequest_ptr r) {
    if (!isInControl() || isBusy()) {
        SctNames::Mrs() << "SEQUENCE_NOT_DONE" << MRS_TEXT("Cant do sequence") 
            << MRS_PARAM<int>("CC-status",status.status)
            << MRS_WARNING << ENDM;
        return;
    }

    status.status = status.BUSY;  // set back to INCONTROL by the SequenceRequestWorker
    updateStatus();

    m_sequence_request_thread_group.create_thread(SequenceRequestWorker(*this, r));
#warning the second argument to this func should probably inherit from the self-destructing portable adapter mixin class ...
}

Sct_SctApi::Scan_ptr CalibrationControllerImpl::getScan(unsigned long runNumber, unsigned long scanNumber) {
  cerr << "CalibrationControllerImpl::getScan - Not implemented" << endl;
  return Sct_SctApi::Scan::_nil();
}

void CalibrationControllerImpl::updateStatus() {
  string name = SctNames::getControlDataName();
  name += ".Status";
  ISUtilities::addOrUpdateOrMessage(name, status, __FILE__, __LINE__, MRS_DIAGNOSTIC);
}
  
CalibrationControllerImpl * CalibrationControllerImpl::inst = 0;

}

---