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
00244
00245
00246
00247
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
00290
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
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
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
00413
00414 }
00415
00416 void ScanDefImpl::setTrigger2(boost::shared_ptr< ::SctApi::Trigger> trigger)
00417 {
00418 trigSequence2 = trigger;
00419
00420
00421
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
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 }