TRD/AliTRDtrapConfigHandler.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 ////////////////////////////////////////////////////////////////////////////
  17 //                                                                        //
  18 //  MCM configuraton handler                                              //
  19 //                                                                        //
  20 //  Author: U. Westerhoff                                                 //
  21 //                                                                        //
  22 ////////////////////////////////////////////////////////////////////////////
  23
  24 #include "AliTRDtrapConfigHandler.h"
  25
  26 #include <iostream>
  27 #include <sstream>
  28 #include <iomanip>
  29
  30 #include "AliLog.h"
  31
  32 #include "AliTRDfeeParam.h"
  33 #include "AliTRDtrapConfig.h"
  34 #include "AliTRDmcmSim.h"
  35 #include "AliTRDgeometry.h"
  36 #include "AliTRDcalibDB.h"
  37
  38 #include "TMath.h"
  39 #include "TGeoMatrix.h"
  40 #include "TGraph.h"
  41
  42 #include "Cal/AliTRDCalOnlineGainTable.h"
  43 #include "Cal/AliTRDCalOnlineGainTableROC.h"
  44 #include "Cal/AliTRDCalOnlineGainTableMCM.h"
  45
  46 using namespace std;
  47
  48 AliTRDtrapConfigHandler::AliTRDtrapConfigHandler(AliTRDtrapConfig *cfg) :
  49      ltuParam()
  50      , fRestrictiveMask((0x3ffff << 11) | (0x1f << 6) | 0x3f)
  51      , fTrapConfig(cfg)
  52      , fGtbl()
  53 {
  54
  55 }
  56
  57
  58 AliTRDtrapConfigHandler::~AliTRDtrapConfigHandler()
  59 {
  60
  61 }
  62
  63 void AliTRDtrapConfigHandler::Init()
  64 {
  65   if (!fTrapConfig) {
  66     AliError("No TRAPconfig given");
  67     return;
  68   }
  69
  70   // setup of register allocation
  71   // I/O configuration which we don't care about
  72   fTrapConfig->SetTrapRegAlloc(AliTRDtrapConfig::kSEBDOU, AliTRDtrapConfig::kAllocNone);
  73   // position look-up table by layer
  74   for (Int_t iBin = 0; iBin < 128; iBin++)
  75     fTrapConfig->SetTrapRegAlloc((AliTRDtrapConfig::TrapReg_t) (AliTRDtrapConfig::kTPL00 + iBin), AliTRDtrapConfig::kAllocByLayer);
  76   // ... individual
  77   fTrapConfig->SetTrapRegAlloc(AliTRDtrapConfig::kC14CPUA, AliTRDtrapConfig::kAllocByMCM);
  78   fTrapConfig->SetTrapRegAlloc(AliTRDtrapConfig::kC15CPUA, AliTRDtrapConfig::kAllocByMCM);
  79
  80   // setup of DMEM allocation
  81   for(Int_t iAddr = AliTRDtrapConfig::fgkDmemStartAddress;
  82             iAddr < (AliTRDtrapConfig::fgkDmemWords + AliTRDtrapConfig::fgkDmemStartAddress); iAddr++) {
  83
  84     if(iAddr == AliTRDmcmSim::fgkDmemAddrDeflCorr)
  85       fTrapConfig->SetDmemAlloc(iAddr, AliTRDtrapConfig::kAllocByMCMinSM);
  86
  87     else if(iAddr == AliTRDmcmSim::fgkDmemAddrNdrift)
  88       fTrapConfig->SetDmemAlloc(iAddr, AliTRDtrapConfig::kAllocByDetector);
  89
  90     else if((iAddr >= AliTRDmcmSim::fgkDmemAddrDeflCutStart) && (iAddr <= AliTRDmcmSim::fgkDmemAddrDeflCutEnd))
  91       fTrapConfig->SetDmemAlloc(iAddr, AliTRDtrapConfig::kAllocByMCMinSM);
  92
  93     else if((iAddr >= AliTRDmcmSim::fgkDmemAddrTrackletStart) && (iAddr <= AliTRDmcmSim::fgkDmemAddrTrackletEnd))
  94       fTrapConfig->SetDmemAlloc(iAddr, AliTRDtrapConfig::kAllocByMCM);
  95
  96     else if((iAddr >= AliTRDmcmSim::fgkDmemAddrLUTStart) && (iAddr <= AliTRDmcmSim::fgkDmemAddrLUTEnd))
  97       fTrapConfig->SetDmemAlloc(iAddr, AliTRDtrapConfig::kAllocGlobal);
  98
  99     else if(iAddr == AliTRDmcmSim::fgkDmemAddrLUTcor0)
 100       fTrapConfig->SetDmemAlloc(iAddr, AliTRDtrapConfig::kAllocByMCMinSM);
 101
 102     else if(iAddr == AliTRDmcmSim::fgkDmemAddrLUTcor1)
 103       fTrapConfig->SetDmemAlloc(iAddr, AliTRDtrapConfig::kAllocByMCMinSM);
 104
 105     else if(iAddr == AliTRDmcmSim::fgkDmemAddrLUTnbins)
 106       fTrapConfig->SetDmemAlloc(iAddr, AliTRDtrapConfig::kAllocGlobal);
 107
 108     else if(iAddr == AliTRDmcmSim::fgkDmemAddrLUTLength)
 109       fTrapConfig->SetDmemAlloc(iAddr, AliTRDtrapConfig::kAllocGlobal);
 110
 111     else
 112       fTrapConfig->SetDmemAlloc(iAddr, AliTRDtrapConfig::kAllocGlobal);
 113   }
 114 }
 115
 116 void AliTRDtrapConfigHandler::ResetMCMs()
 117 {
 118    //
 119    // Reset all MCM registers and DMEM
 120    //
 121
 122   if (!fTrapConfig) {
 123     AliError("No TRAPconfig given");
 124     return;
 125   }
 126
 127    fTrapConfig->ResetRegs();
 128    fTrapConfig->ResetDmem();
 129 }
 130
 131
 132 Int_t AliTRDtrapConfigHandler::LoadConfig()
 133 {
 134   // load a default configuration which is suitable for simulation
 135   // for a detailed description of the registers see the TRAP manual
 136   // if you want to resimulate tracklets on real data use the appropriate config instead
 137
 138   if (!fTrapConfig) {
 139     AliError("No TRAPconfig given");
 140     return -1;
 141   }
 142
 143   // prepare ltuParam
 144   // ndrift (+ 5 binary digits)
 145   ltuParam.SetNtimebins(20 << 5);
 146   // deflection + tilt correction
 147   ltuParam.SetRawOmegaTau(0.16133);
 148   // deflection range table
 149   ltuParam.SetRawPtMin(0.1);
 150   // magnetic field
 151   ltuParam.SetRawMagField(0.0);
 152   // scaling factors for q0, q1
 153   ltuParam.SetRawScaleQ0(0);
 154   ltuParam.SetRawScaleQ1(0);
 155   // disable length correction and tilting correction
 156   ltuParam.SetRawLengthCorrectionEnable(kFALSE);
 157   ltuParam.SetRawTiltCorrectionEnable(kFALSE);
 158
 159   for (Int_t iDet = 0; iDet < 540; iDet++) {
 160     // HC header configuration bits
 161     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kC15CPUA, 0x2102, iDet); // zs, deh
 162
 163     // no. of timebins
 164     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kC13CPUA, 24, iDet);
 165
 166     // pedestal filter
 167     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kFPNP, 4*10, iDet);
 168     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kFPTC, 0, iDet);
 169     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kFPBY, 0, iDet); // bypassed!
 170
 171     // gain filter
 172     for (Int_t adc = 0; adc < 20; adc++) {
 173       fTrapConfig->SetTrapReg(AliTRDtrapConfig::TrapReg_t(AliTRDtrapConfig::kFGA0+adc), 40, iDet);
 174       fTrapConfig->SetTrapReg(AliTRDtrapConfig::TrapReg_t(AliTRDtrapConfig::kFGF0+adc), 15, iDet);
 175     }
 176     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kFGTA, 20, iDet);
 177     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kFGTB, 2060, iDet);
 178     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kFGBY, 0, iDet);  // bypassed!
 179
 180     // tail cancellation
 181     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kFTAL, 200, iDet);
 182     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kFTLL, 0, iDet);
 183     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kFTLS, 200, iDet);
 184     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kFTBY, 0, iDet);
 185
 186     // tracklet calculation
 187     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kTPQS0, 5, iDet);
 188     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kTPQE0, 10, iDet);
 189     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kTPQS1, 11, iDet);
 190     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kTPQE1, 20, iDet);
 191     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kTPFS, 5, iDet);
 192     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kTPFE, 20, iDet);
 193     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kTPVBY, 0, iDet);
 194     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kTPVT, 10, iDet);
 195     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kTPHT, 150, iDet);
 196     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kTPFP, 40, iDet);
 197     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kTPCL, 1, iDet);
 198     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kTPCT, 10, iDet);
 199
 200     // apply ltuParams
 201     ConfigureDyCorr(iDet);
 202     ConfigureDRange(iDet); // deflection range
 203     ConfigureNTimebins(iDet);  // timebins in the drift region
 204     ConfigurePIDcorr(iDet);  // scaling parameters for the PID
 205
 206     // event buffer
 207     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kEBSF, 1, iDet);  // 0: store filtered; 1: store unfiltered
 208
 209     // zs applied to data stored in event buffer (sel. by EBSF)
 210     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kEBIS, 15 << 2, iDet); // single indicator threshold (plus two digits)
 211     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kEBIT, 30 << 2, iDet); // sum indicator threshold (plus two digits)
 212     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kEBIL, 0xf0, iDet);   // lookup table
 213     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kEBIN, 0, iDet);      // neighbour sensitivity
 214
 215     // raw data
 216     fTrapConfig->SetTrapReg(AliTRDtrapConfig::kNES, (0x0000 << 16) | 0x1000, iDet);
 217   }
 218
 219   // ****** hit position LUT
 220
 221   // now calculate it from PRF
 222   AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
 223
 224   Double_t padResponse[3]; // pad response left, central, right
 225   Double_t padResponseR[3]; // pad response left, central, right
 226   Double_t padResponseL[3]; // pad response left, central, right
 227
 228   for (Int_t iLayer = 0; iLayer < 6; iLayer++) {
 229     TGraph gr(128);
 230     for (Int_t iBin = 0; iBin < 256*0.5; iBin++) {
 231       cal->PadResponse(1., iBin*1./256.,    iLayer, padResponse);
 232       cal->PadResponse(1., iBin*1./256.-1., iLayer, padResponseR);
 233       cal->PadResponse(1., iBin*1./256.+1., iLayer, padResponseL);
 234       gr.SetPoint(iBin, (0.5 * (padResponseR[1] - padResponseL[1])/padResponse[1] * 256), iBin);
 235     }
 236     for (Int_t iBin = 0; iBin < 128; iBin++) {
 237       Int_t corr = (Int_t) (gr.Eval(iBin)) - iBin;
 238       if (corr < 0)
 239         corr = 0;
 240       else if (corr > 31)
 241         corr = 31;
 242       for (Int_t iStack = 0; iStack < 540/6; iStack++) {
 243         fTrapConfig->SetTrapReg((AliTRDtrapConfig::TrapReg_t) (AliTRDtrapConfig::kTPL00 + iBin), corr, 6*iStack + iLayer);
 244       }
 245     }
 246   }
 247   // ****** hit position LUT configuration end
 248
 249   return 0;
 250 }
 251
 252
 253 Int_t AliTRDtrapConfigHandler::LoadConfig(TString filename)
 254 {
 255    //
 256   // load a TRAP configuration from a file
 257    // The file format is the format created by the standalone
 258    // command coder scc / show_cfdat but without the running number
 259    // scc /show_cfdat adds as the first column
 260    // which are two tools to inspect/export configurations from wingDB
 261    //
 262
 263   if (!fTrapConfig) {
 264     AliError("No TRAPconfig given");
 265     return -1;
 266   }
 267
 268    Int_t ignoredLines=0;
 269    Int_t ignoredCmds=0;
 270    Int_t readLines=0;
 271
 272
 273    AliDebug(5, Form("Processing file %s", filename.Data()));
 274    std::ifstream infile;
 275    infile.open(filename.Data(), std::ifstream::in);
 276    if (!infile.is_open()) {
 277     AliError(Form("Can not open MCM configuration file %s", filename.Data()));
 278     return kFALSE;
 279    }
 280
 281    UInt_t cmd;
 282    Int_t extali, addr, data;
 283
 284    // reset restrictive mask
 285    fRestrictiveMask = (0x3ffff << 11) | (0x1f << 6) | 0x3f;
 286    char linebuffer[512];
 287    istringstream line;
 288
 289    while(infile.getline(linebuffer, 512) && infile.good()) {
 290       line.clear();
 291       line.str(linebuffer);
 292       cmd=999;
 293       extali=-1;
 294       addr=-1;
 295       data=-1;
 296       line >> std::skipws >> cmd >> addr >> data >> extali;  // the lines read from config file can contain additional columns.
 297       // Therefore the detour via istringstream
 298
 299       if(cmd!=999 && addr != -1 && data!= -1 && extali!=-1) {
 300
 301          if(cmd==fgkScsnCmdWrite) {
 302             for(Int_t det=0; det<AliTRDgeometry::Ndet(); det++) {
 303                UInt_t rocpos = (1 << (AliTRDgeometry::GetSector(det)+11)) | (1 << (AliTRDgeometry::GetStack(det)+6)) | (1 << AliTRDgeometry::GetLayer(det));
 304                AliDebug(1, Form("checking restriction: mask=0x%08x, rocpos=0x%08x", fRestrictiveMask, rocpos));
 305                if ((fRestrictiveMask & rocpos) == rocpos) {
 306                  AliDebug(1, Form("match: %i %i %i %i", cmd, extali, addr, data));
 307                   AddValues(det, cmd, extali, addr, data);
 308                }
 309             }
 310          }
 311
 312          else if(cmd == fgkScsnLTUparam) {
 313             ProcessLTUparam(extali, addr, data);
 314          }
 315
 316          else if(cmd == fgkScsnCmdRestr) {
 317             fRestrictiveMask = data;
 318            AliDebug(1, Form("updated restrictive mask to 0x%08x", fRestrictiveMask));
 319          }
 320
 321          else if((cmd == fgkScsnCmdReset) ||
 322                  (cmd == fgkScsnCmdRobReset)) {
 323            fTrapConfig->ResetRegs();
 324          }
 325
 326          else if (cmd == fgkScsnCmdSetHC) {
 327            Int_t fullVersion = ((data & 0x7F00) >> 1) | (data & 0x7f);
 328
 329            for (Int_t iDet = 0; iDet < AliTRDgeometry::Ndet(); iDet++) {
 330              Int_t smls = (AliTRDgeometry::GetSector(iDet) << 6) | (AliTRDgeometry::GetLayer(iDet) << 3) | AliTRDgeometry::GetStack(iDet);
 331
 332              for (Int_t iRob = 0; iRob < 8; iRob++) {
 333                // HC mergers
 334                fTrapConfig->SetTrapReg(AliTRDtrapConfig::kC14CPUA, 0xc << 16, iDet, iRob, 17);
 335                fTrapConfig->SetTrapReg(AliTRDtrapConfig::kC15CPUA, ((1<<29) | (fullVersion<<15) | (1<<12) | (smls<<1) | (iRob%2)), iDet, iRob, 17);
 336
 337                // board mergers
 338                fTrapConfig->SetTrapReg(AliTRDtrapConfig::kC14CPUA, 0, iDet, iRob, 16);
 339                fTrapConfig->SetTrapReg(AliTRDtrapConfig::kC15CPUA, ((1<<29) | (fullVersion<<15) | (1<<12) | (smls<<1) | (iRob%2)), iDet, iRob, 16);
 340
 341                // and now for the others
 342                for (Int_t iMcm = 0; iMcm < 16; iMcm++) {
 343                  fTrapConfig->SetTrapReg(AliTRDtrapConfig::kC14CPUA, iMcm | (iRob << 4) | (3 << 16), iDet, iRob, iMcm);
 344                  fTrapConfig->SetTrapReg(AliTRDtrapConfig::kC15CPUA, ((1<<29) | (fullVersion<<15) | (1<<12) | (smls<<1) | (iRob%2)), iDet, iRob, iMcm);
 345                }
 346              }
 347            }
 348          }
 349
 350          else if((cmd == fgkScsnCmdRead) ||
 351                  (cmd == fgkScsnCmdPause) ||
 352                  (cmd == fgkScsnCmdPtrg) ||
 353                  (cmd == fgkScsnCmdHwPtrg) ||
 354                  (cmd == fgkScsnCmdRobPower) ||
 355                  (cmd == fgkScsnCmdTtcRx) ||
 356                  (cmd == fgkScsnCmdMcmTemp) ||
 357                  (cmd == fgkScsnCmdOri) ||
 358                  (cmd == fgkScsnCmdPM) ) {
 359            AliDebug(2, Form("ignored SCSN command: %i %i %i %i", cmd, addr, data, extali));
 360          }
 361
 362          else {
 363             AliWarning(Form("unknown SCSN command: %i %i %i %i", cmd, addr, data, extali));
 364             ignoredCmds++;
 365          }
 366
 367          readLines++;
 368       }
 369
 370       else if(!infile.eof() && !infile.good()) {
 371          infile.clear();
 372          infile.ignore(256, '\n');
 373          ignoredLines++;
 374       }
 375
 376       if(!infile.eof())
 377          infile.clear();
 378    }
 379
 380    infile.close();
 381
 382    AliDebug(5, Form("Ignored lines: %i, ignored cmds: %i", ignoredLines, ignoredCmds));
 383
 384
 385    if(ignoredLines>readLines)
 386       AliError(Form("More than 50 %% of the input file could not be processed. Perhaps you should check the input file %s", filename.Data()));
 387
 388
 389    return kTRUE;
 390 }
 391
 392
 393
 394 Int_t AliTRDtrapConfigHandler::SetGaintable(AliTRDCalOnlineGainTable const &gtbl)
 395 {
 396    fGtbl=gtbl;
 397    return 0;
 398 }
 399
 400
 401 void AliTRDtrapConfigHandler::ProcessLTUparam(Int_t dest, Int_t addr, UInt_t data)
 402 {
 403    //
 404    // Process the LTU parameters and stores them in internal class variables
 405    // or transfer the stored values to AliTRDtrapConfig, depending on the dest parameter
 406    //
 407
 408    switch (dest) {
 409
 410    case 0: // set the parameters in AliTRDtrapConfig
 411       for(Int_t det=0; det<AliTRDgeometry::Ndet(); det++) {
 412          ConfigureDyCorr(det);
 413          ConfigureDRange(det); // deflection range
 414          ConfigureNTimebins(det);  // timebins in the drift region
 415          ConfigurePIDcorr(det);  // scaling parameters for the PID
 416       }
 417       break;
 418
 419    case 1: // set variables
 420       switch (addr) {
 421
 422       case 0: ltuParam.SetPtMin(data); break; // pt_min in GeV/c (*1000)
 423       case 1: ltuParam.SetMagField(data); break; // B in T (*1000)
 424       case 2: ltuParam.SetOmegaTau(data); break; // omega*tau
 425       case 3: ltuParam.SetNtimebins(data); break;
 426         // ntimbins: drift time (for 3 cm) in timebins (5 add. bin. digits)
 427       case 4: ltuParam.SetScaleQ0(data); break;
 428       case 5: ltuParam.SetScaleQ1(data); break;
 429       case 6: ltuParam.SetLengthCorrectionEnable(data); break;
 430       case 7: ltuParam.SetTiltCorrectionEnable(data); break;
 431       }
 432       break;
 433
 434    default:
 435       AliError(Form("dest %i not implemented", dest));
 436    }
 437
 438 }
 439
 440
 441 void AliTRDtrapConfigHandler::ConfigureNTimebins(Int_t det)
 442 {
 443    //
 444    // Set timebins in the drift region
 445    //
 446
 447   if (!fTrapConfig) {
 448     AliError("No TRAPconfig given");
 449     return;
 450   }
 451
 452   AddValues(det, fgkScsnCmdWrite, 127, AliTRDmcmSim::fgkDmemAddrNdrift, ltuParam.GetNtimebins());
 453 }
 454
 455
 456
 457 void AliTRDtrapConfigHandler::ConfigureDyCorr(Int_t det)
 458 {
 459    //
 460    //  Deflection length correction
 461    //  due to Lorentz angle and tilted pad correction
 462    //  This correction is in units of padwidth / (256*32)
 463    //
 464
 465   if (!fTrapConfig) {
 466     AliError("No TRAPconfig given");
 467     return;
 468   }
 469
 470    Int_t nRobs = AliTRDgeometry::GetStack(det) == 2 ? 6 : 8;
 471
 472   for (Int_t r = 0; r < nRobs; r++) {
 473     for (Int_t m = 0; m < 16; m++) {
 474       Int_t dest =  1<<10 | r<<7 | m;
 475       Int_t dyCorrInt = ltuParam.GetDyCorrection(det, r, m);
 476       AddValues(det, fgkScsnCmdWrite, dest, AliTRDmcmSim::fgkDmemAddrDeflCorr, dyCorrInt);
 477     }
 478   }
 479 }
 480
 481
 482
 483
 484
 485 void AliTRDtrapConfigHandler::ConfigureDRange(Int_t det)
 486 {
 487    //
 488    // deflection range LUT
 489    // range calculated according to B-field (in T) and pt_min (in GeV/c)
 490    // if pt_min < 0.1 GeV/c the maximal allowed range for the tracklet
 491    // deflection (-64..63) is used
 492    //
 493
 494   if (!fTrapConfig) {
 495     AliError("No TRAPconfig given");
 496     return;
 497   }
 498
 499   Int_t nRobs = AliTRDgeometry::GetStack(det) == 2 ? 6 : 8;
 500
 501   Int_t dyMinInt;
 502   Int_t dyMaxInt;
 503
 504    for (Int_t r = 0; r < nRobs; r++) {
 505       for (Int_t m = 0; m < 16; m++) {
 506          for (Int_t c = 0; c < 18; c++) {
 507
 508            // cout << "maxdefl: " << maxDeflAngle << ", localPhi " << localPhi << endl;
 509            // cout << "r " << r << ", m" << m << ", c " << c << ", min angle: " << localPhi-maxDeflAngle << ", max: " << localPhi+maxDeflAngle
 510            //   << ", min int: " << dyMinInt << ", max int: " << dyMaxInt << endl;
 511            Int_t dest =  1<<10 | r<<7 | m;
 512            Int_t lutAddr = AliTRDmcmSim::fgkDmemAddrDeflCutStart + 2*c;
 513            ltuParam.GetDyRange(det, r, m, c, dyMinInt, dyMaxInt);
 514            AddValues(det, fgkScsnCmdWrite, dest, lutAddr+0, dyMinInt);
 515            AddValues(det, fgkScsnCmdWrite, dest, lutAddr+1, dyMaxInt);
 516          }
 517       }
 518    }
 519 }
 520
 521 void AliTRDtrapConfigHandler::PrintGeoTest()
 522 {
 523    //
 524    // Prints some information about the geometry. Only for debugging
 525    //
 526
 527    int sm=0;
 528    //   for(int sm=0; sm<6; sm++) {
 529    for(int stack=0; stack<5; stack++) {
 530       for(int layer=0; layer<6; layer++) {
 531
 532          Int_t det = sm*30+stack*6+layer;
 533          for (Int_t r = 0; r < 6; r++) {
 534             for (Int_t m = 0; m < 16; m++) {
 535                for (Int_t c = 7; c < 8; c++) {
 536                  cout << stack << ";" << layer << ";" << r << ";" << m
 537                       << ";" << ltuParam.GetX(det, r, m)
 538                       << ";" << ltuParam.GetLocalY(det, r, m, c)
 539                       << ";" << ltuParam.GetLocalZ(det, r, m) << endl;
 540                }
 541             }
 542          }
 543       }
 544    }
 545    // }
 546 }
 547
 548
 549 void AliTRDtrapConfigHandler::ConfigurePIDcorr(Int_t det)
 550 {
 551    //
 552    // Calculate the MCM individual correction factors for the PID
 553    // and transfer them to AliTRDtrapConfig
 554    //
 555
 556   if (!fTrapConfig) {
 557     AliError("No TRAPconfig given");
 558     return;
 559   }
 560
 561    static const Int_t addrLUTcor0 = AliTRDmcmSim::fgkDmemAddrLUTcor0;
 562    static const Int_t addrLUTcor1 = AliTRDmcmSim::fgkDmemAddrLUTcor1;
 563
 564    UInt_t cor0;
 565    UInt_t cor1;
 566
 567    Int_t nRobs = AliTRDgeometry::GetStack(det) == 2 ? 6 : 8;
 568
 569    for (Int_t r=0; r<nRobs; r++) {
 570       for(Int_t m=0; m<16; m++) {
 571          Int_t dest =  1<<10 | r<<7 | m;
 572          if(fGtbl.GetGainTableROC(det) && fGtbl.GetGainTableROC(det)->GetGainTableMCM(r, m))
 573             ltuParam.GetCorrectionFactors(det, r, m, 9, cor0, cor1, fGtbl.GetGainTableROC(det)->GetGainTableMCM(r, m)->GetMCMGain());
 574          else
 575             ltuParam.GetCorrectionFactors(det, r, m, 9, cor0, cor1);
 576          AddValues(det, fgkScsnCmdWrite, dest, addrLUTcor0, cor0);
 577          AddValues(det, fgkScsnCmdWrite, dest, addrLUTcor1, cor1);
 578     }
 579   }
 580 }
 581
 582
 583 Bool_t AliTRDtrapConfigHandler::AddValues(UInt_t det, UInt_t cmd, UInt_t extali, Int_t addr, UInt_t data)
 584 {
 585    // transfer the informations provided by LoadConfig to the internal class variables
 586
 587   if (!fTrapConfig) {
 588     AliError("No TRAPconfig given");
 589     return kFALSE;
 590   }
 591
 592   if(cmd != fgkScsnCmdWrite) {
 593     AliError(Form("Invalid command received: %i", cmd));
 594     return kFALSE;
 595   }
 596
 597   AliTRDtrapConfig::TrapReg_t mcmReg = fTrapConfig->GetRegByAddress(addr);
 598   Int_t rocType = AliTRDgeometry::GetStack(det) == 2 ? 0 : 1;
 599
 600   static const int mcmListSize=40;  // 40 is more or less arbitrary
 601   Int_t mcmList[mcmListSize];
 602
 603   // configuration registers
 604   if(mcmReg >= 0 && mcmReg < AliTRDtrapConfig::kLastReg) {
 605
 606     for(Int_t linkPair=0; linkPair<fgkMaxLinkPairs; linkPair++) {
 607       if(AliTRDfeeParam::ExtAliToAli(extali, linkPair, rocType, mcmList, mcmListSize)!=0) {
 608         Int_t i=0;
 609         while(mcmList[i] != -1 && i<mcmListSize) {
 610           if(mcmList[i]==127) {
 611             AliDebug(1, Form("broadcast write to %s: 0x%08x",
 612                              fTrapConfig->GetRegName((AliTRDtrapConfig::TrapReg_t) mcmReg), data));
 613             fTrapConfig->SetTrapReg( (AliTRDtrapConfig::TrapReg_t) mcmReg, data, det);
 614           }
 615           else {
 616             AliDebug(1, Form("individual write to %s (%i, %i): 0x%08x",
 617                              fTrapConfig->GetRegName((AliTRDtrapConfig::TrapReg_t) mcmReg), (mcmList[i]>>7), (mcmList[i]&0x7F), data));
 618             fTrapConfig->SetTrapReg( (AliTRDtrapConfig::TrapReg_t) mcmReg, data, det, (mcmList[i]>>7)&0x7, (mcmList[i]&0x7F));
 619           }
 620           i++;
 621         }
 622       }
 623     }
 624     return kTRUE;
 625   }
 626   // DMEM
 627   else if ( (addr >= AliTRDtrapConfig::fgkDmemStartAddress) &&
 628             (addr < (AliTRDtrapConfig::fgkDmemStartAddress + AliTRDtrapConfig::fgkDmemWords))) {
 629     for(Int_t linkPair=0; linkPair<fgkMaxLinkPairs; linkPair++) {
 630       if(AliTRDfeeParam::ExtAliToAli(extali, linkPair, rocType, mcmList, mcmListSize)!=0) {
 631         Int_t i=0;
 632         while(mcmList[i] != -1 && i < mcmListSize) {
 633           if(mcmList[i] == 127)
 634              fTrapConfig->SetDmem(addr, data, det, 0, 127);
 635           else
 636              fTrapConfig->SetDmem(addr, data, det, mcmList[i] >> 7, mcmList[i] & 0x7f);
 637           i++;
 638         }
 639       }
 640     }
 641     return kTRUE;
 642   }
 643   else if ( (addr >= AliTRDtrapConfig::fgkImemStartAddress) &&
 644             (addr < (AliTRDtrapConfig::fgkImemStartAddress + AliTRDtrapConfig::fgkImemWords))) {
 645     // IMEM is ignored for now
 646     return kTRUE;
 647   }
 648   else if ( (addr >= AliTRDtrapConfig::fgkDbankStartAddress) &&
 649             (addr < (AliTRDtrapConfig::fgkDbankStartAddress + AliTRDtrapConfig::fgkImemWords))) {
 650     // DBANK is ignored for now
 651     return kTRUE;
 652   }
 653   else {
 654     AliError(Form("Writing to unhandled address 0x%04x", addr));
 655     return kFALSE;
 656   }
 657 }