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

SctApiImpl.cxx

00001 
00002 
00025 #include <iostream>
00026 
00027 #include <vector>
00028 
00029 #include "ScanDefImpl.h"
00030 #include "TriggerImpl.h"
00031 #include "SctApiException.h"
00032 
00033 #include "ABCD/ABCDchip.h"
00034 
00035 using namespace SctApi;
00036 using namespace boost;
00037 using namespace boost::posix_time;
00038 
00039 #include "crate.h"
00040 
00041 SctApiException::SctApiException(const CrateException &c) throw() : desc(c.what()) {}
00042 
00043 TriggerImpl::TriggerImpl() 
00044 {
00045   incCmd = incData = 0;
00046 }
00047 
00048 TriggerImpl::TriggerImpl(const TriggerImpl &other) :
00049   trigSequence(other.trigSequence), incCmd(other.incCmd), incData(other.incData)
00050 {
00051 }
00052 
00053 boost::shared_ptr<TriggerImpl> TriggerImpl::clone(const boost::shared_ptr< ::SctApi::Trigger> other) {
00054   boost::shared_ptr<TriggerImpl> result(new TriggerImpl());
00055 
00056   result->trigSequence = other->getRODTriggers();
00057 
00058   unsigned short command;
00059   unsigned short incr;
00060   other->getCommIncr(command, incr);
00061 
00062   result->incCmd = command;
00063   result->incData = incr;
00064 
00065   return result;
00066 }
00067 
00068 TriggerImpl::~TriggerImpl() 
00069 {
00070 }
00071 
00072 void TriggerImpl::singleL1A() 
00073 {
00074   trigSequence.clear();
00075 
00076   trigSequence.push_back(std::make_pair(L1_TRIGGER, 0));
00077 
00078   incCmd = incData = 0;
00079 }
00080 
00081 void TriggerImpl::doubleL1A(unsigned short delay) 
00082 {
00083   trigSequence.clear();
00084 
00085   trigSequence.push_back(std::make_pair(L1_TRIGGER, 0));
00086   trigSequence.push_back(std::make_pair(DELAY, delay));
00087   trigSequence.push_back(std::make_pair(L1_TRIGGER, 0));
00088 
00089   incCmd = incData = 0;
00090 }
00091 
00092 void TriggerImpl::delayedL1A(unsigned short delay) 
00093 {
00094   trigSequence.clear();
00095 
00096   trigSequence.push_back(std::make_pair(DELAY, delay));
00097   trigSequence.push_back(std::make_pair(L1_TRIGGER, 0));
00098 
00099   incCmd = incData = 0;
00100 }
00101 
00102 void TriggerImpl::calL1A(unsigned short delay) 
00103 {
00104   trigSequence.clear();
00105 
00106   trigSequence.push_back(std::make_pair(CALIBRATION_PULSE, 0));
00107   trigSequence.push_back(std::make_pair(DELAY, delay));
00108   trigSequence.push_back(std::make_pair(L1_TRIGGER, 0));
00109 
00110   incCmd = incData = 0;
00111 }
00112 
00113 void TriggerImpl::pulseL1A(unsigned short delay)
00114 {
00115   trigSequence.clear();
00116 
00117   trigSequence.push_back(std::make_pair(PULSE_INPUT_REG, 0));
00118   trigSequence.push_back(std::make_pair(DELAY, delay));
00119   trigSequence.push_back(std::make_pair(L1_TRIGGER, 0));
00120 
00121   incCmd = incData = 0;
00122 }
00123 
00124 void TriggerImpl::softL1A(unsigned short delay)
00125 {
00126   trigSequence.clear();
00127 
00128   trigSequence.push_back(std::make_pair(SOFT_RESET, 0));
00129   trigSequence.push_back(std::make_pair(DELAY, delay));
00130   trigSequence.push_back(std::make_pair(L1_TRIGGER, 0));
00131 
00132   incCmd = incData = 0;
00133 }
00134 
00135 void TriggerImpl::softCalL1A(unsigned short delay, unsigned short delay2)
00136 {
00137   trigSequence.clear();
00138 
00139   trigSequence.push_back(std::make_pair(SOFT_RESET, 0));
00140   trigSequence.push_back(std::make_pair(DELAY, delay));
00141   trigSequence.push_back(std::make_pair(CALIBRATION_PULSE, 0));
00142   trigSequence.push_back(std::make_pair(DELAY, delay2));
00143   trigSequence.push_back(std::make_pair(L1_TRIGGER, 0));
00144 
00145   incCmd = incData = 0;
00146 }
00147  
00148 void TriggerImpl::softPulseL1A(unsigned short delay, unsigned short delay2)
00149 {
00150   trigSequence.clear();
00151 
00152   trigSequence.push_back(std::make_pair(SOFT_RESET, 0));
00153   trigSequence.push_back(std::make_pair(DELAY, delay));
00154   trigSequence.push_back(std::make_pair(PULSE_INPUT_REG, 0));
00155   trigSequence.push_back(std::make_pair(DELAY, delay2));
00156   trigSequence.push_back(std::make_pair(L1_TRIGGER, 0));
00157 
00158   incCmd = incData = 0;
00159 }
00160 
00161 void TriggerImpl::softBc(unsigned short delay)
00162 {
00163   trigSequence.clear();
00164 
00165   trigSequence.push_back(std::make_pair(SOFT_RESET, 0));
00166   trigSequence.push_back(std::make_pair(DELAY, delay));
00167   trigSequence.push_back(std::make_pair(BC_RESET, 0));
00168 
00169   incCmd = incData = 0;
00170 }
00171 
00172 void TriggerImpl::soft()
00173 {
00174   trigSequence.clear();
00175   
00176   trigSequence.push_back(std::make_pair(SOFT_RESET, 0));
00177   
00178   incCmd = incData = 0;
00179 }
00180 
00181 void TriggerImpl::bc()
00182 {
00183   trigSequence.clear();
00184   
00185   trigSequence.push_back(std::make_pair(BC_RESET, 0));
00186   
00187   incCmd = incData = 0;
00188 }
00189 
00190 void TriggerImpl::bcL1A(unsigned short delay)
00191 {
00192   trigSequence.clear();
00193 
00194   trigSequence.push_back(std::make_pair(BC_RESET, 0));
00195   trigSequence.push_back(std::make_pair(DELAY, delay));
00196   trigSequence.push_back(std::make_pair(L1_TRIGGER, 0));
00197 
00198   incCmd = incData = 0;
00199 }
00200 
00201 void TriggerImpl::bcCalL1A(unsigned short delay, unsigned short delay2)
00202 {
00203   trigSequence.clear();
00204 
00205   trigSequence.push_back(std::make_pair(BC_RESET, 0));
00206   trigSequence.push_back(std::make_pair(DELAY, delay));
00207   trigSequence.push_back(std::make_pair(CALIBRATION_PULSE, 0));
00208   trigSequence.push_back(std::make_pair(DELAY, delay2));
00209   trigSequence.push_back(std::make_pair(L1_TRIGGER, 0));
00210 
00211   incCmd = incData = 0;
00212 }
00213  
00214 void TriggerImpl::bcPulseL1A(unsigned short delay, unsigned short delay2)
00215 {
00216   trigSequence.clear();
00217 
00218   trigSequence.push_back(std::make_pair(BC_RESET, 0));
00219   trigSequence.push_back(std::make_pair(DELAY, delay));
00220   trigSequence.push_back(std::make_pair(PULSE_INPUT_REG, 0));
00221   trigSequence.push_back(std::make_pair(DELAY, delay2));
00222   trigSequence.push_back(std::make_pair(L1_TRIGGER, 0));
00223 
00224   incCmd = incData = 0;
00225 }
00226 
00227 void TriggerImpl::setCommIncr(unsigned short command, unsigned short incr)
00228 {
00229   incCmd = command;
00230   incData = incr;
00231 }
00232 
00233 void TriggerImpl::getCommIncr(unsigned short &command, unsigned short &incr) const
00234 {
00235   command = incCmd;
00236   incr = incData;
00237 }
00238 
00239 const ::SctApi::Trigger::RODTriggers TriggerImpl::getRODTriggers() const 
00240 {
00241   return trigSequence;
00242 
00243 //   ::SctApi::Trigger::RODTriggers result;
00244 
00245   
00246 
00247 //   return result;
00248 }
00249 
00250 #if 0
00251 void TriggerImpl::copy(const ::SctApi::Trigger &trig) 
00252 {
00253   short unsigned cmd, data;
00254 
00255   trig.getCommIncr(cmd, data);
00256 
00257   incCmd = cmd;
00258   incData = data;
00259 
00260   trigSequence = trig.getRODTriggers();
00261 }
00262 #endif
00263 
00264 ScanDefImpl::ScanDefImpl() 
00265   : allTrigsSame(true), 
00266     scanVariable(0), scanVariable2(0),
00267     trigSequence(new TriggerImpl), trigSequence2(new TriggerImpl),
00268     full(0),
00269     bits32(1),
00270     loopCalLine(0),
00271     distSlave(1),
00272     debug(0),
00273     tim(0),
00274     nth(0), nth_rem(0),
00275     enableDataMode(true),
00276     scanNumber(0),
00277     runNumber(0),
00278     m_maxGroup(0),
00279     startTime(second_clock::universal_time()),
00280     endTime(second_clock::universal_time())
00281 {
00282   trigPoints.clear();
00283   scanPoints.clear();
00284   scanPoints2.clear();
00285 }
00286 
00287 ScanDefImpl::~ScanDefImpl() 
00288 {
00289 //   delete trigSequence;
00290 //   delete trigSequence2;
00291 }
00292 
00293 ScanDefImpl::ScanDefImpl(const ScanDefImpl &other) :
00294   scanPoints(other.scanPoints),
00295   scanPoints2(other.scanPoints2),
00296   trigPoints(other.trigPoints),
00297   allTrigsSame(other.allTrigsSame),
00298   scanVariable(other.scanVariable),
00299   scanVariable2(other.scanVariable2),
00300 
00301   trigSequence(TriggerImpl::clone(other.trigSequence)),
00302   trigSequence2(TriggerImpl::clone(other.trigSequence2)),
00303 
00304   full(other.full), 
00305   bits32(other.bits32),
00306   loopCalLine(other.loopCalLine),
00307 
00308   distSlave(other.distSlave),
00309   debug(other.debug),
00310   tim(other.tim),
00311   nth(other.nth),
00312   nth_rem(other.nth_rem),
00313   enableDataMode(other.enableDataMode),
00314 
00315   scanNumber(other.scanNumber), 
00316   runNumber(other.runNumber), 
00317   groupLists(other.groupLists), 
00318   m_maxGroup(other.m_maxGroup), 
00319 
00320   startTime(other.startTime),
00321   endTime(other.endTime)
00322 {
00323 }
00324 
00325 boost::shared_ptr<ScanDefImpl> ScanDefImpl::clone(const boost::shared_ptr< ::SctApi::Scan> other) {
00326   boost::shared_ptr<ScanDefImpl> result(new ScanDefImpl);
00327 
00328   result->trigPoints = other->getVariableTrigs();
00329   result->scanVariable = other->getScanVariable1();
00330   result->scanVariable2 = other->getScanVariable2();
00331   result->scanPoints = other->getScanPoints1();
00332   result->scanPoints2 = other->getScanPoints2();
00333 
00334   result->trigSequence = TriggerImpl::clone(other->getTrigger1());
00335   result->trigSequence2 = TriggerImpl::clone(other->getTrigger2());
00336 
00337   result->full = other->getOption(Scan::FULL);
00338   result->bits32 = other->getOption(Scan::BITS32);
00339   result->loopCalLine = other->getOption(Scan::LOOPCALLINE);
00340   result->distSlave = other->getOption(Scan::DISTSLAVE);
00341   result->debug = other->getOption(Scan::DEBUG);
00342   result->tim = other->getOption(Scan::TIM);
00343   result->nth = other->getOption(Scan::NTH);
00344   result->nth_rem = other->getOption(Scan::NTH_REM);
00345   result->enableDataMode = other->getOption(Scan::ENABLE_DATA_MODE);
00346 
00347   result->startTime = other->getStartTime();
00348   result->endTime = other->getEndTime();
00349 
00350   return result;
00351 }
00352 
00353 void ScanDefImpl::configure(unsigned short type, float start, float stop, float step)
00354 {
00355   scanVariable = type;
00356 
00357   // Add 1 to be inclusive of the stop point, extra 0.1% (over kill) for floating point error 
00358   int npoints = int(((stop - start) / step) + 1.001);
00359 
00360   scanPoints.resize(npoints);
00361 
00362   for(int i=0; i<npoints; i++) {
00363     FLOAT32 point = start + i * step;
00364     scanPoints[i] = point;
00365   }
00366 
00367   if(allTrigsSame) {
00368     // Default to 0
00369     int newNTrig = trigPoints.size() > 0?trigPoints[0]:0;
00370     trigPoints.resize(std::max(1U, scanPoints.size()), newNTrig);
00371   }
00372 }
00373 
00374 void ScanDefImpl::configure2(unsigned short type, float start, float stop, float step)
00375 {
00376   scanVariable2 = type;
00377 
00378   int npoints = int(((stop - start) / step) + 1.001);
00379 
00380   scanPoints2.resize(npoints);
00381 
00382   for(int i=0; i<npoints; i++) {
00383     FLOAT32 point = start + i * step; 
00384     scanPoints2[i] = point;
00385   }
00386 }
00387 
00388 const boost::shared_ptr< ::SctApi::Trigger> ScanDefImpl::getTrigger1() const
00389 {
00390   return trigSequence;
00391 }
00392 
00393 const boost::shared_ptr< ::SctApi::Trigger> ScanDefImpl::getTrigger2() const
00394 {
00395   return trigSequence2;
00396 }
00397 
00398 boost::shared_ptr< ::SctApi::Trigger> ScanDefImpl::getTrigger1()
00399 {
00400   return trigSequence;
00401 }
00402 
00403 boost::shared_ptr< ::SctApi::Trigger> ScanDefImpl::getTrigger2()
00404 {
00405   return trigSequence2;
00406 }
00407 
00408 void ScanDefImpl::setTrigger1(boost::shared_ptr< ::SctApi::Trigger> trigger)
00409 {
00410   trigSequence = trigger;
00411 
00412 //   trigSequence = TriggerImpl::clone(trigger); // dynamic_cast< ::SctApi::TriggerImpl *>(trigger);
00413 //   trigSequence.copy(*trigger);
00414 }
00415 
00416 void ScanDefImpl::setTrigger2(boost::shared_ptr< ::SctApi::Trigger> trigger)
00417 {
00418   trigSequence2 = trigger;
00419 
00420 //   trigSequence2 = TriggerImpl::clone(trigger); // dynamic_cast< ::SctApi::TriggerImpl *>(trigger);
00421 //   trigSequence2.copy(*trigger);
00422 }
00423 
00424 void ScanDefImpl::setScanVariable1(unsigned short var)
00425 {
00426   scanVariable = var;
00427 }
00428 
00429 void ScanDefImpl::setScanVariable2(unsigned short var)
00430 {
00431   scanVariable2 = var;
00432 }
00433 
00434 unsigned short ScanDefImpl::getScanVariable1() const
00435 {
00436   return scanVariable;
00437 }
00438 
00439 unsigned short ScanDefImpl::getScanVariable2() const
00440 {
00441   return scanVariable2;
00442 }
00443 
00444 void ScanDefImpl::setNTrigs(unsigned long nTrigs) 
00445 {
00446   trigPoints.resize(std::max(1U, scanPoints.size()));
00447 
00448   for(unsigned int i=0; i<trigPoints.size(); i++) {
00449     trigPoints[i] = nTrigs;
00450   }
00451 
00452   allTrigsSame = true;
00453 }
00454 
00455 unsigned long ScanDefImpl::getNTrigs() const
00456 {
00457   if(trigPoints.size() > 0) {
00458     return trigPoints[0];
00459   } else {
00460     return 0;
00461   }
00462 }
00463 
00464 const ::SctApi::Scan::TrigPoints ScanDefImpl::getVariableTrigs() const
00465 {
00466   return trigPoints;
00467 }
00468 
00469 void ScanDefImpl::setVariableTrigs(const TrigPoints &trigs)
00470 {
00471   allTrigsSame = false;
00472   trigPoints = trigs;
00473 }
00474 
00475 void ScanDefImpl::setVariableTrigRange(unsigned short start, unsigned short end, unsigned long value)
00476 {
00477   allTrigsSame = false;
00478   for(int i=start; i<=end; i++) 
00479     trigPoints[i] = value;
00480 }
00481 
00482 const ::SctApi::Scan::ScanPoints ScanDefImpl::getScanPoints1() const
00483 {
00484   return scanPoints;
00485 }
00486 
00487 const ::SctApi::Scan::ScanPoints ScanDefImpl::getScanPoints2() const
00488 {
00489   return scanPoints2;
00490 }
00491 
00492 void ScanDefImpl::setScanPoints1(const ScanPoints &scans)
00493 {
00494   scanPoints = scans;
00495 
00496   if(allTrigsSame) {
00497     // Default to 0
00498     int newNTrig = trigPoints.size() > 0?trigPoints[0]:0;
00499     trigPoints.resize(std::max(1U, scanPoints.size()), newNTrig);
00500   }
00501 }
00502 
00503 void ScanDefImpl::setScanPoints2(const ScanPoints &scans)
00504 {
00505   scanPoints2 = scans;
00506 }
00507 
00508 int ScanDefImpl::getOption(enum ScanOptions opt) const
00509 {
00510   switch(opt) {
00511   case FULL:
00512     return full;
00513   case BITS32:
00514     return bits32;
00515   case LOOPCALLINE:
00516     return loopCalLine;
00517   case DISTSLAVE:
00518     return distSlave;
00519   case DEBUG:
00520     return debug;
00521   case TIM:
00522     return tim;
00523   case NTH:
00524     return nth;
00525   case NTH_REM:
00526     return nth_rem;
00527   case ENABLE_DATA_MODE:
00528     return enableDataMode;
00529   default:
00530     return 0;
00531   }
00532 }
00533 
00534 void ScanDefImpl::setOption(enum ScanOptions opt, int option) 
00535 {
00536   switch(opt) {
00537   case FULL:
00538     full = option;
00539     break;
00540   case BITS32:
00541     bits32 = option;
00542     break;
00543   case LOOPCALLINE:
00544     loopCalLine = option;
00545     break;
00546   case DISTSLAVE:
00547     distSlave = option;
00548     break;
00549   case DEBUG:
00550     debug = option;
00551     break;
00552   case TIM:
00553     tim = option;
00554     break;
00555   case NTH:
00556     nth = option;
00557     break;
00558   case NTH_REM:
00559     nth_rem = option;
00560     break;
00561   case ENABLE_DATA_MODE:
00562     enableDataMode = option;
00563     break;
00564   }
00565 }
00566 
00567 void ScanDefImpl::print() const {
00568   std::cout << "Scan\n";
00569   std::cout << "Run: " << getRunNumber() << " Scan: " << getScanNumber() << std::endl;
00570 
00571   if(allTrigsSame) {
00572     std::cout << getNTrigs() << " triggers per scan point\n";
00573 
00574     TrigPoints points = getVariableTrigs();
00575 
00576     unsigned int initVal = points[0];
00577 
00578     for(TrigPoints::const_iterator iter = points.begin();
00579         iter != points.end();
00580         iter++) {
00581       if(*iter != initVal) std::cout << " Trigger count array not constant\n";
00582     }
00583 
00584     if(points.size() != getScanPoints1().size()) {
00585       std::cout << " Trigger count array not the same size as scan point array!!!\n";
00586     }
00587 
00588   } else {
00589     std::cout << "Triggers per scan point:\n";
00590 
00591     TrigPoints points = getVariableTrigs();
00592 
00593     int i=0;
00594     for(TrigPoints::const_iterator iter = points.begin();
00595         iter != points.end();
00596         i++, iter++) {
00597       if(i && (i%20 == 0)) std::cout << std::endl;
00598       std::cout.width(4);
00599 
00600       std::cout << *iter << " ";
00601     }
00602     std::cout << std::endl;
00603   }
00604 
00605   std::cout << "Binning mode " << (getOption(Scan::FULL)?"full":"condensed") << std::endl;
00606   std::cout << "Bin size " << (getOption(Scan::BITS32)?"32bit":"16bit") << std::endl;
00607   std::cout << "Cal line loop " << (getOption(Scan::LOOPCALLINE)?"yes":"no") << std::endl;
00608   std::cout << "Use TIM for triggers (synchronous) " << (getOption(Scan::TIM)?"yes":"no") << std::endl;
00609   std::cout << "Put module into dataTakingMode during configure (usually yes): " << (getOption(Scan::ENABLE_DATA_MODE)?"yes":"no") << std::endl;
00610 
00611   std::cout << "Slave DSPs: ";
00612   switch(getOption(Scan::DISTSLAVE)) {
00613   case 0: 
00614     {
00615       std::cout << "All to Slave 0";
00616       if(getOption(Scan::NTH) > 1) {
00617         std::cout << ": Capture trigger%" << getOption(Scan::NTH) << "==" << getOption(Scan::NTH_REM);
00618       }
00619       break;
00620     }
00621   case 1: std::cout << "According to groups"; break;
00622   case 2: 
00623     {
00624       std::cout << "Router distribution";
00625       if(getOption(Scan::NTH) > 1) {
00626         std::cout << ": Capture trigger%" << getOption(Scan::NTH) << "==" << getOption(Scan::NTH_REM);
00627       }
00628       break;
00629     }
00630   default: std::cout << "Invalid type!"; break;
00631   }
00632   std::cout << std::endl;
00633 
00634   if(getOption(Scan::DEBUG)) {
00635     std::cout << "In debug mode\n";
00636   }
00637 
00638   if(getScanPoints2().size() > 0) {
00639     std::cout << "Module set 0\n";
00640   } else {
00641     std::cout << "Scan parameters\n";
00642   }
00643 
00644   std::cout << "Scan over variable number " << getScanVariable1() << std::endl;
00645 
00646   std::cout << getScanPoints1().size() << " scan points:\n";
00647   int i=0;
00648 
00649   std::vector<FLOAT32> points = getScanPoints1();
00650 
00651   for(std::vector<FLOAT32>::const_iterator iter=points.begin();
00652       iter != points.end();
00653       i++, iter++) {
00654     if(i && (i%20 == 0)) std::cout << std::endl;
00655     std::cout.width(4);
00656 
00657     std::cout << *iter << " ";
00658   }
00659   std::cout << std::endl;
00660 
00661   std::cout << "Trigger:\n";
00662 
00663   getTrigger1()->print();
00664 
00665   if(getScanPoints2().size() > 0) {
00666     std::cout << "Module set 1\n";
00667 
00668     std::cout << "Scan over variable number " << getScanVariable2() << std::endl;
00669 
00670     std::cout << getScanPoints2().size() << " scan points:\n";
00671     int i=0;
00672 
00673     std::vector<FLOAT32> points2 = getScanPoints2();
00674 
00675     for(std::vector<FLOAT32>::const_iterator iter=points2.begin();
00676         iter != points2.end();
00677         i++, iter++) {
00678       if(i && (i%20 == 0)) std::cout << std::endl;
00679       std::cout.width(4);
00680 
00681       std::cout << *iter << " ";
00682     }
00683     std::cout << std::endl;
00684 
00685     std::cout << "Trigger2:\n";
00686 
00687     getTrigger2()->print();
00688   } else {
00689     std::cout << "Second trigger not defined\n";
00690   }
00691 
00692   for(int i=0; i<4; i++) {
00693     std::cout << "Modules in group " << i << std::endl;
00694 
00695     ModuleList groupList = getModuleList(i);
00696 
00697     for(ModuleList::const_iterator iter = groupList.begin();
00698         iter != groupList.end();
00699         iter++) {
00700       std::cout << " " << *iter << std::endl;
00701     }
00702   }
00703 }
00704 
00705 
00706 void ScanDefImpl::setScanNumber(unsigned int scan) 
00707 {
00708   scanNumber = scan;
00709 }
00710  
00711 unsigned int ScanDefImpl::getScanNumber() const 
00712 {
00713   return scanNumber;
00714 }
00715 
00716 void ScanDefImpl::setRunNumber(unsigned int run)
00717 {
00718   runNumber = run;
00719 }
00720 
00721 unsigned int ScanDefImpl::getRunNumber() const 
00722 {
00723   return runNumber;
00724 }
00725 
00726 std::list<std::string> ScanDefImpl::getModuleList(unsigned int group) const 
00727 {
00728   std::list<std::string> result;
00729 
00730   if(group<groupLists.size()) {
00731     result = groupLists[group];
00732   }
00733 
00734   return result;
00735 }
00736  
00737 void ScanDefImpl::setModuleList(unsigned int group, const ::SctApi::ModuleList & newList)
00738 {
00739   if(group+1 > groupLists.size()) {
00740     groupLists.resize(group + 1);
00741   }
00742   groupLists[group] = newList;
00743 }
00744 
00745 unsigned int ScanDefImpl::getNGroups() const
00746 {
00747   return m_maxGroup;
00748 }
00749 
00750 void ScanDefImpl::setNGroups(unsigned int val)
00751 {
00752   m_maxGroup = val;
00753 }
00754 
00755 void TriggerImpl::print() const 
00756 {
00757   Trigger::RODTriggers trigs = getRODTriggers();
00758 
00759   std::cout << "Printing trigger: length " << trigs.size() << std::endl;
00760 
00761   if(trigs.size() > 6) {
00762     std::cout << "Trigger sequence over size\n";
00763   }
00764 
00765   unsigned short trigData, trigCmd;
00766   getCommIncr(trigData, trigCmd);
00767 
00768   for(unsigned int i = 0; i < trigs.size(); i++) {
00769     std::cout.width(4);
00770 
00771     std::cout << trigs[i].first << ": " << trigs[i].second << "   ";
00772     if(trigData != 0 && trigCmd == i) {
00773       std::cout << "+" << trigData;
00774     }
00775     std::cout << std::endl;
00776   }
00777 }
00778 
00779 ptime ScanDefImpl::getStartTime() const {
00780     return startTime;
00781 }
00782 
00783 void ScanDefImpl::setStartTime(ptime t) {
00784     startTime = t;
00785 }
00786   
00787 ptime ScanDefImpl::getEndTime() const {
00788     return endTime;
00789 }
00790 
00791 void ScanDefImpl::setEndTime(ptime t) {
00792     endTime = t;
00793 }
00794 
00795 bool RodLabel::operator==(const RodLabel &rhs) const {
00796   return partition == rhs.partition && crate == rhs.crate && rod == rhs.rod;
00797 }
00798 
00799 bool RodLabel::operator!=(const RodLabel &rhs) const {
00800   return !(*this == rhs);
00801 }
00802 
00803 bool RodLabel::operator<(const RodLabel &rhs) const {
00804   if(partition < rhs.partition) return true;
00805   if(crate < rhs.crate) return true;
00806   if(rod < rhs.rod) return true;
00807 
00808   return false;
00809 }
00810 
00811 
00812 bool CrateLabel::operator==(const CrateLabel &rhs) const {
00813   return partition == rhs.partition && crate == rhs.crate;
00814 }
00815 
00816 bool CrateLabel::operator<(const CrateLabel &rhs) const {
00817   if(partition < rhs.partition) return true;
00818   if(crate < rhs.crate) return true;
00819 
00820   return false;
00821 }

Generated on Fri Sep 16 18:01:57 2005 for SCT DAQ/DCS Software - C++ by doxygen 1.3.5