---

H4Geom.cc

Go to the documentation of this file.

// 
// File H4Geom.cxx
//
#include "IORawData/Ecal2004TBInputService/interface/H4Geom.h"
#include <iostream>

using namespace std;

const int H4Geom::crystalChannelMap[5][5] = {
  { 4, 5, 14, 15, 24},
  { 3, 6, 13, 16, 23},
  { 2, 7, 12, 17, 22},
  { 1, 8, 11, 18, 21},
  { 0, 9, 10, 19, 20}
};

const int H4Geom::crystalMap[25] = {
  340, 255, 170,  85,   0,
    1,  86, 171, 256, 341,
  342, 257, 172,  87,   2,
    3,  88, 173, 258, 343,
  344, 259, 174,  89,   4
};

H4Geom::GeomPeriod_t H4Geom::geometry_ = H4Geom::Undef;

// modified to set always autumn2004
H4Geom::H4Geom()
{ 
  GeomPeriod_t ForFilesConversion;    
  ForFilesConversion = Automn2004;
  H4Geom::SetGeomPeriod(ForFilesConversion);
}

H4Geom::~H4Geom()
{ }

bool H4Geom::init()
{
  // if (gConfigParser->isDefined("Geometry::Period"))
  //    geometry_ = H4Geom::GeomPeriod_t(gConfigParser->
  //                                 readIntOption("Geometry::Period"));
  //  else
  //    return false;
  return true;
}

int H4Geom::getSMCrystalNumber(int tower, int crystal) const 
{
  if (!IsGeomPeriodDefined()) abort();
  if (geometry_ == H4Geom::Spring2004) {
    int smCrystalNbr = 0;
    if ((crystal/5)%2 == 0)
      smCrystalNbr = kCrystalsPerTower - 
        int(crystal/kCardsPerTower)*kChannelsPerCard - 
        crystal%kChannelsPerCard + (tower - 1)*kCrystalsPerTower;
    else
      smCrystalNbr = kCrystalsPerTower + 1 - 
        (int(crystal/kCardsPerTower) + 1)*kChannelsPerCard + 
        crystal%kChannelsPerCard + (tower - 1)*kCrystalsPerTower;
    return smCrystalNbr;
  } else if (geometry_ == H4Geom::Automn2004) {
    int eta = (tower - 1)/kTowersInPhi*kCardsPerTower;
    int phi = (tower - 1)%kTowersInPhi*kChannelsPerCard;
    if (rightTower(tower))
      eta += crystal/kCardsPerTower;
    else
      eta += (kCrystalsPerTower - 1 - crystal)/kCardsPerTower;
    if (rightTower(tower) && (crystal/kCardsPerTower)%2 == 1 ||
        !rightTower(tower) && (crystal/kCardsPerTower)%2 == 0)
      phi += (kChannelsPerCard - 1 - crystal%kChannelsPerCard);
    else
      phi += crystal%kChannelsPerCard;
    return eta*kChannelsPerCard*kTowersInPhi + phi + 1;
  } else {
    int towerId = tower - 1;
    int line = towerId%4;
    int column = towerId/4;
    int lowerRight = 5*line*85 + column*5;
    if (rightTower(tower))
      return lowerRight+crystalMap[crystal];
    else
      return lowerRight+crystalMap[24-crystal];
  }
}


void H4Geom::getTowerCrystalNumber(int &tower, int &crystal, int smCrystal) const 
{
  if (!IsGeomPeriodDefined()) abort();
  if (geometry_ == H4Geom::Spring2004) {
    // We do not know where the supercrystal is...
    tower = (smCrystal - 1)/kCrystalsPerTower + 1; 
    smCrystal -= (tower - 1)*kCrystalsPerTower;
    if (((smCrystal - 1)/kCardsPerTower)%2 == 0)
      crystal = (kCardsPerTower - 
                 int((smCrystal - 1)/kCardsPerTower))*kCardsPerTower - 
                (smCrystal - 1)%kCardsPerTower - 1;
    else
      crystal = (kCardsPerTower - 1 - 
                 int((smCrystal - 1)/kCardsPerTower))*kCardsPerTower + 
                (smCrystal - 1)%kCardsPerTower;
    return;
  } else if (geometry_ == H4Geom::Automn2004) {
    int eta = (smCrystal - 1)/(kChannelsPerCard*kTowersInPhi);
    int phi = (smCrystal - 1)%(kChannelsPerCard*kTowersInPhi);
    tower = eta/kCardsPerTower*kTowersInPhi + phi/kChannelsPerCard + 1;
    if (rightTower(tower)) {
      crystal = (eta%kCardsPerTower)*kChannelsPerCard;
      if ((eta%kChannelsPerCard)%2 == 0)
        crystal += phi%kChannelsPerCard;
      else
        crystal += kChannelsPerCard - 1 - phi%kChannelsPerCard;
    } else {
      crystal = (kCardsPerTower - 1 - eta%kCardsPerTower)*kChannelsPerCard;
      if ((eta%kChannelsPerCard)%2 == 0)
        crystal += kChannelsPerCard - 1 - phi%kChannelsPerCard;
      else
        crystal += phi%kChannelsPerCard;
    }
  } else {
    int line = smCrystal/85;
    int cInLine = smCrystal%85;
    
    tower= 1 + (cInLine/5) * 4 + line/5; // tower number in SM
    crystal = crystalChannelMap[line%5][cInLine%5];
    if (leftTower(tower)) crystal = 24-crystal ;
  }
  return;
}


