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  if (maker=="StKFVertexMaker" && GetOption("laserIT")) mk->SetAttr("laserIT" ,kTRUE);
554  // Sti(ITTF) end
555  if (maker=="StGenericVertexMaker") {
556  // VertexFinder methods
557  if (GetOption("Sti") || GetOption("StiCA") || GetOption("StiVMC" ) ) mk->SetAttr("ITTF" , kTRUE);
558  if (GetOption("VFMinuit" ) ) mk->SetAttr("VFMinuit" , kTRUE);
559  if (GetOption("VFppLMV" ) ) mk->SetAttr("VFppLMV" , kTRUE);
560  if (GetOption("VFppLMV5" ) ) mk->SetAttr("VFppLMV5" , kTRUE);
561  if ( GetOption("VFPPVEv") ) {
562  gSystem->Load("StBTofUtil.so");
563  mk->SetAttr("VFPPVEv" , kTRUE);
564  }
565  else if (GetOption("VFPPV") && GetOption("Sti")) mk->SetAttr( "VFPPV", kTRUE);
566  if (GetOption("VFPPVEvNoBtof")){
567  gSystem->Load("StBTofUtil.so"); //Not used but loaded to avoid fail
568  mk->SetAttr("VFPPVEvNoBtof", kTRUE);
569  }
570  if (GetOption("VFPPVnoCTB" ) ) mk->SetAttr("VFPPVnoCTB" , kTRUE);
571  if (GetOption("VFFV" ) ) mk->SetAttr("VFFV" , kTRUE);
572  if (GetOption("VFMCE" ) ) mk->SetAttr("VFMCE" , kTRUE);
573  if (GetOption("VFMinuit2" ) ) mk->SetAttr("VFMinuit2" , kTRUE);
574  if (GetOption("VFMinuit3" ) ) mk->SetAttr("VFMinuit3" , kTRUE);
575  if (GetOption("beamLine" ) ) mk->SetAttr("BeamLine" , kTRUE);
576  if (GetOption("beamLine3D" ) ) mk->SetAttr("BeamLine3D" , kTRUE);
577  if (GetOption("CtbMatchVtx") ) mk->SetAttr("CTB" , kTRUE);
578  if (GetOption("min2trkVtx" ) ) mk->SetAttr("minTracks" , 2);
579  if (GetOption("VtxSeedCalG") ) mk->SetAttr("calibBeamline" , kTRUE);
580  if (GetOption("usePct4Vtx" ) ) mk->SetAttr("PCT" , kTRUE);
581  if (GetOption("useBTOF4Vtx") ) mk->SetAttr("BTOF" , kTRUE);
582  if (GetOption("useBTOFmatchOnly") ) mk->SetAttr("useBTOFmatchOnly", kTRUE);
583 
584  // X-tended works only for VFPPV, VFPPVnoCTB, VFPPVev for now but could be re-used
585  // However, we will change this to a more flexible arbitrarry setting later
586  if (GetOption("VFStoreX") ) mk->SetAttr("VFStore" , 100);
587  //if (GetOption("VFStoreX") ) mk->SetAttr("VFStore" , 100);
588  mk->PrintAttr();
589  }
590  if (maker=="StKFVertexMaker") {
591  if (GetOption("beamLine" ) ) mk->SetAttr("BeamLine" , kTRUE);
592  }
593  if (maker=="StAssociationMaker") {
594 
595  LOG_QA << "StBFChain::Instantiate Setting the Parameters for the Association Maker" << endm;
596 
597  TString cmd("");
598  if (GetOption("ITTF") || GetOption("StiVMC") || GetOption("useInTracker"))
599  cmd = Form ("((StAssociationMaker *) %p)->useInTracker();",mk);
600  cmd += "StMcParameterDB* parameterDB = StMcParameterDB::instance();";
601  // TPC
602 #if 0
603  cmd += "parameterDB->setXCutTpc(.5);"; // 5 mm
604  cmd += "parameterDB->setYCutTpc(.5);"; // 5 mm
605  cmd += "parameterDB->setZCutTpc(.5);"; // 5 mm
606 #endif
607  cmd += "parameterDB->setReqCommonHitsTpc(3);"; // Require 3 hits in common for tracks to be associated
608  // FTPC
609 #if 0
610  cmd += "parameterDB->setRCutFtpc(.3);"; // 3 mm
611  cmd += "parameterDB->setPhiCutFtpc(5*(3.1415927/180.0));"; // 5 degrees
612 #endif
613  cmd += "parameterDB->setReqCommonHitsFtpc(3);"; // Require 3 hits in common for tracks to be associated
614  // SVT
615 #if 0
616  cmd += "parameterDB->setXCutSvt(.08);"; // 800 um
617  cmd += "parameterDB->setYCutSvt(.08);"; // 800 um
618  cmd += "parameterDB->setZCutSvt(.08);"; // 800 um
619 #endif
620  cmd += "parameterDB->setReqCommonHitsSvt(1);"; // Require 1 hits in common for tracks to be associated
621  if (GetOption("IdTruth")) cmd += Form("((StAssociationMaker *) %p)->useIdAssoc();",mk);
622  ProcessLine(cmd);
623  }
624  if (maker == "StMiniMcMaker" && GetOption("IdTruth") && ! GetOption("OldMiniMc")) {
625  mk->SetMode(1);
626  gMessMgr->QAInfo() << "StBFChain::Instantiate create simplified MiniMcTree in " << maker << endm;
627  }
628  // usually, we do maker first and option second but the
629  // logic is more readable with option first here (as it
630  // got a bit out of hand)
631  if (GetOption("ppOpt") ) { // pp specific stuff
632  if (maker == "StTrsMaker")
633  mk->SetMode(1); // Pile-up correction
634  }
635 
636  if (maker == "StStrangeMuDstMaker" && GetOption("CMuDST")&& GetOption("StrngMuDST") ) {
637 
638  mk -> SetAttr( "DoV0", 1 );
639  mk -> SetAttr( "DoXi", 1 );
640  mk -> SetAttr( "DoKink", 1 );
641  mk -> SetAttr( "SetNoKeep", 1 );
642 
643  }
644 
645  // Alex requested an option (not turned by default) to disable all
646  // hit reco cuts. This will make allm hits saved to MuDST /ezTree.
647  if ( maker == "StEmcRawMaker" && GetOption("BEmcDebug"))
648  mk->SetMode(1); // only one option now, bit a bitmask
649 
650  // Use status tables for raw BEMC data (helpful for QA)
651  if ( maker == "StEmcRawMaker" && GetOption("BEmcChkStat"))
652  mk->SetAttr("BEmcCheckStatus",kTRUE);
653 
654  // trigger simu maker
655  if ( maker == "StEmcRawMaker" && GetOption("picoWrite") ) {
656  mk->SetMode(10); // picoDst production - save all BTOW hits for triggerSimuMaker
657  }
658 
659  // trigger simu maker
660  if ( maker == "StTriggerSimuMaker" && GetOption("picoWrite") ) {
661  mk->SetMode(10); // picoDst production
662  }
663 
664  // MuDST and ezTree. Combinations are
665  // ezTree -> ezTree only
666  // CMuDST -> regular MuDST only
667  // ezTree,CMuDST -> both
668  if (maker == "StMuDstMaker" && GetOption("ezTree") ){
669  TString cmd(Form("StMuDstMaker *pMuMk = (StMuDstMaker *) %p;",mk));
670  if ( ! GetOption("CMuDST")) cmd += "pMuMk->SetStatus(\"*\",0);";
671  cmd += "pMuMk->SetStatus(\"EztAll\",1);";
672  ProcessLine(cmd);
673  }
674 
675  // FST Raw hits in StEvent
676  if (maker == "StFstRawHitMaker" && GetOption("fstEvtRawHit") ){
677  mk->SetAttr("fstEvtRawHit", kTRUE);
678  }
679 
680  // FST Raw hits in MuDST
681  if (maker == "StMuDstMaker" && GetOption("fstMuRawHit") ){
682  mk->SetAttr("fstMuRawHit", kTRUE);
683  }
684 
685  if ( maker == "StPicoDstMaker"){
686  if ( GetOption("picoWrite") ) mk->SetMode(1);
687  if ( GetOption("picoRead") ) mk->SetMode(2); // possibly more magic
688  if ( GetOption("PicoVtxVpd")) mk->SetAttr("PicoVtxMode", "PicoVtxVpd");
689  else if ( GetOption("PicoVtxFXT")) mk->SetAttr("PicoVtxMode", "PicoVtxFXT");
690  else if ( GetOption("PicoVtxMtd")) mk->SetAttr("PicoVtxMode", "PicoVtxMtd");
691  else if ( GetOption("PicoVtxVpdOrDefault")) mk->SetAttr("PicoVtxMode", "PicoVtxVpdOrDefault");
692  else if ( GetOption("PicoVtxDefault")) mk->SetAttr("PicoVtxMode", "PicoVtxDefault");
693  if ( GetOption("PicoCovMtxWrite")) mk->SetAttr("PicoCovMtxMode", "PicoCovMtxWrite");
694  else if ( GetOption("PicoCovMtxSkip")) mk->SetAttr("PicoCovMtxMode", "PicoCovMtxSkip"); // Default mode
695  if ( GetOption("PicoBEmcSmdWrite")) mk->SetAttr("PicoBEmcSmdMode", "PicoBEmcSmdWrite");
696  else if ( GetOption("PicoBEmcSmdSkip")) mk->SetAttr("PicoBEmcSmdMode", "PicoBEmcSmdSkip"); // Default mode
697  }
698 
699 
700  if (maker == "StLaserEventMaker"){
701  // Bill stuff - Empty place-holder
702  }
703  if (maker == "StDetectorDbMaker") {
704  if ( GetOption("DbRichSca") ) mk->SetMode(1);
705  }
706  if (maker == "StTpcRSMaker") {
707  if (! GetOption("TrsToF")) {
708  Int_t mode = mk->GetMode();
709  mode |= (1 << 10); // kNoToflight //10 don't account for particle time of flight
710  mk->SetMode(mode);
711  }
712  if (GetOption("EbyET0")) mk->SetAttr("EbyET0", kTRUE);
713  }
714  if (maker == "StTrsMaker") {
715  Int_t mode = 0;
716  if (GetOption("TrsPileUp")) mode += 1; // Pile-up correction
717  if (GetOption("TrsToF")) mode += 2; // account for particle time of flight
718  if (mode) mk->SetMode(mode);
719  }
720 
721  // Place-holder. Would possibly be a bitmask
722  if (maker == "StTofrMatchMaker"){
723  mk->SetMode(0);
724  }
725 
726  if (maker == "StSpaceChargeEbyEMaker") {
727  if ( GetOption("SpcChgCal") ||
728  GetOption("SpcChgCalG")) mk->SetMode(2);
729  if ( GetOption("SCScalerCal") ) mk->SetMode(4);
730  if ( GetOption("EastOff")) mk->SetAttr("EastOff",kTRUE);
731  if ( GetOption("WestOff")) mk->SetAttr("WestOff",kTRUE);
732  }
733  if (maker == "StEventQAMaker" && GetOption("QAalltrigs"))
734  ProcessLine(Form("((StEventQAMaker *) %p)->AllTriggers();",mk));
735  //Special options for V0s and Xis using estGlobal tracks
736  if(maker=="StV0FinderMaker" && Key=="v0svt"){
737  TString cmd(Form("StV0FinderMaker *V0mk=(StV0FinderMaker*) %p;",mk));
738  cmd += "V0mk->SetLanguageUsage(0);";
739  cmd += "V0mk->SetSVTUsage(1);";
740  cmd += "V0mk->SetV0LanguageUsage(3);";
741  ProcessLine(cmd);
742  }
743  if(maker=="StXiFinderMaker" && Key=="xisvt"){
744  TString cmd(Form("StXiFinderMaker *Ximk=(StXiFinderMaker*) %p;",mk));
745  cmd += "Ximk->SetLanguageUsage(0);";
746  cmd += "Ximk->SetSVTUsage(1);";
747  cmd += "Ximk->SetV0LanguageUsage(3);";
748  cmd += "Ximk->SetXiLanguageUsage(5);";
749  ProcessLine(cmd);
750  }
751 
752  // TPC
753  if (maker == "StTpcRTSHitMaker") {
754  if ( GetOption("TpxClu2D")) mk->SetAttr("TpxClu2D", kTRUE);
755  if ( GetOption("TPC23")) mk->SetAttr("TPC23", kTRUE);
756  }
757  if (maker == "StTpcDbMaker"){
758  if ( GetOption("Simu") && ! GetOption("NoSimuDb")) mk->SetAttr("Simu",kTRUE);
759  if ( GetOption("useLDV") ) mk->SetAttr("useLDV",kTRUE) ;// uses laserDV database
760  if ( GetOption("useCDV") ) mk->SetAttr("useCDV",kTRUE) ;// uses ofl database
761  if ( GetOption("useNewLDV") ) mk->SetAttr("useNewLDV",kTRUE);// uses new laserDV
762  if ( GetOption("shadow") ) mk->SetAttr("NoReset",kTRUE);// no resetting ExB
763  if ( GetOption("ExB")){
764  mk->SetAttr("ExB", kTRUE); // bit 0 is ExB ON or OFF
765  if ( GetOption("EB1") ) mk->SetAttr("EB1", kTRUE);
766  else if ( GetOption("EB2") ) mk->SetAttr("EB2", kTRUE);
767  else {
768  // depend on RY option i.e. take default for that RealYear data
769  // expectations.
770  if(GetOption("RY1H") ||
771  GetOption("RY2000") ||
772  GetOption("RY2001") ||
773  GetOption("RY2001N") ||
774  GetOption("RY2003") ||
775  GetOption("RY2003X")) mk->SetAttr("OldRuns", kTRUE);
776  }
777  // Other options introduced in October 2001 for distortion corrections
778  // studies and year1 re-production. Those are OR additive to the mask.
779  //(void) printf("StBFChain:: Options list : %d %d %d %d %d %d %d %d\n",
780  // kPadrow13,kTwist,kClock,kMembrane,kEndcap,
781  // kIFCShift,kSpaceCharge,kSpaceChargeR2);
782  if( GetOption("OBmap") ) mk->SetAttr("OBmap" , kTRUE);
783  if( GetOption("OPr13") ) mk->SetAttr("OPr13" , kTRUE);
784  if( GetOption("OPr40") ) mk->SetAttr("OPr40" , kTRUE);
785  if( GetOption("OTwist") ) mk->SetAttr("OTwist" , kTRUE);
786  if( GetOption("OClock") ) mk->SetAttr("OClock" , kTRUE);
787  if( GetOption("OCentm") ) mk->SetAttr("OCentm" , kTRUE);
788  if( GetOption("OECap") ) mk->SetAttr("OECap" , kTRUE);
789  if( GetOption("OIFC") ) mk->SetAttr("OIFC" , kTRUE);
790  if( GetOption("OSpaceZ") ) mk->SetAttr("OSpaceZ" , kTRUE);
791  if( GetOption("OSpaceZ2") ) {
792  if( GetOption("FXT") ) mk->SetAttr("OSpaceFXT" , kTRUE);
793  else mk->SetAttr("OSpaceZ2" , kTRUE);
794  }
795  if( GetOption("OShortR") ) mk->SetAttr("OShortR" , kTRUE);
796  if( GetOption("OBMap2d") ) mk->SetAttr("OBMap2d" , kTRUE);
797  if( GetOption("OGridLeak") ) mk->SetAttr("OGridLeak" , kTRUE);
798  if( GetOption("OGridLeak3D")) mk->SetAttr("OGridLeak3D", kTRUE);
799  if( GetOption("OGridLeakFull")) mk->SetAttr("OGridLeakFull", kTRUE);
800  if( GetOption("OGGVoltErr") ) mk->SetAttr("OGGVoltErr" , kTRUE);
801  if( GetOption("OSectorAlign"))mk->SetAttr("OSectorAlign",kTRUE);
802  if( GetOption("ODistoSmear")) mk->SetAttr("ODistoSmear", kTRUE);
803  if( GetOption("OAbortGap")) mk->SetAttr("OAbortGap" , kTRUE);
804  }
805  mk->PrintAttr();
806  }
807  if (maker == "StTpcHitMover" && GetOption("EbyET0")) {
808  mk->SetAttr("EbyET0", kTRUE);
809  }
810  if ((maker == "StdEdxY2Maker" || maker == "StTpcHitMover") &&
811  GetOption("EmbeddingShortCut")) {
812  mk->SetAttr("EmbeddingShortCut", kTRUE);
813  mk->PrintAttr();
814  }
815  if (maker == "StdEdxY2Maker" && !GetOption("CalcdNdx")) {
816  mk->SetAttr("SkipdNdx", kTRUE);
817  }
818  if (maker == "StSvtDbMaker" || maker == "StSsdDbMaker"){
819  mk->SetMode(0);
820  // If simulation running make sure pick up simu stuff from db
821  if (GetOption("Simu") && ! GetOption("NoSimuDb")) mk->SetMode(1);
822  }
823 
824  // FTPC
825  if ((maker == "StFtpcClusterMaker" ||
826  maker == "StFtpcTrackMaker" ) &&
827  GetOption("fdbg")) mk->SetMode(mk->GetMode()+2);
828  if ( ( maker == "StFtpcClusterMaker" || // ?
829  maker == "StFtpcTrackMaker" ) &&
830  GetOption("flaser")) mk->SetMode(mk->GetMode()+1);
831 
832  if ((maker == "StFtpcClusterMaker" ||
833  maker == "StFtpcTrackMaker" ) &&
834  GetOption("fgain")) mk->SetMode(mk->GetMode()+4);
835 
836 
837  // PMD
838  if ( maker == "StPmdReadMaker" &&
839  GetOption("pmdRaw")) mk->SetAttr("pmdRaw",kTRUE);
840 
841  // HFT
842  //if (maker == "StPxlSimMaker" &&
843  // GetOption("pxlSlowSim")) mk->SetAttr("useDIGMAPSSim",kTRUE);
844  // ... PXL
845  if (maker == "StPxlSimMaker") {
846  if (GetOption("pxlSlowSim")) mk->SetAttr("useDIGMAPSSim",kTRUE);
847  }
848 
849  //FMS GainCorrection flavors
850  if (maker == "StFmsDbMaker"){
851  if(fFmsGainCorrTag!="") mk->SetAttr("FmsGainCorr",fFmsGainCorrTag.Data());
852  }
853 
854  // Hit filtering will be made from a single maker in
855  // future with flexible filtering method
856  if (maker == "StHitFilterMaker") {
857  if (GetOption("SvtHitFilt")){
858  // Filter out SVT bad hits, TPC hits not on tracks and all hits if fabs(ZVert)>30
859  LOG_QA << "SVT hit filter is ON" << endm;
860  TString cmd(Form("StHitFilterMaker *Filtmk=(StHitFilterMaker*) %p;",mk));
861  cmd += "Filtmk->setPtLowerCut(-99.);";
862  cmd += "Filtmk->setPtUpperCut(-99.);";
863  cmd += "Filtmk->setAbsEtaCut(-99);";
864  cmd += "Filtmk->setAbsZVertCut(30);";
865  ProcessLine(cmd);
866  } else if (GetOption("TpcHitFilt")){
867  // Filter out TPC hits not on tracks
868  LOG_QA << "TPC hit filter is ON" << endm;
869  TString cmd(Form("StHitFilterMaker *Filtmk=(StHitFilterMaker*) %p;",mk));
870  cmd += "Filtmk->setPtLowerCut(-99.);";
871  cmd += "Filtmk->setPtUpperCut(-99.);";
872  cmd += "Filtmk->setAbsEtaCut(-99);";
873  cmd += "Filtmk->setAbsZVertCut(999);";
874  ProcessLine(cmd);
875  } else if (GetOption("HftHitFilt")){
876  // Filter out TPC hits not on tracks
877  LOG_QA << "HFT hit filter is ON" << endm;
878  TString cmd(Form("StHitFilterMaker *Filtmk=(StHitFilterMaker*) %p;",mk));
879  cmd += "Filtmk->setAbsZVertCut(-1);";
880  cmd += "Filtmk->setKeepWestHighEtaHitsForFgt(0);";
881  ProcessLine(cmd);
882  } else {
883  LOG_QA << "Default hit filtering is ON" << endm;
884  }
885  Int_t mode = 0;
886  if (GetOption("KeepTpcHit")) mode |= (1 << kTpcId);
887  if (GetOption("KeepSvtHit")) mode |= (1 << kSvtId);
888  mk->SetMode(mode);
889  // the m_Mode (Int_t is signed integer 4 bytes) mask is too short for the FGT
890  if (GetOption("KeepFgtHit")){
891  TString cmd(Form("StHitFilterMaker *Filtmk=(StHitFilterMaker*) %p;",mk));
892  cmd += "Filtmk->setKeepWestHighEtaHitsForFgt(1.0);";
893  ProcessLine(cmd);
894  }
895  }
896  if (maker == "StMiniMcMaker" && fFileOut != "") {
897  ProcessLine(Form("((StMiniMcMaker *) %p)->setFileName(\"%s\");", mk, fFileOut.Data()));
898  }
899  if (maker == "StMcAnalysisMaker") {
900  Int_t mode = 0;
901  if (GetOption("McAnaTpc")) mode += 0x1;
902  if (GetOption("McAnaSvt")) mode += 0x2;
903  if (GetOption("McAnaSsd")) mode += 0x4;
904  if (mode)
905  ProcessLine(Form("((StMaker *) %p)->SetMode(%i);", mk, mode));
906  }
907  if (maker == "StBTofCalibMaker") {
908  if (GetOption("UseProjectedVertex")) mk->SetAttr("UseProjectedVertex",kTRUE);
909  if (GetOption("setOutlierRej4BToft0")) mk->SetAttr("setPPPAOutlierRej", kTRUE);
910  if (GetOption("ImpBToFt0Mode")) mk->SetAttr("pppAMode", kTRUE);
911  if (GetOption("btofFXT")) mk->SetAttr("btofFXT", kTRUE);
912  }
913  if (maker == "StVpdCalibMaker" && GetOption("ImpBToFt0Mode")) mk->SetAttr("pppAMode", kTRUE);
914 
915  if (maker == "StEventMaker" && fFiltTrg.Length()) {
916  mk->SetAttr("FiltTrg",(Int_t) (fFiltTrg.BeginsWith('+') ? 1 : -1));
917  TString FiltTrgFlavor = fFiltTrg(1,128);
918  if (FiltTrgFlavor.Length())
919  SetFlavor((FiltTrgFlavor += "+ofl").Data(),"trgOfflineFilter");
920  }
921  if (maker == "StTagsMaker"){
922  if ( GetOption("shadow") ) mk->SetAttr("shadow",kTRUE);
923  }
924 
925  Add2Chain:
926  if (! mk) continue;
927  if (name == "") strncpy (fBFC[i].Name,(Char_t *) mk->GetName() , sizeof(fBFC[i].Name));
928  if (myChain) myChain->AddMaker(mk);
929  continue;
930  Error:
931  status = kStErr;
932  LOG_QA << " ======================================" << endm;
933  LOG_QA << " problem with Instantiation of " << fBFC[i].Maker << endm;
934  LOG_QA << " ======================================" << endm;
935  }
936  // PrintQAInfo();
937  PrintInfo();
938  // START the chain (may the force be with you)
939  // Create HTML docs of all Maker's inv
940 #if 0
941  if (GetOption("MakeDoc")) MakeDoc();
942 #endif
943  if (GetOption("Debug")) SetDEBUG(1);
944  if (GetOption("Debug1")) SetDEBUG(1);
945  if (GetOption("Debug2")) SetDEBUG(2);
946  if (GetOption("nohistos")) SetAttr(".histos",0,"*");
947  else SetAttr(".histos",1,"*");
948  if (GetOption("NoRepeat")) gMessMgr->IgnoreRepeats();
949 
950  if (GetOption("svt1hit")) SetAttr("minPrecHits",1,"Sti");
951  if (GetOption("svt1hit")) SetAttr("minPrecHits",1,"StiCA");
952  if (GetOption("svt1hit")) SetAttr("minPrecHits",1,"StiVMC");
953 
954  for ( unsigned int n=0 ; n < Gproperty.size() ; n++ ){
955  gMessMgr->QAInfo() << "+++ Setting attribute "
956  << (Gproperty.at(n)).Data() << " = " << (Gvalue.at(n)).Data() << " for "
957  << (Gpattern.at(n).Data()) << endm;
958 
959  SetAttr( (Gproperty.at(n)).Data(),
960  (Gvalue.at(n)).Data(),
961  (Gpattern.at(n)).Data() );
962  }
963 
964  return status;
965 }
966 //_____________________________________________________________________
967 Int_t StBFChain::Init() {
968 
969  TDatime td;
970  Info("Init","Time=%s Cwd=%s",td.AsString(),gSystem->pwd());
971 
972  SetChainOpt(new StBFChainOpt(this));
973  // SetDbOptions(); moved to Instantiation
974  if (fNoChainOptions) {
975  // SetGeantOptions(); move back to Init
976  if (GetOption("Simu") && ! (GetOption("mtin") || GetOption("PrepEmbed") || GetOption("pythiaEmbed"))) { // ! Simu
977  StEvtHddr *fEvtHddr = (StEvtHddr*)GetDataSet("EvtHddr");
978  if (!fEvtHddr) {
979  fEvtHddr = new StEvtHddr(m_ConstSet);
980  SetOutput(fEvtHddr); //Declare this "EvtHddr" for output
981  }
982  if (fEvtHddr->GetRunNumber() < 0 || fEvtHddr->GetRunNumber() >= 1000000) {
983  fEvtHddr->SetRunNumber(1); // to have run positive and < 1000000 (to avoid mess with RunLog)
984  }
985  }
986  }
987  if (fNoChainOptions) {
988  if (GetOption("NoOutput") || GetOption("EvOutOnly")) {
989  if (! GetOption("RMuDst"))
990  SetAttr(".call","SetActive(0)","MuDst"); //NO MuDst
991  if (! GetOption("EvOutOnly")) {
992  SetAttr(".call","SetActive(0)","outputStream"); //NO Out
993  }
994  SetAttr(".call","SetActive(0)","kink2");
995  SetAttr(".call","SetActive(0)","StTagsMaker::");
996  SetAttr(".call","SetActive(0)","StStrangeMuDstMaker::");
997  }
998 #if 1
999 
1000 
1001  if (fNoChainOptions) {
1002  if (GetOption("misalign") && TClass::GetClass("AgPosition") )
1003  gROOT->ProcessLine("AgPosition::SetReal();");
1004  else if ( TClass::GetClass("AgPosition") )
1005  gROOT->ProcessLine("AgPosition::SetIdeal();");
1006  }
1007 
1008 
1009  // force load of geometry for VMC and Sti
1010 
1011  if (GetOption("Sti") || GetOption("StiCA") ||
1012  GetOption("StiVMC") ||GetOption("VMC") ||
1013  GetOption("VMCPassive")) {
1014  const DbAlias_t *DbAlias = GetDbAliases();
1015  for (Int_t i = 0; DbAlias[i].tag; i++) {
1016  TString dbTag("r");
1017  dbTag += DbAlias[i].tag;
1018  if (GetOption(dbTag)) {
1019  TString path("./StarDb/AgiGeometry:$STAR/StarDb/AgiGeometry");
1020  if (GetOption("AgML")) {
1021  path = "./StarDb/AgMLGeometry:$STAR/StarDb/AgMLGeometry";
1022  }
1023  if (GetOption("VmcGeo")) {
1024  path = "./StarDb/VmcGeo:$STAR/StarDb/VmcGeo";
1025  }
1026  TString geom("Geometry.");
1027  geom += DbAlias[i].geometry;
1028  geom += ".C";
1029  Char_t *file = gSystem->Which(path.Data(),geom,kReadPermission);
1030  if (file) {
1031  LOG_INFO << "StBFChain::Init force load of " << file << endm;
1032  TString command = ".L "; command += file;
1033  gInterpreter->ProcessLine(command);
1034  gInterpreter->Calc("CreateTable()");
1035  command.ReplaceAll(".L ",".U ");
1036  gInterpreter->ProcessLine(command);
1037  delete [] file;
1038  } else {
1039  LOG_INFO << "StBFChain::Init file for geometry tag " << geom << " has not been found in path" << path << endm;
1040  }
1041  break;
1042  }
1043  }
1044  }
1045 #endif
1046  }
1047  return StChain::Init();
1048 }
1049 //_____________________________________________________________________
1051 Int_t StBFChain::Finish()
1052 {
1053  TFile *tf = GetTFile();
1054  if (tf) {tf->Write(); tf->Flush(); tf->Close(); delete tf; SetTFile(0);}
1055  if (!fBFC) return kStOK;
1056  Int_t ians = StChain::Finish();
1057  SafeDelete(fchainOpt);
1058  fBFC = 0;
1059 // delete gMessMgr; gMessMgr = 0;
1060  return ians;
1061 }
1062 
1063 
1064 //_____________________________________________________________________
1065 Int_t StBFChain::AddAB (const Char_t *mkname,const StMaker *maker,const Int_t Opt) {
1066  if (! maker || strlen(mkname) == 0) return kStErr;
1067  StMaker *parent = maker->GetParentMaker();
1068  if (parent) {
1069  TList *list = parent->GetMakeList();
1070  list->Remove((StMaker *)maker);
1071  }
1072  StMaker *mk = GetMaker(mkname); if (!mk) return kStErr;
1073  parent = mk->GetParentMaker(); if (!parent) return kStErr;
1074  TList *list = parent->GetMakeList(); if (!list) return kStErr;
1075  if (Opt > 0) list->AddAfter (mk,(StMaker*)maker);
1076  else list->AddBefore(mk,(StMaker*)maker);
1077  return kStOk;
1078 }
1079 
1080 //_____________________________________________________________________
1081 Int_t StBFChain::ParseString (const TString &tChain, TObjArray &Opt, Bool_t Sort) {
1082  Opt.Clear();
1083  TObjArray *obj = tChain.Tokenize("[^ ;,]+");
1084  Int_t nParsed = obj->GetEntries();
1085  Int_t k, N = 0;
1086  if (GetChain() && GetChain()->Debug() > 2) {
1087  gMessMgr->QAInfo() << "ParseString " << tChain.Data() << endm;
1088  for (k = 0; k < nParsed; k++) {
1089  if (obj->At(k)) {
1090  gMessMgr->QAInfo() << k << "\t" << ((TObjString *) obj->At(k))->GetName() << endm;
1091  }
1092  }
1093  }
1094  for (k = 0; k < nParsed; k++) {if (obj->At(k)) {if (k != N) obj->AddAt(obj->At(k),N); N++;}}
1095  nParsed = N;
1096  // sort options
1097  StBFChain *curChain = (StBFChain *) StMaker::GetChain();
1098  if (curChain && Sort) {// sort options
1099  TArrayI idT(nParsed); Int_t *idx = idT.GetArray();
1100  TArrayI kdT(nParsed); Int_t *kdx = kdT.GetArray();
1101  for (k = 0; k < nParsed; k++) {
1102  TString string = ((TObjString *) obj->At(k))->GetString();
1103  kdx[k] = TMath::Abs(curChain->kOpt(string,kFALSE));
1104  }
1105  TMath::Sort(nParsed,kdx,idx,0);
1106  TString sChain;
1107  for (k = 0; k < nParsed; k++) {
1108  Opt.AddAtAndExpand(obj->At(idx[k]),k);
1109  if (k == 0) sChain = ((TObjString *)Opt[k])->GetString();
1110  else {sChain += ","; sChain += ((TObjString *)Opt[k])->GetString();}
1111  }
1112  if (N > 1 && curChain->Debug() > 2) {
1113  gMessMgr->QAInfo() << "Requested chain is :\t" << tChain.Data() << endm;
1114  gMessMgr->QAInfo() << "Sorted chain is :\t" << sChain.Data() << endm;
1115  }
1116  } else for (k = 0; k < nParsed; k++) Opt.AddAtAndExpand(obj->At(k),k);
1117  obj->SetOwner(kFALSE);
1118  delete obj;
1119  return nParsed;
1120 }
1121 
1122 //_____________________________________________________________________
1124 Int_t StBFChain::kOpt (const Char_t *tag, Bool_t Check) const {
1125  TString Tag(tag);
1126  Int_t kO = kOpt(&Tag, Check);
1127  return kO;
1128 }
1129 //_____________________________________________________________________
1131 
1137 Int_t StBFChain::kOpt (const TString *tag, Bool_t Check) const {
1138  TString Tag = *tag;
1139  Tag.ToLower();
1140  TString opt, nopt;
1141  for (Int_t i = 1; i< fNoChainOptions; i++) {
1142  opt = TString(fBFC[i].Key); //check nick name
1143  opt.ToLower();
1144  nopt = TString("-");
1145  nopt += opt;
1146  if (Tag == opt) {return i;}
1147  else {if (Tag == nopt) {return -i;}}
1148  opt = fBFC[i].Maker; //check full maker name2
1149  nopt = "-";
1150  nopt += opt;
1151  if (Tag == opt) {return i;}
1152  else {if (Tag == nopt) {return -i;}}
1153  }
1154  //
1155  // JL - sdt and dbv for timestamp
1156  //
1157  // Gopt for arbitrary property on 3 letter name (wildcard would be added) and length
1158  // 6 for a value. Not advertized / not used and implementation is not complete (needed
1159  // a case and do not have a clear one). TBD.
1160  //
1161  // 2011/11 added the possibility of detector sub-system specific timestamps.
1162  // DBV only for now, logic is similar if we equally parse.
1163  //
1164  // {sdt|dbv}YYYYMMDD -> {sdt|dbv} 3 / YYYYMMDD 8 => 11 || YYYYMMDD.HHMMSS = 15 => 18
1165  if (Tag.BeginsWith("dbv") || Tag.BeginsWith("sdt")) {
1166  Check = kTRUE;
1167 
1168  if (Tag.Length() == 11 || Tag.Length() == 18) return 0;
1169 
1170  // Else we need to parse some more - assume a pattern {dbv|sdt}YYYYMMDD[.HHMMSS]_XXX_ZZZZZ
1171  // First, detect it using quick counting
1172  Tag.ToLower();
1173  if ( TPRegexp(BFC_DBREGEXP).Match(Tag) == 7) return 0;
1174  }
1175  if (Tag.BeginsWith("rung")) {
1176  Check = kTRUE;
1177  return 0;
1178  }
1179 
1180  //FMS gaincorr
1181  if(Tag.BeginsWith("fmsGainCorr")){
1182  Check = kTRUE;
1183  return 0;
1184  }
1185 
1186  // GoptXXXvvvvvv -> Gopt 4 / XXX 3 / vvvvvv 6 = 13
1187  if ( Tag.BeginsWith("gopt") && Tag.Length() == 13 ) return 0;
1188 
1189  if ( Tag.BeginsWith("FiltTrg",TString::kIgnoreCase) ) {
1190  Check = kTRUE;
1191  if ( TPRegexp("^FiltTrg(Inc|Exc)?(_.*)*$").Match(Tag,"i") > 0) return 0;
1192  }
1193  if ( Tag.BeginsWith("VFStore",TString::kIgnoreCase) ||
1194  Tag.BeginsWith("TpcVpdVzDiffCut",TString::kIgnoreCase)
1195  ) {
1196  // need to match an ":" sign
1197  Check = kTRUE;
1198  if ( Tag.Index(':') != 0) return 0;
1199  }
1200 
1201 
1202  if (Check) {
1203  gMessMgr->Error() << "Option " << Tag.Data() << " has not been recognized" << endm;
1204  abort(); //assert(1);
1205  }
1206  return 0;
1207 }
1208 //_____________________________________________________________________
1209 void StBFChain::SetOptions(const Char_t *options, const Char_t *chainName) {
1210  TString tChain(options);
1211  TObjArray Opts;
1212  Int_t nParsed = ParseString(tChain,Opts,kTRUE);
1213  for (Int_t l = 0; l < nParsed; l++) {
1214  TString Tag = ((TObjString *)Opts[l])->GetString();
1215  Int_t kgo;
1216  Int_t in = Tag.Index("=");
1217  if (in > 0) {// string with "="
1218  TString subTag(Tag.Data(),in);
1219  subTag.ToLower(); //printf ("Chain %s\n",tChain.Data());
1220  kgo = kOpt(subTag.Data());
1221  if (kgo > 0) {
1222  int len= sizeof(fBFC[kgo].Comment);
1223  memset(fBFC[kgo].Comment,0,len); // be careful size of Comment
1224  TString Comment(Tag.Data()+in+1,Tag.Capacity()-in-1);
1225  if ( Comment.Length() <= len ){
1226  strncpy (fBFC[kgo].Comment, Comment.Data(),sizeof(fBFC[kgo].Comment));
1227  gMessMgr->QAInfo() << Form(" Set %s = %s", fBFC[kgo].Key,fBFC[kgo].Comment) << endm;
1228  } else {
1229  gMessMgr->Error() << Form(" Cpy problem [%s] is > %d - adjust BFC Comment field size",
1230  Comment.Data(),len) << endm;
1231  }
1232  }
1233  } else {
1234  Tag.ToLower();
1235  // printf ("Chain %s\n",tChain.Data());
1236  kgo = kOpt(Tag.Data(),kFALSE);
1237  if (kgo != 0) {
1238  SetOption(kgo,chainName);
1239  if (kgo > 0) {
1240  TString Comment(fBFC[kgo].Comment);
1241  TString Opts(fBFC[kgo].Opts);
1242  if (Tag.BeginsWith("Test.",TString::kIgnoreCase) && ! Comment.BeginsWith("/star/") &&
1243  Opts.BeginsWith("test_",TString::kIgnoreCase)) {
1244  SetOptions(Opts,Tag);
1245  } else {
1246  if ((Tag.BeginsWith("Test.",TString::kIgnoreCase) ||
1247  Tag.BeginsWith("test_",TString::kIgnoreCase) ||
1248  Tag.BeginsWith("eval_",TString::kIgnoreCase)) && Comment.BeginsWith("/star/") ) {
1249  fkChain = kgo;
1250  gMessMgr->QAInfo() << "Default Test chain set " << fBFC[fkChain].Key << " with input " << fBFC[fkChain].Comment << endm;
1251  }
1252  }
1253  }
1254  } else {
1255  // it is 0 i.e. was not recognized.
1256  // Check if it is a (dbv|sdt)YYYYMMDD or (dbv|sdt)YYYYMMDD.HHMMSS and derivative
1257  // We really set the options only once later in SetDbOptions() (removing the fBFC[i].Flag check)
1258  // but the goal here is to avoid user's histeria by displaying extra messages NOW.
1259  //
1260  // Note that kOpt() has already validated the pattern (so it has to be right here).
1261  //
1262  // !!! Debug: dbv20040917
1263  if (Tag.BeginsWith("dbv")) {
1264  if (Tag.Length() == 11) (void) sscanf(Tag.Data(),"dbv%8d",&FDate);
1265  if (Tag.Length() == 18) (void) sscanf(Tag.Data(),"dbv%8d.%6d",&FDate,&FTime);
1266  if (Tag.Length() == 11 || Tag.Length() == 18) {
1267  gMessMgr->QAInfo() << Tag.Data() << " ... but still will be considered as a dynamic timestamp (Max DB EntryTime) "
1268  << FDate << "." << FTime << endm;
1269 #ifdef USE_BFCTIMESTAMP
1270  } else {
1271  // we passed kOpt() parsing was fine
1272  //if ( TPRegexp(BFC_DBREGEXP).Match(Tag) == 7) return 0;
1273  TObjArray *subStrL = TPRegexp(BFC_DBREGEXP).MatchS(Tag);
1274  BFCTimeStamp TS;
1275  TString realm;
1276 
1277  TS.Type = 1;
1278  TS.Date = (((TObjString *) subStrL->At(2))->GetString()).Atoi();
1279  TS.Time = 0; // for now, avoid parsing this as user use simple TS 99% of the time
1280  TS.Detector = ((TObjString *) subStrL->At(4))->GetString();
1281  TS.Realm = ((TObjString *) subStrL->At(6))->GetString();
1282 
1283  if ( TS.Realm.IsNull() ){ realm = "*";}
1284  else { realm = TS.Realm;}
1285 
1286  GTSOptions.push_back(TS);
1287 
1288  LOG_WARN << "Override timestamp for detector requested\n\t"
1289  << "Detector " << TS.Detector << "\n\t"
1290  << "Realm " << realm << "\n\t"
1291  << "Date " << TS.Date << "\n\t"
1292  << "Time " << TS.Time << endm;
1293 #endif /* USE_BFCTIMESTAMP */
1294  }
1295 
1296  } else if (Tag.BeginsWith("sdt")) {
1297  if (Tag.Length() == 11) (void) sscanf(Tag.Data(),"sdt%8d",&FDateS);
1298  if (Tag.Length() == 18) (void) sscanf(Tag.Data(),"sdt%8d.%6d",&FDateS,&FTimeS);
1299  if (Tag.Length() == 11 || Tag.Length() == 18) {
1300  gMessMgr->QAInfo() << Tag.Data() << " ... but still will be considered as a dynamic timestamp (Event Time) "
1301  << FDateS << "." << FTimeS << endm;
1302 
1303  // <<< same logic for GTSOptions can be inserted here
1304  // <<< if so, use TS.Type = 2
1305  }
1306 
1307  } else if ( Tag.BeginsWith("gopt") && Tag.Length() == 13){
1308  // TODO option best as gopt.$ATTRR.$VAL for arbitrary attribute and value
1309  // parsing to extend
1310  char GOptName[4],GOptValue[7];
1311  TString property(".gopt.");
1312  //TString pattern("*");
1313 
1314  (void) sscanf(Tag.Data(),"gopt%3s%6s",GOptName,GOptValue);
1315  // sscanf adds null terminators for %s, so buffers need to be 1 longer
1316 
1317  // see StBFChain::Setup() for default values
1318  property += GOptName;
1319  Gproperty.push_back(property);
1320  Gvalue.push_back(GOptValue);
1321  Gpattern.push_back("*");
1322 
1323  // JL - this is not finished, see comment in kOpt()
1324 
1325  // pattern is case sensitive, need more checks on this before
1326  // setting to something else than "*"
1327  //Gpattern += GOptName;
1328  //Gpattern += "*";
1329 
1330 
1331  gMessMgr->QAInfo() << Tag.Data() << " ... this will set an general attribute "
1332  << property.Data() << " with value " << GOptValue << " to "
1333  << "*" << endm;
1334  // Attr() need to be set after the maker exist
1335  //SetAttr(property.Data(),GOptValue,pattern.Data());
1336  //SetAttr(property.Data(),GOptValue,pattern.Data());
1337 
1338  } else if (Tag.BeginsWith("rung")) {
1339  fRunG = 1;
1340  if (Tag.Length() > 4) (void) sscanf(Tag.Data(),"rung.%d",&fRunG);
1341  gMessMgr->QAInfo() << Tag.Data() << " will be considered as Run number (& rndm seed set) "
1342  << fRunG << " for simulation." << endm;
1343 
1344 
1345  // JL: super long options I could not accomomodate with gopt (also used ":")
1346  } else if (Tag.BeginsWith("VFStore" ,TString::kIgnoreCase) ||
1347  Tag.BeginsWith("TpcVpdVzDiffCut",TString::kIgnoreCase)
1348  ) {
1349  TString VFS = Tag;
1350  Ssiz_t idx = Tag.Index(':');
1351 
1352  //cout << "-+-+-+- DEBUG -+-+-+- position = " << idx << endl;
1353 
1354  if ( idx != 0){
1355  // exclude VFStoreX or options not containing "."
1356  Gproperty.push_back(Tag(0,idx));
1357  Gvalue.push_back(Tag(idx+1,64));
1358  // can use better patterns VFStore -> mk=StGenericVertexMaker
1359  Gpattern.push_back("*");
1360 
1361  gMessMgr->QAInfo() << "Detecting " << Tag(0,idx).Data() << " = " << Tag(idx+1,64).Data() << " as global property" << endm;
1362 
1363  // Attr() need to be set after the maker exist
1364 
1365  }
1366 
1367 
1368  } else if (Tag.BeginsWith("FiltTrg",TString::kIgnoreCase)) {
1369  TString filtTrgTag = Tag;
1370  Ssiz_t flavorIdx = Tag.Index('_');
1371  if (flavorIdx > 0) {
1372  filtTrgTag = Tag(0,flavorIdx);
1373  fFiltTrg = Tag(flavorIdx+1,64);
1374  }
1375  if (filtTrgTag.CompareTo("FiltTrgExc",TString::kIgnoreCase)==0) {
1376  gMessMgr->QAInfo() << "Trigger Filtering exclude with flavor=" << fFiltTrg << endm;
1377  fFiltTrg.Prepend('-');
1378  } else if (filtTrgTag.CompareTo("FiltTrgInc",TString::kIgnoreCase)==0 ||
1379  filtTrgTag.CompareTo("FiltTrg" ,TString::kIgnoreCase)==0) {
1380  gMessMgr->QAInfo() << "Trigger Filtering include with flavor=" << fFiltTrg << endm;
1381  fFiltTrg.Prepend('+');
1382  } else {
1383  // not a match, disable
1384  fFiltTrg = "";
1385  }
1386 
1387  } else if (Tag.BeginsWith("fmsGainCorr",TString::kIgnoreCase)) {
1388  fFmsGainCorrTag = Tag;
1389 
1390  } else { // Check for predefined db time stamps ?
1391  kgo = kOpt(Tag.Data(),kFALSE);
1392  if (kgo != 0){
1393  SetOption(kgo,chainName);
1394  } else {
1395  // Check that option can be library name or / and Maker
1396  static const Char_t *path = ".:.$STAR_HOST_SYS/lib::.$STAR_HOST_SYS/LIB:$STAR/.$STAR_HOST_SYS/lib:$STAR/.$STAR_HOST_SYS/LIB";
1397  TString File = Tag; File += ".so";
1398  Char_t *file = gSystem->Which(path,File.Data(),kReadPermission);
1399  if (file) {
1400  TString Maker("");
1401  Bfc_st row = {"","","","","","","",kTRUE};
1402  memcpy (&row.Key, Tag.Data(), Tag.Length());
1403  if (Tag.Contains("Maker")) memcpy (&row.Maker, Tag.Data(), Tag.Length());
1404  memcpy (&row.Libs, Tag.Data(), Tag.Length());
1405  fchainOpt->AddAt(&row);
1406  fNoChainOptions = fchainOpt->GetNRows();
1407  fBFC = fchainOpt->GetTable();
1408  delete [] file;
1409  }
1410  kgo = kOpt(Tag.Data(),kFALSE);
1411  if (kgo != 0) {
1412  SetOption(kgo,chainName);
1413  } else {
1414  gMessMgr->QAInfo() << " Invalid Option " << Tag.Data() << ". !! ABORT !! " << endm;
1415  abort(); //assert(1);
1416  return;
1417  }
1418  }
1419  }
1420  }
1421  }
1422  }
1423  Opts.Delete();
1424 }
1425 //_____________________________________________________________________
1427 void StBFChain::SetOption(const Int_t k, const Char_t *chainName) {
1428  if (k > 0) {
1429  assert(k<fNoChainOptions);
1430  Int_t n = strlen(fBFC[k].Opts);
1431  if (n > 0) SetOptions(fBFC[k].Opts,fBFC[k].Key);
1432  if (!fBFC[k].Flag) {
1433  fBFC[k].Flag = kTRUE;
1434  gMessMgr->QAInfo() << Form(" Switch On %20s by %s", fBFC[k].Key, chainName) << endm;
1435  }
1436  } else {
1437  assert(-k<fNoChainOptions);
1438  if (k < 0 && fBFC[-k].Flag) {
1439  fBFC[-k].Flag = kFALSE;
1440  gMessMgr->QAInfo() << Form(" Switch Off %20s by %s", fBFC[-k].Key, chainName) << endm;
1441  }
1442  }
1443 }
1444 
1445 //_____________________________________________________________________
1447 Bool_t StBFChain::GetOption(const Int_t k) const
1448 {
1449  return (k>0 && k <fNoChainOptions) ? fBFC[k].Flag : kFALSE;
1450 }
1451 
1453 
1472 Char_t *StBFChain::GetOptionString(const Char_t *Opt)
1473 {
1474  Int_t o = kOpt(Opt);
1475  if(!o) return NULL;
1476  else if(!GetOption(o)) return NULL;
1477  else return(fBFC[o].Comment);
1478 }
1479 
1480 
1481 //_____________________________________________________________________________
1483 
1510 void StBFChain::SetFlags(const Char_t *chainOpts)
1511 {
1512  TString tChain(chainOpts);
1513  Int_t mode = 1;
1514  Setup(mode);
1515  Int_t k=0;
1516  if (tChain == "" || tChain.CompareTo("ittf",TString::kIgnoreCase) == 0) {
1517  gMessMgr->QAInfo() << "\tPossible Chain Options are:" << endm;
1518  for (k=0;k<fNoChainOptions;k++)
1519  gMessMgr->QAInfo()
1520  << Form(" %3d: %-30s:%-12s:%-12s:%s:%s:%s:%s"
1521  ,k,fBFC[k].Key,fBFC[k].Name,fBFC[k].Chain,fBFC[k].Opts,fBFC[k].Maker,fBFC[k].Libs,fBFC[k].Comment)
1522  << endm;
1523 
1524  return;
1525  }
1526  TString STAR_VERSION("$STAR_VERSION");
1527  gSystem->ExpandPathName(STAR_VERSION);
1528  gMessMgr->QAInfo() << "==============================================" << endm;
1529  gMessMgr->QAInfo() << "============= You are in " << STAR_VERSION.Data() << " ===============" << endm;
1530  gMessMgr->QAInfo() << "Requested chain " << GetName() << " is :\t" << tChain.Data() << endm;
1531  SetOptions(tChain,"Chain");
1532  if (GetOption("NewTpcAlignment")) {
1533  gMessMgr->QAInfo() << "Set environment to use NewTpcAlignment" << endm;
1534  gEnv->SetValue("NewTpcAlignment",1);
1535  }
1536  if (!GetOption("NoDefault")) { // Default
1537  // Check flags consistency
1538  if (gClassTable->GetID("TGiant3") >= 0) { // root4star
1539  SetOption("-VMC","Default,TGiant3");
1540  SetOption("-VMCPassive","Default,TGiant3");
1541  SetOption("-VMCAppl","Default,TGiant3");
1542  SetOption("-RootVMC","Default,TGiant3");
1543  if (GetOption("xgeometry")) {
1544  SetOption("-geometry","Default,-xgeometry");
1545  SetOption("-geomNoField","Default,-xgeometry");
1546  }
1547  } else { // root
1548  if (GetOption("fzin")) {
1549  gMessMgr->Error() << "Option fzin cannot be used in root.exe. Use root4star" << endm;
1550  abort();
1551  }
1552  if (GetOption("ntin")) {
1553  gMessMgr->Error() << "Option ntin cannot be used in root.exe. Use root4star" << endm;
1554  abort();
1555  }
1556 
1557  if (GetOption("gstar") || GetOption("pythia")) {
1558  SetOption("VMC","Default,-TGiant3,gstar");
1559  SetOption("-gstar","Default,-TGiant3");
1560  SetOption("-pythia","Default,-TGiant3");
1561  }
1562 
1563  SetOption("-geant","Default,-TGiant3");
1564  SetOption("-geantL","Default,-TGiant3");
1565  SetOption("-geometry","Default,-TGiant3");
1566  SetOption("-geomNoField","Default,-TGiant3");
1567 
1568  if (! (GetOption("VMC") || GetOption("VMCPassive"))) {
1569  SetOption("VMCPassive","Default,-TGiant3");
1570  }
1571  SetOption("pgf77","Default,-TGiant3");
1572  SetOption("mysql","Default,-TGiant3");
1573  SetOption("StarMiniCern","Default,-TGiant3");
1574 
1575  }
1576  if (GetOption("ITTF") && ! (GetOption("Sti") || GetOption("StiCA") || GetOption("StiVMC"))) {
1577  TString STAR_LEVEL(gSystem->Getenv("STAR_LEVEL"));
1578  if (STAR_LEVEL == ".DEV2") SetOption("StiCA","Default,ITTF");
1579  else SetOption("Sti" ,"Default,ITTF");
1580  }
1581  }
1582  if (!GetOption("Eval") && GetOption("AllEvent")) SetOption("Eval","-Eval,AllEvent");
1583  // Print set values
1584  St_Bfc *Bfc = new St_Bfc("BFChain",fNoChainOptions);
1585  AddRunco(Bfc);
1586  for (k = 1; k<fNoChainOptions;k++) {
1587  if (GetOption(k)) {
1588  gMessMgr->QAInfo() << Form("================== %20s\tis ON \t: %s",
1589  (char *) fBFC[k].Key, (char *) fBFC[k].Comment) << endm;
1590  Bfc->AddAt(&fBFC[k]);
1591  }
1592  }
1593  // gSystem->Exit(1);
1594 }
1595 //_____________________________________________________________________
1596 void StBFChain::Set_IO_Files (const Char_t *infile, const Char_t *outfile){
1597  TString gc("");
1598  if (infile) {
1599  if (strlen(infile) > 2) {
1600  gc = TString(infile,3);
1601  gc.ToLower();
1602  }
1603  }
1604  SetInputFile(infile);
1605  if (! GetOption("NoOutput")) SetOutputFile(outfile);
1606 }
1607 //_____________________________________________________________________
1608 void StBFChain::SetInputFile (const Char_t *infile){
1609  // define input file
1610  if (infile) fInFile = infile;
1611  if (fInFile != "") {
1612  fInFile.ReplaceAll("\n",";");
1613  fInFile.ReplaceAll("#",";");
1614  fInFile.ReplaceAll(":",";");
1615  gMessMgr->QAInfo() << "Input file name = " << fInFile.Data() << endm;
1616  } else {
1617  if (fkChain >= 0) {
1618  fInFile = fBFC[fkChain].Comment;
1619  fInFile.ReplaceAll("\n",";");
1620  gMessMgr->QAInfo() << "Default Input file name = " << fInFile.Data() << " for chain : " << fBFC[fkChain].Key << endm;
1621  }
1622  }
1623  if (fInFile == "") {SetOption("-in","No Input File"); SetOption("-InTree","NoInput File"); return;}
1624  if (!GetOption("fzin") && !GetOption("ntin")) {
1625  fSetFiles= new StFile();
1626  TObjArray Files;
1627  ParseString(fInFile,Files);
1628  TIter next(&Files);
1629  TObjString *File;
1630  while ((File = (TObjString *) next())) {
1631  TString string = File->GetString();
1632  if (!string.Contains("*") && ! string.BeginsWith("@") &&
1633  gSystem->AccessPathName(string.Data())) {// file does not exist
1634  gMessMgr->Error() << "StBFChain::SetInputFile *** NO FILE: " << string.Data() << ", exit!" << endm;
1635  gSystem->Exit(1);
1636  }
1637  else fSetFiles->AddFile(File->String().Data());
1638  }
1639  Files.Delete();
1640  }
1641 }
1642 //_____________________________________________________________________
1644 void StBFChain::SetOutputFile (const Char_t *outfile){
1645  if (! GetOption("NoOutput")) {
1646  if (outfile) {
1647  fFileOut = outfile;
1648  } else {
1649  if (fInFile != "") {
1650  if (GetOption("fzin") || GetOption("ntin")) {
1651  TObjArray words;
1652  ParseString(fInFile,words);
1653  TIter nextL(&words);
1654  TObjString *word = 0;
1655  while ((word = (TObjString *) nextL())) {
1656  if (word->GetString().Contains(".fz") ||
1657  word->GetString().Contains(".nt")) {
1658  fFileOut = gSystem->BaseName(word->GetName());
1659  break;
1660  }
1661  }
1662  } else {
1663  fFileOut = gSystem->BaseName(fInFile.Data());
1664  if (GetOption("shadow")) {
1665  TObjArray* fileOutTokens = fFileOut.Tokenize("_.");
1666  TString& runToken = ((TObjString*) (fileOutTokens->At(2)))->String();
1667  TString& seqToken = ((TObjString*) (fileOutTokens->At(4)))->String();
1668  if (!(runToken.CompareTo("adc"))) {
1669  runToken = ((TObjString*) (fileOutTokens->At(3)))->String();
1670  seqToken = ((TObjString*) (fileOutTokens->At(5)))->String();
1671  }
1672  if (!(runToken.IsDigit())) {
1673  LOG_ERROR << "Unable to locate run number in filename for shadowing." << endm;
1674  } else {
1675  fFileOut.ReplaceAll(runToken,Form("%d",
1676  StShadowMaker::getRunNumber(runToken.Atoi())));
1677  }
1678  if (!(seqToken.IsDigit())) {
1679  LOG_ERROR << "Unable to locate file sequence number in filename for shadowing." << endm;
1680  } else {
1681  fFileOut.ReplaceAll(seqToken,Form("%07d",
1682  StShadowMaker::getFileSeq(seqToken.Atoi())));
1683  }
1684  delete fileOutTokens;
1685  }
1686  }
1687  }
1688  if (fFileOut == "") {
1689  if (GetOption("pythia")) fFileOut = "pythia.root";
1690  else if (GetOption("hijing")) fFileOut = "hijing.root";
1691  else if (GetOption("VMC")) fFileOut = "VMC.root";
1692  else if (GetOption("gstar")) fFileOut = "gtrack.root";
1693  }
1694  if ( fFileOut != "") {
1695  fFileOut.ReplaceAll("*","");
1696  fFileOut.ReplaceAll("@","");
1697  fFileOut.ReplaceAll("..",".");
1698  fFileOut.ReplaceAll(".daq","");
1699  fFileOut.ReplaceAll(".fzd","");
1700  fFileOut.ReplaceAll(".fz","");
1701  fFileOut.ReplaceAll(".nt","");
1702  fFileOut.ReplaceAll(".root","");
1703  fFileOut.ReplaceAll(".list","");
1704  fFileOut.ReplaceAll(".lis","");
1705  fFileOut.Strip();
1706  fFileOut.Append(".root");
1707  }
1708  }
1709  }
1710  if (fFileOut != "") gMessMgr->QAInfo() << "Output root file name " << fFileOut.Data() << endm;
1711  else SetOption("NoOutput","No Output File");
1712  if (!GetTFile()) {
1713  if ( ( GetOption("tags") || GetOption("lana") ) && (fFileOut != "") ){
1714  TString TagsName = fFileOut;
1715  if( GetOption("lana") ){
1716  TagsName.ReplaceAll(".root",".laser.root");
1717  } else if ( GetOption("mtdEvtFilt") ){
1718  TagsName.ReplaceAll(".root",".pretags.root");
1719  } else {
1720  TagsName.ReplaceAll(".root",".tags.root");
1721  }
1722  SetTFile(new TFile(TagsName.Data(),"RECREATE"));
1723  }
1724  }
1725 }
1726 //_____________________________________________________________________
1728 
1734 void StBFChain::SetGeantOptions(StMaker *geantMk){
1735  if (geantMk && geantMk->InheritsFrom("St_geant_Maker")) {
1736  SetInput("geant",".make/geant/.data");
1737  TString GeomVersion("");
1738  if (fRunG > 0) {
1739  geantMk->SetAttr("RunG",fRunG);
1740  }
1741  if (!GetOption("fzin") || GetOption("ForceGeometry")) {
1742  GeomVersion = "y2004x";
1743  const DbAlias_t *DbAlias = GetDbAliases();
1744  Int_t found = 0;
1745  for (Int_t i = 0; DbAlias[i].tag; i++) {
1746  TString r("r");
1747  r += DbAlias[i].tag;
1748  if ( !GetOption(DbAlias[i].tag,kFALSE) && !GetOption(r,kFALSE)) continue;
1749  GeomVersion = DbAlias[i].geometry;
1750  found = i;
1751  break;
1752  }
1753  if (! found) gMessMgr->QAInfo() << "StBFChain::SetGeantOptions() Chain has not found geometry tag. Use " << GeomVersion << endm;
1754  TString GeometryOpt;
1755  if (GetOption("phys_off")) {GeometryOpt += "detp phys_off=1;"; geantMk->SetAttr("phys_off",kTRUE);}
1756  if (GetOption("hadr_off")) {GeometryOpt += "detp hadr_off=1;"; geantMk->SetAttr("hadr_off",kTRUE);}
1757  GeometryOpt += ("detp geometry ");
1758  GeometryOpt += GeomVersion;
1759  ProcessLine(Form("((St_geant_Maker *) %p)->LoadGeometry(\"%s\");",geantMk,GeometryOpt.Data()));
1760  }
1761  if ((GetOption("fzin") || GetOption("ntin") || GetOption("mtin") || fInFile.Data()[0] == ';') && fInFile != "")
1762  ProcessLine(Form("((St_geant_Maker *) %p)->SetInputFile(\"%s\")",geantMk,fInFile.Data()));
1763  }
1764 }
1765 //_____________________________________________________________________
1767 
1779 void StBFChain::SetDbOptions(StMaker *mk){
1780  if (! mk ) return;
1781  if (GetOption("Agi")) mk->SetAlias("VmcGeometry","db/.const/StarDb/AgiGeometry");
1782  else if (GetOption("AgML") ) mk->SetAlias("VmcGeometry","db/.const/StarDb/AgMLGeometry");
1783  else if (GetOption("VmcGeo")) mk->SetAlias("VmcGeometry","db/.const/StarDb/VmcGeo");
1784  else mk->SetAlias("VmcGeometry","db/.const/StarDb/AgiGeometry");
1785  Int_t i;
1786  Int_t Idate=0,Itime=0;
1787 
1788  // First possibility
1789  for (i = 1; i < fNoChainOptions; i++) {
1790  if (fBFC[i].Flag && !strncmp(fBFC[i].Key ,"DbV",3)){
1791  // JL - we use to set timestamp as a chain option (any) starting with dbv and followed
1792  // by an arbitrary set of numbers. The real stamp was taken from the comment.
1793  // This supports this old mode.
1794  gMessMgr->QAInfo() << "StBFChain::SetDbOptions Found time-stamp " << fBFC[i].Key << " [" << fBFC[i].Comment << "]" << endm;
1795  (void) sscanf(fBFC[i].Comment,"%d/%d",&Idate,&Itime);
1796  }
1797  }
1798 
1799  // If FDate is set and we do not have the old mode, then a dynamic timestamp was used
1800  // Overwrite
1801  if( ! Idate && FDate){
1802  gMessMgr->QAInfo() << "StBFChain::SetDbOptions Switching to user chosen dynamic time-stamp (MaxEntry) "
1803  << FDate << " " << FTime << endm;
1804  gMessMgr->QAInfo() << "Chain may crash if time-stamp is not validated by db interface" << endm;
1805 
1806  Idate = FDate;
1807  Itime = FTime;
1808  }
1809 
1810  St_db_Maker *db = (St_db_Maker *) mk;
1811  // Startup date over-write
1812  if (FDateS){
1813  gMessMgr->QAInfo() << "StBFChain::SetDbOptions Switching to user chosen dynamic time-stamp (Start)"
1814  << FDateS << " " << FTimeS << endm;
1815  gMessMgr->QAInfo() << "Chain may crash if time-stamp is not validated by db interface" << endm;
1816 
1817  db->SetDateTime(FDateS,FTimeS);
1818  } else {
1819  if (GetOption("simu")) {
1820  const DbAlias_t *DbAlias = GetDbAliases();
1821  Int_t found = 0;
1822  for (Int_t i = 0; DbAlias[i].tag; i++) {
1823  if (GetOption(DbAlias[i].tag,kFALSE)) {
1824  db->SetDateTime(DbAlias[i].tag);
1825  found = i;
1826  break;
1827  }
1828  }
1829  if (! found) {gMessMgr->QAInfo() << "StBFChain::SetDbOptions() Chain has not set a time-stamp" << endm;}
1830  // Show date settings
1831  gMessMgr->QAInfo() << db->GetName()
1832  << " Maker set time = "
1833  << db->GetDateTime().GetDate() << "."
1834  << db->GetDateTime().GetTime() << endm;
1835  if (GetOption("SIMU") && m_EvtHddr) {
1836  gMessMgr->QAInfo() << GetName() << " Chain set time from " << db->GetName() << endm;
1837  m_EvtHddr->SetDateTime(db->GetDateTime());
1838  }
1839  }
1840  }
1841 
1842  // MaxEntry over-write - default and global for all realm and detectors
1843  if (Idate) {
1844  db->SetMaxEntryTime(Idate,Itime);
1845  gMessMgr->Info() << "\tSet DataBase max entry time " << Idate << "/" << Itime
1846  << " for St_db_Maker(\"" << db->GetName() <<"\")" << endm;
1847  }
1848 #ifdef USE_BFCTIMESTAMP
1849  //
1850  // Now treat the detector specific options
1851  //
1852  TString realm;
1853  for (UInt_t i = 0; i < GTSOptions.size() ; i++){
1854  if ( (GTSOptions[i].Realm).IsNull() ){ realm = "*";}
1855  else { realm = GTSOptions[i].Realm;}
1856 
1857  //LOG_INFO << "DEBUG MORE [" << (GTSOptions[i].Realm).Data() << "]" << endm;
1858  //LOG_INFO << "DEBUG MORE [" << realm.Data() << "]" << endm;
1859 
1860  if ( GTSOptions[i].Type == 1){
1861  db->AddMaxEntryTimeOverride(GTSOptions[i].Date,0,
1862  (char *) realm.Data(),
1863  (char *) GTSOptions[i].Detector.Data());
1864 
1865  LOG_INFO << "Recovering override stamp " << i << " :: "
1866  << GTSOptions[i].Detector << ", " << realm << ", "
1867  << GTSOptions[i].Date << ", " << GTSOptions[i].Time << endm;
1868  } else {
1869  LOG_WARN << "Found override type " << GTSOptions[i].Type << " no treated yet"
1870  << GTSOptions[i].Detector << ", " << realm << ", "
1871  << GTSOptions[i].Date << ", " << GTSOptions[i].Time << endm;
1872  }
1873  }
1874 
1875  //abort();
1876 #endif /* USE_BFCTIMESTAMP */
1877 
1878  if (!GetOption("fzin")) {
1879  struct Field_t {
1880  const Char_t *name;
1881  Float_t scale;
1882  };
1883  Field_t FieldOptions[5] = {
1884  {"FullMagFNegative", -1.0},
1885  {"FullMagFPositive", 1.0},
1886  {"HalfMagFNegative", -0.5},
1887  {"HalfMagFPositive", 0.5},
1888  {"ZeroMagF", 0.0}
1889  };
1890  Int_t k = -1;
1891  if (GetOption("FieldON")) {
1892  if (GetOption("ReverseField")) k = 0;
1893  else k = 1;
1894  } else if (GetOption("HalfField")) {
1895  if (GetOption("ReverseField")) k = 2;
1896  else k = 3;
1897  } else if (GetOption("FieldOff")) k = 4;
1898  if (k >= 0) {
1899  SetFlavor(FieldOptions[k].name, "MagFactor");
1900  gMessMgr->QAInfo() << "StBFChain::SetDbOptions SetFlavor(\"" << FieldOptions[k].name
1901  << "\",\"MagFactor\")" << endm;
1902  if ( gClassTable->GetID("StarMagField") >= 0) {
1903  TString cmd =
1904  Form("if (!StarMagField::Instance()) new StarMagField( StarMagField::EBField::kMapped, %f, kTRUE);",
1905  FieldOptions[k].scale);
1906  ProcessLine(cmd);
1907  }
1908  }
1909  }
1910  if (this == GetTopChain()) {
1911  // Db blacklist (remove black listed system from St_Db_Maker Calibrations configuration)
1912  if (! GetOption("TpcDb") ) {mk->SetAttr("blacklist", "tpc"); gMessMgr->QAInfo() << "blacklist tpc" << endm;}
1913  if (!(GetOption("SvtDb")||GetOption("SvtCalDb"))) {mk->SetAttr("blacklist", "svt"); gMessMgr->QAInfo() << "blacklist svt" << endm;}
1914  if (!(GetOption("SsdDb")||GetOption("SsdCalDb"))) {mk->SetAttr("blacklist", "ssd"); gMessMgr->QAInfo() << "blacklist ssd" << endm;}
1915  if (!(GetOption("SstDb")||GetOption("SstCalDb"))) {mk->SetAttr("blacklist", "sst"); gMessMgr->QAInfo() << "blacklist sst" << endm;}
1916  if (! GetOption("EemcDb") ) {mk->SetAttr("blacklist", "eemc"); gMessMgr->QAInfo() << "blacklist eemc"<< endm;}
1917  if (! GetOption("FmsDb") ) {mk->SetAttr("blacklist", "fms"); gMessMgr->QAInfo() << "blacklist fms" << endm;}
1918  } else {// for Embedding chain trigger black list by NoSsdIT and NoSvtIT, could be some problems if you try to run svt or ssd clusters, ...
1919  if (GetOption("NoSvtIt")) {mk->SetAttr("blacklist", "svt"); gMessMgr->QAInfo() << "blacklist svt" << endm;}
1920  if (GetOption("NoSsdIt")) {mk->SetAttr("blacklist", "ssd"); gMessMgr->QAInfo() << "blacklist ssd" << endm;}
1921  if (GetOption("NoSstIt")) {mk->SetAttr("blacklist", "sst"); gMessMgr->QAInfo() << "blacklist sst" << endm;}
1922  }
1923 }
1924 //_____________________________________________________________________
1926 void StBFChain::SetTreeOptions()
1927 {
1928 
1929  StTreeMaker *treeMk = (StTreeMaker *) GetMaker("outputStream");
1930  if (!treeMk) return;
1931  if (GetOption("EvOut")){
1932  gMessMgr->QAInfo() << "Will Write StEvent out, treeMk->GetFile() = " << treeMk->GetFile() << endm;
1933  treeMk->IntoBranch("eventBranch","StEvent");
1934  if (GetOption("EvOutOnly")) return;
1935  }
1936  if (! GetOption("nohistos")) treeMk->SetBranch("histBranch");
1937  if (! GetOption("norunco")) treeMk->SetBranch("runcoBranch");
1938  if (GetOption("McEvent") && GetOption("McEvOut")){
1939  gMessMgr->QAInfo() << "Will Write StMcEvent out, treeMk->GetFile() = " << treeMk->GetFile() << endm;
1940  treeMk->IntoBranch("McEventBranch","StMcEvent");
1941  }
1942  if (GetOption("GeantOut")) treeMk->IntoBranch("geantBranch","geant");
1943  if (GetOption("AllEvent")) {
1944  if (GetOption("fzin") ||
1945  GetOption("ntin") ||
1946  GetOption("gstar") ||
1947  GetOption("pythia") ||
1948  GetOption("VMC") ||
1949  GetOption("PrepEmbed")) {
1950  treeMk->IntoBranch("geantBranch","geant");
1951  treeMk->IntoBranch("geantBranch","geant/.data/particle");
1952  treeMk->IntoBranch("geantBranch","geant/.data/g2t_rch_hit");
1953  }
1954  }
1955 }
1956 //________________________________________________________________________________
1957 Long_t StBFChain::ProcessLine(const char *line) {
1958  if (! line || !strlen(line)) return -1;
1959  if (Debug()) gMessMgr->QAInfo() << "ProcessLine " << line << endm;
1960  TInterpreter::EErrorCode error = TInterpreter::kNoError;
1961  Long_t res = gInterpreter->ProcessLine(line, &error);
1962  if (error != TInterpreter::kNoError) {
1963  gMessMgr->Error() << "StBFChain::ProcessLine command:" << line << " has failed. Quit job." << endm;
1964  gSystem->Exit(1);
1965  }
1966  return res;
1967 }
1968 //________________________________________________________________________________
1969 TString StBFChain::GetGeometry() const
1970 {
1971  Int_t n = fchainOpt->GetNRows();
1972  for (Int_t i=0;i<n;i++) {
1973  if (!fchainOpt->GetTable()[i].Flag) continue;
1974  TString k(fchainOpt->GetTable()[i].Key);
1975  k.ToLower();
1976  if (k[0]!='y') continue;
1977  if (k[1]!='2') continue;
1978  if (k[2] <'0' || k[2]>'9') continue;
1979  if (k[3] <'0' || k[3]>'9') continue;
1980  if (k[4] <'0' || k[4]>'9') continue;
1981  return k;
1982  }
1983  return TString("");
1984 }
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:1051
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:1472
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:1510
StBFChain::SetTreeOptions
virtual void SetTreeOptions()
Creates output-tree branches.
Definition: StBFChain.cxx:1926
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:1734
StBFChain::SetDbOptions
virtual void SetDbOptions(StMaker *db=0)
Treats the DbV options used for database timestamp.
Definition: StBFChain.cxx:1779
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:1137
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:1427
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:1644
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