[u/mrichter/AliRoot.git] / RAW / AliCaloAltroMapping.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * 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.                  *
 **************************************************************************/
/* $Id$ */

// This class handles the mapping of the Altro channels in the PHOS/EMCAL
// The mapping is read from an external mapping files
// Author: C.Cheshkov

/// Exported from PHOS to be used also by EMCAL
/// November 2006 Gustavo Conesa Balbastre

#include "AliCaloAltroMapping.h"
#include "AliLog.h"
#include <Riostream.h>
//#include <stdlib.h>


ClassImp(AliCaloAltroMapping)

//_____________________________________________________________________________
AliCaloAltroMapping::AliCaloAltroMapping():
  AliAltroMapping(),
  fMinRow(0),
  fMaxRow(0),
  fMinCol(0),
  fMaxCol(0),
  fInvMappingLow(NULL),
  fInvMappingHigh(NULL)
{
  // Default constructor
}

//_____________________________________________________________________________
AliCaloAltroMapping::AliCaloAltroMapping(const char *mappingFile):
  AliAltroMapping(mappingFile),
  fMinRow(0),
  fMaxRow(0),
  fMinCol(0),
  fMaxCol(0),
  fInvMappingLow(NULL),
  fInvMappingHigh(NULL)
{
  // Constructor
  ReadMapping();
  CloseMappingFile();
}

//_____________________________________________________________________________
AliCaloAltroMapping::~AliCaloAltroMapping()
{
  // destructor
  // Deletes the arrays which have been
  // allocated during the reading of the
  // mapping file
  if (fInvMappingLow) delete [] fInvMappingLow;

  if (fInvMappingHigh) delete [] fInvMappingHigh;
}

//_____________________________________________________________________________
Bool_t AliCaloAltroMapping::ReadMapping()
{
  // Initalizes the ALTRO mapping from a file
  // Look at the Calo module for the format of
  // the mapping file
  if (!fIn) {
    AliFatal("Mapping file has not been opened !");
    return kFALSE;
  }

  fMinRow = 0x7fffffff;
  fMaxRow = 0;
  fMinCol = 0x7fffffff;
  fMaxCol = 0;
  fMappingSize = 3*(fMaxHWAddress+1);
  fMapping = new Short_t[fMappingSize];
  for (Int_t i = 0; i <= fMaxHWAddress; i++) {
    fMapping[3*i] = fMapping[3*i+1] = fMapping[3*i+2] = -1;
  }
 
  for(Int_t i = 0; i < fNumberOfChannels ; i++) { // 1792 = 2*896 channels connected to each RCU
    Int_t hwAddress;
    if (!(*fIn >> hwAddress)) {
      AliFatal("Syntax of the mapping file is wrong !");
      return kFALSE;
    }
    if (hwAddress > fMaxHWAddress) {
      AliFatal(Form("Hardware (ALTRO) adress (%d) outside the range (0 -> %d) !",hwAddress,fMaxHWAddress));
      return kFALSE;
    }
    Int_t row,col,gain;
    if (!(*fIn >> row >> col >> gain)) {
      AliFatal("Syntax of the mapping file is wrong !");
      return kFALSE;
    }

    if (gain < 0 || gain > 1) {
      AliFatal(Form("Wrong gain value found (%d)! Should be 0 or 1 !",gain));
      return kFALSE;
    }
 
    fMapping[3*hwAddress] = row;
    fMapping[3*hwAddress+1] = col;
    fMapping[3*hwAddress+2] = gain;

    if (row > fMaxRow) fMaxRow = row;
    if (row < fMinRow) fMinRow = row;
    if (col > fMaxCol) fMaxCol = col;
    if (col < fMinCol) fMinCol = col;

  }

  return kTRUE;
}

