[u/mrichter/AliRoot.git] / TOF / AliTOFFEEReader.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.                  *
***************************************************************************/

/* 
 * author: Roberto Preghenella (R+), Roberto.Preghenella@bo.infn.it
 */

//////////////////////////////////////////////////////////////////////
//                                                                  //
//                                                                  //
//   This class provides the TOF FEE reader.                        //
//                                                                  //
//                                                                  //
//////////////////////////////////////////////////////////////////////

#include <TSystem.h>
#include "AliTOFFEEReader.h"
#include "AliTOFFEEConfig.h"
#include "AliTOFFEElightConfig.h"
#include "AliTOFRawStream.h"
#include "AliTOFGeometry.h"
#include "AliTOFcalibHisto.h"
#include "AliLog.h"
#include <fstream>

ClassImp(AliTOFFEEReader)

//_______________________________________________________________

AliTOFFEEReader::AliTOFFEEReader() :
  TObject(),
  fFEEConfig(new AliTOFFEEConfig()),
  fFEElightConfig(new AliTOFFEElightConfig()),
  fChannelEnabled(),
  fMatchingWindow(),
  fLatencyWindow()
{
  /* 
   * 
   * default constructor 
   *
   */

  Reset();
}

//_______________________________________________________________

AliTOFFEEReader::AliTOFFEEReader(const AliTOFFEEReader &source) :
  TObject(source),
  fFEEConfig(new AliTOFFEEConfig()),
  fFEElightConfig(new AliTOFFEElightConfig())
{
  /* 
   * 
   * copy constructor 
   *
   */

  memcpy(fFEEConfig, source.fFEEConfig, sizeof(AliTOFFEEConfig));
  memcpy(fFEElightConfig, source.fFEElightConfig, sizeof(AliTOFFEElightConfig));
}

//_______________________________________________________________

AliTOFFEEReader &
AliTOFFEEReader::operator=(const AliTOFFEEReader &source)
{
  /* 
   * 
   * operator = 
   * 
   */

  TObject::operator=(source);
  memcpy(fFEEConfig, source.fFEEConfig, sizeof(AliTOFFEEConfig));
  memcpy(fFEElightConfig, source.fFEElightConfig, sizeof(AliTOFFEElightConfig));
  return *this;
}

//_______________________________________________________________

AliTOFFEEReader::~AliTOFFEEReader()
{
  /* 
   *
   * default destructor 
   *
   */

  delete fFEEConfig;
  delete fFEElightConfig;
}

//_______________________________________________________________

void
AliTOFFEEReader::ResetChannelEnabledArray()
{
  /*
   *
   * reset channel enabled array
   *
   */

  for (Int_t iIndex = 0; iIndex < GetNumberOfIndexes(); iIndex++)
    fChannelEnabled[iIndex] = kFALSE;
}

//_______________________________________________________________

void
AliTOFFEEReader::Reset()
{
  /*
   *
   * reset 
   *
   */

  for (Int_t iIndex = 0; iIndex < GetNumberOfIndexes(); iIndex++) {
    fChannelEnabled[iIndex] = kFALSE;
    fMatchingWindow[iIndex] = 0;
    fLatencyWindow[iIndex] = 0;
  }
}

//_______________________________________________________________

void
AliTOFFEEReader::LoadFEEConfig(const Char_t *FileName) const
{
  /*
   *
   * load FEE config
   *
   */

  Char_t *expandedFileName = gSystem->ExpandPathName(FileName);
  std::ifstream is;
  is.open(expandedFileName, std::ios::binary);
  is.read((Char_t *)fFEEConfig, sizeof(AliTOFFEEConfig));
  is.close();
}

//_______________________________________________________________

void
AliTOFFEEReader::LoadFEElightConfig(const Char_t *FileName) const
{
  /*
   *
   * load FEElight config
   *
   */

  Char_t *expandedFileName = gSystem->ExpandPathName(FileName);
  std::ifstream is;
  is.open(expandedFileName, std::ios::binary);
  is.read((Char_t *)fFEElightConfig, sizeof(AliTOFFEElightConfig));
  is.close();
}

//_______________________________________________________________

