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
00206
00207
00208
00209
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
00252
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
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
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
00375
00376 }
00377
00378 void ScanDefImpl::setTrigger2(boost::shared_ptr< ::SctApi::Trigger> trigger)
00379 {
00380 trigSequence2 = trigger;
00381
00382
00383
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
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 }