roclib/src_nxyter/FebUtil.cxx (r4864/r4162)

Go to the documentation of this file.

//============================================================================
//============================================================================

#include "nxyter/FebUtil.h"

#include <stdlib.h>
#include <stdio.h>
#include <sys/time.h>
#include <time.h>

#include <stdexcept>
#include <memory>

#include "base/Gpio.h"
#include "nxyter/RocNx.h"
#include "nxyter/NxContext.h"
#include "nxyter/DistFuncArray.h"

//----------------------------------------------------------------------------

nxyter::FebUtil::FebUtil(FebBase* feb, QuickDaq* qdaq) :
  fFeb(feb),
  fQdaq(qdaq),
  fLoopState(kLoopStopped),
  fStartLoopTime(0.),
  fTestLoopTime(0.),
  fTestTime(0.),
  fLoopCount(0)
{
}

//----------------------------------------------------------------------------

nxyter::FebUtil::~FebUtil()
{
}

//----------------------------------------------------------------------------

void nxyter::FebUtil::startLoop(double time)
{
  fLoopState = kLoopRunning;
  fStartLoopTime = now();
  fTestTime = time;
  fLoopCount = 0;
}

//----------------------------------------------------------------------------

void nxyter::FebUtil::interruptLoop() 
{ 
  if (fLoopState == kLoopRunning) fLoopState = kLoopInterrupted;
}

//----------------------------------------------------------------------------

void nxyter::FebUtil::stopLoop() 
{ 
  if (fLoopState == kLoopRunning) fLoopState = kLoopStopped;
}

//----------------------------------------------------------------------------

bool nxyter::FebUtil::testLoop()
{
  if (fLoopState != kLoopRunning) return false;  
  fTestLoopTime = now();
  if (fLoopCount>0 &&                       // if not first iteration and
      fTestTime>0. &&                       // finite time chosen check time
      fTestLoopTime > fStartLoopTime + fTestTime) return false;
  fLoopCount++;
  return true;
}

//----------------------------------------------------------------------------

int nxyter::FebUtil::saveFeb(nxyter::NxContext cntx[4], int domask)
{
  if (fFeb==0) return -1;

  int rc;
  for (int i=0; i<fFeb->numNx(); i++) {
    if (fFeb->getNxOffline(i)) continue;    // skip if offline
    rc = fFeb->nx(i).i2c().getContext(cntx[i], domask);
    if (rc) return rc;
  }
  return 0;
}

//----------------------------------------------------------------------------

int nxyter::FebUtil::restoreFeb(nxyter::NxContext cntx[4], int domask)
{
  if (fFeb==0) return -1;

  int rc;
  for (int i=0; i<fFeb->numNx(); i++) {
    if (fFeb->getNxOffline(i)) continue;    // skip if offline
    rc = fFeb->nx(i).i2c().setContext(cntx[i], domask, true);
    if (rc) return rc;
  }
  return 0;
}

//----------------------------------------------------------------------------

int nxyter::FebUtil::acquireTestTriggerData(int nxind, int npuls, 
                                            DistFuncArray& dfa, bool cleardist)
{  
  if (fFeb==0 || fQdaq==0) return -1;

  base::Gpio     gpio(fFeb->getBoard());
  nxyter::RocNx rocnx(fFeb->getBoard());

  int nxnum   = fFeb->nx(nxind).getNxNumber();
  double time = double(npuls) / 2500.;      // FIXME: is that safe ??

  if (cleardist) dfa.clear();

  rocnx.fireTestPulse(0,0,0);               // FIXME: rc; ensure that pulser off

  uint32_t save_gpiomask;
  gpio.getConfig(save_gpiomask);            // FIXME: retcode
  uint32_t new_gpiomask = save_gpiomask;
  gpio.packConfig(new_gpiomask, 6, false, false, false, true, true);
  gpio.setConfig(new_gpiomask);             // FIXME: retcode

  fQdaq->nextRunNxMask(1<<nxnum);
  fQdaq->startRun(0, time);

  rocnx.fireTestPulse(100000,50000,npuls);   // FIXME: rc; fire pulser 2.5 KHz

  while(fQdaq->testRun()) {
    roc::Message& msg = fQdaq->msg();
    
    if (msg.isHitMsg()) {
      int num = msg.getNxNumber();
      if (num == nxnum) {
        int cha = msg.getNxChNum();
        int adc = msg.getNxAdcValue();
        dfa.addEntry(cha, float(adc));
      }
    }
  }

  if (fQdaq->stats().errorCount()) {
    fQdaq->stats().print(std::cout, 0., nxyter::QuickDaqStats::kPrintError);
  }

  gpio.setConfig(save_gpiomask);            // FIXME: retcode

  return 0;
}

