[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::ResetTriggerMaskArray()
{
  /*
   *
   * reset trigger mask array
   *
   */

  for (Int_t iddl = 0; iddl < GetNumberOfDDLs(); iddl++)
    fTriggerMask[iddl] = 0x0;
}

//_______________________________________________________________

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

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

  for (Int_t iddl = 0; iddl < GetNumberOfDDLs(); iddl++)
    fTriggerMask[iddl] = 0x0;
}

//_______________________________________________________________

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");

  Reset();

  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();
  }

  AliTOFFEEtriggerConfig *triggerConfig = NULL;
  for (Int_t iddl = 0; iddl < GetNumberOfDDLs(); iddl++) {
    triggerConfig = fFEElightConfig->GetTriggerConfig(iddl);
    fTriggerMask[iddl] = triggerConfig->GetStatusMap();
  }
 
  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", (Int_t)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
1f4ce44e	124	void
	125	AliTOFFEEReader::ResetTriggerMaskArray()
	126	{
	127	/*
	128	*
	129	* reset trigger mask array
	130	*
	131	*/
	132
	133	for (Int_t iddl = 0; iddl < GetNumberOfDDLs(); iddl++)
	134	fTriggerMask[iddl] = 0x0;
	135	}
	136
	137	//_______________________________________________________________
	138
b059882a	139	void
	140	AliTOFFEEReader::Reset()
	141	{
	142	/*
	143	*
	144	* reset
	145	*
	146	*/
	147
	148	for (Int_t iIndex = 0; iIndex < GetNumberOfIndexes(); iIndex++) {
	149	fChannelEnabled[iIndex] = kFALSE;
	150	fMatchingWindow[iIndex] = 0;
046dfc5f	151	fLatencyWindow[iIndex] = 0;
b059882a	152	}
1f4ce44e	153
	154	for (Int_t iddl = 0; iddl < GetNumberOfDDLs(); iddl++)
	155	fTriggerMask[iddl] = 0x0;
b059882a	156	}
	157
	158	//_______________________________________________________________
	159
1605abc6	160	void
39dff6a4	161	AliTOFFEEReader::LoadFEEConfig(const Char_t *FileName) const
1605abc6	162	{
	163	/*
	164	*
	165	* load FEE config
	166	*
	167	*/
	168
5b086af5	169	Char_t *expandedFileName = gSystem->ExpandPathName(FileName);
1605abc6	170	std::ifstream is;
5b086af5	171	is.open(expandedFileName, std::ios::binary);
1605abc6	172	is.read((Char_t *)fFEEConfig, sizeof(AliTOFFEEConfig));
	173	is.close();
	174	}
	175
	176	//_______________________________________________________________
	177
046dfc5f	178	void
	179	AliTOFFEEReader::LoadFEElightConfig(const Char_t *FileName) const
	180	{
	181	/*
	182	*
	183	* load FEElight config
	184	*
	185	*/
	186
	187	Char_t *expandedFileName = gSystem->ExpandPathName(FileName);
	188	std::ifstream is;
	189	is.open(expandedFileName, std::ios::binary);
	190	is.read((Char_t *)fFEElightConfig, sizeof(AliTOFFEElightConfig));
	191	is.close();
	192	}
	193
	194	//_______________________________________________________________
	195
1605abc6	196	Int_t
	197	AliTOFFEEReader::ParseFEEConfig()
	198	{
	199	/*
	200	*
	201	* parse FEE config
	202	*
	203	* loops over all FEE channels, checks whether they are enabled
	204	* and sets channel enabled
	205	*
	206	*/
	207
046dfc5f	208	AliInfo("parsing TOF FEE config");
1605abc6	209
	210	AliTOFRawStream rawStream;
	211	Int_t nEnabled = 0;
	212	Int_t volume[5], index;
	213	Int_t temp;
	214
b059882a	215	Reset();
1605abc6	216
	217	/* loop over all FEE channels */
	218	for (Int_t iDDL = 0; iDDL < GetNumberOfDDLs(); iDDL++)
	219	for (Int_t iTRM = 0; iTRM < GetNumberOfTRMs(); iTRM++)
	220	for (Int_t iChain = 0; iChain < GetNumberOfChains(); iChain++)
	221	for (Int_t iTDC = 0; iTDC < GetNumberOfTDCs(); iTDC++)
	222	for (Int_t iChannel = 0; iChannel < GetNumberOfChannels(); iChannel++)
	223	/* check whether FEE channel is enabled */
	224	if (IsChannelEnabled(iDDL, iTRM + 3, iChain, iTDC, iChannel)) {
	225	/* convert FEE channel indexes into detector indexes */
	226	rawStream.EquipmentId2VolumeId(iDDL, iTRM + 3, iChain, iTDC, iChannel, volume);
	227	/* swap padx and padz to fit AliTOFGeometry::GetIndex behaviour */
	228	temp = volume[4]; volume[4] = volume[3]; volume[3] = temp;
b059882a	229	/* check if index is ok */
	230	if (volume[0] < 0 \|\| volume[0] > 17 \|\|
	231	volume[1] < 0 \|\| volume[1] > 4 \|\|
	232	volume[2] < 0 \|\| volume[2] > 18 \|\|
	233	volume[3] < 0 \|\| volume[3] > 1 \|\|
	234	volume[4] < 0 \|\| volume[4] > 47)
	235	continue;
1605abc6	236	/* convert detector indexes into calibration index */
	237	index = AliTOFGeometry::GetIndex(volume);
	238	/* check calibration index */
	239	if (index != -1 && index < GetNumberOfIndexes()) {
	240	/* set calibration channel enabled */
	241	fChannelEnabled[index] = kTRUE;
b059882a	242	fMatchingWindow[index] = GetMatchingWindow(iDDL, iTRM + 3, iChain, iTDC, iChannel);
1605abc6	243	nEnabled++;
	244	}
	245	}
	246	return nEnabled;
	247	}
	248
	249	//_______________________________________________________________
	250
