CbmRoot
CbmTrdParManager.cxx
Go to the documentation of this file.
1 
6 #include "CbmTrdParManager.h"
7 
8 #include "CbmTrdGeoHandler.h" // for CbmTrdGeoHandler
9 #include "CbmTrdPads.h" // for fst1_pad_type, fst1_sect_count
10 #include "CbmTrdParAsic.h" // for CbmTrdParAsic, CbmTrdParAsic::kCriId...
11 #include "CbmTrdParFasp.h" // for CbmTrdParFasp
12 #include "CbmTrdParModDigi.h" // for CbmTrdParModDigi
13 #include "CbmTrdParModGain.h" // for CbmTrdParModGain
14 #include "CbmTrdParModGas.h" // for CbmTrdParModGas
15 #include "CbmTrdParSet.h" // for CbmTrdParSet
16 #include "CbmTrdParSetAsic.h" // for CbmTrdParSetAsic
17 #include "CbmTrdParSetDigi.h" // for CbmTrdParSetDigi
18 #include "CbmTrdParSetGain.h" // for CbmTrdParSetGain
19 #include "CbmTrdParSetGas.h" // for CbmTrdParSetGas
20 #include "CbmTrdParSpadic.h" // for CbmTrdParSpadic
21 
22 #include <FairParAsciiFileIo.h> // for FairParAsciiFileIo
23 #include <FairParRootFileIo.h> // for FairParRootFileIo
24 #include <FairRunAna.h> // for FairRunAna
25 #include <FairRuntimeDb.h> // for FairRuntimeDb
26 #include <FairTask.h> // for FairTask, InitStatus, kSUCCESS
27 
28 #include <TArrayD.h> // for TArrayD
29 #include <TFile.h> // for TFile
30 #include <TGeoManager.h> // for TGeoManager, gGeoManager
31 #include <TGeoNode.h> // for TGeoNode
32 #include <TList.h> // for TList
33 #include <TObjArray.h> // for TObjArray
34 #include <TObject.h> // for TObject
35 #include <TRandom.h> // for TRandom, gRandom
36 
37 #include <stdio.h> // for printf
38 #include <stdlib.h> // for getenv
39 #include <vector> // for vector
40 
42  : FairTask("TrdParManager")
43  , fMaxSectors(0)
44  , fFASP(fasp)
45  // fModuleMap(),
46  , fAsicPar(nullptr)
47  , fDigiPar(nullptr)
48  , fGasPar(nullptr)
49  , fGainPar(nullptr)
50  , fGeoHandler(new CbmTrdGeoHandler())
51  , fGeometryTag("")
52  , fHardwareSetup() {
53  // Get the maximum number of sectors. All arrays will have this number of entries.
55 }
56 
58 
60  FairRuntimeDb* rtdb = FairRunAna::Instance()->GetRuntimeDb();
61  fAsicPar = (CbmTrdParSetAsic*) (rtdb->getContainer("CbmTrdParSetAsic"));
62  fDigiPar = (CbmTrdParSetDigi*) (rtdb->getContainer("CbmTrdParSetDigi"));
63  fGasPar = (CbmTrdParSetGas*) (rtdb->getContainer("CbmTrdParSetGas"));
64  fGainPar = (CbmTrdParSetGain*) (rtdb->getContainer("CbmTrdParSetGain"));
65 }
66 
67 InitStatus CbmTrdParManager::Init() {
68  // The geometry structure is treelike with cave as
69  // the top node. For the TRD there are keeping volume
70  // trd_vXXy_1 which is only container for the different layers.
71  // The trd layer is again only a container for all volumes of this layer.
72  // Loop over all nodes below the top node (cave). If one of
73  // the nodes contains a string trd it must be TRD detector.
74  // Now loop over the layers and
75  // then over all modules of the layer to extract in the end
76  // all active regions (gas) of the complete TRD. For each
77  // of the gas volumes get the information about size and
78  // position from the geomanager and the sizes of the sectors
79  // and pads from the definitions in CbmTrdPads. This info
80  // is then stored in a CbmTrdModuleSim object for each of the
81  // TRD modules.
82 
83  TGeoNode* topNode = gGeoManager->GetTopNode();
84  TObjArray* nodes = topNode->GetNodes();
85  for (Int_t iNode = 0; iNode < nodes->GetEntriesFast(); iNode++) {
86  TGeoNode* node = static_cast<TGeoNode*>(nodes->At(iNode));
87  if (!TString(node->GetName()).Contains("trd"))
88  continue; // trd_vXXy top node, e.g. trd_v13a, trd_v14b
89  TGeoNode* station = node;
90  fGeometryTag = station->GetName();
92  TObjArray* layers = station->GetNodes();
93  for (Int_t iLayer = 0; iLayer < layers->GetEntriesFast(); iLayer++) {
94  TGeoNode* layer = static_cast<TGeoNode*>(layers->At(iLayer));
95  if (!TString(layer->GetName()).Contains("layer"))
96  continue; // only layers
97 
98  TObjArray* modules = layer->GetNodes();
99  for (Int_t iModule = 0; iModule < modules->GetEntriesFast(); iModule++) {
100  TGeoNode* module = static_cast<TGeoNode*>(modules->At(iModule));
101  TObjArray* parts = module->GetNodes();
102  for (Int_t iPart = 0; iPart < parts->GetEntriesFast(); iPart++) {
103  TGeoNode* part = static_cast<TGeoNode*>(parts->At(iPart));
104  if (!TString(part->GetName()).BeginsWith("gas_"))
105  continue; // only active gas volume
106 
107  // Put together the full path to the interesting volume, which
108  // is needed to navigate with the geomanager to this volume.
109  // Extract the geometry information (size, global position)
110  // from this volume.
111  TString path = TString("/") + topNode->GetName() + "/"
112  + station->GetName() + "/" + layer->GetName() + "/"
113  + module->GetName() + "/" + part->GetName();
114 
116  }
117  }
118  }
119  }
120 
121  return kSUCCESS;
122 }
123 
125  FairRuntimeDb* rtdb = FairRunAna::Instance()->GetRuntimeDb();
126  // fDigiPar = (CbmTrdParSetDigi*) (rtdb->getContainer("CbmTrdParSetDigi"));
127  // fDigiPar->print();
128  fAsicPar = (CbmTrdParSetAsic*) (rtdb->getContainer("CbmTrdParSetAsic"));
129  fAsicPar->Print();
130 }
131 
132 void CbmTrdParManager::Exec(Option_t*) {}
133 
134 
135 void CbmTrdParManager::CreateModuleParameters(const TString& path) {
140  Int_t moduleAddress = fGeoHandler->GetModuleAddress(path);
141  Int_t orientation = fGeoHandler->GetModuleOrientation(path);
142 
143  Double_t sizeX = fGeoHandler->GetSizeX(path);
144  Double_t sizeY = fGeoHandler->GetSizeY(path);
145  Double_t sizeZ = fGeoHandler->GetSizeZ(path);
146  Double_t x = fGeoHandler->GetX(path);
147  Double_t y = fGeoHandler->GetY(path);
148  Double_t z = fGeoHandler->GetZ(path);
149 
150  TArrayD sectorSizeX(fMaxSectors);
151  TArrayD sectorSizeY(fMaxSectors);
152  TArrayD padSizeX(fMaxSectors);
153  TArrayD padSizeY(fMaxSectors);
154  Int_t moduleType = fGeoHandler->GetModuleType(path);
155 
156  printf("\nCbmTrdParManager::CreateModuleParameters(%s) type[%d]\n",
157  path.Data(),
158  moduleType);
159  for (Int_t i = 0; i < fst1_sect_count; i++) {
160  sectorSizeX.AddAt(fst1_pad_type[moduleType - 1][i][0], i);
161  sectorSizeY.AddAt(fst1_pad_type[moduleType - 1][i][1], i);
162  padSizeX.AddAt(fst1_pad_type[moduleType - 1][i][2], i);
163  padSizeY.AddAt(fst1_pad_type[moduleType - 1][i][3], i);
164  printf(" sec[%d] dx[%5.2f] dy[%5.2f] px[%5.2f] py[%5.2f]\n",
165  i,
166  sectorSizeX[i],
167  sectorSizeY[i],
168  padSizeX[i],
169  padSizeY[i]);
170  }
171 
172  // Orientation of the detector layers
173  // Odd layers (1,3,5..) have resolution in x-direction (isRotated == 0) - vertical pads
174  // Even layers (2,4,6..) have resolution in y-direction (isRotated == 1) - horizontal pads
175  // Int_t isRotated = fGeoHandler->GetModuleOrientation(path);
176  // if( (isRotated%2) == 1 ) { // flip pads for even layers
177  // Double_t copybuf;
178  // for (Int_t i = 0; i < fMaxSectors; i++) {
179  // copybuf = padSizeX.At(i);
180  // padSizeX.AddAt(padSizeY.At(i), i);
181  // padSizeY.AddAt(copybuf, i);
182  // copybuf = sectorSizeX.At(i);
183  // sectorSizeX.AddAt(sectorSizeY.At(i), i);
184  // sectorSizeY.AddAt(copybuf, i);
185  // }
186  // }
187 
188  // Create new digi par for this module.
189  CbmTrdParModDigi* digi = new CbmTrdParModDigi(x,
190  y,
191  z,
192  sizeX,
193  sizeY,
194  sizeZ,
195  fMaxSectors,
196  orientation,
197  sectorSizeX,
198  sectorSizeY,
199  padSizeX,
200  padSizeY);
201  if (moduleType
202  >= 9) { // for the Bucharest inner detector special anode wire geometry
204  digi->SetAnodeWireOffset(0.);
205  digi->SetAnodeWireSpacing(0.3);
206  }
207  digi->SetModuleId(moduleAddress);
208  digi->Print();
209  fDigiPar->addParam(digi);
210 
211  // Create new asic par for this module
212  CbmTrdParSetAsic* asics(nullptr);
213  // if(moduleType>=9 && fFASP){ // I do not think this check is required, actually I think it creates a bug in parameter creation
214  if (moduleType >= 9) {
215  asics = new CbmTrdParSetAsic(
216  "TrdParModFasp",
217  Form("Fasp set for Module %d", moduleAddress) /*, GetContext()*/);
218  asics->SetAsicType(moduleType);
219  Double_t par[6];
220  par[1] = 14;
221  par[4] = 4.181e-6;
222  Int_t iasic(0), ncol(digi->GetNofColumns()), asicAddress, chAddress;
223  CbmTrdParFasp* asic(nullptr);
224  for (Int_t r(0); r < digi->GetNofRows(); r++) {
225  for (Int_t c(0); c < ncol; c++) {
226  if (c % 8 == 0) {
227  if (asic) asics->SetAsicPar(asicAddress, asic);
228  asicAddress = moduleAddress * 1000 + iasic;
229  asic = new CbmTrdParFasp(asicAddress);
230  iasic++;
231  }
232  for (Int_t ipair(0); ipair < 2; ipair++) {
233  par[0] = gRandom->Gaus(300, 4);
234  par[2] = gRandom->Gaus(600, 40);
235  par[3] = gRandom->Gaus(2580, 10);
236  chAddress = 2 * (r * ncol + c) + ipair;
237  par[5] = ipair;
238  asic->SetChannelAddress(chAddress);
239  Int_t chIdFasp = asic->QueryChannel(chAddress);
240  asic->SetCalibParameters(chIdFasp, par);
241  }
242  }
243  }
244  if (asic) asics->SetAsicPar(asicAddress, asic);
245  } else { // Here only rectangular modules should enter. Hence, we have spadics in use.
246  asics = new CbmTrdParSetAsic(
247  "TrdParModSpadic", Form("Spadic set for Module %d", moduleAddress));
248  asics->SetAsicType(moduleType);
249  CbmTrdParSpadic* asic(nullptr);
250 
251  // To write the channelAddresses to the parameter files we first of all need to now the number of columns, rows and channels. The numbering of the channels starts at the bottom left and goes along the short side (column) of the pads row by row, for a not rotated module. The rotation is also taken care about in the following code.
252  Int_t nModuleColumns(digi->GetNofColumns());
253  Int_t nModuleRows(digi->GetNofRows());
254  Int_t nModuleChannels(nModuleColumns * nModuleRows);
255 
256  Int_t nAsicsAlongColumns(-1);
257 
258  std::vector<Int_t> chAddressesVec;
259  for (Int_t iAsic = 0;
260  iAsic < CbmTrdParSpadic::GetNasicsOnModule(moduleType);
261  iAsic++) {
262  asic = new CbmTrdParSpadic(
263  1000 * moduleAddress
264  + iAsic); // nTh-asic + module address define asicAddress counting for asic starts at bottom left and goes left to right row by row
265 
266  Int_t nAsicChannels(asic->GetNchannels());
267 
268  // Figure out the number of asics per column, this is required since one spadic is connected to two rows
269  nAsicsAlongColumns = nModuleColumns < nModuleRows
270  ? nModuleRows / 2
271  : nModuleColumns / (nAsicChannels / 2);
272 
273  // Get the asic-row (= rows/2) for the given asic
274  Int_t nThAsicRow(iAsic / nAsicsAlongColumns);
275 
276  Int_t nThAsicColumn(iAsic % nAsicsAlongColumns);
277 
278  chAddressesVec.clear();
279  chAddressesVec.resize(nAsicChannels);
280 
281  Int_t iAsicChannel =
282  0; // This is the nth asic channel as it is written to the raw messages
283  for (auto channelAddress : chAddressesVec) {
284  // Now apply the asic specific mapping
285  channelAddress = asic->GetAsicChAddress(
286  iAsicChannel); // returns the channeladdress in the scope of one asic
287 
288  // Get the channel addressed to the top or bottom row of the single asic
289  if ((channelAddress / (nAsicChannels / 2)) > 0) {
290  // if the address corresponds to the second 16 channels 16..31 it goes into the next row
291  channelAddress -= (nAsicChannels / 2);
292  // since we have only 16 channels per row we have to subtract 16 from channels 16..31
293  channelAddress += nModuleColumns;
294  }
295  // move channel address to the correct column according to the asic column position
296  channelAddress +=
297  nThAsicColumn * nAsicChannels / 2; // one asic is split over two rows
298  // move channel address to the correct row according to the asic row position
299  channelAddress +=
300  nThAsicRow * nModuleColumns * 2; // one asic is split over two rows
301 
302  // if the module is rotated 180 or 270 degrees, the channel number counting has to be rotated as well, since the X-Y placing in CbmTrdParModDigi expect it in this way.
303  if (orientation == 2) {
304  channelAddress *= (-1);
305  channelAddress += (nModuleChannels - 1);
306  }
307  chAddressesVec.at(iAsicChannel) = channelAddress;
308  iAsicChannel++;
309  }
310 
311  asic->SetChannelAddresses(chAddressesVec);
312  // Get the according hardware component Id for the real asic placed at the according position in the experiment
314  asics->SetAsicPar(asic->GetAddress(), asic);
315  }
316  }
317 
318 
319  asics->Print();
320  fAsicPar->AddParameters(asics);
321 
322  // Create new gas par for this module
323  CbmTrdParModGas* gas(nullptr);
324  if (moduleType >= 9) {
325  gas = new CbmTrdParModGas(
326  Form("Module/%d/Ua/%d/Ud/%d/Gas/Xe", moduleAddress, 1900, 500));
327  gas->SetDetType(1);
328  gas->SetPidType(1);
329  } else
330  gas = new CbmTrdParModGas(
331  Form("Module/%d/Ua/%d/Ud/%d/Gas/Xe", moduleAddress, 1600, 500));
332  gas->Print();
333  fGasPar->addParam(gas);
334 
335  // Create new gain par for this module
336  CbmTrdParModGain* gain(nullptr);
337  if (moduleType == 9)
338  gain = new CbmTrdParModGain();
339  else
340  gain = new CbmTrdParModGain();
341  gain->SetModuleId(moduleAddress);
342  gain->Print();
343  fGainPar->addParam(gain);
344 }
345 
346 // ---- CreateParFilesFromGeometry ------------------------------------------------
347 bool CbmTrdParManager::CreateParFilesFromGeometry(bool createRootFileOutput,
348  TString outDir) {
349  // This function creates the trd parameter files based on a given geometry file, which has to be passed in a macro to the FairRunAna instance. Such a geometry file is produced by FairRunSim bases on the trd geometry input.
350 
351  if (!createRootFileOutput) return CreateParFilesFromGeometry(outDir);
352 
353  FairRunAna* run = FairRunAna::Instance();
354  FairRuntimeDb* rtdb = run->GetRuntimeDb();
355 
357 
358  TString inputDirectory = run->GetGeoFile()->GetName();
359  inputDirectory.Resize((inputDirectory.Last('/') + 1));
360  TString geoName = run->GetGeoFile()->GetName();
361  geoName.ReplaceAll(inputDirectory.Data(), "");
362  geoName.ReplaceAll("geofile_", "");
363  geoName.ReplaceAll(".root", "");
364 
365  if (outDir.IsNull()) {
366  outDir = Form("%s/../src/parameters/trd", getenv("CBM_ROOT"));
367  }
368 
369  TList* containerList = rtdb->getListOfContainers();
370 
371  TString currentPar = "";
372  CbmTrdParSet* currentContainer = nullptr;
373  FairParRootFileIo parOut;
374  parOut.open(Form("%s/%s.par.root", outDir.Data(), geoName.Data()),
375  "RECREATE");
376  rtdb->setOutput(&parOut);
377 
378  for (auto iContainerIt : *containerList) {
379  currentPar = iContainerIt->GetName();
380  if (!currentPar.Contains("CbmTrd"))
381  continue; // make sure that we only edit Trd container
382  currentContainer = (CbmTrdParSet*) iContainerIt;
383  currentContainer->setChanged();
384  currentContainer->setInputVersion(0, 1);
385  }
386  rtdb->saveOutput();
387  rtdb->closeOutput();
388 
389  return true; // check if rtdb->writeContainers() could be used to run a bool check and return that bool instead of saveOutput void
390 }
391 
392 // ---- private - CreateParFilesFromGeometry --------------------------------------
394  // This function creates the trd parameter files based on a given geometry file, which has to be passed in a macro to the FairRunAna instance. Such a geometry file is produced by FairRunSim bases on the trd geometry input.
395 
396  FairRunAna* run = FairRunAna::Instance();
397  FairRuntimeDb* rtdb = run->GetRuntimeDb();
398 
400 
401  TString inputDirectory = run->GetGeoFile()->GetName();
402  inputDirectory.Resize((inputDirectory.Last('/') + 1));
403  TString geoName = run->GetGeoFile()->GetName();
404  geoName.ReplaceAll(inputDirectory.Data(), "");
405  geoName.ReplaceAll("geofile_", "");
406  geoName.ReplaceAll(".root", "");
407 
408  if (outDir.IsNull()) {
409  outDir = Form("%s/../src/parameters/trd", getenv("CBM_ROOT"));
410  }
411 
412  TList* containerList = rtdb->getListOfContainers();
413 
414  TString currentPar = "";
415  TString currentFile = "";
416  CbmTrdParSet* currentContainer = nullptr;
417 
418  for (auto iContainerIt : *containerList) {
419  currentPar = iContainerIt->GetName();
420  if (!currentPar.Contains("CbmTrd"))
421  continue; // make sure that we only edit Trd container
422  currentContainer = (CbmTrdParSet*) iContainerIt;
423  currentPar.ReplaceAll("CbmTrdParSet", "");
424  currentPar.ToLower();
425  currentFile.Form(
426  "%s/%s.%s.par", outDir.Data(), geoName.Data(), currentPar.Data());
427  FairParAsciiFileIo parOut;
428  parOut.open(currentFile, "out");
429  rtdb->setOutput(&parOut);
430  currentContainer->setChanged();
431  currentContainer->setInputVersion(0, 1);
432  rtdb->saveOutput();
433  rtdb->closeOutput();
434  }
435  return true; // check if rtdb->writeContainers() could be used to run a bool check and return that bool instead of saveOutput void
436 }
437 
438 // ---- GetParSetList ----
439 void CbmTrdParManager::GetParSetList(std::vector<CbmTrdParSet*>* parSetList) {
440  // std::vector<CbmTrdParSet*> parSetList;
441  CbmTrdParSet* parSet = nullptr;
442  for (Int_t iParSetType = (Int_t) ECbmTrdParSets::kBegin;
443  iParSetType <= (Int_t) ECbmTrdParSets::kEnd;
444  iParSetType++) {
445  switch (iParSetType) {
447  parSet = new CbmTrdParSetAsic();
448  break;
450  parSet = new CbmTrdParSetDigi();
451  break;
453  parSet = new CbmTrdParSetGain();
454  break;
456  parSet = new CbmTrdParSetGas();
457  break;
458  }
459  parSetList->emplace_back(parSet);
460  }
461 }
462 
463 // ---- GetParFileExtensions ----
464 void CbmTrdParManager::GetParFileExtensions(std::vector<std::string>* vec) {
465  for (Int_t iParSetType = (Int_t) ECbmTrdParSets::kBegin;
466  iParSetType <= (Int_t) ECbmTrdParSets::kEnd;
467  iParSetType++) {
468  switch (iParSetType) {
470  vec->emplace_back("asic");
471  break;
473  vec->emplace_back("digi");
474  break;
476  vec->emplace_back("gas");
477  break;
479  vec->emplace_back("gain");
480  break;
481  }
482  }
483 }
484 
485 
486 // void CbmTrdParManager::FillDigiPar()
487 // {
488 // printf("CbmTrdParManager::FillDigiPar()\n");
489 // // Int_t nofModules = fModuleMap.size();
490 // // fDigiPar->SetNrOfModules(nofModules);
491 // // fDigiPar->SetMaxSectors(fMaxSectors);
492 // //
493 // // TArrayI moduleId(nofModules);
494 // // Int_t iModule = 0;
495 // // std::map<Int_t, CbmTrdModuleSim*>::iterator it;
496 // // for (it = fModuleMap.begin() ; it != fModuleMap.end(); it++) {
497 // // moduleId.AddAt(it->second->GetModuleAddress(), iModule);
498 // // iModule++;
499 // // }
500 // //
501 // // fDigiPar->SetModuleIdArray(moduleId);
502 // // fDigiPar->SetModuleMap(fModuleMap);
503 // }
504 
CbmTrdParAsic::SetChannelAddresses
virtual void SetChannelAddresses(std::vector< Int_t > addresses)
Definition: CbmTrdParAsic.cxx:51
CbmTrdParAsic::GetAddress
virtual Int_t GetAddress() const
Definition: CbmTrdParAsic.h:41
CbmTrdParSpadic::GetNasicsOnModule
static Int_t GetNasicsOnModule(Int_t moduleType)
Returns the number of asics on a given moduleType defined in eCbmTrdModuleTypes.
Definition: CbmTrdParSpadic.cxx:148
CbmTrdParManager::fMaxSectors
Int_t fMaxSectors
Definition: CbmTrdParManager.h:102
CbmTrdParModGas.h
CbmTrdParSetAsic::Print
virtual void Print(Option_t *opt="") const
Definition: CbmTrdParSetAsic.cxx:248
CbmTrdGeoHandler::GetModuleAddress
Int_t GetModuleAddress()
Return module address calculated based on the current node in the TGeoManager.
Definition: CbmTrdGeoHandler.cxx:49
CbmTrdGeoHandler::GetSizeX
Double_t GetSizeX(const TString &path)
Definition: CbmTrdGeoHandler.cxx:112
CbmTrdParManager::Init
virtual InitStatus Init()
Inherited from FairTask.
Definition: CbmTrdParManager.cxx:67
CbmTrdParManager::fHardwareSetup
CbmTrdHardwareSetupR fHardwareSetup
Definition: CbmTrdParManager.h:116
CbmTrdParManager::ECbmTrdParSets::kEnd
@ kEnd
CbmTrdParAsic::SetComponentId
virtual void SetComponentId(std::uint64_t id)
Definition: CbmTrdParAsic.h:66
CbmTrdParManager::CbmTrdParManager
CbmTrdParManager(Bool_t fasp=kFALSE)
enumerator for organising the existing parameter sets of the trd
Definition: CbmTrdParManager.cxx:41
CbmTrdParSetGas
Describe TRD module working settings (HV, etc)
Definition: CbmTrdParSetGas.h:15
CbmTrdParModDigi::SetAnodeWireSpacing
void SetAnodeWireSpacing(Double_t dw)
Definition: CbmTrdParModDigi.h:122
CbmTrdParModDigi::GetNofRows
Int_t GetNofRows() const
Definition: CbmTrdParModDigi.cxx:340
CbmTrdParManager::SetParContainers
virtual void SetParContainers()
Inherited from FairTask.
Definition: CbmTrdParManager.cxx:59
i
int i
Definition: L1/vectors/P4_F32vec4.h:25
CbmTrdParSetAsic
Describe TRD module ASIC settings (electronic gain, delays, etc)
Definition: CbmTrdParSetAsic.h:18
CbmTrdGeoHandler::GetModuleType
Int_t GetModuleType(const TString &path)
Definition: CbmTrdGeoHandler.cxx:142
CbmTrdParSet::addParam
virtual void addParam(CbmTrdParMod *mod)
Definition: CbmTrdParSet.cxx:65
CbmTrdParManager::fDigiPar
CbmTrdParSetDigi * fDigiPar
The set of read-out description parameters.
Definition: CbmTrdParManager.h:109
CbmTrdParManager.h
Assign pad layout to TRD Modules.
CbmTrdParSpadic::GetAsicChAddress
Int_t GetAsicChAddress(const Int_t asicChannel)
Returns the nth asic Channel in asic coordinates in single asic padplane coordinates....
Definition: CbmTrdParSpadic.cxx:187
CbmTrdParManager::GetParSetList
static void GetParSetList(std::vector< CbmTrdParSet * > *parSetList)
Definition: CbmTrdParManager.cxx:439
CbmTrdParSpadic.h
CbmTrdParSpadic::GetNchannels
virtual Int_t GetNchannels() const
Definition: CbmTrdParSpadic.h:30
CbmTrdParAsic.h
CbmTrdParManager
Manipulate calibration parameters for the TRD detectors.
Definition: CbmTrdParManager.h:36
CbmTrdGeoHandler::GetY
Double_t GetY(const TString &path)
Definition: CbmTrdGeoHandler.cxx:132
CbmTrdParSetAsic.h
CbmTrdGeoHandler
Definition: CbmTrdGeoHandler.h:29
CbmTrdPads.h
CbmTrdParModGain.h
CbmTrdGeoHandler::GetModuleOrientation
Int_t GetModuleOrientation(const TString &path)
Navigate to node and return pad orientation.
Definition: CbmTrdGeoHandler.cxx:107
CbmTrdParSetGain
Definition: CbmTrdParSetGain.h:16
CbmTrdParSet
Definition: CbmTrdParSet.h:19
CbmTrdHardwareSetupR::GetComponentId
std::uint64_t GetComponentId(Int_t asicAddress, ECbmTrdHardwareSetupVersion hwSetup)
Retrieve componentId of the asic add the passed address for the passed hwSetup.
Definition: CbmTrdHardwareSetupR.cxx:40
CbmTrdParManager::CreateParFilesFromGeometry
bool CreateParFilesFromGeometry(bool createRootFileOutput, TString outDir="")
Create parameter files from geometry in gGeoManager A run macro can be found in the trd cbm....
Definition: CbmTrdParManager.cxx:347
fst1_sect_count
Int_t fst1_sect_count
Definition: CbmTrdPads.h:11
CbmTrdGeoHandler::GetSizeZ
Double_t GetSizeZ(const TString &path)
Definition: CbmTrdGeoHandler.cxx:122
CbmTrdParManager::CreateModuleParameters
void CreateModuleParameters(const TString &path)
Definition: CbmTrdParManager.cxx:135
CbmTrdParManager::~CbmTrdParManager
virtual ~CbmTrdParManager()
Destructor.
Definition: CbmTrdParManager.cxx:57
CbmTrdParModGas::SetPidType
void SetPidType(Int_t like=1)
Definition: CbmTrdParModGas.h:101
CbmTrdParManager::Finish
virtual void Finish()
Inherited from FairTask.
Definition: CbmTrdParManager.cxx:124
CbmTrdGeoHandler.h
Helper class to extract information from the GeoManager.
CbmTrdParFasp.h
CbmTrdParModDigi
Definition of chamber gain conversion for one TRD module.
Definition: CbmTrdParModDigi.h:14
CbmTrdParModDigi.h
CbmTrdParSetGain.h
ClassImp
ClassImp(CbmConverterManager) InitStatus CbmConverterManager
Definition: CbmConverterManager.cxx:12
CbmTrdHardwareSetupR::SelectComponentIdMap
void SelectComponentIdMap(ECbmTrdHardwareSetupVersion hwSetup)
Definition: CbmTrdHardwareSetupR.cxx:271
CbmTrdParFasp
Definition of FASP parameters.
Definition: CbmTrdParFasp.h:74
CbmTrdParAsic::QueryChannel
virtual Int_t QueryChannel(Int_t ch) const
Query ASIC for specific pad address.
Definition: CbmTrdParAsic.cxx:30
CbmTrdParSetAsic::AddParameters
void AddParameters(CbmTrdParSetAsic *)
Definition: CbmTrdParSetAsic.cxx:201
CbmTrdParManager::ECbmTrdParSets::kCbmTrdParSetDigi
@ kCbmTrdParSetDigi
CbmTrdParSetDigi.h
CbmTrdParManager::fGeoHandler
CbmTrdGeoHandler * fGeoHandler
Definition: CbmTrdParManager.h:113
CbmTrdParManager::ECbmTrdParSets::kCbmTrdParSetGas
@ kCbmTrdParSetGas
CbmTrdParManager::fGeometryTag
TString fGeometryTag
Definition: CbmTrdParManager.h:115
CbmTrdParManager::fGasPar
CbmTrdParSetGas * fGasPar
The set of gas description parameters.
Definition: CbmTrdParManager.h:110
CbmTrdParSetAsic::SetAsicPar
virtual void SetAsicPar(Int_t address, CbmTrdParAsic *p)
Definition: CbmTrdParSetAsic.cxx:273
CbmTrdGeoHandler::GetSizeY
Double_t GetSizeY(const TString &path)
Definition: CbmTrdGeoHandler.cxx:117
x
Double_t x
Definition: CbmMvdSensorDigiToHitTask.cxx:68
CbmTrdParMod::SetModuleId
virtual void SetModuleId(Int_t m)
Definition: CbmTrdParMod.h:17
y
Double_t y
Definition: CbmMvdSensorDigiToHitTask.cxx:68
CbmTrdParSet.h
CbmTrdParManager::ECbmTrdParSets::kCbmTrdParSetAsic
@ kCbmTrdParSetAsic
CbmTrdParSetDigi
Definition: CbmTrdParSetDigi.h:15
CbmTrdParAsic::SetChannelAddress
virtual void SetChannelAddress(Int_t address)
Definition: CbmTrdParAsic.cxx:41
CbmTrdParManager::fAsicPar
CbmTrdParSetAsic * fAsicPar
The set of ASIC characterization parameters.
Definition: CbmTrdParManager.h:108
CbmTrdParSetGas.h
CbmTrdParManager::ECbmTrdParSets::kCbmTrdParSetGain
@ kCbmTrdParSetGain
CbmTrdGeoHandler::GetX
Double_t GetX(const TString &path)
Definition: CbmTrdGeoHandler.cxx:137
CbmTrdParModGas::SetDetType
void SetDetType(Int_t gsi=0)
Definition: CbmTrdParModGas.h:92
CbmTrdParManager::ECbmTrdParSets::kBegin
@ kBegin
CbmTrdParModGas::Print
virtual void Print(Option_t *opt="") const
Definition: CbmTrdParModGas.cxx:198
CbmTrdParManager::GetParFileExtensions
static void GetParFileExtensions(std::vector< std::string > *vec)
Definition: CbmTrdParManager.cxx:464
CbmTrdParModDigi::Print
void Print(Option_t *opt="") const
Definition: CbmTrdParModDigi.cxx:147
CbmTrdParModDigi::SetAnodeWireOffset
void SetAnodeWireOffset(Double_t off)
Definition: CbmTrdParModDigi.h:121
fst1_pad_type
Float_t fst1_pad_type[9][3][4]
Definition: CbmTrdPads.h:14
CbmTrdParFasp::SetCalibParameters
virtual Bool_t SetCalibParameters(Int_t ch, Double_t const *par)
Load FASP calibration parameters for a specific channel.
Definition: CbmTrdParFasp.cxx:77
CbmTrdParModGas
Definition of gas parameters for one TRD module.
Definition: CbmTrdParModGas.h:16
CbmTrdParModDigi::SetAnodeWireToPadPlaneDistance
void SetAnodeWireToPadPlaneDistance(Double_t d)
Definition: CbmTrdParModDigi.h:118
CbmTrdParModGain
Definition of gain parameters for one TRD module.
Definition: CbmTrdParModGain.h:9
CbmTrdParSetAsic::SetAsicType
virtual void SetAsicType(Int_t t)
Definition: CbmTrdParSetAsic.h:51
CbmTrdParModDigi::GetNofColumns
Int_t GetNofColumns() const
Definition: CbmTrdParModDigi.cxx:321
CbmTrdParManager::fGainPar
CbmTrdParSetGain * fGainPar
The set of gain conversion parameters.
Definition: CbmTrdParManager.h:111
CbmTrdParSpadic
Definition of SPADIC parameters.
Definition: CbmTrdParSpadic.h:16
CbmTrdParManager::Exec
virtual void Exec(Option_t *option)
Inherited from FairTask.
Definition: CbmTrdParManager.cxx:132
CbmTrdGeoHandler::GetZ
Double_t GetZ(const TString &path)
Definition: CbmTrdGeoHandler.cxx:127