[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCMapping.cxx

// $Id$
/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        * 
 * ALICE Experiment at CERN, All rights reserved.                         *
 *                                                                        *
 * Primary Authors: Kenneth Aamodt <kenneth@ift.uib.no>                   *
 *                  for The ALICE HLT Project.                            *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/** @file   AliHLTTPCMapping.cxx
    @author Kenneth Aamodt
    @date   
    @brief  A mapping class for the TPC.
*/

// see header file for class documentation                                   //
// or                                                                        //
// refer to README to build package                                          //
// or                                                                        //
// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt                          //

#if __GNUC__>= 3
using namespace std;
#endif
#include <cassert>
#include "AliHLTTPCMapping.h"
#include "AliHLTTPCTransform.h"

ClassImp(AliHLTTPCMapping)

AliHLTTPCMapping::AliHLTTPCMapping(UInt_t patch)
  :
  fPatch(patch),
  fCurrentRowMapping(NULL),
  fCurrentPadMapping(NULL),
  fNofRows(0),
  fMaxHWAdd(0),
  fRowOffset(0)
{
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt

  assert(patch<fgkNofPatches);
  if (patch>=fgkNofPatches) fPatch=0; // just to avoid boundary overflow

  // Get the row offset.
  // we have several possibilities to count the rows:
  // - A: absolute number: 0 to 158 over all partitions
  // - B: sectorwise: 0 to 62 for inner, 0 to 95 for outer sector
  // - C: within a partition: the mappping class is designed to return the
  //   mapping within a partition.
  // The mapping files use scheme B. We have to subtract the first row.
  // AliHLTTPCTransform::GetFirstRow returns first row in scheme A.
  fNofRows=AliHLTTPCTransform::GetNRows(patch);
  fRowOffset=AliHLTTPCTransform::GetFirstRow(patch);

  if(!fgMappingIsDone[patch]){
    ReadArray(patch, fgkMappingSize[patch], fgRowMapping[patch], fgPadMapping[patch], fgkMappingHwaSize, fgHwaMapping[patch]);
    fgMappingIsDone[patch]=kTRUE;
  }
  fCurrentRowMapping=fgRowMapping[patch];
  fCurrentPadMapping=fgPadMapping[patch];
  fMaxHWAdd=fgkMappingSize[patch];
}

Bool_t AliHLTTPCMapping::fgMappingIsDone[fgkNofPatches]={
  kFALSE,
  kFALSE,
  kFALSE,
  kFALSE,
  kFALSE,
  kFALSE
};

const UInt_t AliHLTTPCMapping::fgkMappingSize[fgkNofPatches]={
  AliHLTTPCMapping::fgkMapping0Size,
  AliHLTTPCMapping::fgkMapping1Size,
  AliHLTTPCMapping::fgkMapping2Size,
  AliHLTTPCMapping::fgkMapping3Size,
  AliHLTTPCMapping::fgkMapping4Size,
  AliHLTTPCMapping::fgkMapping5Size
};

UInt_t AliHLTTPCMapping::fgRowMapping0[fgkMapping0Size];
UInt_t AliHLTTPCMapping::fgPadMapping0[fgkMapping0Size];
UInt_t AliHLTTPCMapping::fgHwaMapping0[fgkMappingHwaSize];
UInt_t AliHLTTPCMapping::fgRowMapping1[fgkMapping1Size];
UInt_t AliHLTTPCMapping::fgPadMapping1[fgkMapping1Size];
UInt_t AliHLTTPCMapping::fgHwaMapping1[fgkMappingHwaSize];
UInt_t AliHLTTPCMapping::fgRowMapping2[fgkMapping2Size];
UInt_t AliHLTTPCMapping::fgPadMapping2[fgkMapping2Size];
UInt_t AliHLTTPCMapping::fgHwaMapping2[fgkMappingHwaSize];
UInt_t AliHLTTPCMapping::fgRowMapping3[fgkMapping3Size];
UInt_t AliHLTTPCMapping::fgPadMapping3[fgkMapping3Size];
UInt_t AliHLTTPCMapping::fgHwaMapping3[fgkMappingHwaSize];
UInt_t AliHLTTPCMapping::fgRowMapping4[fgkMapping4Size];
UInt_t AliHLTTPCMapping::fgPadMapping4[fgkMapping4Size];
UInt_t AliHLTTPCMapping::fgHwaMapping4[fgkMappingHwaSize];
UInt_t AliHLTTPCMapping::fgRowMapping5[fgkMapping5Size];
UInt_t AliHLTTPCMapping::fgPadMapping5[fgkMapping5Size];
UInt_t AliHLTTPCMapping::fgHwaMapping5[fgkMappingHwaSize];

UInt_t* AliHLTTPCMapping::fgRowMapping[fgkNofPatches]={
  AliHLTTPCMapping::fgRowMapping0,
  AliHLTTPCMapping::fgRowMapping1,
  AliHLTTPCMapping::fgRowMapping2,
  AliHLTTPCMapping::fgRowMapping3,
  AliHLTTPCMapping::fgRowMapping4,
  AliHLTTPCMapping::fgRowMapping5
};

UInt_t* AliHLTTPCMapping::fgPadMapping[fgkNofPatches]={
  AliHLTTPCMapping::fgPadMapping0,
  AliHLTTPCMapping::fgPadMapping1,
  AliHLTTPCMapping::fgPadMapping2,
  AliHLTTPCMapping::fgPadMapping3,
  AliHLTTPCMapping::fgPadMapping4,
  AliHLTTPCMapping::fgPadMapping5
};

UInt_t* AliHLTTPCMapping::fgHwaMapping[fgkNofPatches]={
  AliHLTTPCMapping::fgHwaMapping0,
  AliHLTTPCMapping::fgHwaMapping1,
  AliHLTTPCMapping::fgHwaMapping2,
  AliHLTTPCMapping::fgHwaMapping3,
  AliHLTTPCMapping::fgHwaMapping4,
  AliHLTTPCMapping::fgHwaMapping5
};

AliHLTTPCMapping::~AliHLTTPCMapping(){
  // see header file for class documentation
}

void AliHLTTPCMapping::InitializeMap(UInt_t patch)
{
  // see header file for class documentation
  // method is deprecated, just kept as history for a while

  UInt_t fNRowsToSubtract=0;
  //The row numbers returned by digit readers used are not from zero always
  switch(patch){
  case 0:
    fNRowsToSubtract=0;
    break;
  case 1:
    fNRowsToSubtract=30;
    break;
  case 2:
    fNRowsToSubtract=0;
    break;
  case 3:
    fNRowsToSubtract=27;
    break;
  case 4:
    fNRowsToSubtract=54;
    break;
  case 5:
    fNRowsToSubtract=76;
    break;
  }

  //Making mapping arrays for the given patch
  ifstream inFile;
  TString filename;
  const char* basePath=getenv("ALICE_ROOT");
  if (basePath) {
    filename.Form("%s/TPC/mapping/Patch%d.data", basePath,patch);
  }
  inFile.open(filename.Data());
  if (!inFile) {
    HLTFatal("Unable to open file: %s      This means no mapping is provided.", filename.Data());
  }
  else{
    UInt_t nHWAdd=0;
    if(inFile >> nHWAdd){
      if(inFile >> fMaxHWAdd){
        UInt_t hwAdd=0;
        UInt_t row=0;
        UInt_t pad=0;
	switch(patch){
	case 0:
	  if(fgkMappingSize[patch]<fMaxHWAdd){
	    HLTFatal("Max hardware address exceeded for patch %d, max number is %d, number from mapping file is %d.",patch,fgkMappingSize[patch] ,fMaxHWAdd);
	    break;
	  }
	  while(inFile>>hwAdd && inFile>>row && inFile>>pad){
	    if (hwAdd>fMaxHWAdd) {
	      HLTFatal("hardware address exceeds max hwAddress %d, mapping file %s corrupted?", fMaxHWAdd);
	      break;
	    }
	    fgRowMapping0[hwAdd]=row-fNRowsToSubtract;
	    fgPadMapping0[hwAdd]=pad;
	  }
	  fgMappingIsDone[patch]=kTRUE;
	  break;
	case 1:
	  if(fgkMappingSize[patch]<fMaxHWAdd){
	    HLTFatal("Max hardware address exceeded for patch %d, max number is %d, number from mapping file is %d.",patch,fgkMappingSize[patch] ,fMaxHWAdd);
	    break;
	  }
	  while(inFile>>hwAdd && inFile>>row && inFile>>pad){
	    if (hwAdd>fMaxHWAdd) {
	      HLTFatal("hardware address exceeds max hwAddress %d, mapping file %s corrupted?", fMaxHWAdd);
	      break;
	    }
	    fgRowMapping1[hwAdd]=row-fNRowsToSubtract;
	    fgPadMapping1[hwAdd]=pad;
	  }
	  fgMappingIsDone[patch]=kTRUE;
	  break;
	case 2:
	  if(fgkMappingSize[patch]<fMaxHWAdd){
	    HLTFatal("Max hardware address exceeded for patch %d, max number is %d number from mapping file is %d.",patch,fgkMappingSize[patch] ,fMaxHWAdd);
	    break;
	  }
	  while(inFile>>hwAdd && inFile>>row && inFile>>pad){
	    if (hwAdd>fMaxHWAdd) {
	      HLTFatal("hardware address exceeds max hwAddress %d, mapping file %s corrupted?", fMaxHWAdd);
	      break;
	    }
	    fgRowMapping2[hwAdd]=row-fNRowsToSubtract;
	    fgPadMapping2[hwAdd]=pad;
	  }
	  fgMappingIsDone[patch]=kTRUE;
	  break;
	case 3:
	  if(fgkMappingSize[patch]<fMaxHWAdd){
	    HLTFatal("Max hardware address exceeded for patch %d, max number is %d number from mapping file is %d.",patch,fgkMappingSize[patch] ,fMaxHWAdd);
	    break;
	  }
	  while(inFile>>hwAdd && inFile>>row && inFile>>pad){
	    if (hwAdd>fMaxHWAdd) {
	      HLTFatal("hardware address exceeds max hwAddress %d, mapping file %s corrupted?", fMaxHWAdd);
	      break;
	    }
	    fgRowMapping3[hwAdd]=row-fNRowsToSubtract;
	    fgPadMapping3[hwAdd]=pad;
	  }
	  fgMappingIsDone[patch]=kTRUE;
	  break;
	case 4:
	  if(fgkMappingSize[patch]<fMaxHWAdd){
	    HLTFatal("Max hardware address exceeded for patch %d, max number is %d number from mapping file is %d.",patch,fgkMappingSize[patch] ,fMaxHWAdd);
	    break;
	  }
	  while(inFile>>hwAdd && inFile>>row && inFile>>pad){
	    if (hwAdd>fMaxHWAdd) {
	      HLTFatal("hardware address exceeds max hwAddress %d, mapping file %s corrupted?", fMaxHWAdd);
	      break;
	    }
	    fgRowMapping4[hwAdd]=row-fNRowsToSubtract;
	    fgPadMapping4[(UInt_t)hwAdd]=(UInt_t)pad;
	  }
	  fgMappingIsDone[patch]=kTRUE;
	  break;
	case 5:
	  if(fgkMappingSize[patch]<fMaxHWAdd){
	    HLTFatal("Max hardware address exceeded for patch %d, max number is %d number from mapping file is %d.",patch,fgkMappingSize[patch] ,fMaxHWAdd);
	    break;
	  }
	  while(inFile>>hwAdd && inFile>>row && inFile>>pad){
	    if (hwAdd>fMaxHWAdd) {
	      HLTFatal("hardware address exceeds max hwAddress %d, mapping file %s corrupted?", fMaxHWAdd);
	      break;
	    }
	    fgRowMapping5[hwAdd]=row-fNRowsToSubtract;
	    fgPadMapping5[hwAdd]=pad;
	  }
	  fgMappingIsDone[patch]=kTRUE;
	  break;
	}
      }
    }
  }
  inFile.close();
}

UInt_t AliHLTTPCMapping::GetRow(UInt_t hwadd) const
{
  // see header file for class documentation
  assert(fCurrentRowMapping);
  if (!fCurrentRowMapping) return 0;
  if (hwadd>fMaxHWAdd) return 0;
  return fCurrentRowMapping[hwadd];
}

UInt_t AliHLTTPCMapping::GetPad(UInt_t hwadd) const
{
  // see header file for class documentation
  assert(fCurrentPadMapping);
  if (!fCurrentPadMapping) return 0;
  if (hwadd>fMaxHWAdd) return 0;
  return fCurrentPadMapping[hwadd];
}

UInt_t AliHLTTPCMapping::GetHwAddress(UInt_t row, UInt_t pad) const
{
  // see header file for class documentation
  assert(fPatch<fgkNofPatches);
  assert(fgHwaMapping[fPatch]);
  UInt_t hwaIndex=(row<<fgkMappingHwaRowBitShift) + pad;
  if (hwaIndex<fgkMappingHwaSize) {
    return (fgHwaMapping[fPatch])[hwaIndex];
  }
  return ~((UInt_t)0);
}

Bool_t AliHLTTPCMapping::ReadArray(UInt_t patch, UInt_t arraySize, UInt_t rowArray[], UInt_t padArray[], UInt_t hwaMappingSize, UInt_t hwaArray[]) const
{
  // see header file for class documentation
  //Making mapping arrays for the given patch
  Bool_t result=kTRUE;

  assert(rowArray!=NULL || padArray!=NULL || hwaArray!=NULL);
  if (!rowArray || !padArray || !hwaArray) return kFALSE;

  memset(rowArray, 0, arraySize*sizeof(rowArray[0]));
  memset(padArray, 0, arraySize*sizeof(padArray[0]));
  memset(hwaArray, 0, hwaMappingSize*sizeof(padArray[0]));

  ifstream inFile;
  TString filename;
  const char* basePath=getenv("ALICE_ROOT");
  if (basePath) {
    filename.Form("%s/TPC/mapping/Patch%d.data", basePath,patch);
  }
  inFile.open(filename.Data());
  if (!inFile) {
    HLTFatal("Unable to open file: %s      This means no mapping is provided.", filename.Data());
    return kFALSE;
  }

  UInt_t nHWAdd=0;
  UInt_t maxHWAdd=0;
  if(inFile >> nHWAdd){
    if(inFile >> maxHWAdd){
      if(arraySize<maxHWAdd){
	HLTFatal("Max hardware address exceeded for patch %d, max number is %d, number from mapping file is %d.",patch, arraySize ,fMaxHWAdd);
	result=kFALSE;
      }
      UInt_t hwAdd=0;
      UInt_t row=0;
      UInt_t pad=0;
      while(result && inFile>>hwAdd && inFile>>row && inFile>>pad){
	if (hwAdd>maxHWAdd) {
	  HLTFatal("hardware address exceeds max hwAddress %d, mapping file %s corrupted?", maxHWAdd);
	  result=kFALSE;
	  break;
	}
	Int_t dummy=0;
	// AliHLTTPCTransform::GetFirstRow returns first row in scheme A.
	// We have to transform to scheme B by AliHLTTPCTransform::Slice2Sector.
	Int_t offsetSchemeB=0;
	AliHLTTPCTransform::Slice2Sector(0, fRowOffset, dummy, offsetSchemeB);
	rowArray[hwAdd]=row-offsetSchemeB;
	padArray[hwAdd]=pad;
	UInt_t hwaIndex=(rowArray[hwAdd]<<fgkMappingHwaRowBitShift) + padArray[hwAdd];
	assert(hwaIndex<hwaMappingSize);
	if (hwaIndex<hwaMappingSize) {
	  hwaArray[hwaIndex]=hwAdd;
	}
      }
    }
  }
  inFile.close();
  return result;
}

Bool_t AliHLTTPCMapping::IsValidHWAddress(UInt_t hwadd) const
{
  if (hwadd>fMaxHWAdd){
    return kFALSE;
  }
  else{
    return kTRUE;
  }
}
Commit	Line	Data
	1	// $Id$
	2	/**************************************************************************
	3	* This file is property of and copyright by the ALICE HLT Project *
	4	* ALICE Experiment at CERN, All rights reserved. *
	5	* *
	6	* Primary Authors: Kenneth Aamodt <kenneth@ift.uib.no> *
	7	* for The ALICE HLT Project. *
	8	* *
	9	* Permission to use, copy, modify and distribute this software and its *
	10	* documentation strictly for non-commercial purposes is hereby granted *
	11	* without fee, provided that the above copyright notice appears in all *
	12	* copies and that both the copyright notice and this permission notice *
	13	* appear in the supporting documentation. The authors make no claims *
	14	* about the suitability of this software for any purpose. It is *
	15	* provided "as is" without express or implied warranty. *
	16	**************************************************************************/
	17
	18	/** @file AliHLTTPCMapping.cxx
	19	@author Kenneth Aamodt
	20	@date
	21	@brief A mapping class for the TPC.
	22	*/
	23
	24	// see header file for class documentation //
	25	// or //
	26	// refer to README to build package //
	27	// or //
	28	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt //
	29
	30	#if __GNUC__>= 3
	31	using namespace std;
	32	#endif
	33	#include <cassert>
	34	#include "AliHLTTPCMapping.h"
	35	#include "AliHLTTPCTransform.h"
	36
	37	ClassImp(AliHLTTPCMapping)
	38
	39	AliHLTTPCMapping::AliHLTTPCMapping(UInt_t patch)
	40	:
	41	fPatch(patch),
	42	fCurrentRowMapping(NULL),
	43	fCurrentPadMapping(NULL),
	44	fNofRows(0),
	45	fMaxHWAdd(0),
	46	fRowOffset(0)
	47	{
	48	// see header file for class documentation
	49	// or
	50	// refer to README to build package
	51	// or
	52	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	53
	54	assert(patch<fgkNofPatches);
	55	if (patch>=fgkNofPatches) fPatch=0; // just to avoid boundary overflow
	56
	57	// Get the row offset.
	58	// we have several possibilities to count the rows:
	59	// - A: absolute number: 0 to 158 over all partitions
	60	// - B: sectorwise: 0 to 62 for inner, 0 to 95 for outer sector
	61	// - C: within a partition: the mappping class is designed to return the
	62	// mapping within a partition.
	63	// The mapping files use scheme B. We have to subtract the first row.
	64	// AliHLTTPCTransform::GetFirstRow returns first row in scheme A.
	65	fNofRows=AliHLTTPCTransform::GetNRows(patch);
	66	fRowOffset=AliHLTTPCTransform::GetFirstRow(patch);
	67
	68	if(!fgMappingIsDone[patch]){
	69	ReadArray(patch, fgkMappingSize[patch], fgRowMapping[patch], fgPadMapping[patch], fgkMappingHwaSize, fgHwaMapping[patch]);
	70	fgMappingIsDone[patch]=kTRUE;
	71	}
	72	fCurrentRowMapping=fgRowMapping[patch];
	73	fCurrentPadMapping=fgPadMapping[patch];
	74	fMaxHWAdd=fgkMappingSize[patch];
	75	}
	76
	77	Bool_t AliHLTTPCMapping::fgMappingIsDone[fgkNofPatches]={
	78	kFALSE,
	79	kFALSE,
	80	kFALSE,
	81	kFALSE,
	82	kFALSE,
	83	kFALSE
	84	};
	85
	86	const UInt_t AliHLTTPCMapping::fgkMappingSize[fgkNofPatches]={
	87	AliHLTTPCMapping::fgkMapping0Size,
	88	AliHLTTPCMapping::fgkMapping1Size,
	89	AliHLTTPCMapping::fgkMapping2Size,
	90	AliHLTTPCMapping::fgkMapping3Size,
	91	AliHLTTPCMapping::fgkMapping4Size,
	92	AliHLTTPCMapping::fgkMapping5Size
	93	};
	94
	95	UInt_t AliHLTTPCMapping::fgRowMapping0[fgkMapping0Size];
	96	UInt_t AliHLTTPCMapping::fgPadMapping0[fgkMapping0Size];
	97	UInt_t AliHLTTPCMapping::fgHwaMapping0[fgkMappingHwaSize];
	98	UInt_t AliHLTTPCMapping::fgRowMapping1[fgkMapping1Size];
	99	UInt_t AliHLTTPCMapping::fgPadMapping1[fgkMapping1Size];
	100	UInt_t AliHLTTPCMapping::fgHwaMapping1[fgkMappingHwaSize];
	101	UInt_t AliHLTTPCMapping::fgRowMapping2[fgkMapping2Size];
	102	UInt_t AliHLTTPCMapping::fgPadMapping2[fgkMapping2Size];
	103	UInt_t AliHLTTPCMapping::fgHwaMapping2[fgkMappingHwaSize];
	104	UInt_t AliHLTTPCMapping::fgRowMapping3[fgkMapping3Size];
	105	UInt_t AliHLTTPCMapping::fgPadMapping3[fgkMapping3Size];
	106	UInt_t AliHLTTPCMapping::fgHwaMapping3[fgkMappingHwaSize];
	107	UInt_t AliHLTTPCMapping::fgRowMapping4[fgkMapping4Size];
	108	UInt_t AliHLTTPCMapping::fgPadMapping4[fgkMapping4Size];
	109	UInt_t AliHLTTPCMapping::fgHwaMapping4[fgkMappingHwaSize];
	110	UInt_t AliHLTTPCMapping::fgRowMapping5[fgkMapping5Size];
	111	UInt_t AliHLTTPCMapping::fgPadMapping5[fgkMapping5Size];
	112	UInt_t AliHLTTPCMapping::fgHwaMapping5[fgkMappingHwaSize];
	113
	114	UInt_t* AliHLTTPCMapping::fgRowMapping[fgkNofPatches]={
	115	AliHLTTPCMapping::fgRowMapping0,
	116	AliHLTTPCMapping::fgRowMapping1,
	117	AliHLTTPCMapping::fgRowMapping2,
	118	AliHLTTPCMapping::fgRowMapping3,
	119	AliHLTTPCMapping::fgRowMapping4,
	120	AliHLTTPCMapping::fgRowMapping5
	121	};
	122
	123	UInt_t* AliHLTTPCMapping::fgPadMapping[fgkNofPatches]={
	124	AliHLTTPCMapping::fgPadMapping0,
	125	AliHLTTPCMapping::fgPadMapping1,
	126	AliHLTTPCMapping::fgPadMapping2,
	127	AliHLTTPCMapping::fgPadMapping3,
	128	AliHLTTPCMapping::fgPadMapping4,
	129	AliHLTTPCMapping::fgPadMapping5
	130	};
	131
	132	UInt_t* AliHLTTPCMapping::fgHwaMapping[fgkNofPatches]={
	133	AliHLTTPCMapping::fgHwaMapping0,
	134	AliHLTTPCMapping::fgHwaMapping1,
	135	AliHLTTPCMapping::fgHwaMapping2,
	136	AliHLTTPCMapping::fgHwaMapping3,
	137	AliHLTTPCMapping::fgHwaMapping4,
	138	AliHLTTPCMapping::fgHwaMapping5
	139	};
	140
	141	AliHLTTPCMapping::~AliHLTTPCMapping(){
	142	// see header file for class documentation
	143	}
	144
	145	void AliHLTTPCMapping::InitializeMap(UInt_t patch)
	146	{
	147	// see header file for class documentation
	148	// method is deprecated, just kept as history for a while
	149
	150	UInt_t fNRowsToSubtract=0;
	151	//The row numbers returned by digit readers used are not from zero always
	152	switch(patch){
	153	case 0:
	154	fNRowsToSubtract=0;
	155	break;
	156	case 1:
	157	fNRowsToSubtract=30;
	158	break;
	159	case 2:
	160	fNRowsToSubtract=0;
	161	break;
	162	case 3:
	163	fNRowsToSubtract=27;
	164	break;
	165	case 4:
	166	fNRowsToSubtract=54;
	167	break;
	168	case 5:
	169	fNRowsToSubtract=76;
	170	break;
	171	}
	172
	173	//Making mapping arrays for the given patch
	174	ifstream inFile;
	175	TString filename;
	176	const char* basePath=getenv("ALICE_ROOT");
	177	if (basePath) {
	178	filename.Form("%s/TPC/mapping/Patch%d.data", basePath,patch);
	179	}
	180	inFile.open(filename.Data());
	181	if (!inFile) {
	182	HLTFatal("Unable to open file: %s This means no mapping is provided.", filename.Data());
	183	}
	184	else{
	185	UInt_t nHWAdd=0;
	186	if(inFile >> nHWAdd){
	187	if(inFile >> fMaxHWAdd){
	188	UInt_t hwAdd=0;
	189	UInt_t row=0;
	190	UInt_t pad=0;
	191	switch(patch){
	192	case 0:
	193	if(fgkMappingSize[patch]<fMaxHWAdd){
	194	HLTFatal("Max hardware address exceeded for patch %d, max number is %d, number from mapping file is %d.",patch,fgkMappingSize[patch] ,fMaxHWAdd);
	195	break;
	196	}
	197	while(inFile>>hwAdd && inFile>>row && inFile>>pad){
	198	if (hwAdd>fMaxHWAdd) {
	199	HLTFatal("hardware address exceeds max hwAddress %d, mapping file %s corrupted?", fMaxHWAdd);
	200	break;
	201	}
	202	fgRowMapping0[hwAdd]=row-fNRowsToSubtract;
	203	fgPadMapping0[hwAdd]=pad;
	204	}
	205	fgMappingIsDone[patch]=kTRUE;
	206	break;
	207	case 1:
	208	if(fgkMappingSize[patch]<fMaxHWAdd){
	209	HLTFatal("Max hardware address exceeded for patch %d, max number is %d, number from mapping file is %d.",patch,fgkMappingSize[patch] ,fMaxHWAdd);
	210	break;
	211	}
	212	while(inFile>>hwAdd && inFile>>row && inFile>>pad){
	213	if (hwAdd>fMaxHWAdd) {
	214	HLTFatal("hardware address exceeds max hwAddress %d, mapping file %s corrupted?", fMaxHWAdd);
	215	break;
	216	}
	217	fgRowMapping1[hwAdd]=row-fNRowsToSubtract;
	218	fgPadMapping1[hwAdd]=pad;
	219	}
	220	fgMappingIsDone[patch]=kTRUE;
	221	break;
	222	case 2:
	223	if(fgkMappingSize[patch]<fMaxHWAdd){
	224	HLTFatal("Max hardware address exceeded for patch %d, max number is %d number from mapping file is %d.",patch,fgkMappingSize[patch] ,fMaxHWAdd);
	225	break;
	226	}
	227	while(inFile>>hwAdd && inFile>>row && inFile>>pad){
	228	if (hwAdd>fMaxHWAdd) {
	229	HLTFatal("hardware address exceeds max hwAddress %d, mapping file %s corrupted?", fMaxHWAdd);
	230	break;
	231	}
	232	fgRowMapping2[hwAdd]=row-fNRowsToSubtract;
	233	fgPadMapping2[hwAdd]=pad;
	234	}
	235	fgMappingIsDone[patch]=kTRUE;
	236	break;
	237	case 3:
	238	if(fgkMappingSize[patch]<fMaxHWAdd){
	239	HLTFatal("Max hardware address exceeded for patch %d, max number is %d number from mapping file is %d.",patch,fgkMappingSize[patch] ,fMaxHWAdd);
	240	break;
	241	}
	242	while(inFile>>hwAdd && inFile>>row && inFile>>pad){
	243	if (hwAdd>fMaxHWAdd) {
	244	HLTFatal("hardware address exceeds max hwAddress %d, mapping file %s corrupted?", fMaxHWAdd);
	245	break;
	246	}
	247	fgRowMapping3[hwAdd]=row-fNRowsToSubtract;
	248	fgPadMapping3[hwAdd]=pad;
	249	}
	250	fgMappingIsDone[patch]=kTRUE;
	251	break;
	252	case 4:
	253	if(fgkMappingSize[patch]<fMaxHWAdd){
	254	HLTFatal("Max hardware address exceeded for patch %d, max number is %d number from mapping file is %d.",patch,fgkMappingSize[patch] ,fMaxHWAdd);
	255	break;
	256	}
	257	while(inFile>>hwAdd && inFile>>row && inFile>>pad){
	258	if (hwAdd>fMaxHWAdd) {
	259	HLTFatal("hardware address exceeds max hwAddress %d, mapping file %s corrupted?", fMaxHWAdd);
	260	break;
	261	}
	262	fgRowMapping4[hwAdd]=row-fNRowsToSubtract;
	263	fgPadMapping4[(UInt_t)hwAdd]=(UInt_t)pad;
	264	}
	265	fgMappingIsDone[patch]=kTRUE;
	266	break;
	267	case 5:
	268	if(fgkMappingSize[patch]<fMaxHWAdd){
	269	HLTFatal("Max hardware address exceeded for patch %d, max number is %d number from mapping file is %d.",patch,fgkMappingSize[patch] ,fMaxHWAdd);
	270	break;
	271	}
	272	while(inFile>>hwAdd && inFile>>row && inFile>>pad){
	273	if (hwAdd>fMaxHWAdd) {
	274	HLTFatal("hardware address exceeds max hwAddress %d, mapping file %s corrupted?", fMaxHWAdd);
	275	break;
	276	}
	277	fgRowMapping5[hwAdd]=row-fNRowsToSubtract;
	278	fgPadMapping5[hwAdd]=pad;
	279	}
	280	fgMappingIsDone[patch]=kTRUE;
	281	break;
	282	}
	283	}
	284	}
	285	}
	286	inFile.close();
	287	}
	288
	289	UInt_t AliHLTTPCMapping::GetRow(UInt_t hwadd) const
	290	{
	291	// see header file for class documentation
	292	assert(fCurrentRowMapping);
	293	if (!fCurrentRowMapping) return 0;
	294	if (hwadd>fMaxHWAdd) return 0;
	295	return fCurrentRowMapping[hwadd];
	296	}
	297
	298	UInt_t AliHLTTPCMapping::GetPad(UInt_t hwadd) const
	299	{
	300	// see header file for class documentation
	301	assert(fCurrentPadMapping);
	302	if (!fCurrentPadMapping) return 0;
	303	if (hwadd>fMaxHWAdd) return 0;
	304	return fCurrentPadMapping[hwadd];
	305	}
	306
	307	UInt_t AliHLTTPCMapping::GetHwAddress(UInt_t row, UInt_t pad) const
	308	{
	309	// see header file for class documentation
	310	assert(fPatch<fgkNofPatches);
	311	assert(fgHwaMapping[fPatch]);
	312	UInt_t hwaIndex=(row<<fgkMappingHwaRowBitShift) + pad;
	313	if (hwaIndex<fgkMappingHwaSize) {
	314	return (fgHwaMapping[fPatch])[hwaIndex];
	315	}
	316	return ~((UInt_t)0);
	317	}
	318
	319	Bool_t AliHLTTPCMapping::ReadArray(UInt_t patch, UInt_t arraySize, UInt_t rowArray[], UInt_t padArray[], UInt_t hwaMappingSize, UInt_t hwaArray[]) const
	320	{
	321	// see header file for class documentation
	322	//Making mapping arrays for the given patch
	323	Bool_t result=kTRUE;
	324
	325	assert(rowArray!=NULL \|\| padArray!=NULL \|\| hwaArray!=NULL);
	326	if (!rowArray \|\| !padArray \|\| !hwaArray) return kFALSE;
	327
	328	memset(rowArray, 0, arraySize*sizeof(rowArray[0]));
	329	memset(padArray, 0, arraySize*sizeof(padArray[0]));
	330	memset(hwaArray, 0, hwaMappingSize*sizeof(padArray[0]));
	331
	332	ifstream inFile;
	333	TString filename;
	334	const char* basePath=getenv("ALICE_ROOT");
	335	if (basePath) {
	336	filename.Form("%s/TPC/mapping/Patch%d.data", basePath,patch);
	337	}
	338	inFile.open(filename.Data());
	339	if (!inFile) {
	340	HLTFatal("Unable to open file: %s This means no mapping is provided.", filename.Data());
	341	return kFALSE;
	342	}
	343
	344	UInt_t nHWAdd=0;
	345	UInt_t maxHWAdd=0;
	346	if(inFile >> nHWAdd){
	347	if(inFile >> maxHWAdd){
	348	if(arraySize<maxHWAdd){
	349	HLTFatal("Max hardware address exceeded for patch %d, max number is %d, number from mapping file is %d.",patch, arraySize ,fMaxHWAdd);
	350	result=kFALSE;
	351	}
	352	UInt_t hwAdd=0;
	353	UInt_t row=0;
	354	UInt_t pad=0;
	355	while(result && inFile>>hwAdd && inFile>>row && inFile>>pad){
	356	if (hwAdd>maxHWAdd) {
	357	HLTFatal("hardware address exceeds max hwAddress %d, mapping file %s corrupted?", maxHWAdd);
	358	result=kFALSE;
	359	break;
	360	}
	361	Int_t dummy=0;
	362	// AliHLTTPCTransform::GetFirstRow returns first row in scheme A.
	363	// We have to transform to scheme B by AliHLTTPCTransform::Slice2Sector.
	364	Int_t offsetSchemeB=0;
	365	AliHLTTPCTransform::Slice2Sector(0, fRowOffset, dummy, offsetSchemeB);
	366	rowArray[hwAdd]=row-offsetSchemeB;
	367	padArray[hwAdd]=pad;
	368	UInt_t hwaIndex=(rowArray[hwAdd]<<fgkMappingHwaRowBitShift) + padArray[hwAdd];
	369	assert(hwaIndex<hwaMappingSize);
	370	if (hwaIndex<hwaMappingSize) {
	371	hwaArray[hwaIndex]=hwAdd;
	372	}
	373	}
	374	}
	375	}
	376	inFile.close();
	377	return result;
	378	}
	379
	380	Bool_t AliHLTTPCMapping::IsValidHWAddress(UInt_t hwadd) const
	381	{
	382	if (hwadd>fMaxHWAdd){
	383	return kFALSE;
	384	}
	385	else{
	386	return kTRUE;
	387	}
	388	}