SctApiImpl.cxx

#include <iostream>

#include <vector>

#include "ScanDefImpl.h"
#include "TriggerImpl.h"
#include "SctApiException.h"
#include "SctApiHisto.h"
#include "ConfigurationUtility.h"
#include "Sct/AbcdChip.h"

using namespace SctApi;
using namespace boost;
using namespace boost::posix_time;

#include "crate.h"
#include "RodCrate/TimDefine.h"

SctApiException::SctApiException(const CrateException &c) throw() : desc(c.what()) {}

TriggerImpl::TriggerImpl() 
{
  incCmd = incData = 0;
  m_source = SOURCE_UNKNOWN;
  m_freq=40.;
  m_random=0;
}

TriggerImpl::TriggerImpl(const TriggerImpl &other) :
  trigSequence(other.trigSequence), incCmd(other.incCmd), incData(other.incData), 
  m_source(other.m_source), m_freq(other.m_freq), m_random(other.m_random)
{
}

boost::shared_ptr<TriggerImpl> TriggerImpl::clone(const boost::shared_ptr< ::SctApi::Trigger> other) {
  boost::shared_ptr<TriggerImpl> result(new TriggerImpl());

  result->trigSequence = other->getRODTriggers();

  unsigned short command;
  unsigned short incr;
  other->getCommIncr(command, incr);

  result->incCmd = command;
  result->incData = incr;
  result->m_source = other->getSource();
  result->m_freq= other->getFrequency();
  result->m_random = other->getRandom();

  return result;
}

TriggerImpl::~TriggerImpl() 
{
}

void TriggerImpl::clear() {
  trigSequence.clear();
}

void TriggerImpl::addCommand(UINT16 first, UINT32 second) {
  trigSequence.push_back(std::make_pair(first, second));
}

void TriggerImpl::singleL1A() 
{
  trigSequence.clear();

  trigSequence.push_back(std::make_pair(L1_TRIGGER, 0));

  incCmd = incData = 0;
}

void TriggerImpl::doubleL1A(unsigned short delay) 
{
  trigSequence.clear();

  trigSequence.push_back(std::make_pair(L1_TRIGGER, 0));
  trigSequence.push_back(std::make_pair(DELAY, delay));
  trigSequence.push_back(std::make_pair(L1_TRIGGER, 0));

  incCmd = incData = 0;
}

void TriggerImpl::delayedL1A(unsigned short delay) 
{
  trigSequence.clear();

  trigSequence.push_back(std::make_pair(DELAY, delay));
  trigSequence.push_back(std::make_pair(L1_TRIGGER, 0));

  incCmd = incData = 0;
}

void TriggerImpl::calL1A(unsigned short delay) 
{
  trigSequence.clear();

  trigSequence.push_back(std::make_pair(CALIBRATION_PULSE, 0));
  trigSequence.push_back(std::make_pair(DELAY, delay));
  trigSequence.push_back(std::make_pair(L1_TRIGGER, 0));

  incCmd = incData = 0;
}

void TriggerImpl::pulseL1A(unsigned short delay)
{
  trigSequence.clear();

  trigSequence.push_back(std::make_pair(PULSE_INPUT_REG, 0));
  trigSequence.push_back(std::make_pair(DELAY, delay));
  trigSequence.push_back(std::make_pair(L1_TRIGGER, 0));

  incCmd = incData = 0;
}

void TriggerImpl::softL1A(unsigned short delay)
{
  trigSequence.clear();

  trigSequence.push_back(std::make_pair(SOFT_RESET, 0));
  trigSequence.push_back(std::make_pair(DELAY, delay));
  trigSequence.push_back(std::make_pair(L1_TRIGGER, 0));

  incCmd = incData = 0;
}