Int_t
AliTOFFEEReader::ParseFEEConfig()
{
  /* 
   *
   * parse FEE config
   *
   * loops over all FEE channels, checks whether they are enabled
   * and sets channel enabled 
   *
   */

  AliInfo("parsing TOF FEE config");

  AliTOFRawStream rawStream;
  Int_t nEnabled = 0;
  Int_t volume[5], index;
  Int_t temp;

  Reset();

  /* loop over all FEE channels */
  for (Int_t iDDL = 0; iDDL < GetNumberOfDDLs(); iDDL++)
    for (Int_t iTRM = 0; iTRM < GetNumberOfTRMs(); iTRM++)
      for (Int_t iChain = 0; iChain < GetNumberOfChains(); iChain++)
	for (Int_t iTDC = 0; iTDC < GetNumberOfTDCs(); iTDC++)
	  for (Int_t iChannel = 0; iChannel < GetNumberOfChannels(); iChannel++)
	    /* check whether FEE channel is enabled */
	    if (IsChannelEnabled(iDDL, iTRM + 3, iChain, iTDC, iChannel)) {
	      /* convert FEE channel indexes into detector indexes */
	      rawStream.EquipmentId2VolumeId(iDDL, iTRM + 3, iChain, iTDC, iChannel, volume);
	      /* swap padx and padz to fit AliTOFGeometry::GetIndex behaviour */
	      temp = volume[4]; volume[4] = volume[3]; volume[3] = temp; 
	      /* check if index is ok */
	      if (volume[0] < 0 || volume[0] > 17 ||
		  volume[1] < 0 || volume[1] > 4 ||
		  volume[2] < 0 || volume[2] > 18 ||
		  volume[3] < 0 || volume[3] > 1 ||
		  volume[4] < 0 || volume[4] > 47)
		continue;
	      /* convert detector indexes into calibration index */
	      index = AliTOFGeometry::GetIndex(volume);
	      /* check calibration index */
	      if (index != -1 && index < GetNumberOfIndexes()) {
		/* set calibration channel enabled */
		fChannelEnabled[index] = kTRUE;
		fMatchingWindow[index] = GetMatchingWindow(iDDL, iTRM + 3, iChain, iTDC, iChannel);
		nEnabled++;
	      }
	    }
  return nEnabled;
}

//_______________________________________________________________

Int_t
AliTOFFEEReader::ParseFEElightConfig()
{
  /* 
   *
   * parse FEElight config
   *
   * loops over all FEE channels, checks whether they are enabled
   * and sets channel enabled 
   *
   */

  AliInfo("parsing TOF FEElight config");

  AliTOFcalibHisto calibHisto;
  calibHisto.LoadCalibHisto();

  Int_t nEnabled = 0, index;
  AliTOFFEEchannelConfig *channelConfig = NULL;
  for (Int_t i = 0; i < GetNumberOfIndexesEO(); i++) {
    channelConfig = fFEElightConfig->GetChannelConfig(i);
    if (!channelConfig->IsEnabled()) continue;
    /* get index DO from index EO */
    index = (Int_t)calibHisto.GetCalibMap(AliTOFcalibHisto::kIndex, i);
    if (index == -1) continue;
    nEnabled++;
    fChannelEnabled[index] = channelConfig->IsEnabled();
    fMatchingWindow[index] = channelConfig->GetMatchingWindow();
    fLatencyWindow[index] = channelConfig->GetLatencyWindow();
  }
 
  return nEnabled;
}

//_______________________________________________________________

Bool_t 
AliTOFFEEReader::IsChannelEnabled(Int_t iDDL, Int_t iTRM, Int_t iChain, Int_t iTDC, Int_t iChannel) const
{
  /*
   *
   * is channel enabled
   *
   * checks whether a FEE channel is enabled using the
   * TOF FEE config object.
   *
   */

  AliTOFFEEConfig *feeConfig;
  AliTOFCrateConfig *crateConfig;
  AliTOFTRMConfig *trmConfig;
  Int_t maskPB, maskTDC, activeChip;
  
  /* get and check fee config */
  if (!(feeConfig = GetFEEConfig()))
    return kFALSE;
  
  /* get and check crate config */
  if (!(crateConfig = feeConfig->GetCrateConfig(iDDL)))
    return kFALSE;
  
  /* get and check TRM config */
  if (!(trmConfig = crateConfig->GetTRMConfig(iTRM - 3)))
    return kFALSE;

  /* check DRM enabled */
  if (!crateConfig->IsDRMEnabled())
    return kFALSE;

  /* check TRM enabled */
  if (!crateConfig->IsTRMEnabled(iTRM - 3))
    return kFALSE;

  /* switch chain */
  switch (iChain) {
    /* chain A */
  case 0:
    /* check chain enabled */
    if (trmConfig->GetChainAFlag() != 1)
      return kFALSE;
    /* get active chip mask */
    activeChip = trmConfig->GetActiveChipA();
    /* switch TDC */
    switch (iTDC) {
    case 0: case 1: case 2:
      maskPB = trmConfig->GetMaskPB0();
      break;
    case 3: case 4: case 5:
      maskPB = trmConfig->GetMaskPB1();
      break;
    case 6: case 7: case 8:
      maskPB = trmConfig->GetMaskPB2();
      break;
    case 9: case 10: case 11:
      maskPB = trmConfig->GetMaskPB3();
      break;
    case 12: case 13: case 14:
      maskPB = trmConfig->GetMaskPB4();
      break;
    default:
      return kFALSE;
      break;  
    } /* switch TDC */
    break; /* chain A */
    /* chain B */
  case 1:
    /* check chain enabled */
    if (trmConfig->GetChainBFlag() != 1)
      return kFALSE;
    /* get active chip mask */
    activeChip = trmConfig->GetActiveChipB();
    /* switch TDC */
    switch (iTDC) {
    case 0: case 1: case 2:
      maskPB = trmConfig->GetMaskPB5();
      break;
    case 3: case 4: case 5:
      maskPB = trmConfig->GetMaskPB6();
      break;
    case 6: case 7: case 8:
      maskPB = trmConfig->GetMaskPB7();
      break;
    case 9: case 10: case 11:
      maskPB = trmConfig->GetMaskPB8();
      break;
    case 12: case 13: case 14:
      maskPB = trmConfig->GetMaskPB9();
      break;
    default:
      return kFALSE;
      break;  
    } /* switch TDC */
    break; /* chain B */
  default:
    return kFALSE;
    break;
  } /* switch chain */

  /* check chip enabled */
  if (!(activeChip & (0x1 << iTDC)))
    return kFALSE;

  /* check channel enabled */
  maskTDC = (maskPB & (0xFF << ((iTDC % 3) * 8))) >> ((iTDC % 3) * 8);
  if (maskTDC & (0x1 << iChannel))
    return kTRUE;
  else
    return kFALSE;
  
}

