StRoot  1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
StBFChain.cxx
1 // @(#)StRoot/StBFChain:$Name: $:$Id: StBFChain.cxx,v 1.670 2021/03/21 03:32:28 genevb Exp $
2 
3 #include "TROOT.h"
4 #include "TPRegexp.h"
5 #include "TString.h"
6 #include "TObjString.h"
7 #include "TSystem.h"
8 #include "TInterpreter.h"
9 #include "TClassTable.h"
10 #include "StMemStat.h"
11 #include "StBFChain.h"
12 #include "StBFChainOpt.h"
13 #include "St_db_Maker/St_db_Maker.h"
14 #include "StTreeMaker/StTreeMaker.h"
15 #include "StIOMaker/StIOMaker.h"
16 #include "StMessMgr.h"
17 #include "StShadowMaker/StShadowMaker.h"
18 #include "StEnumerations.h"
19 #include "TTree.h"
20 #include "TEnv.h"
21 #define STAR_LOGGER 1
22 // PLease, preserve the comment after = { . It is used for documentation formatting
23 //
24 #if 0
25 // Keep to be compatible with old documentaion
26 #define STR_OBSOLETE "WARNING *** Option is OBSOLETE ***"
27 
28 //#include "BFC.h"
29 // ITTF Chain will be put here. Option list starting from minimalistic requirements
30 // and may not initially work.
31 // Please, preserve the comment after = { . It is used for documentation formatting
32 //
33 // ITTF Chains
34 //#include "BFC2.h"
35 #endif
36 
37 // JL - define this once, use two places
38 #define BFC_DBREGEXP "(dbv|sdt)(\\d+)(_)(.*)(_)(.*)"
39 
40 
41 // NoChainOptions -> Number of chain options auto-calculated
42 TableImpl(Bfc);
43 ClassImp(StBFChain);
44 
45 StBFChain *chain = nullptr;
46 
47 //_____________________________________________________________________________
48 // Hack constructor.
59 void StBFChain::Setup(Int_t mode) {
60  static const Char_t *path = "./StRoot/StBFChain:$STAR/StRoot/StBFChain";
61  TString fileName("BFC.C");
62  Char_t *file = gSystem->Which(path,fileName,kReadPermission);
63 #ifdef STAR_LOGGER
64  if (! file) { LOG_FATAL << Form("StBFChain::Setup\tFile %s has not been found in path %s",fileName.Data(),path) << endm; }
65  else { LOG_WARN << Form("StBFChain::Setup\tFile %s has been found as %s",fileName.Data(),file) << endm; }
66 #else
67 
68  if (! file) Fatal("StBFChain::Setup","File %s has not been found in path %s",fileName.Data(),path);
69  else Warning("StBFChain::Setup","File %s has been found as %s",fileName.Data(),file);
70 #endif
71  TString cmd(".L ");
72  cmd += file;
73  gInterpreter->ProcessLine(cmd);
74  fchainOpt = (St_Bfc *) gInterpreter->Calc("CreateTable()");
75  cmd = ".U ";
76  cmd += file;
77  gInterpreter->ProcessLine(cmd);
78  assert(fchainOpt);
79  delete [] file;
80  fNoChainOptions = fchainOpt->GetNRows();
81  fBFC = fchainOpt->GetTable();
82  // add predifined time stamps and geometry versions
83  const DbAlias_t *DbAlias = GetDbAliases();
84  Bfc_st row = {"","","","db,detDb","","","",kFALSE};
85  for (Int_t i = 0; DbAlias[i].tag; i++) {
86  for (Int_t r = 0; r < 2; r++) {
87  TString dbTag("");
88  if (r) dbTag += "r";
89  dbTag += DbAlias[i].tag;
90  if (! kOpt(dbTag,kFALSE)) {
91  memset (&row.Key, 0, sizeof(row.Key));
92  memcpy (&row.Key, dbTag.Data(), dbTag.Length());
93  fchainOpt->AddAt(&row);
94  fNoChainOptions = fchainOpt->GetNRows();
95  fBFC = fchainOpt->GetTable();
96  }
97  }
98  }
99  FDate = FTime = 0;
100  FDateS = FTimeS = 0;
101  fFiltTrg = "";
102  fRunG = -1;
103  fFmsGainCorrTag="";
104  Gproperty.clear();
105  Gvalue.clear();
106  Gpattern.clear();
107 
108 
109 }
110 //_____________________________________________________________________________
112 StBFChain::~StBFChain(){
113  Finish();
114 }
115 //_____________________________________________________________________________
117 Int_t StBFChain::Load()
118 {
119  static const Char_t *prefix[3] = {"lib_","lib",""};
120  Int_t status = kStOk;
121  Int_t i, iok;
122  TString lib(gSystem->GetLibraries(0,"D"));
123  TObjArray LoadedLibs;
124  ParseString(lib,LoadedLibs);
125  TIter next(&LoadedLibs);
126  TObjString *LoadedLib;
127  while ((LoadedLib = (TObjString *) next())){
128  TString Base(gSystem->BaseName(LoadedLib->GetName()));
129  Base.ReplaceAll(".so","");
130  Base.ReplaceAll(".sl","");
131  if (Base.BeginsWith("lib_")) Base.ReplaceAll("lib_","");
132  if (Base.BeginsWith("lib")) Base.ReplaceAll("lib","");
133  LoadedLib->SetString(Base);
134  }
135  for (i = 1; i< fNoChainOptions; i++) { // Load Libraries if any
136  if (fBFC[i].Flag) {
137  if (strlen(fBFC[i].Libs) > 0) {
138  TObjArray Libs;
139  ParseString(fBFC[i].Libs,Libs);
140  TIter nextL(&Libs);
141  TObjString *libe = 0;
142  Char_t *path = 0;
143  while ((libe = (TObjString *) nextL())) {
144  TString libN(libe->GetString());
145  if (libN.BeginsWith("lib_")) libN.ReplaceAll("lib_","");
146  if (libN.BeginsWith("lib")) libN.ReplaceAll("lib","");
147 
148  TString libL("");
149  for (Int_t j = 0; j < 3; j++) {
150  libL = prefix[j]; libL += libN;
151  //LOG_QA << " Checking " << libL << endm;
152  if ((path = gSystem->DynamicPathName(libL,kTRUE))) break;
153  }
154  iok = -1;
155  if (path) {
156  TIter next(&LoadedLibs);
157  TObjString *LoadedLib;
158  while ((LoadedLib = (TObjString *) next())){
159  TString Base(LoadedLib->GetName());
160  //LOG_QA << " Checking " << Base << endm;
161  if (Base == libN) {iok = 1; break;}
162  }
163  if (iok > 0) continue;
164 
165 
166  //LOG_QA << "Trying to load Library " << libL << endm;
167 
168 
169  iok = gSystem->Load(libL);
170  if (iok < 0) {
171 
172  LOG_FATAL << "problem with loading of " << libL.Data() << endm;
173  LOG_FATAL << fBFC[i].Key << " is switched off \t!!!!" << endm;
174 
175  //fBFC[i].Flag = kFALSE;
176  //status = kStErr;
177  //assert(iok >= 0); ?? obviously it is so, but not very specific
178  Int_t libraryload = kStErr;
179  assert(libraryload!=kStErr); // this is obvious and will display an explicit
180  break;
181  } else {
182  LOG_QA << Form("Library %-22s [%15s] (%s)\tis loaded",libL.Data(),fBFC[i].Key,path) << endm;
183  StMemStat::doPs(libL.Data(), "Load");
184  LoadedLibs.Add(new TObjString(libN));
185  }
186  } else {
187  if ( ! index(fBFC[i].Libs,',') || Debug() > 1 ) {
188  LOG_WARN << "No path for Key=" << fBFC[i].Key << "-> Searched for [" << libL
189  << "] from Libs=" << fBFC[i].Libs << " (will proceed)" << endm;
190  }
191  }
192  }
193  Libs.Delete();
194  }
195  }
196  }
197  LoadedLibs.Delete();
198  return status;
199 }
200 
201 //_____________________________________________________________________________
203 
214 Int_t StBFChain::Instantiate()
215 {
216  Int_t status = kStOk;
217  Int_t i;
218  if (! fNoChainOptions) return status;
219  Long64_t maxsize = kMaxLong64;
220  TTree::SetMaxTreeSize(maxsize);
221  for (i = 1; i< fNoChainOptions; i++) {// Instantiate Makers if any
222  if (! fBFC[i].Flag) continue;
223  TString maker(fBFC[i].Maker);
224  if (maker == "") continue;
225  TString Key(fBFC[i].Key);
226  TString name(fBFC[i].Name);
227  Key.ToLower();
228  StMaker *myChain = 0;
229  StMaker *mk = 0;
230  // Require only instance for the following named makers
231  if (maker == "St_db_Maker" || maker == "StTpcDbMaker" ||
232  maker == "StSvtDbMaker" || maker == "StSsdDbMaker" || maker == "StSstDbMaker" ||
233  maker == "StDetectorDbMaker" ||
234  maker == "StMagFMaker" ||
235  maker == "StEEmcDbMaker" ||
236  maker == "St_geant_Maker" ||
237  maker == "StVMCMaker") {
238  mk = GetTopChain()->GetMakerInheritsFrom(maker);
239  if (mk) {
240  if (maker == "St_geant_Maker" || maker == "StVMCMaker") {
241  LOG_INFO << "StBFChain::Instantiate ignore request for instantiation of " << maker
242  << "(\"" << fBFC[i].Name << "\") because chain alreary has one." << endm;
243  continue;
244  }
245  if (name == "" || name == mk->GetName()) {
246  LOG_INFO << "StBFChain::Instantiate ignore request for instantiation of " << maker
247  << "(\"" << fBFC[i].Name << "\") because chain alreary has one"
248  << " but accumulate options" << endm;
249  //Accumulate option for these makers continue;
250  }
251  }
252  }
253  if (strlen(fBFC[i].Chain) > 0) myChain = GetMaker(fBFC[i].Chain);
254  if (maker == "St_db_Maker"){
255  if (Key.CompareTo("db",TString::kIgnoreCase) == 0) {
256  St_db_Maker* dbMk = (St_db_Maker *) mk;
257  if (! dbMk) {
258  TString MySQLDb("MySQL:StarDb");
259  TString MainCintDb("$STAR/StarDb");
260  TString MainCintDbObj("$STAR/.$STAR_HOST_SYS/obj/StarDb");
261  TString MyCintDb("$PWD/StarDb");
262  TString MyCintDbObj("$PWD/.$STAR_HOST_SYS/obj/StarDb");
263  if (GetOption("NoMySQLDb")) {MySQLDb = "";}
264  // Removed twice already and put back (start to be a bit boring)
265  // DO NOT REMOVE THE NEXT OPTION - Used in AutoCalibration
266  if (GetOption("NoLocalCintDb")) {MyCintDb = "";}
267  if (GetOption("NoStarCintDb") ) {MainCintDb = "";}
268  if (GetOption("NoCintDb") ) {MainCintDb = ""; MyCintDb = "";}
269 
270  TString Dirs[10];
271  Int_t j;
272  for (j = 0; j < 10; j++) Dirs[j] = "";
273  j = 0;
274  if (MySQLDb != "") {Dirs[j] = MySQLDb; j++;}
275  if (MainCintDb != "") {Dirs[j] = MainCintDb; j++;}
276  if (MainCintDbObj != "") {Dirs[j] = MainCintDbObj; j++;}
277  if (MyCintDb != "") {Dirs[j] = MyCintDb; j++;}
278  if (MyCintDbObj != "") {Dirs[j] = MyCintDbObj; j++;}
279  dbMk = new St_db_Maker(fBFC[i].Name,Dirs[0],Dirs[1],Dirs[2],Dirs[3],Dirs[4]);
280  if (!dbMk) goto Error;
281 
282  TString namec = dbMk->GetName();
283  int len = sizeof(fBFC[i].Name);
284  if ( namec.Length() <= len){
285  strncpy (fBFC[i].Name, namec.Data(),len);
286  } else {
287  gMessMgr->Error() << "Maker name [" << namec
288  << "] length is > " << len
289  << " - increase BFC Name field length" << endm;
290  }
291 
292  // Determine flavors
293  TString flavors = "ofl"; // default flavor for offline
294 
295  // fixed target flavor
296  if (GetOption("FXT")) flavors.Prepend("FXT+");
297 
298  // simulation flavors
299  if (GetOption("Simu") && ! GetOption("NoSimuDb")) flavors.Prepend("sim+");
300 
301  // filestream flavors
302  if (fSetFiles) {
303  TString firstFileName = fSetFiles->GetFileName(0);
304  firstFileName = firstFileName(firstFileName.Last('/')+1,firstFileName.Length());
305  if (firstFileName.BeginsWith("st_")) {
306  TString fileStream = firstFileName(3,firstFileName.Index('_',3)-3);
307  if (fileStream.Length()>0) flavors.Prepend(fileStream += '+');
308  }
309  }
310 
311  LOG_INFO << "Using DB flavors: " << flavors << endm;
312  dbMk->SetFlavor(flavors.Data());
313  mk = dbMk;
314  }
315  if (GetOption("dbSnapshot")) dbMk->SetAttr("dbSnapshot","dbSnapshot.root",dbMk->GetName());
316  SetDbOptions(dbMk);
317  }
318  goto Add2Chain;
319  }
320  if (!mk && maker == "StIOMaker" && fSetFiles) {
321  StIOMaker *inpMk=0;
322  if (GetOption("InTree")) {
323  Char_t line[80] = "bfcTree";
324  Int_t k = kOpt("InTree");
325  sscanf(fBFC[k].Comment,"%s",line);
326  inpMk = new StIOMaker("inputStream","r",fSetFiles,line);
327  }
328  else inpMk = new StIOMaker("inputStream","r",fSetFiles);
329  mk = inpMk;
330  if (mk) {
331  TString namec = mk->GetName();
332  int len = sizeof(fBFC[i].Name);
333  if ( namec.Length() <= len){
334  strncpy (fBFC[i].Name, namec.Data() , len);
335  } else {
336  gMessMgr->Error() << "Maker name [" << namec
337  << "] length is > " << len
338  << " - increase BFC Name field length" << endm;
339  }
340 
341  SetInput("StDAQReader",".make/inputStream/.make/inputStream_DAQ/.const/StDAQReader");
342  if (GetOption("ReadAll")) { //activate all branches
343  // inpMk->SetBranch("*",0,"r");
344  const Char_t *allBranches[] = {
345  "emc_rawBranch","eventBranch","ftpc_rawBranch",
346  "geantBranch","globalBranch","McEventBranch","svt_hitsBranch","svt_tracksBranch",
347  "tpc_hitsBranch","trgBranch",0};
348  for (Int_t i = 0; allBranches[i]; i++) inpMk->SetBranch(allBranches[i],0,"r");
349  }
350  if (GetOption("adcOnly")) mk->SetAttr("adcOnly",1); ;
351  goto Add2Chain;
352  }
353  goto Error;
354  }
355  if (!mk && maker == "StTreeMaker" && fFileOut != "") {
356  StTreeMaker *treeMk = 0;
357  if (GetOption("OutTree")) {
358  Char_t line[80] = "bfcTree";
359  Int_t k = kOpt("OutTree");
360  sscanf(fBFC[k].Comment,"%s",line);
361  treeMk = new StTreeMaker("outputStream",fFileOut.Data(),line);
362  }
363  else treeMk = new StTreeMaker("outputStream",fFileOut.Data());
364  mk = treeMk;
365  if (mk) {
366  TString namec = treeMk->GetName();
367  int len = sizeof(fBFC[i].Name);
368  if ( namec.Length() <= len ){
369  strncpy (fBFC[i].Name, namec.Data() , len);
370  } else {
371  gMessMgr->Error() << "Maker name [" << namec
372  << "] length is > " << len
373  << " - increase BFC Name field length" << endm;
374  }
375  treeMk->SetIOMode("w");
376  SetTreeOptions();
377  goto Add2Chain;
378  }
379  }
380  // Special makers already created or action which
381  // need to take place before 'maker' is created.
382  if (! mk) {
383  if (strlen(fBFC[i].Name) > 0) mk = New(fBFC[i].Maker,fBFC[i].Name);
384  else mk = New(fBFC[i].Maker);
385  if (! mk) {
386  LOG_FATAL << Form("StBFChain::Instantiate() problem with instantiation Maker=[%s] Name=[%s]",fBFC[i].Maker,fBFC[i].Name) << endm;
387  assert(mk);
388  }
389  }
390 
391  {
392  TString namec = mk->GetName();
393  int len = sizeof(fBFC[i].Name);
394  if ( namec.Length() <= len){
395  strncpy (fBFC[i].Name,namec.Data(),len);
396  } else {
397  gMessMgr->Error() << "Maker name [" << namec
398  << "] length is > " << len
399  << " - increase BFC Name field length" << endm;
400  }
401  }
402 
403  if (maker == "StTpcDbMaker" && GetOption("laserIT")) mk->SetAttr("laserIT" ,kTRUE);
404  if (maker == "StDAQMaker") {
405  if (GetOption("adcOnly")) mk->SetAttr("adcOnly",1); ;
406  }
407 
408  if (maker == "St_geant_Maker") { // takes only first request for geant, if it is active then it should be the first one
409  Int_t NwGeant = 10; // default geant parameters
410  if (!GetOption("fzin") &&
411  !GetOption("ntin") &&
412  !GetOption("gstar") &&
413  !GetOption("pythia")) NwGeant = 5;
414  if (GetOption("big")) NwGeant = 20;
415  if (GetOption("bigbig")) NwGeant = 40;
416  if (GetOption("huge")) NwGeant = 80;
417  ProcessLine(Form("((St_geant_Maker *) %p)->SetNwGEANT(%i);",mk,NwGeant));
418  if (GetOption("Higz")) ProcessLine(Form("((St_geant_Maker *) %p)->SetIwtype(1);",mk));
419  if (GetOption("paw")) ProcessLine(Form("((St_geant_Maker *) %p)->SetNwPAW(2);",mk));
420  if (GetOption("fzin") ||
421  GetOption("ntin") ||
422  GetOption("gstar") ||
423  GetOption("pythia") ||
424  GetOption("hijing") ||
425  GetOption("PrepEmbed") ||
426  GetOption("mtin")) {
427  mk->SetActive(kTRUE);
428  // if (GetOption("PrepEmbed")) mk->SetMode(10*(mk->GetMode()/10)+1);
429  if (GetOption("PrepEmbed") || GetOption("pythiaEmbed")) mk->SetAttr("Don'tTouchTimeStamp",kTRUE);
430  if (GetOption("flux")) mk->SetAttr("flux",kTRUE);
431  if (GetOption("pythia")) {
432  mk->SetAttr("Pythia",kTRUE);
433  if (GetOption("Wenu")) mk->SetAttr("Wenu",kTRUE);
434  if (GetOption("beamLine")) mk->SetAttr("beamLine",kTRUE);
435  }
436  if (GetOption("hijing")) {
437  mk->SetAttr("hijing",kTRUE);
438  }
439  }
440  else mk->SetActive(kFALSE);
441  //if (! mk) goto Error;
442  SetGeantOptions(mk);
443  }
444 
445  // special maker options
446  // m_Mode xyz
447  // x = 1 phys_off
448  // y = 1 Passive mode (do not call RunMC()
449  // z = 1 Mixer Mode
450  if (maker == "StVMCMaker") {
451  if (GetOption("VMCPassive")) {// don't use mk->SetActive(kFALSE) because we want to have InitRun
452  mk->SetAttr("VMCPassive",kTRUE);
453  }
454  else {
455  if (GetOption("phys_off")) mk->SetAttr("phys_off",kTRUE);
456  if (GetOption("hadr_off")) mk->SetAttr("hadr_off",kTRUE);
457  if (fInFile != "") {
458  if (ProcessLine(Form("((StVMCMaker *) %p)->SetInputFile(\"%s\")",mk,fInFile.Data())))
459  goto Error;
460  }
461  }
462  if (GetOption("Embedding")) mk->SetAttr("Embedding",kTRUE);
463  }
464 
465  // ---
466  // Sti(ITTF) start
467  // ---
468  if (maker == "StiMaker" || maker == "StiVMCMaker" ) {
469 
470  // When StiCA library is requested CA will be used as seed finder in StiMaker
471  if ( GetOption("StiCA") ) {
472  mk->SetAttr("seedFinders", "CA DEF");
473  }
474 
475  // Option to re-use hits in other tracks
476  if ( GetOption("hitreuseon") ){
477  mk->SetAttr("SetMaxTimes", 100);
478  }
479 
480  // By default iTpc hits are used in tracking
481  mk->SetAttr("activeiTpc", GetOption("iTpcIT") ? kTRUE : kFALSE);
482 
483  // old logic for svt and ssd
484  if (GetOption("NoSvtIT")){
485  mk->SetAttr("useSvt" ,kFALSE);
486  } else {
487  if (GetOption("SvtIT")){
488  mk->SetAttr("useSvt" ,kTRUE);
489  mk->SetAttr("activeSvt" ,kTRUE);
490  }
491  }
492  if ( GetOption("NoSsdIT") &&
493  !GetOption("SstIT") ){
494  mk->SetAttr("useSsd" ,kFALSE);
495  } else {
496  if (GetOption("SsdIT")){
497  mk->SetAttr("useSsd" ,kTRUE);
498  mk->SetAttr("activeSsd" ,kTRUE);
499  }
500  }
501 
502  // this was an R&D detector never implemented
503  // simulations were made nonetheless
504  if (GetOption("HpdIT")){
505  mk->SetAttr("useHpd" ,kTRUE);
506  mk->SetAttr("activeHpd" ,kTRUE);
507  }
508 
509  // back to the HFT sub-system
510  if (GetOption("NoPxlIT")) {
511  mk->SetAttr("usePxl" ,kTRUE);
512  mk->SetAttr("usePixel" ,kTRUE);
513  } else {
514  if (GetOption("PixelIT") || GetOption("PxlIT") ){
515  mk->SetAttr("usePxl" ,kTRUE);
516  mk->SetAttr("usePixel" ,kTRUE);
517  mk->SetAttr("activePxl" ,kTRUE);
518  mk->SetAttr("activePixel",kTRUE);
519  }
520  }
521  if (GetOption("NoIstIT")) {
522  mk->SetAttr("useIst" ,kTRUE);
523  } else {
524  if (GetOption("IstIT")){
525  mk->SetAttr("useIst" ,kTRUE);
526  mk->SetAttr("activeIst" ,kTRUE);
527  }
528  }
529  if (GetOption("NoSstIT")) {
530  mk->SetAttr("useSst" ,kTRUE);
531  } else {
532  if (GetOption("SstIT")){
533  mk->SetAttr("useSst" ,kTRUE);
534  mk->SetAttr("activeSst" ,kTRUE);
535  }
536  }
537 
538  // other sub-systems
539  if (GetOption("BTofIT")){
540  mk->SetAttr("useBTof" ,kTRUE);
541  mk->SetAttr("activeBTof" ,kTRUE);
542  }
543 
544  if (GetOption("StiPulls")) mk->SetAttr("makePulls" ,kTRUE);
545  if (GetOption("skip1row")) mk->SetAttr("skip1row" ,kTRUE);
546  if (GetOption("EastOff")) mk->SetAttr("EastOff" ,kTRUE);
547  if (GetOption("WestOff")) mk->SetAttr("WestOff" ,kTRUE);
548  if (GetOption("laserIT")) mk->SetAttr("laserIT" ,kTRUE);
549  if (GetOption("Alignment")) mk->SetAttr("Alignment" ,kTRUE);
550  if (GetOption("Cosmics")) mk->SetAttr("Cosmics" ,kTRUE);
551  mk->PrintAttr();
552  }
553 
554  if (maker== "StGmtClusterMaker") {
555  if (GetOption("gmtCosmics")) mk->SetAttr("gmtCosmics", kTRUE);
556  }
557 
558  if (maker=="StKFVertexMaker" && GetOption("laserIT")) mk->SetAttr("laserIT" ,kTRUE);
559  // Sti(ITTF) end
560  if (maker=="StGenericVertexMaker") {
561  // VertexFinder methods
562  if (GetOption("Sti") || GetOption("StiCA") || GetOption("StiVMC" ) ) mk->SetAttr("ITTF" , kTRUE);
563  if (GetOption("VFMinuit" ) ) mk->SetAttr("VFMinuit" , kTRUE);
564  if (GetOption("VFppLMV" ) ) mk->SetAttr("VFppLMV" , kTRUE);
565  if (GetOption("VFppLMV5" ) ) mk->SetAttr("VFppLMV5" , kTRUE);
566  if ( GetOption("VFPPVEv") ) {
567  gSystem->Load("StBTofUtil.so");
568  mk->SetAttr("VFPPVEv" , kTRUE);
569  }
570  else if (GetOption("VFPPV") && GetOption("Sti")) mk->SetAttr( "VFPPV", kTRUE);
571  if (GetOption("VFPPVEvNoBtof")){
572  gSystem->Load("StBTofUtil.so"); //Not used but loaded to avoid fail
573  mk->SetAttr("VFPPVEvNoBtof", kTRUE);
574  }
575  if (GetOption("VFPPVnoCTB" ) ) mk->SetAttr("VFPPVnoCTB" , kTRUE);
576  if (GetOption("VFFV" ) ) mk->SetAttr("VFFV" , kTRUE);
577  if (GetOption("VFMCE" ) ) mk->SetAttr("VFMCE" , kTRUE);
578  if (GetOption("VFMinuit2" ) ) mk->SetAttr("VFMinuit2" , kTRUE);
579  if (GetOption("VFMinuit3" ) ) mk->SetAttr("VFMinuit3" , kTRUE);
580  if (GetOption("beamLine" ) ) mk->SetAttr("BeamLine" , kTRUE);
581  if (GetOption("beamLine3D" ) ) mk->SetAttr("BeamLine3D" , kTRUE);
582  if (GetOption("CtbMatchVtx") ) mk->SetAttr("CTB" , kTRUE);
583  if (GetOption("min2trkVtx" ) ) mk->SetAttr("minTracks" , 2);
584  if (GetOption("VtxSeedCalG") ) mk->SetAttr("calibBeamline" , kTRUE);
585  if (GetOption("usePct4Vtx" ) ) mk->SetAttr("PCT" , kTRUE);
586  if (GetOption("useBTOF4Vtx") ) mk->SetAttr("BTOF" , kTRUE);
587  if (GetOption("useBTOFmatchOnly") ) mk->SetAttr("useBTOFmatchOnly", kTRUE);
588  if (GetOption("FXT" ) ) mk->SetAttr("FXT" , kTRUE);
589 
590  // X-tended works only for VFPPV, VFPPVnoCTB, VFPPVev for now but could be re-used
591  // However, we will change this to a more flexible arbitrarry setting later
592  if (GetOption("VFStoreX") ) mk->SetAttr("VFStore" , 100);
593  //if (GetOption("VFStoreX") ) mk->SetAttr("VFStore" , 100);
594  mk->PrintAttr();
595  }
596  if (maker=="StKFVertexMaker") {
597  if (GetOption("beamLine" ) ) mk->SetAttr("BeamLine" , kTRUE);
598  }
599  if (maker=="StAssociationMaker") {
600 
601  LOG_QA << "StBFChain::Instantiate Setting the Parameters for the Association Maker" << endm;
602 
603  TString cmd("");
604  if (GetOption("ITTF") || GetOption("StiVMC") || GetOption("useInTracker"))
605  cmd = Form ("((StAssociationMaker *) %p)->useInTracker();",mk);
606  cmd += "StMcParameterDB* parameterDB = StMcParameterDB::instance();";
607  // TPC
608 #if 0
609  cmd += "parameterDB->setXCutTpc(.5);"; // 5 mm
610  cmd += "parameterDB->setYCutTpc(.5);"; // 5 mm
611  cmd += "parameterDB->setZCutTpc(.5);"; // 5 mm
612 #endif
613  cmd += "parameterDB->setReqCommonHitsTpc(3);"; // Require 3 hits in common for tracks to be associated
614  // FTPC
615 #if 0
616  cmd += "parameterDB->setRCutFtpc(.3);"; // 3 mm
617  cmd += "parameterDB->setPhiCutFtpc(5*(3.1415927/180.0));"; // 5 degrees
618 #endif
619  cmd += "parameterDB->setReqCommonHitsFtpc(3);"; // Require 3 hits in common for tracks to be associated
620  // SVT
621 #if 0
622  cmd += "parameterDB->setXCutSvt(.08);"; // 800 um
623  cmd += "parameterDB->setYCutSvt(.08);"; // 800 um
624  cmd += "parameterDB->setZCutSvt(.08);"; // 800 um
625 #endif
626  cmd += "parameterDB->setReqCommonHitsSvt(1);"; // Require 1 hits in common for tracks to be associated
627  if (GetOption("IdTruth")) cmd += Form("((StAssociationMaker *) %p)->useIdAssoc();",mk);
628  ProcessLine(cmd);
629  }
630  if (maker == "StMiniMcMaker" && GetOption("IdTruth") && ! GetOption("OldMiniMc")) {
631  mk->SetMode(1);
632  gMessMgr->QAInfo() << "StBFChain::Instantiate create simplified MiniMcTree in " << maker << endm;
633  }
634  // usually, we do maker first and option second but the
635  // logic is more readable with option first here (as it
636  // got a bit out of hand)
637  if (GetOption("ppOpt") ) { // pp specific stuff
638  if (maker == "StTrsMaker")
639  mk->SetMode(1); // Pile-up correction
640  }
641 
642  if (maker == "StStrangeMuDstMaker" && GetOption("CMuDST")&& GetOption("StrngMuDST") ) {
643 
644  mk -> SetAttr( "DoV0", 1 );
645  mk -> SetAttr( "DoXi", 1 );
646  mk -> SetAttr( "DoKink", 1 );
647  mk -> SetAttr( "SetNoKeep", 1 );
648 
649  }
650 
651  // Alex requested an option (not turned by default) to disable all
652  // hit reco cuts. This will make allm hits saved to MuDST /ezTree.
653  if ( maker == "StEmcRawMaker" && GetOption("BEmcDebug"))
654  mk->SetMode(1); // only one option now, bit a bitmask
655 
656  // Use status tables for raw BEMC data (helpful for QA)
657  if ( maker == "StEmcRawMaker" && GetOption("BEmcChkStat"))
658  mk->SetAttr("BEmcCheckStatus",kTRUE);
659 
660  // trigger simu maker
661  if ( maker == "StEmcRawMaker" && GetOption("picoWrite") ) {
662  mk->SetMode(10); // picoDst production - save all BTOW hits for triggerSimuMaker
663  }
664 
665  // trigger simu maker
666  if ( maker == "StTriggerSimuMaker" && GetOption("picoWrite") ) {
667  mk->SetMode(10); // picoDst production
668  }
669 
670  // MuDST and ezTree. Combinations are
671  // ezTree -> ezTree only
672  // CMuDST -> regular MuDST only
673  // ezTree,CMuDST -> both
674  if (maker == "StMuDstMaker" && GetOption("ezTree") ){
675  TString cmd(Form("StMuDstMaker *pMuMk = (StMuDstMaker *) %p;",mk));
676  if ( ! GetOption("CMuDST")) cmd += "pMuMk->SetStatus(\"*\",0);";
677  cmd += "pMuMk->SetStatus(\"EztAll\",1);";
678  ProcessLine(cmd);
679  }
680 
681  // FST Raw hits in StEvent
682  if (maker == "StFstRawHitMaker" && GetOption("fstEvtRawHit") ){
683  mk->SetAttr("fstEvtRawHit", kTRUE);
684  }
685 
686  // FST Raw hits in MuDST
687  if (maker == "StMuDstMaker" && GetOption("fstMuRawHit") ){
688  mk->SetAttr("fstMuRawHit", kTRUE);
689  }
690 
691  if ( maker == "StPicoDstMaker"){
692  if ( GetOption("picoWrite") ) mk->SetMode(1);
693  if ( GetOption("picoRead") ) mk->SetMode(2); // possibly more magic
694  if ( GetOption("PicoVtxVpd")) mk->SetAttr("PicoVtxMode", "PicoVtxVpd");
695  else if ( GetOption("PicoVtxFXT")) mk->SetAttr("PicoVtxMode", "PicoVtxFXT");
696  else if ( GetOption("PicoVtxMtd")) mk->SetAttr("PicoVtxMode", "PicoVtxMtd");
697  else if ( GetOption("PicoVtxVpdOrDefault")) mk->SetAttr("PicoVtxMode", "PicoVtxVpdOrDefault");
698  else if ( GetOption("PicoVtxDefault")) mk->SetAttr("PicoVtxMode", "PicoVtxDefault");
699  if ( GetOption("PicoCovMtxWrite")) mk->SetAttr("PicoCovMtxMode", "PicoCovMtxWrite");
700  else if ( GetOption("PicoCovMtxSkip")) mk->SetAttr("PicoCovMtxMode", "PicoCovMtxSkip"); // Default mode
701  if ( GetOption("PicoBEmcSmdWrite")) mk->SetAttr("PicoBEmcSmdMode", "PicoBEmcSmdWrite");
702  else if ( GetOption("PicoBEmcSmdSkip")) mk->SetAttr("PicoBEmcSmdMode", "PicoBEmcSmdSkip"); // Default mode
703  }
704 
705 
706  if (maker == "StLaserEventMaker"){
707  // Bill stuff - Empty place-holder
708  }
709  if (maker == "StDetectorDbMaker") {
710  if ( GetOption("DbRichSca") ) mk->SetMode(1);
711  }
712  if (maker == "StTpcRSMaker") {
713  if (! GetOption("TrsToF")) {
714  Int_t mode = mk->GetMode();
715  mode |= (1 << 10); // kNoToflight //10 don't account for particle time of flight
716  mk->SetMode(mode);
717  }
718  if (GetOption("EbyET0")) mk->SetAttr("EbyET0", kTRUE);
719  }
720  if (maker == "StTrsMaker") {
721  Int_t mode = 0;
722  if (GetOption("TrsPileUp")) mode += 1; // Pile-up correction
723  if (GetOption("TrsToF")) mode += 2; // account for particle time of flight
724  if (mode) mk->SetMode(mode);
725  }
726 
727  // Place-holder. Would possibly be a bitmask
728  if (maker == "StTofrMatchMaker"){
729  mk->SetMode(0);
730  }
731 
732  if (maker == "StSpaceChargeEbyEMaker") {
733  if ( GetOption("SpcChgCal") ||
734  GetOption("SpcChgCalG")) mk->SetMode(2);
735  if ( GetOption("SCScalerCal") ) mk->SetMode(4);
736  if ( GetOption("EastOff")) mk->SetAttr("EastOff",kTRUE);
737  if ( GetOption("WestOff")) mk->SetAttr("WestOff",kTRUE);
738  }
739  if (maker == "StEventQAMaker") {
740  if ( GetOption("QAalltrigs")) mk->SetAttr("allTrigs",kTRUE);
741  if ( GetOption("QAallevents")) mk->SetAttr("allEvents",kTRUE);
742  }
743  //Special options for V0s and Xis using estGlobal tracks
744  if(maker=="StV0FinderMaker" && Key=="v0svt"){
745  TString cmd(Form("StV0FinderMaker *V0mk=(StV0FinderMaker*) %p;",mk));
746  cmd += "V0mk->SetLanguageUsage(0);";
747  cmd += "V0mk->SetSVTUsage(1);";
748  cmd += "V0mk->SetV0LanguageUsage(3);";
749  ProcessLine(cmd);
750  }
751  if(maker=="StXiFinderMaker" && Key=="xisvt"){
752  TString cmd(Form("StXiFinderMaker *Ximk=(StXiFinderMaker*) %p;",mk));
753  cmd += "Ximk->SetLanguageUsage(0);";
754  cmd += "Ximk->SetSVTUsage(1);";
755  cmd += "Ximk->SetV0LanguageUsage(3);";
756  cmd += "Ximk->SetXiLanguageUsage(5);";
757  ProcessLine(cmd);
758  }
759 
760  // TPC
761  if (maker == "StTpcRTSHitMaker") {
762  if ( GetOption("TpxClu2D")) mk->SetAttr("TpxClu2D", kTRUE);
763  if ( GetOption("TPC23")) mk->SetAttr("TPC23", kTRUE);
764  }
765  if (maker == "StTpcDbMaker"){
766  if ( GetOption("Simu") && ! GetOption("NoSimuDb")) mk->SetAttr("Simu",kTRUE);
767  if ( GetOption("useLDV") ) mk->SetAttr("useLDV",kTRUE) ;// uses laserDV database
768  if ( GetOption("useCDV") ) mk->SetAttr("useCDV",kTRUE) ;// uses ofl database
769  if ( GetOption("useNewLDV") ) mk->SetAttr("useNewLDV",kTRUE);// uses new laserDV
770  if ( GetOption("shadow") ) mk->SetAttr("NoReset",kTRUE);// no resetting ExB
771  if ( GetOption("ExB")){
772  mk->SetAttr("ExB", kTRUE); // bit 0 is ExB ON or OFF
773  if ( GetOption("EB1") ) mk->SetAttr("EB1", kTRUE);
774  else if ( GetOption("EB2") ) mk->SetAttr("EB2", kTRUE);
775  else {
776  // depend on RY option i.e. take default for that RealYear data
777  // expectations.
778  if(GetOption("RY1H") ||
779  GetOption("RY2000") ||
780  GetOption("RY2001") ||
781  GetOption("RY2001N") ||
782  GetOption("RY2003") ||
783  GetOption("RY2003X")) mk->SetAttr("OldRuns", kTRUE);
784  }
785  // Other options introduced in October 2001 for distortion corrections
786  // studies and year1 re-production. Those are OR additive to the mask.
787  //(void) printf("StBFChain:: Options list : %d %d %d %d %d %d %d %d\n",
788  // kPadrow13,kTwist,kClock,kMembrane,kEndcap,
789  // kIFCShift,kSpaceCharge,kSpaceChargeR2);
790  if( GetOption("OBmap") ) mk->SetAttr("OBmap" , kTRUE);
791  if( GetOption("OPr13") ) mk->SetAttr("OPr13" , kTRUE);
792  if( GetOption("OPr40") ) mk->SetAttr("OPr40" , kTRUE);
793  if( GetOption("OTwist") ) mk->SetAttr("OTwist" , kTRUE);
794  if( GetOption("OClock") ) mk->SetAttr("OClock" , kTRUE);
795  if( GetOption("OCentm") ) mk->SetAttr("OCentm" , kTRUE);
796  if( GetOption("OECap") ) mk->SetAttr("OECap" , kTRUE);
797  if( GetOption("OIFC") ) mk->SetAttr("OIFC" , kTRUE);
798  if( GetOption("OSpaceZ") ) mk->SetAttr("OSpaceZ" , kTRUE);
799  if( GetOption("OSpaceZ2") ) {
800  if( GetOption("FXT") ) mk->SetAttr("OSpaceFXT" , kTRUE);
801  else mk->SetAttr("OSpaceZ2" , kTRUE);
802  }
803  if( GetOption("OShortR") ) mk->SetAttr("OShortR" , kTRUE);
804  if( GetOption("OBMap2d") ) mk->SetAttr("OBMap2d" , kTRUE);
805  if( GetOption("OGridLeak") ) mk->SetAttr("OGridLeak" , kTRUE);
806  if( GetOption("OGridLeak3D")) mk->SetAttr("OGridLeak3D", kTRUE);
807  if( GetOption("OGridLeakFull")) mk->SetAttr("OGridLeakFull", kTRUE);
808  if( GetOption("OGGVoltErr") ) mk->SetAttr("OGGVoltErr" , kTRUE);
809  if( GetOption("OSectorAlign"))mk->SetAttr("OSectorAlign",kTRUE);
810  if( GetOption("ODistoSmear")) mk->SetAttr("ODistoSmear", kTRUE);
811  if( GetOption("OAbortGap")) mk->SetAttr("OAbortGap" , kTRUE);
812  }
813  mk->PrintAttr();
814  }
815  if (maker == "StTpcHitMover" && GetOption("EbyET0")) {
816  mk->SetAttr("EbyET0", kTRUE);
817  }
818  if ((maker == "StdEdxY2Maker" || maker == "StTpcHitMover") &&
819  GetOption("EmbeddingShortCut")) {
820  mk->SetAttr("EmbeddingShortCut", kTRUE);
821  mk->PrintAttr();
822  }
823  if (maker == "StdEdxY2Maker" && !GetOption("CalcdNdx")) {
824  mk->SetAttr("SkipdNdx", kTRUE);
825  }
826  if (maker == "StSvtDbMaker" || maker == "StSsdDbMaker"){
827  mk->SetMode(0);
828  // If simulation running make sure pick up simu stuff from db
829  if (GetOption("Simu") && ! GetOption("NoSimuDb")) mk->SetMode(1);
830  }
831 
832  // FTPC
833  if ((maker == "StFtpcClusterMaker" ||
834  maker == "StFtpcTrackMaker" ) &&
835  GetOption("fdbg")) mk->SetMode(mk->GetMode()+2);
836  if ( ( maker == "StFtpcClusterMaker" || // ?
837  maker == "StFtpcTrackMaker" ) &&
838  GetOption("flaser")) mk->SetMode(mk->GetMode()+1);
839 
840  if ((maker == "StFtpcClusterMaker" ||
841  maker == "StFtpcTrackMaker" ) &&
842  GetOption("fgain")) mk->SetMode(mk->GetMode()+4);
843 
844 
845  // PMD
846  if ( maker == "StPmdReadMaker" &&
847  GetOption("pmdRaw")) mk->SetAttr("pmdRaw",kTRUE);
848 
849  // HFT
850  //if (maker == "StPxlSimMaker" &&
851  // GetOption("pxlSlowSim")) mk->SetAttr("useDIGMAPSSim",kTRUE);
852  // ... PXL
853  if (maker == "StPxlSimMaker") {
854  if (GetOption("pxlSlowSim")) mk->SetAttr("useDIGMAPSSim",kTRUE);
855  }
856 
857  //FMS GainCorrection flavors
858  if (maker == "StFmsDbMaker"){
859  if(fFmsGainCorrTag!="") mk->SetAttr("FmsGainCorr",fFmsGainCorrTag.Data());
860  }
861 
862  // Hit filtering will be made from a single maker in
863  // future with flexible filtering method
864  if (maker == "StHitFilterMaker") {
865  if (GetOption("SvtHitFilt")){
866  // Filter out SVT bad hits, TPC hits not on tracks and all hits if fabs(ZVert)>30
867  LOG_QA << "SVT hit filter is ON" << endm;
868  TString cmd(Form("StHitFilterMaker *Filtmk=(StHitFilterMaker*) %p;",mk));
869  cmd += "Filtmk->setPtLowerCut(-99.);";
870  cmd += "Filtmk->setPtUpperCut(-99.);";
871  cmd += "Filtmk->setAbsEtaCut(-99);";
872  cmd += "Filtmk->setAbsZVertCut(30);";
873  ProcessLine(cmd);
874  } else if (GetOption("TpcHitFilt")){
875  // Filter out TPC hits not on tracks
876  LOG_QA << "TPC hit filter is ON" << endm;
877  TString cmd(Form("StHitFilterMaker *Filtmk=(StHitFilterMaker*) %p;",mk));
878  cmd += "Filtmk->setPtLowerCut(-99.);";
879  cmd += "Filtmk->setPtUpperCut(-99.);";
880  cmd += "Filtmk->setAbsEtaCut(-99);";
881  cmd += "Filtmk->setAbsZVertCut(999);";
882  ProcessLine(cmd);
883  } else if (GetOption("HftHitFilt")){
884  // Filter out TPC hits not on tracks
885  LOG_QA << "HFT hit filter is ON" << endm;
886  TString cmd(Form("StHitFilterMaker *Filtmk=(StHitFilterMaker*) %p;",mk));
887  cmd += "Filtmk->setAbsZVertCut(-1);";
888  cmd += "Filtmk->setKeepWestHighEtaHitsForFgt(0);";
889  ProcessLine(cmd);
890  } else {
891  LOG_QA << "Default hit filtering is ON" << endm;
892  }
893  Int_t mode = 0;
894  if (GetOption("KeepTpcHit")) mode |= (1 << kTpcId);
895  if (GetOption("KeepSvtHit")) mode |= (1 << kSvtId);
896  mk->SetMode(mode);
897  // the m_Mode (Int_t is signed integer 4 bytes) mask is too short for the FGT
898  if (GetOption("KeepFgtHit")){
899  TString cmd(Form("StHitFilterMaker *Filtmk=(StHitFilterMaker*) %p;",mk));
900  cmd += "Filtmk->setKeepWestHighEtaHitsForFgt(1.0);";
901  ProcessLine(cmd);
902  }
903  }
904  if (maker == "StMiniMcMaker" && fFileOut != "") {
905  ProcessLine(Form("((StMiniMcMaker *) %p)->setFileName(\"%s\");", mk, fFileOut.Data()));
906  }
907  if (maker == "StMcAnalysisMaker") {
908  Int_t mode = 0;
909  if (GetOption("McAnaTpc")) mode += 0x1;
910  if (GetOption("McAnaSvt")) mode += 0x2;
911  if (GetOption("McAnaSsd")) mode += 0x4;
912  if (mode)
913  ProcessLine(Form("((StMaker *) %p)->SetMode(%i);", mk, mode));
914  }
915  if (maker == "StBTofCalibMaker") {
916  if (GetOption("UseProjectedVertex")) mk->SetAttr("UseProjectedVertex",kTRUE);
917  if (GetOption("setOutlierRej4BToft0")) mk->SetAttr("setPPPAOutlierRej", kTRUE);
918  if (GetOption("ImpBToFt0Mode")) mk->SetAttr("pppAMode", kTRUE);
919  if (GetOption("btofFXT")) mk->SetAttr("btofFXT", kTRUE);
920  }
921  if (maker == "StVpdCalibMaker" && GetOption("ImpBToFt0Mode")) mk->SetAttr("pppAMode", kTRUE);
922 
923  if (maker == "StEventMaker" && fFiltTrg.Length()) {
924  mk->SetAttr("FiltTrg",(Int_t) (fFiltTrg.BeginsWith('+') ? 1 : -1));
925  TString FiltTrgFlavor = fFiltTrg(1,128);
926  if (FiltTrgFlavor.Length())
927  SetFlavor((FiltTrgFlavor += "+ofl").Data(),"trgOfflineFilter");
928  }
929  if (maker == "StTagsMaker"){
930  if ( GetOption("shadow") ) mk->SetAttr("shadow",kTRUE);
931  }
932 
933  Add2Chain:
934  if (! mk) continue;
935  if (name == "") strncpy (fBFC[i].Name,(Char_t *) mk->GetName() , sizeof(fBFC[i].Name));
936  if (myChain) myChain->AddMaker(mk);
937  continue;
938  Error:
939  status = kStErr;
940  LOG_QA << " ======================================" << endm;
941  LOG_QA << " problem with Instantiation of " << fBFC[i].Maker << endm;
942  LOG_QA << " ======================================" << endm;
943  }
944  // PrintQAInfo();
945  PrintInfo();
946  // START the chain (may the force be with you)
947  // Create HTML docs of all Maker's inv
948 #if 0
949  if (GetOption("MakeDoc")) MakeDoc();
950 #endif
951  if (GetOption("Debug")) SetDEBUG(1);
952  if (GetOption("Debug1")) SetDEBUG(1);
953  if (GetOption("Debug2")) SetDEBUG(2);
954  if (GetOption("nohistos")) SetAttr(".histos",0,"*");
955  else SetAttr(".histos",1,"*");
956  if (GetOption("NoRepeat")) gMessMgr->IgnoreRepeats();
957 
958  if (GetOption("svt1hit")) SetAttr("minPrecHits",1,"Sti");
959  if (GetOption("svt1hit")) SetAttr("minPrecHits",1,"StiCA");
960  if (GetOption("svt1hit")) SetAttr("minPrecHits",1,"StiVMC");
961 
962  for ( unsigned int n=0 ; n < Gproperty.size() ; n++ ){
963  gMessMgr->QAInfo() << "+++ Setting attribute "
964  << (Gproperty.at(n)).Data() << " = " << (Gvalue.at(n)).Data() << " for "
965  << (Gpattern.at(n).Data()) << endm;
966 
967  SetAttr( (Gproperty.at(n)).Data(),
968  (Gvalue.at(n)).Data(),
969  (Gpattern.at(n)).Data() );
970  }
971 
972  return status;
973 }
974 //_____________________________________________________________________
975 Int_t StBFChain::Init() {
976 
977  TDatime td;
978  Info("Init","Time=%s Cwd=%s",td.AsString(),gSystem->pwd());
979 
980  SetChainOpt(new StBFChainOpt(this));
981  // SetDbOptions(); moved to Instantiation
982  if (fNoChainOptions) {
983  // SetGeantOptions(); move back to Init
984  if (GetOption("Simu") && ! (GetOption("mtin") || GetOption("PrepEmbed") || GetOption("pythiaEmbed"))) { // ! Simu
985  StEvtHddr *fEvtHddr = (StEvtHddr*)GetDataSet("EvtHddr");
986  if (!fEvtHddr) {
987  fEvtHddr = new StEvtHddr(m_ConstSet);
988  SetOutput(fEvtHddr); //Declare this "EvtHddr" for output
989  }
990  if (fEvtHddr->GetRunNumber() < 0 || fEvtHddr->GetRunNumber() >= 1000000) {
991  fEvtHddr->SetRunNumber(1); // to have run positive and < 1000000 (to avoid mess with RunLog)
992  }
993  }
994  }
995  if (fNoChainOptions) {
996  if (GetOption("NoOutput") || GetOption("EvOutOnly")) {
997  if (! GetOption("RMuDst"))
998  SetAttr(".call","SetActive(0)","MuDst"); //NO MuDst
999  if (! GetOption("EvOutOnly")) {
1000  SetAttr(".call","SetActive(0)","outputStream"); //NO Out
1001  }
1002  SetAttr(".call","SetActive(0)","kink2");
1003  SetAttr(".call","SetActive(0)","StTagsMaker::");
1004  SetAttr(".call","SetActive(0)","StStrangeMuDstMaker::");
1005  }
1006 #if 1
1007 
1008 
1009  if (fNoChainOptions) {
1010  if (GetOption("misalign") && TClass::GetClass("AgPosition") )
1011  gROOT->ProcessLine("AgPosition::SetReal();");
1012  else if ( TClass::GetClass("AgPosition") )
1013  gROOT->ProcessLine("AgPosition::SetIdeal();");
1014  }
1015 
1016 
1017  // force load of geometry for VMC and Sti
1018 
1019  if (GetOption("Sti") || GetOption("StiCA") ||
1020  GetOption("StiVMC") ||GetOption("VMC") ||
1021  GetOption("VMCPassive")) {
1022  const DbAlias_t *DbAlias = GetDbAliases();
1023  for (Int_t i = 0; DbAlias[i].tag; i++) {
1024  TString dbTag("r");
1025  dbTag += DbAlias[i].tag;
1026  if (GetOption(dbTag)) {
1027  TString path("./StarDb/AgiGeometry:$STAR/StarDb/AgiGeometry");
1028  if (GetOption("AgML")) {
1029  path = "./StarDb/AgMLGeometry:$STAR/StarDb/AgMLGeometry";
1030  }
1031  if (GetOption("VmcGeo")) {
1032  path = "./StarDb/VmcGeo:$STAR/StarDb/VmcGeo";
1033  }
1034  TString geom("Geometry.");
1035  geom += DbAlias[i].geometry;
1036  geom += ".C";
1037  Char_t *file = gSystem->Which(path.Data(),geom,kReadPermission);
1038  if (file) {
1039  LOG_INFO << "StBFChain::Init force load of " << file << endm;
1040  TString command = ".L "; command += file;
1041  gInterpreter->ProcessLine(command);
1042  gInterpreter->Calc("CreateTable()");
1043  command.ReplaceAll(".L ",".U ");
1044  gInterpreter->ProcessLine(command);
1045  delete [] file;
1046  } else {
1047  LOG_INFO << "StBFChain::Init file for geometry tag " << geom << " has not been found in path" << path << endm;
1048  }
1049  break;
1050  }
1051  }
1052  }
1053 #endif
1054  }
1055  return StChain::Init();
1056 }
1057 //_____________________________________________________________________
1059 Int_t StBFChain::Finish()
1060 {
1061  TFile *tf = GetTFile();
1062  if (tf) {tf->Write(); tf->Flush(); tf->Close(); delete tf; SetTFile(0);}
1063  if (!fBFC) return kStOK;
1064  Int_t ians = StChain::Finish();
1065  SafeDelete(fchainOpt);
1066  fBFC = 0;
1067 // delete gMessMgr; gMessMgr = 0;
1068  return ians;
1069 }
1070 
1071 
1072 //_____________________________________________________________________
1073 Int_t StBFChain::AddAB (const Char_t *mkname,const StMaker *maker,const Int_t Opt) {
1074  if (! maker || strlen(mkname) == 0) return kStErr;
1075  StMaker *parent = maker->GetParentMaker();
1076  if (parent) {
1077  TList *list = parent->GetMakeList();
1078  list->Remove((StMaker *)maker);
1079  }
1080  StMaker *mk = GetMaker(mkname); if (!mk) return kStErr;
1081  parent = mk->GetParentMaker(); if (!parent) return kStErr;
1082  TList *list = parent->GetMakeList(); if (!list) return kStErr;
1083  if (Opt > 0) list->AddAfter (mk,(StMaker*)maker);
1084  else list->AddBefore(mk,(StMaker*)maker);
1085  return kStOk;
1086 }
1087 
1088 //_____________________________________________________________________
1089 Int_t StBFChain::ParseString (const TString &tChain, TObjArray &Opt, Bool_t Sort) {
1090  Opt.Clear();
1091  TObjArray *obj = tChain.Tokenize("[^ ;,]+");
1092  Int_t nParsed = obj->GetEntries();
1093  Int_t k, N = 0;
1094  if (GetChain() && GetChain()->Debug() > 2) {
1095  gMessMgr->QAInfo() << "ParseString " << tChain.Data() << endm;
1096  for (k = 0; k < nParsed; k++) {
1097  if (obj->At(k)) {
1098  gMessMgr->QAInfo() << k << "\t" << ((TObjString *) obj->At(k))->GetName() << endm;
1099  }
1100  }
1101  }
1102  for (k = 0; k < nParsed; k++) {if (obj->At(k)) {if (k != N) obj->AddAt(obj->At(k),N); N++;}}
1103  nParsed = N;
1104  // sort options
1105  StBFChain *curChain = (StBFChain *) StMaker::GetChain();
1106  if (curChain && Sort) {// sort options
1107  TArrayI idT(nParsed); Int_t *idx = idT.GetArray();
1108  TArrayI kdT(nParsed); Int_t *kdx = kdT.GetArray();
1109  for (k = 0; k < nParsed; k++) {
1110  TString string = ((TObjString *) obj->At(k))->GetString();
1111  kdx[k] = TMath::Abs(curChain->kOpt(string,kFALSE));
1112  }
1113  TMath::Sort(nParsed,kdx,idx,0);
1114  TString sChain;
1115  for (k = 0; k < nParsed; k++) {
1116  Opt.AddAtAndExpand(obj->At(idx[k]),k);
1117  if (k == 0) sChain = ((TObjString *)Opt[k])->GetString();
1118  else {sChain += ","; sChain += ((TObjString *)Opt[k])->GetString();}
1119  }
1120  if (N > 1 && curChain->Debug() > 2) {
1121  gMessMgr->QAInfo() << "Requested chain is :\t" << tChain.Data() << endm;
1122  gMessMgr->QAInfo() << "Sorted chain is :\t" << sChain.Data() << endm;
1123  }
1124  } else for (k = 0; k < nParsed; k++) Opt.AddAtAndExpand(obj->At(k),k);
1125  obj->SetOwner(kFALSE);
1126  delete obj;
1127  return nParsed;
1128 }
1129 
1130 //_____________________________________________________________________
1132 Int_t StBFChain::kOpt (const Char_t *tag, Bool_t Check) const {
1133  TString Tag(tag);
1134  Int_t kO = kOpt(&Tag, Check);
1135  return kO;
1136 }
1137 //_____________________________________________________________________
1139 
1145 Int_t StBFChain::kOpt (const TString *tag, Bool_t Check) const {
1146  TString Tag = *tag;
1147  Tag.ToLower();
1148  TString opt, nopt;
1149  for (Int_t i = 1; i< fNoChainOptions; i++) {
1150  opt = TString(fBFC[i].Key); //check nick name
1151  opt.ToLower();
1152  nopt = TString("-");
1153  nopt += opt;
1154  if (Tag == opt) {return i;}
1155  else {if (Tag == nopt) {return -i;}}
1156  opt = fBFC[i].Maker; //check full maker name2
1157  nopt = "-";
1158  nopt += opt;
1159  if (Tag == opt) {return i;}
1160  else {if (Tag == nopt) {return -i;}}
1161  }
1162  //
1163  // JL - sdt and dbv for timestamp
1164  //
1165  // Gopt for arbitrary property on 3 letter name (wildcard would be added) and length
1166  // 6 for a value. Not advertized / not used and implementation is not complete (needed
1167  // a case and do not have a clear one). TBD.
1168  //
1169  // 2011/11 added the possibility of detector sub-system specific timestamps.
1170  // DBV only for now, logic is similar if we equally parse.
1171  //
1172  // {sdt|dbv}YYYYMMDD -> {sdt|dbv} 3 / YYYYMMDD 8 => 11 || YYYYMMDD.HHMMSS = 15 => 18
1173  if (Tag.BeginsWith("dbv") || Tag.BeginsWith("sdt")) {
1174  Check = kTRUE;
1175 
1176  if (Tag.Length() == 11 || Tag.Length() == 18) return 0;
1177 
1178  // Else we need to parse some more - assume a pattern {dbv|sdt}YYYYMMDD[.HHMMSS]_XXX_ZZZZZ
1179  // First, detect it using quick counting
1180  Tag.ToLower();
1181  if ( TPRegexp(BFC_DBREGEXP).Match(Tag) == 7) return 0;
1182  }
1183  if (Tag.BeginsWith("rung")) {
1184  Check = kTRUE;
1185  return 0;
1186  }
1187 
1188  //FMS gaincorr
1189  if(Tag.BeginsWith("fmsGainCorr")){
1190  Check = kTRUE;
1191  return 0;
1192  }
1193 
1194  // GoptXXXvvvvvv -> Gopt 4 / XXX 3 / vvvvvv 6 = 13
1195  if ( Tag.BeginsWith("gopt") && Tag.Length() == 13 ) return 0;
1196 
1197  if ( Tag.BeginsWith("FiltTrg",TString::kIgnoreCase) ) {
1198  Check = kTRUE;
1199  if ( TPRegexp("^FiltTrg(Inc|Exc)?(_.*)*$").Match(Tag,"i") > 0) return 0;
1200  }
1201  if ( Tag.BeginsWith("VFStore",TString::kIgnoreCase) ||
1202  Tag.BeginsWith("TpcVpdVzDiffCut",TString::kIgnoreCase)
1203  ) {
1204  // need to match an ":" sign
1205  Check = kTRUE;
1206  if ( Tag.Index(':') != 0) return 0;
1207  }
1208 
1209 
1210  if (Check) {
1211  gMessMgr->Error() << "Option " << Tag.Data() << " has not been recognized" << endm;
1212  abort(); //assert(1);
1213  }
1214  return 0;
1215 }
1216 //_____________________________________________________________________
1217 void StBFChain::SetOptions(const Char_t *options, const Char_t *chainName) {
1218  TString tChain(options);
1219  TObjArray Opts;
1220  Int_t nParsed = ParseString(tChain,Opts,kTRUE);
1221  for (Int_t l = 0; l < nParsed; l++) {
1222  TString Tag = ((TObjString *)Opts[l])->GetString();
1223  Int_t kgo;
1224  Int_t in = Tag.Index("=");
1225  if (in > 0) {// string with "="
1226  TString subTag(Tag.Data(),in);
1227  subTag.ToLower(); //printf ("Chain %s\n",tChain.Data());
1228  kgo = kOpt(subTag.Data());
1229  if (kgo > 0) {
1230  int len= sizeof(fBFC[kgo].Comment);
1231  memset(fBFC[kgo].Comment,0,len); // be careful size of Comment
1232  TString Comment(Tag.Data()+in+1,Tag.Capacity()-in-1);
1233  if ( Comment.Length() <= len ){
1234  strncpy (fBFC[kgo].Comment, Comment.Data(),sizeof(fBFC[kgo].Comment));
1235  gMessMgr->QAInfo() << Form(" Set %s = %s", fBFC[kgo].Key,fBFC[kgo].Comment) << endm;
1236  } else {
1237  gMessMgr->Error() << Form(" Cpy problem [%s] is > %d - adjust BFC Comment field size",
1238  Comment.Data(),len) << endm;
1239  }
1240  }
1241  } else {
1242  Tag.ToLower();
1243  // printf ("Chain %s\n",tChain.Data());
1244  kgo = kOpt(Tag.Data(),kFALSE);
1245  if (kgo != 0) {
1246  SetOption(kgo,chainName);
1247  if (kgo > 0) {
1248  TString Comment(fBFC[kgo].Comment);
1249  TString Opts(fBFC[kgo].Opts);
1250  if (Tag.BeginsWith("Test.",TString::kIgnoreCase) && ! Comment.BeginsWith("/star/") &&
1251  Opts.BeginsWith("test_",TString::kIgnoreCase)) {
1252  SetOptions(Opts,Tag);
1253  } else {
1254  if ((Tag.BeginsWith("Test.",TString::kIgnoreCase) ||
1255  Tag.BeginsWith("test_",TString::kIgnoreCase) ||
1256  Tag.BeginsWith("eval_",TString::kIgnoreCase)) && Comment.BeginsWith("/star/") ) {
1257  fkChain = kgo;
1258  gMessMgr->QAInfo() << "Default Test chain set " << fBFC[fkChain].Key << " with input " << fBFC[fkChain].Comment << endm;
1259  }
1260  }
1261  }
1262  } else {
1263  // it is 0 i.e. was not recognized.
1264  // Check if it is a (dbv|sdt)YYYYMMDD or (dbv|sdt)YYYYMMDD.HHMMSS and derivative
1265  // We really set the options only once later in SetDbOptions() (removing the fBFC[i].Flag check)
1266  // but the goal here is to avoid user's histeria by displaying extra messages NOW.
1267  //
1268  // Note that kOpt() has already validated the pattern (so it has to be right here).
1269  //
1270  // !!! Debug: dbv20040917
1271  if (Tag.BeginsWith("dbv")) {
1272  if (Tag.Length() == 11) (void) sscanf(Tag.Data(),"dbv%8d",&FDate);
1273  if (Tag.Length() == 18) (void) sscanf(Tag.Data(),"dbv%8d.%6d",&FDate,&FTime);
1274  if (Tag.Length() == 11 || Tag.Length() == 18) {
1275  gMessMgr->QAInfo() << Tag.Data() << " ... but still will be considered as a dynamic timestamp (Max DB EntryTime) "
1276  << FDate << "." << FTime << endm;
1277 #ifdef USE_BFCTIMESTAMP
1278  } else {
1279  // we passed kOpt() parsing was fine
1280  //if ( TPRegexp(BFC_DBREGEXP).Match(Tag) == 7) return 0;
1281  TObjArray *subStrL = TPRegexp(BFC_DBREGEXP).MatchS(Tag);
1282  BFCTimeStamp TS;
1283  TString realm;
1284 
1285  TS.Type = 1;
1286  TS.Date = (((TObjString *) subStrL->At(2))->GetString()).Atoi();
1287  TS.Time = 0; // for now, avoid parsing this as user use simple TS 99% of the time
1288  TS.Detector = ((TObjString *) subStrL->At(4))->GetString();
1289  TS.Realm = ((TObjString *) subStrL->At(6))->GetString();
1290 
1291  if ( TS.Realm.IsNull() ){ realm = "*";}
1292  else { realm = TS.Realm;}
1293 
1294  GTSOptions.push_back(TS);
1295 
1296  LOG_WARN << "Override timestamp for detector requested\n\t"
1297  << "Detector " << TS.Detector << "\n\t"
1298  << "Realm " << realm << "\n\t"
1299  << "Date " << TS.Date << "\n\t"
1300  << "Time " << TS.Time << endm;
1301 #endif /* USE_BFCTIMESTAMP */
1302  }
1303 
1304  } else if (Tag.BeginsWith("sdt")) {
1305  if (Tag.Length() == 11) (void) sscanf(Tag.Data(),"sdt%8d",&FDateS);
1306  if (Tag.Length() == 18) (void) sscanf(Tag.Data(),"sdt%8d.%6d",&FDateS,&FTimeS);
1307  if (Tag.Length() == 11 || Tag.Length() == 18) {
1308  gMessMgr->QAInfo() << Tag.Data() << " ... but still will be considered as a dynamic timestamp (Event Time) "
1309  << FDateS << "." << FTimeS << endm;
1310 
1311  // <<< same logic for GTSOptions can be inserted here
1312  // <<< if so, use TS.Type = 2
1313  }
1314 
1315  } else if ( Tag.BeginsWith("gopt") && Tag.Length() == 13){
1316  // TODO option best as gopt.$ATTRR.$VAL for arbitrary attribute and value
1317  // parsing to extend
1318  char GOptName[4],GOptValue[7];
1319  TString property(".gopt.");
1320  //TString pattern("*");
1321 
1322  (void) sscanf(Tag.Data(),"gopt%3s%6s",GOptName,GOptValue);
1323  // sscanf adds null terminators for %s, so buffers need to be 1 longer
1324 
1325  // see StBFChain::Setup() for default values
1326  property += GOptName;
1327  Gproperty.push_back(property);
1328  Gvalue.push_back(GOptValue);
1329  Gpattern.push_back("*");
1330 
1331  // JL - this is not finished, see comment in kOpt()
1332 
1333  // pattern is case sensitive, need more checks on this before
1334  // setting to something else than "*"
1335  //Gpattern += GOptName;
1336  //Gpattern += "*";
1337 
1338 
1339  gMessMgr->QAInfo() << Tag.Data() << " ... this will set an general attribute "
1340  << property.Data() << " with value " << GOptValue << " to "
1341  << "*" << endm;
1342  // Attr() need to be set after the maker exist
1343  //SetAttr(property.Data(),GOptValue,pattern.Data());
1344  //SetAttr(property.Data(),GOptValue,pattern.Data());
1345 
1346  } else if (Tag.BeginsWith("rung")) {
1347  fRunG = 1;
1348  if (Tag.Length() > 4) (void) sscanf(Tag.Data(),"rung.%d",&fRunG);
1349  gMessMgr->QAInfo() << Tag.Data() << " will be considered as Run number (& rndm seed set) "
1350  << fRunG << " for simulation." << endm;
1351 
1352 
1353  // JL: super long options I could not accomomodate with gopt (also used ":")
1354  } else if (Tag.BeginsWith("VFStore" ,TString::kIgnoreCase) ||
1355  Tag.BeginsWith("TpcVpdVzDiffCut",TString::kIgnoreCase)
1356  ) {
1357  TString VFS = Tag;
1358  Ssiz_t idx = Tag.Index(':');
1359 
1360  //cout << "-+-+-+- DEBUG -+-+-+- position = " << idx << endl;
1361 
1362  if ( idx != 0){
1363  // exclude VFStoreX or options not containing "."
1364  Gproperty.push_back(Tag(0,idx));
1365  Gvalue.push_back(Tag(idx+1,64));
1366  // can use better patterns VFStore -> mk=StGenericVertexMaker
1367  Gpattern.push_back("*");
1368 
1369  gMessMgr->QAInfo() << "Detecting " << Tag(0,idx).Data() << " = " << Tag(idx+1,64).Data() << " as global property" << endm;
1370 
1371  // Attr() need to be set after the maker exist
1372 
1373  }
1374 
1375 
1376  } else if (Tag.BeginsWith("FiltTrg",TString::kIgnoreCase)) {
1377  TString filtTrgTag = Tag;
1378  Ssiz_t flavorIdx = Tag.Index('_');
1379  if (flavorIdx > 0) {
1380  filtTrgTag = Tag(0,flavorIdx);
1381  fFiltTrg = Tag(flavorIdx+1,64);
1382  }
1383  if (filtTrgTag.CompareTo("FiltTrgExc",TString::kIgnoreCase)==0) {
1384  gMessMgr->QAInfo() << "Trigger Filtering exclude with flavor=" << fFiltTrg << endm;
1385  fFiltTrg.Prepend('-');
1386  } else if (filtTrgTag.CompareTo("FiltTrgInc",TString::kIgnoreCase)==0 ||
1387  filtTrgTag.CompareTo("FiltTrg" ,TString::kIgnoreCase)==0) {
1388  gMessMgr->QAInfo() << "Trigger Filtering include with flavor=" << fFiltTrg << endm;
1389  fFiltTrg.Prepend('+');
1390  } else {
1391  // not a match, disable
1392  fFiltTrg = "";
1393  }
1394 
1395  } else if (Tag.BeginsWith("fmsGainCorr",TString::kIgnoreCase)) {
1396  fFmsGainCorrTag = Tag;
1397 
1398  } else { // Check for predefined db time stamps ?
1399  kgo = kOpt(Tag.Data(),kFALSE);
1400  if (kgo != 0){
1401  SetOption(kgo,chainName);
1402  } else {
1403  // Check that option can be library name or / and Maker
1404  static const Char_t *path = ".:.$STAR_HOST_SYS/lib::.$STAR_HOST_SYS/LIB:$STAR/.$STAR_HOST_SYS/lib:$STAR/.$STAR_HOST_SYS/LIB";
1405  TString File = Tag; File += ".so";
1406  Char_t *file = gSystem->Which(path,File.Data(),kReadPermission);
1407  if (file) {
1408  TString Maker("");
1409  Bfc_st row = {"","","","","","","",kTRUE};
1410  memcpy (&row.Key, Tag.Data(), Tag.Length());
1411  if (Tag.Contains("Maker")) memcpy (&row.Maker, Tag.Data(), Tag.Length());
1412  memcpy (&row.Libs, Tag.Data(), Tag.Length());
1413  fchainOpt->AddAt(&row);
1414  fNoChainOptions = fchainOpt->GetNRows();
1415  fBFC = fchainOpt->GetTable();
1416  delete [] file;
1417  }
1418  kgo = kOpt(Tag.Data(),kFALSE);
1419  if (kgo != 0) {
1420  SetOption(kgo,chainName);
1421  } else {
1422  gMessMgr->QAInfo() << " Invalid Option " << Tag.Data() << ". !! ABORT !! " << endm;
1423  abort(); //assert(1);
1424  return;
1425  }
1426  }
1427  }
1428  }
1429  }
1430  }
1431  Opts.Delete();
1432 }
1433 //_____________________________________________________________________
1435 void StBFChain::SetOption(const Int_t k, const Char_t *chainName) {
1436  if (k > 0) {
1437  assert(k<fNoChainOptions);
1438  Int_t n = strlen(fBFC[k].Opts);
1439  if (n > 0) SetOptions(fBFC[k].Opts,fBFC[k].Key);
1440  if (!fBFC[k].Flag) {
1441  fBFC[k].Flag = kTRUE;
1442  gMessMgr->QAInfo() << Form(" Switch On %20s by %s", fBFC[k].Key, chainName) << endm;
1443  }
1444  } else {
1445  assert(-k<fNoChainOptions);
1446  if (k < 0 && fBFC[-k].Flag) {
1447  fBFC[-k].Flag = kFALSE;
1448  gMessMgr->QAInfo() << Form(" Switch Off %20s by %s", fBFC[-k].Key, chainName) << endm;
1449  }
1450  }
1451 }
1452 
1453 //_____________________________________________________________________
1455 Bool_t StBFChain::GetOption(const Int_t k) const
1456 {
1457  return (k>0 && k <fNoChainOptions) ? fBFC[k].Flag : kFALSE;
1458 }
1459 
1461 
1480 Char_t *StBFChain::GetOptionString(const Char_t *Opt)
1481 {
1482  Int_t o = kOpt(Opt);
1483  if(!o) return NULL;
1484  else if(!GetOption(o)) return NULL;
1485  else return(fBFC[o].Comment);
1486 }
1487 
1488 
1489 //_____________________________________________________________________________
1491 
1518 void StBFChain::SetFlags(const Char_t *chainOpts)
1519 {
1520  TString tChain(chainOpts);
1521  Int_t mode = 1;
1522  Setup(mode);
1523  Int_t k=0;
1524  if (tChain == "" || tChain.CompareTo("ittf",TString::kIgnoreCase) == 0) {
1525  gMessMgr->QAInfo() << "\tPossible Chain Options are:" << endm;
1526  for (k=0;k<fNoChainOptions;k++)
1527  gMessMgr->QAInfo()
1528  << Form(" %3d: %-30s:%-12s:%-12s:%s:%s:%s:%s"
1529  ,k,fBFC[k].Key,fBFC[k].Name,fBFC[k].Chain,fBFC[k].Opts,fBFC[k].Maker,fBFC[k].Libs,fBFC[k].Comment)
1530  << endm;
1531 
1532  return;
1533  }
1534  TString STAR_VERSION("$STAR_VERSION");
1535  gSystem->ExpandPathName(STAR_VERSION);
1536  gMessMgr->QAInfo() << "==============================================" << endm;
1537  gMessMgr->QAInfo() << "============= You are in " << STAR_VERSION.Data() << " ===============" << endm;
1538  gMessMgr->QAInfo() << "Requested chain " << GetName() << " is :\t" << tChain.Data() << endm;
1539  SetOptions(tChain,"Chain");
1540  if (GetOption("NewTpcAlignment")) {
1541  gMessMgr->QAInfo() << "Set environment to use NewTpcAlignment" << endm;
1542  gEnv->SetValue("NewTpcAlignment",1);
1543  }
1544  if (!GetOption("NoDefault")) { // Default
1545  // Check flags consistency
1546  if (gClassTable->GetID("TGiant3") >= 0) { // root4star
1547  SetOption("-VMC","Default,TGiant3");
1548  SetOption("-VMCPassive","Default,TGiant3");
1549  SetOption("-VMCAppl","Default,TGiant3");
1550  SetOption("-RootVMC","Default,TGiant3");
1551  if (GetOption("xgeometry")) {
1552  SetOption("-geometry","Default,-xgeometry");
1553  SetOption("-geomNoField","Default,-xgeometry");
1554  }
1555  } else { // root
1556  if (GetOption("fzin")) {
1557  gMessMgr->Error() << "Option fzin cannot be used in root.exe. Use root4star" << endm;
1558  abort();
1559  }
1560  if (GetOption("ntin")) {
1561  gMessMgr->Error() << "Option ntin cannot be used in root.exe. Use root4star" << endm;
1562  abort();
1563  }
1564 
1565  if (GetOption("gstar") || GetOption("pythia")) {
1566  SetOption("VMC","Default,-TGiant3,gstar");
1567  SetOption("-gstar","Default,-TGiant3");
1568  SetOption("-pythia","Default,-TGiant3");
1569  }
1570 
1571  SetOption("-geant","Default,-TGiant3");
1572  SetOption("-geantL","Default,-TGiant3");
1573  SetOption("-geometry","Default,-TGiant3");
1574  SetOption("-geomNoField","Default,-TGiant3");
1575 
1576  if (! (GetOption("VMC") || GetOption("VMCPassive"))) {
1577  SetOption("VMCPassive","Default,-TGiant3");
1578  }
1579  SetOption("pgf77","Default,-TGiant3");
1580  SetOption("mysql","Default,-TGiant3");
1581  SetOption("StarMiniCern","Default,-TGiant3");
1582 
1583  }
1584  if (GetOption("ITTF") && ! (GetOption("Sti") || GetOption("StiCA") || GetOption("StiVMC"))) {
1585  TString STAR_LEVEL(gSystem->Getenv("STAR_LEVEL"));
1586  if (STAR_LEVEL == ".DEV2") SetOption("StiCA","Default,ITTF");
1587  else SetOption("Sti" ,"Default,ITTF");
1588  }
1589  }
1590  if (!GetOption("Eval") && GetOption("AllEvent")) SetOption("Eval","-Eval,AllEvent");
1591  // Print set values
1592  St_Bfc *Bfc = new St_Bfc("BFChain",fNoChainOptions);
1593  AddRunco(Bfc);
1594  for (k = 1; k<fNoChainOptions;k++) {
1595  if (GetOption(k)) {
1596  gMessMgr->QAInfo() << Form("================== %20s\tis ON \t: %s",
1597  (char *) fBFC[k].Key, (char *) fBFC[k].Comment) << endm;
1598  Bfc->AddAt(&fBFC[k]);
1599  }
1600  }
1601  // gSystem->Exit(1);
1602 }
1603 //_____________________________________________________________________
1604 void StBFChain::Set_IO_Files (const Char_t *infile, const Char_t *outfile){
1605  TString gc("");
1606  if (infile) {
1607  if (strlen(infile) > 2) {
1608  gc = TString(infile,3);
1609  gc.ToLower();
1610  }
1611  }
1612  SetInputFile(infile);
1613  if (! GetOption("NoOutput")) SetOutputFile(outfile);
1614 }
1615 //_____________________________________________________________________
1616 void StBFChain::SetInputFile (const Char_t *infile){
1617  // define input file
1618  if (infile) fInFile = infile;
1619  if (fInFile != "") {
1620  fInFile.ReplaceAll("\n",";");
1621  fInFile.ReplaceAll("#",";");
1622  fInFile.ReplaceAll(":",";");
1623  gMessMgr->QAInfo() << "Input file name = " << fInFile.Data() << endm;
1624  } else {
1625  if (fkChain >= 0) {
1626  fInFile = fBFC[fkChain].Comment;
1627  fInFile.ReplaceAll("\n",";");
1628  gMessMgr->QAInfo() << "Default Input file name = " << fInFile.Data() << " for chain : " << fBFC[fkChain].Key << endm;
1629  }
1630  }
1631  if (fInFile == "") {SetOption("-in","No Input File"); SetOption("-InTree","NoInput File"); return;}
1632  if (!GetOption("fzin") && !GetOption("ntin")) {
1633  fSetFiles= new StFile();
1634  TObjArray Files;
1635  ParseString(fInFile,Files);
1636  TIter next(&Files);
1637  TObjString *File;
1638  while ((File = (TObjString *) next())) {
1639  TString string = File->GetString();
1640  if (!string.Contains("*") && ! string.BeginsWith("@") &&
1641  gSystem->AccessPathName(string.Data())) {// file does not exist
1642  gMessMgr->Error() << "StBFChain::SetInputFile *** NO FILE: " << string.Data() << ", exit!" << endm;
1643  gSystem->Exit(1);
1644  }
1645  else fSetFiles->AddFile(File->String().Data());
1646  }
1647  Files.Delete();
1648  }
1649 }
1650 //_____________________________________________________________________
1652 void StBFChain::SetOutputFile (const Char_t *outfile){
1653  if (! GetOption("NoOutput")) {
1654  if (outfile) {
1655  fFileOut = outfile;
1656  } else {
1657  if (fInFile != "") {
1658  if (GetOption("fzin") || GetOption("ntin")) {
1659  TObjArray words;
1660  ParseString(fInFile,words);
1661  TIter nextL(&words);
1662  TObjString *word = 0;
1663  while ((word = (TObjString *) nextL())) {
1664  if (word->GetString().Contains(".fz") ||
1665  word->GetString().Contains(".nt")) {
1666  fFileOut = gSystem->BaseName(word->GetName());
1667  break;
1668  }
1669  }
1670  } else {
1671  fFileOut = gSystem->BaseName(fInFile.Data());
1672  if (GetOption("shadow")) {
1673  TObjArray* fileOutTokens = fFileOut.Tokenize("_.");
1674  TString& runToken = ((TObjString*) (fileOutTokens->At(2)))->String();
1675  TString& seqToken = ((TObjString*) (fileOutTokens->At(4)))->String();
1676  if (!(runToken.CompareTo("adc"))) {
1677  runToken = ((TObjString*) (fileOutTokens->At(3)))->String();
1678  seqToken = ((TObjString*) (fileOutTokens->At(5)))->String();
1679  }
1680  if (!(runToken.IsDigit())) {
1681  LOG_ERROR << "Unable to locate run number in filename for shadowing." << endm;
1682  } else {
1683  fFileOut.ReplaceAll(runToken,Form("%d",
1684  StShadowMaker::getRunNumber(runToken.Atoi())));
1685  }
1686  if (!(seqToken.IsDigit())) {
1687  LOG_ERROR << "Unable to locate file sequence number in filename for shadowing." << endm;
1688  } else {
1689  fFileOut.ReplaceAll(seqToken,Form("%07d",
1690  StShadowMaker::getFileSeq(seqToken.Atoi())));
1691  }
1692  delete fileOutTokens;
1693  }
1694  }
1695  }
1696  if (fFileOut == "") {
1697  if (GetOption("pythia")) fFileOut = "pythia.root";
1698  else if (GetOption("hijing")) fFileOut = "hijing.root";
1699  else if (GetOption("VMC")) fFileOut = "VMC.root";
1700  else if (GetOption("gstar")) fFileOut = "gtrack.root";
1701  }
1702  if ( fFileOut != "") {
1703  fFileOut.ReplaceAll("*","");
1704  fFileOut.ReplaceAll("@","");
1705  fFileOut.ReplaceAll("..",".");
1706  fFileOut.ReplaceAll(".daq","");
1707  fFileOut.ReplaceAll(".fzd","");
1708  fFileOut.ReplaceAll(".fz","");
1709  fFileOut.ReplaceAll(".nt","");
1710  fFileOut.ReplaceAll(".root","");
1711  fFileOut.ReplaceAll(".list","");
1712  fFileOut.ReplaceAll(".lis","");
1713  fFileOut.Strip();
1714  fFileOut.Append(".root");
1715  }
1716  }
1717  }
1718  if (fFileOut != "") gMessMgr->QAInfo() << "Output root file name " << fFileOut.Data() << endm;
1719  else SetOption("NoOutput","No Output File");
1720  if (!GetTFile()) {
1721  if ( ( GetOption("tags") || GetOption("lana") ) && (fFileOut != "") ){
1722  TString TagsName = fFileOut;
1723  if( GetOption("lana") ){
1724  TagsName.ReplaceAll(".root",".laser.root");
1725  } else if ( GetOption("mtdEvtFilt") ){
1726  TagsName.ReplaceAll(".root",".pretags.root");
1727  } else {
1728  TagsName.ReplaceAll(".root",".tags.root");
1729  }
1730  SetTFile(new TFile(TagsName.Data(),"RECREATE"));
1731  }
1732  }
1733 }
1734 //_____________________________________________________________________
1736 
1742 void StBFChain::SetGeantOptions(StMaker *geantMk){
1743  if (geantMk && geantMk->InheritsFrom("St_geant_Maker")) {
1744  SetInput("geant",".make/geant/.data");
1745  TString GeomVersion("");
1746  if (fRunG > 0) {
1747  geantMk->SetAttr("RunG",fRunG);
1748  }
1749  if (!GetOption("fzin") || GetOption("ForceGeometry")) {
1750  GeomVersion = "y2004x";
1751  const DbAlias_t *DbAlias = GetDbAliases();
1752  Int_t found = 0;
1753  for (Int_t i = 0; DbAlias[i].tag; i++) {
1754  TString r("r");
1755  r += DbAlias[i].tag;
1756  if ( !GetOption(DbAlias[i].tag,kFALSE) && !GetOption(r,kFALSE)) continue;
1757  GeomVersion = DbAlias[i].geometry;
1758  found = i;
1759  break;
1760  }
1761  if (! found) gMessMgr->QAInfo() << "StBFChain::SetGeantOptions() Chain has not found geometry tag. Use " << GeomVersion << endm;
1762  TString GeometryOpt;
1763  if (GetOption("phys_off")) {GeometryOpt += "detp phys_off=1;"; geantMk->SetAttr("phys_off",kTRUE);}
1764  if (GetOption("hadr_off")) {GeometryOpt += "detp hadr_off=1;"; geantMk->SetAttr("hadr_off",kTRUE);}
1765  GeometryOpt += ("detp geometry ");
1766  GeometryOpt += GeomVersion;
1767  ProcessLine(Form("((St_geant_Maker *) %p)->LoadGeometry(\"%s\");",geantMk,GeometryOpt.Data()));
1768  }
1769  if ((GetOption("fzin") || GetOption("ntin") || GetOption("mtin") || fInFile.Data()[0] == ';') && fInFile != "")
1770  ProcessLine(Form("((St_geant_Maker *) %p)->SetInputFile(\"%s\")",geantMk,fInFile.Data()));
1771  }
1772 }
1773 //_____________________________________________________________________
1775 
1787 void StBFChain::SetDbOptions(StMaker *mk){
1788  if (! mk ) return;
1789  if (GetOption("Agi")) mk->SetAlias("VmcGeometry","db/.const/StarDb/AgiGeometry");
1790  else if (GetOption("AgML") ) mk->SetAlias("VmcGeometry","db/.const/StarDb/AgMLGeometry");
1791  else if (GetOption("VmcGeo")) mk->SetAlias("VmcGeometry","db/.const/StarDb/VmcGeo");
1792  else mk->SetAlias("VmcGeometry","db/.const/StarDb/AgiGeometry");
1793  Int_t i;
1794  Int_t Idate=0,Itime=0;
1795 
1796  // First possibility
1797  for (i = 1; i < fNoChainOptions; i++) {
1798  if (fBFC[i].Flag && !strncmp(fBFC[i].Key ,"DbV",3)){
1799  // JL - we use to set timestamp as a chain option (any) starting with dbv and followed
1800  // by an arbitrary set of numbers. The real stamp was taken from the comment.
1801  // This supports this old mode.
1802  gMessMgr->QAInfo() << "StBFChain::SetDbOptions Found time-stamp " << fBFC[i].Key << " [" << fBFC[i].Comment << "]" << endm;
1803  (void) sscanf(fBFC[i].Comment,"%d/%d",&Idate,&Itime);
1804  }
1805  }
1806 
1807  // If FDate is set and we do not have the old mode, then a dynamic timestamp was used
1808  // Overwrite
1809  if( ! Idate && FDate){
1810  gMessMgr->QAInfo() << "StBFChain::SetDbOptions Switching to user chosen dynamic time-stamp (MaxEntry) "
1811  << FDate << " " << FTime << endm;
1812  gMessMgr->QAInfo() << "Chain may crash if time-stamp is not validated by db interface" << endm;
1813 
1814  Idate = FDate;
1815  Itime = FTime;
1816  }
1817 
1818  St_db_Maker *db = (St_db_Maker *) mk;
1819  // Startup date over-write
1820  if (FDateS){
1821  gMessMgr->QAInfo() << "StBFChain::SetDbOptions Switching to user chosen dynamic time-stamp (Start)"
1822  << FDateS << " " << FTimeS << endm;
1823  gMessMgr->QAInfo() << "Chain may crash if time-stamp is not validated by db interface" << endm;
1824 
1825  db->SetDateTime(FDateS,FTimeS);
1826  } else {
1827  if (GetOption("simu")) {
1828  const DbAlias_t *DbAlias = GetDbAliases();
1829  Int_t found = 0;
1830  for (Int_t i = 0; DbAlias[i].tag; i++) {
1831  if (GetOption(DbAlias[i].tag,kFALSE)) {
1832  db->SetDateTime(DbAlias[i].tag);
1833  found = i;
1834  break;
1835  }
1836  }
1837  if (! found) {gMessMgr->QAInfo() << "StBFChain::SetDbOptions() Chain has not set a time-stamp" << endm;}
1838  // Show date settings
1839  gMessMgr->QAInfo() << db->GetName()
1840  << " Maker set time = "
1841  << db->GetDateTime().GetDate() << "."
1842  << db->GetDateTime().GetTime() << endm;
1843  if (GetOption("SIMU") && m_EvtHddr) {
1844  gMessMgr->QAInfo() << GetName() << " Chain set time from " << db->GetName() << endm;
1845  m_EvtHddr->SetDateTime(db->GetDateTime());
1846  }
1847  }
1848  }
1849 
1850  // MaxEntry over-write - default and global for all realm and detectors
1851  if (Idate) {
1852  db->SetMaxEntryTime(Idate,Itime);
1853  gMessMgr->Info() << "\tSet DataBase max entry time " << Idate << "/" << Itime
1854  << " for St_db_Maker(\"" << db->GetName() <<"\")" << endm;
1855  }
1856 #ifdef USE_BFCTIMESTAMP
1857  //
1858  // Now treat the detector specific options
1859  //
1860  TString realm;
1861  for (UInt_t i = 0; i < GTSOptions.size() ; i++){
1862  if ( (GTSOptions[i].Realm).IsNull() ){ realm = "*";}
1863  else { realm = GTSOptions[i].Realm;}
1864 
1865  //LOG_INFO << "DEBUG MORE [" << (GTSOptions[i].Realm).Data() << "]" << endm;
1866  //LOG_INFO << "DEBUG MORE [" << realm.Data() << "]" << endm;
1867 
1868  if ( GTSOptions[i].Type == 1){
1869  db->AddMaxEntryTimeOverride(GTSOptions[i].Date,0,
1870  (char *) realm.Data(),
1871  (char *) GTSOptions[i].Detector.Data());
1872 
1873  LOG_INFO << "Recovering override stamp " << i << " :: "
1874  << GTSOptions[i].Detector << ", " << realm << ", "
1875  << GTSOptions[i].Date << ", " << GTSOptions[i].Time << endm;
1876  } else {
1877  LOG_WARN << "Found override type " << GTSOptions[i].Type << " no treated yet"
1878  << GTSOptions[i].Detector << ", " << realm << ", "
1879  << GTSOptions[i].Date << ", " << GTSOptions[i].Time << endm;
1880  }
1881  }
1882 
1883  //abort();
1884 #endif /* USE_BFCTIMESTAMP */
1885 
1886  if (!GetOption("fzin")) {
1887  struct Field_t {
1888  const Char_t *name;
1889  Float_t scale;
1890  };
1891  Field_t FieldOptions[5] = {
1892  {"FullMagFNegative", -1.0},
1893  {"FullMagFPositive", 1.0},
1894  {"HalfMagFNegative", -0.5},
1895  {"HalfMagFPositive", 0.5},
1896  {"ZeroMagF", 0.0}
1897  };
1898  Int_t k = -1;
1899  if (GetOption("FieldON")) {
1900  if (GetOption("ReverseField")) k = 0;
1901  else k = 1;
1902  } else if (GetOption("HalfField")) {
1903  if (GetOption("ReverseField")) k = 2;
1904  else k = 3;
1905  } else if (GetOption("FieldOff")) k = 4;
1906  if (k >= 0) {
1907  SetFlavor(FieldOptions[k].name, "MagFactor");
1908  gMessMgr->QAInfo() << "StBFChain::SetDbOptions SetFlavor(\"" << FieldOptions[k].name
1909  << "\",\"MagFactor\")" << endm;
1910  if ( gClassTable->GetID("StarMagField") >= 0) {
1911  TString cmd =
1912  Form("if (!StarMagField::Instance()) new StarMagField( StarMagField::EBField::kMapped, %f, kTRUE);",
1913  FieldOptions[k].scale);
1914  ProcessLine(cmd);
1915  }
1916  }
1917  }
1918  if (this == GetTopChain()) {
1919  // Db blacklist (remove black listed system from St_Db_Maker Calibrations configuration)
1920  if (! GetOption("TpcDb") ) {mk->SetAttr("blacklist", "tpc"); gMessMgr->QAInfo() << "blacklist tpc" << endm;}
1921  if (!(GetOption("SvtDb")||GetOption("SvtCalDb"))) {mk->SetAttr("blacklist", "svt"); gMessMgr->QAInfo() << "blacklist svt" << endm;}
1922  if (!(GetOption("SsdDb")||GetOption("SsdCalDb"))) {mk->SetAttr("blacklist", "ssd"); gMessMgr->QAInfo() << "blacklist ssd" << endm;}
1923  if (!(GetOption("SstDb")||GetOption("SstCalDb"))) {mk->SetAttr("blacklist", "sst"); gMessMgr->QAInfo() << "blacklist sst" << endm;}
1924  if (! GetOption("EemcDb") ) {mk->SetAttr("blacklist", "eemc"); gMessMgr->QAInfo() << "blacklist eemc"<< endm;}
1925  if (! GetOption("FmsDb") ) {mk->SetAttr("blacklist", "fms"); gMessMgr->QAInfo() << "blacklist fms" << endm;}
1926  } else {// for Embedding chain trigger black list by NoSsdIT and NoSvtIT, could be some problems if you try to run svt or ssd clusters, ...
1927  if (GetOption("NoSvtIt")) {mk->SetAttr("blacklist", "svt"); gMessMgr->QAInfo() << "blacklist svt" << endm;}
1928  if (GetOption("NoSsdIt")) {mk->SetAttr("blacklist", "ssd"); gMessMgr->QAInfo() << "blacklist ssd" << endm;}
1929  if (GetOption("NoSstIt")) {mk->SetAttr("blacklist", "sst"); gMessMgr->QAInfo() << "blacklist sst" << endm;}
1930  }
1931 }
1932 //_____________________________________________________________________
1934 void StBFChain::SetTreeOptions()
1935 {
1936 
1937  StTreeMaker *treeMk = (StTreeMaker *) GetMaker("outputStream");
1938  if (!treeMk) return;
1939  if (GetOption("EvOut")){
1940  gMessMgr->QAInfo() << "Will Write StEvent out, treeMk->GetFile() = " << treeMk->GetFile() << endm;
1941  treeMk->IntoBranch("eventBranch","StEvent");
1942  if (GetOption("EvOutOnly")) return;
1943  }
1944  if (! GetOption("nohistos")) treeMk->SetBranch("histBranch");
1945  if (! GetOption("norunco")) treeMk->SetBranch("runcoBranch");
1946  if (GetOption("McEvent") && GetOption("McEvOut")){
1947  gMessMgr->QAInfo() << "Will Write StMcEvent out, treeMk->GetFile() = " << treeMk->GetFile() << endm;
1948  treeMk->IntoBranch("McEventBranch","StMcEvent");
1949  }
1950  if (GetOption("GeantOut")) treeMk->IntoBranch("geantBranch","geant");
1951  if (GetOption("AllEvent")) {
1952  if (GetOption("fzin") ||
1953  GetOption("ntin") ||
1954  GetOption("gstar") ||
1955  GetOption("pythia") ||
1956  GetOption("VMC") ||
1957  GetOption("PrepEmbed")) {
1958  treeMk->IntoBranch("geantBranch","geant");
1959  treeMk->IntoBranch("geantBranch","geant/.data/particle");
1960  treeMk->IntoBranch("geantBranch","geant/.data/g2t_rch_hit");
1961  }
1962  }
1963 }
1964 //________________________________________________________________________________
1965 Long_t StBFChain::ProcessLine(const char *line) {
1966  if (! line || !strlen(line)) return -1;
1967  if (Debug()) gMessMgr->QAInfo() << "ProcessLine " << line << endm;
1968  TInterpreter::EErrorCode error = TInterpreter::kNoError;
1969  Long_t res = gInterpreter->ProcessLine(line, &error);
1970  if (error != TInterpreter::kNoError) {
1971  gMessMgr->Error() << "StBFChain::ProcessLine command:" << line << " has failed. Quit job." << endm;
1972  gSystem->Exit(1);
1973  }
1974  return res;
1975 }
1976 //________________________________________________________________________________
1977 TString StBFChain::GetGeometry() const
1978 {
1979  Int_t n = fchainOpt->GetNRows();
1980  for (Int_t i=0;i<n;i++) {
1981  if (!fchainOpt->GetTable()[i].Flag) continue;
1982  TString k(fchainOpt->GetTable()[i].Key);
1983  k.ToLower();
1984  if (k[0]!='y') continue;
1985  if (k[1]!='2') continue;
1986  if (k[2] <'0' || k[2]>'9') continue;
1987  if (k[3] <'0' || k[3]>'9') continue;
1988  if (k[4] <'0' || k[4]>'9') continue;
1989  return k;
1990  }
1991  return TString("");
1992 }
St_db_Maker
Definition: St_db_Maker.h:141
Error
Definition: FJcore.h:367
DbAlias_t
Definition: StMaker.h:48
StBFChain::Instantiate
virtual Int_t Instantiate()
Maker-instantiation handler.
Definition: StBFChain.cxx:214
StBFChain::Finish
virtual Int_t Finish()
Really the destructor (close files, delete pointers etc ...)
Definition: StBFChain.cxx:1059
StFile
Definition: StTree.h:125
StBFChain::GetOptionString
virtual Char_t * GetOptionString(const Char_t *)
Returns the comment string associated to an option.
Definition: StBFChain.cxx:1480
StIOInterFace::SetIOMode
virtual void SetIOMode(Option_t *iomode="w")
number of transactions
Definition: StIOInterFace.h:35
StBFChain::Setup
void Setup(Int_t mode=1)
Definition: StBFChain.cxx:59
StBFChain::SetFlags
void SetFlags(const Char_t *Chain="gstar tfs")
Scan all flags, check if they are correct, manipulate the comment if necessary.
Definition: StBFChain.cxx:1518
StBFChain::SetTreeOptions
virtual void SetTreeOptions()
Creates output-tree branches.
Definition: StBFChain.cxx:1934
StChain::Finish
virtual Int_t Finish()
Definition: StChain.cxx:85
StBFChain::SetGeantOptions
virtual void SetGeantOptions(StMaker *geant=0)
Handles all geant options.
Definition: StBFChain.cxx:1742
StBFChain::SetDbOptions
virtual void SetDbOptions(StMaker *db=0)
Treats the DbV options used for database timestamp.
Definition: StBFChain.cxx:1787
Bfc_st
Definition: Bfc.h:8
StBFChain::kOpt
virtual Int_t kOpt(const TString *Tag, Bool_t Check=kTRUE) const
Check option if defined.
Definition: StBFChain.cxx:1145
TTable::GetNRows
virtual Long_t GetNRows() const
Returns the number of the used rows for the wrapped table.
Definition: TTable.cxx:1388
TTable::AddAt
virtual Int_t AddAt(const void *c)
Definition: TTable.cxx:1122
StMaker::GetName
virtual const char * GetName() const
special overload
Definition: StMaker.cxx:237
kStOK
Definition: Stypes.h:40
StBFChain::SetOption
virtual void SetOption(const Int_t k, const Char_t *chain="Chain")
Enable/disable valid command line options.
Definition: StBFChain.cxx:1435
StBFChain::Load
virtual Int_t Load()
Routine handling library loading depending on chain options.
Definition: StBFChain.cxx:117
StBFChain::~StBFChain
virtual ~StBFChain()
Destructor. Call Finish() . See this method for detail on what is cleaned.
Definition: StBFChain.cxx:112
StBFChain::SetOutputFile
void SetOutputFile(const Char_t *outfile=0)
Takes care of output file name (extension)
Definition: StBFChain.cxx:1652
StMaker::SetActive
virtual void SetActive(Bool_t k=kTRUE)
Setters for flags and switches.
Definition: StMaker.h:208
kStErr
Definition: Stypes.h:44
kStOk
Definition: Stypes.h:41
St_Bfc
Definition: Bfc.h:28
Generated by   doxygen 1.8.5