Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Data Structures | File List | Namespace Members | Data Fields | Related Pages

CalibrationControllerImpl.cpp

00001 #include "CalibrationControllerImpl.h"
00002 #include "ScanLibraryImpl.h"
00003 #include "TestLibraryImpl.h"
00004 #include "SequenceLibraryImpl.h"
00005 #include "SequenceRequestWorker.h"
00006 #include "RunController.h"
00007 #include "SctApiAccessException.h"
00008 #include "ipc/SequenceRequest.h"
00009 #include "scripts/DefaultSequence.h"
00010 #include "scripts/DefaultTest.h"
00011 #include "Sequence.h"
00012 #include "Test.h"
00013 #include "SctApiCall.h"
00014 #include "ConfigUpdater/ConfigUpdaterManager.h"
00015 
00016 #include "Sct/SctNames.h"
00017 #include "Sct/LogicErrors.h"
00018 #include "Sct/IoExceptions.h"
00019 #include "Sct/ISUtilities.h"
00020 #include "Sct/CorbaExceptionWrapper.h"
00021 #include "Sct/StdExceptionWrapper.h"
00022 #include "Sct/IS/IOManagerIS.h"
00023 #include "Sct/IS/IONameIS.h"
00024 #include "Sct/OmniMarshalling.h"
00025 #include "SctData/TestResult.h"
00026 #include "Sct/UniqueID.h"
00027 #include <ipc/server.h>
00028 #include <is/isinfotmpl.h>
00029 //#include <ilu/iluxport.h>
00030 #include <boost/utility.hpp>
00031 #include <unistd.h>
00032 #include <iostream>
00033 #include "Sct/BugReport.h"
00034 #include "Sct/CorbaExceptionWrapper.h"
00035 
00036 #ifndef __Sct_SctApi_H_
00037 #include "Sct_SctApi/SctApi.hh"
00038 #endif
00039 
00040 
00041 using namespace std;
00042 using namespace Sct;
00043 using namespace SctData;
00044 
00045 namespace SctCalibrationController {
00046 
00047 using namespace Scripts;
00048 
00049 CalibrationControllerImpl::CalibrationControllerImpl(RunControl& rc) : rc(rc), runNumber(0), 
00050     nextScanNumber(0), abortNow(false), abortRightNow(false) {
00051     status.currentScanIndex = 0;
00052     publish();
00053     updateStatus();
00054 }
00055 
00056 CalibrationControllerImpl::~CalibrationControllerImpl() {
00057     withdraw();
00058 
00059     //Remove status from IS:
00060     string name = SctNames::getControlDataName();
00061     name += ".Status";
00062     ISInfoDictionary& is = SctNames::getISDictionary();
00063     is.remove(name.c_str());
00064     inst->_destroy();
00065 }
00066 
00067 Sct_SctApi::SctApiIPC_ptr CalibrationControllerImpl::getApi() {
00068   if (CORBA::is_nil(m_api)){
00069     // get new handle...
00070     m_api=SctNames::getPartition().lookup<Sct_SctApi::SctApiIPC>(Sct_SctApi::SctApiIPC::instanceName);
00071     if (CORBA::is_nil(m_api)) {
00072       SctNames::Mrs() << "CC" << MRS_TEXT("Calibration Controller failed to find SctApi") << MRS_ERROR << ENDM;
00073     } else {
00074       SctNames::Mrs() << "CC" << MRS_TEXT("Calibration Controller refreshed SctApi handle") << MRS_DIAGNOSTIC << ENDM;
00075     }
00076   }
00077   Sct_SctApi::SctApiIPC_ptr ret = Sct_SctApi::SctApiIPC::_duplicate(m_api);
00078   if (CORBA::is_nil(ret)) {
00079       SctNames::Mrs() << "CC" << MRS_TEXT("Calibration Controller failed to duplicate handle") << MRS_ERROR << ENDM;    
00080   };
00081   return ret;
00082 }
00083 
00084 void CalibrationControllerImpl::setApi(Sct_SctApi::SctApiIPC_ptr api) {
00085     this->m_api = Sct_SctApi::SctApiIPC::_duplicate(api);
00086 }
00087 
00088 void CalibrationControllerImpl::reset() {
00089     SctNames::Mrs() << "CC_RESET" << MRS_TEXT("Calibration controller was reset") << MRS_DIAGNOSTIC << ENDM;
00090     status.status = status.LOADED;
00091     updateStatus();
00092     m_api = Sct_SctApi::SctApiIPC::_nil();
00093 }
00094 
00095 void CalibrationControllerImpl::sctApiError(SctApiAccessException& e) {
00096   rc.sctApiError(/*rc.SCTAPI_ACCESS_FAILURE, */e.what());
00097   //status.status = status.ERROR;
00098   updateStatus();
00099 }
00100 
00101 void CalibrationControllerImpl::takeControl(unsigned int runNumber) {
00102     if (status.status != status.LOADED || CORBA::is_nil(m_api) )
00103         return;
00104     this->runNumber = runNumber;
00105     nextScanNumber = 0;
00106     status.status = status.INCONTROL;
00107     
00108     SctNames::Mrs() << "CC_START" << MRS_TEXT("Calibration Controller taking control") << MRS_INFORMATION << ENDM;
00109     updateStatus();
00110 }
00111 
00112 void CalibrationControllerImpl::giveupControl() {
00113     if (status.status == status.INCONTROL) {
00114     SctNames::Mrs() << "CC_END" << MRS_TEXT("Calibration Controller giving up control") << MRS_INFORMATION << ENDM;
00115 
00116         status.status = status.LOADED;
00117         updateStatus();
00118     }
00119 }
00120 
00121 bool CalibrationControllerImpl::isInControl() {
00122     return status.status == status.INCONTROL;
00123 }
00124 
00125 bool CalibrationControllerImpl::isBusy() {
00126     return status.status == status.BUSY;
00127 }
00128 
00129 void CalibrationControllerImpl::setBusy(bool busy) {
00130     if (busy && status.status == status.INCONTROL)
00131         status.status = status.BUSY;
00132     else if (!busy && status.status == status.BUSY)
00133         status.status = status.INCONTROL;
00134     updateStatus();
00135 }
00136 
00137 unsigned int CalibrationControllerImpl::getRunNumber() const {
00138     return runNumber;
00139 }
00140 
00141 unsigned int CalibrationControllerImpl::getNextScanNumber() const {
00142     return nextScanNumber;
00143 }
00144 
00145 void CalibrationControllerImpl::setNextScanNumber(unsigned int scanNumber) {
00146     nextScanNumber = scanNumber;
00147     Sct_SctApi::SctApiIPC_var api = getApi();
00148     APICALL(api, setScanNumber(scanNumber), "setScanNumber failed in setNextScanNumber")
00149 }
00150 
00151 void CalibrationControllerImpl::abort() {
00153     if (status.status != status.BUSY) return;
00154 
00155     abortNow = true;
00156     //Notify MRS
00157     SctNames::Mrs() << "CC_ABORT" << MRS_TEXT("User requested abort Sequence") << MRS_INFORMATION << ENDM;
00158 
00159     //See if SctApi is responding, if not, then abortRightNow!
00160     //Use pid as an example...
00161     try{
00162       Sct_SctApi::SctApiIPC_var api = getApi();
00163       ipc::servant::info_var info = api->information();
00164     }catch(CORBA::Exception& e){
00165       abortRightNow = true;
00166     }
00167 }
00168 
00169 void CalibrationControllerImpl::executeSequence(Sct_CalibrationController::SequenceRequest_ptr sr) {
00170     SctNames::Mrs() << "CC_SEQ_START" << MRS_TEXT("Calibration Controller starting sequence") << MRS_INFORMATION << ENDM;
00171 
00172     string name;
00173     Sct_SctApi::SctApiIPC_var api = getApi();
00174 
00175     Sct::BugReport("BUG01", "CCImpl.cpp", "Just before startSequence try block");
00176     try {
00177       Sct::BugReport("BUG01", "CCImpl.cpp", "Just before xx1 startSequence try block");
00178       if (CORBA::is_nil(sr)) {
00179         Sct::BugReport("BUG01", "CCImpl.cpp", "Oh dear, sr was nil!");
00180         throw Sct::IllegalStateError("Null Sequence pointer ", __FILE__, __LINE__);
00181       };
00182       Sct::BugReport("BUG01", "CCImpl.cpp", "Just before xx2 startSequence try block");
00183 //First up, synchronise our scanNumber with SctApi's
00184       APIRETCALL(api, nextScanNumber, getScanNumber(), "Couldn't synchronise scan numbers")
00185       //The call startSequence
00186       Sct::BugReport("BUG01", "CCImpl.cpp", "Just before xx3 startSequence try block");
00187       CORBA::String_var corbaname = sr->startSequence(api);
00188       Sct::BugReport("BUG01", "CCImpl.cpp", "Just before xx4 startSequence try block");
00189       name = corbaname;
00190       Sct::BugReport("BUG01", "CCImpl.cpp", "Just before xx5 the startSequence we are trying to understand.");
00191       std::cout << "CC: name of sequence is : " << name << std::endl;
00192     } catch (SctApiAccessException& e) {
00193       Sct::BugReport("BUG01", "CCImpl.cpp", "In first catch");
00194       sctApiError(e);
00195       throw;    //Drop through
00196     } catch (CorbaExceptionWrapper& e) {
00197       Sct::BugReport("BUG01", "CCImpl.cpp", "In second catch");
00198       e.sendToMrs();
00199       return;
00200     }
00201     Sct::BugReport("BUG01", "CCImpl.cpp", "posn 2");
00202 
00203     shared_ptr<Sequence> s;
00204     Sct::BugReport("BUG01", "CCImpl.cpp", "posn 3");
00205     try {
00206         Sct::BugReport("BUG01", "CCImpl.cpp", "posn 4");
00207         sctConf::ModuleList_var mlist;
00208     std::cout << "CC Getting module List" << std::endl;
00209         Sct::BugReport("BUG01", "CCImpl.cpp", "posn 5");
00210         APIRETCALL(api, mlist, getModuleList(), "Couldn't get module list")
00211         Sct::BugReport("BUG01", "CCImpl.cpp", "posn 6");
00212     std::cout << "CC Got module List" << std::endl;
00213         Sct::BugReport("BUG01", "CCImpl.cpp", "posn 7");
00214 
00215         list<string> list = copyCorbaToList<sctConf::ModuleList, string>(&(mlist.in()));
00216         s = Sequence::create(name, runNumber, nextScanNumber, list);
00217 
00218         status.currentSequence = s->getUniqueID();
00219         Sct::BugReport("BUG01", "CCImpl.cpp", "posn 8");
00220         updateStatus();
00221         Sct::BugReport("BUG01", "CCImpl.cpp", "posn 9");
00222 
00223         Sct_CalibrationController::TestRequest_var tr = Sct_CalibrationController::TestRequest::_nil();
00224         Sct::BugReport("BUG01", "CCImpl.cpp", "posn 10");
00225         unsigned long index = 0;
00226 
00227         Sct::BugReport("BUG01", "CCImpl.cpp", "posn 11");
00228     do {
00229         Sct::BugReport("BUG01", "CCImpl.cpp", "posn 12");
00230         tr = sr->getNextTest(index);
00231         Sct::BugReport("BUG01", "CCImpl.cpp", "posn 12.5");
00232         if (!CORBA::is_nil(tr)) {
00233         Sct::BugReport("BUG01", "CCImpl.cpp", "posn 13");
00234         unsigned firstScanInTest = getNextScanNumber();
00235         unsigned runNumber = getRunNumber();
00236         s->addTest(executeTest(tr, s));
00237         Sct::BugReport("BUG01", "CCImpl.cpp", "posn 14");
00238 
00239         //Check we didn't fail somewhere
00240         if (s->getTest(index)->getData().status != TestData::COMPLETED) {
00241             SctNames::Mrs() << "CC_SEQ_END" << MRS_TEXT("Calibration Controller aborting sequence") << MRS_INFORMATION << ENDM;
00242             s->setStatus(SequenceData::ABORTED);
00243             return; //All done!
00244         }
00245         Sct::BugReport("BUG01", "CCImpl.cpp", "posn 15");
00246 
00247         if (tr->canFeedback()) {
00248             std::list<std::string> moduleList = s->getModuleList();
00249             applyChanges(runNumber, firstScanInTest, moduleList);
00250         }
00251         Sct::BugReport("BUG01", "CCImpl.cpp", "posn 16");
00252         } else {
00253               Sct::BugReport("BUG01", "CCImpl.cpp","posn 16.5 -- tr was null!");
00254             };
00255         ++index;
00256         Sct::BugReport("BUG01", "CCImpl.cpp", "posn 17");
00257     } while (!CORBA::is_nil(tr));
00258     
00259         Sct::BugReport("BUG01", "CCImpl.cpp", "posn 18");
00260         // Save any changes that have been made (into the ROD)
00261         APICALL(api, setABCDModules(Sct_SctApi::CALIBRATION_CONFIG), "setABCDModules failed after update")
00262         Sct::BugReport("BUG01", "CCImpl.cpp", "posn 19");
00263 
00264     SctNames::Mrs() << "CC_SEQ_END" << MRS_TEXT("Calibration Controller ending sequence") << MRS_INFORMATION << ENDM;
00265     sr->endSequence();
00266         Sct::BugReport("BUG01", "CCImpl.cpp", "posn 20");
00267     s->setStatus(SequenceData::COMPLETED);
00268         Sct::BugReport("BUG01", "CCImpl.cpp", "posn 21");
00269 
00270     } catch (SctApiAccessException& e) {
00271         Sct::BugReport("BUG01", "CCImpl.cpp", "posn 22");
00272     sctApiError(e);
00273         Sct::BugReport("BUG01", "CCImpl.cpp", "posn 23");
00274     throw;  //Drop through
00275     } catch (Throwable& e) {
00276         Sct::BugReport("BUG01", "CCImpl.cpp", "posn 24");
00277     e.sendToMrs(MRS_INFORMATION);
00278     if (s) s->setStatus(SequenceData::ABORTED);
00279     }
00280         Sct::BugReport("BUG01", "CCImpl.cpp", "posn 25");
00281 }
00282 
00283 void CalibrationControllerImpl::applyChanges(const unsigned long runNumber, const unsigned long scanNumber, const std::list<std::string>& modulelist ) {
00284     Sct_SctApi::SctApiIPC_var api = getApi();
00285 
00286     cout << "Update option = " << status.updateOption << endl;
00287 
00288     bool printed=false;
00289     while (status.updateOption=="WAIT") {
00290         if (!printed)
00291             cerr << "CalibrationController awaiting instructions as to whether to apply changes" << endl;
00292         printed=true;
00293     }
00294 
00295     //status.updateOption can be changed by other IPC method
00296     if (status.updateOption!="UPDATE")
00297         return;
00298 
00299     cout << "updating " << modulelist.size() << "" << " modules" << endl;
00300 
00301     std::ostringstream regexp;
00302     regexp << ".*TestResult\\." << runNumber << "\\." << scanNumber << "\\..*";
00303     cout << "Cal Controller looking for " << regexp.str() << endl;
00304 
00305     unsigned nprinted=0;
00306 
00307     // make another list which we can remove things from:
00308     std::list<std::string> mylist=modulelist;
00309 
00310     while (!mylist.empty() && status.updateOption=="UPDATE") {
00311         ISInfoIterator ii(SctNames::getPartition(),
00312                           SctNames::getTestDataName().c_str(),
00313                           regexp.str().c_str() );
00314 
00315         while (ii() && status.updateOption=="UPDATE") {
00316             if (nprinted<10)
00317                 cout << "    checking " << ii.name() << endl;
00318 
00319 
00320             // make an IONameIS which allows us to interpret the IS name
00321             Sct::IS::IONameIS isname(ii.name());
00322             std::string moduleName=isname.getUniqueID().getModule();
00323 
00324             // look for the module name in our list
00325             std::list<string>::iterator it = std::find( mylist.begin(), mylist.end(), moduleName);
00326             // if its there, then update that module, and remove it from our list.
00327             if ( it != mylist.end() ) {
00328                 shared_ptr<const Serializable> ob ( Sct::IS::IOManagerIS::instance().read(ii.name()) );
00329                 shared_ptr<const SctData::TestResult> testResult = boost::dynamic_pointer_cast<const SctData::TestResult>(ob);
00330                 if (!testResult)
00331                     throw Sct::InvalidArgumentError("Fitter::applyChangesCallback not a SctData::TestResult.", __FILE__, __LINE__);
00332 
00333                 cout << "about to update " << moduleName << endl;
00334         ConfigUpdaterManager::instance().update(*testResult, api);
00335                 it=mylist.erase(it);
00336             }
00337         } // end of loop over currently available TestResult
00338 
00339         sleep (1);
00340 
00341         if (nprinted<10) {
00342             cout << "Cal Controller waiting for TestResults (have "
00343             << mylist.size() << " still to go)" << endl;
00344         }
00345         nprinted ++;
00346     }
00347 }
00348 
00349 void CalibrationControllerImpl::updateWith(const char * testResultInIs, bool force){
00350   setBusy(true);
00351   try{
00352     Sct_SctApi::SctApiIPC_var api = getApi();
00353     shared_ptr<const TestResult> tr = dynamic_pointer_cast<const TestResult> ( Sct::IS::IOManagerIS::instance().read(testResultInIs) );
00354     if (!tr.get()) throw Sct::IoException(string("Couldnt retrieve ")+testResultInIs , __FILE__, __LINE__);
00355     ConfigUpdaterManager::instance().update(*tr, api, force);
00356   }catch(Sct::Throwable& e){
00357     e.sendToMrs();
00358   }catch(std::exception& e){
00359     Sct::StdExceptionWrapper(e, __FILE__, __LINE__).sendToMrs();
00360   }
00361   setBusy(false);
00362 }
00363 
00364 void CalibrationControllerImpl::setUpdateOption(Sct_CalibrationController::CalibrationController::UpdateOption opt) {
00365     cout << "CalibrationContrllerImpl: resetting update option to " << opt;
00366     switch (opt) {
00367     case Sct_CalibrationController::CalibrationController::update : {
00368         status.updateOption="UPDATE";
00369         SctNames::Mrs() << "CC_UPDATE_CHANGE"
00370             << MRS_TEXT("CalibrationControllerImpl setting updateOption=UPDATE") << MRS_DIAGNOSTIC << ENDM;
00371         break;
00372     }
00373     case Sct_CalibrationController::CalibrationController::noupdate : {
00374     status.updateOption="NOUPDATE";
00375     SctNames::Mrs() << "CC_UPDATE_CHANGE"
00376             << MRS_TEXT("CalibrationControllerImpl setting updateOption=NOUPDATE")  << MRS_DIAGNOSTIC << ENDM;
00377     break;
00378     }
00379     case Sct_CalibrationController::CalibrationController::wait : {
00380     status.updateOption="WAIT";
00381     SctNames::Mrs() << "CC_UPDATE_CHANGE"
00382             << MRS_TEXT("CalibrationControllerImpl setting updateOption=WAIT")  << MRS_DIAGNOSTIC << ENDM;
00383     break;
00384     }
00385     default : {
00386     IllegalStateError e("CalibrationControllerImpl updateOption UNKNOWN", __FILE__, __LINE__);
00387     e.sendToMrs(MRS_DIAGNOSTIC);
00388     break;
00389     }
00390     }
00391     updateStatus();
00392 }
00393 
00394 auto_ptr<Test> CalibrationControllerImpl::executeTest(Sct_CalibrationController::TestRequest_ptr tr, shared_ptr<const Sequence> s) {
00395     BugReport("BUG01", "CCImpl.cpp","Starting executeTest");
00396  
00397     BugReport("BUG01", "CCImpl.cpp","In executeTest 1");
00398     TestData data;
00399      BugReport("BUG01", "CCImpl.cpp","In executeTest 2");
00400     BugReport("BUG01", "CCImpl.cpp","In executeTest 3");
00401 
00402     if (CORBA::is_nil(tr)) {
00403       BugReport("BUG01", "CCImpl.cpp","Ending executeTest early 0");
00404       throw IllegalStateError("Test request pointer was nill", __FILE__, __LINE__);
00405     };
00406 
00407     SctNames::Mrs() << "CC_TEST_START" << MRS_TEXT("Calibration Controller starting test") << MRS_INFORMATION << ENDM;
00408     BugReport("BUG01", "CCImpl.cpp","In executeTest 4");
00409     Sct_SctApi::SctApiIPC_var api = getApi();
00410     BugReport("BUG01", "CCImpl.cpp","In executeTest 5");
00411     APICALL(api, setABCDModules(Sct_SctApi::CALIBRATION_CONFIG), "setABCDModules failed")
00412     BugReport("BUG01", "CCImpl.cpp","In executeTest 6");
00413 
00414     data.runNumber = runNumber;
00415     BugReport("BUG01", "CCImpl.cpp","In executeTest 7");
00416     data.startScanNumber = nextScanNumber;
00417     BugReport("BUG01", "CCImpl.cpp","In executeTest 8");
00418 
00419     {
00420       Sct_CalibrationController::TestPoints_var testPointsOut;
00421       {
00422         BugReport("BUG01", "CCImpl.cpp","In executeTest 9");
00423         //TestRequestAdapter tra(tr);
00424         BugReport("BUG01", "CCImpl.cpp","In executeTest 10");
00425         CORBA::String_var testNameOut;
00426         BugReport("BUG01", "CCImpl.cpp","In executeTest 10.1");
00427         CORBA::UShort testVariableOut;
00428         BugReport("BUG01", "CCImpl.cpp","In executeTest 10.2");
00429         CORBA::ULong nScansOut;
00430         BugReport("BUG01", "CCImpl.cpp","In executeTest 10.3");
00431         tr->startTest(api, testNameOut, testVariableOut, nScansOut, testPointsOut);
00432         if (CORBA::is_nil(tr)) {
00433           BugReport("BUG01", "CCImpl.cpp","Ending executeTest early 000 .. tr was accidentally made null!");
00434           throw IllegalStateError("Test request pointer was accidentally made nill at ", __FILE__, __LINE__);
00435         };
00436         BugReport("BUG01", "CCImpl.cpp","In executeTest 10.4");
00437         data.testName = testNameOut;
00438         BugReport("BUG01", "CCImpl.cpp","In executeTest 10.5");
00439         data.testVariable = testVariableOut;
00440         BugReport("BUG01", "CCImpl.cpp","In executeTest 10.6");
00441         data.nScans = nScansOut;
00442         BugReport("BUG01", "CCImpl.cpp","In executeTest 11.7");
00443       };
00444       
00445       BugReport("BUG01", "CCImpl.cpp","In executeTest 12");
00446       data.testPoints = new double[testPointsOut->length()];
00447       BugReport("BUG01", "CCImpl.cpp","In executeTest 13");
00448       data.testPoints_size = testPointsOut->length();
00449       BugReport("BUG01", "CCImpl.cpp","In executeTest 14");
00450       for (unsigned int i=0; i<testPointsOut->length(); ++i) {
00451         BugReport("BUG01", "CCImpl.cpp","In executeTest 15");
00452         data.testPoints[i] = testPointsOut[i];
00453         BugReport("BUG01", "CCImpl.cpp","In executeTest 16");
00454       }
00455     };
00456 
00457     BugReport("BUG01", "CCImpl.cpp","In executeTest 17");
00458     auto_ptr<Test> test (new Test(data, s->getModuleList()));
00459     BugReport("BUG01", "CCImpl.cpp","In executeTest 18");
00460 
00461     status.currentTest = test->getUniqueID();
00462     BugReport("BUG01", "CCImpl.cpp","In executeTest 19");
00463     updateStatus();
00464     BugReport("BUG01", "CCImpl.cpp","In executeTest 20");
00465 
00466     try {
00467     BugReport("BUG01", "CCImpl.cpp","In executeTest 21");
00468         unsigned int i=0;
00469     bool errorFlag=false;
00470     for (; i<data.nScans; ++i) {
00471     BugReport("BUG01", "CCImpl.cpp","In executeTest 22");
00472         Sct_CalibrationController::ScanRequest_var scan = tr->getNextScan(i);
00473     BugReport("BUG01", "CCImpl.cpp","In executeTest 22.5");
00474         if (CORBA::is_nil(scan)) {
00475     BugReport("BUG01", "CCImpl.cpp","In executeTest 23");
00476               throw IllegalStateError("getNextScan returned zero!", __FILE__, __LINE__);
00477             };
00478     BugReport("BUG01", "CCImpl.cpp","In executeTest 23.5");
00479         if (CORBA::is_nil(scan->getScanCorba())) {
00480     BugReport("BUG01", "CCImpl.cpp","In executeTest 24");
00481               throw IllegalStateError("ScanRequest.getScan returned zero!", __FILE__, __LINE__);
00482             };
00483     BugReport("BUG01", "CCImpl.cpp","In executeTest 25");
00484         test->addScan(scan->getScanCorba());
00485     BugReport("BUG01", "CCImpl.cpp","In executeTest 26");
00486         if (abortNow) {
00487     BugReport("BUG01", "CCImpl.cpp","In executeTest 27");
00488         abortNow = false;
00489         abortRightNow = false;
00490         break;
00491         }
00492     BugReport("BUG01", "CCImpl.cpp","In executeTest 28");
00493         try{
00494     BugReport("BUG01", "CCImpl.cpp","In executeTest 29");
00495           executeScan(scan, i);
00496     BugReport("BUG01", "CCImpl.cpp","In executeTest 30");
00497         }catch(CORBA::Exception& e){
00498     BugReport("BUG01", "CCImpl.cpp","In executeTest 31");
00499           throw CorbaExceptionWrapper(e,"Exception in executeScan", __FILE__, __LINE__);
00500         }
00501     BugReport("BUG01", "CCImpl.cpp","In executeTest 32");
00502     }
00503     BugReport("BUG01", "CCImpl.cpp","In executeTest 33");
00504     if (i == data.nScans && !errorFlag) {
00505     BugReport("BUG01", "CCImpl.cpp","In executeTest 34");
00506         SctNames::Mrs() << "CC_TEST_END" << MRS_TEXT("Calibration Controller ending test") << MRS_INFORMATION << ENDM;
00507         test->setStatus(TestData::COMPLETED);
00508     BugReport("BUG01", "CCImpl.cpp","In executeTest 35");
00509     } else {
00510     BugReport("BUG01", "CCImpl.cpp","In executeTest 36");
00511         SctNames::Mrs() << "CC_TEST_ABORT" << MRS_TEXT("Calibration Controller aborting test") << MRS_INFORMATION << ENDM;
00512         test->setStatus(TestData::ABORTED);
00513     BugReport("BUG01", "CCImpl.cpp","In executeTest 37");
00514 
00515         const TestData& testData = test->getData();
00516         setNextScanNumber(testData.startScanNumber + testData.nScans);
00517     }
00518     BugReport("BUG01", "CCImpl.cpp","In executeTest 38");
00519 
00520     } catch (SctApiAccessException& e) {
00521     BugReport("BUG01", "CCImpl.cpp","In executeTest 39");
00522     sctApiError(e);
00523         BugReport("BUG01", "CCImpl.cpp","Ending executeTest early 2");
00524     throw;  //Drop through
00525     } catch (CorbaExceptionWrapper& e) {
00526     SctNames::Mrs() << "CC_TEST_ABORT" << MRS_TEXT("Calibration Controller aborting test") << MRS_INFORMATION << ENDM;
00527     test->setStatus(TestData::ABORTED);
00528     BugReport("BUG01", "CCImpl.cpp","In executeTest 40");
00529     e.sendToMrs(MRS_INFORMATION);
00530 
00531     //Try an increment the scan number to the end of the test
00532     const TestData& testData = test->getData();
00533     BugReport("BUG01", "CCImpl.cpp","In executeTest 41");
00534     setNextScanNumber(testData.startScanNumber + testData.nScans);
00535     }
00536     BugReport("BUG01", "CCImpl.cpp","In executeTest 42");
00537 
00538     //End the test
00539     try {
00540     BugReport("BUG01", "CCImpl.cpp","In executeTest 43");
00541         tr->endTest();
00542     BugReport("BUG01", "CCImpl.cpp","In executeTest 44");
00543     } catch (CorbaExceptionWrapper& e) {
00544     BugReport("BUG01", "CCImpl.cpp","In executeTest 45");
00545     e.sendToMrs(MRS_DIAGNOSTIC);
00546     BugReport("BUG01", "CCImpl.cpp","In executeTest 46");
00547     }
00548     BugReport("BUG01", "CCImpl.cpp","In executeTest 47");
00549 
00550     //Reset the module configurations to the original
00551     try {
00552     BugReport("BUG01", "CCImpl.cpp","In executeTest 48");
00553         APICALL(api, getABCDModules(Sct_SctApi::CALIBRATION_CONFIG), "getABCDModules failed")
00554     BugReport("BUG01", "CCImpl.cpp","In executeTest 49");
00555         APICALL(api, sendABCDModules(Sct_SctApi::PHYSICS_CONFIG), "sendABCDModules failed")
00556     BugReport("BUG01", "CCImpl.cpp","In executeTest 50");
00557     } catch (SctApiAccessException& e) {
00558     BugReport("BUG01", "CCImpl.cpp","In executeTest 51");
00559         sctApiError(e);
00560     BugReport("BUG01", "CCImpl.cpp","In executeTest 52");
00561         e.sendToMrs();
00562     BugReport("BUG01", "CCImpl.cpp","In executeTest 53");
00563     }
00564     BugReport("BUG01", "CCImpl.cpp","In executeTest 54");
00565 
00566     BugReport("BUG01", "CCImpl.cpp","Ending executeTest normally");
00567  return test;
00568 }
00569 
00570 void CalibrationControllerImpl::executeScan(Sct_CalibrationController::ScanRequest_ptr scan, unsigned int index) {
00571     Sct_SctApi::SctApiIPC_var api = getApi();
00572     ++nextScanNumber;
00573     SctNames::Mrs() << "CC_SCAN_START" << MRS_TEXT("Calibration Controller starting scan") << MRS_INFORMATION << ENDM;
00574 
00575     status.currentScanIndex = index;
00576     updateStatus();
00577 
00578     SctNames::Mrs() << "CC_SCAN_PART1" << MRS_TEXT("Calibration Controller determining whether scan is raw or cooked ...") << MRS_INFORMATION << ENDM;
00579     if ( scan->isRawCorba() ){
00580       SctNames::Mrs() << "CC_SCAN_PART2" << MRS_TEXT("Calibration Controller thinks scan is raw.  Now doingRawScan ...") << MRS_INFORMATION << ENDM;
00581       APICALL(api, doRawScan(scan->getScanCorba(), scan->delayCorba(), scan->widthCorba(), scan->configureModulesCorba(), scan->clockByTwoCorba()  ), "doRawScan failed");
00582     }else{
00583       SctNames::Mrs() << "CC_SCAN_PART2" << MRS_TEXT("Calibration Controller thinks scan is cooked.  Now doingCookedScan ...") << MRS_INFORMATION << ENDM;
00584       APICALL(api, doScan(scan->getScanCorba() ), "doScan failed");
00585     }
00586     SctNames::Mrs() << "CC_SCAN_PART3" << MRS_TEXT(" ... finished whatever kind of scan we started.") << MRS_INFORMATION << ENDM;
00587 
00588     // Perhaps the next few lines could be replaced by an APICALL to awaitScan ??   CGL: 2004/01/24
00589     // No, awaitScan has no timeout, or other get out (except at CORBA level)
00590     // CalibrationController may want to give more feedback here about what is going on. BJG: 2004/01/25
00591     // Also would be place to put APICALL to abortScan, once implemented properly? 
00592 
00593     ISInfoInt i;
00594     i.setValue(-1);
00595     ISInfo::Status isStatus = ISInfo::Success;
00596     ISInfoDictionary& is = SctNames::getISDictionary();
00597     int nInitialSleeps = 0;
00598 
00599     while ((i.getValue() == -1 && nInitialSleeps < 20) || (i.getValue() == 1 && isStatus == ISInfo::Success)) {
00600         isStatus = is.findValue("SCTAPIServer.scanning", i);
00601         usleep(100);
00602     ++nInitialSleeps;
00603     if (abortRightNow) {
00604         abortRightNow = false;
00605         abortNow = false;
00606         IoException erm("Abort called and SctApi not responding, doScan failed", __FILE__, __LINE__);
00607         throw erm;
00608     }
00609     }
00610 
00611     SctNames::Mrs() << "CC_SCAN_END" << MRS_TEXT("Calibration Controller ending scan") << MRS_INFORMATION << ENDM;
00612 }
00613 
00614   CalibrationControllerImpl & CalibrationControllerImpl::initialize(RunControl& rc) {
00615     inst = new CalibrationControllerImpl(rc);
00616     return *inst;
00617 }
00618 
00619 Sct_CalibrationController::CalibrationController_ptr CalibrationControllerImpl::instance() {
00620     if (!inst)
00621     throw InvariantViolatedError("Need to call CalibrationControllerImpl::initialize first!", __FILE__, __LINE__);
00622     return inst->_this();
00623 }
00624 
00625 Sct_CalibrationController::ScanLibrary_ptr CalibrationControllerImpl::getScanLibrary() {
00626     return ScanLibraryImpl::instance();
00627 }
00628 
00629 Sct_CalibrationController::TestLibrary_ptr CalibrationControllerImpl::getTestLibrary() {
00630     return TestLibraryImpl::instance();
00631 }
00632 
00633 Sct_CalibrationController::SequenceLibrary_ptr CalibrationControllerImpl::getSequenceLibrary() {
00634     cout << "Get Sequence Library" << endl;
00635     return SequenceLibraryImpl::instance();
00636 }
00637 
00638 void CalibrationControllerImpl::doScan(Sct_CalibrationController::ScanRequest_ptr scan) {
00639     doTest(DefaultTest::instance(scan));
00640 }
00641 
00642 void CalibrationControllerImpl::doTest (Sct_CalibrationController::TestRequest_ptr t) {
00643     doSequence(DefaultSequence::instance(t));
00644 }
00645 
00646 void CalibrationControllerImpl::doSequence (Sct_CalibrationController::SequenceRequest_ptr r) {
00647     if (!isInControl() || isBusy()) {
00648         cerr << "Can't execute SequenceRequest - bad status: " << status.status << endl;
00649         return;
00650     }
00651 
00652     cout << "do Sequence" << endl;
00653 
00654     status.status = status.BUSY;  // set back to INCONTROL by the SequenceRequestWorker
00655     updateStatus();
00656 
00657 
00658     m_sequence_request_thread_group.create_thread(SequenceRequestWorker(*this, r));
00659     Sct::BugReport("WARN01","CC","the second argument to this func should probably inherit from the self-destructing portable adapter mixin class ...");
00660 #warning the second argument to this func should probably inherit from the self-destructing portable adapter mixin class ...
00661 }
00662 
00663 Sct_SctApi::Scan_ptr CalibrationControllerImpl::getScan(unsigned long runNumber, unsigned long scanNumber) {
00664   cerr << "CalibrationControllerImpl::getScan - Not implemented" << endl;
00665   return Sct_SctApi::Scan::_nil();
00666 }
00667 
00668 void CalibrationControllerImpl::updateStatus() {
00669   Sct::BugReport("BUG01","CCImpl.cpp","In updateStatus 1/4");
00670   string name = SctNames::getControlDataName();
00671   Sct::BugReport("BUG01","CCImpl.cpp","In updateStatus 2/4");
00672   name += ".Status";
00673   Sct::BugReport("BUG01","CCImpl.cpp","In updateStatus 3/4");
00674   ISUtilities::addOrUpdateOrMessage(name, status, __FILE__, __LINE__, MRS_DIAGNOSTIC);
00675   Sct::BugReport("BUG01","CCImpl.cpp","In updateStatus 4/4");
00676 }
00677   
00678 CalibrationControllerImpl * CalibrationControllerImpl::inst = 0;
00679 
00680 }

Generated on Thu Feb 10 02:40:07 2005 for SCT DAQ/DCS Software - C++ by doxygen 1.3.5