//----------------------------------------------------------------------------

int nxyter::FebUtil::acquireTestTriggerData(int nxind, int npuls, 
                                            NxDataSummary& nds)
{
  DistFuncArray dfa(128, npuls);
  dfa.setMaxEntries(2*npuls);
  int rc = acquireTestTriggerData(nxind, npuls, dfa);
  nds.analyse(dfa);
  return rc;
}

//----------------------------------------------------------------------------

int nxyter::FebUtil::acquireTestPulserData(int nxind, const nxyter::NxContext& cntx,
                                           int npuls, DistFuncArray& dfa)
{
  if (fFeb==0 || fQdaq==0) return -1;

  int rc;
  uint8_t conf1;
  rc = fFeb->nx(nxind).i2c().getRegister(kNxRegConfig1, conf1);
  if (rc) return rc;

  for (int csel=0; csel<=3; csel++) {
    NxContext cntx_run(cntx);

    // mask off all channels not covered by current csel
    for (int ch=0; ch<128; ch++) {
      if ((ch & 0x3) != csel) cntx_run.setChannelMaskBit(ch, true);
    }
    // no readback verification here to save the test trigger mode jojo
    // each time here. If there a comm problems, they also show elsewhere...
    rc = fFeb->nx(nxind).i2c().setContext(cntx_run, nxyter::kDoMask, false);
    if (rc) return rc;

    // now set csel in conf1
    conf1 &= ~kNxC1CalibSelectMask;
    conf1 |= uint8_t(csel);
    rc = fFeb->nx(nxind).i2c().setRegister(kNxRegConfig1, conf1, true);
    if (rc) return rc;

    rc = acquireTestTriggerData(nxind, npuls, dfa, csel==0);
    if (rc) return rc;
  }

  return 0;
}

//----------------------------------------------------------------------------

int nxyter::FebUtil::acquireTestPulserData(int nxind, const nxyter::NxContext& cntx,
                                           int npuls, NxDataSummary& nds)
{
  DistFuncArray dfa(128, npuls);
  dfa.setMaxEntries(20*npuls);
  int rc = acquireTestPulserData(nxind, cntx, npuls, dfa);
  nds.analyse(dfa);
  return rc;
}

//----------------------------------------------------------------------------

int nxyter::FebUtil::testNxControlPath(int nxind, double time)
{
  if (fFeb == 0) return -1;
  int errcnt = 0;
  startLoop(time);
  while(testLoop()) {
    int rc = fFeb->nx(nxind).i2c().probe();
    if (rc) {
      errcnt++;
      std::cout << errcnt << ":" << base::Board::operErrToString(rc) << std::endl;
    }
  }
  return errcnt;
}

//----------------------------------------------------------------------------