//_______________________________________________________________

Int_t 
AliTOFFEEReader::GetMatchingWindow(Int_t iDDL, Int_t iTRM, Int_t iChain, Int_t iTDC, Int_t iChannel) const
{
  /*
   *
   * get matching window
   *
   * checks whether a FEE channel is enabled using the
   * TOF FEE config object and return the associated
   * matching window
   *
   */
  
  AliTOFFEEConfig *feeConfig;
  AliTOFCrateConfig *crateConfig;
  AliTOFTRMConfig *trmConfig;

  iChain = 0; iTDC = 0; iChannel = 0; /* dummy for the time being */
  
  /* get and check fee config */
  if (!(feeConfig = GetFEEConfig()))
    return 0;
  
  /* get and check crate config */
  if (!(crateConfig = feeConfig->GetCrateConfig(iDDL)))
    return 0;
  
  /* get and check TRM config */
  if (!(trmConfig = crateConfig->GetTRMConfig(iTRM - 3)))
    return 0;

  /* check DRM enabled */
  if (!crateConfig->IsDRMEnabled())
    return 0;

  /* check TRM enabled */
  if (!crateConfig->IsTRMEnabled(iTRM - 3))
    return 0;

  return trmConfig->GetMatchingWindow();
}


void
AliTOFFEEReader::DumpFEEConfig()
{
  /*
   * 
   * dump FEE config
   *
   */

  AliTOFFEEConfig *feeConfig = GetFEEConfig();
  AliTOFCrateConfig *crateConfig;
  AliTOFDRMConfig *drmConfig;
  AliTOFLTMConfig *ltmConfig;
  AliTOFTRMConfig *trmConfig;

  AliInfo("-------------------------------------");
  AliInfo("dumping TOF FEE config");
  AliInfo("-------------------------------------");
  AliInfo(Form("version: %d", feeConfig->GetVersion()));
  AliInfo(Form("dump time: %d", feeConfig->GetDumpTime()));
  AliInfo(Form("run number: %d", feeConfig->GetRunNumber()));
  AliInfo(Form("run type: %d", feeConfig->GetRunType()));
  AliInfo("-------------------------------------");
  
  /* loop over crates */
  for (Int_t iCrate = 0; iCrate < AliTOFFEEConfig::GetNumberOfCrates(); iCrate++) {
    crateConfig = feeConfig->GetCrateConfig(iCrate);
    
    /* check crate config */
    if (!crateConfig)
      continue;
    
    /* check DRM enabled */
    if (!crateConfig->IsDRMEnabled())
    continue;

    AliInfo(Form("crate id: %02d", iCrate));

    /* dump DRM config */
    drmConfig = crateConfig->GetDRMConfig();
    AliInfo(Form("DRM is enabled: drmId=%d, slotMask=%03x", drmConfig->GetDRMId(), drmConfig->GetSlotMask()));

    /* dump LTM config if enabled */
    if (crateConfig->IsLTMEnabled()) {
      ltmConfig = crateConfig->GetLTMConfig();
      AliInfo(Form("LTM is enabled: threshold=%d", ltmConfig->GetThreshold()));
    }
    
    /* dump CPDM config if enabled */
    if (crateConfig->IsCPDMEnabled()) {
      AliInfo(Form("CPDM is enabled"));
    }
    
    /* loop over TRMs */
    for (Int_t iTRM = 0; iTRM < AliTOFCrateConfig::GetNumberOfTRMs(); iTRM++) {

      trmConfig = crateConfig->GetTRMConfig(iTRM);

      /* check TRM config */
      if (!trmConfig)
	continue;
      
      /* check TRM enabled */
      if (!crateConfig->IsTRMEnabled(iTRM))
	continue;

      /* dump TRM config */
      AliInfo(Form("TRM%02d is enabled: matchWin=%d, latWin=%d, packFlag=%d", iTRM + 3, trmConfig->GetMatchingWindow(), trmConfig->GetLatencyWindow(), trmConfig->GetPackingFlag()));
      
      /* check TRM chain A flag */
      if (trmConfig->GetChainAFlag() == 1) {
	AliInfo(Form("TRM%02d chainA is enabled: activeChip=%04X, PB0=%06X, PB1=%06X, PB2=%06X, PB3=%06X, PB4=%06X", iTRM + 3, trmConfig->GetActiveChipA(), trmConfig->GetMaskPB0(), trmConfig->GetMaskPB1(), trmConfig->GetMaskPB2(), trmConfig->GetMaskPB3(), trmConfig->GetMaskPB4()));
      }

      /* check TRM chain B flag */
      if (trmConfig->GetChainBFlag() == 1) {
	AliInfo(Form("TRM%02d chainB is enabled: activeChip=%04X, PB5=%06X, PB6=%06X, PB7=%06X, PB8=%06X, PB9=%06X", iTRM + 3, trmConfig->GetActiveChipB(), trmConfig->GetMaskPB5(), trmConfig->GetMaskPB6(), trmConfig->GetMaskPB7(), trmConfig->GetMaskPB8(), trmConfig->GetMaskPB9()));
      }
      

    } /* loop over TRMs */
    AliInfo("-------------------------------------");
  } /* loop over crates */
}

