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

Go to the documentation of this file.

/* @version $Revision: 1759 $ * @modifiedby $Author: jacquem $ * @lastmodified $Date: 2012-06-04 16:49:12 +0200 (Mon, 04 Jun 2012) $ */

#include "geometry/Channel.hh"
#include "geometry/Chip.hh"
#include "geometry/Board.hh"
#include "geometry/Dif.hh"
#include "geometry/Chamber.hh"
#include "event/ChannelHit.hh"

#include <iostream>
#include "tools/Log.hh"

using namespace std;

//-------------------------------------------//
std::ostream& operator <<(std::ostream& out, const Channel& x) {
  out << "        " << x.description << " id " << x.hardId
      << ", position [x/y/z] @[" << x.getX() << ", " << x.getY() << ", " << x.getZ() << "], "
      << "[col/row]=>["<< x.column << "/" << x.row << "]";
  return(out);
} // operator <<

//--------------- Constructeur -------------//
Channel::Channel(const Chip& _chip, const std::string aDesc, const i32 aColumn, const i32 aRow, const i32 aHardId)
  :chip(_chip), description(aDesc), column(aColumn), row(aRow), hardId(aHardId)
{
  enable = true;
  stimulate = false;

        const Chip&  chip = this->getChip() ;
        const Board& board = chip.getBoard() ;
        const Dif* dif = board.getDif();
                unsigned int difId = 0;
         if ( dif != NULL) difId = dif->getId();
        const Chamber& cham = this->getChamber();
        channelSoftId.SetValue(cham.getId(), difId, board.getId(),chip.getId(),getHardId(),getRow(),getColumn());
//  FILE_LOG(logDEBUG) << "------Channel constructor. " << endl;
}

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

//--------------- operateur de copie -------------//
// Obligatoire pour l utisation de cette classe dans un std::vector container
//
Channel& Channel::operator = (const Channel &source)
{
  //FILE_LOG(logDEBUG) << "--Channel operator de copie"<< endl;
  hardId = source.hardId;
  description = source.description;
  column = source.column;
  row = source.row;
  enable = source.enable;
  stimulate = source.stimulate;
  pedestal_offset  = source.pedestal_offset;
  return *this;
}

//--------------- Destructeur -------------//
Channel::~Channel()
{
  FILE_LOG(logDEBUG1) << "------Channel destructeur:" <<  this->getHardId() << " in chip["  << this->getChip().getId() << endl;
}

//-------------------------------------------//
const Chamber& Channel::getChamber() const
{
  return(chip.getBoard().getChamber());
};


//-------------------------------------------//
const float Channel::getX() const

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

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

  return result + getChamber().getX() ;


}
//-------------------------------------------//
const float Channel::getXRelative() const
{

  float result = -( chip.getXLength() / 2. ) + ( row * this->getXLength() )  + ( this->getXLength() / 2. );

  return result;
}
//-------------------------------------------//

const float Channel::getY() const
{

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



}
//-------------------------------------------//
const float Channel::getYRelative() const
{
  float result = 0.;


  result = - ( chip.getYLength() / 2. ) + ( column * this->getYLength() )  + ( this->getYLength() / 2. );


  return result ;
}
//-------------------------------------------//

float Channel::getZ() const
{
  return getChamber().getZ();
}

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

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

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

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


//-------------------------------------------//
void Channel::print() const
{
  cout << *this << endl;
}


//-------------------------------------------//
  const ui16 Channel::getColInChamberRelative() const  // along side Y axis in this franework, without rotation
  {
    const Board& board = chip.getBoard();
    ui16 chipCol =  ( board.getColumn() * board.getNbColumns() ) + chip.getColumn();
    return chipCol * chip.getNbColumns() + getColumn();
  }
//-------------------------------------------//
  const ui16 Channel::getRowInChamberRelative() const  // along side X axis in this franework, without rotation
  {
    const Board& board = chip.getBoard();
    ui16 chipRow =  ( board.getRow() * board.getNbRows() ) + chip.getRow();
    return chipRow * chip.getNbRows() + getRow();
  }

//-------------------------------------------//
  const ui16 Channel::getColInChamber() const  // along side Y axis in this franework, with rotation
  {
    ui16 result = 0;
    const Board& board = chip.getBoard();
    const Chamber& chamber = board.getChamber();
    if ( chamber.getZrotation() == 90 )
    {
      ui16 nbTotalRow = chamber.getNbRows() * board.getNbRows() *  chip.getNbRows();
      result =  nbTotalRow - (getRowInChamberRelative()+1);     
    }
    else if ( chamber.getZrotation() == -90 )
    {
      result =  getRowInChamberRelative();
    }
    else // no roration
    {
      result =  getColInChamberRelative();
    }

    if (  chamber.getXrotation() == true )
    {
      ui16 nbTotalCol = chamber.getNbColumns() * board.getNbColumns() *  chip.getNbColumns();
      result = nbTotalCol - (result+1);
    }

    return result;
    
  }
//-------------------------------------------//
  const ui16 Channel::getRowInChamber() const  // along side Y axis in this franework, with rotation
  {
    ui16 result = 0;
    const Board& board = chip.getBoard();
    const Chamber& chamber = board.getChamber();
    if ( chamber.getZrotation() == 90 )
    {
      result =  getColInChamberRelative();
    }
    else if ( chamber.getZrotation() == -90 )
    {
      ui16 nbTotalCol = chamber.getNbColumns() * board.getNbColumns() *  chip.getNbColumns();
      result =  nbTotalCol - (getColInChamberRelative()+1);
    }
    else
    {
      result =  getRowInChamberRelative() ;
    }
    if (  chamber.getYrotation() == true )
    {
      ui16 nbTotalRow = chamber.getNbRows() * board.getNbRows() *  chip.getNbRows();
      result = nbTotalRow - (result+1);
    }
    return result;
  }

---