046dfc5f	251	Int_t
	252	AliTOFFEEReader::ParseFEElightConfig()
	253	{
	254	/*
	255	*
	256	* parse FEElight config
	257	*
	258	* loops over all FEE channels, checks whether they are enabled
	259	* and sets channel enabled
	260	*
	261	*/
	262
	263	AliInfo("parsing TOF FEElight config");
	264
1f4ce44e	265	Reset();
1f4ce44e	266
99096b5f	267	AliTOFcalibHisto calibHisto;
	268	calibHisto.LoadCalibHisto();
	269
	270	Int_t nEnabled = 0, index;
046dfc5f	271	AliTOFFEEchannelConfig *channelConfig = NULL;
99096b5f	272	for (Int_t i = 0; i < GetNumberOfIndexesEO(); i++) {
046dfc5f	273	channelConfig = fFEElightConfig->GetChannelConfig(i);
99096b5f	274	if (!channelConfig->IsEnabled()) continue;
	275	/* get index DO from index EO */
	276	index = (Int_t)calibHisto.GetCalibMap(AliTOFcalibHisto::kIndex, i);
	277	if (index == -1) continue;
	278	nEnabled++;
	279	fChannelEnabled[index] = channelConfig->IsEnabled();
	280	fMatchingWindow[index] = channelConfig->GetMatchingWindow();
	281	fLatencyWindow[index] = channelConfig->GetLatencyWindow();
046dfc5f	282	}
1f4ce44e	283
	284	AliTOFFEEtriggerConfig *triggerConfig = NULL;
	285	for (Int_t iddl = 0; iddl < GetNumberOfDDLs(); iddl++) {
	286	triggerConfig = fFEElightConfig->GetTriggerConfig(iddl);
	287	fTriggerMask[iddl] = triggerConfig->GetStatusMap();
	288	}
046dfc5f	289
	290	return nEnabled;
	291	}
	292
	293	//_______________________________________________________________
	294
