Line data Source code
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 "AliMpDCSNamer.h"
19 :
20 : #include "AliCodeTimer.h"
21 : #include "AliLog.h"
22 : #include "AliMpArea.h"
23 : #include "AliMpDEIterator.h"
24 : #include "AliMpDEManager.h"
25 : #include "AliMpHelper.h"
26 : #include "AliMpMotifMap.h"
27 : #include "AliMpMotifPosition.h"
28 : #include "AliMpSector.h"
29 : #include "AliMpSegmentation.h"
30 : #include "AliMpSlat.h"
31 : #include "AliMpConstants.h"
32 : #include <Riostream.h>
33 : #include <TMap.h>
34 : #include <TObjArray.h>
35 : #include <TObjString.h>
36 : #include <TString.h>
37 : #include <TSystem.h>
38 : #include <cassert>
39 :
40 : //-----------------------------------------------------------------------------
41 : /// \class AliMpDCSNamer
42 : ///
43 : /// A utility class to manage DCS aliases names, in particular the
44 : /// two conventions used to number the detection elements within a detector.
45 : ///
46 : /// \author: Laurent Aphecetche and Diego Stocco, Subatech
47 : //-----------------------------------------------------------------------------
48 :
49 : using std::cout;
50 : using std::endl;
51 : /// \cond CLASSIMP
52 18 : ClassImp(AliMpDCSNamer)
53 : /// \endcond
54 :
55 : const char* AliMpDCSNamer::fgkDCSChannelSt345Pattern[] =
56 : { "MchHvLvLeft/Chamber%02dLeft/Slat%02d.actual.vMon",
57 : "MchHvLvRight/Chamber%02dRight/Slat%02d.actual.vMon"
58 : };
59 :
60 : const char* AliMpDCSNamer::fgkDCSChannelSt12Pattern[] =
61 : {
62 : "MchHvLvLeft/Chamber%02dLeft/Quad%dSect%d.actual.vMon",
63 : "MchHvLvRight/Chamber%02dRight/Quad%dSect%d.actual.vMon"
64 : };
65 :
66 : const char* AliMpDCSNamer::fgkDCSQuadrantPattern[] =
67 : {
68 : "MchHvLvLeft/Chamber%02dLeft/Quad%d",
69 : "MchHvLvRight/Chamber%02dRight/Quad%d"
70 : };
71 :
72 : const char* AliMpDCSNamer::fgkDCSChamberPattern[] =
73 :
74 : {
75 : "MchHvLvLeft/Chamber%02dLeft",
76 : "MchHvLvRight/Chamber%02dRight"
77 : };
78 :
79 :
80 : const char* AliMpDCSNamer::fgkDCSMCHLVGroupPattern[] =
81 : {
82 : "MchHvLvLeft/Chamber%02dLeft/Group%d%s.MeasurementSenseVoltage",
83 : "MchHvLvRight/Chamber%02dRight/Group%d%s.MeasurementSenseVoltage"
84 : };
85 :
86 : const char* AliMpDCSNamer::fgkDCSSideTrackerName[] = { "Left", "Right" };
87 :
88 :
89 : const char* AliMpDCSNamer::fgkDCSSwitchSt345Pattern = "MchDE%04dsw%d.inValue";
90 :
91 : const char* AliMpDCSNamer::fgkDCSChannelTriggerPatternRead[] = {"MTR_%3sSIDE_MT%2i_RPC%i_HV.%14s", "MTR_%2sSIDE_MT%2i_RPC%i_HV.%14s"};
92 : const char* AliMpDCSNamer::fgkDCSChannelTriggerPattern[] = {"MTR_%3sSIDE_MT%2i_RPC%i_HV.%s", "MTR_%2sSIDE_MT%2i_RPC%i_HV.%s"};
93 : const char* AliMpDCSNamer::fgkDCSSideTriggerName[] = { "OUT", "IN" };
94 : const char* AliMpDCSNamer::fgkDCSMeasureName[] = { "vEff", "actual.iMon" };
95 :
96 : const char* AliMpDCSNamer::fgkDetectorName[] = { "TRACKER", "TRIGGER" };
97 :
98 : //_____________________________________________________________________________
99 0 : AliMpDCSNamer::AliMpDCSNamer():
100 0 : fDetector(-1)
101 0 : {
102 0 : SetDetector("TRACKER");
103 : /// default ctor
104 0 : }
105 :
106 : //_____________________________________________________________________________
107 73628 : AliMpDCSNamer::AliMpDCSNamer(const char* detName):
108 73628 : fDetector(-1)
109 368140 : {
110 : /// ctor taking the detector name as argument (either trigger or tracker)
111 73628 : SetDetector(detName);
112 147256 : }
113 :
114 : //_____________________________________________________________________________
115 : AliMpDCSNamer::~AliMpDCSNamer()
116 147256 : {
117 : /// dtor
118 220884 : }
119 :
120 : //_____________________________________________________________________________
121 : Bool_t AliMpDCSNamer::SetDetector(const char* detName)
122 : {
123 : /// Set the detector type
124 : /// \param detName = tracker, trigger
125 :
126 147256 : TString sDetName(detName);
127 : Bool_t isOk(kTRUE);
128 73628 : sDetName.ToUpper();
129 147256 : if(sDetName.Contains(fgkDetectorName[kTrackerDet]))
130 73628 : fDetector = kTrackerDet;
131 0 : else if(sDetName.Contains(fgkDetectorName[kTriggerDet]))
132 0 : fDetector = kTriggerDet;
133 : else {
134 0 : AliWarning("Detector name must be either tracker or trigger. Default tracker selected");
135 : isOk = kFALSE;
136 : }
137 73628 : return isOk;
138 73628 : }
139 :
140 :
141 : //_____________________________________________________________________________
142 : void
143 : AliMpDCSNamer::AliasesAsLdif(const char* ldiffile) const
144 : {
145 : /// Export the aliases in LDIF format
146 :
147 0 : ofstream out(ldiffile);
148 :
149 0 : TObjArray* a = CompactAliases();
150 :
151 0 : TIter next(a);
152 : TObjString* s;
153 :
154 : // Some header. host name and port probably not up to date.
155 0 : TString detName = (fDetector == kTriggerDet) ? "MTR" : "MCH";
156 :
157 0 : out << "#" << detName.Data() << " config" << endl
158 0 : << "dn: det=" << detName.Data() <<",o=alice,dc=cern,dc=ch" << endl
159 0 : << "objectClass: AliShuttleDetector" << endl
160 0 : << "det: " << detName.Data() << endl
161 0 : << "StrictRunOrder: 1" << endl
162 0 : << "responsible: aphecetc@in2p3.fr" << endl
163 0 : << "DCSHost: aldcs053.cern.ch" << endl
164 0 : << "DCSPort: 4242" <<endl;
165 :
166 0 : while ( ( s = (TObjString*)(next()) ) )
167 : {
168 0 : out << "DCSalias: " << s->String().Data() << endl;
169 : }
170 :
171 0 : out.close();
172 :
173 0 : delete a;
174 0 : }
175 :
176 : //_____________________________________________________________________________
177 : TObjArray*
178 : AliMpDCSNamer::CompactAliases() const
179 : {
180 : /// Generate a compact list of aliases, for Shuttle test
181 : /// This one is completely hand-made, in contrast with GenerateAliases()
182 : /// method
183 :
184 0 : TObjArray* a = new TObjArray;
185 0 : a->SetOwner(kTRUE);
186 :
187 0 : switch(fDetector){
188 : case kTrackerDet:
189 : // St 12 (DCS HV Channels)
190 0 : a->Add(new TObjString("MchHvLvRight/Chamber[00..03]Right/Quad0Sect[0..2].actual.vMon"));
191 0 : a->Add(new TObjString("MchHvLvLeft/Chamber[00..03]Left/Quad1Sect[0..2].actual.vMon"));
192 0 : a->Add(new TObjString("MchHvLvLeft/Chamber[00..03]Left/Quad2Sect[0..2].actual.vMon"));
193 0 : a->Add(new TObjString("MchHvLvRight/Chamber[00..03]Right/Quad3Sect[0..2].actual.vMon"));
194 :
195 : // St345 (DCS HV Channels)
196 :
197 0 : a->Add(new TObjString("MchHvLvRight/Chamber[04..09]Right/Slat[00..08].actual.vMon"));
198 0 : a->Add(new TObjString("MchHvLvLeft/Chamber[04..09]Left/Slat[00..08].actual.vMon"));
199 :
200 0 : a->Add(new TObjString("MchHvLvRight/Chamber[06..09]Right/Slat[09..12].actual.vMon"));
201 0 : a->Add(new TObjString("MchHvLvLeft/Chamber[06..09]Left/Slat[09..12].actual.vMon"));
202 :
203 : // (LV groups)
204 :
205 : // St12 have 4 LV groups
206 :
207 0 : a->Add(new TObjString("MchHvLvLeft/Chamber[01..10]Left/Group[1..4]dig.MeasurementSenseVoltage"));
208 0 : a->Add(new TObjString("MchHvLvLeft/Chamber[01..10]Left/Group[1..4]ann.MeasurementSenseVoltage"));
209 0 : a->Add(new TObjString("MchHvLvLeft/Chamber[01..10]Left/Group[1..4]anp.MeasurementSenseVoltage"));
210 0 : a->Add(new TObjString("MchHvLvRight/Chamber[01..10]Right/Group[1..4]dig.MeasurementSenseVoltage"));
211 0 : a->Add(new TObjString("MchHvLvRight/Chamber[01..10]Right/Group[1..4]ann.MeasurementSenseVoltage"));
212 0 : a->Add(new TObjString("MchHvLvRight/Chamber[01..10]Right/Group[1..4]anp.MeasurementSenseVoltage"));
213 :
214 : // St3 has 5 LV groups
215 :
216 0 : a->Add(new TObjString("MchHvLvLeft/Chamber[05..06]Left/Group[5..5]dig.MeasurementSenseVoltage"));
217 0 : a->Add(new TObjString("MchHvLvLeft/Chamber[05..06]Left/Group[5..5]ann.MeasurementSenseVoltage"));
218 0 : a->Add(new TObjString("MchHvLvLeft/Chamber[05..06]Left/Group[5..5]anp.MeasurementSenseVoltage"));
219 0 : a->Add(new TObjString("MchHvLvRight/Chamber[05..06]Right/Group[5..5]dig.MeasurementSenseVoltage"));
220 0 : a->Add(new TObjString("MchHvLvRight/Chamber[05..06]Right/Group[5..5]ann.MeasurementSenseVoltage"));
221 0 : a->Add(new TObjString("MchHvLvRight/Chamber[05..06]Right/Group[5..5]anp.MeasurementSenseVoltage"));
222 :
223 : // St4-5 have 7 LV groups
224 0 : a->Add(new TObjString("MchHvLvLeft/Chamber[07..10]Left/Group[5..7]dig.MeasurementSenseVoltage"));
225 0 : a->Add(new TObjString("MchHvLvLeft/Chamber[07..10]Left/Group[5..7]ann.MeasurementSenseVoltage"));
226 0 : a->Add(new TObjString("MchHvLvLeft/Chamber[07..10]Left/Group[5..7]anp.MeasurementSenseVoltage"));
227 0 : a->Add(new TObjString("MchHvLvRight/Chamber[07..10]Right/Group[5..7]dig.MeasurementSenseVoltage"));
228 0 : a->Add(new TObjString("MchHvLvRight/Chamber[07..10]Right/Group[5..7]ann.MeasurementSenseVoltage"));
229 0 : a->Add(new TObjString("MchHvLvRight/Chamber[07..10]Right/Group[5..7]anp.MeasurementSenseVoltage"));
230 :
231 0 : break;
232 :
233 : case kTriggerDet:
234 0 : a->Add(new TObjString("MTR_OUTSIDE_MT[11..12]Right/RPC[1..9]_HV.imon"));
235 0 : a->Add(new TObjString("MTR_OUTSIDE_MT[21..22]Right/RPC[1..9]_HV.imon"));
236 0 : a->Add(new TObjString("MTR_INSIDE_MT[11..12]Right/RPC[1..9]_HV.imon"));
237 0 : a->Add(new TObjString("MTR_INSIDE_MT[21..22]Right/RPC[1..9]_HV.imon"));
238 :
239 0 : a->Add(new TObjString("MTR_OUTSIDE_MT[11..12]Right/RPC[1..9]_HV.vmon"));
240 0 : a->Add(new TObjString("MTR_OUTSIDE_MT[21..22]Right/RPC[1..9]_HV.vmon"));
241 0 : a->Add(new TObjString("MTR_INSIDE_MT[11..12]Right/RPC[1..9]_HV.vmon"));
242 0 : a->Add(new TObjString("MTR_INSIDE_MT[21..22]Right/RPC[1..9]_HV.vmon"));
243 0 : }
244 :
245 :
246 0 : if(fDetector == kTrackerDet){
247 : // St345 (DCS Switches)
248 0 : AliMpDEIterator it;
249 :
250 0 : it.First();
251 :
252 0 : while (!it.IsDone())
253 : {
254 0 : Int_t detElemId = it.CurrentDEId();
255 0 : if ( AliMpDEManager::GetStationType(detElemId) == AliMp::kStation345 )
256 : {
257 0 : a->Add(new TObjString(Form("MchDE%04dsw[0..%d].inValue",detElemId,NumberOfPCBs(detElemId)-1)));
258 : }
259 0 : it.Next();
260 : }
261 0 : }
262 :
263 0 : return a;
264 0 : }
265 :
266 : //_____________________________________________________________________________
267 : Int_t
268 : AliMpDCSNamer::DCS2DE(Int_t chId, Int_t side, Int_t dcsNumber) const
269 : {
270 : /// Convert DCS Tracker "slat number" (old convention) to DE (new) convention.
271 : ///
272 : /// \param chamberId : chamber number (starting at 0)
273 : /// \param side : 0 for Left, 1 for Right
274 : /// \param dcsNumber : slat number in DCS convention
275 : ///
276 : /// note that dcsNumber should be >=0 and < number of DEs/2 in chamber
277 :
278 : Int_t de(-1);
279 : Int_t chamberId = chId;
280 :
281 0 : if(fDetector == kTrackerDet){ // Tracker
282 :
283 0 : Int_t nofDE = AliMpDEManager::GetNofDEInChamber(chamberId);
284 :
285 0 : Int_t half = nofDE/2;
286 :
287 0 : dcsNumber = half - dcsNumber;
288 :
289 0 : Int_t quarter = nofDE/4;
290 0 : Int_t threeQuarter = half + quarter;
291 :
292 0 : if ( side == 0 ) // left
293 : {
294 0 : de = threeQuarter + 1 - dcsNumber;
295 0 : }
296 0 : else if ( side == 1 ) // right
297 : {
298 0 : if ( dcsNumber <= quarter )
299 : {
300 0 : de = dcsNumber + threeQuarter;
301 0 : }
302 : else
303 : {
304 0 : de = dcsNumber - quarter - 1;
305 : }
306 : }
307 0 : }
308 : else { // Trigger
309 :
310 0 : if ( chId < 19 ) chamberId = chId - 1;
311 0 : else chamberId = chId - 9;
312 :
313 0 : Int_t nofDE = AliMpDEManager::GetNofDEInChamber(chamberId);
314 :
315 0 : if ( side == 0 ) // left -> Outside
316 : {
317 0 : de = 14 - dcsNumber;
318 0 : }
319 0 : else if ( side == 1 ) // right -> Inside
320 : {
321 0 : if (nofDE>0)
322 0 : de = (13 + dcsNumber) % nofDE;
323 : }
324 : }
325 :
326 0 : return (chamberId+1)*100 + de;
327 : }
328 :
329 :
330 : //_____________________________________________________________________________
331 : Int_t
332 : AliMpDCSNamer::DetElemId2DCS(Int_t detElemId, Int_t& side, Int_t &chId) const
333 : {
334 : /// Convert DE to DCS "slat number"
335 : /// @see DCS2DE
336 :
337 2592 : CheckConsistency(detElemId);
338 :
339 1296 : Int_t chamberId = AliMpDEManager::GetChamberId(detElemId);
340 1296 : if ( chamberId < 0 )
341 : {
342 0 : AliDebug(1,Form("DetElemId %d invalid",detElemId));
343 0 : return -1;
344 : }
345 2496 : Int_t dcsNumber = (detElemId-(chamberId+1)*100);
346 :
347 2496 : switch ( AliMpDEManager::GetStationType(detElemId) )
348 : {
349 : case AliMp::kStation12:
350 : {
351 192 : chId = chamberId;
352 :
353 192 : switch (dcsNumber)
354 : {
355 : case 0:
356 : case 3:
357 48 : side = 1; // right
358 48 : break;
359 : case 1:
360 : case 2:
361 48 : side = 0; // left
362 : default:
363 : break;
364 : }
365 : }
366 : break;
367 : case AliMp::kStation345:
368 : {
369 1200 : chId = chamberId;
370 :
371 1200 : Int_t nofDE = AliMpDEManager::GetNofDEInChamber(chamberId);
372 :
373 1200 : Int_t quarter = nofDE/4;
374 :
375 1200 : Int_t half = nofDE/2;
376 :
377 1200 : Int_t threeQuarter = half + quarter;
378 :
379 1200 : side = -1;
380 :
381 1200 : if ( dcsNumber <= quarter )
382 : {
383 328 : dcsNumber += quarter + 1 ;
384 328 : side = 1; // right
385 328 : }
386 872 : else if ( dcsNumber <= threeQuarter )
387 : {
388 600 : dcsNumber = ( threeQuarter - dcsNumber + 1 );
389 600 : side = 0; // left
390 600 : }
391 272 : else if ( dcsNumber > threeQuarter )
392 : {
393 272 : dcsNumber = dcsNumber - threeQuarter;
394 272 : side = 1; // right
395 272 : }
396 : else
397 : {
398 0 : AliFatal("oups");
399 : }
400 : // dcs convention change : numbering from top, not from bottom
401 1200 : dcsNumber = half-dcsNumber;
402 : }
403 1200 : break;
404 : case AliMp::kStationTrigger:
405 : {
406 0 : if (chamberId < AliMpConstants::NofChambers()-2)
407 0 : chId = chamberId + 1;
408 0 : else chId = 23 + chamberId - AliMpConstants::NofChambers();
409 :
410 0 : Int_t nofDE = AliMpDEManager::GetNofDEInChamber(chamberId);
411 :
412 0 : if ( dcsNumber >=5 && dcsNumber <= 13 ) {
413 0 : side = 0;
414 0 : dcsNumber = 14 - dcsNumber;
415 0 : }
416 : else {
417 0 : side = 1;
418 0 : if (nofDE>0)
419 0 : dcsNumber = (5 + dcsNumber) % nofDE;
420 : }
421 0 : AliDebug(10, Form("detElemId %i -> MT%i_side%i_L%i", detElemId, chId, side, dcsNumber));
422 : }
423 0 : break;
424 : default:
425 : break;
426 : }
427 :
428 : return dcsNumber;
429 1296 : }
430 :
431 : //_____________________________________________________________________________
432 : TString
433 : AliMpDCSNamer::DCSNameFromAlias(const char* dcsAlias) const
434 : {
435 : /// Convert a (possibly partial) aliasname to a name (only for MCH HV)
436 :
437 0 : TString salias(dcsAlias);
438 :
439 0 : if ( !salias.Contains("MchHvLv") ) return dcsAlias; // not MCH
440 0 : if ( salias.Contains("Group")) return dcsAlias; // not MCH HV (but LV)
441 :
442 0 : Int_t quadrantNumber(-1);
443 0 : Int_t chamberNumber(-1);
444 : Int_t side(-1);
445 :
446 0 : if ( salias.Contains("Left")) side = 0;
447 0 : if ( salias.Contains("Right")) side = 1;
448 :
449 0 : if ( side < 0 ) return "";
450 :
451 0 : TString channelName;
452 :
453 0 : if ( salias.Contains("Slat") )
454 : {
455 0 : Int_t slatNumber(-1);
456 0 : sscanf(salias.Data(),fgkDCSChannelSt345Pattern[side],&chamberNumber,&slatNumber);
457 0 : ++chamberNumber;
458 0 : ++slatNumber;
459 0 : channelName = TString::Format(fgkDCSChannelSt345Pattern[side],chamberNumber,slatNumber);
460 0 : }
461 0 : else if ( salias.Contains("Sect") )
462 : {
463 0 : Int_t sectorNumber(-1);
464 0 : sscanf(salias.Data(),fgkDCSChannelSt12Pattern[side],&chamberNumber,&quadrantNumber,§orNumber);
465 0 : ++chamberNumber;
466 0 : ++quadrantNumber;
467 0 : ++sectorNumber;
468 0 : channelName = TString::Format(fgkDCSChannelSt12Pattern[side],chamberNumber,quadrantNumber,sectorNumber);
469 0 : }
470 0 : else if ( salias.Contains("Quad") )
471 : {
472 0 : sscanf(salias.Data(),fgkDCSQuadrantPattern[side],&chamberNumber,&quadrantNumber);
473 0 : ++chamberNumber;
474 0 : ++quadrantNumber;
475 0 : channelName = TString::Format(fgkDCSQuadrantPattern[side],chamberNumber,quadrantNumber);
476 0 : }
477 0 : else if ( salias.Contains("Chamber") )
478 : {
479 0 : sscanf(salias.Data(),fgkDCSChamberPattern[side],&chamberNumber);
480 0 : ++chamberNumber;
481 0 : channelName = TString::Format(fgkDCSChamberPattern[side],chamberNumber);
482 0 : }
483 :
484 0 : if ( TString(dcsAlias).Contains("iMon") )
485 : {
486 0 : channelName.ReplaceAll("vMon","iMon");
487 : }
488 :
489 0 : return channelName;
490 0 : }
491 :
492 : //_____________________________________________________________________________
493 : TString
494 : AliMpDCSNamer::DCSAliasFromName(const char* dcsName) const
495 : {
496 : /// Convert a (possibly partial) dcsname to an alias (only for MCH HV)
497 :
498 0 : TString sname(dcsName);
499 :
500 0 : if ( !sname.Contains("MchHvLv") ) return dcsName;
501 0 : if ( sname.Contains("Group")) return dcsName; // not MCH HV (but LV)
502 :
503 0 : Int_t quadrantNumber(-1);
504 0 : Int_t chamberNumber(-1);
505 : Int_t side(-1);
506 :
507 0 : if ( sname.Contains("Left")) side = 0;
508 0 : if ( sname.Contains("Right")) side = 1;
509 :
510 0 : if ( side < 0 ) return "";
511 :
512 0 : TString channelName;
513 :
514 0 : if ( sname.Contains("Slat") )
515 : {
516 0 : Int_t slatNumber(-1);
517 0 : sscanf(sname.Data(),fgkDCSChannelSt345Pattern[side],&chamberNumber,&slatNumber);
518 0 : --chamberNumber;
519 0 : --slatNumber;
520 0 : channelName = TString::Format(fgkDCSChannelSt345Pattern[side],chamberNumber,slatNumber);
521 0 : }
522 0 : else if ( sname.Contains("Sect") )
523 : {
524 0 : Int_t sectorNumber(-1);
525 0 : sscanf(sname.Data(),fgkDCSChannelSt12Pattern[side],&chamberNumber,&quadrantNumber,§orNumber);
526 0 : --chamberNumber;
527 0 : --quadrantNumber;
528 0 : --sectorNumber;
529 0 : channelName = TString::Format(fgkDCSChannelSt12Pattern[side],chamberNumber,quadrantNumber,sectorNumber);
530 0 : }
531 0 : else if ( sname.Contains("Quad") )
532 : {
533 0 : sscanf(sname.Data(),fgkDCSQuadrantPattern[side],&chamberNumber,&quadrantNumber);
534 0 : --chamberNumber;
535 0 : --quadrantNumber;
536 0 : channelName = TString::Format(fgkDCSQuadrantPattern[side],chamberNumber,quadrantNumber);
537 0 : }
538 0 : else if ( sname.Contains("Chamber") )
539 : {
540 0 : sscanf(sname.Data(),fgkDCSChamberPattern[side],&chamberNumber);
541 0 : --chamberNumber;
542 0 : channelName = TString::Format(fgkDCSChamberPattern[side],chamberNumber);
543 0 : }
544 :
545 0 : if ( TString(dcsName).Contains("iMon") )
546 : {
547 0 : channelName.ReplaceAll("vMon","iMon");
548 : }
549 :
550 0 : return channelName;
551 0 : }
552 :
553 : //_____________________________________________________________________________
554 : Bool_t AliMpDCSNamer::DecodeDCSMCHLVAlias(const char* dcsAlias, Int_t*& detElemId, Int_t& numberOfDetectionElements, AliMp::PlaneType& planeType ) const
555 : {
556 : /// Decode a MCH LV dcs alias in order to get :
557 : /// - the list of detection elements powered by this LV (between 1 for St 1-2 and max 4 DEs for St345 per LV group)
558 : /// - the plane type powered by this LV (only for St 1 and 2)
559 :
560 0 : TString salias(dcsAlias);
561 :
562 0 : detElemId = 0x0;
563 0 : planeType = AliMp::kBendingPlane;
564 :
565 0 : if (!salias.Contains("Group"))
566 : {
567 : // not a MCH LV alias
568 0 : return kFALSE;
569 : }
570 :
571 : Int_t side(-1);
572 :
573 0 : if ( salias.Contains("Left"))
574 : {
575 : side = 0;
576 0 : }
577 0 : else if ( salias.Contains("Right"))
578 : {
579 : side = 1;
580 : }
581 : else {
582 0 : AliError(Form("unexpected alias=%s",salias.Data()));
583 0 : return kFALSE;
584 : }
585 :
586 0 : Bool_t left = ( side == 0 );
587 :
588 0 : Int_t chamberNumber, groupNumber;
589 0 : TString voltageType;
590 :
591 0 : sscanf(salias.Data(),fgkDCSMCHLVGroupPattern[side],&chamberNumber,&groupNumber,&voltageType[0]);
592 :
593 0 : if ( chamberNumber >= 1 && chamberNumber <= 4 )
594 : {
595 : Int_t deOffset = 0;
596 0 : if ( groupNumber == 1 )
597 : {
598 0 : if ( left )
599 : {
600 : deOffset = 1;
601 0 : planeType = AliMp::kBendingPlane;
602 0 : }
603 : else
604 : {
605 : deOffset = 0;
606 0 : planeType = AliMp::kNonBendingPlane;
607 : }
608 : }
609 0 : else if ( groupNumber == 2 )
610 : {
611 0 : if ( left )
612 : {
613 : deOffset = 2;
614 0 : planeType = AliMp::kNonBendingPlane;
615 0 : }
616 : else
617 : {
618 : deOffset = 3;
619 0 : planeType = AliMp::kBendingPlane;
620 : }
621 : }
622 0 : else if ( groupNumber == 3 )
623 : {
624 0 : if ( left )
625 : {
626 : deOffset = 1;
627 0 : planeType = AliMp::kNonBendingPlane;
628 0 : }
629 : else
630 : {
631 : deOffset = 0;
632 0 : planeType = AliMp::kBendingPlane;
633 : }
634 : }
635 0 : else if ( groupNumber == 4 )
636 : {
637 0 : if ( left )
638 : {
639 : deOffset = 2;
640 0 : planeType = AliMp::kBendingPlane;
641 0 : }
642 : else
643 : {
644 : deOffset = 3;
645 0 : planeType = AliMp::kNonBendingPlane;
646 : }
647 : }
648 : else
649 : {
650 0 : AliError(Form("Got incorrect group number=%d from alias=%s",groupNumber,salias.Data()));
651 0 : return kFALSE;
652 : }
653 :
654 0 : numberOfDetectionElements=1;
655 0 : detElemId = new Int_t[numberOfDetectionElements];
656 0 : detElemId[0] = chamberNumber*100 + deOffset;
657 0 : }
658 0 : else if ( chamberNumber >= 5 && chamberNumber <= 10 )
659 : {
660 : Int_t* dcsSlatNumber(0x0);
661 :
662 0 : if ( chamberNumber >= 5 && chamberNumber <= 6 )
663 : {
664 0 : if ( groupNumber == 1 )
665 : {
666 0 : numberOfDetectionElements=3;
667 0 : dcsSlatNumber=new Int_t[numberOfDetectionElements];
668 0 : dcsSlatNumber[0]=1;
669 0 : dcsSlatNumber[1]=2;
670 0 : dcsSlatNumber[2]=3;
671 0 : }
672 0 : else if ( groupNumber == 5 )
673 : {
674 0 : numberOfDetectionElements=3;
675 0 : dcsSlatNumber=new Int_t[numberOfDetectionElements];
676 0 : dcsSlatNumber[0]=7;
677 0 : dcsSlatNumber[1]=8;
678 0 : dcsSlatNumber[2]=9;
679 0 : }
680 0 : else if ( groupNumber > 1 && groupNumber < 5 )
681 : {
682 0 : numberOfDetectionElements=1;
683 0 : dcsSlatNumber=new Int_t[numberOfDetectionElements];
684 0 : dcsSlatNumber[0]=groupNumber+2;
685 : }
686 : else
687 : {
688 0 : AliError(Form("Got incorrect group number=%d from alias=%s",groupNumber,salias.Data()));
689 0 : return kFALSE;
690 : }
691 : }
692 0 : else if ( chamberNumber >= 7 )
693 : {
694 0 : if ( groupNumber == 1 )
695 : {
696 0 : numberOfDetectionElements=4;
697 0 : dcsSlatNumber=new Int_t[numberOfDetectionElements];
698 0 : dcsSlatNumber[0]=1;
699 0 : dcsSlatNumber[1]=2;
700 0 : dcsSlatNumber[2]=3;
701 0 : dcsSlatNumber[3]=4;
702 0 : }
703 0 : else if ( groupNumber == 7 )
704 : {
705 0 : numberOfDetectionElements=4;
706 0 : dcsSlatNumber=new Int_t[numberOfDetectionElements];
707 0 : dcsSlatNumber[0]=10;
708 0 : dcsSlatNumber[1]=11;
709 0 : dcsSlatNumber[2]=12;
710 0 : dcsSlatNumber[3]=13;
711 0 : }
712 0 : else if ( groupNumber > 1 && groupNumber < 7 )
713 : {
714 0 : numberOfDetectionElements=1;
715 0 : dcsSlatNumber=new Int_t[numberOfDetectionElements];
716 0 : dcsSlatNumber[0]=groupNumber+3;
717 : }
718 : else
719 : {
720 0 : AliError(Form("Got incorrect group number=%d from alias=%s",groupNumber,salias.Data()));
721 0 : return kFALSE;
722 : }
723 : }
724 :
725 0 : detElemId = new Int_t[numberOfDetectionElements];
726 0 : for ( int i = 0; i < numberOfDetectionElements; ++i )
727 : {
728 0 : detElemId[i] = DCS2DE(chamberNumber-1,side,dcsSlatNumber[i]-1);
729 : }
730 0 : }
731 : else
732 : {
733 0 : AliError(Form("Got an invalid chamberNumber=%d from alias=%s",chamberNumber,salias.Data()));
734 0 : return kFALSE;
735 : }
736 :
737 0 : return kTRUE;
738 0 : }
739 :
740 : //_____________________________________________________________________________
741 : TString
742 : AliMpDCSNamer::DCSMCHLVAliasName(Int_t detElemId, Int_t voltageType, AliMp::PlaneType planeType) const
743 : {
744 0 : TString voltage;
745 :
746 0 : if ( voltageType == -1 ) {
747 0 : voltage = "ann";
748 0 : } else if ( voltageType == 0 ) {
749 0 : voltage = "dig";
750 0 : } else if ( voltageType == 1 ) {
751 0 : voltage = "anp";
752 : }
753 :
754 0 : if ( !voltage.Length() )
755 : {
756 0 : AliError(Form("Incorrect voltageType=%d. Expected -1,0 or 1.",voltageType));
757 0 : return "";
758 : }
759 :
760 0 : Int_t chamberId = AliMpDEManager::GetChamberId(detElemId);
761 0 : if ( chamberId < 0 )
762 : {
763 0 : AliError(Form("Got an incorrect chamberId=%d from detElemId=%d",chamberId,detElemId));
764 0 : return "";
765 : }
766 0 : Int_t stationId = 1 + chamberId / 2;
767 :
768 0 : Int_t side(-1);
769 0 : Int_t cham;
770 0 : Int_t dcsNumber = DetElemId2DCS(detElemId, side, cham);
771 :
772 : Int_t group(0);
773 :
774 0 : switch (AliMpDEManager::GetStationType(detElemId))
775 : {
776 : case AliMp::kStation12:
777 : {
778 : // For Chamber 1 to 4 Left the relationship between DCS GUI names and groups is:
779 : // Quad2B --> Group3 = DE x01 Non Bending
780 : // Quad2F --> Group1 = DE x01 Bending
781 : // Quad3B --> Group4 = DE x02 Bending
782 : // Quad3F --> Group2 = DE x02 Non Bending
783 : // for Chamber 1 to 4 Right the relationship is:
784 : // Quad1B --> Group3 = DE x00 Bending
785 : // Quad1F --> Group1 = DE x00 Non Bending
786 : // Quad4B --> Group4 = DE x03 Non Bending
787 : // Quad4F --> Group2 = DE x03 Bending
788 : // where x = 1,2,3,4
789 : // and Quad#B = Back = towards IP = cath1
790 : // while Quad#F = Front = towards muon trigger = cath0
791 : //
792 :
793 0 : Int_t remnant = detElemId % 100;
794 0 : switch (remnant) {
795 : case 0: // DE x00
796 0 : group = ( planeType == AliMp::kBendingPlane ) ? 3 : 1;
797 0 : break;
798 : case 1: // DE x01
799 0 : group = ( planeType == AliMp::kBendingPlane ) ? 1 : 3;
800 0 : break;
801 : case 2: // DE x02
802 0 : group = ( planeType == AliMp::kBendingPlane ) ? 4 : 2;
803 0 : break;
804 : case 3: // DE x03
805 0 : group = ( planeType == AliMp::kBendingPlane ) ? 2 : 4;
806 0 : break;
807 : default:
808 0 : AliFatal("");
809 : break;
810 : }
811 : }
812 0 : break;
813 : case AliMp::kStation345:
814 : {
815 0 : Int_t dcsSlatNumber = 1 + dcsNumber;
816 0 : if ( stationId == 3 ) {
817 0 : switch (dcsSlatNumber) {
818 : case 1:
819 : case 2:
820 : case 3:
821 : group = 1;
822 0 : break;
823 : case 4:
824 : case 5:
825 : case 6:
826 0 : group = dcsSlatNumber - 2;
827 0 : break;
828 : case 7:
829 : case 8:
830 : case 9:
831 : group = 5;
832 0 : break;
833 : default:
834 : break;
835 : }
836 : }
837 : else
838 : {
839 0 : switch (dcsSlatNumber) {
840 : case 1:
841 : case 2:
842 : case 3:
843 : case 4:
844 : group = 1;
845 0 : break;
846 : case 5:
847 : case 6:
848 : case 7:
849 : case 8:
850 : case 9:
851 0 : group = dcsSlatNumber - 3;
852 0 : break;
853 : case 10:
854 : case 11:
855 : case 12:
856 : case 13:
857 : group = 7;
858 0 : break;
859 : default:
860 : break;
861 : }
862 : }
863 : }
864 0 : break;
865 : default:
866 : break;
867 : }
868 :
869 0 : if ( group == 0 ) {
870 0 : AliError(Form("Could not get LV group id for detection element %d",detElemId));
871 0 : return "";
872 : }
873 :
874 0 : TString aliasName;
875 :
876 0 : aliasName.Form(fgkDCSMCHLVGroupPattern[side],chamberId+1,group,voltage.Data());
877 :
878 0 : return aliasName;
879 0 : }
880 :
881 : //_____________________________________________________________________________
882 : TString
883 : AliMpDCSNamer::DCSAliasName(Int_t detElemId, Int_t sector, Int_t dcsMeasure) const
884 : {
885 : /// Return the alias name of the DCS Channel for a given DCS area
886 : /// \param detElemId
887 : /// \param sector = 0,1 or 2 for St12, and is unused for st345 and trigger
888 : /// \param dcsMeasure = kDCSHV, kDCSI
889 :
890 2592 : Int_t chamberId = AliMpDEManager::GetChamberId(detElemId);
891 1296 : if ( chamberId < 0 ) return "";
892 :
893 1296 : Int_t side(-1), chId(-1);
894 1296 : Int_t dcsNumber = DetElemId2DCS(detElemId,side,chId);
895 :
896 1296 : TString aliasName;
897 :
898 2592 : switch (AliMpDEManager::GetStationType(detElemId))
899 : {
900 : case AliMp::kStation12:
901 96 : aliasName.Form(fgkDCSChannelSt12Pattern[side],chamberId,dcsNumber,sector);
902 : break;
903 : case AliMp::kStation345:
904 1200 : aliasName.Form(fgkDCSChannelSt345Pattern[side],chamberId,dcsNumber);
905 : break;
906 : case AliMp::kStationTrigger:
907 0 : return TString::Format(fgkDCSChannelTriggerPattern[side],fgkDCSSideTriggerName[side],chId,dcsNumber,fgkDCSMeasureName[dcsMeasure]);
908 : break;
909 : default:
910 0 : return "";
911 : break;
912 : }
913 :
914 1296 : if ( dcsMeasure == AliMpDCSNamer::kDCSI )
915 : {
916 0 : aliasName.ReplaceAll("vMon","iMon");
917 : }
918 :
919 2592 : return aliasName;
920 :
921 2592 : }
922 :
923 : //_____________________________________________________________________________
924 : TString
925 : AliMpDCSNamer::DCSSwitchAliasName(Int_t detElemId, Int_t pcbNumber) const
926 : {
927 : /// Return the alias name of the DCS Switch for a given PCB
928 : /// within a slat of St345
929 :
930 2400 : if (AliMpDEManager::GetStationType(detElemId) == AliMp::kStation345)
931 : {
932 1200 : return TString::Format(fgkDCSSwitchSt345Pattern,detElemId,pcbNumber);
933 : }
934 0 : return "";
935 1200 : }
936 :
937 : //_____________________________________________________________________________
938 : Int_t
939 : AliMpDCSNamer::DCSIndexFromDCSAlias(const char* dcsAlias) const
940 : {
941 : /// Converts the dcs alias to a hv index
942 : ///
943 : /// dcsAlias has one of the following 3 forms :
944 : ///
945 : /// MchHvLv[Left|Right]/Chamber##[Left|Right]/Chamber##[Left|Right]Slat##.actual.vMon
946 : ///
947 : /// MchHvLv[Left|Right]/Chamber##[Left|Right]/Chamber##[Left|Right]Quad#Sect#.actual.vMon
948 : ///
949 : /// MchDE####dsw#.inValue
950 :
951 0 : TString sDcsAlias(dcsAlias);
952 0 : Int_t de(-1);
953 0 : Int_t sw(-1);
954 :
955 : int side(-1);
956 :
957 0 : if ( sDcsAlias.Contains("Left") )
958 : {
959 : side = 0;
960 0 : }
961 0 : else if ( sDcsAlias.Contains("Right") )
962 : {
963 : side = 1;
964 : }
965 : else
966 : {
967 : /// it's a switch
968 0 : sscanf(sDcsAlias.Data(),fgkDCSSwitchSt345Pattern,&de,&sw);
969 0 : return sw;
970 : }
971 :
972 0 : int n1(-1);
973 0 : int n3(-1);
974 0 : int n4(-1);
975 :
976 0 : if ( sDcsAlias.Contains("Quad") )
977 : {
978 0 : sscanf(sDcsAlias.Data(),fgkDCSChannelSt12Pattern[side],&n1,&n3,&n4);
979 0 : return n4;
980 : }
981 :
982 0 : return -2;
983 0 : }
984 :
985 : //_____________________________________________________________________________
986 : Int_t
987 : AliMpDCSNamer::DetElemIdFromDCSAlias(const char* dcsAlias) const
988 : {
989 : /// Converts the dcs alias to a detection element identifier
990 : ///
991 : /// dcsAlias has one of the following forms :
992 : ///
993 : /// MchHvLv[Left|Right]/Chamber##[Left|Right]/Chamber##[Left|Right]Slat##.actual.vMon
994 : ///
995 : /// MchHvLv[Left|Right]/Chamber##[Left|Right]/Chamber##[Left|Right]Quad#Sect#.actual.vMon
996 : ///
997 : /// MTR_Side[OUTSIDE|INSIDE]_MTChamber##_RPC#_HV.Type[actual.iMon|vEff]
998 :
999 0 : AliDebug(1,Form("dcsAlias=%s",dcsAlias));
1000 :
1001 0 : TString sDcsAlias(dcsAlias);
1002 :
1003 : int side(-1);
1004 :
1005 0 : const char** sideName = (fDetector == kTriggerDet) ? fgkDCSSideTriggerName : fgkDCSSideTrackerName;
1006 :
1007 0 : for(Int_t iside=0; iside<2; iside++){
1008 0 : if ( sDcsAlias.Contains(sideName[iside]) ) {
1009 : side = iside;
1010 0 : break;
1011 : }
1012 : }
1013 0 : if(side<0) return -2;
1014 :
1015 0 : int n1(-1);
1016 0 : int n3(-1);
1017 0 : int n4(-1);
1018 0 : char type[15];
1019 0 : char cside[4];
1020 : int detElemId(-1);
1021 :
1022 0 : if ( sDcsAlias.Contains("Slat") )
1023 : {
1024 0 : sscanf(sDcsAlias.Data(),fgkDCSChannelSt345Pattern[side],&n1,&n3);
1025 0 : detElemId = DCS2DE(n1,side,n3);
1026 0 : AliDebug(1,Form("Slat side=%d n1=%d n3=%d de=%d",side,n1,n3,detElemId));
1027 : }
1028 0 : else if ( sDcsAlias.Contains("Quad") )
1029 : {
1030 0 : sscanf(sDcsAlias.Data(),fgkDCSChannelSt12Pattern[side],&n1,&n3,&n4);
1031 0 : detElemId = 100*(n1+1) + n3;
1032 0 : AliDebug(1,Form("Quad side=%d n1=%d n3=%d n4=%d de=%d",side,n1,n3,n4,detElemId));
1033 : }
1034 0 : else if ( sDcsAlias.Contains("MT") )
1035 : {
1036 0 : sscanf(sDcsAlias.Data(),fgkDCSChannelTriggerPatternRead[side],cside,&n1,&n3,type);
1037 0 : detElemId = DCS2DE(n1,side,n3);
1038 0 : AliDebug(1,Form("Slat side=%d n1=%d n3=%d de=%d",side,n1,n3,detElemId));
1039 : }
1040 : else
1041 : {
1042 0 : return -3;
1043 : }
1044 :
1045 0 : if ( !AliMpDEManager::IsValidDetElemId(detElemId) )
1046 : {
1047 0 : AliError(Form("Invalid aliasName %s",dcsAlias));
1048 0 : return -1;
1049 : }
1050 :
1051 0 : return detElemId;
1052 0 : }
1053 :
1054 : //_____________________________________________________________________________
1055 : Int_t AliMpDCSNamer::DCSvariableFromDCSAlias(const char* dcsAlias) const
1056 : {
1057 : /// Get DCS variable from an alias (trigger)
1058 :
1059 0 : TString sDcsAlias(dcsAlias);
1060 :
1061 : Int_t dcsMeasurement = -1;
1062 :
1063 0 : for(Int_t iMeas=0; iMeas<kNDCSMeas; iMeas++){
1064 0 : if ( sDcsAlias.Contains(fgkDCSMeasureName[iMeas]) ) {
1065 : dcsMeasurement = iMeas;
1066 0 : break;
1067 : }
1068 : }
1069 :
1070 : return dcsMeasurement;
1071 0 : }
1072 :
1073 :
1074 : //_____________________________________________________________________________
1075 : TObjArray*
1076 : AliMpDCSNamer::GenerateAliases(const char* pattern) const
1077 : {
1078 : /// Generate DCS alias names, for MUON Tracker High and Low Voltage systems
1079 : /// or for MUON Trigger HV and current system.
1080 : ///
1081 : /// For MCH we first generate 188 aliases of HV DCS channels :
1082 : ///
1083 : /// St 1 ch 1 : 12 channels
1084 : /// ch 2 : 12 channels
1085 : /// St 2 ch 3 : 12 channels
1086 : /// ch 4 : 12 channels
1087 : /// St 3 ch 5 : 18 channels
1088 : /// ch 6 : 18 channels
1089 : /// St 4 ch 7 : 26 channels
1090 : /// ch 8 : 26 channels
1091 : /// St 5 ch 9 : 26 channels
1092 : /// ch 10 : 26 channels
1093 : ///
1094 : /// then 600 aliases of DCS switches (only for St345) : 1 switch per PCB.
1095 : ///
1096 : /// and finally 324 LV groups (108 per voltage x 3 voltages)
1097 : ///
1098 : /// St 1 ch 1 left or right : 4 groups
1099 : /// ch 2 left or right : 4 groups
1100 : /// St 2 ch 3 left or right : 4 groups
1101 : /// ch 4 left or right : 4 groups
1102 : /// St 3 ch 5 left or right : 5 groups
1103 : /// ch 6 left or right : 5 groups
1104 : /// St 4 ch 7 left or right : 7 groups
1105 : /// ch 8 left or right : 7 groups
1106 : /// St 5 ch 9 left or right : 7 groups
1107 : /// ch 10 left or right : 7 groups
1108 : ///
1109 : /// Returns a TObjArray of TObjString(=alias name)
1110 :
1111 0 : TObjArray* aliases = new TObjArray;
1112 0 : aliases->SetOwner(kTRUE);
1113 :
1114 0 : Int_t nMeasures = (fDetector == kTriggerDet) ? kNDCSMeas : 1;
1115 :
1116 0 : for(Int_t iMeas=0; iMeas<nMeasures; iMeas++){
1117 :
1118 0 : AliMpDEIterator it;
1119 :
1120 0 : it.First();
1121 :
1122 0 : Int_t voltageType[] = { -1,0,1 };
1123 :
1124 0 : while (!it.IsDone())
1125 : {
1126 0 : Int_t detElemId = it.CurrentDEId();
1127 :
1128 0 : switch (fDetector){
1129 : case kTrackerDet:
1130 : {
1131 0 : switch ( AliMpDEManager::GetStationType(detElemId) )
1132 : {
1133 : case AliMp::kStation12:
1134 : {
1135 0 : for ( int sector = 0; sector < 3; ++sector)
1136 : {
1137 : // HV voltage
1138 0 : aliases->Add(new TObjString(DCSAliasName(detElemId,sector)));
1139 : // HV current
1140 0 : aliases->Add(new TObjString(DCSAliasName(detElemId,sector,AliMpDCSNamer::kDCSI)));
1141 : }
1142 :
1143 0 : AliMp::PlaneType planeType[] = { AliMp::kBendingPlane, AliMp::kNonBendingPlane };
1144 :
1145 : // LV groups, one per voltage (analog negative, digital, analog positive)
1146 : // per plane (bending / non-bending)
1147 0 : for ( int pt = 0; pt < 2; ++pt )
1148 : {
1149 0 : for ( int i = 0; i < 3; ++i )
1150 : {
1151 0 : TString name = DCSMCHLVAliasName(detElemId,voltageType[i],planeType[pt]);
1152 0 : aliases->Add(new TObjString(name));
1153 0 : }
1154 : }
1155 0 : }
1156 0 : break;
1157 : case AliMp::kStation345:
1158 : {
1159 : // HV voltage
1160 0 : aliases->Add(new TObjString(DCSAliasName(detElemId)));
1161 : // HV current
1162 0 : aliases->Add(new TObjString(DCSAliasName(detElemId,0,AliMpDCSNamer::kDCSI)));
1163 : // HV switches
1164 0 : for ( Int_t i = 0; i < NumberOfPCBs(detElemId); ++i )
1165 : {
1166 0 : aliases->Add(new TObjString(DCSSwitchAliasName(detElemId,i)));
1167 : }
1168 : // LV groups, one per voltage (analog negative, digital, analog positive)
1169 0 : for ( int i = 0; i < 3; ++i )
1170 : {
1171 0 : TString name = DCSMCHLVAliasName(detElemId,voltageType[i]);
1172 : // for Station345 some detection elements share the same voltage group,
1173 : // so we must insure we're not adding the same one several times
1174 0 : if (!aliases->FindObject(name))
1175 : {
1176 0 : aliases->Add(new TObjString(name));
1177 : }
1178 0 : }
1179 : }
1180 0 : break;
1181 : default:
1182 : break;
1183 : }
1184 : }
1185 : break;
1186 : case kTriggerDet:
1187 : {
1188 0 : switch ( AliMpDEManager::GetStationType(detElemId) )
1189 : {
1190 : case AliMp::kStationTrigger:
1191 0 : AliDebug(10,Form("Current DetElemId %i",detElemId));
1192 0 : aliases->Add(new TObjString(DCSAliasName(detElemId,0,iMeas)));
1193 0 : break;
1194 : default:
1195 : break;
1196 : }
1197 : }
1198 : break;
1199 : }
1200 0 : it.Next();
1201 : } // loop on detElemId
1202 0 : } // Loop on measurement type
1203 :
1204 0 : if (pattern && strlen(pattern)>0)
1205 : {
1206 : // remove aliases not containing the input pattern
1207 0 : TObjArray* tmp = new TObjArray;
1208 0 : tmp->SetOwner(kTRUE);
1209 0 : for ( Int_t i = 0; i <= aliases->GetLast(); ++i )
1210 : {
1211 0 : TString name = static_cast<TObjString*>(aliases->At(i))->String();
1212 0 : if (name.Contains(pattern))
1213 : {
1214 0 : tmp->Add(new TObjString(name.Data()));
1215 : }
1216 0 : }
1217 0 : delete aliases;
1218 : aliases = tmp;
1219 0 : }
1220 0 : return aliases;
1221 0 : }
1222 :
1223 : //_____________________________________________________________________________
1224 : Int_t
1225 : AliMpDCSNamer::ManuId2Index(Int_t detElemId, Int_t manuId) const
1226 : {
1227 : /// Convert (de,manu) to hv index, depending on the station
1228 :
1229 100968 : AliMp::StationType stationType = AliMpDEManager::GetStationType(detElemId);
1230 50484 : if ( stationType == AliMp::kStation345 )
1231 : {
1232 29028 : return ManuId2PCBIndex(detElemId,manuId);
1233 : }
1234 21456 : else if ( stationType == AliMp::kStation12 )
1235 : {
1236 21456 : return ManuId2Sector(detElemId,manuId);
1237 : }
1238 0 : return -1;
1239 50484 : }
1240 :
1241 : //_____________________________________________________________________________
1242 : Int_t
1243 : AliMpDCSNamer::ManuId2PCBIndex(Int_t detElemId, Int_t manuId) const
1244 : {
1245 : /// Returns the index of PCB (within a St345 slat) for a given manu number.
1246 : /// Returns -1 if (detElemId,manuId) is incorrect
1247 :
1248 99160 : AliCodeTimerAuto("",0)
1249 :
1250 : const AliMpSlat* slat
1251 99160 : = AliMpSegmentation::Instance()->GetSlatByElectronics(detElemId, manuId);
1252 49580 : if ( ! slat ) return -1;
1253 :
1254 99160 : return slat->FindPCBIndexByMotifPositionID(manuId);
1255 49580 : }
1256 :
1257 : //_____________________________________________________________________________
1258 : Int_t
1259 : AliMpDCSNamer::ManuId2Sector(Int_t detElemId, Int_t manuId) const
1260 : {
1261 : /// Return the DCS-sector number (within a St12 quadrant) for a given manu number.
1262 :
1263 43104 : AliCodeTimerAuto("",0)
1264 :
1265 : const AliMpSector* sector
1266 43104 : = AliMpSegmentation::Instance()->GetSectorByElectronics(detElemId, manuId);
1267 21552 : if ( ! sector ) return -1;
1268 :
1269 21552 : const AliMpMotifMap* motifMap = sector->GetMotifMap();
1270 21552 : const AliMpMotifPosition* motifPos = motifMap->FindMotifPosition(manuId);
1271 :
1272 : Double_t lowerLeftX
1273 43104 : = motifPos->GetPositionX()-motifPos->GetDimensionX();
1274 :
1275 21552 : Double_t x = lowerLeftX*10.0; // cm -> mm
1276 : Int_t isector(-1);
1277 :
1278 21552 : AliMq::Station12Type stationType = AliMpDEManager::GetStation12Type(detElemId);
1279 :
1280 21552 : if ( stationType == AliMq::kStation1 )
1281 : {
1282 10872 : if ( x < -10 ) AliFatal("");
1283 :
1284 15808 : if ( x < 291.65 ) isector = 0;
1285 10368 : else if ( x < 585.65 ) isector = 1;
1286 3008 : else if ( x < 879.65 ) isector = 2;
1287 : }
1288 : else
1289 : {
1290 10680 : if ( x < -140 ) AliFatal("");
1291 :
1292 14656 : if ( x < 283.75 ) isector = 0;
1293 10896 : else if ( x < 606.25 ) isector = 1;
1294 5024 : else if ( x < 1158.75 ) isector = 2;
1295 : }
1296 :
1297 : return isector;
1298 21552 : }
1299 :
1300 : //_____________________________________________________________________________
1301 : Int_t
1302 : AliMpDCSNamer::NumberOfPCBs(Int_t detElemId) const
1303 : {
1304 : /// Returns the number of PCB in a given detection element
1305 : /// Only works for St345
1306 :
1307 2400 : AliMp::StationType stationType = AliMpDEManager::GetStationType(detElemId);
1308 1200 : if ( stationType != AliMp::kStation345 )
1309 : {
1310 0 : return 0;
1311 : }
1312 : else
1313 : {
1314 : const AliMpSlat* slat
1315 1200 : = AliMpSegmentation::Instance()->GetSlat(detElemId, AliMp::kCath0);
1316 1200 : return slat->GetSize();
1317 : }
1318 1200 : }
1319 :
1320 : //_____________________________________________________________________________
1321 : Bool_t AliMpDCSNamer::CheckConsistency(Int_t detElemId) const
1322 : {
1323 : //
1324 : /// Check that the required detElemId either belongs to tracker or trigger
1325 : /// consistently with the initial definition of the namer
1326 : //
1327 :
1328 : Bool_t isConsistent(kFALSE);
1329 2592 : TString requestInfo;
1330 2592 : switch(AliMpDEManager::GetStationType(detElemId))
1331 : {
1332 : case AliMp::kStation12:
1333 : case AliMp::kStation345:
1334 2592 : if (fDetector == kTrackerDet) isConsistent = kTRUE;
1335 1296 : requestInfo = "TRACKER";
1336 : break;
1337 : case AliMp::kStationTrigger:
1338 0 : if (fDetector == kTriggerDet) isConsistent = kTRUE;
1339 0 : requestInfo = "TRIGGER";
1340 : break;
1341 : default:
1342 : break;
1343 : }
1344 :
1345 1296 : if(!isConsistent) AliWarning(Form("Requesting information for %s station but class initialized for %s",requestInfo.Data(), fgkDetectorName[fDetector]));
1346 :
1347 : return isConsistent;
1348 1296 : }
1349 :
1350 : //_____________________________________________________________________________
1351 : Bool_t AliMpDCSNamer::TestMCHLV() const
1352 : {
1353 : /// Circular test of DCSMCHLVAliasName and DecodeDCSMCHLVAlias methods
1354 :
1355 0 : TObjArray* aliases = GenerateAliases("Group");
1356 :
1357 0 : const char* voltageTypeName[] = { "ann","dig","anp"};
1358 0 : Int_t voltageType[] = { -1,0,1 };
1359 : Int_t n(0);
1360 :
1361 0 : for ( Int_t iv = 0; iv < 3; ++iv )
1362 : {
1363 0 : for ( Int_t i = 0; i < aliases->GetEntries(); ++i )
1364 : {
1365 0 : TString dcsAlias = static_cast<TObjString*>(aliases->At(i))->String();
1366 0 : if ( !dcsAlias.Contains(voltageTypeName[iv])) continue;
1367 :
1368 0 : Int_t* detElemId(0x0);
1369 0 : Int_t numberOfDetectionElements(0);
1370 0 : AliMp::PlaneType planeType;
1371 :
1372 0 : Bool_t ok = DecodeDCSMCHLVAlias(dcsAlias.Data(), detElemId, numberOfDetectionElements, planeType);
1373 :
1374 0 : if (!ok)
1375 : {
1376 0 : AliError(Form("Could not decode alias=%s",dcsAlias.Data()));
1377 0 : delete[] detElemId;
1378 0 : return kFALSE;
1379 : }
1380 :
1381 0 : for ( Int_t id = 0; id < numberOfDetectionElements; ++id )
1382 : {
1383 0 : TString check =
1384 0 : DCSMCHLVAliasName(detElemId[id], voltageType[iv], planeType);
1385 :
1386 0 : if (check!=dcsAlias)
1387 : {
1388 0 : AliError(Form("%s != %s",check.Data(),dcsAlias.Data()));
1389 0 : return kFALSE;
1390 : }
1391 : else
1392 : {
1393 0 : ++n;
1394 : }
1395 0 : }
1396 :
1397 0 : delete[] detElemId;
1398 0 : }
1399 : }
1400 :
1401 0 : delete aliases;
1402 :
1403 0 : AliInfo(Form("%d aliases successfully tested",n));
1404 :
1405 0 : return kTRUE;
1406 0 : }
|