//_______________________________________________________________

void
AliTOFFEEReader::CreateFEElightConfig(const Char_t *filename)
{
  /*
   *
   * create FEElight config 
   *
   */

  AliTOFFEElightConfig lightConfig;

  for (Int_t i = 0; i < GetNumberOfIndexes(); i++) {
    if (fChannelEnabled[i]) {
      lightConfig.GetChannelConfig(i)->SetStatus(AliTOFFEEchannelConfig::kStatusEnabled);
      lightConfig.GetChannelConfig(i)->SetMatchingWindow(fMatchingWindow[i]);
      lightConfig.GetChannelConfig(i)->SetLatencyWindow(fLatencyWindow[i]);
    }
    else {
      lightConfig.GetChannelConfig(i)->SetStatus(0x0);
      lightConfig.GetChannelConfig(i)->SetMatchingWindow(0);
      lightConfig.GetChannelConfig(i)->SetLatencyWindow(0);
    }
  }

  Char_t *expandedFileName = gSystem->ExpandPathName(filename);
  std::ofstream os;
  os.open(expandedFileName, std::ios::binary);
  os.write((Char_t *)&lightConfig, sizeof(AliTOFFEElightConfig));
  os.close();
  
}
Commit	Line	Data
1605abc6	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
	16	/*
	17	* author: Roberto Preghenella (R+), Roberto.Preghenella@bo.infn.it
	18	*/
	19
	20	//////////////////////////////////////////////////////////////////////
	21	// //
	22	// //
	23	// This class provides the TOF FEE reader. //
	24	// //
	25	// //
	26	//////////////////////////////////////////////////////////////////////
	27
5b086af5	28	#include <TSystem.h>
1605abc6	29	#include "AliTOFFEEReader.h"
1605abc6	30	#include "AliTOFFEEConfig.h"
046dfc5f	31	#include "AliTOFFEElightConfig.h"
1605abc6	32	#include "AliTOFRawStream.h"
39dff6a4	33	#include "AliTOFGeometry.h"
99096b5f	34	#include "AliTOFcalibHisto.h"
1605abc6	35	#include "AliLog.h"
	36	#include <fstream>
	37
	38	ClassImp(AliTOFFEEReader)
	39
	40	//_______________________________________________________________
	41
	42	AliTOFFEEReader::AliTOFFEEReader() :
	43	TObject(),
	44	fFEEConfig(new AliTOFFEEConfig()),
046dfc5f	45	fFEElightConfig(new AliTOFFEElightConfig()),
b059882a	46	fChannelEnabled(),
046dfc5f	47	fMatchingWindow(),
046dfc5f	48	fLatencyWindow()
1605abc6	49	{
	50	/*
	51	*
	52	* default constructor
	53	*
	54	*/
	55
b059882a	56	Reset();
1605abc6	57	}
	58
	59	//_______________________________________________________________
	60
	61	AliTOFFEEReader::AliTOFFEEReader(const AliTOFFEEReader &source) :
	62	TObject(source),
