[u/mrichter/AliRoot.git] / MUON / AliMUONHVNamer.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$

#include "AliMUONHVNamer.h"

#include "AliMpArea.h"
#include "AliMpDEIterator.h"
#include "AliMpDEManager.h"
#include "AliMpHelper.h"
#include "AliMpSegmentation.h"
#include "AliMpSlat.h"
#include "AliMpSlatSegmentation.h"
#include "AliMpVPadIterator.h"

#include "AliLog.h"
#include "Riostream.h"
#include "TMap.h"
#include "TObjArray.h"
#include "TObjString.h"
#include "TString.h"
#include "TSystem.h"

/// $Id$
///
/// \class AliMUONHVNamer
/// 
/// A utility class to manage HV DCS aliases names, in particular the
/// two conventions used to number the detection elements within a detector.
///
/// \author: Laurent Aphecetche, Subatech

/// \cond CLASSIMP
ClassImp(AliMUONHVNamer)
/// \endcond

const char* AliMUONHVNamer::fgHVChannelSt345Pattern[] = 
{ "MchHvLvLeft/Chamber%02dLeft/Slat%02d.actual.vMon",
  "MchHvLvRight/Chamber%02dRight/Slat%02d.actual.vMon" 
};

const char* AliMUONHVNamer::fgHVChannelSt12Pattern[] = 
{
  "MchHvLvLeft/Chamber%02dLeft/Quad%dSect%d.actual.vMon",
  "MchHvLvRight/Chamber%02dRight/Quad%dSect%d.actual.vMon",
};
  
const char* AliMUONHVNamer::fgHVSwitchSt345Pattern = "MchDE%04dsw%d.inValue";

//_____________________________________________________________________________
AliMUONHVNamer::AliMUONHVNamer()
{
 /// default ctor 
}

//_____________________________________________________________________________
AliMUONHVNamer::~AliMUONHVNamer()
{
  /// dtor
}

//_____________________________________________________________________________
TObjArray*
AliMUONHVNamer::CompactAliases() const
{
  /// Generate a compact list of aliases, for Shuttle test
  /// This one is completely hand-made, in contrast with GenerateAliases()
  /// method

  TObjArray* a = new TObjArray;
  a->SetOwner(kTRUE);
  
  // St 12 (HV Channels)
  a->Add(new TObjString("MchHvLvRight/Chamber[01..04]Right/Quad1Sect[1..3].actual.vMon"));
  a->Add(new TObjString("MchHvLvLeft/Chamber[01..04]Left/Quad2Sect[1..3].actual.vMon"));
  a->Add(new TObjString("MchHvLvLeft/Chamber[01..04]Left/Quad3Sect[1..3].actual.vMon"));
  a->Add(new TObjString("MchHvLvRight/Chamber[01..04]Right/Quad4Sect[1..3].actual.vMon"));
  
  // St345 (HV Channels)
  
  a->Add(new TObjString("MchHvLvRight/Chamber[05..10]Right/Slat[01..09].actual.vMon"));
  a->Add(new TObjString("MchHvLvLeft/Chamber[05..10]Left/Slat[01..09].actual.vMon"));

  a->Add(new TObjString("MchHvLvRight/Chamber[07..10]Right/Slat[10..13].actual.vMon"));
  a->Add(new TObjString("MchHvLvLeft/Chamber[07..10]Left/Slat[10..13].actual.vMon"));

  // St345 (HV Switches)
  AliMpDEIterator it;
  
  it.First();
  
  while (!it.IsDone())
  {
    Int_t detElemId = it.CurrentDEId();
    if ( AliMpDEManager::GetStationType(detElemId) == AliMp::kStation345 )
    {
          a->Add(new TObjString(Form("MchDE%04dsw[1..%d].inValue",detElemId,NumberOfPCBs(detElemId))));
     }
    it.Next();
  }
  return a;
}