int nxyter::FebUtil::testNxRegisters(int nxind)
{
  if (fFeb == 0) return -1;
  int errcnt = 0;

  int rc;
  nxyter::NxContext cntx_save;

  rc = fFeb->nx(nxind).i2c().getContext(cntx_save, kDoAll);
  if (rc) {
    errcnt++;
    std::cout << errcnt << ": getContext({save}): "
         << base::Board::operErrToString(rc) << std::endl;
  }

  startLoop(0.);

  // part 1: mask and core registers, except configuration regs
  static const uint8_t reglist[] = 
    {  0,  1,  2,  3,  4,  5,  6,  7,       // masks
       8,  9, 10, 11, 12, 13, 14, 15,       // "
      16, 17, 18, 19, 20, 21, 22, 23,       // daq regs
      24, 25, 26, 27, 28, 29,               // "
      38, 39, 43, 44, 45                    // delay regs
    };
  static const int dim_reglist = sizeof(reglist)/sizeof(reglist[0]);
  
  static const uint8_t vallist[] =
    {0x00, 0xff,                                     // all 0, all 1
     0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, // 1 bit up
     0xaa, 0x55,                                     // 1010..., 0101...
     0xcc, 0x33, 0x66,                               // 1100..., 0011..., 0110..
     0x0f, 0xf0                                      // 00001111, 11110000
    };
  static const int dim_vallist = sizeof(vallist)/sizeof(vallist[0]);

  // loop over all test patterns
  for (int itest=0; itest<dim_vallist; itest++) {
    if (!testLoop()) break;

    // write all regs with test patters cyclic
    // this way all regs see all patterns, but regs have different values
    for (int ireg=0; ireg<dim_reglist; ireg++) {
      uint8_t reg = reglist[ireg];
      uint8_t val = vallist[(ireg+itest)%dim_vallist];
      rc = fFeb->nx(nxind).i2c().setRegister(reg, val, true);
      if (rc) {
        errcnt++;
        std::cout << errcnt << ": setRegister(" << uint32_t(reg)
             << "," << std::hex << uint32_t(val) << std::dec << ") : "
             << base::Board::operErrToString(rc) << std::endl;
      }
    }

    // read all regs check for proper values
    for (int ireg=0; ireg<dim_reglist; ireg++) {
      uint8_t reg = reglist[ireg];
      uint8_t valexp = vallist[(ireg+itest)%dim_vallist];
      uint8_t val;
      rc = fFeb->nx(nxind).i2c().getRegister(reg, val);
      if (rc) {
        errcnt++;
        std::cout << errcnt << ": getRegister(" << uint32_t(reg)
             << "," << std::hex << uint32_t(val) << std::dec << ") : "
             << base::Board::operErrToString(rc) << std::endl;
      }
      if (val != valexp) {
        errcnt++;
        std::cout << errcnt << ": getRegister(" << uint32_t(reg) << ") : "
             << " found: " << std::hex << uint32_t(val)
             << " expect: " << uint32_t(valexp)
             << std::dec << std::endl;
      }
    }
  }
       
  // part 2: configuration regs
  for (int reg=kNxRegConfig0; reg<=kNxRegConfig1; reg++) {
    if (!testLoop()) break;

    uint8_t valold;
    fFeb->nx(nxind).i2c().getRegister(reg, valold);

    for (int ival=0; ival<dim_vallist; ival++) {
      uint8_t val = vallist[(reg+ival)%dim_vallist];

      rc = fFeb->nx(nxind).i2c().setRegister(reg, val, true);
      if (rc) {
        errcnt++;
        std::cout << errcnt << ": setRegister(" << uint32_t(reg)
             << "," << std::hex << uint32_t(val) << std::dec << ") : "
             << base::Board::operErrToString(rc) << std::endl;
      }

      uint8_t valget;
      rc = fFeb->nx(nxind).i2c().getRegister(reg, valget);
      if (rc) {
        errcnt++;
        std::cout << errcnt << ": getRegister(" << uint32_t(reg)
             << "," << std::hex << uint32_t(val) << std::dec << ") : "
             << base::Board::operErrToString(rc) << std::endl;
      }

      if (valget != val) {
        errcnt++;
        std::cout << errcnt << ": getRegister(" << uint32_t(reg) << ") : "
             << " found: " << std::hex << uint32_t(valget)
             << " expect: " << uint32_t(val)
             << std::dec << std::endl;
      }

    }

    fFeb->nx(nxind).i2c().setRegister(reg, valold);
  }

  // part 3: trim registers
  nxyter::NxContext cntx_set;
  nxyter::NxContext cntx_get;

  static const uint8_t val5list[] =
    {0x00, 0x1f,                                     // all 0, all 1
     0x01, 0x02, 0x04, 0x08, 0x10,                   // 1 bit up
     0x15, 0x0a,                                     // 10101, 01010
     0x19, 0x0d, 0x06                                // 11001, 01101, 00110
    };
  static const int dim_val5list = sizeof(val5list)/sizeof(val5list[0]);
 
  for (int itest=0; itest<dim_val5list; itest++) {
    if (!testLoop()) break;

    for (int cha=0; cha<129; cha++) {
      uint8_t val = val5list[(cha+itest)%dim_val5list];
      cntx_set.setPowerOffMaskBit(cha, true);
      cntx_set.setThresholdTrim(cha, val);
    }

    rc = fFeb->nx(nxind).i2c().setContext(cntx_set, kDoTrim, false);
    if (rc) {
      errcnt++;
      std::cout << errcnt << ": setContext(,kDoTrim {trim check}): "
           << base::Board::operErrToString(rc) << std::endl;
    }
    rc = fFeb->nx(nxind).i2c().getContext(cntx_get, kDoTrim);
    if (rc) {
      errcnt++;
      std::cout << errcnt << ": getContext(,kDoTrim {trim check}): "
           << base::Board::operErrToString(rc) << std::endl;
    }

    int errtest = 0;
    for (int cha=0; cha<129; cha++) {
      uint8_t valexp = val5list[(cha+itest)%dim_val5list];
      uint8_t val = cntx_get.getThresholdTrim(cha);
      if (val != valexp) {
        errcnt++;
        errtest++;
        std::cout << errcnt << ": trim(" << cha << ") : "
             << " found: " << std::hex << uint32_t(val)
             << " expect: " << uint32_t(valexp)
             << std::dec << std::endl;
      }
    }

    if (errtest++) {
      std::cout << "--- set values for trim-daq test " << itest  << std::endl;
      cntx_set.print(std::cout, kDoTrim);
      std::cout << "--- get values for trim-daq test" << std::endl;
      cntx_get.print(std::cout, kDoTrim);
    }
  }
  
  // part 4: power-down registers
  // uses (cha/n)%2 ==0 or ==1 patterns for n=1,2,4,8,16,32,64,128,256

  for (int itest=0; itest<18; itest++) {
    if (!testLoop()) break;

    int ibit = itest%2;
    int idiv = 1<<(itest/2);
    for (int cha=0; cha<129; cha++) {
      bool val = (cha/idiv)%2 == ibit;
      cntx_set.setPowerOffMaskBit(cha, val);
      cntx_set.setThresholdTrim(cha, 16);
    }
    rc = fFeb->nx(nxind).i2c().setContext(cntx_set, kDoTrim, false);
    if (rc) {
      errcnt++;
      std::cout << errcnt << ": setContext(,kDoTrim {poff check}): "
           << base::Board::operErrToString(rc) << std::endl;
    }
    rc = fFeb->nx(nxind).i2c().getContext(cntx_get, kDoTrim);
    if (rc) {
      errcnt++;
      std::cout << errcnt << ": getContext(,kDoTrim {poff check}): "
           << base::Board::operErrToString(rc) << std::endl;
    }
  
    int errtest = 0;
    for (int cha=0; cha<129; cha++) {
      bool valexp = (cha/idiv)%2 == ibit;
      bool val = cntx_get.getPowerOffMaskBit(cha);
      if (val != valexp) {
        errcnt++;
        errtest++;
        std::cout << errcnt << ": power(" << cha << ") : "
             << " found: "  << val
             << " expect: " << valexp
             << std::dec << std::endl;
      }
    }
    if (errtest++) {
      std::cout << "--- set values for power-down test with ibit=" << ibit
           << " idiv=" << idiv << std::endl;
      cntx_set.print(std::cout, kDoTrim);
      std::cout << "--- get values for power-down test" << std::endl;
      cntx_get.print(std::cout, kDoTrim);
    }
  }

  rc = fFeb->nx(nxind).i2c().setContext(cntx_save, kDoAll);
  if (rc) {
    errcnt++;
    std::cout << errcnt << ": setContext({restore}): "
         << base::Board::operErrToString(rc) << std::endl;
  }

  return errcnt;
}