046dfc5f	63	fFEEConfig(new AliTOFFEEConfig()),
046dfc5f	64	fFEElightConfig(new AliTOFFEElightConfig())
1605abc6	65	{
	66	/*
	67	*
	68	* copy constructor
	69	*
	70	*/
	71
	72	memcpy(fFEEConfig, source.fFEEConfig, sizeof(AliTOFFEEConfig));
046dfc5f	73	memcpy(fFEElightConfig, source.fFEElightConfig, sizeof(AliTOFFEElightConfig));
1605abc6	74	}
	75
	76	//_______________________________________________________________
	77
	78	AliTOFFEEReader &
	79	AliTOFFEEReader::operator=(const AliTOFFEEReader &source)
	80	{
	81	/*
	82	*
	83	* operator =
	84	*
	85	*/
	86
	87	TObject::operator=(source);
	88	memcpy(fFEEConfig, source.fFEEConfig, sizeof(AliTOFFEEConfig));
046dfc5f	89	memcpy(fFEElightConfig, source.fFEElightConfig, sizeof(AliTOFFEElightConfig));
1605abc6	90	return *this;
	91	}
	92
	93	//_______________________________________________________________
	94
	95	AliTOFFEEReader::~AliTOFFEEReader()
	96	{
	97	/*
	98	*
	99	* default destructor
	100	*
	101	*/
	102
	103	delete fFEEConfig;
046dfc5f	104	delete fFEElightConfig;
1605abc6	105	}
	106
	107	//_______________________________________________________________
	108
	109	void
	110	AliTOFFEEReader::ResetChannelEnabledArray()
	111	{
	112	/*
	113	*
	114	* reset channel enabled array
	115	*
	116	*/
	117
	118	for (Int_t iIndex = 0; iIndex < GetNumberOfIndexes(); iIndex++)
	119	fChannelEnabled[iIndex] = kFALSE;
	120	}
	121
	122	//_______________________________________________________________
	123
b059882a	124	void
	125	AliTOFFEEReader::Reset()
	126	{
	127	/*
	128	*
	129	* reset
	130	*
	131	*/
	132
	133	for (Int_t iIndex = 0; iIndex < GetNumberOfIndexes(); iIndex++) {
	134	fChannelEnabled[iIndex] = kFALSE;
	135	fMatchingWindow[iIndex] = 0;
046dfc5f	136	fLatencyWindow[iIndex] = 0;
b059882a	137	}
	138	}
	139
	140	//_______________________________________________________________
	141
1605abc6	142	void
39dff6a4	143	AliTOFFEEReader::LoadFEEConfig(const Char_t *FileName) const
1605abc6	144	{
	145	/*
	146	*
	147	* load FEE config
	148	*
	149	*/
	150
5b086af5	151	Char_t *expandedFileName = gSystem->ExpandPathName(FileName);
1605abc6	152	std::ifstream is;
5b086af5	153	is.open(expandedFileName, std::ios::binary);
1605abc6	154	is.read((Char_t *)fFEEConfig, sizeof(AliTOFFEEConfig));
	155	is.close();
	156	}
	157
	158	//_______________________________________________________________
	159
046dfc5f	160	void
	161	AliTOFFEEReader::LoadFEElightConfig(const Char_t *FileName) const
	162	{
	163	/*
	164	*
	165	* load FEElight config
	166	*
	167	*/
	168
	169	Char_t *expandedFileName = gSystem->ExpandPathName(FileName);
	170	std::ifstream is;
	171	is.open(expandedFileName, std::ios::binary);
	172	is.read((Char_t *)fFEElightConfig, sizeof(AliTOFFEElightConfig));
	173	is.close();
	174	}
	175
	176	//_______________________________________________________________
	177