//_____________________________________________________________________________
Int_t 
AliMUONHVNamer::DCS2DE(Int_t chamberId, Int_t side, Int_t dcsNumber) const
{
  /// Convert DCS "slat number" (old convention) to DE (new) convention.
  ///
  /// \param chamberId : chamber number (starting at 1)
  /// \param side : 0 for Left, 1 for Right
  /// \param dcsNumber : slat number in DCS HV convention
  ///
  /// note that dcsNumber should be >=1 and <= number of DEs/2 in chamber

  Int_t nofDE = AliMpDEManager::GetNofDEInChamber(chamberId);
  
  Int_t half = nofDE/2;
  
  dcsNumber = half + 1 - dcsNumber;
  
  Int_t quarter = nofDE/4;
  Int_t threeQuarter = half + quarter;
  
  Int_t de(-1);
  
  if ( side == 0 ) // left
  {
    de = threeQuarter + 1 - dcsNumber;
  }
  else if ( side == 1 ) // right
  {
    if ( dcsNumber <= quarter )
    {
      de = dcsNumber + threeQuarter;
    }
    else
    {
      de = dcsNumber - quarter - 1;
    }
  }
  
  return chamberId*100 + de;
}

//_____________________________________________________________________________
Int_t
AliMUONHVNamer::DetElemId2DCS(Int_t detElemId, Int_t& side) const
{
  /// Convert DE to DCS "slat number"
  /// @see DCS2DE
  
  Int_t chamberId = 1 + AliMpDEManager::GetChamberId(detElemId);
  if ( chamberId < 1 ) 
  {
    AliDebug(1,Form("DetElemId %d invalid",detElemId));
    return -1;
  }
  Int_t dcsNumber = (detElemId-chamberId*100);

  switch ( AliMpDEManager::GetStationType(detElemId) )
  {
    case AliMp::kStation1:
    case AliMp::kStation2:
    {
      switch (dcsNumber)
      {
        case 0:
        case 3:
          side = 1; // right
          ++dcsNumber;
          break;
        case 1:
        case 2:
          side = 0; // left
          ++dcsNumber;
        default:
          break;
      }
    }
      break;
    case AliMp::kStation345:
    {
      Int_t nofDE = AliMpDEManager::GetNofDEInChamber(chamberId-1);
      
      Int_t quarter = nofDE/4;
      
      Int_t half = nofDE/2;
      
      Int_t threeQuarter = half + quarter;  
      
      side = -1;
      
      if ( dcsNumber <= quarter ) 
      {
        dcsNumber += quarter + 1 ;
        side = 1; // right
      }
      else if ( dcsNumber <= threeQuarter )
      {
        dcsNumber = ( threeQuarter - dcsNumber + 1 );
        side = 0; // left
      }
      else if ( dcsNumber > threeQuarter ) 
      {
        dcsNumber = dcsNumber - threeQuarter;
        side = 1; // right
      }
      else
      {
        AliFatal("oups");
      }  
      // dcs convention change : numbering from top, not from bottom
      dcsNumber = half+1-dcsNumber;
    }
      break;
    default:
      break;
  }
  return dcsNumber;
}

//_____________________________________________________________________________
const char* 
AliMUONHVNamer::DCSHVChannelName(Int_t detElemId, Int_t sector) const
{
  /// Return the alias name of the HV Channel for a given HV area 
  /// \param detElemId 
  /// \param sector = 0,1 or 2 for St12, and is unused for st345
  
  Int_t chamberId = 1 + AliMpDEManager::GetChamberId(detElemId);
  if ( chamberId < 1 ) return 0x0;

  Int_t side(-1);
  Int_t dcsNumber = DetElemId2DCS(detElemId,side);
                                  
  switch (AliMpDEManager::GetStationType(detElemId))
  {
    case AliMp::kStation1:
    case AliMp::kStation2:
      return Form(fgHVChannelSt12Pattern[side],chamberId,dcsNumber,sector+1);
      break;
    case AliMp::kStation345:
      return Form(fgHVChannelSt345Pattern[side],chamberId,dcsNumber);
      break;
    default:
      return 0x0;
      break;
  }
}

//_____________________________________________________________________________
const char* 
AliMUONHVNamer::DCSHVSwitchName(Int_t detElemId, Int_t pcbNumber) const
{
  /// Return the alias name of the HV Switch for a given PCB 
  /// within a slat of St345
  
  if (AliMpDEManager::GetStationType(detElemId) == AliMp::kStation345)
  {
    return Form(fgHVSwitchSt345Pattern,detElemId,pcbNumber+1);
  }
  return 0x0;
}

