STDATAFILTERMAKER: StBFChain/StBFChain.cxx Source File

00001 //_____________________________________________________________________
00002 // @(#)StRoot/StBFChain:$Name:  $:$Id: StBFChain.cxx,v 1.616 2015/02/23 20:08:19 genevb Exp $
00003 //_____________________________________________________________________
00004 #include "TROOT.h"
00005 #include "TPRegexp.h"
00006 #include "TString.h"
00007 #include "TObjString.h"
00008 #include "TSystem.h"
00009 #include "TInterpreter.h"
00010 #include "TClassTable.h"
00011 #include "StMemStat.h"
00012 #include "StBFChain.h"
00013 #include "StBFChainOpt.h"
00014 #include "St_db_Maker/St_db_Maker.h"
00015 #include "StTreeMaker/StTreeMaker.h"
00016 #include "StIOMaker/StIOMaker.h"
00017 #include "StDbUtilities/StMagUtilities.h"
00018 #include "StMessMgr.h"
00019 #include "StEnumerations.h"
00020 #include "TTree.h"
00021 #include "TEnv.h"
00022 #define STAR_LOGGER 1
00023 // PLease, preserve the comment after = { . It is used for documentation formatting
00024 //
00025 #if 0
00026 // Keep to be compatible with old documentaion
00027 #define STR_OBSOLETE "WARNING *** Option is OBSOLETE ***"
00028 
00029 //#include "BFC.h"
00030 // ITTF Chain will be put here. Option list starting from minimalistic requirements
00031 // and may not initially work.
00032 // Please, preserve the comment after = { . It is used for documentation formatting
00033 //
00034 // ITTF Chains
00035 //#include "BFC2.h"
00036 #endif
00037 
00038 // JL - define this once, use two places
00039 #define BFC_DBREGEXP "(dbv|sdt)(\\d+)(_)(.*)(_)(.*)"
00040 
00041 
00042 // NoChainOptions -> Number of chain options auto-calculated
00043 TableImpl(Bfc);
00044 ClassImp(StBFChain);
00045 
00046 //_____________________________________________________________________________
00047 // Hack constructor.
00058 void StBFChain::Setup(Int_t mode) {
00059   static const Char_t *path  = "./StRoot/StBFChain:$STAR/StRoot/StBFChain";
00060   TString chain("BFC.C");
00061   Char_t *file = gSystem->Which(path,chain,kReadPermission);
00062 #ifdef STAR_LOGGER
00063   if (! file) { LOG_FATAL  << Form("StBFChain::Setup\tFile %s has not been found in path %s",chain.Data(),path) << endm; }
00064   else        { LOG_WARN   << Form("StBFChain::Setup\tFile %s has been found as %s",chain.Data(),file) << endm; }
00065 #else
00066 
00067   if (! file)   Fatal("StBFChain::Setup","File %s has not been found in path %s",chain.Data(),path);
00068   else        Warning("StBFChain::Setup","File %s has been found as %s",chain.Data(),file);
00069 #endif
00070   TString cmd(".L ");
00071   cmd += file;
00072   gInterpreter->ProcessLine(cmd);
00073   fchainOpt  = (St_Bfc *) gInterpreter->Calc("CreateTable()");
00074   cmd = ".U ";
00075   cmd += file;
00076   gInterpreter->ProcessLine(cmd);
00077   assert(fchainOpt);
00078   delete [] file;
00079   fNoChainOptions = fchainOpt->GetNRows();
00080   fBFC = fchainOpt->GetTable();
00081   // add predifined time stamps and geometry versions
00082   const DbAlias_t *DbAlias = GetDbAliases();
00083   Bfc_st row = {"","","","db,detDb","","","",kFALSE};
00084   for (Int_t i = 0; DbAlias[i].tag; i++) {
00085     for (Int_t r = 0; r < 2; r++) {
00086       TString dbTag("");
00087       if (r) dbTag += "r";
00088       dbTag += DbAlias[i].tag;
00089       if (! kOpt(dbTag,kFALSE)) {
00090         memset (&row.Key, 0, sizeof(row.Key));
00091         memcpy (&row.Key, dbTag.Data(), dbTag.Length());
00092         fchainOpt->AddAt(&row);
00093         fNoChainOptions = fchainOpt->GetNRows();
00094         fBFC = fchainOpt->GetTable();
00095       }
00096     }
00097   }
00098   FDate  = FTime  = 0;
00099   FDateS = FTimeS = 0;
00100   fFiltTrg   = "";
00101   fRunG  = -1;
00102   Gproperty  = ".gopt.";
00103   Gvalue     = "";
00104   Gpattern   = "*";
00105 
00106 
00107 }
00108 //_____________________________________________________________________________
00110 StBFChain::~StBFChain(){
00111   Finish();
00112 }
00113 //_____________________________________________________________________________
00115 Int_t StBFChain::Load()
00116 {
00117   static const Char_t *prefix[3] = {"lib_","lib",""};
00118   Int_t status = kStOk;
00119   Int_t i, iok;
00120   TString lib(gSystem->GetLibraries(0,"D"));
00121   TObjArray LoadedLibs;
00122   ParseString(lib,LoadedLibs);
00123   TIter next(&LoadedLibs);
00124   TObjString *LoadedLib;
00125   while ((LoadedLib = (TObjString *) next())){
00126     TString Base(gSystem->BaseName(LoadedLib->GetName()));
00127     Base.ReplaceAll(".so","");
00128     Base.ReplaceAll(".sl","");
00129     if (Base.BeginsWith("lib_")) Base.ReplaceAll("lib_","");
00130     if (Base.BeginsWith("lib"))  Base.ReplaceAll("lib","");
00131     LoadedLib->SetString(Base);
00132   }
00133   for (i = 1; i< fNoChainOptions; i++) { // Load Libraries if any
00134     if (fBFC[i].Flag) {
00135       if (strlen(fBFC[i].Libs) > 0) {
00136         TObjArray Libs;
00137         ParseString(fBFC[i].Libs,Libs);
00138         TIter nextL(&Libs);
00139         TObjString *libe = 0;
00140         Char_t *path = 0;
00141         while ((libe = (TObjString *) nextL())) {
00142           TString libN(libe->GetString());
00143           if (libN.BeginsWith("lib_")) libN.ReplaceAll("lib_","");
00144           if (libN.BeginsWith("lib"))  libN.ReplaceAll("lib","");
00145 
00146           TString libL("");
00147           for (Int_t j = 0; j < 3; j++) {
00148             libL = prefix[j]; libL += libN;
00149             //LOG_QA  << "    Checking " << libL << endm;
00150             if ((path = gSystem->DynamicPathName(libL,kTRUE))) break;
00151           }
00152           iok = -1;
00153           if (path) {
00154             TIter next(&LoadedLibs);
00155             TObjString *LoadedLib;
00156             while ((LoadedLib = (TObjString *) next())){
00157               TString Base(LoadedLib->GetName());
00158               //LOG_QA  << "    Checking " << Base << endm;
00159               if (Base == libN) {iok = 1; break;}
00160             }
00161             if (iok > 0) continue;
00162 
00163 
00164             //LOG_QA  << "Trying to load Library " << libL << endm;
00165 
00166 
00167             iok = gSystem->Load(libL);
00168             if (iok < 0)  {
00169 
00170               LOG_FATAL  << "problem with loading of " << libL.Data() << endm;
00171               LOG_FATAL  <<  fBFC[i].Key << " is switched off \t!!!!" << endm;
00172 
00173               //fBFC[i].Flag = kFALSE;
00174               //status = kStErr;
00175               //assert(iok >= 0); ?? obviously it is so, but not very specific
00176               Int_t libraryload = kStErr;
00177               assert(libraryload!=kStErr); // this is obvious and will display an explicit
00178               break;
00179             } else {
00180               if (Debug() > 1) {  TString ts("load "); ts += libL; StMemStat::PrintMem(ts.Data());}
00181 
00182               LOG_QA  << "Library " << Form("%-20s\t(%s)\tis loaded",libL.Data(),path) << endm;
00183 
00184               LoadedLibs.Add(new TObjString(libN));
00185             }
00186           } else {
00187             if ( ! index(fBFC[i].Libs,',') || Debug() > 1 ) {
00188               LOG_WARN << "No path for Key=" << fBFC[i].Key << "-> Searched for [" << libL 
00189                        << "] from Libs=" << fBFC[i].Libs << " (will proceed)" << endm;
00190             }
00191           }
00192         }
00193         Libs.Delete();
00194       }
00195     }
00196   }
00197   LoadedLibs.Delete();
00198   return status;
00199 }
00200 
00201 //_____________________________________________________________________________
00203 
00214 Int_t StBFChain::Instantiate()
00215 {
00216   Int_t status = kStOk;
00217   Int_t i;
00218   if (! fNoChainOptions) return status;
00219   Long64_t maxsize = kMaxLong64;
00220   TTree::SetMaxTreeSize(maxsize);
00221   for (i = 1; i< fNoChainOptions; i++) {// Instantiate Makers if any
00222     if (! fBFC[i].Flag) continue;
00223     TString maker(fBFC[i].Maker);
00224     if (maker == "") continue;
00225     TString Key(fBFC[i].Key);
00226     TString name(fBFC[i].Name);
00227     Key.ToLower();
00228     StMaker *myChain = 0;
00229     StMaker *mk = 0;
00230     // Require only instance for the following named makers
00231     if (maker == "St_db_Maker"  || maker == "StTpcDbMaker" ||
00232         maker == "StSvtDbMaker" || maker == "StSsdDbMaker" ||
00233         maker == "StDetectorDbMaker" ||
00234         maker == "StMagFMaker"    ||
00235         maker == "StEEmcDbMaker"  ||
00236         maker == "St_geant_Maker" ||
00237         maker == "StVMCMaker") {
00238       mk = GetTopChain()->GetMakerInheritsFrom(maker);
00239       if (mk) {
00240         if (maker == "St_geant_Maker" || maker == "StVMCMaker") {
00241           LOG_INFO << "StBFChain::Instantiate ignore request for instantiation of " << maker
00242                    << "(\"" << fBFC[i].Name << "\") because chain alreary has one." << endm;
00243           continue;
00244         }
00245         if (name == "" || name == mk->GetName()) {
00246           LOG_INFO << "StBFChain::Instantiate ignore request for instantiation of " << maker
00247                    << "(\"" << fBFC[i].Name << "\") because chain alreary has one"
00248                    << " but accumulate options" << endm;
00249           //Accumulate option for these makers    continue;
00250         }
00251       }
00252     }
00253     if (strlen(fBFC[i].Chain) > 0) myChain = GetMaker(fBFC[i].Chain);
00254     if (maker == "St_db_Maker"){
00255       if (Key.CompareTo("db",TString::kIgnoreCase) == 0) {
00256         St_db_Maker* dbMk = (St_db_Maker *) mk;
00257         if (! dbMk) {
00258           TString MySQLDb("MySQL:StarDb");
00259           TString MainCintDb("$STAR/StarDb");
00260           TString MainCintDbObj("$STAR/.$STAR_HOST_SYS/obj/StarDb");
00261           TString MyCintDb("$PWD/StarDb");
00262           TString MyCintDbObj("$PWD/.$STAR_HOST_SYS/obj/StarDb");
00263           if (GetOption("NoMySQLDb"))   {MySQLDb = "";}
00264           // Removed twice already and put back (start to be a bit boring)
00265           // DO NOT REMOVE THE NEXT OPTION - Used in AutoCalibration
00266           if (GetOption("NoLocalCintDb")) {MyCintDb = "";}
00267           if (GetOption("NoStarCintDb") ) {MainCintDb = "";}
00268           if (GetOption("NoCintDb")     ) {MainCintDb = ""; MyCintDb = "";}
00269           
00270           TString Dirs[10];
00271           Int_t j;
00272           for (j = 0; j < 10; j++) Dirs[j] = "";
00273           j = 0;
00274           if (MySQLDb       != "") {Dirs[j] = MySQLDb;    j++;}
00275           if (MainCintDb    != "") {Dirs[j] = MainCintDb; j++;}
00276           if (MainCintDbObj != "") {Dirs[j] = MainCintDbObj; j++;}
00277           if (MyCintDb      != "") {Dirs[j] = MyCintDb;   j++;}
00278           if (MyCintDbObj   != "") {Dirs[j] = MyCintDbObj;   j++;}
00279           dbMk = new St_db_Maker(fBFC[i].Name,Dirs[0],Dirs[1],Dirs[2],Dirs[3],Dirs[4]);
00280           if (!dbMk) goto Error;
00281           strcpy (fBFC[i].Name, (Char_t *) dbMk->GetName());
00282 
00283           // Determine flavors
00284           TString flavors = "ofl"; // default flavor for offline
00285 
00286           // simulation flavors
00287           if (GetOption("Simu") && ! GetOption("NoSimuDb")) flavors.Prepend("sim+");
00288 
00289           // filestream flavors
00290           if (fSetFiles) {
00291             TString firstFileName = fSetFiles->GetFileName(0);
00292             firstFileName = firstFileName(firstFileName.Last('/')+1,firstFileName.Length());
00293             if (firstFileName.BeginsWith("st_")) {
00294               TString fileStream = firstFileName(3,firstFileName.Index('_',3)-3);
00295               if (fileStream.Length()>0) flavors.Prepend(fileStream += '+');
00296             }
00297           }
00298  
00299           LOG_INFO << "Using DB flavors: " << flavors << endm;
00300           dbMk->SetFlavor(flavors.Data());
00301           mk = dbMk;
00302         }
00303         if (GetOption("dbSnapshot")) dbMk->SetAttr("dbSnapshot","dbSnapshot.root",dbMk->GetName());
00304         SetDbOptions(dbMk);
00305       }
00306       goto Add2Chain;
00307     }
00308     if (!mk && maker == "StIOMaker" && fSetFiles) {
00309       StIOMaker *inpMk=0;
00310       if (GetOption("InTree")) {
00311         Char_t line[80] = "bfcTree";
00312         Int_t k = kOpt("InTree");
00313         sscanf(fBFC[k].Comment,"%s",line);
00314         inpMk = new StIOMaker("inputStream","r",fSetFiles,line);
00315       }
00316       else inpMk = new StIOMaker("inputStream","r",fSetFiles);
00317       mk = inpMk;
00318       if (mk) {
00319         strcpy (fBFC[i].Name,(Char_t *) mk->GetName());
00320         SetInput("StDAQReader",".make/inputStream/.make/inputStream_DAQ/.const/StDAQReader");
00321         if (GetOption("ReadAll")) {     //activate all branches
00322           // inpMk->SetBranch("*",0,"r");
00323           const Char_t *allBranches[] = {
00324             "emc_rawBranch","eventBranch","ftpc_rawBranch",
00325             "geantBranch","globalBranch","McEventBranch","svt_hitsBranch","svt_tracksBranch",
00326             "tpc_hitsBranch","trgBranch",0};
00327           for (Int_t i = 0; allBranches[i]; i++) inpMk->SetBranch(allBranches[i],0,"r");
00328         }
00329         if (GetOption("adcOnly")) mk->SetAttr("adcOnly",1);                        ;
00330         goto Add2Chain;
00331       }
00332       goto Error;
00333     }
00334     if (!mk && maker == "StTreeMaker" && fFileOut != "") {
00335       StTreeMaker    *treeMk  = 0;
00336       if (GetOption("OutTree")) {
00337         Char_t line[80] = "bfcTree";
00338         Int_t k = kOpt("OutTree");
00339         sscanf(fBFC[k].Comment,"%s",line);
00340         treeMk = new StTreeMaker("outputStream",fFileOut.Data(),line);
00341       }
00342       else treeMk = new StTreeMaker("outputStream",fFileOut.Data());
00343       mk = treeMk;
00344       if (mk) {
00345         strcpy (fBFC[i].Name,(Char_t *) treeMk->GetName());
00346         treeMk->SetIOMode("w");
00347         SetTreeOptions();
00348         goto Add2Chain;
00349       }
00350     }
00351     // Special makers already created or action which
00352     // need to take place before 'maker' is created.
00353     if (! mk) {
00354       if (strlen(fBFC[i].Name) > 0) mk = New(fBFC[i].Maker,fBFC[i].Name);
00355       else                          mk = New(fBFC[i].Maker);
00356       if (! mk) {
00357         LOG_FATAL << Form("StBFChain::Instantiate() problem with instantiation Maker=[%s] Name=[%s]",fBFC[i].Maker,fBFC[i].Name) << endm;
00358         assert(mk);
00359       }
00360     }
00361     strcpy (fBFC[i].Name,(Char_t *) mk->GetName());
00362     if (maker == "StTpcDbMaker" && GetOption("laserIT"))   mk->SetAttr("laserIT"    ,kTRUE);
00363     if (maker == "StDAQMaker") {
00364       if (GetOption("adcOnly")) mk->SetAttr("adcOnly",1);                        ;
00365     }
00366 
00367     if (maker == "St_geant_Maker") { // takes only first request for geant, if it is active then it should be the first one
00368       Int_t NwGeant = 10; // default geant parameters
00369       if (!GetOption("fzin")  && 
00370           !GetOption("ntin")  &&
00371           !GetOption("gstar") && 
00372           !GetOption("pythia"))                      NwGeant =  5;
00373       if (GetOption("big"))                          NwGeant = 20;
00374       if (GetOption("bigbig"))                       NwGeant = 40;
00375       ProcessLine(Form("((St_geant_Maker *) %p)->SetNwGEANT(%i);",mk,NwGeant));
00376       if (GetOption("Higz")) ProcessLine(Form("((St_geant_Maker *) %p)->SetIwtype(1);",mk));
00377       if (GetOption("paw"))  ProcessLine(Form("((St_geant_Maker *) %p)->SetNwPAW(2);",mk));
00378       if (GetOption("fzin")      || 
00379           GetOption("ntin")      || 
00380           GetOption("gstar")     || 
00381           GetOption("pythia")    || 
00382           GetOption("hijing")    || 
00383           GetOption("PrepEmbed") || 
00384           GetOption("mtin")) {
00385         mk->SetActive(kTRUE);
00386         //      if (GetOption("PrepEmbed")) mk->SetMode(10*(mk->GetMode()/10)+1);
00387         if (GetOption("PrepEmbed") || GetOption("pythiaEmbed")) mk->SetAttr("Don'tTouchTimeStamp",kTRUE);
00388         if (GetOption("flux")) mk->SetAttr("flux",kTRUE);
00389         if (GetOption("pythia")) {
00390           mk->SetAttr("Pythia",kTRUE);
00391           if (GetOption("Wenu")) mk->SetAttr("Wenu",kTRUE);
00392           if (GetOption("beamLine"))  mk->SetAttr("beamLine",kTRUE);
00393         }
00394         if (GetOption("hijing")) {
00395           mk->SetAttr("hijing",kTRUE);
00396         }
00397       }
00398       else mk->SetActive(kFALSE);
00399       if (! mk) goto Error;
00400       SetGeantOptions(mk);
00401     }
00402 
00403     // special maker options
00404     // m_Mode xyz
00405     //        x = 1 phys_off                    
00406     //        y = 1 Passive mode (do not call RunMC()
00407     //        z = 1 Mixer Mode
00408     if (maker == "StVMCMaker") {
00409       if (GetOption("VMCPassive")) {// don't use mk->SetActive(kFALSE) because we want to have InitRun
00410         mk->SetAttr("VMCPassive",kTRUE);
00411       }
00412       else {
00413         if (GetOption("phys_off")) mk->SetAttr("phys_off",kTRUE);
00414         if (GetOption("hadr_off")) mk->SetAttr("hadr_off",kTRUE);
00415         if (fInFile != "")  {
00416           if (ProcessLine(Form("((StVMCMaker *) %p)->SetInputFile(\"%s\")",mk,fInFile.Data())))
00417             goto Error;
00418         }
00419       }
00420       if (GetOption("Embedding")) mk->SetAttr("Embedding",kTRUE);
00421     }
00422 
00423     // ---
00424     //          Sti(ITTF) start
00425     // ---
00426     if (maker == "StiMaker" || maker == "StiVMCMaker" || maker == "StvMaker") {
00427       if ( maker == "StvMaker" &&  GetOption("StvCA")) {
00428         //      mk->SetAttr("seedFinders","CA","Stv");              // for CA seed finder
00429         mk->SetAttr("seedFinders","CA,Default","Stv");      // for CA + Default seed finders
00430       }
00431 
00432       // old logic for svt and ssd
00433       if (GetOption("NoSvtIT")){
00434         mk->SetAttr("useSvt"    ,kFALSE);
00435       } else {
00436         if (GetOption("SvtIT")){
00437           mk->SetAttr("useSvt"    ,kTRUE);
00438           mk->SetAttr("activeSvt" ,kTRUE);
00439         }
00440       }
00441       if (   GetOption("NoSsdIT") &&
00442             !GetOption("SstIT") ){
00443         mk->SetAttr("useSsd"    ,kFALSE);
00444       } else {
00445         if (GetOption("SsdIT")){
00446           mk->SetAttr("useSsd"    ,kTRUE);
00447           mk->SetAttr("activeSsd" ,kTRUE);
00448         }
00449       }
00450 
00451       // this was an R&D detector never implemented
00452       // simulations were made nonetheless
00453       if (GetOption("HpdIT")){
00454         mk->SetAttr("useHpd"     ,kTRUE);
00455         mk->SetAttr("activeHpd"  ,kTRUE);
00456       }
00457 
00458       // back to the HFT sub-system
00459       if (GetOption("NoPxlIT")) {
00460         mk->SetAttr("usePixel"   ,kTRUE);
00461       } else {
00462         if (GetOption("PixelIT") || GetOption("PxlIT") ){
00463           mk->SetAttr("usePixel"         ,kTRUE);
00464           mk->SetAttr("activePixel",kTRUE);
00465         }
00466       }
00467       if (GetOption("NoIstIT")) {
00468         mk->SetAttr("useIst"     ,kTRUE);
00469       } else {
00470         if (GetOption("IstIT")){
00471           mk->SetAttr("useIst"     ,kTRUE);
00472           mk->SetAttr("activeIst"  ,kTRUE);
00473         }
00474       }
00475       if (GetOption("NoSstIT")) {
00476         mk->SetAttr("useSst"     ,kTRUE);
00477       } else {
00478         if (GetOption("SstIT")){
00479           mk->SetAttr("useSst"   ,kTRUE);
00480           mk->SetAttr("activeSst"  ,kTRUE);
00481         }
00482       }
00483 
00484       // other sub-systems
00485       if (GetOption("BTofIT")){
00486         mk->SetAttr("useBTof"    ,kTRUE);
00487         mk->SetAttr("activeBTof" ,kTRUE);
00488       }
00489 
00490       if (GetOption("StiPulls") || 
00491           GetOption("StvPulls"))  mk->SetAttr("makePulls"  ,kTRUE);
00492       if (GetOption("skip1row"))  mk->SetAttr("skip1row"   ,kTRUE);
00493       if (GetOption("EastOff"))   mk->SetAttr("EastOff"    ,kTRUE);
00494       if (GetOption("WestOff"))   mk->SetAttr("WestOff"    ,kTRUE);
00495       if (GetOption("laserIT"))   mk->SetAttr("laserIT"    ,kTRUE);
00496       if (GetOption("Alignment")) mk->SetAttr("Alignment"  ,kTRUE);
00497       if (GetOption("Cosmics"))   mk->SetAttr("Cosmics"    ,kTRUE);
00498       mk->PrintAttr();
00499     }
00500     if (maker=="StKFVertexMaker" && GetOption("laserIT"))   mk->SetAttr("laserIT"    ,kTRUE);
00501     //          Sti(ITTF) end
00502     if (maker=="StGenericVertexMaker") {
00503       // VertexFinder methods
00504       if (GetOption("Sti") || GetOption("StiCA") ||
00505           GetOption("Stv") ||
00506           GetOption("StiVMC"     ) ) mk->SetAttr("ITTF"         , kTRUE);
00507       if (GetOption("VFMinuit"   ) ) mk->SetAttr("VFMinuit"     , kTRUE);
00508       if (GetOption("VFppLMV"    ) ) mk->SetAttr("VFppLMV"      , kTRUE);
00509       if (GetOption("VFppLMV5"   ) ) mk->SetAttr("VFppLMV5"     , kTRUE);
00510       if (GetOption("VFPPV"      ) ) mk->SetAttr("VFPPV"        , kTRUE);
00511       if (GetOption("VFPPVEv"  ) ) {
00512         gSystem->Load("StBTofUtil.so");
00513         mk->SetAttr("VFPPVEv"      , kTRUE);
00514       }
00515       if (GetOption("VFPPVEvNoBtof")){
00516         gSystem->Load("StBTofUtil.so"); //Not used but loaded to avoid fail
00517         mk->SetAttr("VFPPVEvNoBtof", kTRUE);
00518       }
00519       if (GetOption("VFPPVnoCTB" ) ) mk->SetAttr("VFPPVnoCTB"   , kTRUE);
00520       if (GetOption("VFFV"       ) ) mk->SetAttr("VFFV"         , kTRUE);
00521       if (GetOption("VFMCE"      ) ) mk->SetAttr("VFMCE"        , kTRUE);
00522       if (GetOption("VFMinuit2"  ) ) mk->SetAttr("VFMinuit2"    , kTRUE);
00523       if (GetOption("VFMinuit3"  ) ) mk->SetAttr("VFMinuit3"    , kTRUE);
00524       if (GetOption("beamLine"   ) ) mk->SetAttr("BeamLine"     , kTRUE);
00525       if (GetOption("CtbMatchVtx") ) mk->SetAttr("CTB"          , kTRUE);
00526       if (GetOption("min2trkVtx" ) ) mk->SetAttr("minTracks"    , 2);
00527       if (GetOption("VtxSeedCalG") ) mk->SetAttr("calibBeamline", kTRUE);
00528       if (GetOption("usePct4Vtx" ) ) mk->SetAttr("PCT"          , kTRUE);
00529       if (GetOption("useBTOF4Vtx") ) mk->SetAttr("BTOF"         , kTRUE);
00530       mk->PrintAttr();
00531     }
00532     if (maker=="StKFVertexMaker") {
00533       if (GetOption("beamLine"   ) ) mk->SetAttr("BeamLine"     , kTRUE);
00534     }
00535     if (maker=="StAssociationMaker") {
00536 
00537       LOG_QA << "StBFChain::Instantiate Setting the Parameters for the Association Maker" << endm;
00538 
00539       TString cmd("");
00540       if (GetOption("ITTF") || GetOption("StiVMC") || GetOption("useInTracker"))
00541         cmd = Form ("((StAssociationMaker *) %p)->useInTracker();",mk);
00542       cmd += "StMcParameterDB* parameterDB = StMcParameterDB::instance();";
00543       // TPC
00544 #if 0
00545       cmd += "parameterDB->setXCutTpc(.5);"; // 5 mm
00546       cmd += "parameterDB->setYCutTpc(.5);"; // 5 mm
00547       cmd += "parameterDB->setZCutTpc(.5);"; // 5 mm
00548 #endif
00549       cmd += "parameterDB->setReqCommonHitsTpc(3);"; // Require 3 hits in common for tracks to be associated
00550       // FTPC
00551 #if 0
00552       cmd += "parameterDB->setRCutFtpc(.3);"; // 3 mm
00553       cmd += "parameterDB->setPhiCutFtpc(5*(3.1415927/180.0));"; // 5 degrees
00554 #endif
00555       cmd += "parameterDB->setReqCommonHitsFtpc(3);"; // Require 3 hits in common for tracks to be associated
00556       // SVT
00557 #if 0
00558       cmd += "parameterDB->setXCutSvt(.08);"; // 800 um
00559       cmd += "parameterDB->setYCutSvt(.08);"; // 800 um
00560       cmd += "parameterDB->setZCutSvt(.08);"; // 800 um
00561 #endif
00562       cmd += "parameterDB->setReqCommonHitsSvt(1);"; // Require 1 hits in common for tracks to be associated
00563       if (GetOption("IdTruth")) cmd += Form("((StAssociationMaker *) %p)->useIdAssoc();",mk);
00564       ProcessLine(cmd);
00565     }
00566     if (maker == "StMiniMcMaker" && GetOption("IdTruth") && ! GetOption("OldMiniMc")) {
00567       mk->SetMode(1);
00568       gMessMgr->QAInfo() << "StBFChain::Instantiate create simplified MiniMcTree in " << maker  << endm;
00569     }
00570     // usually, we do maker first and option second but the
00571     // logic is more readable with option first here (as it
00572     // got a bit out of hand)
00573     if (GetOption("ppOpt") ) {                         // pp specific stuff
00574       if (maker == "StTrsMaker")
00575         mk->SetMode(1);       // Pile-up correction
00576     }
00577 
00578     if (maker == "StStrangeMuDstMaker" && GetOption("CMuDST")&& GetOption("StrngMuDST") ) {
00579       TString cmd(Form("StStrangeMuDstMaker *pSMMk = (StStrangeMuDstMaker*) %p;",mk));
00580       cmd += "pSMMk->DoV0();";                                 // Set StrangeMuDstMaker parameters
00581       cmd += "pSMMk->DoXi();";
00582       cmd += "pSMMk->DoKink();";
00583       cmd += "pSMMk->SetNoKeep();";                            // Set flag for output OFF
00584       ProcessLine(cmd);
00585     }
00586 
00587     // Alex requested an option (not turned by default) to disable all
00588     // hit reco cuts. This will make allm hits saved to MuDST /ezTree.
00589     if ( maker == "StEmcRawMaker" && GetOption("BEmcDebug"))
00590       mk->SetMode(1); // only one option now, bit a bitmask
00591 
00592     // Use status tables for raw BEMC data (helpful for QA)
00593     if ( maker == "StEmcRawMaker" && GetOption("BEmcChkStat"))
00594       mk->SetAttr("BEmcCheckStatus",kTRUE);
00595 
00596     // MuDST and ezTree. Combinations are
00597     //  ezTree         -> ezTree only
00598     //  CMuDST         -> regular MuDST only
00599     //  ezTree,CMuDST  -> both
00600     if (maker == "StMuDstMaker" && GetOption("ezTree") ){
00601       TString cmd(Form("StMuDstMaker *pMuMk = (StMuDstMaker *) %p;",mk));
00602       if ( ! GetOption("CMuDST")) cmd += "pMuMk->SetStatus(\"*\",0);";
00603       cmd += "pMuMk->SetStatus(\"EztAll\",1);";
00604       ProcessLine(cmd);
00605     }
00606 
00607     if (maker == "StLaserEventMaker"){
00608       // Bill stuff - Empty place-holder
00609     }
00610     if (maker == "StDetectorDbMaker") {
00611       if ( GetOption("DbRichSca") ) mk->SetMode(1);
00612     }
00613     if (maker == "StTpcRSMaker") {
00614       if (! GetOption("TrsToF")) {
00615         Int_t mode = mk->GetMode();
00616         mode |= (1 << 10); // kNoToflight   //10 don't account for particle time of flight
00617         mk->SetMode(mode);
00618       }
00619     }
00620     if (maker == "StTrsMaker") {
00621       Int_t mode = 0;
00622       if (GetOption("TrsPileUp")) mode += 1; // Pile-up correction
00623       if (GetOption("TrsToF"))    mode += 2; // account for particle time of flight
00624       if (mode) mk->SetMode(mode);
00625     }
00626     // Place-holder. Would possibly be a bitmask
00627     if (maker == "StTofrMatchMaker"){
00628       mk->SetMode(0);
00629     }
00630 
00631     if (maker == "StSpaceChargeEbyEMaker") {
00632       if ( GetOption("SpcChgCal") ||
00633            GetOption("SpcChgCalG"))   mk->SetMode(2);
00634       if ( GetOption("SCScalerCal") ) mk->SetMode(4);
00635       if ( GetOption("EastOff"))      mk->SetAttr("EastOff",kTRUE);
00636       if ( GetOption("WestOff"))      mk->SetAttr("WestOff",kTRUE);
00637     }
00638     if (maker == "StEventQAMaker" && GetOption("QAalltrigs"))
00639       ProcessLine(Form("((StEventQAMaker *) %p)->AllTriggers();",mk));
00640     //Special options for V0s and Xis using estGlobal tracks
00641     if(maker=="StV0FinderMaker" && Key=="v0svt"){
00642       TString cmd(Form("StV0FinderMaker *V0mk=(StV0FinderMaker*) %p;",mk));
00643       cmd += "V0mk->SetLanguageUsage(0);";
00644       cmd += "V0mk->SetSVTUsage(1);";
00645       cmd += "V0mk->SetV0LanguageUsage(3);";
00646       ProcessLine(cmd);
00647     }
00648     if(maker=="StXiFinderMaker" && Key=="xisvt"){
00649       TString cmd(Form("StXiFinderMaker *Ximk=(StXiFinderMaker*) %p;",mk));
00650       cmd += "Ximk->SetLanguageUsage(0);";
00651       cmd += "Ximk->SetSVTUsage(1);";
00652       cmd += "Ximk->SetV0LanguageUsage(3);";
00653       cmd += "Ximk->SetXiLanguageUsage(5);";
00654       ProcessLine(cmd);
00655     }
00656     if (maker == "StTpcRTSHitMaker") {
00657       if ( GetOption("TpxClu2D")) mk->SetAttr("TpxClu2D", kTRUE);
00658     }
00659     if (maker == "StTpcDbMaker"){
00660       if ( GetOption("Simu") && ! GetOption("NoSimuDb")) mk->SetAttr("Simu",kTRUE);
00661       if ( GetOption("useLDV")    ) mk->SetAttr("useLDV",kTRUE) ;// uses laserDV database
00662       if ( GetOption("useCDV")    ) mk->SetAttr("useCDV",kTRUE) ;// uses ofl database
00663       if ( GetOption("useNewLDV") ) mk->SetAttr("useNewLDV",kTRUE);// uses new laserDV
00664       if (GetOption("ExB")){
00665         mk->SetAttr("ExB", kTRUE);      // bit 0 is ExB ON or OFF
00666         if      ( GetOption("EB1") ) mk->SetAttr("EB1", kTRUE);
00667         else if ( GetOption("EB2") ) mk->SetAttr("EB2", kTRUE);
00668         else {
00669           // depend on RY option i.e. take default for that RealYear data
00670           // expectations.
00671           if(GetOption("RY1H")    ||
00672              GetOption("RY2000")  ||
00673              GetOption("RY2001")  ||
00674              GetOption("RY2001N") ||
00675              GetOption("RY2003")  ||
00676              GetOption("RY2003X"))   mk->SetAttr("OldRuns", kTRUE);
00677         }
00678         // Other options introduced in October 2001 for distortion corrections
00679         // studies and year1 re-production. Those are OR additive to the mask.
00680         //(void) printf("StBFChain:: Options list : %d %d %d %d %d %d %d %d\n",
00681         //                kPadrow13,kTwist,kClock,kMembrane,kEndcap,
00682         //            kIFCShift,kSpaceCharge,kSpaceChargeR2);
00683         if( GetOption("OBmap")      ) mk->SetAttr("OBmap"      , kTRUE);
00684         if( GetOption("OPr13")      ) mk->SetAttr("OPr13"      , kTRUE);
00685         if( GetOption("OTwist")     ) mk->SetAttr("OTwist"     , kTRUE);
00686         if( GetOption("OClock")     ) mk->SetAttr("OClock"     , kTRUE);
00687         if( GetOption("OCentm")     ) mk->SetAttr("OCentm"     , kTRUE);
00688         if( GetOption("OECap")      ) mk->SetAttr("OECap"      , kTRUE);
00689         if( GetOption("OIFC")       ) mk->SetAttr("OIFC"       , kTRUE);
00690         if( GetOption("OSpaceZ")    ) mk->SetAttr("OSpaceZ"    , kTRUE);
00691         if( GetOption("OSpaceZ2")   ) mk->SetAttr("OSpaceZ2"   , kTRUE);
00692         if( GetOption("OShortR")    ) mk->SetAttr("OShortR"    , kTRUE);
00693         if( GetOption("OBMap2d")    ) mk->SetAttr("OBMap2d"    , kTRUE);
00694         if( GetOption("OGridLeak")  ) mk->SetAttr("OGridLeak"  , kTRUE);
00695         if( GetOption("OGridLeak3D")) mk->SetAttr("OGridLeak3D", kTRUE);
00696         if( GetOption("OGGVoltErr") ) mk->SetAttr("OGGVoltErr" , kTRUE);
00697         if( GetOption("OSectorAlign"))mk->SetAttr("OSectorAlign",kTRUE);
00698       }
00699       mk->PrintAttr();
00700     }
00701     if ((maker == "StdEdxY2Maker"  || maker == "StTpcHitMover") &&
00702         GetOption("EmbeddingShortCut"))  {
00703       mk->SetAttr("EmbeddingShortCut", kTRUE);
00704       mk->PrintAttr();
00705     }
00706     if (maker == "StSvtDbMaker" || maker == "StSsdDbMaker"){
00707       mk->SetMode(0);
00708       // If simulation running make sure pick up simu stuff from db
00709       if (GetOption("Simu") && ! GetOption("NoSimuDb")) mk->SetMode(1);
00710     }
00711 
00712     // FTPC
00713     if ((maker == "StFtpcClusterMaker" ||
00714          maker == "StFtpcTrackMaker"    )  &&
00715         GetOption("fdbg"))                     mk->SetMode(mk->GetMode()+2);
00716     if ( ( maker == "StFtpcClusterMaker" || // ?
00717            maker == "StFtpcTrackMaker" ) &&
00718          GetOption("flaser"))                  mk->SetMode(mk->GetMode()+1);
00719 
00720     if ((maker == "StFtpcClusterMaker" ||
00721          maker == "StFtpcTrackMaker"    )  &&
00722         GetOption("fgain"))                    mk->SetMode(mk->GetMode()+4);
00723 
00724     // FTPC
00725 
00726     // PMD
00727     if ( maker == "StPmdReadMaker"         &&
00728          GetOption("pmdRaw"))                  mk->SetAttr("pmdRaw",kTRUE);
00729     // PMD
00730 
00731     // Hit filtering will be made from a single maker in
00732     // future with flexible filtering method
00733     if (maker == "StHitFilterMaker") {
00734       if (GetOption("SvtHitFilt")){
00735         // Filter out SVT bad hits, TPC hits not on tracks and all hits if fabs(ZVert)>30
00736         LOG_QA << "SVT hit filter is ON" << endm;
00737         TString cmd(Form("StHitFilterMaker *Filtmk=(StHitFilterMaker*) %p;",mk));
00738         cmd += "Filtmk->setPtLowerCut(-99.);";
00739         cmd += "Filtmk->setPtUpperCut(-99.);";
00740         cmd += "Filtmk->setAbsEtaCut(-99);";
00741         cmd += "Filtmk->setAbsZVertCut(30);";
00742         ProcessLine(cmd);
00743       } else if (GetOption("TpcHitFilt")){
00744         // Filter out TPC hits not on tracks
00745         LOG_QA << "TPC hit filter is ON" << endm;
00746         TString cmd(Form("StHitFilterMaker *Filtmk=(StHitFilterMaker*) %p;",mk));
00747         cmd += "Filtmk->setPtLowerCut(-99.);";
00748         cmd += "Filtmk->setPtUpperCut(-99.);";
00749         cmd += "Filtmk->setAbsEtaCut(-99);";
00750         cmd += "Filtmk->setAbsZVertCut(999);";
00751         ProcessLine(cmd);
00752       } else {
00753         LOG_QA << "Default hit filtering is ON" << endm;
00754       }
00755       Int_t    mode = 0;
00756       if (GetOption("KeepTpcHit")) mode |= (1 << kTpcId);
00757       if (GetOption("KeepSvtHit")) mode |= (1 << kSvtId);
00758       mk->SetMode(mode);
00759       // the m_Mode (Int_t is signed integer 4 bytes) mask is too short for the FGT
00760       if (GetOption("KeepFgtHit")){
00761         TString cmd(Form("StHitFilterMaker *Filtmk=(StHitFilterMaker*) %p;",mk));
00762         cmd += "Filtmk->setKeepWestHighEtaHitsForFgt(1.0);";
00763         ProcessLine(cmd);
00764       }
00765     }
00766     if (maker == "StMiniMcMaker" && fFileOut != "") {
00767       ProcessLine(Form("((StMiniMcMaker *) %p)->setFileName(\"%s\");", mk, fFileOut.Data()));
00768     }
00769     if (maker == "StMcAnalysisMaker") {
00770       Int_t mode = 0;
00771       if (GetOption("McAnaTpc")) mode += 0x1;
00772       if (GetOption("McAnaSvt")) mode += 0x2;
00773       if (GetOption("McAnaSsd")) mode += 0x4;
00774       if (mode)
00775         ProcessLine(Form("((StMaker *) %p)->SetMode(%i);", mk, mode));
00776     }
00777     if (maker == "StBTofCalibMaker" && GetOption("UseProjectedVertex")) mk->SetAttr("UseProjectedVertex",kTRUE);
00778     if (maker == "StEventMaker" && fFiltTrg.Length()) {
00779       mk->SetAttr("FiltTrg",(Int_t) (fFiltTrg.BeginsWith('+') ? 1 : -1));
00780       TString FiltTrgFlavor = fFiltTrg(1,128);
00781       if (FiltTrgFlavor.Length())
00782         SetFlavor((FiltTrgFlavor += "+ofl").Data(),"trgOfflineFilter");
00783     }
00784   Add2Chain:
00785     if (! mk) continue;
00786     if (name == "") strcpy (fBFC[i].Name,(Char_t *) mk->GetName());
00787     if (myChain) myChain->AddMaker(mk);
00788     continue;
00789   Error:
00790     status = kStErr;
00791     LOG_QA      << " ======================================"          << endm;
00792     LOG_QA      << " problem with Instantiation of " << fBFC[i].Maker << endm;
00793     LOG_QA      << " ======================================"          << endm;
00794   }
00795   //  PrintQAInfo();
00796   PrintInfo();
00797   // START the chain (may the force be with you)
00798   // Create HTML docs of all Maker's inv
00799 #if 0
00800   if (GetOption("MakeDoc"))  MakeDoc();
00801 #endif
00802   if (GetOption("Debug"))    SetDEBUG(1);
00803   if (GetOption("Debug1"))   SetDEBUG(1);
00804   if (GetOption("Debug2"))   SetDEBUG(2);
00805   if (GetOption("nohistos")) SetAttr(".histos",0,"*");
00806   else                       SetAttr(".histos",1,"*");
00807   if (GetOption("NoRepeat")) gMessMgr->IgnoreRepeats();
00808 
00809   if (GetOption("svt1hit"))  SetAttr("minPrecHits",1,"Sti");
00810   if (GetOption("svt1hit"))  SetAttr("minPrecHits",1,"StiCA");
00811   if (GetOption("svt1hit"))  SetAttr("minPrecHits",1,"Stv");
00812   if (GetOption("svt1hit"))  SetAttr("minPrecHits",1,"StiVMC");
00813 
00814   gMessMgr->QAInfo() << "+++ Setting attribute " << Gproperty.Data() << " = " << Gvalue.Data() << endm;
00815   SetAttr(Gproperty.Data(),Gvalue.Data(),Gpattern.Data());
00816 
00817   return status;
00818 }
00819 //_____________________________________________________________________
00820 Int_t StBFChain::Init() {
00821 
00822   TDatime td;
00823   Info("Init","Time=%s Cwd=%s",td.AsString(),gSystem->pwd());
00824 
00825   SetChainOpt(new StBFChainOpt(this));
00826   //  SetDbOptions(); moved to Instantiation
00827   if (fNoChainOptions) {
00828     //  SetGeantOptions(); move back to Init
00829     if (GetOption("Simu") && ! (GetOption("mtin") || GetOption("PrepEmbed") || GetOption("pythiaEmbed"))) { //  ! Simu
00830       StEvtHddr *fEvtHddr = (StEvtHddr*)GetDataSet("EvtHddr");
00831       if (!fEvtHddr) {
00832         fEvtHddr = new StEvtHddr(m_ConstSet);
00833         SetOutput(fEvtHddr);                  //Declare this "EvtHddr" for output
00834       }
00835       if (fEvtHddr->GetRunNumber() < 0 || fEvtHddr->GetRunNumber() >= 1000000) {
00836         fEvtHddr->SetRunNumber(1); // to have run positive and < 1000000 (to avoid mess with RunLog)
00837       }
00838     }
00839   }
00840   if (fNoChainOptions) {
00841     if (GetOption("NoOutput") || GetOption("EvOutOnly")) {
00842       if (! GetOption("RMuDst"))
00843         SetAttr(".call","SetActive(0)","MuDst");                //NO MuDst
00844       if (! GetOption("EvOutOnly")) {
00845         SetAttr(".call","SetActive(0)","outputStream"); //NO Out
00846       }
00847       SetAttr(".call","SetActive(0)","kink2");
00848       SetAttr(".call","SetActive(0)","StTagsMaker::");
00849       SetAttr(".call","SetActive(0)","StStrangeMuDstMaker::");
00850     }
00851 #if 1
00852     // force load of geometry for VMC and Sti
00853     
00854     if (GetOption("Sti") || GetOption("StiCA") || 
00855         GetOption("Stv") || 
00856         GetOption("StiVMC") ||GetOption("VMC") || 
00857         GetOption("VMCPassive")) {
00858       const DbAlias_t *DbAlias = GetDbAliases();
00859       for (Int_t i = 0; DbAlias[i].tag; i++) {
00860         TString dbTag("r");
00861         dbTag += DbAlias[i].tag;
00862         if (GetOption(dbTag)) {
00863           TString path("./StarDb/AgiGeometry:$STAR/StarDb/AgiGeometry");
00864           if (GetOption("AgML")) {
00865             path  = "./StarDb/AgMLGeometry:$STAR/StarDb/AgMLGeometry";
00866           }
00867           if (GetOption("VmcGeo")) {
00868             path  = "./StarDb/VmcGeo:$STAR/StarDb/VmcGeo";
00869           }
00870           TString geom("Geometry.");
00871           geom +=  DbAlias[i].geometry;
00872           geom += ".C";
00873           Char_t *file = gSystem->Which(path.Data(),geom,kReadPermission);
00874           if (file) {
00875             LOG_INFO << "StBFChain::Init force load of " << file << endm;
00876             TString command = ".L "; command += file;
00877             gInterpreter->ProcessLine(command);
00878             gInterpreter->Calc("CreateTable()");
00879             command.ReplaceAll(".L ",".U ");
00880             gInterpreter->ProcessLine(command);
00881             delete [] file;
00882           } else {
00883             LOG_INFO << "StBFChain::Init file for geometry tag  " << geom << " has not been found in path" << path << endm;
00884           }
00885           break;
00886         }
00887       }
00888     }
00889 #endif
00890   }
00891   return StChain::Init();
00892 }
00893 //_____________________________________________________________________
00895 Int_t StBFChain::Finish()
00896 {
00897   TFile *tf = GetTFile();
00898   if (tf) {tf->Write(); tf->Flush(); tf->Close(); delete tf; SetTFile(0);}
00899   if (!fBFC) return kStOK;
00900   Int_t ians = StChain::Finish();
00901   SafeDelete(fchainOpt);
00902   fBFC = 0;
00903 //  delete gMessMgr; gMessMgr = 0;
00904   return ians;
00905 }
00906 
00907 
00908 //_____________________________________________________________________
00909 Int_t StBFChain::AddAB (const Char_t *mkname,const StMaker *maker,const Int_t Opt) {
00910   if (! maker || strlen(mkname) == 0) return kStErr;
00911   StMaker *parent = maker->GetParentMaker();
00912   if (parent) {
00913     TList   *list    = parent->GetMakeList();
00914     list->Remove((StMaker *)maker);
00915   }
00916   StMaker *mk      = GetMaker(mkname);      if (!mk)     return kStErr;
00917   parent  = mk->GetParentMaker();  if (!parent) return kStErr;
00918   TList   *list    = parent->GetMakeList(); if (!list)   return kStErr;
00919   if (Opt > 0) list->AddAfter (mk,(StMaker*)maker);
00920   else         list->AddBefore(mk,(StMaker*)maker);
00921   return kStOk;
00922 }
00923 
00924 //_____________________________________________________________________
00925 Int_t StBFChain::ParseString (const TString &tChain, TObjArray &Opt, Bool_t Sort) {
00926   Opt.Clear();
00927   TObjArray *obj = tChain.Tokenize("[^ ;,]+");
00928   Int_t nParsed = obj->GetEntries();
00929   Int_t k, N = 0;
00930   if (GetChain() && GetChain()->Debug() > 2) {
00931     gMessMgr->QAInfo() << "ParseString " << tChain.Data() << endm;
00932     for (k = 0; k < nParsed; k++) {
00933       if (obj->At(k)) {
00934         gMessMgr->QAInfo() << k << "\t" << ((TObjString *) obj->At(k))->GetName() << endm;
00935       }
00936     }
00937   }
00938   for (k = 0; k < nParsed; k++) {if (obj->At(k)) {if (k != N) obj->AddAt(obj->At(k),N); N++;}}
00939   nParsed = N;
00940   // sort options
00941   StBFChain *chain = (StBFChain *) StMaker::GetChain();
00942   if (chain && Sort) {// sort options
00943     TArrayI idT(nParsed); Int_t *idx = idT.GetArray();
00944     TArrayI kdT(nParsed); Int_t *kdx = kdT.GetArray();
00945     for (k = 0; k < nParsed; k++) {
00946       TString string = ((TObjString *) obj->At(k))->GetString();
00947       kdx[k] = TMath::Abs(chain->kOpt(string,kFALSE));
00948     }
00949     TMath::Sort(nParsed,kdx,idx,0);
00950     TString sChain;
00951     for (k = 0; k < nParsed; k++) {
00952       Opt.AddAtAndExpand(obj->At(idx[k]),k);
00953       if (k == 0) sChain = ((TObjString *)Opt[k])->GetString();
00954       else {sChain += ","; sChain += ((TObjString *)Opt[k])->GetString();}
00955     }
00956     if (N > 1 && chain->Debug() > 2) {
00957       gMessMgr->QAInfo() << "Requested chain is :\t" << tChain.Data() << endm;
00958       gMessMgr->QAInfo() << "Sorted    chain is :\t" << sChain.Data() << endm;
00959     }
00960   } else for (k = 0; k < nParsed; k++) Opt.AddAtAndExpand(obj->At(k),k);
00961   obj->SetOwner(kFALSE);
00962   delete obj;
00963   return nParsed;
00964 }
00965 
00966 //_____________________________________________________________________
00968 Int_t StBFChain::kOpt (const Char_t *tag, Bool_t Check) const {
00969   TString Tag(tag);
00970   Int_t kO = kOpt(&Tag, Check);
00971   return kO;
00972 }
00973 //_____________________________________________________________________
00975 
00981 Int_t StBFChain::kOpt (const TString *tag, Bool_t Check) const {
00982   TString Tag = *tag;
00983   Tag.ToLower();
00984   TString opt, nopt;
00985   for (Int_t i = 1; i< fNoChainOptions; i++) {
00986     opt = TString(fBFC[i].Key); //check nick name
00987     opt.ToLower();
00988     nopt = TString("-");
00989     nopt += opt;
00990     if       (Tag ==  opt) {return  i;}
00991     else {if (Tag == nopt) {return -i;}}
00992     opt   = fBFC[i].Maker; //check full maker name2
00993     nopt  = "-";
00994     nopt += opt;
00995     if       (Tag ==  opt) {return  i;}
00996     else {if (Tag == nopt) {return -i;}}
00997   }
00998   //
00999   // JL - sdt and dbv for timestamp
01000   //
01001   // Gopt for arbitrary property on 3 letter name (wildcard would be added) and length
01002   // 6 for a value. Not advertized / not used and implementation is not complete (needed
01003   // a case and di not have a clear one). TBD.
01004   //
01005   // 2011/11 added the possibility of detector sub-system specific timestamps.
01006   // DBV only for now, logic is similar if we equally parse.
01007   //
01008   // {sdt|dbv}YYYYMMDD -> {sdt|dbv} 3 / YYYYMMDD 8 => 11 || YYYYMMDD.HHMMSS = 15 => 18
01009   if (Tag.BeginsWith("dbv") || Tag.BeginsWith("sdt")) {
01010     Check = kTRUE;
01011 
01012     if (Tag.Length() == 11  || Tag.Length() == 18) return 0;
01013 
01014     // Else we need to parse some more - assume a pattern {dbv|sdt}YYYYMMDD[.HHMMSS]_XXX_ZZZZZ
01015     // First, detect it using quick counting 
01016     Tag.ToLower();
01017     if ( TPRegexp(BFC_DBREGEXP).Match(Tag)  == 7) return 0;
01018   }
01019   if (Tag.BeginsWith("rung")) {
01020     Check = kTRUE;
01021     return 0;
01022   }
01023   // GoptXXXvvvvvv -> Gopt 4 / XXX 3 / vvvvvv 6 = 13
01024   if ( Tag.BeginsWith("gopt") && Tag.Length() == 13 ) return 0;
01025 
01026   if ( Tag.BeginsWith("FiltTrg",TString::kIgnoreCase) ) {
01027     Check = kTRUE;
01028     if ( TPRegexp("^FiltTrg(Inc|Exc)?(_.*)*$").Match(Tag,"i") > 0) return 0;
01029   }
01030 
01031   if (Check) {
01032     gMessMgr->Error() << "Option " << Tag.Data() << " has not been recognized" << endm;
01033     abort(); //assert(1);
01034   }
01035   return 0;
01036 }
01037 //_____________________________________________________________________
01038 void StBFChain::SetOptions(const Char_t *options, const Char_t *chain) {
01039   TString tChain(options);
01040   TObjArray Opts;
01041   Int_t nParsed = ParseString(tChain,Opts,kTRUE);
01042   for (Int_t l = 0; l < nParsed; l++) {
01043     TString Tag = ((TObjString *)Opts[l])->GetString();
01044     Int_t kgo;
01045     Int_t in = Tag.Index("=");
01046     if (in > 0) {// string with  "="
01047       TString subTag(Tag.Data(),in);
01048       subTag.ToLower(); //printf ("Chain %s\n",tChain.Data());
01049       kgo = kOpt(subTag.Data());
01050       if (kgo > 0) {
01051         memset(fBFC[kgo].Comment,0,sizeof(fBFC[kgo].Comment)); // be careful size of Comment
01052         TString Comment(Tag.Data()+in+1,Tag.Capacity()-in-1);
01053         strcpy (fBFC[kgo].Comment, Comment.Data());
01054         gMessMgr->QAInfo() << Form(" Set        %s = %s", fBFC[kgo].Key,fBFC[kgo].Comment) << endm;
01055       }
01056     } else {
01057       Tag.ToLower();
01058       // printf ("Chain %s\n",tChain.Data());
01059       kgo = kOpt(Tag.Data(),kFALSE);
01060       if (kgo != 0) {
01061         SetOption(kgo,chain);
01062         if (kgo > 0) {
01063           TString Comment(fBFC[kgo].Comment);
01064           TString Opts(fBFC[kgo].Opts);
01065           if (Tag.BeginsWith("Test.",TString::kIgnoreCase) && ! Comment.BeginsWith("/star/") && 
01066               Opts.BeginsWith("test_",TString::kIgnoreCase)) {
01067             SetOptions(Opts,Tag);
01068           } else {
01069             if ((Tag.BeginsWith("Test.",TString::kIgnoreCase) ||
01070                  Tag.BeginsWith("test_",TString::kIgnoreCase) ||
01071                  Tag.BeginsWith("eval_",TString::kIgnoreCase)) && Comment.BeginsWith("/star/") ) {
01072               fkChain = kgo;
01073               gMessMgr->QAInfo() << "Default Test chain set " << fBFC[fkChain].Key << " with input " << fBFC[fkChain].Comment << endm;
01074             } 
01075           }
01076         }
01077       } else {
01078         // it is 0 i.e. was not recognized. 
01079         // Check if it is a (dbv|sdt)YYYYMMDD or (dbv|sdt)YYYYMMDD.HHMMSS and derivative
01080         // We really set the options only once later in SetDbOptions() (removing the fBFC[i].Flag check) 
01081         // but the goal here is to avoid user's histeria by displaying extra messages NOW.
01082         //
01083         // Note that kOpt() has already validated the pattern (so it has to be right here).
01084         //
01085         // !!! Debug: dbv20040917
01086         if (Tag.BeginsWith("dbv")) {
01087           if (Tag.Length() == 11)  (void) sscanf(Tag.Data(),"dbv%8d",&FDate);
01088           if (Tag.Length() == 18)  (void) sscanf(Tag.Data(),"dbv%8d.%6d",&FDate,&FTime);
01089           if (Tag.Length() == 11 || Tag.Length() == 18) {
01090             gMessMgr->QAInfo() << Tag.Data() << " ... but still will be considered as a dynamic timestamp (Max DB EntryTime) "
01091                                << FDate  << "." << FTime << endm;
01092 #ifdef USE_BFCTIMESTAMP
01093           } else {
01094             // we passed kOpt() parsing was fine
01095             //if ( TPRegexp(BFC_DBREGEXP).Match(Tag)  == 7) return 0;
01096             TObjArray *subStrL = TPRegexp(BFC_DBREGEXP).MatchS(Tag);
01097             BFCTimeStamp TS;
01098             TString realm;
01099 
01100             TS.Type     = 1;
01101             TS.Date     = (((TObjString *) subStrL->At(2))->GetString()).Atoi();
01102             TS.Time     = 0; // for now, avoid parsing this as user use simple TS 99% of the time
01103             TS.Detector = ((TObjString *) subStrL->At(4))->GetString();
01104             TS.Realm    = ((TObjString *) subStrL->At(6))->GetString();
01105 
01106             if ( TS.Realm.IsNull() ){ realm = "*";}
01107             else {                    realm = TS.Realm;}
01108 
01109             GTSOptions.push_back(TS);
01110 
01111             LOG_WARN << "Override timestamp for detector requested\n\t" 
01112                      << "Detector " << TS.Detector  << "\n\t"
01113                      << "Realm    " << realm        << "\n\t"
01114                      << "Date     " << TS.Date      << "\n\t"
01115                      << "Time     " << TS.Time      << endm;
01116 #endif /*  USE_BFCTIMESTAMP */
01117           }
01118 
01119         } else if (Tag.BeginsWith("sdt")) {
01120           if (Tag.Length() == 11)  (void) sscanf(Tag.Data(),"sdt%8d",&FDateS);
01121           if (Tag.Length() == 18)  (void) sscanf(Tag.Data(),"sdt%8d.%6d",&FDateS,&FTimeS);
01122           if (Tag.Length() == 11 || Tag.Length() == 18) {
01123             gMessMgr->QAInfo() << Tag.Data() << " ... but still will be considered as a dynamic timestamp (Event Time) "
01124                                << FDateS  << "." << FTimeS << endm;
01125 
01126             // <<< same logic for GTSOptions can be inserted here
01127             // <<< if so, use TS.Type     = 2
01128           }
01129 
01130         } else if ( Tag.BeginsWith("gopt") && Tag.Length() == 13){
01131           char GOptName[4],GOptValue[7];
01132           //TString property(".gopt.");
01133           //TString pattern("*");
01134 
01135           (void) sscanf(Tag.Data(),"gopt%3s%6s",GOptName,GOptValue);
01136           // sscanf adds null terminators for %s, so buffers need to be 1 longer
01137 
01138           // see StBFChain::Setup() for default values
01139           Gproperty += GOptName;
01140 
01141           // JL - this is not finished, see comment in kOpt()
01142           
01143           // pattern is case sensitive, need more checks on this before
01144           // setting to something else than "*"
01145           //Gpattern  += GOptName;
01146           //Gpattern  += "*";
01147           Gvalue = GOptValue;
01148 
01149           gMessMgr->QAInfo() << Tag.Data() << " ... this will set an general attribute "
01150                              << Gproperty.Data() << " with value " << GOptValue << " to "
01151                              << Gpattern.Data() << endm;
01152           // Attr() need to be set after the maker exist
01153           //SetAttr(property.Data(),GOptValue,pattern.Data());
01154           //SetAttr(property.Data(),GOptValue,pattern.Data());
01155 
01156         } else if (Tag.BeginsWith("rung")) {
01157           fRunG = 1;
01158           if (Tag.Length() > 4)  (void) sscanf(Tag.Data(),"rung.%d",&fRunG);
01159           gMessMgr->QAInfo() << Tag.Data() << " will be considered as Run number (& rndm seed set) " 
01160                              << fRunG << " for simulation." << endm; 
01161         } else if (Tag.BeginsWith("FiltTrg",TString::kIgnoreCase)) {
01162           TString filtTrgTag = Tag;
01163           Ssiz_t flavorIdx = Tag.Index('_');
01164           if (flavorIdx > 0) {
01165             filtTrgTag = Tag(0,flavorIdx);
01166             fFiltTrg = Tag(flavorIdx+1,64);
01167           }
01168           if (filtTrgTag.CompareTo("FiltTrgExc",TString::kIgnoreCase)==0) {
01169             gMessMgr->QAInfo() << "Trigger Filtering exclude with flavor=" << fFiltTrg << endm;
01170             fFiltTrg.Prepend('-');
01171           } else if (filtTrgTag.CompareTo("FiltTrgInc",TString::kIgnoreCase)==0 ||
01172                      filtTrgTag.CompareTo("FiltTrg"   ,TString::kIgnoreCase)==0) {
01173             gMessMgr->QAInfo() << "Trigger Filtering include with flavor=" << fFiltTrg << endm;
01174             fFiltTrg.Prepend('+');
01175           } else {
01176             // not a match, disable
01177             fFiltTrg = "";
01178           }
01179         } else { // Check for predefined db time stamps ?
01180           kgo = kOpt(Tag.Data(),kFALSE);
01181           if (kgo != 0){
01182             SetOption(kgo,chain);
01183           } else {
01184             // Check that option can be library name or / and Maker
01185             static const Char_t *path = ".:.$STAR_HOST_SYS/lib::.$STAR_HOST_SYS/LIB:$STAR/.$STAR_HOST_SYS/lib:$STAR/.$STAR_HOST_SYS/LIB";
01186             TString File = Tag; File += ".so";
01187             Char_t *file = gSystem->Which(path,File.Data(),kReadPermission);
01188             if (file) {
01189               TString Maker("");
01190               Bfc_st row = {"","","","","","","",kTRUE};
01191               memcpy (&row.Key, Tag.Data(), Tag.Length());
01192               if (Tag.Contains("Maker")) memcpy (&row.Maker, Tag.Data(), Tag.Length());
01193               memcpy (&row.Libs, Tag.Data(), Tag.Length());
01194               fchainOpt->AddAt(&row);
01195               fNoChainOptions = fchainOpt->GetNRows();
01196               fBFC = fchainOpt->GetTable();
01197               delete [] file;
01198             }
01199             kgo = kOpt(Tag.Data(),kFALSE);
01200             if (kgo != 0) {
01201               SetOption(kgo,chain);
01202             } else {
01203               gMessMgr->QAInfo() << " Invalid Option " << Tag.Data() << ". !! ABORT !! " << endm;
01204               abort(); //assert(1);
01205               return;
01206             }
01207           }
01208         }
01209       }
01210     }
01211   }
01212   Opts.Delete();
01213 }
01214 //_____________________________________________________________________
01216 void StBFChain::SetOption(const Int_t k, const Char_t *chain) {
01217   if (k > 0) {
01218     assert(k<fNoChainOptions);
01219     Int_t n = strlen(fBFC[k].Opts);
01220     if (n >  0) SetOptions(fBFC[k].Opts,fBFC[k].Key);
01221     if (!fBFC[k].Flag) {
01222       fBFC[k].Flag = kTRUE;
01223       gMessMgr->QAInfo() << Form(" Switch On  %20s by %s", fBFC[k].Key, chain) << endm;
01224     }
01225   } else {
01226     assert(-k<fNoChainOptions);
01227     if (k < 0 && fBFC[-k].Flag) {
01228       fBFC[-k].Flag = kFALSE;
01229       gMessMgr->QAInfo() << Form(" Switch Off %20s by %s", fBFC[-k].Key, chain) << endm;
01230     }
01231   }
01232 }
01233 
01234 //_____________________________________________________________________
01236 Bool_t StBFChain::GetOption(const Int_t k) const
01237 {
01238   return (k>0 && k <fNoChainOptions) ? fBFC[k].Flag : kFALSE;
01239 }
01240 
01242 
01261 Char_t *StBFChain::GetOptionString(const Char_t *Opt)
01262 {
01263   Int_t o = kOpt(Opt);
01264   if(!o) return NULL;
01265   else if(!GetOption(o)) return NULL;
01266   else return(fBFC[o].Comment);
01267 }
01268 
01269 
01270 //_____________________________________________________________________________
01272 
01299 void StBFChain::SetFlags(const Char_t *Chain)
01300 {
01301   TString tChain(Chain);
01302   Int_t mode = 1;
01303   Setup(mode);
01304   Int_t k=0;
01305   if (tChain == "" || tChain.CompareTo("ittf",TString::kIgnoreCase) == 0) {
01306     gMessMgr->QAInfo() << "\tPossible Chain Options are:" << endm;
01307     for (k=0;k<fNoChainOptions;k++)
01308     gMessMgr->QAInfo()
01309       << Form(" %3d: %-30s:%-12s:%-12s:%s:%s:%s:%s"
01310               ,k,fBFC[k].Key,fBFC[k].Name,fBFC[k].Chain,fBFC[k].Opts,fBFC[k].Maker,fBFC[k].Libs,fBFC[k].Comment)
01311       << endm;
01312 
01313     return;
01314   }
01315   TString STAR_VERSION("$STAR_VERSION");
01316   gSystem->ExpandPathName(STAR_VERSION);
01317   gMessMgr->QAInfo() << "=============================================="  << endm;
01318   gMessMgr->QAInfo() << "============= You are in " << STAR_VERSION.Data() << " ===============" << endm;
01319   gMessMgr->QAInfo() << "Requested chain " << GetName() << " is :\t" << tChain.Data() << endm;
01320   SetOptions(tChain,"Chain");
01321   if (GetOption("NewTpcAlignment")) {
01322     gMessMgr->QAInfo() << "Set environment to use NewTpcAlignment" << endm;
01323     gEnv->SetValue("NewTpcAlignment",1);
01324   }
01325   if (!GetOption("NoDefault")) { // Default
01326     // Check flags consistency
01327     if (gClassTable->GetID("TGiant3") >= 0) { // root4star
01328       SetOption("-VMC","Default,TGiant3");
01329       SetOption("-VMCPassive","Default,TGiant3");
01330       SetOption("-VMCAppl","Default,TGiant3");
01331       SetOption("-RootVMC","Default,TGiant3");
01332 #if 1 /* Not Active geant is not needed any more, except BTofUtil */
01333       if (!( GetOption("fzin")   || 
01334              GetOption("ntin")   || 
01335              GetOption("gstar" ) || 
01336              GetOption("pythia") || 
01337              GetOption("PrepEmbed"))) {// Not Active geant
01338         SetOption("geant","Default,TGiant3");
01339         SetOption("MagF","Default,TGiant3");
01340       }
01341 #endif
01342       if (GetOption("xgeometry")) {
01343         SetOption("-geometry","Default,-xgeometry");
01344         SetOption("-geomNoField","Default,-xgeometry");
01345       }
01346     } else {                                  // root
01347       if (GetOption("fzin")) {
01348         gMessMgr->Error() << "Option fzin cannot be used in root.exe. Use root4star" << endm;
01349         abort();
01350       }
01351       if (GetOption("ntin")) {
01352         gMessMgr->Error() << "Option ntin cannot be used in root.exe. Use root4star" << endm;
01353         abort();
01354       }
01355       if (! (GetOption("Stv"))) {
01356         if (GetOption("gstar") || GetOption("pythia")) {
01357           SetOption("VMC","Default,-TGiant3,gstar");
01358           SetOption("-gstar","Default,-TGiant3");
01359           SetOption("-pythia","Default,-TGiant3");
01360         }
01361       }
01362       SetOption("-geant","Default,-TGiant3");
01363       SetOption("-geantL","Default,-TGiant3");
01364       SetOption("-geometry","Default,-TGiant3");
01365       SetOption("-geomNoField","Default,-TGiant3");
01366       if (! (GetOption("Stv"))) {
01367         if (! (GetOption("VMC") || GetOption("VMCPassive"))) {
01368           SetOption("VMCPassive","Default,-TGiant3");
01369         }
01370         SetOption("pgf77","Default,-TGiant3");
01371         SetOption("mysql","Default,-TGiant3");
01372         SetOption("minicern","Default,-TGiant3");
01373       }
01374     }
01375     if (GetOption("ITTF") && ! (GetOption("Sti") || GetOption("StiCA")  || GetOption("Stv") || GetOption("StiVMC"))) {
01376       TString STAR_LEVEL(gSystem->Getenv("STAR_LEVEL"));
01377       if (STAR_LEVEL == ".DEV2")  SetOption("StiCA","Default,ITTF");
01378       else                        SetOption("Sti"  ,"Default,ITTF");
01379     }  
01380     if (GetOption("Stv")) {
01381       SetOption("-TpcIT","Default,Stv");
01382       SetOption("-SvtIT","Default,Stv");
01383       SetOption("-SsdIT","Default,Stv");
01384       SetOption("-HpdIT","Default,Stv");
01385       SetOption("-BTofIT","Default,Stv");
01386       SetOption("-PxlIT","Default,Stv");
01387       SetOption("-IstIT","Default,Stv");
01388     }  
01389     
01390   }
01391   if (!GetOption("Eval") && GetOption("AllEvent"))  SetOption("Eval","-Eval,AllEvent");
01392   // Print set values
01393   St_Bfc *Bfc = new St_Bfc("BFChain",fNoChainOptions);
01394   AddRunco(Bfc);
01395   for (k = 1; k<fNoChainOptions;k++) {
01396     if (GetOption(k)) {
01397       gMessMgr->QAInfo() << Form("================== %4d %15s\tis ON \t: %s",
01398                                  k, (char *) fBFC[k].Key, (char *) fBFC[k].Comment) << endm;
01399       Bfc->AddAt(&fBFC[k]);
01400     }
01401   }
01402   //  gSystem->Exit(1);
01403 }
01404 //_____________________________________________________________________
01405 void StBFChain::Set_IO_Files (const Char_t *infile, const Char_t *outfile){
01406   TString gc("");
01407   if (infile) {
01408     if (strlen(infile) > 2) {
01409       gc = TString(infile,3);
01410       gc.ToLower();
01411     }
01412   }
01413   SetInputFile(infile);
01414   if (! GetOption("NoOutput")) SetOutputFile(outfile);
01415 }
01416 //_____________________________________________________________________
01417 void StBFChain::SetInputFile (const Char_t *infile){
01418   // define input file
01419   if (infile) fInFile = infile;
01420   if (fInFile != "") {
01421     fInFile.ReplaceAll("\n",";");
01422     fInFile.ReplaceAll("#",";");
01423     fInFile.ReplaceAll(":",";");
01424     gMessMgr->QAInfo() << "Input file name = " << fInFile.Data() << endm;
01425   } else {
01426     if (fkChain >= 0) {
01427       fInFile = fBFC[fkChain].Comment;
01428       fInFile.ReplaceAll("\n",";");
01429       gMessMgr->QAInfo() << "Default Input file name = " << fInFile.Data() << " for chain : " << fBFC[fkChain].Key << endm;
01430     }
01431   }
01432   if (fInFile == "") {SetOption("-in","No Input File"); SetOption("-InTree","NoInput File"); return;}
01433   if (!GetOption("fzin") && !GetOption("ntin")) {
01434     fSetFiles= new StFile();
01435     TObjArray Files;
01436     ParseString(fInFile,Files);
01437     TIter next(&Files);
01438     TObjString *File;
01439     while ((File = (TObjString *) next())) {
01440       TString string = File->GetString();
01441       if (!string.Contains("*") && ! string.BeginsWith("@") &&
01442           gSystem->AccessPathName(string.Data())) {// file does not exist
01443         gMessMgr->Error() << "StBFChain::SetInputFile  *** NO FILE: " << string.Data() << ", exit!" << endm;
01444         gSystem->Exit(1);
01445       }
01446       else fSetFiles->AddFile(File->String().Data());
01447     }
01448     Files.Delete();
01449   }
01450 }
01451 //_____________________________________________________________________
01453 void StBFChain::SetOutputFile (const Char_t *outfile){
01454   if (!  GetOption("NoOutput")) {
01455     if (outfile) { 
01456       fFileOut = outfile;
01457     } else {
01458       if (fInFile != "") {
01459         if (GetOption("fzin") || GetOption("ntin")) {
01460           TObjArray words;
01461           ParseString(fInFile,words);
01462           TIter nextL(&words);
01463           TObjString *word = 0;
01464           while ((word = (TObjString *) nextL())) {
01465             if (word->GetString().Contains(".fz") ||
01466                 word->GetString().Contains(".nt")) {
01467               fFileOut = gSystem->BaseName(word->GetName());
01468               break;
01469             }
01470           }
01471         } else {
01472           fFileOut = gSystem->BaseName(fInFile.Data());
01473         }
01474       } 
01475       if (fFileOut == "") {
01476         if      (GetOption("pythia")) fFileOut = "pythia.root";
01477         else if (GetOption("hijing")) fFileOut = "hijing.root";
01478         else if (GetOption("VMC"))    fFileOut = "VMC.root";
01479         else if (GetOption("gstar"))  fFileOut = "gtrack.root";
01480       }
01481       if (  fFileOut != "") {
01482         fFileOut.ReplaceAll("*","");
01483         fFileOut.ReplaceAll("@","");
01484         fFileOut.ReplaceAll("..",".");
01485         fFileOut.ReplaceAll(".daq","");
01486         fFileOut.ReplaceAll(".fzd","");
01487         fFileOut.ReplaceAll(".fz","");
01488         fFileOut.ReplaceAll(".nt","");
01489         fFileOut.ReplaceAll(".root","");
01490         fFileOut.ReplaceAll(".list","");
01491         fFileOut.ReplaceAll(".lis","");
01492         fFileOut.Strip();
01493         fFileOut.Append(".root");
01494       }
01495     }
01496   }
01497   if (fFileOut != "")  gMessMgr->QAInfo() << "Output root file name " <<  fFileOut.Data() << endm;
01498   else                 SetOption("NoOutput","No Output File");
01499   if (!GetTFile()) {
01500     if ( ( GetOption("tags")  || GetOption("lana") ) &&  (fFileOut != "") ){
01501       TString TagsName = fFileOut;
01502       if( GetOption("lana") ){
01503         TagsName.ReplaceAll(".root",".laser.root");
01504       } else if ( GetOption("mtdEvtFilt") ){
01505         TagsName.ReplaceAll(".root",".pre.tags.root");
01506       } else {
01507         TagsName.ReplaceAll(".root",".tags.root");
01508       }
01509       SetTFile(new TFile(TagsName.Data(),"RECREATE"));
01510     }
01511   }
01512 }
01513 //_____________________________________________________________________
01515 
01521 void StBFChain::SetGeantOptions(StMaker *geantMk){
01522   if (geantMk && geantMk->InheritsFrom("St_geant_Maker")) {
01523     SetInput("geant",".make/geant/.data");
01524     TString GeomVersion("");
01525     if (fRunG > 0) {
01526       geantMk->SetAttr("RunG",fRunG);
01527     }
01528     if (!GetOption("fzin") || GetOption("ForceGeometry")) {
01529       GeomVersion = "y2004x";
01530       const DbAlias_t *DbAlias = GetDbAliases();
01531       Int_t found = 0;
01532       for (Int_t i = 0; DbAlias[i].tag; i++) {
01533         TString r("r");
01534         r +=  DbAlias[i].tag;
01535         if ( !GetOption(DbAlias[i].tag,kFALSE) && !GetOption(r,kFALSE)) continue;
01536         GeomVersion = DbAlias[i].geometry;
01537         found = i;
01538         break;
01539       }
01540       if (! found) gMessMgr->QAInfo() << "StBFChain::SetGeantOptions() Chain has not found geometry tag. Use " << GeomVersion << endm;
01541       TString GeometryOpt;
01542       if (GetOption("phys_off")) {GeometryOpt += "detp phys_off=1;"; geantMk->SetAttr("phys_off",kTRUE);}
01543       if (GetOption("hadr_off")) {GeometryOpt += "detp hadr_off=1;"; geantMk->SetAttr("hadr_off",kTRUE);}
01544       GeometryOpt += ("detp geometry ");
01545       GeometryOpt += GeomVersion;
01546       ProcessLine(Form("((St_geant_Maker *) %p)->LoadGeometry(\"%s\");",geantMk,GeometryOpt.Data()));
01547     }
01548     if ((GetOption("fzin") || GetOption("ntin") || GetOption("mtin") || fInFile.Data()[0] == ';') && fInFile != "")
01549       ProcessLine(Form("((St_geant_Maker *) %p)->SetInputFile(\"%s\")",geantMk,fInFile.Data()));
01550   }
01551 }
01552 //_____________________________________________________________________
01554 
01566 void StBFChain::SetDbOptions(StMaker *mk){
01567   if (! mk ) return;
01568   if      (GetOption("Agi"))    mk->SetAlias("VmcGeometry","db/.const/StarDb/AgiGeometry");
01569   else if (GetOption("AgML")  ) mk->SetAlias("VmcGeometry","db/.const/StarDb/AgMLGeometry");
01570   else if (GetOption("VmcGeo")) mk->SetAlias("VmcGeometry","db/.const/StarDb/VmcGeo");
01571   else                          mk->SetAlias("VmcGeometry","db/.const/StarDb/AgiGeometry");
01572   Int_t i;
01573   Int_t Idate=0,Itime=0;
01574 
01575   // First possibility
01576   for (i = 1; i < fNoChainOptions; i++) {
01577     if (fBFC[i].Flag && !strncmp(fBFC[i].Key ,"DbV",3)){
01578       // JL - we use to set timestamp as a chain option (any) starting with dbv and followed
01579       // by an arbitrary set of numbers. The real stamp was taken from the comment.
01580       // This supports this old mode.
01581       gMessMgr->QAInfo() << "StBFChain::SetDbOptions  Found time-stamp " << fBFC[i].Key << " [" << fBFC[i].Comment << "]" << endm;
01582       (void) sscanf(fBFC[i].Comment,"%d/%d",&Idate,&Itime);
01583     }
01584   }
01585 
01586   // If FDate is set and we do not have the old mode, then a dynamic timestamp was used
01587   // Overwrite
01588   if( ! Idate && FDate){
01589     gMessMgr->QAInfo() << "StBFChain::SetDbOptions Switching to user chosen dynamic time-stamp (MaxEntry) "
01590                          << FDate << " " << FTime << endm;
01591     gMessMgr->QAInfo() << "Chain may crash if time-stamp is not validated by db interface" << endm;
01592 
01593     Idate = FDate;
01594     Itime = FTime;
01595   }
01596 
01597   St_db_Maker *db = (St_db_Maker *) mk;
01598   // Startup date over-write
01599   if (FDateS){
01600     gMessMgr->QAInfo() << "StBFChain::SetDbOptions Switching to user chosen dynamic time-stamp (Start)"
01601                        << FDateS << " " << FTimeS << endm;
01602     gMessMgr->QAInfo() << "Chain may crash if time-stamp is not validated by db interface" << endm;
01603 
01604     db->SetDateTime(FDateS,FTimeS);
01605   } else {
01606     if (GetOption("simu")) {
01607       const DbAlias_t *DbAlias = GetDbAliases();
01608       Int_t found = 0;
01609       for (Int_t i = 0; DbAlias[i].tag; i++) {
01610         if (GetOption(DbAlias[i].tag,kFALSE)) {
01611           db->SetDateTime(DbAlias[i].tag);
01612           found = i;
01613           break;
01614         }
01615       }
01616       if (! found) {gMessMgr->QAInfo() << "StBFChain::SetDbOptions() Chain has not set a time-stamp" << endm;}
01617       // Show date settings
01618       gMessMgr->QAInfo() << db->GetName()
01619                          << " Maker set time = "
01620                          << db->GetDateTime().GetDate() << "."
01621                          << db->GetDateTime().GetTime() << endm;
01622       if (GetOption("SIMU") && m_EvtHddr) {
01623         gMessMgr->QAInfo() << GetName() << " Chain set time from  " << db->GetName() << endm;
01624         m_EvtHddr->SetDateTime(db->GetDateTime());
01625       }
01626     }
01627   }
01628 
01629   // MaxEntry over-write - default and global for all realm and detectors
01630   if (Idate) {
01631     db->SetMaxEntryTime(Idate,Itime);
01632     gMessMgr->Info() << "\tSet DataBase max entry time " << Idate << "/" << Itime
01633                      << " for St_db_Maker(\"" << db->GetName() <<"\")" << endm;
01634   } 
01635 #ifdef USE_BFCTIMESTAMP
01636   //
01637   // Now treat the detector specific options
01638   //
01639   TString realm;
01640   for (UInt_t i = 0; i < GTSOptions.size() ; i++){
01641     if ( (GTSOptions[i].Realm).IsNull() ){ realm = "*";}
01642     else {                                 realm = GTSOptions[i].Realm;}
01643 
01644     //LOG_INFO << "DEBUG MORE [" << (GTSOptions[i].Realm).Data() << "]" << endm;
01645     //LOG_INFO << "DEBUG MORE [" << realm.Data() << "]" << endm;
01646 
01647     if ( GTSOptions[i].Type == 1){
01648       db->AddMaxEntryTimeOverride(GTSOptions[i].Date,0,
01649                                   (char *) realm.Data(),
01650                                   (char *) GTSOptions[i].Detector.Data());
01651 
01652       LOG_INFO << "Recovering override stamp " << i << " :: " 
01653                << GTSOptions[i].Detector << ", " << realm << ", "  
01654                << GTSOptions[i].Date     << ", " << GTSOptions[i].Time  << endm;
01655     } else {
01656       LOG_WARN << "Found override type " << GTSOptions[i].Type << " no treated yet" 
01657                << GTSOptions[i].Detector << ", " << realm << ", "  
01658                << GTSOptions[i].Date     << ", " << GTSOptions[i].Time  << endm;
01659     }
01660   }
01661 
01662   //abort();
01663 #endif /*  USE_BFCTIMESTAMP */
01664 
01665   if (!GetOption("fzin")) {
01666     struct Field_t {
01667       const Char_t *name;
01668       Float_t scale;
01669     };
01670     Field_t FieldOptions[5] = {
01671       {"FullMagFNegative", -1.0},
01672       {"FullMagFPositive",  1.0},
01673       {"HalfMagFNegative", -0.5},
01674       {"HalfMagFPositive",  0.5},
01675       {"ZeroMagF",          0.0}
01676     };
01677     Int_t k = -1;
01678     if         (GetOption("FieldON")) {
01679       if       (GetOption("ReverseField"))  k = 0;
01680       else                                  k = 1;
01681     } else if (GetOption("HalfField")) {
01682       if      (GetOption("ReverseField"))   k = 2;
01683       else                                  k = 3;
01684     } else if (GetOption("FieldOff"))       k = 4;
01685     if (k >= 0) {
01686       SetFlavor(FieldOptions[k].name,        "MagFactor");
01687       gMessMgr->QAInfo() << "StBFChain::SetDbOptions SetFlavor(\"" << FieldOptions[k].name
01688                          << "\",\"MagFactor\")" << endm;
01689       if ( gClassTable->GetID("StarMagField") >= 0) {
01690         TString cmd =
01691           Form("if (!StarMagField::Instance()) new StarMagField( 2, %f, kTRUE);",
01692                FieldOptions[k].scale);
01693         ProcessLine(cmd);
01694       }
01695     }
01696   }
01697   if (this == GetTopChain()) {
01698     // Db blacklist (remove black listed system from St_Db_Maker Calibrations configuration)
01699     if (! GetOption("TpcDb")                        ) {mk->SetAttr("blacklist", "tpc");  gMessMgr->QAInfo() << "blacklist tpc" << endm;}
01700     if (! GetOption("SvtDb")||!GetOption("SvtCalDb")) {mk->SetAttr("blacklist", "svt");  gMessMgr->QAInfo() << "blacklist svt" << endm;}
01701     if (! GetOption("SsdDb")||!GetOption("SsdCalDb")) {mk->SetAttr("blacklist", "ssd");  gMessMgr->QAInfo() << "blacklist ssd" << endm;}
01702     if (! GetOption("EemcDb")                       ) {mk->SetAttr("blacklist", "eemc"); gMessMgr->QAInfo() << "blacklist eemc"<< endm;}
01703     if (! GetOption("FmsDb")                        ) {mk->SetAttr("blacklist", "fms");  gMessMgr->QAInfo() << "blacklist fms" << endm;}
01704   } else {// for Embedding chain trigger black list by NoSsdIT and NoSvtIT, could be some problems if you try to run svt or ssd clusters, ...
01705     if (GetOption("NoSvtIt"))                         {mk->SetAttr("blacklist", "svt");  gMessMgr->QAInfo() << "blacklist svt" << endm;}
01706     if (GetOption("NoSsdIt"))                         {mk->SetAttr("blacklist", "ssd");  gMessMgr->QAInfo() << "blacklist ssd" << endm;}
01707   }
01708 }
01709 //_____________________________________________________________________
01711 void StBFChain::SetTreeOptions()
01712 {
01713 
01714   StTreeMaker *treeMk = (StTreeMaker *) GetMaker("outputStream");
01715   if (!treeMk) return;
01716   if (GetOption("EvOut")){
01717     gMessMgr->QAInfo() << "Will Write StEvent out, treeMk->GetFile() = "  << treeMk->GetFile() << endm;
01718     treeMk->IntoBranch("eventBranch","StEvent");
01719     if (GetOption("EvOutOnly")) return;
01720   }
01721   if (! GetOption("nohistos"))     treeMk->SetBranch("histBranch");
01722   if (! GetOption("norunco"))    treeMk->SetBranch("runcoBranch");
01723   if (GetOption("McEvent") && GetOption("McEvOut")){
01724     gMessMgr->QAInfo() << "Will Write StMcEvent out, treeMk->GetFile() = "  << treeMk->GetFile() << endm;
01725     treeMk->IntoBranch("McEventBranch","StMcEvent");
01726   }
01727   if (GetOption("GeantOut")) treeMk->IntoBranch("geantBranch","geant");
01728   if (GetOption("AllEvent")) {
01729     if (GetOption("fzin")   || 
01730         GetOption("ntin")   || 
01731         GetOption("gstar")  || 
01732         GetOption("pythia") || 
01733         GetOption("VMC")    || 
01734         GetOption("PrepEmbed")) {
01735       treeMk->IntoBranch("geantBranch","geant");
01736       treeMk->IntoBranch("geantBranch","geant/.data/particle");
01737       treeMk->IntoBranch("geantBranch","geant/.data/g2t_rch_hit");
01738     }
01739   }
01740 }
01741 //________________________________________________________________________________
01742 Long_t  StBFChain::ProcessLine(const char *line) {
01743   if (! line ||  !strlen(line)) return -1;
01744   if (Debug()) gMessMgr->QAInfo() << "ProcessLine " << line << endm;
01745   TInterpreter::EErrorCode error = TInterpreter::kNoError;
01746   Long_t  res = gInterpreter->ProcessLine(line, &error);
01747   if (error != TInterpreter::kNoError) {
01748     gMessMgr->Error() << "StBFChain::ProcessLine command:" << line << " has failed. Quit job." << endm;
01749     gSystem->Exit(1);
01750   }
01751   return res;
01752 }
01753 //________________________________________________________________________________
01754 TString StBFChain::GetGeometry() const
01755 {
01756   Int_t n = fchainOpt->GetNRows();
01757   for (Int_t i=0;i<n;i++) {
01758     if (!fchainOpt->GetTable()[i].Flag) continue;
01759     TString k(fchainOpt->GetTable()[i].Key);
01760     k.ToLower();
01761     if (k[0]!='y')              continue;
01762     if (k[1]!='2')              continue;
01763     if (k[2] <'0' || k[2]>'9')  continue;
01764     if (k[3] <'0' || k[3]>'9')  continue;
01765     if (k[4] <'0' || k[4]>'9')  continue;
01766     return k;
01767   }
01768   return TString(""); 
01769 }   
01770