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

using namespace std;


Chip::Chip(const Board& _board, const i32 aCol, const i32 aRow, const ui32 aNbColumns,const ui32 aNbRows ,const i32 aId ,const ui32 aSerialNumber)
:board(_board), id(aId), serialNum(aSerialNumber),  row(aRow), column(aCol), nbRows(aNbRows), nbColumns(aNbColumns), bypassed(false), configured(false)
{
    gain = 0;
    type = 0;
    const Dif* dif = _board.getDif();
           unsigned int difId = 0;
           if ( dif != NULL) difId = dif->getId();
           const Chamber& cham = _board.getChamber();

                chipSoftId.SetValue(cham.getId(), difId,_board.getId(), id);
    FILE_LOG(logDEBUG1) << "Chip id["<< id << "], serial number["<< serialNum <<"]" << endl;


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

//--------------------------//
std::ostream& Chip::operator <<(std::ostream& out) const {
  out << "      " << "Chip id " << id << ", Chip serialNum " << serialNum << ", position [x/y] @[" << getX() << ", " << getY() << "], "
      << "[col/row]=>["<< column << "/" << row << "], "
      << "[Xlength/Ylength]=>["<< getXLength() << "/" << getYLength() << "], "
      << channels.size() << " channels" 
      << "bypassed[" << this->bypassed << "]" << endl;
  
  return(out);
};

//--------------------------//
Chip::Chip(const Chip& x) : board(x.board) {
  *this = x;
}

//--------------------------//
Chip& Chip::operator = (const Chip& x) {
  id = x.id;
  column = x.column, row = x.row;
  nbColumns = x.nbColumns, nbRows = x.nbRows;
  channels = x.channels;
        const Dif* dif = board.getDif();
        unsigned int difId = 0;
        if ( dif != NULL) difId = dif->getId();
        const Chamber& cham = board.getChamber();

        chipSoftId.SetValue(cham.getId(), difId,board.getId(), id);
  gain  = x.gain;
}

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

//--------------------------//
Channel &Chip::getChannelById(const i32 channelId)
{
  std::map<i32, Channel *>::const_iterator it = channels.find(channelId);
  if (it == channels.end())
    throw MicroException("Chip.getChannelById : no Channel found for this id and this chamber ");

  //FILE_LOG(logDEBUG) << "----Channel Id " << channelId << " found" << endl;
  return(*(it->second));
};

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

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

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

  return result + board.getChamber().getX() ;

}

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

  return result;
}


//-------------------------------------------//
const float Chip::getY() const
{

  float result = 0.;
  if ( board.getChamber().getZrotation() == 90 )
  {
    result = -(getXRelative() + board.getXRelative());
 }
  else if ( board.getChamber().getZrotation() == -90 )
  {
    result = (getXRelative() + board.getXRelative());
 }
  else {
    result =  getYRelative() + board.getYRelative(); 
  }
  if ( board.getChamber().getXrotation() )
  {
    result = - result;
  }
  return result + board.getChamber().getY();

}

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

  return result;

}

//-------------------------------------------//
const float Chip::getLeftBottomX() const
{
  if ( board.getChamber().getZrotation() == 90 || board.getChamber().getZrotation() == -90) return ( getX() - getYLength() / 2.);
   return ( getX() - getXLength() / 2.);
}

//-------------------------------------------//
const float Chip::getLeftBottomY() const
{
  if ( board.getChamber().getZrotation() == 90 || board.getChamber().getZrotation() == -90) return ( getY() - getXLength() / 2.);
   return ( getY() - getYLength() / 2.);
}

//-------------------------------------------//
const float Chip::getRightUpperX() const
{
  if ( board.getChamber().getZrotation() == 90 || board.getChamber().getZrotation() == -90) return ( getX() + getYLength() / 2.);
   return ( getX() + getXLength() / 2.);
}

//-------------------------------------------//
const float Chip::getRightUpperY() const
{
  if ( board.getChamber().getZrotation() == 90|| board.getChamber().getZrotation() == -90 ) return ( getY() + getXLength() / 2.);
   return ( getY() + getYLength() / 2.);
}



//-------------------------------------------//
const float  Chip::getXLength() const
{
  if (channels.size()) {
    const Channel&  ch = *(channels.begin()->second);
    return (nbRows * ch.getXLength())  + ( nbRows-1)  * getXGap() ;
  }
  return(0);
}
//-------------------------------------------//
const float  Chip::getYLength() const
{
  if (channels.size()) {
    const Channel&  ch = *(channels.begin()->second);
    return (nbColumns *  ch.getYLength()) + (nbColumns-1) * getYGap() ;
  }
  return(0);
}

//-------------------------------------------//
i32 Chip::getMinChannelId() const
{
        i32     result = 0xffff;
  for (std::map<i32, Channel *>::const_iterator it = channels.begin(); it != channels.end(); ++it)
  {
    Channel* channel = it->second;
                if (channel)
                {
                                                if ( channel->getHardId() < result) { result = channel->getHardId(); }
                }
        }
                return result;
}

//-------------------------------------------//
i32 Chip::getMaxChannelId() const
{
        i32     result = 0;
  for (std::map<i32, Channel *>::const_iterator it = channels.begin(); it != channels.end(); ++it)
  {
    Channel* channel = it->second;
                if (channel)
                {
                                                if ( channel->getHardId() > result) { result = channel->getHardId(); }
                }
        }
                return result;
}

---