1605abc6	295	Bool_t
39dff6a4	296	AliTOFFEEReader::IsChannelEnabled(Int_t iDDL, Int_t iTRM, Int_t iChain, Int_t iTDC, Int_t iChannel) const
1605abc6	297	{
	298	/*
	299	*
	300	* is channel enabled
	301	*
	302	* checks whether a FEE channel is enabled using the
	303	* TOF FEE config object.
	304	*
	305	*/
	306
	307	AliTOFFEEConfig *feeConfig;
	308	AliTOFCrateConfig *crateConfig;
	309	AliTOFTRMConfig *trmConfig;
71b82bd2	310	Int_t maskPB, maskTDC, activeChip;
1605abc6	311
	312	/* get and check fee config */
	313	if (!(feeConfig = GetFEEConfig()))
	314	return kFALSE;
	315
	316	/* get and check crate config */
	317	if (!(crateConfig = feeConfig->GetCrateConfig(iDDL)))
	318	return kFALSE;
	319
	320	/* get and check TRM config */
	321	if (!(trmConfig = crateConfig->GetTRMConfig(iTRM - 3)))
	322	return kFALSE;
	323
	324	/* check DRM enabled */
	325	if (!crateConfig->IsDRMEnabled())
	326	return kFALSE;
	327
	328	/* check TRM enabled */
	329	if (!crateConfig->IsTRMEnabled(iTRM - 3))
	330	return kFALSE;
	331
	332	/* switch chain */
	333	switch (iChain) {
	334	/* chain A */
	335	case 0:
	336	/* check chain enabled */
	337	if (trmConfig->GetChainAFlag() != 1)
	338	return kFALSE;
71b82bd2	339	/* get active chip mask */
71b82bd2	340	activeChip = trmConfig->GetActiveChipA();
1605abc6	341	/* switch TDC */
	342	switch (iTDC) {
	343	case 0: case 1: case 2:
	344	maskPB = trmConfig->GetMaskPB0();
	345	break;
	346	case 3: case 4: case 5:
	347	maskPB = trmConfig->GetMaskPB1();
	348	break;
	349	case 6: case 7: case 8:
	350	maskPB = trmConfig->GetMaskPB2();
	351	break;
	352	case 9: case 10: case 11:
	353	maskPB = trmConfig->GetMaskPB3();
	354	break;
	355	case 12: case 13: case 14:
	356	maskPB = trmConfig->GetMaskPB4();
	357	break;
	358	default:
	359	return kFALSE;
	360	break;
	361	} /* switch TDC */
	362	break; /* chain A */
	363	/* chain B */
	364	case 1:
	365	/* check chain enabled */
	366	if (trmConfig->GetChainBFlag() != 1)
	367	return kFALSE;
71b82bd2	368	/* get active chip mask */
71b82bd2	369	activeChip = trmConfig->GetActiveChipB();
1605abc6	370	/* switch TDC */
	371	switch (iTDC) {
	372	case 0: case 1: case 2:
	373	maskPB = trmConfig->GetMaskPB5();
	374	break;
	375	case 3: case 4: case 5:
	376	maskPB = trmConfig->GetMaskPB6();
	377	break;
	378	case 6: case 7: case 8:
	379	maskPB = trmConfig->GetMaskPB7();
	380	break;
	381	case 9: case 10: case 11:
	382	maskPB = trmConfig->GetMaskPB8();
	383	break;
	384	case 12: case 13: case 14:
	385	maskPB = trmConfig->GetMaskPB9();
	386	break;
	387	default:
	388	return kFALSE;
	389	break;
	390	} /* switch TDC */
	391	break; /* chain B */
	392	default:
	393	return kFALSE;
	394	break;
	395	} /* switch chain */
	396
71b82bd2	397	/* check chip enabled */
	398	if (!(activeChip & (0x1 << iTDC)))
	399	return kFALSE;
	400
1605abc6	401	/* check channel enabled */
	402	maskTDC = (maskPB & (0xFF << ((iTDC % 3) * 8))) >> ((iTDC % 3) * 8);
	403	if (maskTDC & (0x1 << iChannel))
	404	return kTRUE;
	405	else
	406	return kFALSE;
	407
	408	}
	409
b059882a	410	//_______________________________________________________________
	411
	412	Int_t
	413	AliTOFFEEReader::GetMatchingWindow(Int_t iDDL, Int_t iTRM, Int_t iChain, Int_t iTDC, Int_t iChannel) const
	414	{
	415	/*
	416	*
	417	* get matching window
	418	*
	419	* checks whether a FEE channel is enabled using the
	420	* TOF FEE config object and return the associated
	421	* matching window
	422	*
	423	*/
bf1a5fa6	424
b059882a	425	AliTOFFEEConfig *feeConfig;
	426	AliTOFCrateConfig *crateConfig;
	427	AliTOFTRMConfig *trmConfig;
bf1a5fa6	428
bf1a5fa6	429	iChain = 0; iTDC = 0; iChannel = 0; /* dummy for the time being */
b059882a	430
	431	/* get and check fee config */
	432	if (!(feeConfig = GetFEEConfig()))
	433	return 0;
	434
	435	/* get and check crate config */
	436	if (!(crateConfig = feeConfig->GetCrateConfig(iDDL)))
	437	return 0;
	438
	439	/* get and check TRM config */
	440	if (!(trmConfig = crateConfig->GetTRMConfig(iTRM - 3)))
	441	return 0;
	442
	443	/* check DRM enabled */
	444	if (!crateConfig->IsDRMEnabled())
	445	return 0;
	446
	447	/* check TRM enabled */
	448	if (!crateConfig->IsTRMEnabled(iTRM - 3))
	449	return 0;
	450
	451	return trmConfig->GetMatchingWindow();
	452	}
	453