//_____________________________________________________________________________
Int_t 
AliMUONHVNamer::DetElemIdFromDCSAlias(const char* dcsAlias) const
{
  /// Converts the dcs alias to a detection element identifier
  ///
  /// dcsAlias has one of the following 2 forms :
  ///
  /// MchHvLv[Left|Right]/Chamber##[Left|Right]/Chamber##[Left|Right]Slat##.actual.vMon
  ///
  /// MchHvLv[Left|Right]/Chamber##[Left|Right]/Chamber##[Left|Right]Quad#Sect#.actual.vMon
  
  TString sDcsAlias(dcsAlias);
  
  int side(-1);
  
  if ( sDcsAlias.Contains("Left") )
  {
    side = 0;
  }
  else if ( sDcsAlias.Contains("Right") )
  {
    side = 1;
  }
  else
  {
    return -2;
  }
  
  int n1(-1);
  int n3(-1);
  int n4(-1);
  int detElemId(-1);
  
  if ( sDcsAlias.Contains("Slat") )
  {
    sscanf(sDcsAlias.Data(),fgHVChannelSt345Pattern[side],&n1,&n3);
    detElemId = DCS2DE(n1,side,n3);
  }
  else if ( sDcsAlias.Contains("Quad") )
  {
    sscanf(sDcsAlias.Data(),fgHVChannelSt12Pattern[side],&n1,&n3,&n4);    
    detElemId = n3-1;
  }
  else
  {
    return -3;
  }
  
  if ( !AliMpDEManager::IsValidDetElemId(detElemId)  )
  {
    AliError(Form("Invalid aliasName %s",dcsAlias));
    return -1;
  }
  
  return detElemId;
}

//_____________________________________________________________________________
TObjArray*
AliMUONHVNamer::GenerateAliases() const
{
  /// Generate DCS alias names, for MUON Tracker High Voltage system.
  ///
  /// We first generate aliases of HV channels :
  ///
  /// St 1 ch  1 : 12 channels
  ///      ch  2 : 12 channels 
  /// St 2 ch  3 : 12 channels
  ///      ch  4 : 12 channels
  /// St 3 ch  5 : 18 channels
  ///      ch  6 : 18 channels
  /// St 4 ch  7 : 26 channels
  ///      ch  8 : 26 channels
  /// St 5 ch  9 : 26 channels
  ///      ch 10 : 26 channels
  ///
  /// then aliases of HV switches (only for St345) : 1 switch per PCB.
  ///
  /// Returns a TObjArray of TObjString(=alias name)
  
  TObjArray* aliases = new TObjArray;
  aliases->SetOwner(kTRUE);
  
  AliMpDEIterator it;
  
  it.First();
  
  while (!it.IsDone())
  {
    Int_t detElemId = it.CurrentDEId();
    switch ( AliMpDEManager::GetStationType(detElemId) )
    {
      case AliMp::kStation1:
      case AliMp::kStation2:
        for ( int sector = 0; sector < 3; ++sector)
        {
          aliases->Add(new TObjString(DCSHVChannelName(detElemId,sector)));
        }
        break;
      case AliMp::kStation345:
        aliases->Add(new TObjString(DCSHVChannelName(detElemId)));
        for ( Int_t i = 0; i < NumberOfPCBs(detElemId); ++i )
        {
          aliases->Add(new TObjString(DCSHVSwitchName(detElemId,i)));
        }
        break;
      default:
        break;
    }
    it.Next();
  }
  
  return aliases;
}

//_____________________________________________________________________________
Int_t 
AliMUONHVNamer::ManuId2PCBIndex(Int_t detElemId, Int_t manuId) const
{
  /// Returns the index of PCB (within a St345 slat) for a given manu number.
  /// Returns -1 if (detElemId,manuId) is incorrect
  
  const AliMpSlatSegmentation* seg = static_cast<const AliMpSlatSegmentation*>
    (AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId));
  const AliMpSlat* slat = seg->Slat();
  AliMpVPadIterator* it = seg->CreateIterator();
  it->First();
  AliMpPad pad = it->CurrentItem();
  
  while ( !it->IsDone() && pad.GetLocation().GetFirst() != manuId ) 
  {
    it->Next();
    pad = it->CurrentItem();
  }
  
  Int_t pcbIndex = slat->FindPCBIndex(pad.Position().X()+slat->Position().X(),
                                      pad.Position().Y()+slat->Position().Y());