1605abc6	178	Int_t
	179	AliTOFFEEReader::ParseFEEConfig()
	180	{
	181	/*
	182	*
	183	* parse FEE config
	184	*
	185	* loops over all FEE channels, checks whether they are enabled
	186	* and sets channel enabled
	187	*
	188	*/
	189
046dfc5f	190	AliInfo("parsing TOF FEE config");
1605abc6	191
	192	AliTOFRawStream rawStream;
	193	Int_t nEnabled = 0;
	194	Int_t volume[5], index;
	195	Int_t temp;
	196
b059882a	197	Reset();
1605abc6	198
	199	/* loop over all FEE channels */
	200	for (Int_t iDDL = 0; iDDL < GetNumberOfDDLs(); iDDL++)
	201	for (Int_t iTRM = 0; iTRM < GetNumberOfTRMs(); iTRM++)
	202	for (Int_t iChain = 0; iChain < GetNumberOfChains(); iChain++)
	203	for (Int_t iTDC = 0; iTDC < GetNumberOfTDCs(); iTDC++)
	204	for (Int_t iChannel = 0; iChannel < GetNumberOfChannels(); iChannel++)
	205	/* check whether FEE channel is enabled */
	206	if (IsChannelEnabled(iDDL, iTRM + 3, iChain, iTDC, iChannel)) {
	207	/* convert FEE channel indexes into detector indexes */
	208	rawStream.EquipmentId2VolumeId(iDDL, iTRM + 3, iChain, iTDC, iChannel, volume);
	209	/* swap padx and padz to fit AliTOFGeometry::GetIndex behaviour */
	210	temp = volume[4]; volume[4] = volume[3]; volume[3] = temp;
b059882a	211	/* check if index is ok */
	212	if (volume[0] < 0 \|\| volume[0] > 17 \|\|
	213	volume[1] < 0 \|\| volume[1] > 4 \|\|
	214	volume[2] < 0 \|\| volume[2] > 18 \|\|
	215	volume[3] < 0 \|\| volume[3] > 1 \|\|
	216	volume[4] < 0 \|\| volume[4] > 47)
	217	continue;
1605abc6	218	/* convert detector indexes into calibration index */
	219	index = AliTOFGeometry::GetIndex(volume);
	220	/* check calibration index */
	221	if (index != -1 && index < GetNumberOfIndexes()) {
	222	/* set calibration channel enabled */
	223	fChannelEnabled[index] = kTRUE;
b059882a	224	fMatchingWindow[index] = GetMatchingWindow(iDDL, iTRM + 3, iChain, iTDC, iChannel);
1605abc6	225	nEnabled++;
	226	}
	227	}
	228	return nEnabled;
	229	}
	230
	231	//_______________________________________________________________
	232
046dfc5f	233	Int_t
	234	AliTOFFEEReader::ParseFEElightConfig()
	235	{
	236	/*
	237	*
	238	* parse FEElight config
	239	*
	240	* loops over all FEE channels, checks whether they are enabled
	241	* and sets channel enabled
	242	*
	243	*/
	244
	245	AliInfo("parsing TOF FEElight config");
	246
99096b5f	247	AliTOFcalibHisto calibHisto;
	248	calibHisto.LoadCalibHisto();
	249
	250	Int_t nEnabled = 0, index;
046dfc5f	251	AliTOFFEEchannelConfig *channelConfig = NULL;
99096b5f	252	for (Int_t i = 0; i < GetNumberOfIndexesEO(); i++) {
046dfc5f	253	channelConfig = fFEElightConfig->GetChannelConfig(i);
99096b5f	254	if (!channelConfig->IsEnabled()) continue;
	255	/* get index DO from index EO */
	256	index = (Int_t)calibHisto.GetCalibMap(AliTOFcalibHisto::kIndex, i);
	257	if (index == -1) continue;
	258	nEnabled++;
	259	fChannelEnabled[index] = channelConfig->IsEnabled();
	260	fMatchingWindow[index] = channelConfig->GetMatchingWindow();
	261	fLatencyWindow[index] = channelConfig->GetLatencyWindow();
046dfc5f	262	}
	263
	264	return nEnabled;
	265	}
	266
	267	//_______________________________________________________________
	268