void TriggerImpl::softCalL1A(unsigned short delay, unsigned short delay2)
{
  trigSequence.clear();

  trigSequence.push_back(std::make_pair(SOFT_RESET, 0));
  trigSequence.push_back(std::make_pair(DELAY, delay));
  trigSequence.push_back(std::make_pair(CALIBRATION_PULSE, 0));
  trigSequence.push_back(std::make_pair(DELAY, delay2));
  trigSequence.push_back(std::make_pair(L1_TRIGGER, 0));

  incCmd = incData = 0;
}
 
void TriggerImpl::softPulseL1A(unsigned short delay, unsigned short delay2)
{
  trigSequence.clear();

  trigSequence.push_back(std::make_pair(SOFT_RESET, 0));
  trigSequence.push_back(std::make_pair(DELAY, delay));
  trigSequence.push_back(std::make_pair(PULSE_INPUT_REG, 0));
  trigSequence.push_back(std::make_pair(DELAY, delay2));
  trigSequence.push_back(std::make_pair(L1_TRIGGER, 0));

  incCmd = incData = 0;
}

void TriggerImpl::softBc(unsigned short delay)
{
  trigSequence.clear();

  trigSequence.push_back(std::make_pair(SOFT_RESET, 0));
  trigSequence.push_back(std::make_pair(DELAY, delay));
  trigSequence.push_back(std::make_pair(BC_RESET, 0));

  incCmd = incData = 0;
}

void TriggerImpl::soft()
{
  trigSequence.clear();
  
  trigSequence.push_back(std::make_pair(SOFT_RESET, 0));
  
  incCmd = incData = 0;
}

void TriggerImpl::bc()
{
  trigSequence.clear();
  
  trigSequence.push_back(std::make_pair(BC_RESET, 0));
  
  incCmd = incData = 0;
}

void TriggerImpl::bcL1A(unsigned short delay)
{
  trigSequence.clear();

  trigSequence.push_back(std::make_pair(BC_RESET, 0));
  trigSequence.push_back(std::make_pair(DELAY, delay));
  trigSequence.push_back(std::make_pair(L1_TRIGGER, 0));

  incCmd = incData = 0;
}

void TriggerImpl::bcCalL1A(unsigned short delay, unsigned short delay2)
{
  trigSequence.clear();

  trigSequence.push_back(std::make_pair(BC_RESET, 0));
  trigSequence.push_back(std::make_pair(DELAY, delay));
  trigSequence.push_back(std::make_pair(CALIBRATION_PULSE, 0));
  trigSequence.push_back(std::make_pair(DELAY, delay2));
  trigSequence.push_back(std::make_pair(L1_TRIGGER, 0));

  incCmd = incData = 0;
}
 
void TriggerImpl::bcPulseL1A(unsigned short delay, unsigned short delay2)
{
  trigSequence.clear();

  trigSequence.push_back(std::make_pair(BC_RESET, 0));
  trigSequence.push_back(std::make_pair(DELAY, delay));
  trigSequence.push_back(std::make_pair(PULSE_INPUT_REG, 0));
  trigSequence.push_back(std::make_pair(DELAY, delay2));
  trigSequence.push_back(std::make_pair(L1_TRIGGER, 0));

  incCmd = incData = 0;
}

void TriggerImpl::setCommIncr(unsigned short command, unsigned short incr)
{
  incCmd = command;
  incData = incr;
}

void TriggerImpl::getCommIncr(unsigned short &command, unsigned short &incr) const
{
  command = incCmd;
  incr = incData;
}

const ::SctApi::Trigger::RODTriggers TriggerImpl::getRODTriggers(int scan_point) const 
{
  ::SctApi::Trigger::RODTriggers out_trigs = trigSequence;
  if (incCmd<out_trigs.size() && incCmd>=0){
    out_trigs[incCmd].second+=incData*scan_point;
  }
  return out_trigs;
}

const ::SctApi::Trigger::TIMTriggers TriggerImpl::getTIMTriggers(int scan_point) const {
  return convertToTIMTriggers(getRODTriggers(scan_point));
}