//----------------------------------------------------------------------------

int nxyter::FebUtil::testMainAdcControlPath(double time)
{
  if (fFeb == 0) return -1;
  int errcnt = 0;
  startLoop(time);
  while(testLoop()) {
    int rc = fFeb->adc().probe();
    if (rc) {
      errcnt++;
      std::cout << errcnt << ":" << base::Board::operErrToString(rc) << std::endl;
    }
  }
  return errcnt;
}

//----------------------------------------------------------------------------

int nxyter::FebUtil::testMainAdcDataPath(double time)
{
  if (fFeb == 0) return -1;
  int errcnt = 0;
  startLoop(time);
  int rc;
  // set all adc channels to test pattern mode
             rc = fFeb->adc().setTestMode(0, 8);
  if (rc==0) rc = fFeb->adc().setTestMode(1, 8);
  if (rc==0) rc = fFeb->adc().setTestMode(2, 8);
  if (rc==0) rc = fFeb->adc().setTestMode(3, 8);
  if (rc) {
    std::cout << "failed to set test pattern mode for ADC: "
         << base::Board::operErrToString(rc) << std::endl;
    std::cout << "Abort test because startup failed..." << std::endl;
    return 1;
  }

  uint16_t adcpatt = 0;
  int chmax = 2;
  
  while(testLoop()) {
     fFeb->adc().setUserPattern(adcpatt);
     for (int ch=0; ch<chmax; ch++) {
        uint32_t val;
        rc = fFeb->adc().getAdcDirect(ch, val);
        if (rc) {
           std::cout << errcnt << ": adc().getAdcDirect(): "
                 << base::Board::operErrToString(rc) << std::endl;
           errcnt++;;
        }
        if ((uint16_t) val != adcpatt) {

           char sbuf[100];
           snprintf(sbuf, sizeof(sbuf),
                   "%d: mismatch for adc chan=%d: found=0x%03x, expected 0x%03x",
                    errcnt, ch, (unsigned) val, (unsigned) adcpatt);

           std::cout << sbuf << std::endl;
           errcnt++;
        }
     }
     adcpatt = (adcpatt+1) & 0x0fff;
  }

  // reset all adc channels to normal mode
             rc = fFeb->adc().setTestMode(0, 0);
  if (rc==0) rc = fFeb->adc().setTestMode(1, 0);
  if (rc==0) rc = fFeb->adc().setTestMode(2, 0);
  if (rc==0) rc = fFeb->adc().setTestMode(3, 0);
  if (rc) {
    std::cout << "failed to restore ADC default settings: "
         << base::Board::operErrToString(rc) << std::endl;
    errcnt++;
  }

  return errcnt;
}

