MUON/mapping/AliMpTriggerReader.cxx

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