//_____________________________________________________________________________
Bool_t AliCaloAltroMapping::CreateInvMapping()
{
  // Create the inverse mapping
  // needed for the simulation of
  // raw data
  if (fInvMappingLow) return kTRUE;

  if (!fMapping) {
    AliWarning("Mapping array was not initalized correctly ! Impossible to create the inverse mapping !");
    return kFALSE;
  }

  Int_t nRows = fMaxRow - fMinRow + 1;
  Int_t nCols = fMaxCol - fMinCol + 1;
  Int_t invMappingSize = nRows*nCols;

  fInvMappingLow  = new Short_t[invMappingSize];
  fInvMappingHigh = new Short_t[invMappingSize];
  for (Int_t i = 0; i < nRows; i++) {
    for (Int_t j = 0; j < nCols; j++) {
      fInvMappingLow[nCols*i+j]  = -1;
      fInvMappingHigh[nCols*i+j] = -1;
    }
  }

  for(Int_t i = 0; i <= fMaxHWAddress; i++) {
    Int_t row = fMapping[3*i];
    Int_t col = fMapping[3*i+1];
    Int_t gain = fMapping[3*i+2];
    if(row != -1 && col != -1) {
      if (gain == 0)
	fInvMappingLow[nCols*(row-fMinRow)+(col-fMinCol)] = i;
      if (gain == 1)
	fInvMappingHigh[nCols*(row-fMinRow)+(col-fMinCol)] = i;
    }
  }

  return kTRUE;
}

//_____________________________________________________________________________
Int_t AliCaloAltroMapping::GetHWAddress(Int_t row, Int_t col, Int_t gain)
{
  // Get the content of the mapping array
  // return -1 in case there is no hardware
  // adress defined for these row-column-gain
  if (!fInvMappingLow || !fInvMappingHigh) {
    if (!CreateInvMapping()) return -1;
  }
  if (row < fMinRow || row > fMaxRow) {
    AliWarning(Form("Index of row (%d) outside the range (%d -> %d) !",row,fMinRow,fMaxRow));
    return -1;
  }
  if (col < fMinCol || col > fMaxCol) {
    AliWarning(Form("Index of column (%d) outside the range (0 -> %d) !",col,fMinCol,fMaxCol));
    return -1;
  }
  if (gain < 0 || gain > 1) {
    AliWarning(Form("Invalid gain (%d)! Should be 0 or 1 !",gain));
    return -1;
  }
  Int_t hwAddress = -1;
  if (gain == 0)
    hwAddress = fInvMappingLow[(fMaxCol - fMinCol + 1)*(row-fMinRow)+(col-fMinCol)];
  if (gain == 1)
    hwAddress = fInvMappingHigh[(fMaxCol - fMinCol + 1)*(row-fMinRow)+(col-fMinCol)];

  if (hwAddress == -1)
    AliWarning(Form("Hardware (ALTRO) adress is not defined for these row (%d), column (%d) and gain (%d) !",row,col,gain));

  return hwAddress;
}

//_____________________________________________________________________________
Int_t AliCaloAltroMapping::GetPadRow(Int_t hwAddress) const
{
  // Return the row index
  // Note the difference w.r.t to the base class notation
  if (!fMapping) {
    AliWarning("Mapping array was not initalized correctly !");
    return -1;
  }
  if (hwAddress > fMaxHWAddress) {
    AliWarning(Form("Hardware (ALTRO) adress (%d) outside the range (0 -> %d) !",hwAddress,fMaxHWAddress));
    return -1;
  }
  Int_t row = fMapping[3*hwAddress];
  if (row == -1)
    AliWarning(Form("Hardware (ALTRO) adress (%d) is not defined !",hwAddress));

  return row;
}

//_____________________________________________________________________________
Int_t AliCaloAltroMapping::GetPad(Int_t hwAddress) const
{
  // Return the column index
  // Note the difference w.r.t to the base class notation
  if (!fMapping) {
    AliWarning("Mapping array was not initalized correctly !");
    return -1;
  }
  if (hwAddress > fMaxHWAddress) {
    AliWarning(Form("Hardware (ALTRO) adress (%d) outside the range (0 -> %d) !",hwAddress,fMaxHWAddress));
    return -1;
  }
  Int_t col = fMapping[3*hwAddress+1];
  if (col == -1)
    AliWarning(Form("Hardware (ALTRO) adress (%d) is not defined !",hwAddress));

  return col;
}

