// 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 <fstream>

#include <iostream>

#include <string>

#include <sstream>

#include <cstdlib>

#include <cmath>

#include "TPCBase/Mapper.h"

#include "GPUCommonLogger.h"

namespace o2

{

namespace tpc

{

constexpr std::array<double, SECTORSPERSIDE> Mapper::SinsPerSector /*{{

0,

0.3420201433256687129080830800376133993268,

0.6427876096865392518964199553010985255241,

0.8660254037844385965883020617184229195118,

0.9848077530122080203156542665965389460325,

0.9848077530122080203156542665965389460325,

0.866025403784438707610604524234076961875,

0.6427876096865394739410248803324066102505,

0.3420201433256688794415367738110944628716,

0.,

-0.3420201433256686573969318487797863781452,

-0.6427876096865392518964199553010985255241,

-0.8660254037844383745436971366871148347855,

-0.9848077530122080203156542665965389460325,

-0.9848077530122081313379567291121929883957,

-0.8660254037844385965883020617184229195118,

-0.6427876096865395849633273428480606526136,

-0.3420201433256686018857806175219593569636

}}*/

;

// static constexpr std::array<int, 2> test{1,2};

constexpr std::array<double, SECTORSPERSIDE> Mapper::CosinsPerSector /*{{

1,

0.9396926207859084279050421173451468348503,

0.7660444431189780134516809084743726998568,

0.5000000000000001110223024625156540423632,

0.1736481776669304144533612088707741349936,

-0.1736481776669303034310587463551200926304,

-0.4999999999999997779553950749686919152737,

-0.7660444431189779024293784459587186574936,

-0.9396926207859083168827396548294927924871,

-1,

-0.9396926207859084279050421173451468348503,

-0.7660444431189780134516809084743726998568,

-0.5000000000000004440892098500626161694527,

-0.1736481776669303311866343619840336032212,

0.1736481776669299703641513588081579655409,

0.5000000000000001110223024625156540423632,

0.7660444431189777914070759834430646151304,

0.9396926207859084279050421173451468348503

}}*/

;

Mapper::Mapper(const std::string& mappingDir)

: mMapGlobalPadToPadPos(mPadsInSector),

mMapGlobalPadCentre(mPadsInSector),

mMapPadPosGlobalPad(),

mMapFECIDGlobalPad(FECInfo::globalSAMPAId(91, 0, 0)),

mMapGlobalPadFECInfo(mPadsInSector),

mMapPadRegionInfo(),

mMapPartitionInfo()

{

load(mappingDir);

loadTraceLengths(mappingDir);

}

bool Mapper::readMappingFile(std::string file)

{

// ===| Mapping file layout |=================================================

// Col 0 -> INDEX

// Col 1 -> PADROW

// Col 2 -> PAD

// Col 3 -> X coordinate

// Col 4 -> y coordinate

// Col 5 -> Connector

// Col 6 -> Pin

// Col 7 -> Partion

// Col 8 -> Region

// Col 9 -> FEC

// Col 10 -> FEC Connector

// Col 11 -> FEC Channel

// Col 12 -> SAMPA Chip

// Col 13 -> SAMPA Channel

// ===| Input variables |=====================================================

// pad info

GlobalPadNumber padIndex;

unsigned int padRow;

unsigned int pad;

float xPos;

float yPos;

// pad plane info

unsigned int connector;

unsigned int pin;

unsigned int partion;

unsigned int region;

// FEC info

unsigned int fecIndex;

unsigned int fecConnector;

unsigned int fecChannel;

unsigned int sampaChip;

unsigned int sampaChannel;

std::string line;

std::ifstream infile(file, std::ifstream::in);

if (!infile.is_open()) {

LOGP(fatal, "could not open file {}", file);

}

while (std::getline(infile, line)) {

std::stringstream streamLine(line);

streamLine

// pad info

>> padIndex >> padRow >> pad >> xPos >> yPos

// pad plane info

>> connector >> pin >> partion >> region

// FEC info

>> fecIndex >> fecConnector >> fecChannel >> sampaChip >> sampaChannel;

// the x and y positions are in mm

// in the mapping files, the values are given for sector C04 in the global ALICE coordinate system

// however, we need it in the local tracking system. Therefore:

const float localX = yPos / 10.f;

const float localY = -xPos / 10.f;

// with the pad counting (looking to C-Side pad 0,0 is bottom left -- pad-side front view)

// these values are for the C-Side

// For the A-Side the localY position must be mirrored

mMapGlobalPadToPadPos[padIndex] = PadPos(padRow, pad);

mMapPadPosGlobalPad[PadPos(padRow, pad)] = padIndex;

mMapGlobalPadFECInfo[padIndex] = FECInfo(fecIndex, /*fecConnector, fecChannel,*/ sampaChip, sampaChannel);

mMapFECIDGlobalPad[FECInfo::globalSAMPAId(fecIndex, sampaChip, sampaChannel)] = padIndex;

mMapGlobalPadCentre[padIndex] = PadCentre(localX, localY);

// std::cout

//<< padIndex<< " "

//<< padRow<< " "

//<< pad<< " "

//<< xPos<< " "

//<< yPos<< " "

//<< " "

//// pad plane info<< " "

//<< connector<< " "

//<< pin<< " "

//<< partion<< " "

//<< region<< " "

//<< " "

//// FEC info<< " "

//<< fecIndex<< " "

//<< fecConnector<< " "

//<< fecChannel<< " "

//<< sampaChip<< " "

//<< sampaChannel << std::endl;

}

return true;

}

void Mapper::load(const std::string& mappingDir)

{

// std::string inputDir(std::getenv("ALICEO2"));

std::string inputDir = mappingDir;

if (!inputDir.size()) {

// const char* aliceO2env=std::getenv("ALICEO2");

// if (aliceO2env) inputDir=aliceO2env;

// readMappingFile(inputDir+"/Detectors/TPC/base/files/TABLE-IROC.txt");

// readMappingFile(inputDir+"/Detectors/TPC/base/files/TABLE-OROC1.txt");

// readMappingFile(inputDir+"/Detectors/TPC/base/files/TABLE-OROC2.txt");

// readMappingFile(inputDir+"/Detectors/TPC/base/files/TABLE-OROC3.txt");

const char* aliceO2env = std::getenv("O2_ROOT");

if (aliceO2env) {

inputDir = aliceO2env;

}

inputDir += "/share/Detectors/TPC/files";

}

readMappingFile(inputDir + "/TABLE-IROC.txt");

readMappingFile(inputDir + "/TABLE-OROC1.txt");

readMappingFile(inputDir + "/TABLE-OROC2.txt");

readMappingFile(inputDir + "/TABLE-OROC3.txt");

initPadRegionsAndPartitions();

}

void Mapper::initPadRegionsAndPartitions()

{

// original values for pad widht and height and pad row position are in mm

// the ALICE coordinate system is in cm

mMapPadRegionInfo[0] = PadRegionInfo(0, 0, 17, 7.5 / 10., 4.16 / 10., 848.5 / 10., 0, 33.20, 0);

mMapPadRegionInfo[1] = PadRegionInfo(1, 0, 15, 7.5 / 10., 4.20 / 10., 976.0 / 10., 17, 33.00, 17);

mMapPadRegionInfo[2] = PadRegionInfo(2, 1, 16, 7.5 / 10., 4.20 / 10., 1088.5 / 10., 32, 33.08, 32);

mMapPadRegionInfo[3] = PadRegionInfo(3, 1, 15, 7.5 / 10., 4.36 / 10., 1208.5 / 10., 48, 31.83, 48);

mMapPadRegionInfo[4] = PadRegionInfo(4, 2, 18, 10 / 10., 6.00 / 10., 1347.0 / 10., 0, 38.00, 63);

mMapPadRegionInfo[5] = PadRegionInfo(5, 2, 16, 10 / 10., 6.00 / 10., 1527.0 / 10., 18, 38.00, 81);

mMapPadRegionInfo[6] = PadRegionInfo(6, 3, 16, 12 / 10., 6.08 / 10., 1708.0 / 10., 0, 47.90, 97);

mMapPadRegionInfo[7] = PadRegionInfo(7, 3, 14, 12 / 10., 5.88 / 10., 1900.0 / 10., 16, 49.55, 113);

mMapPadRegionInfo[8] = PadRegionInfo(8, 4, 13, 15 / 10., 6.04 / 10., 2089.0 / 10., 0, 59.39, 127);

mMapPadRegionInfo[9] = PadRegionInfo(9, 4, 12, 15 / 10., 6.07 / 10., 2284.0 / 10., 0, 64.70, 140);

mMapPartitionInfo[0] = PartitionInfo(15, 0, 32, 0, 2400);

mMapPartitionInfo[1] = PartitionInfo(18, 15, 31, 32, 2880);

mMapPartitionInfo[2] = PartitionInfo(18, 15 + 18, 34, 32 + 31, 2880);

mMapPartitionInfo[3] = PartitionInfo(20, 15 + 18 + 18, 30, 32 + 31 + 34, 3200);

mMapPartitionInfo[4] = PartitionInfo(20, 15 + 18 + 18 + 20, 25, 32 + 31 + 34 + 30, 3200);

int globalRow = 0;

int padsInRow = 0;

int padOffset = 0;

for (const auto& reg : mMapPadRegionInfo) {

for (int row = 0; row < reg.getNumberOfPadRows(); ++row) {

mMapPadOffsetPerRow[globalRow] = padOffset;

padsInRow = reg.getPadsInRowRegion(row);

mMapNumberOfPadsPerRow[globalRow] = padsInRow;

++globalRow;

padOffset += padsInRow;

}

}

}

//______________________________________________________________________________

void Mapper::loadTraceLengths(std::string_view mappingDir)

{

std::string inputDir = mappingDir.data();

if (!inputDir.size()) {

const char* aliceO2env = std::getenv("O2_ROOT");

if (aliceO2env) {

inputDir = aliceO2env;

}

inputDir += "/share/Detectors/TPC/files";

}

mTraceLengthsIROC.reserve(Mapper::getPadsInIROC());

mTraceLengthsOROC.reserve(Mapper::getPadsInOROC());

setTraceLengths(inputDir + "/LENGTH-IROC.txt", mTraceLengthsIROC);

setTraceLengths(inputDir + "/LENGTH-OROC1.txt", mTraceLengthsOROC);

setTraceLengths(inputDir + "/LENGTH-OROC2.txt", mTraceLengthsOROC);

setTraceLengths(inputDir + "/LENGTH-OROC3.txt", mTraceLengthsOROC);

assert(mTraceLengthsIROC.size() == Mapper::getPadsInIROC());

assert(mTraceLengthsOROC.size() == Mapper::getPadsInOROC());

}

//______________________________________________________________________________

void Mapper::setTraceLengths(std::string_view inputFile, std::vector<float>& length)

{

std::ifstream infile(inputFile.data(), std::ifstream::in);

if (!infile.is_open()) {

LOGP(fatal, "could not open file {}", inputFile);

}

// e.g. IROC file

// Col 0 -> INDEX (0 - 5279)

// Col 1 -> PADROW (0 - 62)

// Col 2 -> PAD (0 - (Np-1))

// Col 3 -> Connector (1 - 132)

// Col 4 -> Pin (1 - 40)

// Col 5 -> Trace length (mm)

// Col 6 -> Number of vias

unsigned int index{};

unsigned int padrow{};

unsigned int pad{};

unsigned int connector{};

unsigned int pin{};

float traceLength{};

unsigned int numberOfVias{};

std::string line;

while (std::getline(infile, line)) {

std::stringstream streamLine(line);

streamLine >> index >> padrow >> pad >> connector >> pin >> traceLength >> numberOfVias;

traceLength /= 10.f;

length.emplace_back(traceLength);

}

}

bool Mapper::isEdgePad(int rowInSector, int padInRow)

{

const auto& mapper = instance();

return (padInRow == 0) || (padInRow == mapper.getNumberOfPadsInRowSector(rowInSector) - 1);

}

bool Mapper::isFirstOrLastRowInStack(int rowInSector)

{

if (rowInSector == 0 || rowInSector == PADROWS - 1) {

return true;

}

const auto& mapper = instance();

for (int i = 1; i < 4; ++i) {

if (rowInSector == ROWOFFSETSTACK[i] || rowInSector == ROWOFFSETSTACK[i] - 1) {

return true;

}

}

return false;

}

bool Mapper::isBelowSpacerCross(int rowInSector, int padInRow)

{

static std::vector<bool> ROWSBELOWCROSS{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0};

if (ROWSBELOWCROSS[rowInSector]) {

return true;

}

const auto& mapper = instance();

const auto padCenter = mapper.getNumberOfPadsInRowSector(rowInSector) / 2;

if (padInRow == padCenter || padInRow == padCenter - 1) {

return true;

}

return false;

}

} // namespace tpc

} // namespace o2