// AJB 8/8/05 - not terribly sure that this is all accurate
bool TriggerImpl::isValidRODTrigger() const{
  return trigSequence.size()<=6;
}

// AJB 8/8/05 - not terribly sure that this is all accurate
bool TriggerImpl::isValidTIMTrigger() const{
  for (::SctApi::Trigger::RODTriggers::const_iterator i=trigSequence.begin(); i!=trigSequence.end(); ++i){
    switch (i->first) {
      // TIM understands these trigger types
    case L1_TRIGGER : case BC_RESET :
    case SOFT_RESET : case DELAY:
    case CALIBRATION_PULSE : continue;
      // any other type makes it invalid
    default: return false;
    }
  }
  return true;
}

bool TriggerImpl::timNeedsSequencer() const{
  if (trigSequence.empty()) return false;
  if (trigSequence.size()==1 && trigSequence[0].first==L1_TRIGGER) return false;
  return true;
}

void TriggerImpl::setFrequency(double freq){
  m_freq=freq;
}

double TriggerImpl::getFrequency() const{
  return m_freq;
}

Trigger::Source TriggerImpl::getSource() const{
  return m_source;
}

void TriggerImpl::setSource(Trigger::Source s){
  m_source=s;
}

int TriggerImpl::getRandom() const{
  return m_random;
}

void TriggerImpl::setRandom(int r){
  m_random=r;
}

#if 0
void TriggerImpl::copy(const ::SctApi::Trigger &trig) 
{
  short unsigned cmd, data;

  trig.getCommIncr(cmd, data);

  incCmd = cmd;
  incData = data;
  m_source = trig.getSource();
  m_freq = trig.getFrequency();
  m_random = trig.getRandom();

  trigSequence = trig.getRODTriggers();
}
#endif

ScanDefImpl::ScanDefImpl() 
  : allTrigsSame(true), 
    scanVariable(0), scanVariable2(0),
    trigSequence(new TriggerImpl), trigSequence2(new TriggerImpl),
    full(0),
    bits32(1),
    loopCalLine(0),
    distSlave(1),
    debug(0),
    tim(0),
    nth(0), nth_rem(0),
    enableDataMode(true),
    ccode(0),
    ope(0),
    scanNumber(0),
    runNumber(0),
    m_maxGroup(0),
    startTime(second_clock::universal_time()),
    endTime(second_clock::universal_time())
{
  trigPoints.clear();
  scanPoints.clear();
  scanPoints2.clear();
}

ScanDefImpl::~ScanDefImpl() 
{
//   delete trigSequence;
//   delete trigSequence2;
}

ScanDefImpl::ScanDefImpl(const ScanDefImpl &other) :

  scanPoints(other.scanPoints),
  scanPoints2(other.scanPoints2),
  trigPoints(other.trigPoints),
  allTrigsSame(other.allTrigsSame),
  scanVariable(other.scanVariable),
  scanVariable2(other.scanVariable2),

  trigSequence(TriggerImpl::clone(other.trigSequence)),
  trigSequence2(TriggerImpl::clone(other.trigSequence2)),

  full(other.full), 
  bits32(other.bits32),
  loopCalLine(other.loopCalLine),

  distSlave(other.distSlave),
  debug(other.debug),
  tim(other.tim),
  nth(other.nth),
  nth_rem(other.nth_rem),
  enableDataMode(other.enableDataMode),
  ccode(other.ccode),
  ope(other.ope),

  scanNumber(other.scanNumber), 
  runNumber(other.runNumber), 
  groupLists(other.groupLists), 
  m_maxGroup(other.m_maxGroup), 

  startTime(other.startTime),
  endTime(other.endTime)
{
}