//_____________________________________________________________________________
Int_t AliCaloAltroMapping::GetSector(Int_t hwAddress) const
{
  // Return the gain factor (0/1)
  // Note the difference w.r.t to the base class notation
  if (!fMapping) {
    AliWarning("Mapping array was not initalized correctly !");
    return -1;
  }
  if (hwAddress > fMaxHWAddress) {
    AliWarning(Form("Hardware (ALTRO) adress (%d) outside the range (0 -> %d) !",hwAddress,fMaxHWAddress));
    return -1;
  }
  Int_t gain = fMapping[3*hwAddress+2];
  if (gain == -1)
    AliWarning(Form("Hardware (ALTRO) adress (%d) is not defined !",hwAddress));

  return gain;
}
Commit	Line	Data
d84933b0	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15	/* $Id$ */
	16
	17	// This class handles the mapping of the Altro channels in the PHOS/EMCAL
	18	// The mapping is read from an external mapping files
	19	// Author: C.Cheshkov
	20
	21	/// Exported from PHOS to be used also by EMCAL
	22	/// November 2006 Gustavo Conesa Balbastre
	23
	24	#include "AliCaloAltroMapping.h"
	25	#include "AliLog.h"
	26	#include <Riostream.h>
	27	//#include <stdlib.h>
	28
	29
	30	ClassImp(AliCaloAltroMapping)
	31
44174d11	32	//_____________________________________________________________________________
	33	AliCaloAltroMapping::AliCaloAltroMapping():
	34	AliAltroMapping(),
	35	fMinRow(0),
	36	fMaxRow(0),
	37	fMinCol(0),
	38	fMaxCol(0),
44174d11	39	fInvMappingLow(NULL),
	40	fInvMappingHigh(NULL)
	41	{
	42	// Default constructor
	43	}
	44
d84933b0	45	//_____________________________________________________________________________
	46	AliCaloAltroMapping::AliCaloAltroMapping(const char *mappingFile):
	47	AliAltroMapping(mappingFile),
	48	fMinRow(0),
	49	fMaxRow(0),
	50	fMinCol(0),
	51	fMaxCol(0),
