/data3/calcul/jacquem/working_dir/Micromegas/micromegasFrameWork/src/geometry/Board.cpp

Go to the documentation of this file.

/* @version $Revision: 1751 $ * @modifiedby $Author: lcdet $ * @lastmodified $Date: 2012-05-30 17:01:35 +0200 (Wed, 30 May 2012) $ */

#include "geometry/Channel.hh"
#include "geometry/Chip.hh"
#include "geometry/Board.hh"
#include "geometry/Chamber.hh"

#include "tools/MicroException.hh"
#include "tools/Log.hh"

#include <iostream>

using namespace std;

//--------------------------//
std::ostream& operator <<(std::ostream& out, const Board& x) {
  return(x.operator <<(out));
} // operator <<

//--------------------------//
Board::Board(const Chamber& _chamber,  const ui32 aCol, const ui32 aRow, const ui32 aNbColumns, const ui32 aNbRows,  const i32 aId)
: chamber(_chamber), dif(NULL),  row(aRow), column(aCol), nbColumns(aNbColumns), nbRows(aNbRows),  id(aId)
{
  FILE_LOG(logDEBUG1) << "Board constructor row " << row << ", column:" << column << endl;
}

//--------------------------//
Board::~Board() {
  FILE_LOG(logDEBUG1) << "Board destructor" << endl;
  for (std::map<i32, Chip *>::const_iterator it = chips.begin(); it != chips.end(); ++it)
  {
    delete (it->second);
  }
}

//--------------------------//
Board::Board(const Board &x) : chamber(x.chamber) {
  *this = x;
}

//--------------------------//
Board& Board::operator=(const Board &x) {
//  (Chamber)chamber = x.chamber;
  id = x.id;
  column = x.column, row= x.row;
  nbColumns = x.nbColumns, nbRows = x.nbRows;
  chips = x.chips;
}

//--------------------------//
std::ostream& Board::operator <<(std::ostream& out) const {
  out << "    " << "Board id " << id << ", [x/y/z] @[" << getX() << ", " << getY() << ", " << chamber.getZ() << "], "
      << "[col/row]=>["<< column << "/" << row << "], "
      << "[Xlength/Ylength]=>["<< getXLength() << "/" << getYLength() << "], "
      << chips.size() << " chips" << endl;
  if (chips.size()) {
    for (std::map<i32, Chip *>::const_iterator it = chips.begin(); it != chips.end(); ++it) {
      out << *(it->second);
    }
  }
  return(out);
} // operator <<

//--------------------------//
void Board::addChip(Chip *chip) {
  chips.insert(make_pair(chip->getId(), chip));
} // Board.addChip

//--------------------------//
 Chip &Board::getChipById(const i32 chipId) {
  std::map<i32, Chip *>::const_iterator itChip = chips.find(chipId);
  if (itChip == chips.end()) {
    throw MicroException("Board.getChipById : no Chip found for this id in this Board ");
  }
  return(*itChip->second);
}

//--------------------------//
  Chip &Board::getChipByRowCol(const i16 row, const i16 col )
{
    for (std::map<i32, Chip *>::const_iterator it = chips.begin(); it != chips.end(); ++it) {
      Chip &chip = *(it->second);
      if ( chip.getRow() == row && chip.getColumn() == col )
      {
        return(chip);
      }
  }
  throw MicroException("Board.getChannelByRowCol : no Channel found with this col and row" );
}
//--------------------------//
Channel &Board::getChannelById(const i32 channelId, const i32 chipId)
{
  // for gassiplex boards the ChipId is the same as the channelId (every chip contains one and only one channel)
  try {
    Chip& chip = getChipById((chipId >= 0) ? chipId : channelId);
    Channel& ch = chip.getChannelById(channelId);
    return(ch);
  }
  catch (MicroException& e) {
  }
  throw MicroException("Board.getChannelById : no Channel found with this id" );
};

//-------------------------------------------//
const float Board::getX() const
{

  float result = 0.;

  if ( getChamber().getZrotation() == 90 )
  { result = getYRelative(); }
  else if ( getChamber().getZrotation() == -90 )
  { result = -getYRelative(); }

  else  { result = getXRelative(); }

 if ( getChamber().getYrotation())
  {
    result = - result;
  }

  return result + chamber.getX();//true);
}

//-------------------------------------------//
const float Board::getXRelative() const
{
  float result = - ( chamber.getXLength() / 2. ) + ( row * this->getXLength() )  + ( this->getXLength() / 2. ) + ( row ) * chamber.getXGap();

  return result;
}
//-------------------------------------------//
const float Board::getY() const
{

  float result = 0.;
  if ( getChamber().getZrotation() == 90 )
  { result = -getXRelative(); }

 else if ( getChamber().getZrotation() == -90 )
  { result = getXRelative(); }


  else {  result = getYRelative(); }  

  if ( getChamber().getXrotation())
  {
    result = - result;
  }
   return result + chamber.getY();//true);
}


//-------------------------------------------//
const float Board::getYRelative() const
{
  float result = 0.;
  result = - ( chamber.getYLength() / 2. ) + ( column * this->getYLength() )  + ( this->getYLength() / 2. )  + ( column  * chamber.getYGap());

  return result;

}
//-------------------------------------------//
const float  Board::getXLength() const
{

  if (chips.size())
  {
    Chip* ch = chips.begin()->second;
    return  (nbRows *  ch->getXLength())  +( (nbRows-1) * getXGap() ) ;
  }

  return 0.;
}

//-------------------------------------------//
void Board::setDif( Dif *aDif)
{
    dif = aDif;
}

//-------------------------------------------//
const float  Board::getYLength() const
{
  if (chips.size())
  {
    Chip *ch = chips.begin()->second;
    return  (nbColumns *  ch->getYLength()) +( (nbColumns-1) * getYGap() ) ;

  }
  return 0;
}

//-------------------------------------------//
const float Board::getLeftBottomX() const
{
  if ( getChamber().getZrotation() == 90 || getChamber().getZrotation() == -90 ) return ( getX() - getYLength() / 2.);
   return ( getX() - getXLength() / 2.);
}
//-------------------------------------------//
const float Board::getLeftBottomY() const
{
  if ( getChamber().getZrotation() == 90  || getChamber().getZrotation() == -90) return ( getY() - getXLength() / 2.);
   return ( getY() - getYLength() / 2.);
}
//-------------------------------------------//
const float Board::getRightUpperX() const
{
  if ( getChamber().getZrotation() == 90  || getChamber().getZrotation() == -90) return ( getX() + getYLength() / 2.);
   return ( getX() + getXLength() / 2.);
}
//-------------------------------------------//
const float Board::getRightUpperY() const
{
  if ( getChamber().getZrotation() == 90  || getChamber().getZrotation() == -90) return ( getY() + getXLength() / 2.);
   return ( getY() + getYLength() / 2.);
}

//-------------------------------------------//
i32 Board::getMinChipId() const
{
        i32     result = 0xffff;
  for (std::map<i32, Chip *>::const_iterator it = chips.begin(); it != chips.end(); ++it)
  {
    Chip* chip = it->second;
                if (chip)
                {
                                                if ( chip->getId() < result) { result = chip->getId(); }
                }
        }
                return result;
}

//-------------------------------------------//
i32 Board::getMaxChipId() const
{
        i32     result = 0;
  for (std::map<i32, Chip *>::const_iterator it = chips.begin(); it != chips.end(); ++it)
  {
    Chip* chip = it->second;
                if (chip)
                {
                                                if ( chip->getId() > result) { result = chip->getId(); }
                }
        }
                return result;
}

---