TPCFastTransformGeo.cxx

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
#include "TPCFastTransformGeo.h"
#include "FlatObject.h"
#include "GPUCommonMath.h"
#include "GPUCommonLogger.h"
 
#include <iostream>
 
using namespace o2::gpu;
 
TPCFastTransformGeo::TPCFastTransformGeo()
{
  // Default Constructor: creates an empty uninitialized object
  for (int32_t i = 0; i < NumberOfSectors; i++) {
    double angle = (i + 0.5) * 2. * M_PI / NumberOfSectorsA;
    mSectorInfos[i].sinAlpha = sin(angle);
    mSectorInfos[i].cosAlpha = cos(angle);
  }
  mSectorInfos[NumberOfSectors] = SectorInfo{};
 
  for (int32_t i = 0; i < MaxNumberOfRows + 1; i++) {
    mRowInfos[i] = RowInfo{};
  }
}
 
void TPCFastTransformGeo::startConstruction(int32_t numberOfRows)
{
 
  assert(numberOfRows >= 0 && numberOfRows < MaxNumberOfRows);
 
  mConstructionMask = ConstructionState::InProgress;
  mNumberOfRows = numberOfRows;
 
  mTPCzLength = 0.f;
 
  for (int32_t i = 0; i < MaxNumberOfRows; i++) {
    mRowInfos[i] = RowInfo{};
  }
}
 
void TPCFastTransformGeo::setTPCzLength(float tpcZlength)
{
 
  assert(mConstructionMask & ConstructionState::InProgress);
  assert(tpcZlength > 0.f);
 
  mTPCzLength = tpcZlength;
 
  mConstructionMask |= ConstructionState::GeometryIsSet;
}
 
void TPCFastTransformGeo::setTPCrow(int32_t iRow, float x, int32_t nPads, float padWidth)
{
  assert(mConstructionMask & ConstructionState::InProgress);
  assert(iRow >= 0 && iRow < mNumberOfRows);
  assert(nPads > 1);
  assert(padWidth > 0.);
 
  // Make scaled U = area between centers of the first and the last pad
 
  // double uWidth = (nPads - 1) * padWidth;
 
  // Make scaled U = area between the geometrical sector borders
 
  const double sectorAngle = 2. * M_PI / NumberOfSectorsA;
  const double scaleXtoRowWidth = 2. * tan(0.5 * sectorAngle);
  double uWidth = x * scaleXtoRowWidth; // distance to the sector border
 
  RowInfo& row = mRowInfos[iRow];
  row.x = x;
  row.maxPad = nPads - 1;
  row.padWidth = padWidth;
  row.yMin = -uWidth / 2.;
}
 
void TPCFastTransformGeo::finishConstruction()
{
 
  assert(mConstructionMask & ConstructionState::InProgress);    // construction in process
  assert(mConstructionMask & ConstructionState::GeometryIsSet); // geometry is  set
 
  for (int32_t i = 0; i < mNumberOfRows; i++) { // all TPC rows are initialized
    assert(getRowInfo(i).maxPad > 0);
  }
 
  mConstructionMask = (uint32_t)ConstructionState::Constructed; // clear all other construction flags
}
 
void TPCFastTransformGeo::print() const
{
  LOG(info) << "TPC Fast Transformation Geometry: ";
  LOG(info) << "mNumberOfRows = " << mNumberOfRows;
  LOG(info) << "mTPCzLength = " << mTPCzLength;
  LOG(info) << "TPC Rows : ";
  for (int32_t i = 0; i < mNumberOfRows; i++) {
    LOG(info) << " tpc row " << i << ": x = " << mRowInfos[i].x << " maxPad = " << mRowInfos[i].maxPad << " padWidth = " << mRowInfos[i].padWidth;
  }
}
 
int32_t TPCFastTransformGeo::test(int32_t sector, int32_t row, float ly, float lz) const
{
 
  int32_t error = 0;
 
  if (!isConstructed()) {
    error = -1;
  }
  if (mNumberOfRows <= 0 || mNumberOfRows >= MaxNumberOfRows) {
    error = -2;
  }
  float lx = getRowInfo(row).x;
  float lx1 = 0.f, ly1 = 0.f, lz1 = 0.f;
  float gx = 0.f, gy = 0.f, gz = 0.f;
 
  convLocalToGlobal(sector, lx, ly, lz, gx, gy, gz);
  convGlobalToLocal(sector, gx, gy, gz, lx1, ly1, lz1);
 
  if (fabs(lx1 - lx) > 1.e-4 || fabs(ly1 - ly) > 1.e-4 || fabs(lz1 - lz) > 1.e-7) {
    LOG(info) << "Error local <-> global: x " << lx << " dx " << lx1 - lx << " y " << ly << " dy " << ly1 - ly << " z " << lz << " dz " << lz1 - lz;
    error = -3;
  }
 
  float pad, length;
  convLocalToPadDriftLength(sector, 10, ly, lz, pad, length);
  float ly2, lz2;
  convPadDriftLengthToLocal(sector, 10, pad, length, ly2, lz2);
 
  if (fabs(ly2 - ly) + fabs(lz2 - lz) > 1.e-6) {
    LOG(info) << "Error local <-> UV: y " << ly << " dy " << ly2 - ly << " z " << lz << " dz " << lz2 - lz;
    error = -4;
  }
 
  if (error != 0) {
    LOG(info) << "TPC Fast Transformation Geometry: Internal ERROR " << error;
  }
  return error;
}
 
int32_t TPCFastTransformGeo::test() const
{
 
  return test(2, 5, 10., 10.); // test at an arbitrary position
}