d84933b0	52	fInvMappingLow(NULL),
	53	fInvMappingHigh(NULL)
	54	{
	55	// Constructor
	56	ReadMapping();
	57	CloseMappingFile();
	58	}
	59
	60	//_____________________________________________________________________________
	61	AliCaloAltroMapping::~AliCaloAltroMapping()
	62	{
	63	// destructor
573322da	64	// Deletes the arrays which have been
	65	// allocated during the reading of the
	66	// mapping file
	67	if (fInvMappingLow) delete [] fInvMappingLow;
	68
	69	if (fInvMappingHigh) delete [] fInvMappingHigh;
d84933b0	70	}
d84933b0	71
d84933b0	72	//_____________________________________________________________________________
	73	Bool_t AliCaloAltroMapping::ReadMapping()
	74	{
	75	// Initalizes the ALTRO mapping from a file
	76	// Look at the Calo module for the format of
	77	// the mapping file
	78	if (!fIn) {
	79	AliFatal("Mapping file has not been opened !");
	80	return kFALSE;
	81	}
	82
	83	fMinRow = 0x7fffffff;
	84	fMaxRow = 0;
	85	fMinCol = 0x7fffffff;
	86	fMaxCol = 0;
44174d11	87	fMappingSize = 3*(fMaxHWAddress+1);
44174d11	88	fMapping = new Short_t[fMappingSize];
d84933b0	89	for (Int_t i = 0; i <= fMaxHWAddress; i++) {
44174d11	90	fMapping[3i] = fMapping[3i+1] = fMapping[3*i+2] = -1;
d84933b0	91	}
	92
	93	for(Int_t i = 0; i < fNumberOfChannels ; i++) { // 1792 = 2*896 channels connected to each RCU
	94	Int_t hwAddress;
	95	if (!(*fIn >> hwAddress)) {
	96	AliFatal("Syntax of the mapping file is wrong !");
	97	return kFALSE;
	98	}
	99	if (hwAddress > fMaxHWAddress) {
	100	AliFatal(Form("Hardware (ALTRO) adress (%d) outside the range (0 -> %d) !",hwAddress,fMaxHWAddress));
	101	return kFALSE;
	102	}
	103	Int_t row,col,gain;
	104	if (!(*fIn >> row >> col >> gain)) {
	105	AliFatal("Syntax of the mapping file is wrong !");
	106	return kFALSE;
	107	}
	108
	109	if (gain < 0 \|\| gain > 1) {
	110	AliFatal(Form("Wrong gain value found (%d)! Should be 0 or 1 !",gain));
	111	return kFALSE;
	112	}
	113
44174d11	114	fMapping[3*hwAddress] = row;
	115	fMapping[3*hwAddress+1] = col;
	116	fMapping[3*hwAddress+2] = gain;
d84933b0	117
	118	if (row > fMaxRow) fMaxRow = row;
	119	if (row < fMinRow) fMinRow = row;
	120	if (col > fMaxCol) fMaxCol = col;
	121	if (col < fMinCol) fMinCol = col;
	122
	123	}
	124
573322da	125	return kTRUE;
	126	}
	127
	128	//_____________________________________________________________________________
	129	Bool_t AliCaloAltroMapping::CreateInvMapping()
	130	{
	131	// Create the inverse mapping
	132	// needed for the simulation of
	133	// raw data
	134	if (fInvMappingLow) return kTRUE;
	135
	136	if (!fMapping) {
	137	AliWarning("Mapping array was not initalized correctly ! Impossible to create the inverse mapping !");
	138	return kFALSE;
	139	}
	140
44174d11	141	Int_t nRows = fMaxRow - fMinRow + 1;
44174d11	142	Int_t nCols = fMaxCol - fMinCol + 1;
573322da	143	Int_t invMappingSize = nRows*nCols;
44174d11	144
573322da	145	fInvMappingLow = new Short_t[invMappingSize];
573322da	146	fInvMappingHigh = new Short_t[invMappingSize];
44174d11	147	for (Int_t i = 0; i < nRows; i++) {
	148	for (Int_t j = 0; j < nCols; j++) {
	149	fInvMappingLow[nCols*i+j] = -1;
	150	fInvMappingHigh[nCols*i+j] = -1;
d84933b0	151	}
	152	}
	153
	154	for(Int_t i = 0; i <= fMaxHWAddress; i++) {
44174d11	155	Int_t row = fMapping[3*i];
	156	Int_t col = fMapping[3*i+1];
	157	Int_t gain = fMapping[3*i+2];
d84933b0	158	if(row != -1 && col != -1) {
d84933b0	159	if (gain == 0)
44174d11	160	fInvMappingLow[nCols*(row-fMinRow)+(col-fMinCol)] = i;
d84933b0	161	if (gain == 1)
44174d11	162	fInvMappingHigh[nCols*(row-fMinRow)+(col-fMinCol)] = i;
d84933b0	163	}
	164	}
	165
	166	return kTRUE;
	167	}
	168
	169	//_____________________________________________________________________________
