/data3/calcul/jacquem/working_dir/Micromegas/micromegasFrameWork/src/geometry/Chamber.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/Chamber.hh"
#include "geometry/Dif.hh"
#include "geometry/Board.hh"
#include "geometry/Chip.hh"
#include "geometry/Channel.hh"

#include "tools/MicroException.hh"
#include "tools/Log.hh"
#include <iostream>
#include "mTypes.h"

using namespace std;

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

//-------------------------------------------//
std::ostream& Chamber::operator <<(std::ostream& out) const {
  out << description << " id " << id << " @[" << xPos << ", " << yPos << ", " << zPos << "] x rotation[" << xRotation << "][ y rotation["  << yRotation << "] [ z rotation["  << zRotation << "]" << boards.size() << " boards, " << difs.size() << " difs" << endl;


  if (difs.size()) {
    for (DifMap_t::const_iterator it = difs.begin(); it != difs.end(); ++it) {
      out << *(it->second) << endl;
    }
  }
  else {
    for (std::map<i32, Board *>::const_iterator it = boards.begin(); it != boards.end(); ++it) {
      out << *(it->second) << endl;
    }
  }
  return(out);
} // operator <<

//---------------  Constructeur -------------//
//Chamber::Chamber(const i32 aX, const i32 aY, const i32 aZ, const i32 _id) : id(_id), xPos(aX), yPos(aY), zPos(aZ), description("")
Chamber::Chamber(const float aX, const float aY, const float aZ,const bool axRotation, const bool ayRotation , const i16 azRotation , const ui32 aNbColumns, const ui32 aNbRows, const i32 aId)
: id(aId), xPos(aX), yPos(aY), zPos(aZ), xRotation(axRotation), yRotation(ayRotation), zRotation(azRotation) , description(""), nbColumns(aNbColumns) , nbRows(aNbRows)
{
                //cout << "Chamber[" << this->id << "] x[" << xPos <<"] y[" << yPos << "]" << endl;
//  FILE_LOG(logDEBUG) << "--Chamber constructor id:" << id << endl;
}

//--------------- Constructeur de copie -------------//
// Obligatoire pour l utisation de cette classe dans un std::vector container
Chamber::Chamber(const Chamber &source)
{
//  FILE_LOG(logDEBUG) << "--Chamber Constructeur de copie"<< endl;
  *this = source;  //appel de l operateur =
}

//--------------- operateur de copie -------------//
// Obligatoire pour l utisation de cette classe dans un std::vector container
Chamber& Chamber::operator =(const Chamber &source)
{
  //FILE_LOG(logDEBUG) << "--Chamber operator de copie"<< endl;
  xPos = source.xPos;
  yPos = source.yPos;
  zPos = source.zPos;
        xRotation = source.xRotation;
        yRotation = source.yRotation;
        zRotation = source.zRotation;
  id = source.id;
  description = source.description;
  boards = source.boards;
//  type = source.type;
  return *this;
}

//--------------- Destructeur -------------//
Chamber::~Chamber()
{
//  FILE_LOG(logDEBUG)<< "----Chamber destructeur"<< endl;
  for (std::map<i32, Board *>::const_iterator it = boards.begin(); it != boards.end(); ++it) {
    delete (it->second);
  }
}

//--------------------------//
void Chamber::addDif(Dif *dif)
{
  difs.insert(make_pair(dif->getId(), dif));
} //

void Chamber::addBoard(Board *board)
{
  boards.insert(make_pair(board->getId(), board));
}

//--------------------------//
const BoardMap_t& Chamber::getBoardsByDifId(const i32 difId) const {
  DifMap_t::const_iterator difIt = difs.find(difId);
  if (difIt == difs.end()) {
    throw MicroException("no Dif found with this id: ");
  }
  return(difIt->second->getBoards());
} // Chamber.getBoardByDifId

//--------------------------//
const Channel& Chamber::getChannelById(const i32 channelId, const i32 chipId, const i32 difId) const
{
  // default case for Gassiplex without chipId and difId : direct use of the board list
  // case for Hardroc and Dirac boards which are connected to a Dif : look for the boards which Dif Id
  const BoardMap_t& boardMap = (chipId < 0) ? boards : getBoardsByDifId(difId);

  // then look for the channel with given board list
  //for (BoardMap_t::const_iterator boardIt = boards.begin(); boardIt != boards.end(); ++boardIt) {
  for (BoardMap_t::const_iterator boardIt = boardMap.begin(); boardIt != boardMap.end(); ++boardIt) {
    try {
      Channel& channel = boardIt->second->getChannelById(channelId, chipId);
      return(channel);
    }
    catch (MicroException &e) {
      //FILE_LOG(logDEBUG)<< "Chamber::getChannelById channelid["<< channelId << "] chipId:["<< chipId << "] difId:["<< difId << "], trying next board" << endl;
    }
  }

  throw MicroException("Chamber.getChannelById : no Channel found for this id and this chamber ");
} // Chamber.getChannelById

//-------------------------------------------//
float Chamber::getX() const 
{
  return xPos;
}
//-------------------------------------------//
float Chamber::getY() const 
{

  return yPos;
}

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

//-------------------------------------------//
const float  Chamber::getXLength() const
{
  const Board& board = *(boards.begin()->second);
        //cout << "Chamber getXleght: this->nbRows[" << this->nbRows << "]  board.getXLength()[" << board.getXLength() <<"[ this->getXGap()[" <<  this->getXGap() << endl;
  return (this->nbRows *  board.getXLength()) + ( (this->nbRows -1 ) * this->getXGap() );
}

//-------------------------------------------//
const float  Chamber::getYLength() const
{
  const Board& board = *(boards.begin()->second);
  return  (this->nbColumns *  board.getYLength() )+ ((this->nbColumns-1 ) *  this->getYGap() );
}


//--------------------------//
const Dif& Chamber::getDifById(const i32 difId) const
{
  std::map<i32, Dif *>::const_iterator it = difs.find(difId);
  if (it == difs.end())
    throw MicroException("Chanber.getDifById : no Dif found for this id");

  return(*(it->second));
}; 

---