- Added Global Crate object
authorivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 16 Nov 2007 14:52:33 +0000 (14:52 +0000)
committerivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 16 Nov 2007 14:52:33 +0000 (14:52 +0000)
- Changed format of regional crate file (crate.dat) and updated reader method accordingly
(Christian)

MUON/mapping/AliMpDDLStore.cxx
MUON/mapping/AliMpDDLStore.h
MUON/mapping/AliMpFiles.cxx
MUON/mapping/AliMpFiles.h

index 99e834d..8afaeab 100644 (file)
@@ -63,35 +63,35 @@ const Int_t    AliMpDDLStore::fgkNofTriggerDDLs = 2;
 //
 
 //______________________________________________________________________________
-AliMpDDLStore* AliMpDDLStore::Instance(Bool_t warn)
+AliMpDDLStore* AliMpDDLStore::Instance(Bool_t warn) 
 {
-/// Create the DDL store if it does not yet exist
-/// and return its instance
+    /// Create the DDL store if it does not yet exist
+    /// and return its instance
 
-  if ( ! fgInstance && warn  ) {
-    AliWarningClass("DDL Store has not been loaded");
-  }  
-     
-  return fgInstance;
-}    
+    if ( ! fgInstance && warn  ) {
+        AliWarningClass("DDL Store has not been loaded");
+    }
+
+    return fgInstance;
+}
 
 //______________________________________________________________________________
-AliMpDDLStore* AliMpDDLStore::ReadData(Bool_t warn)
+AliMpDDLStore* AliMpDDLStore::ReadData(Bool_t warn) 
 {
-/// Load the DDL store from ASCII data files
-/// and return its instance
+    /// Load the DDL store from ASCII data files
+    /// and return its instance
 
-  if ( fgInstance ) {
-    if ( warn )
-      AliWarningClass("DDL Store has been already loaded");
-    return fgInstance;
-  }  
-  
-  AliInfoClass("Reading DDL Store from ASCII files.");
+    if ( fgInstance ) {
+        if ( warn )
+            AliWarningClass("DDL Store has been already loaded");
+        return fgInstance;
+    }
 
-  fgInstance = new AliMpDDLStore();
-  return fgInstance;
-}    
+    AliInfoClass("Reading DDL Store from ASCII files.");
+
+    fgInstance = new AliMpDDLStore();
+    return fgInstance;
+}
 
 //
 // ctors, dtor
@@ -99,67 +99,70 @@ AliMpDDLStore* AliMpDDLStore::ReadData(Bool_t warn)
 
 //______________________________________________________________________________
 AliMpDDLStore::AliMpDDLStore()