boost::shared_ptr<ScanDefImpl> ScanDefImpl::clone(const boost::shared_ptr<const ::SctApi::Scan> other) {
  std::cout << "Starting ScanDefImpl::clone ... " << std::endl;
  boost::shared_ptr<ScanDefImpl> result(new ScanDefImpl);

  result->scanPoints = other->getScanPoints1();
  result->scanPoints2 = other->getScanPoints2();
  //result->allTrigsSame = other->allTrigsSame;
  result->trigPoints = other->getVariableTrigs();
  result->scanVariable = other->getScanVariable1();
  result->scanVariable2 = other->getScanVariable2();

  result->trigSequence = TriggerImpl::clone(other->getTrigger1());
  result->trigSequence2 = TriggerImpl::clone(other->getTrigger2());

  result->full = other->getOption(Scan::FULL);
  result->bits32 = other->getOption(Scan::BITS32);
  result->loopCalLine = other->getOption(Scan::LOOPCALLINE);
  result->distSlave = other->getOption(Scan::DISTSLAVE);
  result->debug = other->getOption(Scan::DEBUG);
  result->tim = other->getOption(Scan::TIM);
  result->nth = other->getOption(Scan::NTH);
  result->nth_rem = other->getOption(Scan::NTH_REM);
  result->enableDataMode = other->getOption(Scan::ENABLE_DATA_MODE);
  result->ccode = other->getOption(Scan::USE_CCODE);
  result->ope = other->getOption(Scan::OPE);

  //result->scanNumber= (other->scanNumber);
  //result->runNumber = (other->runNumber ); 
  //result->groupLists= (other->groupLists); 
  //result->m_maxGroup= (other->m_maxGroup); 

#if !USE_CONST_SCAN
  result->startTime = other->getStartTime();
  result->endTime = other->getEndTime();
#endif

  std::cout << "Finishing ScanDefImpl::clone ... " << std::endl;
  return result;
}

void ScanDefImpl::configure(unsigned short type, float start, float stop, float step)
{
  scanVariable = type;

  // Add 1 to be inclusive of the stop point, extra 0.1% (over kill) for floating point error 
  int npoints = int(((stop - start) / step) + 1.001);

  scanPoints.resize(npoints);

  for(int i=0; i<npoints; i++) {
    FLOAT32 point = start + i * step;
    scanPoints[i] = point;
  }

  if(allTrigsSame) {
    // Default to 0
    int newNTrig = trigPoints.size() > 0?trigPoints[0]:0;
    trigPoints.resize(std::max(1U, scanPoints.size()), newNTrig);
  }
}

void ScanDefImpl::configure2(unsigned short type, float start, float stop, float step)
{
  scanVariable2 = type;

  int npoints = int(((stop - start) / step) + 1.001);

  scanPoints2.resize(npoints);

  for(int i=0; i<npoints; i++) {
    FLOAT32 point = start + i * step; 
    scanPoints2[i] = point;
  }
}

const boost::shared_ptr< ::SctApi::Trigger> ScanDefImpl::getTrigger1() const
{
  return trigSequence;
}

const boost::shared_ptr< ::SctApi::Trigger> ScanDefImpl::getTrigger2() const
{
  return trigSequence2;
}

boost::shared_ptr< ::SctApi::Trigger> ScanDefImpl::getTrigger1()
{
  return trigSequence;
}

boost::shared_ptr< ::SctApi::Trigger> ScanDefImpl::getTrigger2()
{
  return trigSequence2;
}

void ScanDefImpl::setTrigger1(boost::shared_ptr< ::SctApi::Trigger> trigger)
{
  trigSequence = trigger;

//   trigSequence = TriggerImpl::clone(trigger); // dynamic_cast< ::SctApi::TriggerImpl *>(trigger);
//   trigSequence.copy(*trigger);
}

void ScanDefImpl::setTrigger2(boost::shared_ptr< ::SctApi::Trigger> trigger)
{
  trigSequence2 = trigger;

//   trigSequence2 = TriggerImpl::clone(trigger); // dynamic_cast< ::SctApi::TriggerImpl *>(trigger);
//   trigSequence2.copy(*trigger);
}