int H4Geom::getTowerCrystalNumber(int smTowerNb, int crystalNbGeom) const
{
  if (crystalNbGeom < 0 || crystalNbGeom >= kCrystalsPerTower) return -1 ;
  int column = crystalNbGeom/kCardsPerTower;
  int line = crystalNbGeom%kChannelsPerCard;
  int crystal = crystalChannelMap[line][column];
  if (leftTower(smTowerNb)) crystal = kCrystalsPerTower - 1 - crystal;
  return crystal;
}


void H4Geom::getCrystalCoord(int &eta, int &phi, int smCrystal) const
{
  if (geometry_ == H4Geom::Spring2004) {
    eta = (smCrystal - 1)/kChannelsPerCard; // arbitrary units
    phi = kChannelsPerCard - 1 - 
      ((smCrystal - 1)%kCrystalsPerTower)%kChannelsPerCard;
  } else if (geometry_ == H4Geom::Automn2004) {
    eta = (smCrystal - 1)/(kChannelsPerCard*kTowersInPhi);
    phi = (smCrystal - 1)%(kChannelsPerCard*kTowersInPhi);
  } else {
    eta = smCrystal%kCrystalsInEta;
    phi = smCrystal/kCrystalsInEta;
  }
}


int H4Geom::getSMCrystalFromCoord(int eta, int phi) const
{
  if (geometry_ == H4Geom::Spring2004) {
    if (eta >= 9 || eta < 0 || phi >= 4 || phi < 0) 
      return -1; // Only two supercrystals
    return eta*kCardsPerTower + (kChannelsPerCard - phi);
  }
  if (eta < 0 || eta >= kCrystalsInEta || phi < 0 || phi >= kCrystalsInPhi) 
    return -1; // non real smCrystal
  else {
    if (geometry_ == H4Geom::Automn2004)
      return eta*kChannelsPerCard*kTowersInPhi + phi + 1;
    else
      return eta + kCrystalsInEta*phi;
  }
}


int H4Geom::getLeft(int smCrystal) const
{
  if (!IsGeomPeriodDefined()) abort();
  if (geometry_ == H4Geom::Spring2004) {
    smCrystal += kChannelsPerCard;
    if (smCrystal > 2*kCrystalsPerTower || smCrystal < 1) return -1;
    return smCrystal;
  } else if (geometry_ == H4Geom::Automn2004) {
    smCrystal += kCrystalsInPhi;
    if (smCrystal > kCrystals) return -1;
    return smCrystal;
  } else {
    smCrystal++;
    if (!(smCrystal % kCrystalsInEta)) return -1;
    if (smCrystal >= kCrystals || smCrystal < 0) return -1;
    return smCrystal;
  }
}


int H4Geom::getRight(int smCrystal) const
{
  if (!IsGeomPeriodDefined()) abort();
  if (geometry_ == H4Geom::Spring2004) {
    smCrystal -= kChannelsPerCard;
    if (smCrystal > 2*kCrystalsPerTower || smCrystal < 1) return -1;
    return smCrystal;
  } else if (geometry_ == H4Geom::Automn2004) {
    smCrystal -= kCrystalsInPhi;
    if (smCrystal < 0) return -1;
    return smCrystal;
  } else {
    smCrystal--;
    if (smCrystal % kCrystalsInEta == kCrystalsInEta - 1) return -1;
    if (smCrystal >= kCrystals || smCrystal < 0) return -1;
    return smCrystal;
  }
}


int H4Geom::getUpper(int smCrystal) const{
  if (!IsGeomPeriodDefined()) abort();
  if (geometry_ == H4Geom::Spring2004) {
    smCrystal--;
    if (smCrystal > 2*kCrystalsPerTower || smCrystal < 1) return -1;
    return smCrystal;
  } else if (geometry_ == H4Geom::Automn2004) {
    if ((smCrystal - 1)%kCrystalsInPhi == 0) return -1; // phi = 0
    smCrystal--;
    return smCrystal;
  } else {
    smCrystal += kCrystalsInEta;
    if (smCrystal >= kCrystals || smCrystal < 0) return -1;
    return smCrystal;
  }
}


int H4Geom::getLower(int smCrystal) const
{
  if (!IsGeomPeriodDefined()) abort();
  if (geometry_ == H4Geom::Spring2004) {
    smCrystal ++;
    if (smCrystal > 2*kCrystalsPerTower || smCrystal < 1) return -1;
    return smCrystal;
  } else if (geometry_ == H4Geom::Automn2004) {
    if (smCrystal%kCrystalsInPhi == 0) return -1; // phi = 19
    smCrystal++;
    return smCrystal;
  } else {
    smCrystal -= kCrystalsInEta;
    if (smCrystal >= kCrystals || smCrystal < 0) return -1;
    return smCrystal;
  }
}


