MUON/AliMUONTrackerIO.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
  18 #include <cstdlib>
  19 #include "AliMUONTrackerIO.h"
  20
  21 /// \class AliMUONTrackerIO
  22 ///
  23 /// Reader class for ASCII calibration files for MUON tracker :
  24 /// converts those ASCII files into AliMUONVStore (suitable to e.g. feed
  25 /// the OCDB).
  26 ///
  27 /// \author Laurent Aphecetche, Subatech
  28
  29 /// \cond CLASSIMP
  30 ClassImp(AliMUONTrackerIO)
  31 /// \endcond
  32
  33 #include "AliDCSValue.h"
  34 #include "AliLog.h"
  35 #include "AliMUONCalibParamND.h"
  36 #include "AliMUONCalibParamNF.h"
  37 #include "AliMUONVStore.h"
  38 #include "AliMpConstants.h"
  39 #include "AliMpDDLStore.h"
  40 #include "AliMpDEManager.h"
  41 #include "AliMpDetElement.h"
  42 #include <Riostream.h>
  43 #include <TClass.h>
  44 #include <TObjString.h>
  45 #include <TSystem.h>
  46 #include <sstream>
  47
  48 //_____________________________________________________________________________
  49 AliMUONTrackerIO::AliMUONTrackerIO()
  50 {
  51   /// ctor
  52 }
  53
  54 //_____________________________________________________________________________
  55 AliMUONTrackerIO::~AliMUONTrackerIO()
  56 {
  57   /// dtor
  58 }
  59
  60 //_____________________________________________________________________________
  61 Int_t
  62 AliMUONTrackerIO::ReadOccupancy(const char* filename,AliMUONVStore& occupancyMap)
  63 {
  64   /// Read occupancy file created by online DA
  65   /// and append values to the occupancyMap store.
  66   /// Expected format of the file is :
  67   /// busPatchId manuId sumofn nevt
  68
  69   TString sFilename(gSystem->ExpandPathName(filename));
  70
  71   std::ifstream in(sFilename.Data());
  72   if (!in.good())
  73   {
  74     return kCannotOpenFile;
  75   }
  76
  77   TString datastring;
  78   ostringstream stream;
  79   char line[1024];
  80   while ( in.getline(line,1024) )
  81         stream << line << "\n";
  82
  83   in.close();
  84
  85   return DecodeOccupancy(stream.str().c_str(),occupancyMap);
  86
  87 }
  88
  89 //_____________________________________________________________________________
  90 Int_t
  91 AliMUONTrackerIO::DecodeOccupancy(const char* data, AliMUONVStore& occupancyMap)
  92 {
  93   /// Decode occupancy string created append values to the occupancyMap store.
  94   /// Expected format of the file is :
  95   /// busPatchId manuId sumofn nevt
  96
  97   if ( ! AliMpDDLStore::Instance(kFALSE) )
  98   {
  99     AliErrorClass("Mapping not loaded. Cannot work");
 100     return 0;
 101   }
 102
 103   char line[1024];
 104   istringstream in(data);
 105
 106   Int_t n(0);
 107
 108   while ( in.getline(line,1024) )
 109   {
 110     AliDebugClass(3,Form("line=%s",line));
 111     if ( line[0] == '/' && line[1] == '/' ) continue;
 112     std::istringstream sin(line);
 113
 114     Int_t busPatchId, manuId;
 115     Int_t numberOfEvents;
 116     Double_t sumn;
 117
 118     sin >> busPatchId >> manuId >> sumn >> numberOfEvents;
 119
 120     Int_t detElemId = AliMpDDLStore::Instance()->GetDEfromBus(busPatchId);
 121
 122     AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
 123
 124     Int_t numberOfChannelsInManu = -1;
 125
 126     if (de) numberOfChannelsInManu = de->NofChannelsInManu(manuId);
 127
 128     if ( numberOfChannelsInManu <= 0 )
 129     {
 130       AliErrorClass(Form("BP %5d DE %5d MANU %5d nchannels=%d",busPatchId,detElemId,manuId,numberOfChannelsInManu));
 131       continue;
 132     }
 133
 134     AliMUONVCalibParam* occupancy =
 135     static_cast<AliMUONVCalibParam*>(occupancyMap.FindObject(detElemId,manuId));
 136     if (occupancy)
 137     {
 138       AliErrorClass(Form("DE %5d MANU %5d is already there ?!",detElemId,manuId));
 139       continue;
 140     }
 141
 142     occupancy = new AliMUONCalibParamND(5,1,detElemId,manuId,0);
 143
 144     occupancyMap.Add(occupancy);
 145
 146     occupancy->SetValueAsDouble(0,0,sumn);
 147     occupancy->SetValueAsDouble(0,1,sumn); // with only 0 and 1s, sumw = sumw2 = sumn
 148     occupancy->SetValueAsDouble(0,2,sumn);
 149     occupancy->SetValueAsInt(0,3,numberOfChannelsInManu);
 150     occupancy->SetValueAsInt(0,4,numberOfEvents);
 151     ++n;
 152   }
 153
 154   return n;
 155 }
 156
 157 //_____________________________________________________________________________
 158 Int_t
 159 AliMUONTrackerIO::ReadPedestals(const char* filename, AliMUONVStore& pedStore)
 160 {
 161   /// Read pedestal file (produced by the MUONTRKda.exe program for instance)
 162   /// and append the read values into the given VStore
 163   /// To be used when the input is a file (for instance when reading data
 164   /// from the OCDB).
 165
 166   TString sFilename(gSystem->ExpandPathName(filename));
 167
 168   std::ifstream in(sFilename.Data());
 169   if (!in.good())
 170   {
 171     return kCannotOpenFile;
 172   }
 173
 174   ostringstream stream;
 175   char line[1024];
 176   while ( in.getline(line,1024) )
 177         stream << line << "\n";
 178
 179   in.close();
 180
 181   return DecodePedestals(stream.str().c_str(),pedStore);
 182
 183 }
 184
 185 //_____________________________________________________________________________
 186 Int_t
 187 AliMUONTrackerIO::DecodePedestals(const char* data, AliMUONVStore& pedStore)
 188 {
 189   /// Read pedestal Data (produced by the MUONTRKda.exe program for instance)
 190   /// and append the read values into the given VStore
 191   /// To be used when the input is a TString (for instance when getting data
 192   /// from AMORE DB).
 193
 194   char line[1024];
 195   Int_t busPatchID, manuID, manuChannel;
 196   Float_t pedMean, pedSigma;
 197   Int_t n(0);
 198   istringstream in(data);
 199
 200   while ( in.getline(line,1024) )
 201   {
 202     AliDebugClass(3,Form("line=%s",line));
 203     if ( line[0] == '/' && line[1] == '/' ) continue;
 204     std::istringstream sin(line);
 205     sin >> busPatchID >> manuID >> manuChannel >> pedMean >> pedSigma;
 206     Int_t detElemID = AliMpDDLStore::Instance()->GetDEfromBus(busPatchID);
 207
 208     if ( !AliMpDEManager::IsValidDetElemId(detElemID) )
 209     {
 210       AliErrorClass(Form("Got an invalid DE = %d from busPatchId=%d manuId=%d",
 211                          detElemID,busPatchID,manuID));
 212       continue;
 213     }
 214
 215     AliDebugClass(3,Form("BUSPATCH %3d DETELEMID %4d MANU %3d CH %3d MEAN %7.2f SIGMA %7.2f",
 216                     busPatchID,detElemID,manuID,manuChannel,pedMean,pedSigma));
 217
 218     AliMUONVCalibParam* ped =
 219       static_cast<AliMUONVCalibParam*>(pedStore.FindObject(detElemID,manuID));
 220     if (!ped)
 221     {
 222       ped = new AliMUONCalibParamNF(2,AliMpConstants::ManuNofChannels(),
 223                                     detElemID,manuID,
 224                                     AliMUONVCalibParam::InvalidFloatValue());
 225       pedStore.Add(ped);
 226     }
 227     ped->SetValueAsFloat(manuChannel,0,pedMean);
 228     ped->SetValueAsFloat(manuChannel,1,pedSigma);
 229     ++n;
 230   }
 231
 232   return n;
 233 }
 234
 235 //_____________________________________________________________________________
 236 Int_t
 237 AliMUONTrackerIO::ReadGains(const char* filename, AliMUONVStore& gainStore,
 238                             TString& comment)
 239 {
 240   /// Read gain file (produced by the MUONTRKda.exe program for instance)
 241   /// and append the read values into the given VStore
 242   /// To be used when the input is a file (for instance when reading data
 243   /// from the OCDB).
 244
 245   comment = "";
 246
 247   TString sFilename(gSystem->ExpandPathName(filename));
 248
 249   std::ifstream in(sFilename.Data());
 250   if (!in.good())
 251   {
 252     return kCannotOpenFile;
 253   }
 254
 255   ostringstream stream;
 256   char line[1024];
 257   while ( in.getline(line,1024) )
 258         stream << line << "\n";
 259
 260   in.close();
 261
 262   return DecodeGains(stream.str().c_str(),gainStore,comment);
 263
 264 }
 265
 266 //_____________________________________________________________________________
 267 Int_t
 268 AliMUONTrackerIO::DecodeGains(const char* data, AliMUONVStore& gainStore,
 269                               TString& comment)
 270 {
 271   /// Read gain file (produced by the MUONTRKda.exe program for instance)
 272   /// and append the read values into the given VStore
 273   /// To be used when the input is a string (for instance when getting data
 274   /// from AMORE DB).
 275
 276   char line[1024];
 277   istringstream in(data);
 278   Int_t busPatchID, manuID, manuChannel;
 279   Float_t a0, a1;
 280   Int_t thres;
 281   UInt_t qual;
 282   const Int_t kSaturation(3000); // FIXME: how to get this number ?
 283   Int_t n(0);
 284   Int_t runNumber(-1);
 285   Int_t* runs(0x0);
 286   Int_t* dac(0x0);
 287   Int_t nDAC(0);
 288   Int_t nInit(0),f1nbp(0),f2nbp(0);
 289
 290   while ( in.getline(line,1024) )
 291   {
 292     if ( strlen(line) < 10 ) continue;
 293     if ( line[0] == '/' && line[1] == '/' )
 294     {
 295       TString sline(line);
 296       if ( sline.Contains("DUMMY") )
 297       {
 298         AliDebugClass(1,"Got a dummy file here");
 299         return kDummyFile;
 300       }
 301       if ( sline.Contains("* Run") )
 302       {
 303         TObjArray* a = sline.Tokenize(":");
 304         if ( a->GetLast() >= 1 )
 305         {
 306           TString s = static_cast<TObjString*>(a->At(1))->String();
 307           runNumber = s.Atoi();
 308           AliDebugClass(1,Form("runNumber is %d",runNumber));
 309         }
 310       }
 311       if ( sline.Contains("DAC values") )
 312       {
 313         nDAC = TString(sline(2,sline.Length()-2)).Atoi();
 314         AliDebugClass(1,Form("# of DAC values = %d",nDAC));
 315         if ( nDAC > 0 )
 316         {
 317           if ( nDAC < 100 )
 318           {
 319             runs = new Int_t[nDAC];
 320             dac = new Int_t[nDAC];
 321             // skip two lines
 322             in.getline(line,1024);
 323             sline = line;
 324             if (!sline.Contains("*  nInit ="))
 325             {
 326               AliErrorClass("Improper format : was expecting nInit= line...");
 327             }
 328             else
 329             {
 330               sscanf(line,"//   *  nInit = %d  *  f1nbp = %d  *  f2nbp = %d",&nInit,&f1nbp,&f2nbp);
 331               AliDebugClass(1,Form("nInit = %d",nInit));
 332               AliDebugClass(1,Form("f1nbp = %d",f1nbp));
 333               AliDebugClass(1,Form("f2nbp = %d",f2nbp));
 334             }
 335             in.getline(line,1024);
 336             in.getline(line,1024);
 337             // then get run and dac values
 338             Int_t iDAC(0);
 339             for ( Int_t i = 0; i < nDAC; ++i )
 340             {
 341               in.getline(line,1024);
 342               Int_t a,b;
 343               sscanf(line,"// %d %d",&a,&b);
 344               runs[iDAC] = a;
 345               dac[iDAC] = b;
 346               AliDebugClass(1,Form("RUN %d is DAC %d",runs[iDAC],dac[iDAC]));
 347               ++iDAC;
 348             }
 349           }
 350           else
 351           {
 352             AliErrorClass(Form("Something went wrong, as I get too big nDAC = %d",nDAC));
 353             nDAC = 0;
 354             return kFormatError;
 355           }
 356         }
 357       }
 358       continue;
 359     }
 360
 361     sscanf(line,"%d %d %d %f %f %d %x",&busPatchID,&manuID,&manuChannel,
 362            &a0,&a1,&thres,&qual);
 363     AliDebugClass(3,Form("line=%s",line));
 364     Int_t detElemID = AliMpDDLStore::Instance()->GetDEfromBus(busPatchID);
 365
 366     if ( !AliMpDEManager::IsValidDetElemId(detElemID) )
 367     {
 368       AliErrorClass(Form("Got an invalid DE = %d from busPatchId=%d manuId=%d",
 369                          detElemID,busPatchID,manuID));
 370       continue;
 371     }
 372
 373     AliDebugClass(3,Form("BUSPATCH %3d DETELEMID %4d MANU %3d CH %3d A0 %7.2f "
 374                     "A1 %e THRES %5d QUAL %x",
 375                     busPatchID,detElemID,manuID,manuChannel,a0,a1,thres,qual));
 376     if ( qual == 0 ) continue;
 377
 378     AliMUONVCalibParam* gain =
 379       static_cast<AliMUONVCalibParam*>(gainStore.FindObject(detElemID,manuID));
 380
 381    if (!gain)
 382     {
 383       gain = new AliMUONCalibParamNF(5,AliMpConstants::ManuNofChannels(),detElemID,manuID,0);
 384       gainStore.Add(gain);
 385     }
 386     gain->SetValueAsFloat(manuChannel,0,a0);
 387     gain->SetValueAsFloat(manuChannel,1,a1);
 388     gain->SetValueAsInt(manuChannel,2,thres);
 389     gain->SetValueAsInt(manuChannel,3,qual);
 390     gain->SetValueAsInt(manuChannel,4,kSaturation);
 391     ++n;
 392   }
 393
 394   comment = "";
 395
 396   if ( runNumber > 0 )
 397   {
 398     comment = Form("RUN %d",runNumber);
 399   }
 400
 401   for ( Int_t i = 0; i < nDAC; ++i )
 402   {
 403     comment += Form(";(RUN %d = DAC %d)",runs[i],dac[i]);
 404   }
 405   comment += Form(";(nDAC = %d)",nDAC);
 406   comment += Form(";(nInit = %d)",nInit);
 407   comment += Form(";(f1nbp = %d)",f1nbp);
 408   comment += Form(";(f2nbp = %d)",f2nbp);
 409
 410   delete[] runs;
 411   delete[] dac;
 412
 413   return n;
 414 }
 415
 416 //_____________________________________________________________________________
 417 Int_t
 418 AliMUONTrackerIO::ReadCapacitances(const char* filename, AliMUONVStore& capaStore)
 419 {
 420   /// Read capacitance file
 421   /// and append the read values into the given VStore
 422
 423   TString sFilename(gSystem->ExpandPathName(filename));
 424
 425   std::ifstream in(sFilename.Data());
 426   if (!in.good())
 427   {
 428     return kCannotOpenFile;
 429   }
 430
 431   ostringstream stream;
 432   char line[1024];
 433   while ( in.getline(line,1024) )
 434         stream << line << "\n";
 435
 436   in.close();
 437
 438   return DecodeCapacitances(stream.str().c_str(),capaStore);
 439 }
 440
 441 //_____________________________________________________________________________
 442 Int_t
 443 AliMUONTrackerIO::DecodeCapacitances(const char* data, AliMUONVStore& capaStore)
 444 {
 445   /// Read capacitances and append the read values into the given VStore
 446   /// To be used when the input is a string (for instance when getting data
 447   /// from AMORE DB).
 448
 449   Int_t ngenerated(0);
 450
 451   char line[1024];
 452   Int_t serialNumber(-1);
 453   AliMUONVCalibParam* param(0x0);
 454   istringstream in(data);
 455
 456   while ( in.getline(line,1024,'\n') )
 457   {
 458     if ( isdigit(line[0]) )
 459     {
 460       serialNumber = atoi(line);
 461       param = static_cast<AliMUONVCalibParam*>(capaStore.FindObject(serialNumber));
 462       if (param)
 463       {
 464         AliErrorClass(Form("serialNumber %d appears several times !",serialNumber));
 465         continue;
 466       }
 467       param = new AliMUONCalibParamNF(2,AliMpConstants::ManuNofChannels(),serialNumber,0,1.0);
 468       Bool_t ok = capaStore.Add(param);
 469       if (!ok)
 470       {
 471         AliErrorClass(Form("Could not set serialNumber=%d",serialNumber));
 472         continue;
 473       }
 474       continue;
 475     }
 476     Int_t channel;
 477     Float_t capaValue;
 478     Float_t injectionGain;
 479     sscanf(line,"%d %f %f",&channel,&capaValue,&injectionGain);
 480     AliDebugClass(1,Form("SerialNumber %10d Channel %3d Capa %f injectionGain %f",
 481                     serialNumber,channel,capaValue,injectionGain));
 482     param->SetValueAsFloat(channel,0,capaValue);
 483     param->SetValueAsFloat(channel,1,injectionGain);
 484     ++ngenerated;
 485   }
 486
 487   return ngenerated;
 488 }
 489
 490 //_____________________________________________________________________________
 491 Int_t
 492 AliMUONTrackerIO::ReadConfig(const char* filename, AliMUONVStore& confStore)
 493 {
 494   /// Read config file (produced by the MUONTRKda.exe program for instance)
 495   /// and append the read values into the given VStore
 496   /// To be used when the input is a file (for instance when reading data
 497   /// from the OCDB).
 498
 499   TString sFilename(gSystem->ExpandPathName(filename));
 500
 501   std::ifstream in(sFilename.Data());
 502   if (!in.good())
 503   {
 504     return kCannotOpenFile;
 505   }
 506
 507   ostringstream stream;
 508   char line[1024];
 509   while ( in.getline(line,1024) )
 510         stream << line << "\n";
 511
 512   in.close();
 513
 514   return DecodeConfig(stream.str().c_str(),confStore);
 515 }
 516
 517 //_____________________________________________________________________________
 518 Int_t
 519 AliMUONTrackerIO::DecodeConfig(const char* data, AliMUONVStore& confStore)
 520 {
 521   /// Read config data (produced by the MUONTRKda.exe program for instance)
 522   /// and append the read values into the given VStore
 523   /// To be used when the input is a TString (for instance when getting data
 524   /// from AMORE DB).
 525
 526   char line[1024];
 527   Int_t busPatchID, manuID;
 528   Int_t n(0);
 529   istringstream in(data);
 530
 531   while ( in.getline(line,1024) )
 532   {
 533     AliDebugClass(3,Form("line=%s",line));
 534     if ( line[0] == '#' )
 535     {
 536       continue;
 537     }
 538     std::istringstream sin(line);
 539     sin >> busPatchID >> manuID;
 540
 541     Int_t detElemID = AliMpDDLStore::Instance()->GetDEfromBus(busPatchID);
 542
 543     if ( !AliMpDEManager::IsValidDetElemId(detElemID) )
 544     {
 545       AliErrorClass(Form("Got an invalid DE = %d from busPatchId=%d manuId=%d",
 546                          detElemID,busPatchID,manuID));
 547       continue;
 548     }
 549
 550     AliMUONVCalibParam* conf =
 551     static_cast<AliMUONVCalibParam*>(confStore.FindObject(detElemID,manuID));
 552     if (!conf)
 553     {
 554       conf = new AliMUONCalibParamNF(1,1,detElemID,manuID,1);
 555       confStore.Add(conf);
 556     }
 557     ++n;
 558   }
 559
 560   return n;
 561 }
 562
 563 //_____________________________________________________________________________
 564 Int_t
 565 AliMUONTrackerIO::WriteConfig(ofstream& out, const AliMUONVStore& confStore)
 566 {
 567   /// Write the conf store as an ASCII file
 568   /// Note that we are converting (back) the detElemId into a busPatchId
 569   /// Return the number of lines written
 570
 571   if ( !AliMpDDLStore::Instance() )
 572   {
 573     cout << "ERROR: mapping not loaded. Cannot work" << endl;
 574     return 0;
 575   }
 576
 577   TIter next(confStore.CreateIterator());
 578   AliMUONVCalibParam* param;
 579   Int_t n(0);
 580
 581   while ( (param=static_cast<AliMUONVCalibParam*>(next())) )
 582   {
 583     Int_t detElemId = param->ID0();
 584     Int_t manuId = param->ID1();
 585
 586     Int_t busPatchId = AliMpDDLStore::Instance()->GetBusPatchId(detElemId,manuId);
 587     ++n;
 588
 589     out << busPatchId << " " << manuId << endl;
 590   }
 591   return n;
 592 }
 593