//----------------------------------------------------------------------------

int nxyter::FebUtil::testFebControlPathCombo(double time)
{
  if (fFeb == 0) return -1;

  nxyter::NxContext cntx_save[4];
  nxyter::NxContext cntx_test[4];
  int errcnt = 0;
  int numnx = fFeb->numNx();

  int nxreg [] = {0,1, 2, 3, 4, 5, 6, 7,    // all mask regs
                  8,9,10,11,12,13,14,15,
                  kNxRegcal,                // 2 daq regs
                  kNxRegiTWC,
                  kNxRegdelayTestPuls,      // 2 delay regs
                  kNxRegdelayTestTrig
  };      

  const static int dim_nxreg = sizeof(nxreg)/sizeof(int);

  uint8_t testpatt[4][dim_nxreg];

  // save nx mask+core register set
  for (int i=0; i<numnx; i++) {
    int rc = fFeb->nx(i).i2c().getContext(cntx_save[i], 
                                          nxyter::kDoMask|nxyter::kDoCore);
    if (rc) {
      std::cout << "failed to save context for nxind=" << i << " :"
           << base::Board::operErrToString(rc) << std::endl;
      errcnt++;
    }
  }

  if (errcnt) {
    std::cout << "Abort test because startup failed..." << std::endl;
    return errcnt;
  }

  startLoop(time);
  while(testLoop()) {
    int rc;
    
    for (int i=0; i<numnx; i++) {
      cntx_test[i] = cntx_save[i];
      for (int j=0; j<dim_nxreg; j++) {
        testpatt[i][j] = (random()>>22) & 0xff; // take bits 22 to 29
        cntx_test[i].setRegister(nxreg[j], testpatt[i][j]);
      }
      rc = fFeb->nx(i).i2c().setContext(cntx_test[i], 
                                        nxyter::kDoMask|nxyter::kDoCore);
      if (rc) {
        std::cout << errcnt << ":setContext() on " << i << " :"
             << base::Board::operErrToString(rc) << std::endl;
        errcnt++;
      }
    }

    for (int i=0; i<numnx; i++) {
      rc = fFeb->nx(i).i2c().getContext(cntx_test[i],
                                        nxyter::kDoMask|nxyter::kDoCore);
      if (rc) {
        std::cout << errcnt << ":getContext() on " << i << " :"
             << base::Board::operErrToString(rc) << std::endl;
        errcnt++;
      }
      for (int j=0; j<dim_nxreg; j++) {
        uint8_t val = cntx_test[i].getRegister(nxreg[j]);
        if (val != testpatt[i][j]) {
           char sbuf[200];
           snprintf(sbuf, sizeof(sbuf),
                   "%d: mismatch for nxind=%d,reg=%2d: found=0x%02x, expected 0x%02x",
                    errcnt, i, nxreg[j], (unsigned) val, (unsigned) testpatt[i][j]);
           std::cout << sbuf << std::endl;
           errcnt++;
        }
      }
    }    
  }

  // restore nx mask+core register set
  for (int i=0; i<numnx; i++) {
    int rc = fFeb->nx(i).i2c().setContext(cntx_save[i],
                                          nxyter::kDoMask|nxyter::kDoCore);
    if (rc) {
      std::cout << "failed to restore context for nxind=" << i << " :"
           << base::Board::operErrToString(rc) << std::endl;
      errcnt++;
    }
  }

  return errcnt;
}