//  AliDebug(1,Form("pcbIndex %d",pcbIndex));
//  StdoutToAliDebug(1,pad.Print());
  return pcbIndex;
}

//_____________________________________________________________________________
Int_t 
AliMUONHVNamer::ManuId2Sector(Int_t /*detElemId*/, Int_t /*manuId*/) const
{
  /// Return the HV-sector number (within a St12 quadrant) for a given manu number.
  
  //FIXME: write me !
  return 0;
}

//_____________________________________________________________________________
Int_t 
AliMUONHVNamer::NumberOfPCBs(Int_t detElemId) const
{
  /// Returns the number of PCB in a given detection element
  /// Only works for St345
  
  AliMp::StationType stationType = AliMpDEManager::GetStationType(detElemId);
  if ( stationType != AliMp::kStation345 )
  {
    return 0;
  }
  else
  {
    const AliMpSlatSegmentation* seg = static_cast<const AliMpSlatSegmentation*>
    (AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,AliMp::kCath0));
    const AliMpSlat* slat = seg->Slat();
    return slat->GetSize();
  }
}
Commit	Line	Data
6b8b24d4	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	// $Id$
	17
	18	#include "AliMUONHVNamer.h"
	19
	20	#include "AliMpArea.h"
	21	#include "AliMpDEIterator.h"
	22	#include "AliMpDEManager.h"
	23	#include "AliMpHelper.h"
	24	#include "AliMpSegmentation.h"
	25	#include "AliMpSlat.h"
	26	#include "AliMpSlatSegmentation.h"
	27	#include "AliMpVPadIterator.h"
	28
	29	#include "AliLog.h"
	30	#include "Riostream.h"
	31	#include "TMap.h"
	32	#include "TObjArray.h"
	33	#include "TObjString.h"
	34	#include "TString.h"
	35	#include "TSystem.h"
	36
	37	/// $Id$
	38	///
	39	/// \class AliMUONHVNamer
	40	///
	41	/// A utility class to manage HV DCS aliases names, in particular the
	42	/// two conventions used to number the detection elements within a detector.
	43	///
78649106	44	/// \author: Laurent Aphecetche, Subatech
6b8b24d4	45
	46	/// \cond CLASSIMP
	47	ClassImp(AliMUONHVNamer)
	48	/// \endcond
	49
	50	const char* AliMUONHVNamer::fgHVChannelSt345Pattern[] =
	51	{ "MchHvLvLeft/Chamber%02dLeft/Slat%02d.actual.vMon",
	52	"MchHvLvRight/Chamber%02dRight/Slat%02d.actual.vMon"
	53	};
	54
	55	const char* AliMUONHVNamer::fgHVChannelSt12Pattern[] =
	56	{
	57	"MchHvLvLeft/Chamber%02dLeft/Quad%dSect%d.actual.vMon",
	58	"MchHvLvRight/Chamber%02dRight/Quad%dSect%d.actual.vMon",
	59	};
	60