-: TObject(),
-  fDDLs(fgkNofDDLs+fgkNofTriggerDDLs), // FIXEME
-  fBusPatches(true),
-  fTriggerCrates(true),
-  fLocalBoards(true),
-  fManuList12(),
-  fManuBridge2()
-{  
-/// Standard constructor
-
-  AliDebug(1,"");
-  fDDLs.SetOwner(true);
-  fBusPatches.SetOwner(true);
-  fBusPatches.SetSize(900);
-
-  fTriggerCrates.SetOwner(true);
-  fTriggerCrates.SetSize(16);
-
-  fLocalBoards.SetOwner(true);
-  fLocalBoards.SetSize(242); // included non-identied board
-
-
-  // Load segmentation & DE store data
-  if ( ! AliMpSegmentation::Instance(false) )
-    AliMpSegmentation::ReadData(true);
-
-  // Create all detection elements
-  ReadDDLs();
-  ReadTriggerDDLs();
-  SetManus();
-  SetPatchModules();
-  SetBusPatchLength();
+        : TObject(),
+        fDDLs(fgkNofDDLs+fgkNofTriggerDDLs), // FIXEME
+        fBusPatches(true),
+        fTriggerCrates(true),
+        fLocalBoards(true),
+        fManuList12(),
+        fManuBridge2(),
+        fGlobalCrate(new AliMpGlobalCrate())
+{
+    /// Standard constructor
+
+    AliDebug(1,"");
+    fDDLs.SetOwner(true);
+    fBusPatches.SetOwner(true);
+    fBusPatches.SetSize(900);
+
+    fTriggerCrates.SetOwner(true);
+    fTriggerCrates.SetSize(16);
+
+    fLocalBoards.SetOwner(true);
+    fLocalBoards.SetSize(242); // included non-identied board
+
+
+    // Load segmentation & DE store data
+    if ( ! AliMpSegmentation::Instance(false) )
+        AliMpSegmentation::ReadData(true);
+
+    // Create all detection elements
+    ReadDDLs();
+    ReadTriggerDDLs();
+    SetManus();
+    SetPatchModules();
+    SetBusPatchLength();
 }
 
 //______________________________________________________________________________
 AliMpDDLStore::AliMpDDLStore(TRootIOCtor* /*ioCtor*/)
-: TObject(),
-  fDDLs(),
-  fBusPatches(),
-  fTriggerCrates(true),
-  fLocalBoards(true)
-{  
-/// Constructor for IO
+        : TObject(),
+        fDDLs(),
+        fBusPatches(),
+        fTriggerCrates(true),
+        fLocalBoards(true),
+        fGlobalCrate()
+{
+    /// Constructor for IO
 
-  AliDebug(1,"");
+    AliDebug(1,"");
 
-  fgInstance = this;
+    fgInstance = this;
 }
 
 
 //______________________________________________________________________________
-AliMpDDLStore::~AliMpDDLStore()
+AliMpDDLStore::~AliMpDDLStore() 
 {
-/// Destructor
+    /// Destructor
 
-  AliDebug(1,"");
+    AliDebug(1,"");
 
-  // DDL objects are deleted with fDDLs 
-  // Bus patches objects are deleted with fBusPatches 
-  
-  fgInstance = 0;
+    // DDL objects are deleted with fDDLs
+    // Bus patches objects are deleted with fBusPatches
+
+    fgInstance = 0;
+    delete fGlobalCrate;
 }
 
 //
@@ -167,538 +170,638 @@ AliMpDDLStore::~AliMpDDLStore()
 //
 
 //______________________________________________________________________________
-Int_t  AliMpDDLStore::GetManuListIndex(Int_t detElemId) const
+Int_t  AliMpDDLStore::GetManuListIndex(Int_t detElemId) const 
 {
-/// Return the index of the manu list for given detElemId
+    /// Return the index of the manu list for given detElemId
+
+    return AliMpDEManager::GetChamberId(detElemId)*4 + (detElemId % 100);
+}
 
-  return AliMpDEManager::GetChamberId(detElemId)*4 + (detElemId % 100);
-}  
-  
 
 //______________________________________________________________________________
-Int_t AliMpDDLStore::GetBusPatchIndex(Int_t detElemId, Int_t manuId) const
+Int_t AliMpDDLStore::GetBusPatchIndex(Int_t detElemId, Int_t manuId) const 
 {
-/// Calculate the index of the buspatch from manuId
+    /// Calculate the index of the buspatch from manuId
 
     Int_t pos = 0;
     AliMp::StationType stationType = AliMpDEManager::GetStationType(detElemId);
     static Int_t manuMask = AliMpConstants::ManuMask(AliMp::kNonBendingPlane) - 1;
 
     if( stationType == AliMp::kStation345) {
-      pos = (manuId & manuMask)/100;
+        pos = (manuId & manuMask)/100;
     } else {
-      Int_t idx = GetManuListIndex(detElemId);
+        Int_t idx = GetManuListIndex(detElemId);
 
-      // using array defined from DetElemIdToBusPatch.dat file
-      for (pos = fManuList12[idx].GetSize()-1; pos >= 0; --pos)
-         if ( manuId >= fManuList12[idx].At(pos)) break;
+        // using array defined from DetElemIdToBusPatch.dat file
+        for (pos = fManuList12[idx].GetSize()-1; pos >= 0; --pos)
+            if ( manuId >= fManuList12[idx].At(pos))
+                break;
     }
 
     return pos;
 }
 
-
 //______________________________________________________________________________
-Bool_t AliMpDDLStore::ReadDDLs()
+Bool_t  AliMpDDLStore::ReadGlobalTrigger(AliMpGlobalCrate& crate, const Char_t* globalName) 
 {
-/// Read ddl <-> bus patch file
+    /// Fill trigger global crate object from ascii file
+    /// put the method static to be used by other class w/o initializing object
+  
+    TString infile;
+        
+    if (globalName == 0)
+      infile = AliMpFiles::GlobalTriggerBoardMapping();
+    else
+      infile = globalName;
     
-  TString infile = AliMpFiles::BusPatchFilePath();
-
-  ifstream in(infile, ios::in);
-  if (!in) {
-    AliErrorStream() << "Data file " << infile << " not found.";
-    return false;
-  }  
-      
-  char line[255];
-
-  while ( in.getline(line,255) ) {
-
-     if ( line[0] == '#' ) continue;
+    ifstream in(infile, ios::in);
 
-     TString tmp(AliMpHelper::Normalize(line));
+    if (!in) {
+        printf("Local Trigger Board Mapping File %s not found", infile.Data());
+        return kFALSE;
+    }
 
-     TObjArray* stringList = tmp.Tokenize(TString(" "));
+    TArrayI list;
 
-     TString sDE = ((TObjString*)stringList->At(0))->GetString();
-     Int_t idDE  = atoi(sDE.Data());
+    char line[255];
+    in.getline(line, 255);
+    TString tmp(AliMpHelper::Normalize(line));
+
+    if (!tmp.Contains(crate.GetName()))
+        printf("Wrong Global Crate File");
+
+    in.getline(line, 255);
+    tmp = AliMpHelper::Normalize(line);
+
+    if (tmp.Contains(crate.GetJtagName())) {
+        // vme addr
+        in.getline(line, 255);
+        TString tmp(AliMpHelper::Normalize(line));
+        ULong_t addr;
+        sscanf(tmp.Data(), "%lx", &addr);
+        crate.SetJtagVmeAddr(addr);
+        //AliDebug(1, Form("Jtag Vme Address: 0x%x", addr));
+
+        // clk div, rx phase, read delay
+        in.getline(line, 255);
+        tmp = AliMpHelper::Normalize(line);
+        TArrayI list;
+        AliMpHelper::DecodeName(line, ' ', list);
+        crate.SetJtagClockDiv(list[0]);
+        crate.SetJtagRxPhase(list[1]);
+        crate.SetJtagRdDelay(list[2]);
+        //AliDebug(1, Form("Jtag Clock Div: %d, Rx Phase: %d, Read Delay %d", list[0], list[1], list[2]));
+
+        // enable
+        in.getline(line, 255);
+        tmp = AliMpHelper::Normalize(line);
+        AliMpHelper::DecodeName(line, ' ', list);
+        UChar_t enable = 0;
+        for (Int_t i = 0; i < crate.GetJtagNofLines(); ++i)
+            enable |= (list[i] << i);
+        crate.SetEnableJtag(enable);
+        //AliDebug(1, Form("Jtag Enable: 0x%x", enable));
+
+        for (Int_t i = 0; i < crate.GetJtagNofLines(); ++i) {
+            in.getline(line, 255);
+            for (Int_t j = 0; j < crate.GetJtagNofLines(); ++j) {
+                in.getline(line, 255);
+                tmp = AliMpHelper::Normalize(line);
+                crate.SetJtagCrateName(i*crate.GetJtagNofLines() + j, tmp);
+                //AliDebug(1, Form("Jtag Crate Name: %s", tmp.Data()));
+            }
+        }
+    }
 
-     if ( ! AliMpDEManager::IsValidDetElemId(idDE, false) ) {
-       AliErrorStream() << "DetElemId "<< idDE << " not valid." << endl;
-       return false;
-     }  
+    in.getline(line, 255);
+    tmp = AliMpHelper::Normalize(line);
+    if (tmp.Contains(crate.GetFirstDarcName())) {
+        // vme addr
+        in.getline(line, 255);
+        TString tmp(AliMpHelper::Normalize(line));
+        ULong_t addr;
+        sscanf(tmp.Data(), "%lx", &addr);
+        crate.SetFirstDarcVmeAddr(addr);
+        //AliDebug(1, Form("First Darc Vme Address: 0x%x", addr));
+
+        // type
+        in.getline(line, 255);
+        tmp = AliMpHelper::Normalize(line);
+        crate.SetFirstDarcType(tmp.Atoi());
+        //AliDebug(1, Form("First Darc Type: %d", tmp.Atoi()));
+
+        // enable
+        in.getline(line, 255);
+        UInt_t item;
+        tmp = AliMpHelper::Normalize(line);
+        sscanf(tmp.Data(), "%x", &item);
+        crate.SetFirstDarcDisable(item);
+        //AliDebug(1, Form("First Darc Enable: 0x%x", item));
+
+        // L0
+        in.getline(line, 255);
+        tmp = AliMpHelper::Normalize(line);
+        sscanf(tmp.Data(), "%x", &item);
+        crate.SetFirstDarcL0Delay(item);
+        //AliDebug(1, Form("First Darc L0 Delay: 0x%x", item));
+
+        // L1
+        in.getline(line, 255);
+        tmp = AliMpHelper::Normalize(line);
+        sscanf(tmp.Data(), "%x", &item);
+        crate.SetFirstDarcL1TimeOut(item);
+        //AliDebug(1, Form("First Darc L1 Time Out: 0x%x", item));
+    }
 
-     TString busPatch = ((TObjString*)stringList->At(1))->GetString();
+    in.getline(line, 255);
+    tmp = AliMpHelper::Normalize(line);
+    if (tmp.Contains(crate.GetSecondDarcName())) {
+        // vme addr
+        in.getline(line, 255);
+        TString tmp(AliMpHelper::Normalize(line));
+        ULong_t addr;
+        sscanf(tmp.Data(), "%lx", &addr);
+        crate.SetSecondDarcVmeAddr(addr);
+        //AliDebug(1, Form("Second Darc Vme Address: 0x%x", addr));
+        
+        // type
+        in.getline(line, 255);
+        tmp = AliMpHelper::Normalize(line);
+        crate.SetSecondDarcType(tmp.Atoi());
+        //AliDebug(1, Form("Second Darc Type: %d", tmp.Atoi()));
+        
+        // enable
+        in.getline(line, 255);
+        UInt_t item;
+        tmp = AliMpHelper::Normalize(line);
+        sscanf(tmp.Data(), "%x", &item);
+        crate.SetSecondDarcDisable(item);
+        //AliDebug(1, Form("Second Darc Enable: 0x%x", item));
+        
+        // L0
+        in.getline(line, 255);
+        tmp = AliMpHelper::Normalize(line);
+        sscanf(tmp.Data(), "%x", &item);
+        crate.SetSecondDarcL0Delay(item);
+        //AliDebug(1, Form("Second Darc L0 Delay: 0x%x", item));
+        
+        // L1
+        in.getline(line, 255);
+        tmp = AliMpHelper::Normalize(line);
+        sscanf(tmp.Data(), "%x", &item);
+        crate.SetSecondDarcL1TimeOut(item);
+        //AliDebug(1, Form("Second Darc L1 Time Out: 0x%x", item));
+    }
 
+    in.getline(line, 255);
+    tmp = AliMpHelper::Normalize(line);
+    if (tmp.Contains(crate.GetGlobalName())) {
+        in.getline(line, 255);
+        TString tmp(AliMpHelper::Normalize(line));
+        ULong_t addr;
+        sscanf(tmp.Data(), "%lx", &addr);
+        crate.SetGlobalVmeAddr(addr);
+        //AliDebug(1, Form("Global Vme Address: 0x%x", addr));
+
+        for (Int_t i = 0; i < crate.GetGlobalNofRegisters(); ++i) {
+            in.getline(line, 255);
+            TString tmp(AliMpHelper::Normalize(line));
+            UInt_t reg;
+            sscanf(tmp.Data(), "%x", &reg);
+            crate.SetGlobalRegister(i, reg);
+            //AliDebug(1, Form("Global Register %d: 0x%x", i, reg));
+        }
+    }
 
-     TString sDDL = ((TObjString*)stringList->At(2))->GetString();
-     Int_t  iDDL  = atoi(sDDL.Data());
+    in.getline(line, 255);
+    tmp = AliMpHelper::Normalize(line);
+    if (tmp.Contains(crate.GetFetName())) {
+        in.getline(line, 255);
+        TString tmp(AliMpHelper::Normalize(line));
+        ULong_t addr;
+        sscanf(tmp.Data(), "%lx", &addr);
+        crate.SetFetVmeAddr(addr);
+        //AliDebug(1, Form("Fet Vme Address: 0x%x", addr));
+
+        for (Int_t i = 0; i < crate.GetFetNofRegisters(); ++i) {
+            in.getline(line, 255);
+            TString tmp(AliMpHelper::Normalize(line));
+            UInt_t reg;
+            sscanf(tmp.Data(), "%x", &reg);
+            crate.SetFetRegister(i, reg);
+            //AliDebug(1, Form("Fet Register %d: 0x%x", i, reg));
+        }
+    }
 
-     if ( iDDL < 0 || iDDL >= fgkNofDDLs ) {
-       AliErrorStream() << "DDL id "<< iDDL << " outside limits." << endl;
-       return false;
-     }
-  
-     AliDebugStream(3)
-        << "idDE " << idDE << " buspatch " << busPatch.Data() << " iDDL " << iDDL 
-        << endl;
-
-     // reading 1st manu Id for each bus patch (station 1 & 2)
-     if(AliMpDEManager::GetStationType(idDE) != AliMp::kStation345) {
-     
-       TString sManu = ((TObjString*)stringList->At(3))->GetString();
-       AliMpHelper::DecodeName(sManu,',',fManuList12[GetManuListIndex(idDE)]);
-  
-       if(AliMpDEManager::GetStationType(idDE) == AliMp::kStation2) {
-        TString sManuBridge = ((TObjString*)stringList->At(4))->GetString();
-        AliMpHelper::DecodeName(sManuBridge,',',fManuBridge2[GetManuListIndex(idDE)]);
-       }
-
-     }
-
-     delete stringList;
-
-     AliMpDDL* ddl = GetDDL(iDDL, false);
-     if ( !ddl) {
-       ddl = new AliMpDDL(iDDL);
-       fDDLs.AddAt(ddl, iDDL);
-     }  
-     ddl->AddDE(idDE);
-     
-     TArrayI busPatchList;
-     // decoding range of buspatch
-     AliMpHelper::DecodeName(busPatch,';',busPatchList);
-     
-     // Update DE
-     AliMpDetElement* de = AliMpDEManager::GetDetElement(idDE);
-     de->SetDdlId(iDDL);
-     // filling buspatch -> idDE
-     for (Int_t i = 0; i < busPatchList.GetSize(); i++) {
-       fBusPatches.Add(busPatchList[i], 
-                       new AliMpBusPatch(busPatchList[i], idDE, iDDL));
-       de->AddBusPatch(busPatchList[i]);
-     }  
-   }
-   
-   // Fill bus patch Ids array in DDLs now
-   for ( Int_t i=0; i<fDDLs.GetEntriesFast(); i++ ) {
-     AliMpDDL* ddl = (AliMpDDL*) fDDLs.At(i);
-     ddl->FillBusPatchIds();
-   }  
-   
-   in.close();
-   return true;
+    return kTRUE;
 }
-
 //______________________________________________________________________________
-Bool_t  AliMpDDLStore::ReadTriggerDDLs()
+Bool_t AliMpDDLStore::ReadDDLs() 
 {
-/// create trigger DDL object ddl<->Crate<->local board
-  
-   AliMpStringObjMap inputXfromMap;
-   AliMpStringObjMap inputXtoMap;
-   AliMpStringObjMap inputYfromMap;
-   AliMpStringObjMap inputYtoMap;
+    /// Read ddl <-> bus patch file
 
-    Int_t nonNotified = 0;
+    TString infile = AliMpFiles::BusPatchFilePath();
 
-    Int_t iDDL = -1;
-
-    TString infile = AliMpFiles::LocalTriggerBoardMapping();
-  
     ifstream in(infile, ios::in);
-    
     if (!in) {
-      AliError(Form("Local Trigger Board Mapping File %s not found", infile.Data()));
-      return kFALSE;
+        AliErrorStream() << "Data file " << infile << " not found.";
+        return false;
     }
-  
-    AliMpLocalBoard* board = 0x0;
-    AliMpTriggerCrate* crate = 0x0;
-
-    TString localNumber;
-    Int_t localNumberId = 0;
-    TArrayI list;
 
     char line[255];
-    while (in.getline(line, 255))
-    {
 
-      // files contains lines with some blank caracters ???
-      if (line[0] == ' ' && strlen(line) < 12) continue;
+    while ( in.getline(line,255) ) {
 
-      TString tmp(AliMpHelper::Normalize(line));
-      if (tmp.IsNull()) continue; // Ignore empty lines
-      if (tmp.Contains("Board")) 
-      {
-       // extract id, name, slot & crate name
-       TObjArray* stringList = tmp.Tokenize(TString(" "));
-  
-       TString localNumber = ((TObjString*)stringList->At(1))->GetString();
-
-       if (localNumber.CompareTo("nn") != 0) // Notified cards
-           localNumberId = localNumber.Atoi();
-       else 
-           localNumberId = AliMpConstants::NofLocalBoards()  + (++nonNotified);
-
-       TString localName = ((TObjString*)stringList->At(4))->GetString();
-       TString slotName  = ((TObjString*)stringList->At(10))->GetString();
-
-       AliDebug(3, Form("%d %s %d\n", localNumberId, localName.Data(), slotName.Atoi()));
-
-       board = new AliMpLocalBoard(localNumberId, localName.Data(), slotName.Atoi());
-
-       // not notified board
-       if (localNumber.CompareTo("nn") == 0)
-           board->SetNotified(false);
-
-       // compose name with number and side (Right or Left)
-       TString crateNumber = ((TObjString*)stringList->At(6))->GetString();
-       TString crateSide = ((TObjString*)stringList->At(7))->GetString();
-       TString crateName = crateNumber + crateSide;
-
-       // set crate name
-       board->SetCrate(crateName);
-
-       // determine ddl number vs crate side
-       if (crateName.Contains("R")) 
-           iDDL = fgkNofDDLs; // starts where tracker ends
-       else 
-           iDDL = fgkNofDDLs + 1;
-       
-       AliMpDDL* ddl = GetDDL(iDDL, false);
-       if ( !ddl) {
-         ddl = new AliMpDDL(iDDL);
-         fDDLs.AddAt(ddl, iDDL);
-       }  
-       
-       Int_t crateId; 
-       if (crateNumber.CompareTo("2-3") != 0)
-           crateId = crateNumber.Atoi();
-       else
-           crateId = 23;
-
-       // add trigger crate number for given ddl if not present
-       if ( !ddl->HasTriggerCrateId(crateId) )
-           ddl->AddTriggerCrate(crateId);
-
-       // if crate not existing then creating
-       if (!GetTriggerCrate(crateName, false)) {
-           crate = new AliMpTriggerCrate(crateName.Data(), iDDL);
-           fTriggerCrates.Add(crateName.Data(), crate);
-       }
-
-       // create list of local board in this crate
-       crate->AddLocalBoard(localNumberId);
-
-       delete stringList;
-      }
+        if ( line[0] == '#' )
+            continue;
 
-      if (tmp.Contains("DetElemId")) 
-      {
-       list.Reset();
-       AliMpDDL* ddl = GetDDL(iDDL, true);
-
-       // add  DE for local board and DDL
-       TString detElem = &tmp[tmp.First(" ")+1];
-       AliMpHelper::DecodeName(detElem,' ',list);
-
-       for (Int_t i = 0; i < list.GetSize(); ++i) {
-
-         if (list[i]) { // skip copy card
-             AliMpDetElement* de = AliMpDEManager::GetDetElement(list[i]);
-             if (de->GetDdlId() == -1)
-                 de->SetDdlId(iDDL);
-         }
-           board->AddDE(list[i]);
-           if(!ddl->HasDEId(list[i]))
-               ddl->AddDE(list[i]);
-       }
-      }
+        TString tmp(AliMpHelper::Normalize(line));
 
-      // map the different copies between cards in X and Y inputs
-      // when copying Xinput, Yinput are copied as well
-      if (tmp.Contains("X3input1")) 
-      {
-       TObjArray* stringList = tmp.Tokenize(TString(" "));
-  
-       TString copyX = ((TObjString*)stringList->At(3))->GetString();
-       TString input = ((TObjString*)stringList->At(2))->GetString();;
-
-       if (copyX.Contains("(1)")) { 
-         inputXfromMap.Add(input, board);
-         inputYfromMap.Add(input, board);
-
-       }
-       if (copyX.Contains("(2)")) {
-         inputXtoMap.Add(input, board);
-         inputYtoMap.Add(input, board);
-       }
-       delete stringList;
-      }
+        TObjArray* stringList = tmp.Tokenize(TString(" "));
 
-      if (tmp.Contains("Y1input1")) 
-      {
-       TObjArray* stringList = tmp.Tokenize(TString(" "));
+        TString sDE = ((TObjString*)stringList->At(0))->GetString();
+        Int_t idDE  = atoi(sDE.Data());
 
-       TString copyY = ((TObjString*)stringList->At(3))->GetString();
-       TString input = ((TObjString*)stringList->At(2))->GetString();;
+        if ( ! AliMpDEManager::IsValidDetElemId(idDE, false) ) {
+            AliErrorStream() << "DetElemId "<< idDE << " not valid." << endl;
+            return false;
+        }
 
-       if (copyY.Contains("(1)")) 
-           inputYfromMap.Add(input, board);
-       if (copyY.Contains("(2)")) 
-           inputYtoMap.Add(input, board);
-       delete stringList;
-      }
+        TString busPatch = ((TObjString*)stringList->At(1))->GetString();
 
 
-      if (tmp.Contains("transv")) 
-      {
-       // set transverse connector
-       Int_t blankPos = tmp.Last(' ');
+        TString sDDL = ((TObjString*)stringList->At(2))->GetString();
+        Int_t  iDDL  = atoi(sDDL.Data());
 
-       TString transv(tmp(blankPos+1, tmp.Length()-blankPos));
-       transv.ToUpper();
-       if (transv.CompareTo("NONE") == 0)
-           board->SetTC(false);
-      }
+        if ( iDDL < 0 || iDDL >= fgkNofDDLs ) {
+            AliErrorStream() << "DDL id "<< iDDL << " outside limits." << endl;
+            return false;
+        }
 
-      if (tmp.Contains("Switch")) 
-      {
-       list.Reset();
-       in.getline(line, 255);// skip one line
+        AliDebugStream(3)
+        << "idDE " << idDE << " buspatch " << busPatch.Data() << " iDDL " << iDDL
+        << endl;
 
-       in.getline(line, 255);
-       TString tmp(AliMpHelper::Normalize(line));
+        // reading 1st manu Id for each bus patch (station 1 & 2)
+        if(AliMpDEManager::GetStationType(idDE) != AliMp::kStation345) {
 
-       // decode switches
-       AliMpHelper::DecodeName(tmp,' ',list);
+            TString sManu = ((TObjString*)stringList->At(3))->GetString();
+            AliMpHelper::DecodeName(sManu,',',fManuList12[GetManuListIndex(idDE)]);
 
-       // store switches
-       AliMpArrayI switches;
+            if(AliMpDEManager::GetStationType(idDE) == AliMp::kStation2) {
+                TString sManuBridge = ((TObjString*)stringList->At(4))->GetString();
+                AliMpHelper::DecodeName(sManuBridge,',',fManuBridge2[GetManuListIndex(idDE)]);
+            }
 
-       for (Int_t i = 0; i < list.GetSize(); ++i)
-           board->AddSwitch(list[i]);
+        }
 
-       // add local board into map
-       fLocalBoards.Add(board->GetId(), board);
+        delete stringList;
 
-      }
+        AliMpDDL* ddl = GetDDL(iDDL, false);
+        if ( !ddl) {
+            ddl = new AliMpDDL(iDDL);
+            fDDLs.AddAt(ddl, iDDL);
+        }
+        ddl->AddDE(idDE);
+
+        TArrayI busPatchList;
+        // decoding range of buspatch
+        AliMpHelper::DecodeName(busPatch,';',busPatchList);
+
+        // Update DE
+        AliMpDetElement* de = AliMpDEManager::GetDetElement(idDE);
+        de->SetDdlId(iDDL);
+        // filling buspatch -> idDE
+        for (Int_t i = 0; i < busPatchList.GetSize(); i++) {
+            fBusPatches.Add(busPatchList[i],
+                            new AliMpBusPatch(busPatchList[i], idDE, iDDL));
+            de->AddBusPatch(busPatchList[i]);
+        }
+    }
+
+    // Fill bus patch Ids array in DDLs now
+    for ( Int_t i=0; i<fDDLs.GetEntriesFast(); i++ ) {
+        AliMpDDL* ddl = (AliMpDDL*) fDDLs.At(i);
+        ddl->FillBusPatchIds();
     }
+
+    in.close();
+    return true;
+}
+//______________________________________________________________________________
+Bool_t  AliMpDDLStore::ReadTriggerDDLs() 
+{
+    /// create trigger DDL object and Global crate object
+  
+  if (!ReadGlobalTrigger(*fGlobalCrate)) return false;
+  if (!ReadLocalTrigger()) return false;
+  
+  return true;
+}
+
+//______________________________________________________________________________
+Bool_t  AliMpDDLStore::ReadLocalTrigger() 
+{
+    /// create trigger DDL object ddl<->Crate<->local board
+  
+    ReadGlobalTrigger(*fGlobalCrate);
     
-    // set copy card number to where the X-Y inputs are copied and
-    // from where the X-Y inputs come.
-    // deleting the first item (TString) done by AliMpStringObjMap itself
-    // keep AliMpLocalBoard object undelete
+    Int_t iDDL = -1;
 
-    TString value;
+    TString infile = AliMpFiles::LocalTriggerBoardMapping();
 
-    for (inputXfromMap.First(); !inputXfromMap.IsDone(); inputXfromMap.Next()) {
-      
-      value = inputXfromMap.CurrentKey();
-      AliMpLocalBoard* boardFrom = (AliMpLocalBoard*)inputXfromMap.CurrentItem();
-      AliMpLocalBoard* boardTo   = (AliMpLocalBoard*)inputXtoMap.Get(value);
-      boardFrom->SetInputXto(boardTo->GetId());
-      boardTo->SetInputXfrom(boardFrom->GetId());
-      AliDebug(3, Form("copy xInputs from local id %d_%s_%d to %d_%s_%d\n", 
-                      boardTo->GetInputXfrom(), boardFrom->GetCrate().Data(), boardFrom->GetSlot(),
-                      boardFrom->GetInputXto(), boardTo->GetCrate().Data(), boardTo->GetSlot()));
+    ifstream in(infile, ios::in);
+
+    if (!in) {
+        AliError(Form("Local Trigger Board Mapping File %s not found", infile.Data()));
+        return kFALSE;
     }
 
-    for (inputYfromMap.First(); !inputYfromMap.IsDone(); inputYfromMap.Next()) {
+    AliMpLocalBoard* board = 0x0;
+    AliMpTriggerCrate* crate = 0x0;
 
-      value = inputYfromMap.CurrentKey();
-      AliMpLocalBoard* boardFrom = (AliMpLocalBoard*)inputYfromMap.CurrentItem();
-      AliMpLocalBoard* boardTo   = (AliMpLocalBoard*)inputYtoMap.Get(value);
-      boardFrom->SetInputYto(boardTo->GetId());
-      boardTo->SetInputYfrom(boardFrom->GetId());
-      AliDebug(3, Form("copy yInputs from local id %d_%s_%d to %d_%s_%d\n", 
-                      boardTo->GetInputYfrom(), boardFrom->GetCrate().Data(), boardFrom->GetSlot(),
-                      boardFrom->GetInputYto(), boardTo->GetCrate().Data(), boardTo->GetSlot()));
-    }
 
+    Int_t localBoardId = 0;
+    TArrayI list;
+    UShort_t crateId, mask;
+    Int_t mode, coincidence;
+    
+    char line[80];
+   
+    while (!in.eof())
+    {
+    in.getline(line,80);
+    if (!strlen(line)) break;
+    TString crateName(AliMpHelper::Normalize(line));
+      
+    in.getline(line,80);    
+    sscanf(line,"%hx",&crateId);
+
+    in.getline(line,80);
+    sscanf(line,"%d",&mode);
+    
+    in.getline(line,80);
+    sscanf(line,"%d",&coincidence);
+    
+    in.getline(line,80);
+    sscanf(line,"%hx",&mask);
+    
+    // determine ddl number vs crate side
+    if (crateName.Contains("R"))
+      iDDL = fgkNofDDLs; // starts where tracker ends
+    else
+      iDDL = fgkNofDDLs + 1;
+
+    AliMpDDL* ddl = GetDDL(iDDL, false);
+    if ( !ddl) {
+      ddl = new AliMpDDL(iDDL);
+      fDDLs.AddAt(ddl, iDDL);
+    }
+    if (!GetTriggerCrate(crateName.Data(), false)) {
+      crate = new AliMpTriggerCrate(crateName.Data(), crateId, mask, mode, coincidence);
+      crate->SetDdlId(iDDL);
+      fTriggerCrates.Add(crateName.Data(), crate);
+    }
+    
+    // add trigger crate number for given ddl if not present
+    if ( !ddl->HasTriggerCrateId(crateId) )
+      ddl->AddTriggerCrate(crateId);
+    
+    
+    Char_t localBoardName[20];
+    Int_t slot;
+    UInt_t switches;
+    
+    for ( Int_t i = 0; i < AliMpConstants::LocalBoardNofChannels(); ++i ) 
+    {
+      if ( (mask >> i ) & 0x1 )
+      {
+        in.getline(line,80);
+        sscanf(line,"%02d %s %03d %03x",&slot,localBoardName,&localBoardId,&switches);
+        board = new AliMpLocalBoard(localBoardId, localBoardName, slot); 
+        board->SetSwitch(switches);
+        board->SetCrate(crateName);
+        
+        if (localBoardId > AliMpConstants::NofLocalBoards())
+          board->SetNotified(false); // copy cards
+        
+        crate->AddLocalBoard(localBoardId);
+        
+        list.Reset();
+        AliMpDDL* ddl = GetDDL(iDDL, true);
+  
+        // add  DE for local board and DDL
+        in.getline(line,80);
+        TString tmp(AliMpHelper::Normalize(line));
+        AliMpHelper::DecodeName(tmp,' ',list);
+  
+        for (Int_t i = 0; i < list.GetSize(); ++i) {
+  
+          if (list[i]) { // skip copy card
+            AliMpDetElement* de = AliMpDEManager::GetDetElement(list[i]);
+            if (de->GetDdlId() == -1)
+              de->SetDdlId(iDDL);
+          }
+          board->AddDE(list[i]);
+          if(!ddl->HasDEId(list[i]))
+            ddl->AddDE(list[i]);
+        }
+        
+        // set copy number and transverse connector
+        in.getline(line,80);
+        tmp = AliMpHelper::Normalize(line);
+        AliMpHelper::DecodeName(tmp,' ',list);
+  
+        board->SetInputXfrom(list[0]);
+        board->SetInputXto(list[1]);
+        
+        board->SetInputYfrom(list[2]);
+        board->SetInputYto(list[3]);
+        
+        board->SetTC(list[4]);
+        
+        // add local board into map
+        fLocalBoards.Add(board->GetId(), board);
+      }
+    }
+  
+  }
     return kTRUE;
 }
 
 //______________________________________________________________________________
-Bool_t AliMpDDLStore::SetManus()
-{
-/// Set manus for each bus patch
+Bool_t AliMpDDLStore::SetManus() {
+    /// Set manus for each bus patch
 
     Int_t manuMask = AliMpConstants::ManuMask(AliMp::kNonBendingPlane) - 1;
 
-    // loop over DDL 
+    // loop over DDL
     for (Int_t iDDL = 0; iDDL < fgkNofDDLs; ++iDDL) {
 
-      AliDebug(3, Form("DDL # %d\n", iDDL));
+        AliDebug(3, Form("DDL # %d\n", iDDL));
 
-      AliMpDDL* ddl = GetDDL(iDDL);
+        AliMpDDL* ddl = GetDDL(iDDL);
 
-      // loop over DE in the given DDL
-      for (Int_t detElemIdx = 0; detElemIdx < ddl->GetNofDEs(); ++detElemIdx) {
+        // loop over DE in the given DDL
+        for (Int_t detElemIdx = 0; detElemIdx < ddl->GetNofDEs(); ++detElemIdx) {
 
-       Int_t detElemId = ddl->GetDEId(detElemIdx);
+            Int_t detElemId = ddl->GetDEId(detElemIdx);
 
-       AliMpDetElement* detElement = GetDetElement(detElemId);
+            AliMpDetElement* detElement = GetDetElement(detElemId);
 
-       AliMp::StationType stationType = AliMpDEManager::GetStationType(detElemId);
+            AliMp::StationType stationType = AliMpDEManager::GetStationType(detElemId);
 
 
-       // list of manu per DE on both cathode
-       TList manuList;
-       for ( Int_t cath = 0; cath < 2 ; ++cath ) {
-         const AliMpVSegmentation* seg 
-             = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,AliMp::GetCathodType(cath));
-        
-         AliMp::PlaneType planeType = detElement->GetPlaneType(AliMp::GetCathodType(cath));
+            // list of manu per DE on both cathode
+            TList manuList;
+            for ( Int_t cath = 0; cath < 2 ; ++cath ) {
+                const AliMpVSegmentation* seg
+                = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,AliMp::GetCathodType(cath));
 
-         TArrayI manus;
-         seg->GetAllElectronicCardIDs(manus);
-          
-         // filling TList manu
-         for ( Int_t im = 0; im < manus.GetSize(); ++im ) {
-      
-           AliMpIntPair* manu = 0x0;
-           if( stationType == AliMp::kStation345) 
-        manu = new AliMpIntPair((manus[im] & manuMask), planeType, kTRUE); //remove offset for NB
-           else 
-        manu = new AliMpIntPair(manus[im], planeType, kTRUE); //keep offset for NB
-           
-           manuList.Add(manu);
-      
-      detElement->AddManu(manus[im]);
-         }        
-       }// cathode
-  
-       manuList.Sort(); // sort regardless B or NB plane
+                AliMp::PlaneType planeType = detElement->GetPlaneType(AliMp::GetCathodType(cath));
 
-       // filling manu to the corresponding buspatch
-       for (Int_t iEntry = 0; iEntry < manuList.GetEntries(); ++iEntry) {
+                TArrayI manus;
+                seg->GetAllElectronicCardIDs(manus);
 
-         AliMpIntPair* manuPtr = (AliMpIntPair*)manuList.At(iEntry);
+                // filling TList manu
+                for ( Int_t im = 0; im < manus.GetSize(); ++im ) {
 
-         Int_t manuId = manuPtr->GetFirst();
-         Int_t pos    = GetBusPatchIndex(detElemId, manuId);
+                    AliMpIntPair* manu = 0x0;
+                    if( stationType == AliMp::kStation345)
+                        manu = new AliMpIntPair((manus[im] & manuMask), planeType, kTRUE); //remove offset for NB
+                    else
+                        manu = new AliMpIntPair(manus[im], planeType, kTRUE); //keep offset for NB
 
-         if (pos > detElement->GetNofBusPatches()) {
-           AliError(Form("pos greater %d than size %d manuId %d detElemId %d \n", 
-                         pos, detElement->GetNofBusPatches(), manuId, detElemId));
-           return false;
-         }
-         
-         // get buspatch and fill manus
-         Int_t busPatchId = detElement->GetBusPatchId(pos);
-         AliMpBusPatch* busPatch = GetBusPatch(busPatchId);
+                    manuList.Add(manu);
 
-         if( stationType == AliMp::kStation345) {
-      
-           if (manuPtr->GetSecond()) 
-        busPatch->AddManu(manuId+manuMask+1); // add offset again after sorted
-           else 
-        busPatch->AddManu(manuId); 
-      
-         } else {
-      
-           busPatch->AddManu(manuId); 
-      
-         }
-       }
+                    detElement->AddManu(manus[im]);
+                }
+            }// cathode
+
+            manuList.Sort(); // sort regardless B or NB plane
 
-       manuList.Delete();
+            // filling manu to the corresponding buspatch
+            for (Int_t iEntry = 0; iEntry < manuList.GetEntries(); ++iEntry) {
 
-       if (AliDebugLevel() == 3) {
+                AliMpIntPair* manuPtr = (AliMpIntPair*)manuList.At(iEntry);
 
-         // print out for checking
-         for(Int_t pos = 0; pos < detElement->GetNofBusPatches(); ++pos) {
-           Int_t busPatchId = detElement->GetBusPatchId(pos);
-           AliMpBusPatch* busPatch = GetBusPatch(busPatchId);
-           printf("BusPatch: %d\n", busPatch->GetId());
-           for (Int_t iEntry = 0; iEntry < busPatch->GetNofManus(); ++iEntry) 
-               printf("manu Id: %d\n", busPatch->GetManuId(iEntry));
-         }
-       }
+                Int_t manuId = manuPtr->GetFirst();
+                Int_t pos    = GetBusPatchIndex(detElemId, manuId);
 
-      } // detection element loop
+                if (pos > detElement->GetNofBusPatches()) {
+                    AliError(Form("pos greater %d than size %d manuId %d detElemId %d \n",
+                                  pos, detElement->GetNofBusPatches(), manuId, detElemId));
+                    return false;
+                }
+
+                // get buspatch and fill manus
+                Int_t busPatchId = detElement->GetBusPatchId(pos);
+                AliMpBusPatch* busPatch = GetBusPatch(busPatchId);
+
+                if( stationType == AliMp::kStation345) {
+
+                    if (manuPtr->GetSecond())
+                        busPatch->AddManu(manuId+manuMask+1); // add offset again after sorted
+                    else
+                        busPatch->AddManu(manuId);
+
+                } else {
+
+                    busPatch->AddManu(manuId);
+
+                }
+            }
+
+            manuList.Delete();
+
+            if (AliDebugLevel() == 3) {
+
+                // print out for checking
+                for(Int_t pos = 0; pos < detElement->GetNofBusPatches(); ++pos) {
+                    Int_t busPatchId = detElement->GetBusPatchId(pos);
+                    AliMpBusPatch* busPatch = GetBusPatch(busPatchId);
+                    printf("BusPatch: %d\n", busPatch->GetId());
+                    for (Int_t iEntry = 0; iEntry < busPatch->GetNofManus(); ++iEntry)
+                        printf("manu Id: %d\n", busPatch->GetManuId(iEntry));
+                }
+            }
+
+        } // detection element loop
     }// DDL loop
 
     return true;
 }
 
 //______________________________________________________________________________
-Bool_t AliMpDDLStore::SetPatchModules()
-{
-/// Compute the number of manu per PCB for each buspatch 
+Bool_t AliMpDDLStore::SetPatchModules() {
+    /// Compute the number of manu per PCB for each buspatch
 
     AliMpDEIterator it;
     Bool_t result = true;
 
     for ( it.First(); !it.IsDone(); it.Next() ) {
 
-      AliMpDetElement* detElement = it.CurrentDE();
-      
-      for (Int_t i = 0; i < detElement->GetNofBusPatches(); ++i) {
-       AliMpBusPatch* busPatch = GetBusPatch(detElement->GetBusPatchId(i));
-       Bool_t newResult = false;
-       Int_t idDE = busPatch->GetDEId();
-
-       if (AliMpDEManager::GetStationType(idDE) == AliMp::kStation2 ) 
-           newResult = busPatch->SetNofManusPerModule(fManuBridge2[GetManuListIndex(idDE)].At(i));
-       else 
-           newResult = busPatch->SetNofManusPerModule();
-      }
+        AliMpDetElement* detElement = it.CurrentDE();
+
+        for (Int_t i = 0; i < detElement->GetNofBusPatches(); ++i) {
+            AliMpBusPatch* busPatch = GetBusPatch(detElement->GetBusPatchId(i));
+            Bool_t newResult = false;
+            Int_t idDE = busPatch->GetDEId();
+
+            if (AliMpDEManager::GetStationType(idDE) == AliMp::kStation2 )
+                newResult = busPatch->SetNofManusPerModule(fManuBridge2[GetManuListIndex(idDE)].At(i));
+            else
+                newResult = busPatch->SetNofManusPerModule();
+        }
     }
 
     return result;
 }
 
 //______________________________________________________________________________
-Bool_t AliMpDDLStore::SetBusPatchLength()
-{
-/// read the buspatch length file and set buspatch length 
+Bool_t AliMpDDLStore::SetBusPatchLength() {
+    /// read the buspatch length file and set buspatch length
 
     TString infile = AliMpFiles::BusPatchLengthFilePath();
     ifstream in(infile, ios::in);
     if (!in) {
-      AliErrorStream() << "Data file " << infile << " not found.";
-      return false;
-    }  
+        AliErrorStream() << "Data file " << infile << " not found.";
+        return false;
+    }
     char line[255];
 
     for (Int_t iDDL = 0; iDDL < fgkNofDDLs; ++iDDL ) {
-      AliMpDDL* ddl = GetDDL(iDDL);
+        AliMpDDL* ddl = GetDDL(iDDL);
 
-      for (Int_t iBusPatch = 0; iBusPatch < ddl->GetNofBusPatches(); ++iBusPatch) {
-  
-       do {
-         if (!in.getline(line,255)) {
-           AliWarning(Form("Wrong size in bus patch length file; index %d DDL %d", 
-                           iBusPatch, iDDL));
-           return false;
-         }
-       } while(line[0] == '#');
+        for (Int_t iBusPatch = 0; iBusPatch < ddl->GetNofBusPatches(); ++iBusPatch) {
 
-       TString tmp(AliMpHelper::Normalize(line));
+            do {
+                if (!in.getline(line,255)) {
+                    AliWarning(Form("Wrong size in bus patch length file; index %d DDL %d",
+                                    iBusPatch, iDDL));
+                    return false;
+                }
+            } while(line[0] == '#');
 
-       TObjArray* stringList = tmp.Tokenize(TString(" "));
-       
-       TString sLocalBusId = ((TObjString*)stringList->At(0))->GetString();
-       Int_t   localBusId  = sLocalBusId.Atoi();
+            TString tmp(AliMpHelper::Normalize(line));
 
-       TString sLength = ((TObjString*)stringList->At(1))->GetString();
-       Float_t length  = sLength.Atof();
+            TObjArray* stringList = tmp.Tokenize(TString(" "));
 
-       delete stringList;
+            TString sLocalBusId = ((TObjString*)stringList->At(0))->GetString();
+            Int_t   localBusId  = sLocalBusId.Atoi();
 
-       if (localBusId != iBusPatch + 1)
-           AliWarning(Form("Wrong local buspatch id %d instead of %d", iBusPatch+1, localBusId));
+            TString sLength = ((TObjString*)stringList->At(1))->GetString();
+            Float_t length  = sLength.Atof();
 
-       Int_t busPatchId = ddl->GetBusPatchId(iBusPatch);
-       AliMpBusPatch* busPatch = GetBusPatch(busPatchId);
-       busPatch->SetCableLength(length);
-      }
+            delete stringList;
+
+            if (localBusId != iBusPatch + 1)
+                AliWarning(Form("Wrong local buspatch id %d instead of %d", iBusPatch+1, localBusId));
+
+            Int_t busPatchId = ddl->GetBusPatchId(iBusPatch);
+            AliMpBusPatch* busPatch = GetBusPatch(busPatchId);
+            busPatch->SetCableLength(length);
+        }
     }
 
     return true;
@@ -706,19 +809,18 @@ Bool_t AliMpDDLStore::SetBusPatchLength()
 
 
 //________________________________________________________________
-Int_t AliMpDDLStore::GetLocalBoardId(TString name) const
-{
-/// return the first board with a given side and line
+Int_t AliMpDDLStore::GetLocalBoardId(TString name) const {
+    /// return the first board with a given side and line
 
-   TExMapIter i = fLocalBoards.GetIterator();
+    TExMapIter i = fLocalBoards.GetIterator();
     Long_t key, value;
     while ( i.Next(key, value) ) {
-      AliMpLocalBoard* local = (AliMpLocalBoard*)value;
+        AliMpLocalBoard* local = (AliMpLocalBoard*)value;
 
-      TString tmp(&local->GetName()[4], 2);
-      if (name.Contains(tmp))
-         if (name[0] == local->GetName()[0])
-             return local->GetId();
+        TString tmp(&local->GetName()[4], 2);
+        if (name.Contains(tmp))
+            if (name[0] == local->GetName()[0])
+                return local->GetId();
     }
 
     return 0;
@@ -731,224 +833,211 @@ Int_t AliMpDDLStore::GetLocalBoardId(TString name) const
 
 
 //______________________________________________________________________________
-AliMpDDL* AliMpDDLStore::GetDDL(Int_t ddlId, Bool_t warn) const
-{
-/// Return DDL for given ddlId
+AliMpDDL* AliMpDDLStore::GetDDL(Int_t ddlId, Bool_t warn) const {
+    /// Return DDL for given ddlId
 
-  AliMpDDL* ddl 
+    AliMpDDL* ddl
     = (AliMpDDL*)fDDLs.At(ddlId);
-    
-  if ( ! ddl && warn ) {  
-    AliErrorStream() 
+
+    if ( ! ddl && warn ) {
+        AliErrorStream()
         << "DDL with Id = " << ddlId << " not defined." << endl;
-  }    
+    }
 
-  return ddl;
-}    
+    return ddl;
+}
 
 //______________________________________________________________________________
-AliMpDetElement*  AliMpDDLStore::GetDetElement(Int_t detElemId, Bool_t warn) const
-{
-/// Return detection element with given detElemId
+AliMpDetElement*  AliMpDDLStore::GetDetElement(Int_t detElemId, Bool_t warn) const {
+    /// Return detection element with given detElemId
 
-  if ( ! AliMpDEStore::Instance() ) {
-    AliFatal("DE Store has not been loaded.");
-    return 0; 
-  }  
+    if ( ! AliMpDEStore::Instance() ) {
+        AliFatal("DE Store has not been loaded.");
+        return 0;
+    }
 
-  return AliMpDEStore::Instance()->GetDetElement(detElemId, warn);
-}  
+    return AliMpDEStore::Instance()->GetDetElement(detElemId, warn);
+}
 
 //______________________________________________________________________________
-AliMpBusPatch* AliMpDDLStore::GetBusPatch(Int_t busPatchId, Bool_t warn) const
-{
-/// Return bus patch with given Id
+AliMpBusPatch* AliMpDDLStore::GetBusPatch(Int_t busPatchId, Bool_t warn) const {
+    /// Return bus patch with given Id
 
-  AliMpBusPatch* busPatch
+    AliMpBusPatch* busPatch
     = (AliMpBusPatch*) fBusPatches.GetValue(busPatchId);
-    
-  if ( ! busPatch && warn ) {  
-    AliErrorStream() 
+
+    if ( ! busPatch && warn ) {
+        AliErrorStream()
         << "Bus patch with Id = " << busPatchId << " not defined." << endl;
-  }    
+    }
 
-  return busPatch;
-}    
+    return busPatch;
+}
 
 //______________________________________________________________________________
-AliMpLocalBoard* AliMpDDLStore::GetLocalBoard(Int_t localBoardId, Bool_t warn) const
-{
-/// Return bus patch with given Id
+AliMpLocalBoard* AliMpDDLStore::GetLocalBoard(Int_t localBoardId, Bool_t warn) const {
+    /// Return bus patch with given Id
 
-  AliMpLocalBoard* localBoard
+    AliMpLocalBoard* localBoard
     = (AliMpLocalBoard*) fLocalBoards.GetValue(localBoardId);
-    
-  if ( ! localBoard && warn ) {  
-    AliErrorStream() 
+
+    if ( ! localBoard && warn ) {
+        AliErrorStream()
         << "Local board with Id = " << localBoardId << " not defined." << endl;
-  }    
+    }
 
-  return localBoard;
-}    
+    return localBoard;
+}
 
 //______________________________________________________________________________
-AliMpTriggerCrate* AliMpDDLStore::GetTriggerCrate(TString name, Bool_t warn) const
-{
-/// Return trigger crate with given name
+AliMpTriggerCrate* AliMpDDLStore::GetTriggerCrate(TString name, Bool_t warn) const {
+    /// Return trigger crate with given name
 
-  AliMpTriggerCrate* crate
-     = (AliMpTriggerCrate*) fTriggerCrates.GetValue(name.Data());
-    
-  if ( ! crate && warn ) {  
-    AliErrorStream() 
+    AliMpTriggerCrate* crate
+    = (AliMpTriggerCrate*) fTriggerCrates.GetValue(name.Data());
+
+    if ( ! crate && warn ) {
+        AliErrorStream()
         << "Trigger crate with name = " << name.Data() << " not defined." << endl;
-  }    
+    }
 
-  return crate;
-}  
+    return crate;
+}
 
 //______________________________________________________________________________
-AliMpTriggerCrate* AliMpDDLStore::GetTriggerCrate(Int_t ddlId, Int_t index, Bool_t warn) const
-{
-/// Return trigger crate with given ddl and index crate
+AliMpTriggerCrate* AliMpDDLStore::GetTriggerCrate(Int_t ddlId, Int_t index, Bool_t warn) const {
+    /// Return trigger crate with given ddl and index crate
 
-  if (ddlId == 0 || ddlId == 1)
-      ddlId += fgkNofDDLs;
+    if (ddlId == 0 || ddlId == 1)
+        ddlId += fgkNofDDLs;
 
-  AliMpDDL* ddl = GetDDL(ddlId, warn);
-  if ( ! ddl ) return 0; 
-  
-  if ( index >= ddl->GetNofTriggerCrates() ) {
-      AliError(Form("crate id %d greater than array[%d]", index, ddl->GetNofTriggerCrates()));
-      return 0;
-  }    
-   
-  Int_t crateId = ddl->GetTriggerCrateId(index);
-  TString name = AliMpTriggerCrate::GenerateName(crateId, ddlId, fgkNofDDLs);
-  
-  return GetTriggerCrate(name, warn);
-}  
+    AliMpDDL* ddl = GetDDL(ddlId, warn);
+    if ( ! ddl )
+        return 0;
+
+    if ( index >= ddl->GetNofTriggerCrates() ) {
+        AliError(Form("crate id %d greater than array[%d]", index, ddl->GetNofTriggerCrates()));
+        return 0;
+    }
+
+    TString name = AliMpTriggerCrate::GenerateName(index, ddlId, fgkNofDDLs);
+
+    return GetTriggerCrate(name, warn);
+}
 
 //______________________________________________________________________________
-Int_t  AliMpDDLStore::GetDEfromBus(Int_t busPatchId) const
-{
-/// Return detection element Id for given busPatchId
+Int_t  AliMpDDLStore::GetDEfromBus(Int_t busPatchId) const {
+    /// Return detection element Id for given busPatchId
 
-  AliMpBusPatch* busPatch = GetBusPatch(busPatchId);
-  
-  if ( ! busPatch ) {
-    AliErrorStream() 
+    AliMpBusPatch* busPatch = GetBusPatch(busPatchId);
+
+    if ( ! busPatch ) {
+        AliErrorStream()
         << "Bus patch with Id = " << busPatchId << " not defined." << endl;
-    return 0;    
-  }    
+        return 0;
+    }
 
-  return busPatch->GetDEId();
-}  
+    return busPatch->GetDEId();
+}
 
 //______________________________________________________________________________
-Int_t  AliMpDDLStore::GetDEfromLocalBoard(Int_t localBoardId, Int_t chamberId) const
-{
-/// Return detElemId for local board Id and chamber id.
+Int_t  AliMpDDLStore::GetDEfromLocalBoard(Int_t localBoardId, Int_t chamberId) const {
+    /// Return detElemId for local board Id and chamber id.
 
-  AliMpLocalBoard* localBoard = GetLocalBoard(localBoardId);
-  
-  if ( ! localBoard ) {
-    AliErrorStream() 
+    AliMpLocalBoard* localBoard = GetLocalBoard(localBoardId);
+
+    if ( ! localBoard ) {
+        AliErrorStream()
         << "Loacl board with Id = " << localBoardId << " not defined." << endl;
-    return 0;    
-  }    
+        return 0;
+    }
 
-   return localBoard->GetDEIdByChamber(chamberId);
+    return localBoard->GetDEIdByChamber(chamberId);
 }
 
 //______________________________________________________________________________
-Int_t  AliMpDDLStore::GetDDLfromBus(Int_t busPatchId) const
-{
-/// Return DDL Id for given busPatchId
+Int_t  AliMpDDLStore::GetDDLfromBus(Int_t busPatchId) const {
+    /// Return DDL Id for given busPatchId
 
-  AliMpBusPatch* busPatch = GetBusPatch(busPatchId);
-  
-  if ( ! busPatch ) {
-    AliErrorStream() 
+    AliMpBusPatch* busPatch = GetBusPatch(busPatchId);
+
+    if ( ! busPatch ) {
+        AliErrorStream()
         << "Bus patch with Id = " << busPatchId << " not defined." << endl;
-    return 0;    
-  }    
+        return 0;
+    }
 
-  return busPatch->GetDdlId();
-}  
+    return busPatch->GetDdlId();
+}
 
 //______________________________________________________________________________
-Int_t AliMpDDLStore::GetBusPatchId(Int_t detElemId, Int_t manuId) const
-{
-/// Return bus patch for a given manuId
-
-  AliMpDetElement* detElement = GetDetElement(detElemId);
-  Int_t pos = GetBusPatchIndex(detElemId, manuId);
-
-  if ( pos > detElement->GetNofBusPatches() ) {
-    AliErrorStream() 
-      << "Pos = " << pos 
-      << " greater than the size = " <<  detElement->GetNofBusPatches()
-      << " for detElemId = " << detElemId 
-      << " manuId = " << manuId << endl;
-    return -1;
-  }
+Int_t AliMpDDLStore::GetBusPatchId(Int_t detElemId, Int_t manuId) const {
+    /// Return bus patch for a given manuId
+
+    AliMpDetElement* detElement = GetDetElement(detElemId);
+    Int_t pos = GetBusPatchIndex(detElemId, manuId);
+
+    if ( pos > detElement->GetNofBusPatches() ) {
+        AliErrorStream()
+        << "Pos = " << pos
+        << " greater than the size = " <<  detElement->GetNofBusPatches()
+        << " for detElemId = " << detElemId
+        << " manuId = " << manuId << endl;
+        return -1;
+    }
 
-  return detElement->GetBusPatchId(pos);
-}    
+    return detElement->GetBusPatchId(pos);
+}
 
 //______________________________________________________________________________
-AliMpIntPair  AliMpDDLStore::GetDetElemIdManu(Int_t manuSerial) const
-{
-/// Return the detElemId and manuId for given serial manu number
+AliMpIntPair  AliMpDDLStore::GetDetElemIdManu(Int_t manuSerial) const {
+    /// Return the detElemId and manuId for given serial manu number
 
-  if ( ! AliMpDEStore::Instance() ) {
-    AliFatal("DE Store has not been loaded.");
-    return AliMpIntPair::Invalid(); 
-  }  
+    if ( ! AliMpDEStore::Instance() ) {
+        AliFatal("DE Store has not been loaded.");
+        return AliMpIntPair::Invalid();
+    }
 
-  return AliMpDEStore::Instance()->GetDetElemIdManu(manuSerial);
-}  
+    return AliMpDEStore::Instance()->GetDetElemIdManu(manuSerial);
+}
 
 //______________________________________________________________________________
-void AliMpDDLStore::PrintAllManu() const
-{
-/// Print all manu Ids and their serial numbers sorted by detection element
-/// and bus patch.                                                            \n
-/// As serial manu numbers are filled in a different way than manu Ids this
-/// printing allows to check that both ways are consistent
-
-  // Loop over DE
-  AliMpDEIterator it;
-  for ( it.First(); ! it.IsDone(); it.Next() ) {
-     AliMpDetElement* de = it.CurrentDE();
-     cout << "DE: " << de->GetId() << endl; 
-     
-     // Loop over bus patches in this DE
-     for ( Int_t i=0; i< de->GetNofBusPatches(); ++i ) {
-
-       AliMpBusPatch* busPatch = GetBusPatch(de->GetBusPatchId(i));    
-       cout << "  busPatch: " << busPatch->GetId() << endl; 
-
-       cout << "    Manu       : ";
-       for ( Int_t j=0; j<busPatch->GetNofManus(); ++j ) {
-         cout << std::setw(6) << busPatch->GetManuId(j) << " ";
-       }
-       cout << endl;
-       
-       cout << "    Manu serial: ";
-       for ( Int_t k=0; k<busPatch->GetNofManus(); ++k ) {
-         cout << std::setw(6) << de->GetManuSerialFromId(busPatch->GetManuId(k)) << " ";
-       }        
-       cout << endl;
-     }
-  }
-}  
+void AliMpDDLStore::PrintAllManu() const {
+    /// Print all manu Ids and their serial numbers sorted by detection element
+    /// and bus patch.                                                            \n
+    /// As serial manu numbers are filled in a different way than manu Ids this
+    /// printing allows to check that both ways are consistent
+
+    // Loop over DE
+    AliMpDEIterator it;
+    for ( it.First(); ! it.IsDone(); it.Next() ) {
+        AliMpDetElement* de = it.CurrentDE();
+        cout << "DE: " << de->GetId() << endl;
+
+        // Loop over bus patches in this DE
+        for ( Int_t i=0; i< de->GetNofBusPatches(); ++i ) {
+
+            AliMpBusPatch* busPatch = GetBusPatch(de->GetBusPatchId(i));
+            cout << "  busPatch: " << busPatch->GetId() << endl;
+
+            cout << "    Manu       : ";
+            for ( Int_t j=0; j<busPatch->GetNofManus(); ++j ) {
+                cout << std::setw(6) << busPatch->GetManuId(j) << " ";
+            }
+            cout << endl;
+
+            cout << "    Manu serial: ";
+            for ( Int_t k=0; k<busPatch->GetNofManus(); ++k ) {
+                cout << std::setw(6) << de->GetManuSerialFromId(busPatch->GetManuId(k)) << " ";
+            }
+            cout << endl;
+        }
+    }
+}
 
 //________________________________________________________________
-Int_t  AliMpDDLStore::GetNextDEfromLocalBoard(Int_t localBoardId, Int_t chamberId ) const
-{
-/// return the next detection element in line
+Int_t  AliMpDDLStore::GetNextDEfromLocalBoard(Int_t localBoardId, Int_t chamberId ) const {
+    /// return the next detection element in line
 
     AliMpLocalBoard* localBoard  =  GetLocalBoard(localBoardId);
 
@@ -956,22 +1045,21 @@ Int_t  AliMpDDLStore::GetNextDEfromLocalBoard(Int_t localBoardId, Int_t chamberI
 
     Int_t line = localBoard->GetPosition().GetFirst();
     ++line;
-    
+
     name.Replace(4,1,Form("%d", line));
 
-   Int_t nextLocalId;
+    Int_t nextLocalId;
     if ((nextLocalId = GetLocalBoardId(name)))
-       return GetDEfromLocalBoard(nextLocalId, chamberId);
+        return GetDEfromLocalBoard(nextLocalId, chamberId);
     else
-       return 0;
+        return 0;
 
     return 0;
 }
 
 //________________________________________________________________
-Int_t  AliMpDDLStore::GetPreviousDEfromLocalBoard(Int_t localBoardId, Int_t chamberId) const
-{
-/// return the previous detection element in line
+Int_t  AliMpDDLStore::GetPreviousDEfromLocalBoard(Int_t localBoardId, Int_t chamberId) const {
+    /// return the previous detection element in line
 
     AliMpLocalBoard* localBoard  =  GetLocalBoard(localBoardId);
 
@@ -979,14 +1067,14 @@ Int_t  AliMpDDLStore::GetPreviousDEfromLocalBoard(Int_t localBoardId, Int_t cham
 
     Int_t line = localBoard->GetPosition().GetFirst();
     --line;
-    
+
     name.Replace(4,1,Form("%d", line));
 
     Int_t prevLocalId;
     if ((prevLocalId = GetLocalBoardId(name)))
-       return GetDEfromLocalBoard(prevLocalId, chamberId);
+        return GetDEfromLocalBoard(prevLocalId, chamberId);
     else
-       return 0;
+        return 0;
 
 }
 
index 2dcafe5..37cfa7e 100644 (file)
@@ -19,7 +19,7 @@
 
 #include "AliMpExMap.h"
 #include "AliMpIntPair.h"
-
+#include "AliMpGlobalCrate.h"
 #include <TObject.h>
 #include <TObjArray.h>
 #include <TArrayI.h>
@@ -30,6 +30,7 @@ class AliMpDetElement;
 class AliMpBusPatch;
 class AliMpLocalBoard;
 class AliMpTriggerCrate;
+
 class TArrayI;
 
 class AliMpDDLStore : public  TObject {
@@ -49,7 +50,9 @@ class AliMpDDLStore : public  TObject {
     AliMpLocalBoard*   GetLocalBoard(Int_t localBoardId, Bool_t warn = true) const;
     AliMpTriggerCrate* GetTriggerCrate(TString crateName, Bool_t warn = true) const;
     AliMpTriggerCrate* GetTriggerCrate(Int_t ddlId, Int_t index, Bool_t warn = true) const;
-
+    /// Get Global Crate object
+    AliMpGlobalCrate*  GetGlobalCrate() const {return fGlobalCrate;}
+    
     Int_t  GetDEfromBus(Int_t busPatchId) const;
     Int_t  GetDEfromLocalBoard(Int_t localBoardId, Int_t chamberId) const;
     Int_t  GetNextDEfromLocalBoard(Int_t localBoardId, Int_t chamberId) const;
@@ -67,10 +70,16 @@ class AliMpDDLStore : public  TObject {
     /// Get an iterator to loop over bus patches
     TExMapIter GetBusPatchesIterator() const { return fBusPatches.GetIterator(); }
     
+    /// read Global trigger crate file
+    static Bool_t ReadGlobalTrigger(AliMpGlobalCrate& crate, const Char_t* globalName = 0);
+       
+    /// Get detection elt and Manu number from serial number
     AliMpIntPair  GetDetElemIdManu(Int_t manuSerial) const;
 
+    /// print info of all manus
     void PrintAllManu() const;
 
+    
   private:
     AliMpDDLStore();
     /// Not implemented
@@ -83,6 +92,7 @@ class AliMpDDLStore : public  TObject {
     Int_t  GetBusPatchIndex(Int_t detElemId, Int_t manuId) const;
     Bool_t ReadDDLs();
     Bool_t ReadTriggerDDLs();
+    Bool_t ReadLocalTrigger();
     Bool_t SetManus();
     Bool_t SetPatchModules();
     Bool_t SetBusPatchLength();
@@ -100,8 +110,9 @@ class AliMpDDLStore : public  TObject {
     AliMpExMap    fLocalBoards;    ///< The map of local board per their ID
     TArrayI       fManuList12[16]; ///< Arrays of 1st manu in bus
     TArrayI       fManuBridge2[16]; ///< Arrays of manu number before the bridge in buspatch
-
-  ClassDef(AliMpDDLStore,2)  // The manager class for definition of detection element types
+    AliMpGlobalCrate* fGlobalCrate;  ///< Global Crate Object 
+        
+  ClassDef(AliMpDDLStore,3)  // The manager class for definition of detection element types
 };
 
 #endif //ALI_MP_DDL_STORE_H
index 87f081b..505e570 100755 (executable)
@@ -63,7 +63,8 @@ const TString AliMpFiles::fgkManuToSerial ="_manu";
 const TString AliMpFiles::fgkPadPosPrefix  = "padPos"; 
 const TString AliMpFiles::fgkDataExt = ".dat";      
 const TString AliMpFiles::fgkBergToGCFileName = "/bergToGC"; 
-const TString AliMpFiles::fgkTriggerLocalBoards = "crate";
+const TString AliMpFiles::fgkTriggerLocalBoards = "RegionalCrate";
+const TString AliMpFiles::fgkTriggerGlobalBoards = "GlobalCrate";
 const TString AliMpFiles::fgkBusPatchFileName = "DetElemIdToBusPatch";
 const TString AliMpFiles::fgkBusPatchLengthFileName = "BusPatchLength";
 //______________________________________________________________________________
@@ -192,6 +193,15 @@ TString AliMpFiles::LocalTriggerBoardMapping()
           + fgkTriggerLocalBoards + fgkDataExt;;
 }
 
+//______________________________________________________________________________
+TString AliMpFiles::GlobalTriggerBoardMapping()
+{
+/// Return path to data file with local trigger board mapping.
+
+  return GetTop() + fgkDataDir + StationDataDir(AliMp::kStationTrigger) 
+      + fgkTriggerGlobalBoards + fgkDataExt;;
+}
+
 //_____________________________________________________________________________
 TString AliMpFiles::SlatFilePath(AliMp::StationType stationType,
                                  const char* slatType,
index f3de52d..6bdb088 100755 (executable)
@@ -49,7 +49,8 @@ class AliMpFiles : public TObject
     // trigger
     //
     static TString LocalTriggerBoardMapping();
-  
+    static TString GlobalTriggerBoardMapping();
+    
     // slats
     //
     static TString SlatFilePath(AliMp::StationType stationType, 
@@ -115,6 +116,7 @@ class AliMpFiles : public TObject
     static const TString fgkDataExt;       ///< file extension
     static const TString fgkBergToGCFileName;  ///< BergToGC mapping file name
     static const TString fgkTriggerLocalBoards;///<  local board name to id mapping
+    static const TString fgkTriggerGlobalBoards;///<  global board name to id mapping
     static const TString fgkBusPatchFileName;  ///< DetElemIdToBusPatch file name
     static const TString fgkBusPatchLengthFileName;///< BusPatch length file name