CMap.cxx

Go to the documentation of this file.

// $Id: CMap.cxx,v 1.3 2008/10/10 20:41:33 jpaley Exp $
//
// cmap::CMap class source code
//
// \author $Author: jpaley $
//

#include "CMap/CMap.h"
#include "JobControl/Exception.h"
#include <string>
#include <iostream>

using namespace cmap;

FDCMap*   FDCMap::fInstance   = 0;
NDCMap*   NDCMap::fInstance   = 0;
IPNDCMap* IPNDCMap::fInstance = 0;

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

CMap::CMap(std::string& fname) : 
  db::Table(fname)
{

}

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

CMap::~CMap()
{

}

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

bool CMap::ChanToCell(int board_id, int chan_id, 
                      int& plane, int& cell)
{
  plane = board_id;
  cell = chan_id;
  return true;
}

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

bool CMap::CellToChan(int plane, int cell, 
                      int& board_id, int& chan_id)
{
  board_id = plane;
  chan_id = cell;
  return true;
}

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

bool CMap::ChanToCellException(int board_id, int chan_id, 
                               int& plane, int& cell)
{
  int bid, cid;

  // look for exceptions in the table... if found, set plane/cell 
  // according to table entries
  for (unsigned int i=0; i<this->size(); ++i) {
    dbi::Row& row = (*this)[i];
    row.Get(std::string("board_id"),bid);
    row.Get(std::string("chan_id"),cid);
    if (bid == board_id && cid == chan_id) {
      row.Get(std::string("plane"),plane);
      row.Get(std::string("cell"),cell);
      return true;
    }
  }

  return false;
}

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

bool CMap::CellToChanException(int plane, int cell,
                               int& board_id, int& chan_id)
{  
  int pl, ce;

  // look for exceptions in the table... if found, set plane/cell 
  // according to table entries
  for (unsigned int i=0; i<this->size(); ++i) {
    dbi::Row& row = (*this)[i];
    row.Get(std::string("plane"),pl);
    row.Get(std::string("cell"),ce);
    if (pl == plane && ce == cell) {
      row.Get(std::string("board_id"),board_id);
      row.Get(std::string("chan_id"),chan_id);
      return true;
    }
  }
  
  return false;
}

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

FDCMap::FDCMap(std::string& fname) : CMap(fname)
{

}

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

FDCMap::~FDCMap()
{

}

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

FDCMap& FDCMap::Instance(time_t& t)
{
  if (!fInstance) {
    std::string fname = "cmapfd.xml";
    fInstance = new FDCMap(fname);
  }
  
  if (t >= fInstance->MinTime() && 
      t <= fInstance->MaxTime()) return *fInstance;
  
  assert_jobc(!fInstance->Init(t), "Failed to initialize!");
  
  return *fInstance;
}

//----------------------------------------------------------------------
// For now we assume a 1-1 mapping, and that the board_id is actually the
// plane number, and the chan_id is the cell number

bool FDCMap::ChanToCell(int board_id, int chan_id,
                        int& plane, int& cell)
{
  if (fInstance->ChanToCellException(board_id, chan_id, plane, cell))
    return true;

  // if no exceptions were found, use algorithmic mapping
  plane = board_id;
  cell = chan_id;
  
  return true;
}

//----------------------------------------------------------------------
// For now we assume a 1-1 mapping, and that the board_id is actually the
// plane number, and the chan_id is the cell number

bool FDCMap::CellToChan(int plane, int cell,
                        int& board_id, int& chan_id)
{
  if (fInstance->CellToChanException(board_id, chan_id, plane, cell))
    return true;

  // if no exceptions were found, use algorithmic mapping
  board_id = plane;
  chan_id = cell;

  return true;
}

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

NDCMap::NDCMap(std::string& fname) : CMap(fname)
{

}

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

NDCMap::~NDCMap()
{

}

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

NDCMap& NDCMap::Instance(time_t& t)
{
  if (!fInstance) {
    std::string fname = "cmapnd.xml";
    fInstance = new NDCMap(fname);
  }
  
  if (t >= fInstance->MinTime() && 
      t <= fInstance->MaxTime()) return *fInstance;

  assert_jobc(!fInstance->Init(t), "Failed to initialize!");
  
  return *fInstance;
}

//----------------------------------------------------------------------
// For now we assume a 1-1 mapping, and that the board_id is actually the
// plane number, and the chan_id is the cell number

bool NDCMap::ChanToCell(int board_id, int chan_id,
                        int& plane, int& cell)
{
  if (fInstance->ChanToCellException(board_id, chan_id, plane, cell))
    return true;

  // if no exceptions were found, use algorithmic mapping
  plane = board_id;
  cell = chan_id;

  return true;
}

//----------------------------------------------------------------------
// For now we assume a 1-1 mapping, and that the board_id is actually the
// plane number, and the chan_id is the cell number

bool NDCMap::CellToChan(int plane, int cell,
                        int& board_id, int& chan_id)
{
  if (fInstance->CellToChanException(board_id, chan_id, plane, cell))
    return true;

  // if no exceptions were found, use algorithmic mapping
  board_id = plane;
  chan_id = cell;

  return true;
}

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

IPNDCMap::IPNDCMap(std::string& fname) : CMap(fname)
{

}

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

IPNDCMap::~IPNDCMap()
{

}

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

IPNDCMap& IPNDCMap::Instance(time_t& t)
{
  if (!fInstance) {
    std::string fname = "cmapipnd.xml";
    fInstance = new IPNDCMap(fname);
  }
  
  if (t >= fInstance->MinTime() && 
      t <= fInstance->MaxTime()) return *fInstance;

  assert_jobc(!fInstance->Init(t), "Failed to initialize!");
  
  return *fInstance;
}

//----------------------------------------------------------------------
// For now we assume a 1-1 mapping, and that the board_id is actually the
// plane number, and the chan_id is the cell number

bool IPNDCMap::ChanToCell(int board_id, int chan_id,
                        int& plane, int& cell)
{
  if (fInstance->ChanToCellException(board_id, chan_id, plane, cell))
    return true;

  // if no exceptions were found, use algorithmic mapping
  plane = board_id;
  cell = chan_id;

  return true;
}

//----------------------------------------------------------------------
// For now we assume a 1-1 mapping, and that the board_id is actually the
// plane number, and the chan_id is the cell number

bool IPNDCMap::CellToChan(int plane, int cell,
                        int& board_id, int& chan_id)
{
  if (fInstance->CellToChanException(board_id, chan_id, plane, cell))
    return true;

  // if no exceptions were found, use algorithmic mapping
  board_id = plane;
  chan_id = cell;

  return true;
}

---