AliRoot Core  3dc7879 (3dc7879)
AliMpTriggerReader.cxx
Go to the documentation of this file.
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 purpeateose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15 
16 // $Id$
17 // $MpId: AliMpTriggerReader.cxx,v 1.4 2006/05/24 13:58:52 ivana Exp $
18 
19 #include "AliMpTriggerReader.h"
20 
21 #include "AliLog.h"
22 #include "AliMpConstants.h"
23 #include "AliMpDataStreams.h"
24 #include "AliMpFiles.h"
25 #include "AliMpHelper.h"
26 #include "AliMpMotif.h"
27 #include "AliMpMotifPosition.h"
28 #include "AliMpMotifReader.h"
29 #include "AliMpMotifSpecial.h"
30 #include "AliMpMotifType.h"
31 #include "AliMpPCB.h"
32 #include "AliMpSlat.h"
33 #include "AliMpSlatMotifMap.h"
34 #include "AliMpSlatMotifMap.h"
35 #include "AliMpSt345Reader.h"
36 #include "AliMpTrigger.h"
37 #include "Riostream.h"
38 #include "TClass.h"
39 #include "TList.h"
40 #include "TObjString.h"
41 #include "TString.h"
42 #include <TArrayI.h>
43 #include <cstdlib>
44 #include <sstream>
45 
46 //-----------------------------------------------------------------------------
54 //-----------------------------------------------------------------------------
55 
57 ClassImp(AliMpTriggerReader)
59 
60 //
61 // static private methods
62 //
63 
64 //_____________________________________________________________________________
65 const TString& AliMpTriggerReader::GetKeywordLayer()
66 {
68  static const TString kKeywordLayer("LAYER");
69  return kKeywordLayer;
70 }
71 
72 //_____________________________________________________________________________
74 {
76  static const TString kKeywordScale("SCALE");
77  return kKeywordScale;
78 }
79 
80 //_____________________________________________________________________________
82 {
84  static const TString kKeywordPcb("PCB");
85  return kKeywordPcb;
86 }
87 
88 //_____________________________________________________________________________
90 {
92  static const TString kKeywordFlipX("FLIP_X");
93  return kKeywordFlipX;
94 }
95 
96 //_____________________________________________________________________________
98 {
100  static const TString kKeywordFlipY("FLIP_Y");
101  return kKeywordFlipY;
102 }
103 
104 //
105 // ctors, dtor
106 //
107 
108 //_____________________________________________________________________________
110 : TObject(),
111  fMotifMap(motifMap),
113 {
117  fLocalBoardMap.SetOwner(kTRUE);
118 }
119 
120 //_____________________________________________________________________________
122 {
126  fLocalBoardMap.DeleteAll();
127 }
128 
129 //_____________________________________________________________________________
130 AliMpSlat*
132  const char* slatName,
133  AliMp::PlaneType planeType,
134  const TList& lines,
135  Double_t scale)
136 {
139 
140  AliDebug(1,Form("slat %s %s scale %e",
141  slatName,PlaneTypeName(planeType).Data(),scale))
142  ;
143 
144  AliMpSlat* slat = new AliMpSlat(slatName, planeType);
145 
146  TIter it(&lines);
147 
148 // StdoutToAliDebug(3,lines.Print(););
149 
150  TObjString* osline;
151  while ( ( osline = (TObjString*)it.Next() ) )
152  {
153  // note that at this stage lines should not be empty.
154  TString sline(osline->String());
155 
156  TObjArray* tokens = sline.Tokenize(' ');
157 
158  TString& keyword = ((TObjString*)tokens->At(0))->String();
159 
160  if ( keyword == GetKeywordPcb() )
161  {
162  if ( tokens->GetEntriesFast() != 3 )
163  {
164  AliErrorClass(Form("Syntax error : expecting PCB type localboard-list"
165  " in following line:\n%s",sline.Data()));
166  delete slat;
167  delete tokens;
168  return 0;
169  }
170  TString pcbName = ((TObjString*)tokens->At(1))->String();
171 
172  TObjArray* localBoardList = ((TObjString*)tokens->At(2))->String().Tokenize(',');
173 
174  if ( scale != 1.0 )
175  {
176  std::ostringstream s;
177  s << pcbName.Data() << "x" << scale;
178  pcbName = s.str().c_str();
179  }
180 
181  AliMpPCB* pcbType = ReadPCB(dataStreams, pcbName.Data());
182  if (!pcbType)
183  {
184  AliErrorClass(Form("Cannot read pcbType=%s",pcbName.Data()));
185  delete slat;
186  delete tokens;
187  return 0;
188  }
189 
190  TArrayI allLocalBoards;
191 
192  for ( Int_t ilb = 0; ilb < localBoardList->GetEntriesFast(); ++ilb)
193  {
194  TArrayI localBoardNumbers;
195  TString& localBoards = ((TObjString*)localBoardList->At(ilb))->String();
196  Ssiz_t pos = localBoards.First('-');
197  if ( pos < 0 )
198  {
199  pos = localBoards.Length();
200  }
201  AliMpHelper::DecodeName(localBoards(pos-1,localBoards.Length()-pos+1).Data(),
202  ';',localBoardNumbers);
203  for ( int i = 0; i < localBoardNumbers.GetSize(); ++i )
204  {
205  std::ostringstream name;
206  name << localBoards(0,pos-1) << localBoardNumbers[i];
207  AliDebugClass(3,name.str().c_str());
208  localBoardNumbers[i] = LocalBoardNumber(dataStreams,name.str().c_str());
209  AliDebugClass(3,Form("LOCALBOARDNUMBER %d\n",localBoardNumbers[i]));
210  allLocalBoards.Set(allLocalBoards.GetSize()+1);
211  allLocalBoards[allLocalBoards.GetSize()-1] = localBoardNumbers[i];
212  if (localBoardNumbers[i] < 0 )
213  {
214  AliErrorClass(Form("Got a negative local board number in %s ? Unlikely"
215  " to be correct... : %s\n",slatName,name.str().c_str()));
216  }
217  }
218  }
219  AliDebug(3,"Deleting tokens");
220  delete tokens;
221  AliDebug(3,"Deleting localBoardList");
222  delete localBoardList;
223  AliDebug(3,"Adding pcb to slat");
224  slat->Add(*pcbType,allLocalBoards);
225  AliDebug(3,Form("Deleting pcbType=%p %s",pcbType,pcbName.Data()));
226  delete pcbType;
227  }
228  }
229 
230  if ( slat->DX()== 0 || slat->DY() == 0 )
231  {
232  AliFatalClass(Form("Slat %s has invalid null size\n",slat->GetID()));
233  }
234  return slat;
235 }
236 
237 //_____________________________________________________________________________
238 TString
240 {
242  TString boardName;
243 
244  TObjArray* tokens = s.Tokenize(' ');
245 
246  TString& keyword = ((TObjString*)tokens->At(0))->String();
247 
248  if ( keyword == GetKeywordPcb() &&
249  tokens->GetEntriesFast() == 3 )
250  {
251  boardName = ((TObjString*)tokens->At(2))->String();
252  }
253 
254  delete tokens;
255 
256  return boardName;
257 }
258 
259 //_____________________________________________________________________________
260 void
262  TList& lines, Bool_t flipX, Bool_t flipY,
263  Int_t srcLine, Int_t destLine)
264 {
270 
271 
272  if ( flipX )
273  {
274  // Simply swaps R(ight) and L(eft) in the first character of
275  // local board names
276 
277  TObjString* oline;
278  TIter it(&lines);
279  while ( ( oline = (TObjString*)it.Next() ) )
280  {
281  TString& s = oline->String();
282  if ( s.Contains("RC") )
283  {
284  // Change right to left
285  s.ReplaceAll("RC","LC");
286  }
287  else if ( s.Contains("LC") )
288  {
289  // Change left to right
290  s.ReplaceAll("LC","RC");
291  }
292  }
293  }
294 
295  if ( flipY )
296  {
297  // Change line number, according to parameters srcLine and destLine
298  // Note that because of road opening (for planes 3 and 4 at least),
299  // we loop for srcLine +-1
300  //
301  for ( Int_t line = -1; line <=1; ++line )
302  {
303  std::ostringstream src,dest;
304  src << "L" << srcLine+line;
305  dest << "L" << destLine-line;
306  if ( src.str() == dest.str() ) continue;
307 
308  for ( Int_t i = 0; i < lines.GetSize(); ++i )
309  {
310  TObjString* oline = (TObjString*)lines.At(i);
311 
312  TString& s = oline->String();
313 
314  if ( !s.Contains(GetKeywordPcb()) )
315  {
316  // Only consider PCB lines.
317  continue;
318  }
319 
320  if ( s.Contains(src.str().c_str()) )
321  {
322  AliDebugClass(4,Form("Replacing %s by %s in %s\n",
323  src.str().c_str(),dest.str().c_str(),s.Data()));
324 
325  s.ReplaceAll(src.str().c_str(),dest.str().c_str());
326 
327  AliDebugClass(4,s.Data());
328 
329  TString boardName(GetBoardNameFromPCBLine(s));
330 
331  if ( line )
332  {
333  // We must also change board numbers, with the tricky
334  // thing that up and down must be swapped...
335  // Up can only be 1 card so it must be B1
336  // Down must be the uppper card of the line before, so
337  // the biggest possible board number for this Line,Column
338 
339  if (line>0)
340  {
341  // force to B1
342  AliDebugClass(4,Form("Forcing B1 in %s\n",s.Data()));
343  s.ReplaceAll(boardName(boardName.Length()-2,2),"B1");
344  AliDebugClass(4,s.Data());
345  }
346  else
347  {
348  // find the largest valid board number
349  for ( int b = 4; b>=1; --b )
350  {
351  std::ostringstream bs;
352  bs << boardName(0,boardName.Length()-1) << b;
353  if ( LocalBoardNumber(dataStreams,bs.str().c_str()) >= 0 )
354  {
355  AliDebugClass(4,Form("Replacing %s by %s in %s\n",
356  boardName(boardName.Length()-2,2).Data(),
357  Form("B%d",b),
358  s.Data()));
359  s.ReplaceAll(boardName(boardName.Length()-2,2),
360  Form("B%d",b));
361  AliDebugClass(4,s);
362  break;
363  }
364  }
365  }
366  // Check that the replacement we did is ok. If not,
367  // skip the line.
368  Int_t lbn = LocalBoardNumber(dataStreams,GetBoardNameFromPCBLine(s));
369  if ( lbn < 0 )
370  {
371  AliDebugClass(4,Form("Removing line %s\n",s.Data()));
372  lines.Remove(oline);
373  }
374 
375  } // if (line)
376  }
377  }
378  }
379  }
380 }
381 
382 //___________________________________________________________________________
383 Int_t
384 AliMpTriggerReader::IsLayerLine(const TString& sline) const
385 {
387 
388  if ( sline.BeginsWith(GetKeywordLayer()) )
389  {
390  return 1;
391  }
392  else
393  {
394  return 0;
395  }
396 }
397 
398 //___________________________________________________________________________
399 Int_t
401  TString& slatType2,
402  Bool_t& flipX, Bool_t& flipY)
403 {
405 
406  Ssiz_t blankPos = sline.First(' ');
407  if ( blankPos < 0 ) return 0;
408 
409  TString keyword(sline(0,blankPos));
410 
411  if ( keyword == GetKeywordFlipX() )
412  {
413  flipX = kTRUE;
414  } else if ( keyword == GetKeywordFlipY() )
415  {
416  flipY = kTRUE;
417  }
418  else
419  {
420  return 0;
421  }
422 
423  slatType2 = sline(blankPos+1,sline.Length()-blankPos-1);
424  return 1;
425 }
426 
427 //___________________________________________________________________________
428 Int_t
430  Double_t& scale, TString& slatType)
431 {
433 
434  if ( sline(0,GetKeywordScale().Length()) == GetKeywordScale() )
435  {
436  TString tmp(sline(GetKeywordScale().Length()+1,
437  sline.Length()-GetKeywordScale().Length()-1));
438  Ssiz_t blankPos = tmp.First(' ');
439  if ( blankPos < 0 )
440  {
441  AliErrorClass(Form("Syntax error in slat file, should get a slatType after "
442  " SCALE keyword : %s\n",tmp.Data()));
443  return -1;
444  }
445  else
446  {
447  slatType = tmp(0,blankPos);
448  scale = TString(tmp(blankPos+1,tmp.Length()-blankPos-1)).Atof();
449  return 1;
450  }
451  }
452  scale = 1.0;
453  return 0;
454 }
455 
456 //_____________________________________________________________________________
457 Int_t
458 AliMpTriggerReader::GetLine(const TString& slatType)
459 {
466 
467  if ( isdigit(slatType[0]) &&
468  ( slatType[1] == 'R' || slatType[1] == 'L' ) &&
469  slatType[2] == 'L' )
470  {
471  return atoi(slatType(3,1).Data());
472  }
473  return -1;
474 }
475 
476 //_____________________________________________________________________________
477 int
479  const char* localBoardName)
480 {
482 
483  if ( !fLocalBoardMap.GetSize() )
484  {
485  ReadLocalBoardMapping(dataStreams);
486  }
487 
488  TPair* pair = (TPair*)fLocalBoardMap.FindObject(localBoardName);
489 
490  if (pair)
491  {
492  return atoi(((TObjString*)pair->Value())->String().Data());
493  }
494  return -1;
495 }
496 
497 //_____________________________________________________________________________
498 void
500  const char* slatType,
501  AliMp::PlaneType planeType,
502  TList& lines,
503  Double_t& scale,
504  Bool_t& flipX, Bool_t& flipY,
505  Int_t& srcLine, Int_t& destLine)
506 {
512  AliDebugClass(2,Form("SlatType %s Scale %e FlipX %d FlipY %d srcLine %d"
513  " destLine %d\n",slatType,scale,flipX,flipY,
514  srcLine,destLine));
515 
516  istream& in
517  = dataStreams.
518  CreateDataStream(AliMpFiles::SlatFilePath(
519  AliMp::kStationTrigger,slatType, planeType));
520 
521  char line[80];
522 
523  while ( in.getline(line,80) )
524  {
525  TString sline(AliMpHelper::Normalize(line));
526 
527  if ( sline.Length() == 0 || sline[0] == '#' ) continue;
528 
529  Bool_t isKeywordThere =
530  sline.Contains(GetKeywordPcb()) ||
531  sline.Contains(GetKeywordLayer()) ||
532  sline.Contains(GetKeywordScale()) ||
533  sline.Contains(GetKeywordFlipX()) ||
534  sline.Contains(GetKeywordFlipY());
535 
536  if ( !isKeywordThere )
537  {
538  AliErrorClass(Form("Got a line with no keyword : %s."
539  "That's not valid\n",line));
540  continue;
541  }
542 
543  Double_t scale2;
544  TString slatType2;
545 
546  Int_t isScaleLine = DecodeScaleLine(sline,scale2,slatType2);
547 
548  scale *= scale2;
549 
550  if ( isScaleLine < 0 )
551  {
552  AliFatalClass(Form("Syntax error near %s keyword\n",GetKeywordScale().Data()));
553  }
554  else if ( isScaleLine > 0 && slatType2 != slatType )
555  {
556  ReadLines(dataStreams,
557  slatType2.Data(),planeType,lines,scale,flipX,flipY,srcLine,destLine);
558  }
559  else
560  {
561  Bool_t fx(kFALSE);
562  Bool_t fy(kFALSE);
563  Int_t isFlipLine = DecodeFlipLine(sline,slatType2,fx,fy);
564  if ( isFlipLine )
565  {
566  if (fy)
567  {
568  srcLine = GetLine(slatType2);
569  destLine = GetLine(slatType);
570  }
571  flipX |= fx;
572  flipY |= fy;
573  ReadLines(dataStreams,
574  slatType2.Data(),planeType,lines,scale,flipX,flipY,srcLine,destLine);
575  }
576  else
577  {
578  lines.Add(new TObjString(sline.Data()));
579  }
580  }
581  }
582 
583  delete &in;
584 }
585 
586 //_____________________________________________________________________________
587 void
589 {
591 
592  fLocalBoardMap.DeleteAll();
593 
594  UShort_t mask;
595 
596  istream& in
597  = dataStreams.
598  CreateDataStream(AliMpFiles::LocalTriggerBoardMapping());
599 
600  char line[80];
601  Char_t localBoardName[20];
602  Int_t j,localBoardId;
603  UInt_t switches;
604  Int_t nofBoards;
605 
606  while (!in.eof())
607  {
608  for (Int_t i = 0; i < 4; ++i)
609  if (!in.getline(line,80)) continue; //skip 4 first lines
610 
611  // read mask
612  if (!in.getline(line,80)) break;
613  sscanf(line,"%hx",&mask);
614 
615  // read # boards
616  if (!in.getline(line,80)) break;
617  sscanf(line,"%d",&nofBoards);
618 
619  for ( Int_t i = 0; i < nofBoards; ++i )
620  {
621 
622  if (!in.getline(line,80)) break;
623  sscanf(line,"%02d %19s %03d %03x", &j, localBoardName, &localBoardId, &switches);
624  if (localBoardId <= AliMpConstants::NofLocalBoards())
625  {
626  fLocalBoardMap.Add(new TObjString(localBoardName), new TObjString(Form("%d",localBoardId)));
627  AliDebugClass(10,Form("Board %s has number %d\n", localBoardName, localBoardId));
628  }
629  // skip 2 following lines
630  if (!in.getline(line,80)) break;
631  if (!in.getline(line,80)) break;
632 
633  }
634  }
635 
636  delete &in;
637 }
638 
639 //_____________________________________________________________________________
640 AliMpPCB*
642  const char* pcbType)
643 {
647 
648  AliDebugClass(2,Form("pcbType=%s\n",pcbType));
649 
650  TString pcbName(pcbType);
651 
652  Ssiz_t pos = pcbName.First('x');
653 
654  Double_t scale = 1.0;
655 
656  if ( pos > 0 )
657  {
658  scale = TString(pcbName(pos+1,pcbName.Length()-pos-1)).Atof();
659  pcbName = pcbName(0,pos);
660  }
661 
662  istream& in
663  = dataStreams.
664  CreateDataStream(AliMpFiles::SlatPCBFilePath(
665  AliMp::kStationTrigger,pcbName));
666 
668  // note that the nonbending
669  // parameter is of no use for trigger, as far as reading motif is
670  // concerned, as all motifs are supposed to be in the same directory
671  // (as they are shared by bending/non-bending planes).
672 
673  char line[80];
674 
675  const TString kSizeKeyword("SIZES");
676  const TString kMotifKeyword("MOTIF");
677  const TString kMotifSpecialKeyword("SPECIAL_MOTIF");
678 
679  AliMpPCB* pcb(0x0);
680 
681  while ( in.getline(line,80) )
682  {
683  if ( line[0] == '#' ) continue;
684 
685  TString sline(line);
686 
687  if ( sline(0,kSizeKeyword.Length()) == kSizeKeyword )
688  {
689  std::istringstream sin(sline(kSizeKeyword.Length(),
690  sline.Length()-kSizeKeyword.Length()-1).Data());
691  float padSizeX = 0.0;
692  float padSizeY = 0.0;
693  float pcbSizeX = 0.0;
694  float pcbSizeY = 0.0;
695  sin >> padSizeX >> padSizeY >> pcbSizeX >> pcbSizeY;
696  if (pcb)
697  {
698  AliError("pcb not null as expected");
699  }
700  pcb = new AliMpPCB(fMotifMap,pcbType,padSizeX*scale,padSizeY*scale,
701  pcbSizeX*scale,pcbSizeY*scale);
702  }
703 
704  if ( sline(0,kMotifSpecialKeyword.Length()) == kMotifSpecialKeyword )
705  {
706  std::istringstream sin(sline(kMotifSpecialKeyword.Length(),
707  sline.Length()-kMotifSpecialKeyword.Length()).Data());
708  TString sMotifSpecial;
709  TString sMotifType;
710  sin >> sMotifSpecial >> sMotifType;
711 
712  TString id = reader.MotifSpecialName(sMotifSpecial,scale);
713 
714  AliMpMotifSpecial* specialMotif =
715  dynamic_cast<AliMpMotifSpecial*>(fMotifMap->FindMotif(id));
716  if (!specialMotif)
717  {
718  AliDebug(1,Form("Reading motifSpecial %s (%s) from file",
719  sMotifSpecial.Data(),id.Data()));
720  AliMpMotifType* motifType = fMotifMap->FindMotifType(sMotifType.Data());
721  if ( !motifType)
722  {
723  AliDebug(1,Form("Reading motifType %s (%s) from file",
724  sMotifType.Data(),id.Data()));
725  motifType = reader.BuildMotifType(dataStreams,sMotifType.Data());
726  fMotifMap->AddMotifType(motifType);
727  }
728  else
729  {
730  AliDebug(1,Form("Got motifType %s (%s) from motifMap",
731  sMotifType.Data(),id.Data()));
732  }
733  specialMotif = reader.BuildMotifSpecial(dataStreams,sMotifSpecial,motifType,scale);
734  fMotifMap->AddMotif(specialMotif);
735  }
736  else
737  {
738  AliDebug(1,Form("Got motifSpecial %s from motifMap",sMotifSpecial.Data()));
739  }
740  if (pcb)
741  {
742  AliError("pcb not null as expected");
743  }
744  pcb = new AliMpPCB(pcbType,specialMotif);
745  }
746 
747  if ( sline(0,kMotifKeyword.Length()) == kMotifKeyword )
748  {
749  std::istringstream sin(sline(kMotifKeyword.Length(),
750  sline.Length()-kMotifKeyword.Length()).Data());
751  TString sMotifType;
752  int ix;
753  int iy;
754  sin >> sMotifType >> ix >> iy;
755 
756  AliMpMotifType* motifType = fMotifMap->FindMotifType(sMotifType.Data());
757  if ( !motifType)
758  {
759  AliDebug(1,Form("Reading motifType %s from file",sMotifType.Data()));
760  motifType = reader.BuildMotifType(dataStreams,sMotifType.Data());
761  fMotifMap->AddMotifType(motifType);
762  }
763  else
764  {
765  AliDebug(1,Form("Got motifType %s from motifMap",sMotifType.Data()));
766  }
767 
768  if (! pcb)
769  {
770  AliError("pcb null");
771  continue;
772  }
773  pcb->Add(motifType,ix,iy);
774  }
775  }
776 
777  delete &in;
778 
779  return pcb;
780 }
781 
782 //_____________________________________________________________________________
785  const char* slatType, AliMp::PlaneType planeType)
786 {
790 
791  Double_t scale = 1.0;
792  Bool_t flipX = kFALSE;
793  Bool_t flipY = kFALSE;
794  TList lines;
795  lines.SetOwner(kTRUE);
796  Int_t srcLine(-1);
797  Int_t destLine(-1);
798 
799  // Read the file and its include (if any) and store the result
800  // in a TObjArray of TObjStrings.
801  ReadLines(dataStreams,
802  slatType,planeType,lines,scale,flipX,flipY,srcLine,destLine);
803 
804  // Here some more sanity checks could be done.
805  // For the moment we only insure that the first line contains
806  // a layer keyword.
807  TString& firstLine = ((TObjString*)lines.First())->String();
808  if ( !IsLayerLine(firstLine) )
809  {
810  std::ostringstream s;
811  s << GetKeywordLayer();
812  lines.AddFirst(new TObjString(s.str().c_str()));
813  }
814 
815  AliDebugClass(2,Form("Scale=%g\n",scale));
816 
817  FlipLines(dataStreams,lines,flipX,flipY,srcLine,destLine);
818 
819  // Now splits the lines in packets corresponding to different layers
820  // (if any), and create sub-slats.
821  TObjArray layers;
822  layers.SetOwner(kTRUE);
823  Int_t ilayer(-1);
824  TIter it(&lines);
825  TObjString* osline;
826 
827  while ( ( osline = (TObjString*)it.Next() ) )
828  {
829  TString& s = osline->String();
830  if ( IsLayerLine(s) )
831  {
832  TList* list = new TList;
833  list->SetOwner(kTRUE);
834  layers.Add(list);
835  ++ilayer;
836  }
837  else
838  {
839  ((TList*)layers.At(ilayer))->Add(new TObjString(s));
840  }
841  }
842 
843  AliDebugClass(2,Form("nlayers=%d\n",layers.GetEntriesFast()));
844 
845  AliMpTrigger* triggerSlat = new AliMpTrigger(slatType, planeType);
846 
847  for ( ilayer = 0; ilayer < layers.GetEntriesFast(); ++ilayer )
848  {
849  TList& lines1 = *((TList*)layers.At(ilayer));
850  std::ostringstream slatName;
851  slatName << slatType << "-LAYER" << ilayer;
852  AliMpSlat* slat = BuildSlat(dataStreams,
853  slatName.str().c_str(),planeType,lines1,scale);
854  if ( slat )
855  {
856  Bool_t ok = triggerSlat->AdoptLayer(slat);
857  if (!ok)
858  {
859  StdoutToAliError(cout << "could not add slat=" << endl;
860  slat->Print();
861  cout << "to the triggerSlat=" << endl;
862  triggerSlat->Print();
863  );
864  AliError("Slat is=");
865  for ( Int_t i = 0; i < slat->GetSize(); ++i )
866  {
867  AliMpPCB* pcb = slat->GetPCB(i);
868  AliError(Form("ERR pcb %d size %e,%e (unscaled is %e,%e)",
869  i,pcb->DX()*2,pcb->DY()*2,
870  pcb->DX()*2/scale,pcb->DY()*2/scale));
871  }
872  AliError("TriggerSlat is=");
873  for ( Int_t j = 0; j < triggerSlat->GetSize(); ++j )
874  {
875  AliMpSlat* slat1 = triggerSlat->GetLayer(j);
876  AliError(Form("Layer %d",j));
877  for ( Int_t i = 0; i < slat1->GetSize(); ++i )
878  {
879  AliMpPCB* pcb = slat1->GetPCB(i);
880  AliError(Form("ERR pcb %d size %e,%e (unscaled is %e,%e)",
881  i,pcb->DX()*2,pcb->DY()*2,
882  pcb->DX()*2/scale,pcb->DY()*2/scale));
883  }
884  }
886  }
887  }
888  else
889  {
890  AliErrorClass(Form("Could not read %s\n",slatName.str().c_str()));
891  delete triggerSlat;
892  return 0;
893  }
894  }
895 
896  return triggerSlat;
897 }
TBrowser b
Definition: RunAnaESD.C:12
Double_t DX() const
Definition: AliMpPCB.cxx:454
AliMpPCB * ReadPCB(const AliMpDataStreams &dataStreams, const char *pcbType)
Bool_t AddMotifType(AliMpMotifType *motifType, Bool_t warn=kTRUE)
Read trigger slat ASCII files.
static const TString & GetKeywordFlipX()
#define TObjArray
A special motif with varying pad dimensions.
static TString Normalize(const char *line)
AliMpMotifSpecial * BuildMotifSpecial(const AliMpDataStreams &dataStreams, const TString &motifID, AliMpMotifType *motifType, Double_t scale=1.0)
void Add(AliMUONVStore &destStore, const AliMUONVStore &srcStore)
Definition: MCHOCCda.cxx:68
void Print(Option_t *option="") const
AliMpTriggerReader(AliMpSlatMotifMap *motifMap)
TString MotifSpecialName(const TString &motifID, Double_t scale)
A PCB for station 3,4 or 5.
Definition: AliMpPCB.h:46
void Add(const AliMpPCB &pcbType, const TArrayI &manuList)
Definition: AliMpSlat.cxx:112
AliMpSlat * GetLayer(int layer) const
AliMpSlatMotifMap * fMotifMap
! storage for motifTypes and motifs...
AliMpMotifType * BuildMotifType(const AliMpDataStreams &dataStreams, const TString &motifTypeId)
AliMpSlat * BuildSlat(const AliMpDataStreams &dataStreams, const char *slatName, AliMp::PlaneType planeType, const TList &descriptionLines, Double_t scale=1.0)
Float_t scale[5]
A slat (building block of stations 3, 4 and 5)
Definition: AliMpSlat.h:51
static const TString & GetKeywordFlipY()
static Int_t NofLocalBoards()
Return number of trigger local boards.
#define AliFatalClass(message)
Definition: AliLog.h:645
static const TString & GetKeywordScale()
Int_t DecodeFlipLine(const TString &sline, TString &slatType2, Bool_t &flipX, Bool_t &flipY)
A container to keep track of allocated motifs and motifTypes for slats (both St345 and trigger ones)...
void ReadLocalBoardMapping(const AliMpDataStreams &dataStreams)
Double_t DY() const
Definition: AliMpSlat.cxx:171
static TString LocalTriggerBoardMapping()
Definition: AliMpFiles.cxx:337
#define AliErrorClass(message)
Definition: AliLog.h:596
static TString SlatPCBFilePath(AliMp::StationType stationType, const char *pcbType)
Definition: AliMpFiles.cxx:369
A trigger slat.
Definition: AliMpTrigger.h:37
static const TString & GetKeywordLayer()
#define AliDebugClass(logLevel, message)
Definition: AliLog.h:313
Bool_t AdoptLayer(AliMpSlat *slat)
void Print(Option_t *option="") const
Definition: AliMpSlat.cxx:456
Int_t DecodeScaleLine(const TString &sline, Double_t &scale, TString &slatType)
Double_t DX() const
Definition: AliMpSlat.cxx:161
void Add(AliMpMotifType *motifType, Int_t ix, Int_t iy)
Definition: AliMpPCB.cxx:231
Int_t GetSize() const
Returns the number of layers.
AliMpPCB * GetPCB(Int_t i) const
Returns the i-th PCB of this slat.
Definition: AliMpSlat.cxx:435
void FlipLines(const AliMpDataStreams &dataStreams, TList &lines, Bool_t flipX, Bool_t flipY, Int_t srcLine, Int_t destLine)
non-bending plane
TString PlaneTypeName(AliMp::PlaneType planeType)
Return name for given planeType.
TMap fLocalBoardMap
! map of TObjString to TObjString
const char * GetID() const
Definition: AliMpSlat.cxx:356
#define StdoutToAliError(whatever)
Definition: AliLog.h:619
void Print(Option_t *opt="") const
AliMpVMotif * FindMotif(const TString &id) const
value for all non sector stations
Int_t IsLayerLine(const TString &sline) const
Double_t DY() const
Definition: AliMpPCB.cxx:480
#define AliDebug(logLevel, message)
Definition: AliLog.h:300
trigger stations (slats)
void ReadLines(const AliMpDataStreams &dataStreams, const char *slatType, AliMp::PlaneType planeType, TList &lines, Double_t &scale, Bool_t &flipX, Bool_t &flipY, Int_t &srcLine, Int_t &destLine)
Class that takes care of reading the motifs data.
TString GetBoardNameFromPCBLine(const TString &sline)
AliMpTrigger * ReadSlat(const AliMpDataStreams &dataStreams, const char *slatType, AliMp::PlaneType planeType)
#define AliError(message)
Definition: AliLog.h:591
AliMpMotifType * FindMotifType(const TString &id) const
Bool_t AddMotif(AliMpVMotif *motif, Bool_t warn=kTRUE)
static const TString & GetKeywordPcb()
static TString SlatFilePath(AliMp::StationType stationType, const char *slatType, AliMp::PlaneType plane)
Definition: AliMpFiles.cxx:357
int LocalBoardNumber(const AliMpDataStreams &dataStreams, const char *localBoardName)
Int_t GetSize() const
Returns the number of PCBs of this slat.
Definition: AliMpSlat.cxx:446
Class that defines the motif properties.
Int_t GetLine(const TString &slatType)
Mapping data streams provider.
static void DecodeName(const char *manus, char sep, TArrayI &theList)