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

SctApiImpl.cxx

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

Generated on Thu Feb 3 17:37:42 2005 for SCT DAQ/DCS Software - C++ by doxygen 1.3.5