void ScanDefImpl::setScanVariable1(unsigned short var)
{
  scanVariable = var;
}

void ScanDefImpl::setScanVariable2(unsigned short var)
{
  scanVariable2 = var;
}

unsigned short ScanDefImpl::getScanVariable1() const
{
  return scanVariable;
}

unsigned short ScanDefImpl::getScanVariable2() const
{
  return scanVariable2;
}

void ScanDefImpl::setNTrigs(unsigned long nTrigs) 
{
  trigPoints.resize(std::max(1U, scanPoints.size()));

  for(unsigned int i=0; i<trigPoints.size(); i++) {
    trigPoints[i] = nTrigs;
  }

  allTrigsSame = true;
}

unsigned long ScanDefImpl::getNTrigs() const
{
  if(trigPoints.size() > 0) {
    return trigPoints[0];
  } else {
    return 0;
  }
}

const ::SctApi::Scan::TrigPoints ScanDefImpl::getVariableTrigs() const
{
  return trigPoints;
}

void ScanDefImpl::setVariableTrigs(const TrigPoints &trigs)
{
  allTrigsSame = false;
  trigPoints = trigs;
}

void ScanDefImpl::setVariableTrigRange(unsigned short start, unsigned short end, unsigned long value)
{
  allTrigsSame = false;
  for(int i=start; i<=end; i++) 
    trigPoints[i] = value;
}

const ::SctApi::Scan::ScanPoints ScanDefImpl::getScanPoints1() const
{
  return scanPoints;
}

const ::SctApi::Scan::ScanPoints ScanDefImpl::getScanPoints2() const
{
  return scanPoints2;
}

void ScanDefImpl::setScanPoints1(const ScanPoints &scans)
{
  scanPoints = scans;

  if(allTrigsSame) {
    // Default to 0
    int newNTrig = trigPoints.size() > 0?trigPoints[0]:0;
    trigPoints.resize(std::max(1U, scanPoints.size()), newNTrig);
  }
}

void ScanDefImpl::setScanPoints2(const ScanPoints &scans)
{
  scanPoints2 = scans;
}

int ScanDefImpl::getOption(enum ScanOptions opt) const
{
  switch(opt) {
  case FULL:
    return full;
  case BITS32:
    return bits32;
  case LOOPCALLINE:
    return loopCalLine;
  case DISTSLAVE:
    return distSlave;
  case DEBUG:
    return debug;
  case TIM:
    return tim;
  case NTH:
    return nth;
  case NTH_REM:
    return nth_rem;
  case ENABLE_DATA_MODE:
    return enableDataMode;
  case USE_CCODE:
    return ccode;
  case OPE:
    return ope;    
  default:
    return 0;
  }
}

void ScanDefImpl::setOption(enum ScanOptions opt, int option) 
{
  switch(opt) {
  case FULL:
    full = option;
    break;
  case BITS32:
    bits32 = option;
    break;
  case LOOPCALLINE:
    loopCalLine = option;
    break;
  case DISTSLAVE:
    distSlave = option;
    break;
  case DEBUG:
    debug = option;
    break;
  case TIM:
    tim = option;
    break;
  case NTH:
    nth = option;
    break;
  case NTH_REM:
    nth_rem = option;
    break;
  case ENABLE_DATA_MODE:
    enableDataMode = option;
    break;
  case USE_CCODE:
    ccode = option;
    break;
  case OPE:
    ope = option;
    break;
  }
}