void H4Geom::mvLeft(int &eta, int &phi) const
{
  if (eta >= kCrystalsInEta)
    std::cout << "H4Geom::mvLeft: eta is too large " << eta << std::endl;
  eta++;
}

void H4Geom::mvRight(int &eta, int &phi) const
{
  if (eta < 0)
    std::cout << "H4Geom::mvRight: eta is too small " << eta << std::endl;
  eta--;
}

void H4Geom::mvUp(int &eta, int &phi) const
{
  if (phi >= kCrystalsInPhi)
    std::cout << "H4Geom::mvUp: phi is too large " << phi << std::endl;
  phi++;
}


void H4Geom::mvDown(int &eta, int &phi) const
{
  if (phi < 0)
    std::cout << "H4Geom::mvDown: phi is too small " << phi << std::endl;
  phi--;
}



void H4Geom::getTower(int * tower, int towerNb, std::string order) const 
{
  if (!IsGeomPeriodDefined()) abort();
  if (order == "readout") {
    for (int crystalNb = 0; crystalNb < kCrystalsPerTower; crystalNb++)
      tower[crystalNb] = getSMCrystalNumber(towerNb, crystalNb);
  } else {
    int towerId = towerNb - 1;
    int line = towerId%kTowersInPhi;
    int column = towerId/kTowersInPhi;
    if (geometry_ == H4Geom::Automn2004) {
      int smLowerRight = column*kCardsPerTower*kCrystalsInPhi + 
                         (line + 1)*kChannelsPerCard;
      for (int i = 0; i < kCrystalsPerTower; i++)
        tower[i] = smLowerRight - i%kChannelsPerCard + 
                   i/kChannelsPerCard*kCrystalsInPhi;
    } else {
      int smLowerRight = kChannelsPerCard*line*kCrystalsInEta + 
                         column*kCardsPerTower;
      for (int i = 0; i < kCrystalsPerTower; i++)
        tower[i] = i%kChannelsPerCard * kCrystalsInEta + 
                   i/kChannelsPerCard + smLowerRight;
    }
  }
  return;
}



void H4Geom::getVFE(int * VFE, int smCrystal, std::string order) const 
{
  int towerNb, crystalNb;
  getTowerCrystalNumber(towerNb, crystalNb, smCrystal);
  int VFEnb = crystalNb/kChannelsPerCard;
  if (order == "readout") {
    for (crystalNb = 0; crystalNb < kChannelsPerCard; crystalNb++) 
      VFE[crystalNb] = getSMCrystalNumber(towerNb, 
                                          kChannelsPerCard*VFEnb+crystalNb);
  } else {
    int eta, phi;
    getCrystalCoord(eta, phi, smCrystal);
    int smLower = eta+85*5*(phi/5);     
    for (int i = 0; i < 5; i++)
      VFE[i] =  i*85 + smLower;
  }  
}


void H4Geom::getWindow(int * window, int smCrystal, int width, int height) const
{
  if (width <= 0 || width%2 == 0) {
    std::cout << "H4Geom::getWindow, width should be >0 and odd!" << std::endl;
    return;
  }
  if (height <= 0 || height%2 == 0) {
    std::cout << "H4Geom::getWindow, height should be >0 and odd!" 
              << std::endl;
    return;
  }
  int eta, phi;
  getCrystalCoord(eta, phi, smCrystal);
  // get lower-right corner
  int eta0 = eta - (width - 1)/2;
  int phi0 = phi - (height - 1)/2;
  int index = 0;
  eta = eta0;
  phi = phi0;
  for (int i = 0; i < width; i++) {
    for (int j = 0; j < height; j++) {
      window[index] = getSMCrystalFromCoord(eta, phi);
      phi++;
      index++;
    }
    eta++;
    phi = phi0;
  }
}



bool H4Geom::rightTower(int tower) const 
{
  if (!IsGeomPeriodDefined()) abort();
  if (geometry_ == H4Geom::Automn2004) {
    if ((tower - 1)/kTowersInPhi < 3 ||
        ((tower - 1)/kTowersInPhi - 3)%4 >= 2)
      return false;
    else
      return true;
  }
  if ((tower>12 && tower<21) || (tower>28 && tower<37) ||
      (tower>44 && tower<53) || (tower>60 && tower<69))
    return true;
  else
    return false;
}


bool H4Geom::leftTower(int tower) const
{
  return !rightTower(tower);
}

void H4Geom::SetGeomPeriod(GeomPeriod_t geometry)
{
  geometry_ = geometry;
}

bool H4Geom::IsGeomPeriodDefined() const {
  if (geometry_ == H4Geom::Undef) {
    std::cout << "Class H4Geom : geometry is not defined. You should call in"
              << " your program H4Geom::init (and fill the [Geometry] section"
              << " of your config file) or call H4Geom::SetGeomPeriod." 
              << std::endl;
    return false;
  }
  return true;
}

---