MUON/mapping/AliMpManuStore.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 purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 // $Id$
  17 // Category: management
  18
  19 //-----------------------------------------------------------------------------
  20 // Class AliMpManuStore
  21 // --------------------
  22 // The container class for manu serial numbersd
  23 // Authors: Ivana Hrivnacova, IPN Orsay
  24 //          Christian Finck, SUBATECH Nantes
  25 //-----------------------------------------------------------------------------
  26
  27 #include "AliMpManuStore.h"
  28
  29 #include "AliMpDEStore.h"
  30 #include "AliMpDEManager.h"
  31 #include "AliMpDetElement.h"
  32 #include "AliMpConstants.h"
  33 #include "AliMpDataStreams.h"
  34 #include "AliMpFiles.h"
  35 #include "AliMpHelper.h"
  36 #include "AliMpIntPair.h"
  37 #include "AliMpConstants.h"
  38
  39 #include "AliLog.h"
  40
  41 #include <Riostream.h>
  42 #include <TClass.h>
  43 #include <TSystem.h>
  44 #include <TObjString.h>
  45 #include <TObjArray.h>
  46 #include <TMap.h>
  47
  48 #include <fstream>
  49
  50 /// \cond CLASSIMP
  51 ClassImp(AliMpManuStore)
  52 /// \endcond
  53
  54 AliMpManuStore* AliMpManuStore::fgInstance = 0;
  55 Bool_t          AliMpManuStore::fgWarnIfDoublon = kFALSE;
  56
  57 //
  58 // static methods
  59 //
  60
  61 //______________________________________________________________________________
  62 AliMpManuStore* AliMpManuStore::Instance(Bool_t warn)
  63 {
  64     /// Create the DDL store if it does not yet exist
  65     /// and return its instance
  66
  67     if ( ! fgInstance && warn  ) {
  68         AliWarningClass("Manu Store has not been loaded");
  69     }
  70
  71     return fgInstance;
  72 }
  73
  74 //______________________________________________________________________________
  75 AliMpManuStore* AliMpManuStore::ReadData(const AliMpDataStreams& dataStreams,
  76                                          Bool_t warn)
  77 {
  78     /// Load the DDL store from ASCII data files
  79     /// and return its instance
  80
  81     if ( fgInstance ) {
  82         if ( warn )
  83             AliWarningClass("DDL Store has been already loaded");
  84         return fgInstance;
  85     }
  86
  87     if ( dataStreams.GetReadFromFiles() )
  88       AliInfoClass("Reading Manu Store from ASCII files.");
  89
  90     fgInstance = new AliMpManuStore(dataStreams);
  91     return fgInstance;
  92 }
  93
  94 //
  95 // ctors, dtor
  96 //
  97
  98
  99 //______________________________________________________________________________
 100 AliMpManuStore::AliMpManuStore(const AliMpDataStreams& dataStreams)
 101 : TObject(),
 102   fDataStreams(dataStreams),
 103   fManuToSerialNbs(),
 104   fSerialNbToManus(),
 105   fNofManusInDE(),
 106   fNofManus(0)
 107 {
 108 /// Standard constructor
 109
 110   AliDebug(1,"");
 111
 112   // Check if DE store is loaded
 113   if ( ! AliMpDEStore::Instance(false) ) {
 114      AliErrorStream()
 115        << "Mapping segmentation has not be loaded. Cannont load Manu store"
 116        << endl;
 117      return;
 118   }
 119
 120   ReadManuSerial();
 121 }
 122
 123 //______________________________________________________________________________
 124 AliMpManuStore::AliMpManuStore(TRootIOCtor* ioCtor)
 125 : TObject(),
 126   fDataStreams(ioCtor),
 127   fManuToSerialNbs(),
 128   fSerialNbToManus(),
 129   fNofManusInDE(),
 130   fNofManus(0)
 131 {
 132 /// Constructor for IO
 133
 134   AliDebug(1,"");
 135 }
 136
 137
 138 //______________________________________________________________________________
 139 AliMpManuStore::~AliMpManuStore()
 140 {
 141 /// Destructor
 142
 143   AliDebug(1,"");
 144 }
 145
 146 //
 147 // private methods
 148 //
 149
 150 //______________________________________________________________________________
 151 Bool_t AliMpManuStore::ReadData(const AliMpDetElement* de, Int_t& nofManus)
 152 {
 153 /// Read manu serial numbers for the given detection element
 154
 155   Int_t deId = de->GetId();
 156   TString deName = de->GetDEName();
 157   AliMp::StationType stationType
 158     =  AliMpDEManager::GetStationType(de->GetId());
 159
 160   // Nothing to be done for trigger
 161   if ( stationType == AliMp::kStationTrigger ) {
 162     nofManus = 0;
 163     return kTRUE;
 164   }
 165
 166   static Int_t manuMask = AliMpConstants::ManuMask(AliMp::kNonBendingPlane);
 167
 168   istream& in
 169     = fDataStreams.
 170         CreateDataStream(AliMpFiles::ManuToSerialPath(deName, stationType));
 171
 172   char line[80];
 173
 174   nofManus = 0;
 175   while ( in.getline(line,80) ) {
 176
 177     if ( line[0] == '#' ) continue;
 178
 179     TString tmp(AliMpHelper::Normalize(line));
 180
 181     TObjArray* stringList = tmp.Tokenize(TString(" "));
 182
 183     Int_t manuId     = atoi( ((TObjString*)stringList->At(0))->GetName());
 184     Int_t manuSerial = atoi( ((TObjString*)stringList->At(2))->GetName());
 185
 186     TString sPlane = ((TObjString*)stringList->At(1))->GetString();
 187
 188     // filling manuId <> manuSerial
 189     if (!sPlane.CompareTo(PlaneTypeName(AliMp::kBendingPlane)))
 190         AddManu(deId, manuId, manuSerial);
 191     else
 192         AddManu(deId, manuId + manuMask, manuSerial);
 193
 194     ++nofManus;
 195
 196     delete stringList;
 197   }
 198
 199   return kTRUE;
 200 }
 201
 202 //______________________________________________________________________________
 203 Bool_t  AliMpManuStore::ReadManuSerial()
 204 {
 205 /// Read data files for all detection elements.
 206 /// Return true if reading was successful.
 207
 208   Bool_t isOk = kTRUE;
 209
 210   // Loop over DE
 211   AliMpDEIterator it;
 212   for ( it.First(); ! it.IsDone(); it.Next() ) {
 213
 214     AliMpDetElement* detElement = it.CurrentDE();
 215
 216     Int_t nofManus;
 217     Bool_t result = ReadData(detElement, nofManus);
 218     fNofManusInDE.Add(detElement->GetId(), nofManus);
 219     fNofManus += nofManus;
 220
 221     AliDebugStream(2)
 222       << "Adding " << nofManus << " manus for de "
 223       << detElement->GetId() << endl;
 224
 225     isOk = isOk && result;
 226   }
 227
 228   return isOk;
 229 }
 230
 231 //______________________________________________________________________________
 232 void  AliMpManuStore::ReplaceManu(Int_t detElemId, Int_t manuId, Int_t serialNb)
 233 {
 234 /// Replace manu in the map.
 235 /// As TExMap has no replcae function, we have to rebuild map once again.
 236 /// Not yet in use, declared private.
 237
 238   Long_t index = AliMpExMap::GetIndex(AliMpIntPair(detElemId, manuId));
 239
 240   TExMap newManuToSerialNbs;
 241   // Loop over map
 242   TExMapIter it(&fManuToSerialNbs);
 243   Long_t key;
 244   Long_t value;
 245   while ( ( it.Next(key, value) ) ) {
 246
 247     if ( key != index )
 248       newManuToSerialNbs.Add(key, value);
 249     else
 250       newManuToSerialNbs.Add(index, Long_t(serialNb));
 251   }
 252
 253   TExMap newSerialNbToManus;
 254   // Loop over map
 255   TExMapIter it2(&fSerialNbToManus);
 256   while ( ( it2.Next(key, value) ) ) {
 257
 258     if ( value != index )
 259       newSerialNbToManus.Add(key, value);
 260     else
 261       newSerialNbToManus.Add(Long_t(serialNb), index);
 262   }
 263
 264   // And now replace the maps
 265   fManuToSerialNbs = newManuToSerialNbs;
 266   fSerialNbToManus = newManuToSerialNbs;
 267 }
 268
 269
 270 //______________________________________________________________________________
 271 Bool_t  AliMpManuStore::WriteData(const TString& outDir)
 272 {
 273 /// Write data files for all detection elements.
 274 /// Return true if reading was successful.
 275 /// Not yet in use, declared private.
 276
 277   TString curDir = gSystem->pwd();
 278
 279   // Create top directory
 280   //
 281   if ( gSystem->OpenDirectory(outDir.Data()) ) {
 282     AliErrorStream()
 283       << "Directory " << outDir.Data() << " already exists" << endl;
 284     return kFALSE;
 285   }
 286   else {
 287     AliDebugStream(2) << "Making directory " <<  outDir.Data() << endl;
 288     gSystem->mkdir(outDir.Data());
 289   }
 290
 291   // Loop over DE
 292   AliMpDEIterator it;
 293   for ( it.First(); ! it.IsDone(); it.Next() ) {
 294
 295     AliMpDetElement* detElement = it.CurrentDE();
 296     Int_t detElemId = detElement->GetId();
 297     TString deName = detElement->GetDEName();
 298     AliMp::StationType stationType
 299       =  AliMpDEManager::GetStationType(detElemId);
 300
 301     if ( stationType == AliMp::kStationTrigger ) continue;
 302
 303     // Create directory if it does not yet exist
 304     //
 305     TString dirPath = outDir + AliMpFiles::StationDataDir(stationType);
 306     if ( ! gSystem->OpenDirectory(dirPath.Data()) ) {
 307       AliDebugStream(2) << "Making directory " <<  dirPath.Data() << endl;
 308       gSystem->mkdir(dirPath.Data());
 309     }
 310
 311     // Compose output file path
 312     //
 313     string dataPath = AliMpFiles::ManuToSerialPath(deName, stationType).Data();
 314     string top = AliMpFiles::GetTop().Data();
 315     if ( dataPath.find(top) != string::npos ) dataPath.erase(0, top.size()+1);
 316     dataPath.erase(0,dataPath.find('/')+1);
 317     TString filePath = outDir + "/" + dataPath;
 318
 319     // Open file
 320     //
 321     ofstream out(filePath.Data());
 322     if ( ! out.good() ) {
 323       AliErrorStream()
 324         << "Cannot open output file  " << filePath.Data() << endl;
 325       return kFALSE;
 326     }
 327
 328     // Loop over map
 329     TExMapIter it(&fManuToSerialNbs);
 330     Long_t key;
 331     Long_t value;
 332     while ( ( it.Next(key, value) ) ) {
 333       AliMpIntPair pair = AliMpExMap::GetPair(key);
 334
 335       if ( pair.GetFirst() != detElemId ) continue;
 336
 337       AliDebugStream(3)
 338         << "Go to write " << key << " " << pair << " " << value << endl;
 339
 340       Int_t manuId = pair.GetSecond();
 341       static Int_t manuMask = AliMpConstants::ManuMask(AliMp::kNonBendingPlane);
 342
 343       TString planeName = PlaneTypeName(AliMp::kBendingPlane);
 344       if ( pair.GetSecond()> manuMask ) {
 345         planeName = PlaneTypeName(AliMp::kNonBendingPlane);
 346         manuId -= manuMask;
 347       }
 348       out << manuId << " " << planeName.Data() <<  " " << value << endl;
 349
 350       AliDebugStream(3)
 351         << manuId << " " << planeName.Data() <<  " " << value << endl;
 352     }
 353     out.close();
 354   }
 355   gSystem->cd(curDir);
 356   return kTRUE;
 357 }
 358
 359 //
 360 // public methods
 361 //
 362
 363
 364 //______________________________________________________________________________
 365 Int_t  AliMpManuStore::NofManus() const
 366 {
 367 /// Return total number of manus in the store
 368
 369   return fNofManus;
 370 }
 371
 372
 373 //______________________________________________________________________________
 374 Int_t  AliMpManuStore::NofManus(Int_t detElemId) const
 375 {
 376 /// Return number of manus in given detection element
 377
 378    if ( ! AliMpDEManager::IsValidDetElemId(detElemId, kTRUE) ) return 0;
 379
 380    return fNofManusInDE.GetValue(detElemId);
 381 }
 382
 383 //______________________________________________________________________________
 384 Bool_t  AliMpManuStore::AddManu(Int_t detElemId, Int_t manuId, Int_t serialNb)
 385 {
 386 /// Add manu to the map
 387
 388   Long_t index = AliMpExMap::GetIndex(AliMpIntPair(detElemId, manuId));
 389
 390   AliDebugStream(2)
 391     << "Adding (" << detElemId << "," <<  manuId
 392     << ") as index=" << index << " and serialNb=" << serialNb << endl;
 393
 394   fManuToSerialNbs.Add(index, Long_t(serialNb));
 395
 396   Long_t value = fSerialNbToManus.GetValue(Long_t(serialNb));
 397   if ( value ) {
 398     if ( fgWarnIfDoublon ) {
 399       AliWarningStream()
 400         << "Serial number " << serialNb
 401         << " already present for (detElemId, manuId) = " << AliMpExMap::GetPair(value)
 402         << ", it will nod be added for ("
 403         << detElemId << "," << manuId << ")" << endl;
 404      }
 405      return kFALSE;
 406   }
 407   else {
 408     fSerialNbToManus.Add(Long_t(serialNb), index);
 409     return kTRUE;
 410   }
 411 }
 412
 413
 414 //______________________________________________________________________________
 415 Int_t AliMpManuStore::GetManuSerial(Int_t detElemId, Int_t manuId) const
 416 {
 417 /// Return manu serial number for given detElemId and manuId
 418
 419   Long_t index = AliMpExMap::GetIndex(AliMpIntPair(detElemId, manuId));
 420   // cout << index << " " << fManuToSerialNbs.GetValue(index) << endl;
 421
 422   return fManuToSerialNbs.GetValue(index);
 423 }
 424
 425 //______________________________________________________________________________
 426 AliMpIntPair  AliMpManuStore::GetDetElemIdManu(Int_t manuSerial) const
 427 {
 428 /// Return detElemId and manuId for given manu serial number
 429
 430   Long_t value = fSerialNbToManus.GetValue(Long_t(manuSerial));
 431   // cout << manuSerial << " " << value << endl;
 432
 433   return AliMpExMap::GetPair(value);
 434 }
 435