std::string ScanDefImpl::print() const {
  std::ostringstream oss;
  oss << "Scan\n";
  oss << "Run: " << getRunNumber() << " Scan: " << getScanNumber() << "\n";

  if(allTrigsSame) {
    oss << getNTrigs() << " triggers per scan point\n";

    TrigPoints points = getVariableTrigs();


    if (points.empty()){
      oss << "Trigger count array empty\n";
    }else{
      unsigned int initVal = points[0];
      
      for(TrigPoints::const_iterator iter = points.begin();
      iter != points.end();
      iter++) {
    if(*iter != initVal) oss << " Trigger count array not constant\n";
      }
    }

    if(points.size() != getScanPoints1().size()) {
      oss << " Trigger count array not the same size as scan point array!!!\n";
    }

  } else {
    oss << "Triggers per scan point:\n";

    TrigPoints points = getVariableTrigs();

    int i=0;
    for(TrigPoints::const_iterator iter = points.begin();
        iter != points.end();
        i++, iter++) {
      if(i && (i%20 == 0)) oss << "\n";
      oss.width(4);

      oss << *iter << " ";
    }
    oss << "\n";
  }

  oss << "Binning mode " << (getOption(Scan::FULL)?"full":"condensed") << "\n";
  oss << "Bin size " << (getOption(Scan::BITS32)?"32bit":"16bit") << "\n";
  oss << "Cal line loop " << (getOption(Scan::LOOPCALLINE)?"yes":"no") << "\n";
  oss << "Use TIM for triggers (synchronous) " << (getOption(Scan::TIM)?"yes":"no") << "\n";
  oss << "Put module into dataTakingMode during configure (usually yes): " << (getOption(Scan::ENABLE_DATA_MODE)?"yes":"no") << "\n";
  oss << "Histogramming task=" << (getOption(Scan::USE_CCODE)?"ccode":"assembly") << "\n";
  oss << "OPE=" << (getOption(Scan::OPE)?"yes":"no") << "\n";
  oss << "Slave DSPs: ";
  switch(getOption(Scan::DISTSLAVE)) {
  case 0: 
    {
      oss << "All to Slave 0";
      if(getOption(Scan::NTH) > 1) {
        oss << ": Capture trigger%" << getOption(Scan::NTH) << "==" << getOption(Scan::NTH_REM);
      }
      break;
    }
  case 1: oss << "According to groups"; break;
  case 2: 
    {
      oss << "Router distribution";
      if(getOption(Scan::NTH) > 1) {
        oss << ": Capture trigger%" << getOption(Scan::NTH) << "==" << getOption(Scan::NTH_REM);
      }
      break;
    }
  default: oss << "Invalid type!"; break;
  }
  oss << "\n";

  if(getOption(Scan::DEBUG)) {
    oss << "In debug mode\n";
  }

  if(getScanPoints2().size() > 0) {
    oss << "Module set 0\n";
  } else {
    oss << "Scan parameters\n";
  }

  oss << "Scan over variable number " << getScanVariable1() << "\n";

  oss << getScanPoints1().size() << " scan points:\n";
  int i=0;

  std::vector<FLOAT32> points = getScanPoints1();

  for(std::vector<FLOAT32>::const_iterator iter=points.begin();
      iter != points.end();
      i++, iter++) {
    if(i && (i%20 == 0)) oss << "\n";
    oss.width(4);

    oss << *iter << " ";
  }
  oss << "\n";

  oss << "Trigger:\n";

  oss << getTrigger1()->print();

  if(getScanPoints2().size() > 0) {
    oss << "Module set 1\n";

    oss << "Scan over variable number " << getScanVariable2() << "\n";

    oss << getScanPoints2().size() << " scan points:\n";
    int i=0;

    std::vector<FLOAT32> points2 = getScanPoints2();

    for(std::vector<FLOAT32>::const_iterator iter=points2.begin();
        iter != points2.end();
        i++, iter++) {
      if(i && (i%20 == 0)) oss << "\n";
      oss.width(4);

      oss << *iter << " ";
    }
    oss << "\n";

    oss << "Trigger2:\n";

    oss << getTrigger2()->print();
  } else {
    oss << "Second trigger not defined\n";
  }

#if !USE_CONST_SCAN
  for(int i=0; i<4; i++) {
    oss << "Modules in group " << i << "\n";

    ModuleList groupList = getModuleList(i);

    for(ModuleList::const_iterator iter = groupList.begin();
        iter != groupList.end();
        iter++) {
      oss << " [" << *iter << "]\n";
    }
  }
#endif
  return oss.str();
}