1605abc6	454
	455	void
	456	AliTOFFEEReader::DumpFEEConfig()
	457	{
	458	/*
	459	*
	460	* dump FEE config
	461	*
	462	*/
	463
	464	AliTOFFEEConfig *feeConfig = GetFEEConfig();
	465	AliTOFCrateConfig *crateConfig;
	466	AliTOFDRMConfig *drmConfig;
	467	AliTOFLTMConfig *ltmConfig;
	468	AliTOFTRMConfig *trmConfig;
	469
	470	AliInfo("-------------------------------------");
	471	AliInfo("dumping TOF FEE config");
	472	AliInfo("-------------------------------------");
	473	AliInfo(Form("version: %d", feeConfig->GetVersion()));
4682c56e	474	AliInfo(Form("dump time: %d", (Int_t)feeConfig->GetDumpTime()));
1605abc6	475	AliInfo(Form("run number: %d", feeConfig->GetRunNumber()));
	476	AliInfo(Form("run type: %d", feeConfig->GetRunType()));
	477	AliInfo("-------------------------------------");
	478
	479	/* loop over crates */
	480	for (Int_t iCrate = 0; iCrate < AliTOFFEEConfig::GetNumberOfCrates(); iCrate++) {
	481	crateConfig = feeConfig->GetCrateConfig(iCrate);
	482
	483	/* check crate config */
	484	if (!crateConfig)
	485	continue;
	486
	487	/* check DRM enabled */
	488	if (!crateConfig->IsDRMEnabled())
	489	continue;
	490
	491	AliInfo(Form("crate id: %02d", iCrate));
	492
	493	/* dump DRM config */
	494	drmConfig = crateConfig->GetDRMConfig();
	495	AliInfo(Form("DRM is enabled: drmId=%d, slotMask=%03x", drmConfig->GetDRMId(), drmConfig->GetSlotMask()));
	496
	497	/* dump LTM config if enabled */
	498	if (crateConfig->IsLTMEnabled()) {
	499	ltmConfig = crateConfig->GetLTMConfig();
	500	AliInfo(Form("LTM is enabled: threshold=%d", ltmConfig->GetThreshold()));
	501	}
	502
	503	/* dump CPDM config if enabled */
	504	if (crateConfig->IsCPDMEnabled()) {
	505	AliInfo(Form("CPDM is enabled"));
	506	}
	507
	508	/* loop over TRMs */
	509	for (Int_t iTRM = 0; iTRM < AliTOFCrateConfig::GetNumberOfTRMs(); iTRM++) {
	510
	511	trmConfig = crateConfig->GetTRMConfig(iTRM);
	512
	513	/* check TRM config */
	514	if (!trmConfig)
	515	continue;
	516
	517	/* check TRM enabled */
	518	if (!crateConfig->IsTRMEnabled(iTRM))
	519	continue;
	520
	521	/* dump TRM config */
	522	AliInfo(Form("TRM%02d is enabled: matchWin=%d, latWin=%d, packFlag=%d", iTRM + 3, trmConfig->GetMatchingWindow(), trmConfig->GetLatencyWindow(), trmConfig->GetPackingFlag()));
	523
	524	/* check TRM chain A flag */
	525	if (trmConfig->GetChainAFlag() == 1) {
71b82bd2	526	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	527	}
	528
	529	/* check TRM chain B flag */
	530	if (trmConfig->GetChainBFlag() == 1) {
71b82bd2	531	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	532	}
	533
	534
	535
	536	} /* loop over TRMs */
	537	AliInfo("-------------------------------------");
	538	} /* loop over crates */
	539	}
	540
046dfc5f	541	//_______________________________________________________________
	542
	543	void
	544	AliTOFFEEReader::CreateFEElightConfig(const Char_t *filename)
	545	{
	546	/*
	547	*
	548	* create FEElight config
	549	*
	550	*/
	551
	552	AliTOFFEElightConfig lightConfig;
	553
	554	for (Int_t i = 0; i < GetNumberOfIndexes(); i++) {
	555	if (fChannelEnabled[i]) {
	556	lightConfig.GetChannelConfig(i)->SetStatus(AliTOFFEEchannelConfig::kStatusEnabled);
	557	lightConfig.GetChannelConfig(i)->SetMatchingWindow(fMatchingWindow[i]);
	558	lightConfig.GetChannelConfig(i)->SetLatencyWindow(fLatencyWindow[i]);
	559	}
	560	else {
	561	lightConfig.GetChannelConfig(i)->SetStatus(0x0);
	562	lightConfig.GetChannelConfig(i)->SetMatchingWindow(0);
	563	lightConfig.GetChannelConfig(i)->SetLatencyWindow(0);
	564	}
	565	}
	566
	567	Char_t *expandedFileName = gSystem->ExpandPathName(filename);
	568	std::ofstream os;
	569	os.open(expandedFileName, std::ios::binary);
	570	os.write((Char_t *)&lightConfig, sizeof(AliTOFFEElightConfig));
	571	os.close();
	572
	573	}