//----------------------------------------------------------------------------

void nxyter::FebUtil::probe(base::Board* board, bool verbose, std::ostream& os)
{
  bool nxok[2][128];
  bool adcok[2];
  
  if (verbose) os << "Detailed probe() return codes:" << std::endl;

  for (int port=0; port<=1; port++) {
    nxyter::MainAdc adc(board, port);
    int rc = adc.probe();
    adcok[port] = (rc==0);
    if (verbose) {
       char sbuf[1000];
       snprintf(sbuf, sizeof(sbuf),
                "  adc %2d    : rc = %4d,%2d -> %s",
                 port, base::Board::operErrIndex(rc),
                 base::Board::operErrCode(rc),
                 base::Board::operErrCodeName(rc));

       os << sbuf << std::endl;
    }

    for (int addr=2; addr<=126; addr+=2) {
      nxyter::NxI2c nx(board, port, addr);
      rc = nx.probe();
      nxok[port][addr] = (rc==0);
      if (verbose) {
         char sbuf[1000];
         snprintf(sbuf, sizeof(sbuf),
                   "   nx  %2d,%3d: rc = %4d,%2d -> %s",
                   port, addr , base::Board::operErrIndex(rc),
                   base::Board::operErrCode(rc),
                   base::Board::operErrCodeName(rc));
         os << sbuf << std::endl;
      }
    }
  }

  os << "Full MainAdc.probe() and NxI2c::probe() scan found:" << std::endl;
  os << "  port adc ----- nx i2c slave address in range 2,..,126, only even -------" << std::endl;
  os << "           ";
  for (int addr=2; addr<=126; addr+=2) os << ( (addr>=100)?"1":" " );
  os << std::endl;
  os << "           ";
  for (int addr=2; addr<=126; addr+=2) os << ((addr/10)%10);
  os << std::endl;
  os << "           ";
  for (int addr=2; addr<=126; addr+=2) os << (addr%10);
  os << std::endl;

  for (int port=0; port<=1; port++) {
     os << "    " << port << "   " << (adcok[port]?"y":"-") << "  ";
     for (int addr=2; addr<=126; addr+=2) os << (nxok[port][addr] ? "y" : "-");
     os << std::endl;
  }

  int ftyps[2], ftypl[2];
  FebBase::discoverFebs(board, ftyps[0], ftyps[1]);
  FebBase::discoverFebs(board, ftypl[0], ftypl[1], true);

  os << "Autoconfigure with FebBase::discoverFebs() found:" << std::endl;
  for (int port=0; port<=1; port++) {
     os << "  port " << port << " : ";
     if (ftyps[port]==0 && ftypl[port]==0) {
        os << "nothing";
     } else if (ftyps[port] == ftypl[port]) {
        os << FebBase::typeToString(ftyps[port]);
     } else {
        if (ftyps[port])
           os << FebBase::typeToString(ftyps[port])
        << " (strict mode)";
        if (ftypl[port])
           os << FebBase::typeToString(ftypl[port])
        << " (liberal mode, some nx missing)";
     }
     os << std::endl;
  }
}

//----------------------------------------------------------------------------

double nxyter::FebUtil::now()
{
  struct timeval tv;
  gettimeofday(&tv, 0);
  return double(tv.tv_sec) + 1.e-6*double(tv.tv_usec);
}

//----------------------------------------------------------------------------