1605abc6	269	Bool_t
39dff6a4	270	AliTOFFEEReader::IsChannelEnabled(Int_t iDDL, Int_t iTRM, Int_t iChain, Int_t iTDC, Int_t iChannel) const
1605abc6	271	{
	272	/*
	273	*
	274	* is channel enabled
	275	*
	276	* checks whether a FEE channel is enabled using the
	277	* TOF FEE config object.
	278	*
	279	*/
	280
	281	AliTOFFEEConfig *feeConfig;
	282	AliTOFCrateConfig *crateConfig;
	283	AliTOFTRMConfig *trmConfig;
71b82bd2	284	Int_t maskPB, maskTDC, activeChip;
1605abc6	285
	286	/* get and check fee config */
	287	if (!(feeConfig = GetFEEConfig()))
	288	return kFALSE;
	289
	290	/* get and check crate config */
	291	if (!(crateConfig = feeConfig->GetCrateConfig(iDDL)))
	292	return kFALSE;
	293
	294	/* get and check TRM config */
	295	if (!(trmConfig = crateConfig->GetTRMConfig(iTRM - 3)))
	296	return kFALSE;
	297
	298	/* check DRM enabled */
	299	if (!crateConfig->IsDRMEnabled())
	300	return kFALSE;
	301
	302	/* check TRM enabled */
	303	if (!crateConfig->IsTRMEnabled(iTRM - 3))
	304	return kFALSE;
	305
	306	/* switch chain */
	307	switch (iChain) {
	308	/* chain A */
	309	case 0:
	310	/* check chain enabled */
	311	if (trmConfig->GetChainAFlag() != 1)
	312	return kFALSE;
71b82bd2	313	/* get active chip mask */
71b82bd2	314	activeChip = trmConfig->GetActiveChipA();
1605abc6	315	/* switch TDC */
	316	switch (iTDC) {
	317	case 0: case 1: case 2:
	318	maskPB = trmConfig->GetMaskPB0();
	319	break;
	320	case 3: case 4: case 5:
	321	maskPB = trmConfig->GetMaskPB1();
	322	break;
	323	case 6: case 7: case 8:
	324	maskPB = trmConfig->GetMaskPB2();
	325	break;
	326	case 9: case 10: case 11:
	327	maskPB = trmConfig->GetMaskPB3();
	328	break;
	329	case 12: case 13: case 14:
	330	maskPB = trmConfig->GetMaskPB4();
	331	break;
	332	default:
	333	return kFALSE;
	334	break;
	335	} /* switch TDC */
	336	break; /* chain A */
	337	/* chain B */
	338	case 1:
	339	/* check chain enabled */
	340	if (trmConfig->GetChainBFlag() != 1)
	341	return kFALSE;
71b82bd2	342	/* get active chip mask */
71b82bd2	343	activeChip = trmConfig->GetActiveChipB();
1605abc6	344	/* switch TDC */
	345	switch (iTDC) {
	346	case 0: case 1: case 2:
	347	maskPB = trmConfig->GetMaskPB5();
	348	break;
	349	case 3: case 4: case 5:
	350	maskPB = trmConfig->GetMaskPB6();
	351	break;
	352	case 6: case 7: case 8:
	353	maskPB = trmConfig->GetMaskPB7();
	354	break;
	355	case 9: case 10: case 11:
	356	maskPB = trmConfig->GetMaskPB8();
	357	break;
	358	case 12: case 13: case 14:
	359	maskPB = trmConfig->GetMaskPB9();
	360	break;
	361	default:
	362	return kFALSE;
	363	break;
	364	} /* switch TDC */
	365	break; /* chain B */
	366	default:
	367	return kFALSE;
	368	break;
	369	} /* switch chain */
	370
71b82bd2	371	/* check chip enabled */
	372	if (!(activeChip & (0x1 << iTDC)))
	373	return kFALSE;
	374
1605abc6	375	/* check channel enabled */
	376	maskTDC = (maskPB & (0xFF << ((iTDC % 3) * 8))) >> ((iTDC % 3) * 8);
	377	if (maskTDC & (0x1 << iChannel))
	378	return kTRUE;
	379	else
	380	return kFALSE;
	381
	382	}
	383
b059882a	384	//_______________________________________________________________
	385
	386	Int_t
	387	AliTOFFEEReader::GetMatchingWindow(Int_t iDDL, Int_t iTRM, Int_t iChain, Int_t iTDC, Int_t iChannel) const
	388	{
	389	/*
	390	*
	391	* get matching window
	392	*
	393	* checks whether a FEE channel is enabled using the
	394	* TOF FEE config object and return the associated
	395	* matching window
	396	*
	397	*/
bf1a5fa6	398
b059882a	399	AliTOFFEEConfig *feeConfig;
	400	AliTOFCrateConfig *crateConfig;
	401	AliTOFTRMConfig *trmConfig;
bf1a5fa6	402
bf1a5fa6	403	iChain = 0; iTDC = 0; iChannel = 0; /* dummy for the time being */
b059882a	404
	405	/* get and check fee config */
	406	if (!(feeConfig = GetFEEConfig()))
	407	return 0;
	408
	409	/* get and check crate config */
	410	if (!(crateConfig = feeConfig->GetCrateConfig(iDDL)))
	411	return 0;
	412
	413	/* get and check TRM config */
	414	if (!(trmConfig = crateConfig->GetTRMConfig(iTRM - 3)))
	415	return 0;
	416
	417	/* check DRM enabled */
	418	if (!crateConfig->IsDRMEnabled())
	419	return 0;
	420
	421	/* check TRM enabled */
	422	if (!crateConfig->IsTRMEnabled(iTRM - 3))
	423	return 0;
	424
	425	return trmConfig->GetMatchingWindow();
	426	}
	427