573322da	170	Int_t AliCaloAltroMapping::GetHWAddress(Int_t row, Int_t col, Int_t gain)
d84933b0	171	{
	172	// Get the content of the mapping array
	173	// return -1 in case there is no hardware
	174	// adress defined for these row-column-gain
	175	if (!fInvMappingLow \|\| !fInvMappingHigh) {
573322da	176	if (!CreateInvMapping()) return -1;
d84933b0	177	}
	178	if (row < fMinRow \|\| row > fMaxRow) {
	179	AliWarning(Form("Index of row (%d) outside the range (%d -> %d) !",row,fMinRow,fMaxRow));
	180	return -1;
	181	}
	182	if (col < fMinCol \|\| col > fMaxCol) {
	183	AliWarning(Form("Index of column (%d) outside the range (0 -> %d) !",col,fMinCol,fMaxCol));
	184	return -1;
	185	}
	186	if (gain < 0 \|\| gain > 1) {
	187	AliWarning(Form("Invalid gain (%d)! Should be 0 or 1 !",gain));
	188	return -1;
	189	}
	190	Int_t hwAddress = -1;
	191	if (gain == 0)
44174d11	192	hwAddress = fInvMappingLow[(fMaxCol - fMinCol + 1)*(row-fMinRow)+(col-fMinCol)];
d84933b0	193	if (gain == 1)
44174d11	194	hwAddress = fInvMappingHigh[(fMaxCol - fMinCol + 1)*(row-fMinRow)+(col-fMinCol)];
d84933b0	195
	196	if (hwAddress == -1)
	197	AliWarning(Form("Hardware (ALTRO) adress is not defined for these row (%d), column (%d) and gain (%d) !",row,col,gain));
	198
	199	return hwAddress;
	200	}
	201
	202	//_____________________________________________________________________________
	203	Int_t AliCaloAltroMapping::GetPadRow(Int_t hwAddress) const
	204	{
	205	// Return the row index
	206	// Note the difference w.r.t to the base class notation
	207	if (!fMapping) {
	208	AliWarning("Mapping array was not initalized correctly !");
	209	return -1;
	210	}
	211	if (hwAddress > fMaxHWAddress) {
	212	AliWarning(Form("Hardware (ALTRO) adress (%d) outside the range (0 -> %d) !",hwAddress,fMaxHWAddress));
	213	return -1;
	214	}
44174d11	215	Int_t row = fMapping[3*hwAddress];
d84933b0	216	if (row == -1)
	217	AliWarning(Form("Hardware (ALTRO) adress (%d) is not defined !",hwAddress));
	218
	219	return row;
	220	}
	221
	222	//_____________________________________________________________________________
	223	Int_t AliCaloAltroMapping::GetPad(Int_t hwAddress) const
	224	{
	225	// Return the column index
	226	// Note the difference w.r.t to the base class notation
	227	if (!fMapping) {
	228	AliWarning("Mapping array was not initalized correctly !");
	229	return -1;
	230	}
	231	if (hwAddress > fMaxHWAddress) {
	232	AliWarning(Form("Hardware (ALTRO) adress (%d) outside the range (0 -> %d) !",hwAddress,fMaxHWAddress));
	233	return -1;
	234	}
44174d11	235	Int_t col = fMapping[3*hwAddress+1];
d84933b0	236	if (col == -1)
	237	AliWarning(Form("Hardware (ALTRO) adress (%d) is not defined !",hwAddress));
	238
	239	return col;
	240	}
	241
	242	//_____________________________________________________________________________
	243	Int_t AliCaloAltroMapping::GetSector(Int_t hwAddress) const
	244	{
	245	// Return the gain factor (0/1)
	246	// Note the difference w.r.t to the base class notation
	247	if (!fMapping) {
	248	AliWarning("Mapping array was not initalized correctly !");
	249	return -1;
	250	}
	251	if (hwAddress > fMaxHWAddress) {
	252	AliWarning(Form("Hardware (ALTRO) adress (%d) outside the range (0 -> %d) !",hwAddress,fMaxHWAddress));
	253	return -1;
	254	}
44174d11	255	Int_t gain = fMapping[3*hwAddress+2];
d84933b0	256	if (gain == -1)
	257	AliWarning(Form("Hardware (ALTRO) adress (%d) is not defined !",hwAddress));
	258
	259	return gain;
	260	}