98cd9139	61	const char* AliMUONHVNamer::fgHVSwitchSt345Pattern = "MchDE%04dsw%d.inValue";
6b8b24d4	62
	63	//_____________________________________________________________________________
	64	AliMUONHVNamer::AliMUONHVNamer()
	65	{
	66	/// default ctor
	67	}
	68
	69	//_____________________________________________________________________________
	70	AliMUONHVNamer::~AliMUONHVNamer()
	71	{
	72	/// dtor
	73	}
	74
	75	//_____________________________________________________________________________
	76	TObjArray*
	77	AliMUONHVNamer::CompactAliases() const
	78	{
	79	/// Generate a compact list of aliases, for Shuttle test
	80	/// This one is completely hand-made, in contrast with GenerateAliases()
	81	/// method
	82
	83	TObjArray* a = new TObjArray;
	84	a->SetOwner(kTRUE);
	85
	86	// St 12 (HV Channels)
	87	a->Add(new TObjString("MchHvLvRight/Chamber[01..04]Right/Quad1Sect[1..3].actual.vMon"));
	88	a->Add(new TObjString("MchHvLvLeft/Chamber[01..04]Left/Quad2Sect[1..3].actual.vMon"));
	89	a->Add(new TObjString("MchHvLvLeft/Chamber[01..04]Left/Quad3Sect[1..3].actual.vMon"));
	90	a->Add(new TObjString("MchHvLvRight/Chamber[01..04]Right/Quad4Sect[1..3].actual.vMon"));
	91
	92	// St345 (HV Channels)
	93
	94	a->Add(new TObjString("MchHvLvRight/Chamber[05..10]Right/Slat[01..09].actual.vMon"));
	95	a->Add(new TObjString("MchHvLvLeft/Chamber[05..10]Left/Slat[01..09].actual.vMon"));
	96
	97	a->Add(new TObjString("MchHvLvRight/Chamber[07..10]Right/Slat[10..13].actual.vMon"));
	98	a->Add(new TObjString("MchHvLvLeft/Chamber[07..10]Left/Slat[10..13].actual.vMon"));
	99
	100	// St345 (HV Switches)
	101	AliMpDEIterator it;
	102
	103	it.First();
	104
	105	while (!it.IsDone())
	106	{
	107	Int_t detElemId = it.CurrentDEId();
	108	if ( AliMpDEManager::GetStationType(detElemId) == AliMp::kStation345 )
	109	{
98cd9139	110	a->Add(new TObjString(Form("MchDE%04dsw[1..%d].inValue",detElemId,NumberOfPCBs(detElemId))));
6b8b24d4	111	}
	112	it.Next();
	113	}
	114	return a;
	115	}
	116
	117	//_____________________________________________________________________________
	118	Int_t
	119	AliMUONHVNamer::DCS2DE(Int_t chamberId, Int_t side, Int_t dcsNumber) const
	120	{
	121	/// Convert DCS "slat number" (old convention) to DE (new) convention.
	122	///
78649106	123	/// \param chamberId : chamber number (starting at 1)
	124	/// \param side : 0 for Left, 1 for Right
	125	/// \param dcsNumber : slat number in DCS HV convention
6b8b24d4	126	///
	127	/// note that dcsNumber should be >=1 and <= number of DEs/2 in chamber
	128
	129	Int_t nofDE = AliMpDEManager::GetNofDEInChamber(chamberId);
	130
	131	Int_t half = nofDE/2;
38ca2128	132
	133	dcsNumber = half + 1 - dcsNumber;
	134
6b8b24d4	135	Int_t quarter = nofDE/4;
	136	Int_t threeQuarter = half + quarter;
	137
	138	Int_t de(-1);
	139
	140	if ( side == 0 ) // left
	141	{
	142	de = threeQuarter + 1 - dcsNumber;
	143	}
	144	else if ( side == 1 ) // right
	145	{
	146	if ( dcsNumber <= quarter )
	147	{
	148	de = dcsNumber + threeQuarter;
	149	}
	150	else
	151	{
	152	de = dcsNumber - quarter - 1;
	153	}
	154	}
	155
	156	return chamberId*100 + de;
	157	}
	158
	159	//_____________________________________________________________________________
	160	Int_t
	161	AliMUONHVNamer::DetElemId2DCS(Int_t detElemId, Int_t& side) const
	162	{
	163	/// Convert DE to DCS "slat number"
	164	/// @see DCS2DE
	165
	166	Int_t chamberId = 1 + AliMpDEManager::GetChamberId(detElemId);
	167	if ( chamberId < 1 )
	168	{
	169	AliDebug(1,Form("DetElemId %d invalid",detElemId));
	170	return -1;
	171	}
	172	Int_t dcsNumber = (detElemId-chamberId*100);
	173
	174	switch ( AliMpDEManager::GetStationType(detElemId) )
	175	{
	176	case AliMp::kStation1:
	177	case AliMp::kStation2:
	178	{
	179	switch (dcsNumber)
	180	{
	181	case 0:
	182	case 3:
	183	side = 1; // right
	184	++dcsNumber;
	185	break;
	186	case 1:
	187	case 2:
	188	side = 0; // left
	189	++dcsNumber;
	190	default:
	191	break;
	192	}
	193	}
	194	break;
	195	case AliMp::kStation345:
	196	{
	197	Int_t nofDE = AliMpDEManager::GetNofDEInChamber(chamberId-1);
	198
199	Int_t quarter = nofDE/4;
200
201	Int_t half = nofDE/2;
202
203	Int_t threeQuarter = half + quarter;
204
205	side = -1;
206
207	if ( dcsNumber <= quarter )
208	{
209	dcsNumber += quarter + 1 ;
210	side = 1; // right
211	}
38ca2128	212	else if ( dcsNumber <= threeQuarter )
	213	{
	214	dcsNumber = ( threeQuarter - dcsNumber + 1 );
	215	side = 0; // left
	216	}
	217	else if ( dcsNumber > threeQuarter )
	218	{
	219	dcsNumber = dcsNumber - threeQuarter;
	220	side = 1; // right
	221	}
	222	else
	223	{
	224	AliFatal("oups");
	225	}
	226	// dcs convention change : numbering from top, not from bottom
	227	dcsNumber = half+1-dcsNumber;
6b8b24d4	228	}
38ca2128	229	break;
6b8b24d4	230	default:
	231	break;
	232	}
	233	return dcsNumber;
	234	}
	235
	236	//_____________________________________________________________________________
	237	const char*
	238	AliMUONHVNamer::DCSHVChannelName(Int_t detElemId, Int_t sector) const
	239	{
	240	/// Return the alias name of the HV Channel for a given HV area
78649106	241	/// \param detElemId
78649106	242	/// \param sector = 0,1 or 2 for St12, and is unused for st345
6b8b24d4	243
	244	Int_t chamberId = 1 + AliMpDEManager::GetChamberId(detElemId);
	245	if ( chamberId < 1 ) return 0x0;
	246
	247	Int_t side(-1);
	248	Int_t dcsNumber = DetElemId2DCS(detElemId,side);
	249
	250	switch (AliMpDEManager::GetStationType(detElemId))
	251	{
	252	case AliMp::kStation1:
	253	case AliMp::kStation2:
	254	return Form(fgHVChannelSt12Pattern[side],chamberId,dcsNumber,sector+1);
	255	break;
	256	case AliMp::kStation345:
	257	return Form(fgHVChannelSt345Pattern[side],chamberId,dcsNumber);
	258	break;
	259	default:
	260	return 0x0;
	261	break;
	262	}
	263	}
	264
	265	//_____________________________________________________________________________
	266	const char*
	267	AliMUONHVNamer::DCSHVSwitchName(Int_t detElemId, Int_t pcbNumber) const
	268	{
	269	/// Return the alias name of the HV Switch for a given PCB
	270	/// within a slat of St345
	271
	272	if (AliMpDEManager::GetStationType(detElemId) == AliMp::kStation345)
	273	{
	274	return Form(fgHVSwitchSt345Pattern,detElemId,pcbNumber+1);
	275	}
	276	return 0x0;
	277	}
	278
	279	//_____________________________________________________________________________
	280	Int_t
	281	AliMUONHVNamer::DetElemIdFromDCSAlias(const char* dcsAlias) const
	282	{
	283	/// Converts the dcs alias to a detection element identifier
	284	///
	285	/// dcsAlias has one of the following 2 forms :
	286	///
	287	/// MchHvLv[Left\|Right]/Chamber##[Left\|Right]/Chamber##[Left\|Right]Slat##.actual.vMon
	288	///
	289	/// MchHvLv[Left\|Right]/Chamber##[Left\|Right]/Chamber##[Left\|Right]Quad#Sect#.actual.vMon
	290
	291	TString sDcsAlias(dcsAlias);
	292
	293	int side(-1);
	294
	295	if ( sDcsAlias.Contains("Left") )
	296	{
	297	side = 0;
	298	}
	299	else if ( sDcsAlias.Contains("Right") )
	300	{
	301	side = 1;
	302	}
	303	else
	304	{
	305	return -2;
	306	}
307
308	int n1(-1);
309	int n3(-1);
310	int n4(-1);
311	int detElemId(-1);
312
313	if ( sDcsAlias.Contains("Slat") )
314	{
315	sscanf(sDcsAlias.Data(),fgHVChannelSt345Pattern[side],&n1,&n3);
316	detElemId = DCS2DE(n1,side,n3);
317	}
318	else if ( sDcsAlias.Contains("Quad") )
319	{
320	sscanf(sDcsAlias.Data(),fgHVChannelSt12Pattern[side],&n1,&n3,&n4);
321	detElemId = n3-1;
322	}
323	else
324	{
325	return -3;
326	}
327
328	if ( !AliMpDEManager::IsValidDetElemId(detElemId) )
329	{
330	AliError(Form("Invalid aliasName %s",dcsAlias));
331	return -1;
332	}
333
334	return detElemId;
335	}
336
337	//_____________________________________________________________________________
338	TObjArray*
339	AliMUONHVNamer::GenerateAliases() const
340	{
341	/// Generate DCS alias names, for MUON Tracker High Voltage system.
342	///
343	/// We first generate aliases of HV channels :
344	///
345	/// St 1 ch 1 : 12 channels
346	/// ch 2 : 12 channels
347	/// St 2 ch 3 : 12 channels
348	/// ch 4 : 12 channels
349	/// St 3 ch 5 : 18 channels
350	/// ch 6 : 18 channels
351	/// St 4 ch 7 : 26 channels
352	/// ch 8 : 26 channels
353	/// St 5 ch 9 : 26 channels
354	/// ch 10 : 26 channels
355	///
356	/// then aliases of HV switches (only for St345) : 1 switch per PCB.
357	///
358	/// Returns a TObjArray of TObjString(=alias name)
359
360	TObjArray* aliases = new TObjArray;
361	aliases->SetOwner(kTRUE);
362
363	AliMpDEIterator it;
364
365	it.First();
366
367	while (!it.IsDone())
368	{
369	Int_t detElemId = it.CurrentDEId();
370	switch ( AliMpDEManager::GetStationType(detElemId) )
371	{
372	case AliMp::kStation1:
373	case AliMp::kStation2:
374	for ( int sector = 0; sector < 3; ++sector)
375	{
376	aliases->Add(new TObjString(DCSHVChannelName(detElemId,sector)));
377	}
378	break;
379	case AliMp::kStation345:
380	aliases->Add(new TObjString(DCSHVChannelName(detElemId)));
381	for ( Int_t i = 0; i < NumberOfPCBs(detElemId); ++i )
382	{
383	aliases->Add(new TObjString(DCSHVSwitchName(detElemId,i)));
384	}
385	break;
386	default:
387	break;
388	}
389	it.Next();
390	}
391
392	return aliases;
393	}
394
395	//_____________________________________________________________________________
396	Int_t
397	AliMUONHVNamer::ManuId2PCBIndex(Int_t detElemId, Int_t manuId) const
398	{
399	/// Returns the index of PCB (within a St345 slat) for a given manu number.
400	/// Returns -1 if (detElemId,manuId) is incorrect
401
402	const AliMpSlatSegmentation* seg = static_cast<const AliMpSlatSegmentation*>
403	(AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId));
404	const AliMpSlat* slat = seg->Slat();
405	AliMpVPadIterator* it = seg->CreateIterator();
406	it->First();
407	AliMpPad pad = it->CurrentItem();
408
409	while ( !it->IsDone() && pad.GetLocation().GetFirst() != manuId )
410	{
411	it->Next();
412	pad = it->CurrentItem();
413	}
414
415	Int_t pcbIndex = slat->FindPCBIndex(pad.Position().X()+slat->Position().X(),
416	pad.Position().Y()+slat->Position().Y());
417	// AliDebug(1,Form("pcbIndex %d",pcbIndex));
418	// StdoutToAliDebug(1,pad.Print());
419	return pcbIndex;
420	}
421
422	//_____________________________________________________________________________
423	Int_t
d7fc09b9	424	AliMUONHVNamer::ManuId2Sector(Int_t /detElemId/, Int_t /manuId/) const
6b8b24d4	425	{
	426	/// Return the HV-sector number (within a St12 quadrant) for a given manu number.
	427
	428	//FIXME: write me !
	429	return 0;
	430	}
	431
	432	//_____________________________________________________________________________
	433	Int_t
	434	AliMUONHVNamer::NumberOfPCBs(Int_t detElemId) const
	435	{
	436	/// Returns the number of PCB in a given detection element
	437	/// Only works for St345
	438
	439	AliMp::StationType stationType = AliMpDEManager::GetStationType(detElemId);
	440	if ( stationType != AliMp::kStation345 )
	441	{
	442	return 0;
	443	}
	444	else
	445	{
	446	const AliMpSlatSegmentation* seg = static_cast<const AliMpSlatSegmentation*>
	447	(AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,AliMp::kCath0));
	448	const AliMpSlat* slat = seg->Slat();
	449	return slat->GetSize();
	450	}
	451	}