1605abc6	428
	429	void
	430	AliTOFFEEReader::DumpFEEConfig()
	431	{
	432	/*
	433	*
	434	* dump FEE config
	435	*
	436	*/
	437
	438	AliTOFFEEConfig *feeConfig = GetFEEConfig();
	439	AliTOFCrateConfig *crateConfig;
	440	AliTOFDRMConfig *drmConfig;
	441	AliTOFLTMConfig *ltmConfig;
	442	AliTOFTRMConfig *trmConfig;
	443
	444	AliInfo("-------------------------------------");
	445	AliInfo("dumping TOF FEE config");
	446	AliInfo("-------------------------------------");
	447	AliInfo(Form("version: %d", feeConfig->GetVersion()));
	448	AliInfo(Form("dump time: %d", feeConfig->GetDumpTime()));
	449	AliInfo(Form("run number: %d", feeConfig->GetRunNumber()));
	450	AliInfo(Form("run type: %d", feeConfig->GetRunType()));
	451	AliInfo("-------------------------------------");
	452
	453	/* loop over crates */
	454	for (Int_t iCrate = 0; iCrate < AliTOFFEEConfig::GetNumberOfCrates(); iCrate++) {
	455	crateConfig = feeConfig->GetCrateConfig(iCrate);
	456
	457	/* check crate config */
	458	if (!crateConfig)
	459	continue;
	460
	461	/* check DRM enabled */
	462	if (!crateConfig->IsDRMEnabled())
	463	continue;
	464
	465	AliInfo(Form("crate id: %02d", iCrate));
	466
	467	/* dump DRM config */
	468	drmConfig = crateConfig->GetDRMConfig();
	469	AliInfo(Form("DRM is enabled: drmId=%d, slotMask=%03x", drmConfig->GetDRMId(), drmConfig->GetSlotMask()));
	470
	471	/* dump LTM config if enabled */
	472	if (crateConfig->IsLTMEnabled()) {
	473	ltmConfig = crateConfig->GetLTMConfig();
	474	AliInfo(Form("LTM is enabled: threshold=%d", ltmConfig->GetThreshold()));
	475	}
	476
	477	/* dump CPDM config if enabled */
	478	if (crateConfig->IsCPDMEnabled()) {
	479	AliInfo(Form("CPDM is enabled"));
	480	}
	481
	482	/* loop over TRMs */
	483	for (Int_t iTRM = 0; iTRM < AliTOFCrateConfig::GetNumberOfTRMs(); iTRM++) {
	484
	485	trmConfig = crateConfig->GetTRMConfig(iTRM);
	486
	487	/* check TRM config */
	488	if (!trmConfig)
	489	continue;
	490
	491	/* check TRM enabled */
492	if (!crateConfig->IsTRMEnabled(iTRM))
493	continue;
494
495	/* dump TRM config */
496	AliInfo(Form("TRM%02d is enabled: matchWin=%d, latWin=%d, packFlag=%d", iTRM + 3, trmConfig->GetMatchingWindow(), trmConfig->GetLatencyWindow(), trmConfig->GetPackingFlag()));
497
498	/* check TRM chain A flag */
499	if (trmConfig->GetChainAFlag() == 1) {
71b82bd2	500	AliInfo(Form("TRM%02d chainA is enabled: activeChip=%04X, PB0=%06X, PB1=%06X, PB2=%06X, PB3=%06X, PB4=%06X", iTRM + 3, trmConfig->GetActiveChipA(), trmConfig->GetMaskPB0(), trmConfig->GetMaskPB1(), trmConfig->GetMaskPB2(), trmConfig->GetMaskPB3(), trmConfig->GetMaskPB4()));
1605abc6	501	}
	502
	503	/* check TRM chain B flag */
	504	if (trmConfig->GetChainBFlag() == 1) {
71b82bd2	505	AliInfo(Form("TRM%02d chainB is enabled: activeChip=%04X, PB5=%06X, PB6=%06X, PB7=%06X, PB8=%06X, PB9=%06X", iTRM + 3, trmConfig->GetActiveChipB(), trmConfig->GetMaskPB5(), trmConfig->GetMaskPB6(), trmConfig->GetMaskPB7(), trmConfig->GetMaskPB8(), trmConfig->GetMaskPB9()));
1605abc6	506	}
	507
	508
	509
	510	} /* loop over TRMs */
	511	AliInfo("-------------------------------------");
	512	} /* loop over crates */
	513	}
	514
046dfc5f	515	//_______________________________________________________________
	516
	517	void
	518	AliTOFFEEReader::CreateFEElightConfig(const Char_t *filename)
	519	{
	520	/*
	521	*
	522	* create FEElight config
	523	*
	524	*/
	525
	526	AliTOFFEElightConfig lightConfig;
	527
	528	for (Int_t i = 0; i < GetNumberOfIndexes(); i++) {
	529	if (fChannelEnabled[i]) {
	530	lightConfig.GetChannelConfig(i)->SetStatus(AliTOFFEEchannelConfig::kStatusEnabled);
	531	lightConfig.GetChannelConfig(i)->SetMatchingWindow(fMatchingWindow[i]);
	532	lightConfig.GetChannelConfig(i)->SetLatencyWindow(fLatencyWindow[i]);
	533	}
	534	else {
	535	lightConfig.GetChannelConfig(i)->SetStatus(0x0);
	536	lightConfig.GetChannelConfig(i)->SetMatchingWindow(0);
	537	lightConfig.GetChannelConfig(i)->SetLatencyWindow(0);
	538	}
	539	}
	540
	541	Char_t *expandedFileName = gSystem->ExpandPathName(filename);
	542	std::ofstream os;
	543	os.open(expandedFileName, std::ios::binary);
	544	os.write((Char_t *)&lightConfig, sizeof(AliTOFFEElightConfig));
	545	os.close();
	546
	547	}