void ScanDefImpl::setScanNumber(unsigned int scan) 
{
  scanNumber = scan;
}
 
unsigned int ScanDefImpl::getScanNumber() const 
{
  return scanNumber;
}

void ScanDefImpl::setRunNumber(unsigned int run)
{
  runNumber = run;
}

unsigned int ScanDefImpl::getRunNumber() const 
{
  return runNumber;
}

#if USE_CONST_SCAN
#define ScanDefImpl ScanEx
#endif

std::list<std::string> ScanDefImpl::getModuleList(unsigned int group) const 
{
  std::list<std::string> result;

  if(group<groupLists.size()) {
    result = groupLists[group];
  }

  return result;
}
 
void ScanDefImpl::setModuleList(unsigned int group, const ::SctApi::ModuleList & newList)
{
  if(group+1 > groupLists.size()) {
    groupLists.resize(group + 1);
  }
  groupLists[group] = newList;
}

unsigned int ScanDefImpl::getNGroups() const
{
  return m_maxGroup;
}

void ScanDefImpl::setNGroups(unsigned int val)
{
  m_maxGroup = val;
}

#if USE_CONST_SCAN
#undef ScanDefImpl
#endif

std::string TriggerImpl::print() const 
{
  std::ostringstream oss;
  Trigger::RODTriggers trigs = getRODTriggers(0);

  oss << "Printing trigger: length " << trigs.size() << "\n";

  unsigned short trigData, trigCmd;
  getCommIncr(trigData, trigCmd);

  for(unsigned int i = 0; i < trigs.size(); i++) {
    oss.width(4); 
    oss << getNameOfRODTrigger(trigs[i]);
    if(trigData != 0 && trigCmd == i) {
      oss << "+" << trigData;
    }
    oss << "\n";
  }
  oss << "Trigger OK for ROD:" << (isValidRODTrigger()?"Y":"N") 
      << "\tOK for TIM:" << (isValidTIMTrigger()?"Y":"N") << "\n";
  oss << "Trigger Frequency:" << getFrequency() << " kHz, Source:" << getSource();
  oss << " Random:" << getRandom();
  oss << "\n";
  oss << "Trigger: TIM needs sequencer? " << (timNeedsSequencer()?"Y":"N") << "\n";
  return oss.str();
}

#if USE_CONST_SCAN
#define ScanDefImpl ScanEx
#endif

ptime ScanDefImpl::getStartTime() const {
    return startTime;
}

void ScanDefImpl::setStartTime(ptime t) {
    startTime = t;
}
  
ptime ScanDefImpl::getEndTime() const {
    return endTime;
}

void ScanDefImpl::setEndTime(ptime t) {
    endTime = t;
}

#if USE_CONST_SCAN
#undef ScanDefImpl
#endif

bool RodLabel::operator==(const RodLabel &rhs) const {
  return partition == rhs.partition && crate == rhs.crate && rod == rhs.rod;
}

bool RodLabel::operator!=(const RodLabel &rhs) const {
  return !(*this == rhs);
}

bool RodLabel::operator<(const RodLabel &rhs) const {
  if(partition < rhs.partition) return true;
  if(partition > rhs.partition) return false;
  if(crate < rhs.crate) return true;
  if(crate > rhs.crate) return false;
  if(rod < rhs.rod) return true;

  return false;
}


bool CrateLabel::operator==(const CrateLabel &rhs) const {
  return partition == rhs.partition && crate == rhs.crate;
}

bool CrateLabel::operator<(const CrateLabel &rhs) const {
  if(partition < rhs.partition) return true;
  if(partition > rhs.partition) return false;
  if(crate < rhs.crate) return true;

  return false;
}

---