00001
00002
00003
00020 #define STAR_LOGGER 1
00021 #include "Stiostream.h"
00022 #include <stdio.h>
00023 #include <stdlib.h>
00024
00025 #include "TSystem.h"
00026 #include "TClass.h"
00027 #include "TROOT.h"
00028 #include "TError.h"
00029 #if 0
00030 #include "THtml.h"
00031 #endif
00032 #include "TH1.h"
00033
00034 #include "TChain.h"
00035 #include "TTree.h"
00036 #include "TList.h"
00037 #include "TClonesArray.h"
00038 #include "TBrowser.h"
00039
00040 #include "StMaker.h"
00041 #include "StChainOpt.h"
00042 #include "TObjectSet.h"
00043 #include "StChain.h"
00044 #include "TTable.h"
00045 #ifdef TMEMSTATinSTAR
00046 #include "TMemStat.h"
00047 #else
00048 #include "StMemStat.h"
00049 #endif
00050 #include "TAttr.h"
00051 #include "StMkDeb.h"
00052 #include "StMessMgr.h"
00053
00054 StMaker *StMaker::fgTopChain = 0;
00055 StMaker *StMaker::fgStChain = 0;
00056 StMaker *StMaker::fgFailedMaker = 0;
00057 StTestMaker *StMaker::fgTestMaker = 0;
00058 Int_t StMaker::fgTallyMaker[kStFatal+1] = {0,0,0,0,0};
00059 Int_t MaxWarnings = 26;
00060
00061 class MyObjectSet : public TObjectSet
00062 {
00063 typedef void (*MyDelete_t)(void *p);
00064 public:
00065 MyObjectSet(const char *name,void *p,void *d):TObjectSet(name,(TObject*)p,0)
00066 {fD=(MyDelete_t)d;}
00067 ~MyObjectSet(){ (*fD)(GetObject());}
00068 private:
00069 MyDelete_t fD;
00070 };
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183 static const DbAlias_t fDbAlias[] = {
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200 {"y1h", 20000614,175430, "year2000", ""},
00201 {"y2000", 20000614,175430, "year2000", ""},
00202
00203 {"y2001", 20010501, 0, "year2001", ""},
00204
00205
00206
00207
00208 {"y2001n", 20010615, 0, "year2001", ""},
00209
00210 {"y2003", 20021115, 0, "year2003", ""},
00211
00212 {"y2003x", 20021115, 1, "y2003x", ""},
00213
00214
00215
00216 {"y2004", 20031120, 0, "y2004", ""},
00217
00218 {"y2004y", 20031120, 2, "y2004y", ""},
00219 {"y2004a", 20031120, 3, "y2004a", ""},
00220
00221 {"y2004c", 20031125, 0, "y2004c", ""},
00222
00223
00224 {"y2005x", 20041030, 0, "y2005x", ""},
00225 {"y2005", 20041030, 0, "y2005", ""},
00226 {"y2005b", 20041101, 0, "y2005b", ""},
00227
00228
00229
00230 {"y2005f", 20041201, 3, "y2005f", "y2005e + SSD5/CALB2"},
00231 {"y2005g", 20041201, 4, "y2005g", "y2005f + SVT dead material"},
00232 {"y2005h", 20041201, 5, "y2005h", "y2005g + TPC2009 "},
00233 {"y2005i", 20041201, 6, "y2005i", "y2005h + ECALv6 "},
00234
00235
00236 {"y2006", 20051201, 0, "y2006", "base for y2006: y2005e+fixed TPC plane"},
00237
00238
00239 {"y2006c", 20051201, 3, "y2006c", "y2006+new FPD+SSD5/CALB2+noPMD"},
00240 {"y2006g", 20051201, 4, "y2006g", "y2006c + SVT dead material"},
00241 {"y2006h", 20051201, 5, "y2006g", "y2006g + ecal6+tpc2009(JW)"},
00242
00243
00244 {"y2007", 20061105, 0, "y2007", "base geometry for y2007"},
00245
00246 {"y2007g", 20061105, 4, "y2007g", "y2007b + SVT dead material"},
00247 {"y2007h", 20061105, 5, "y2007h", "y2007g + TPC2009"},
00248
00249
00250 {"y2008", 20071101, 0, "y2008", "base for y2008: SVT/SSD out, cone is lost"},
00251 {"y2008a", 20071101, 1, "y2008a", "base for y2008: SVT/SSD out, cone in separate SCON"},
00252 {"y2008b", 20071101, 2, "y2008b", "base for y2008: SVT/SSD out, latest TPC ECAL CALB"},
00253 {"y2008c", 20071101, 3, "y2008c", "TOF fix & TPCE redused"},
00254 {"y2008d", 20071101, 4, "y2008d", "Honey sandwich fix"},
00255 {"y2008e", 20071101, 5, "y2008e", "LOW_EM central calorimter cuts"},
00256
00257
00258 {"y2009", 20081215, 0, "y2009", "based on TGeomanager of YF"},
00259
00260 {"y2009a", 20081215, 1, "y2009a", "y2009+ecalgeo6(JW)"},
00261 {"y2009b", 20081215, 2, "y2009b", "y2009+ecalgeo6(JW) w/ old tracking cuts in eemc."},
00262 {"y2009c", 20081215, 3, "y2009c", "TOF fix & TPCE redused"},
00263 {"y2009d", 20081215, 4, "y2009d", "Honey sandwich fix"},
00264 {"y2010", 20091215, 0, "y2010", "y2009+full BTOF"},
00265 {"y2010a", 20091215, 1, "y2010a", "y2010 production tag"},
00266 {"y2010b", 20091215, 2, "y2010b", "TOF fix & TPCE redused"},
00267 {"y2010c", 20091215, 3, "y2010c", "Honey sandwich fix"},
00268 {"y2011", 20101215, 0, "y2011", "y2011 TOF fix & TPCE redused & honey"},
00269 {"y2011a", 20101215, 1, "y2011a", "y2011a == y2011 now "},
00270 {"y2012", 20111215, 0, "y2012", "y2012 Very preliminary"},
00271
00272
00273
00274
00275
00276
00277 {"upgr01", 20190101, 4, "upgr01", ""},
00278 {"upgr02", 20190101, 5, "upgr02", ""},
00279 {"upgr03", 20190101, 6, "upgr03", ""},
00280 {"upgr04", 20190101, 7, "upgr04", ""},
00281 {"upgr05", 20190101, 8, "upgr05", ""},
00282 {"upgr06", 20190101, 9, "upgr06", ""},
00283 {"upgr07", 20190101, 10, "upgr07", ""},
00284 {"upgr08", 20190101, 11, "upgr08", ""},
00285 {"upgr09", 20190101, 12, "upgr09", ""},
00286 {"upgr10", 20190101, 13, "upgr10", ""},
00287 {"upgr11", 20190101, 14, "upgr11", ""},
00288 {"upgr12", 20190101, 15, "upgr12", ""},
00289 {"upgr13", 20190101, 16, "upgr13", ""},
00290 {"upgr14", 20190101, 17, "upgr14", ""},
00291 {"upgr15", 20190101, 18, "upgr15", ""},
00292 {"upgr16", 20190101, 19, "upgr16", ""},
00293 {"upgr17", 20190101, 20, "upgr17", ""},
00294 {"upgr16a", 20190101, 21, "upgr16a", ""},
00295
00296 {"simpletpc", 20200102, 16, "simpletpc",""},
00297 {"upgr20", 20200102, 17, "upgr20", "y2007 + one TOF"},
00298 {"upgr21", 20200102, 18, "upgr21", "y2007 + full TOF"},
00299 {"dev13", 20200102, 19, "dev13", "dev geo for 2013"},
00300 {"devE", 20200102, 20, "devE", "dev geo for Erick"},
00301 {0, 0, 0, 0, 0}
00302 };
00303
00304
00305 #define TURN_LOGGER(maker) \
00306 if (!fLogger) fLogger = StMessMgr::Instance(ClassName()); \
00307 StTurnLogger SaveRestoreLogger(maker->GetLogger());
00308
00309
00310 ClassImp(StMaker)
00311
00312 static void doPs(const Char_t *who,const Char_t *where);
00313
00314
00315 StMaker::StMaker(const Char_t *name,const Char_t *):TDataSet(name,".maker"),
00316 m_Mode(0), m_Number(0), m_LastRun(-3),
00317 m_DebugLevel(0),m_MakeReturn(0),fStatus(0),
00318 fLogger(0),fLoggerHold(0)
00319 {
00320 m_Attr=0;
00321 m_Inputs = 0;
00322 if (!fgStChain) {
00323 fgTopChain = fgStChain = this;
00324 gROOT->GetListOfBrowsables()->Add(this,GetName());
00325 AddData(0,".make");
00326 } else {
00327 fgStChain->AddData(this,".make");
00328 }
00329 m_DataSet = new TObjectSet(".data") ;Add(m_DataSet);
00330 m_ConstSet = new TObjectSet(".const");Add(m_ConstSet);
00331 m_GarbSet = new TObjectSet(".garb" );Add(m_GarbSet);
00332 m_Inputs = new TObjectSet(".aliases" );Add(m_Inputs);
00333 m_Runco = new TObjectSet(".runco" );Add(m_Runco);
00334 AddHist(0); m_Histograms = GetHistList();
00335 ::doPs(GetName(),"constructor");
00336 m_Timer.Stop();
00337 fMemStatMake = 0;
00338 fMemStatClear = 0;
00339 memset(fTallyMaker,0,(kStFatal+1)*sizeof(Int_t));
00340 SetActive();
00341 StMkDeb::Register(this);
00342 }
00343
00344
00345 void StMaker::AddMaker(StMaker *mk)
00346 {
00347 TDataSet *dotmk = Find(".make");
00348 if (!dotmk) dotmk = new TDataSet(".make",this);
00349 mk->Shunt(dotmk);
00350 }
00351
00352 StMaker::~StMaker()
00353 {
00354 if (fgTopChain == this) fgTopChain = 0;
00355 if (fgStChain == this) fgStChain = 0;
00356 delete fMemStatMake; fMemStatMake = 0;
00357 delete fMemStatClear; fMemStatClear = 0;
00358 TDataSet *ds = this;
00359 Cleanup(ds);
00360 StMkDeb::Cancel(this);
00361
00362 }
00363
00364 const Char_t *StMaker::GetName() const
00365 {
00366 static Int_t occ = 0;
00367 const Char_t *name = TNamed::GetName();
00368 if (name && *name ) return name;
00369 TString ts(ClassName());
00370 ts+="#"; ts+=(occ++);
00371 ((TNamed*)this)->SetName(ts.Data());
00372 return GetName();
00373 }
00374
00375 void StMaker::SetNumber(Int_t number)
00376 {
00377 StMaker *par = GetParentMaker();
00378 if (par) par->SetNumber(number);
00379 m_Number = number;
00380 SetIventNumber(number);
00381 }
00382
00383 Int_t StMaker::GetNumber() const
00384 {
00385 StMaker *par = GetParentMaker();
00386 if (par) return par->GetNumber();
00387 return m_Number;
00388 }
00389
00390 StMaker *StMaker::GetParentMaker() const
00391 {
00392 TDataSet *par = GetParent(); if (!par) return 0;
00393 return (StMaker*)par->GetParent();
00394 }
00395
00396 StMaker *StMaker::GetMaker(const Char_t *mkname)
00397 {
00398 TString path(".make/"); path+=mkname;
00399 return (StMaker*)GetDataSet((const char*)path);
00400 }
00401
00402 TObject *StMaker::GetDirObj(const Char_t *dir) const
00403 {
00404 TObjectSet *h = (TObjectSet*)Find(dir);
00405 if (!h) return 0;
00406 return h->GetObject();
00407 }
00408
00409 void StMaker::SetDirObj(TObject *obj,const Char_t *dir)
00410 {
00411 TObjectSet *set = (TObjectSet *)Find(dir);
00412 if (!set) {
00413 set = new TObjectSet(dir); Add(set);}
00414 set->SetObject(obj);
00415 }
00416
00417 TDataSet *StMaker::AddObj(TObject *obj,const Char_t *dir,int owner)
00418 {
00419 assert (dir[0]=='.');
00420 if (strcmp(".hist",dir)==0) {
00421 AddHist((TH1*)obj); return 0;
00422 } else if (strcmp(".data",dir)==0) {
00423 return ToWhiteBoard(obj->GetName(),obj,owner);
00424
00425 } else if (strcmp(".const",dir)==0) {
00426 return ToWhiteConst(obj->GetName(),obj);
00427 } else { assert(0 && "No .data || .const ||.hist");}
00428 }
00429
00430 void StMaker::AddHist(TH1 *h,const Char_t *)
00431 {
00432 TObjectSet *set = (TObjectSet*)Find(".hist");
00433 if (!set) {
00434 set = new TObjectSet(".hist"); Add(set);}
00435
00436 TList *list = (TList *)set->GetObject();
00437 if (!list) {
00438 list = new TList(); set->SetObject(list);}
00439
00440 if (!h) return ;
00441 if(!list->FindObject(h)) list->Add(h);
00442 if (h->InheritsFrom(TH1::Class())) h->SetDirectory(0);
00443 }
00444
00445 void StMaker::AddRunco (Double_t par,const Char_t *name,const Char_t *comment)
00446 {
00447 assert (name && name && comment[0]);
00448
00449 TDataSet *dp = new TDataSet(name,m_Runco);
00450 TString ts(" // "); ts += comment;
00451 Char_t buf[40];
00452 sprintf(buf,"%f",par);
00453 ts.Replace(0,0,buf);
00454 dp->SetTitle((const char*)ts);
00455 }
00456
00457
00458
00459 void StMaker::AddData(TDataSet *ds, const Char_t *dir)
00460 {
00461 assert (dir); assert(dir[0]=='.');
00462 TDataSet *set = Find(dir);
00463 if (!set) {
00464 set = new TObjectSet(dir); Add(set);}
00465 if (!ds) return;
00466 Int_t dotMake = (strcmp(dir,".make")==0);
00467 Int_t inhMake = ds->InheritsFrom(StMaker::Class());
00468 if (dotMake!=inhMake) {
00469 Error("AddData","Add to %s is NOT allowed: %s.%s\n"
00470 ,dir,ds->ClassName(),ds->GetName());
00471 return;}
00472
00473 TList *tl = set->GetList();
00474 if (!tl || !tl->FindObject(ds->GetName())) {
00475 set->Add(ds);
00476 } else {
00477 Error("AddData","Data %s/%s is not added. ***Name clash***",dir,ds->GetName());
00478 return;
00479 }
00480 return;
00481 }
00482
00483 TDataSet *StMaker::GetData(const Char_t *name, const Char_t *dir) const
00484 {
00485 TDataSet *set = Find(dir);
00486 if (!set) return 0;
00487 return set->Find(name);
00488 }
00489
00490 TDataSet *StMaker::ToWhiteBoard(const Char_t *name, void *dat)
00491 {
00492 TObjectSet *envelop = new TObjectSet(name,(TObject*)dat,0);
00493 envelop->SetTitle(".envelop");
00494 AddData(envelop,".data");
00495 return envelop;
00496 }
00497
00498 TDataSet *StMaker::ToWhiteBoard(const Char_t *name, void *dat, void *owner)
00499 {
00500 MyObjectSet *envelop = new MyObjectSet(name,dat,owner);
00501 envelop->SetTitle(".envelop");
00502 AddData(envelop,".data");
00503 return envelop;
00504 }
00505
00506 TDataSet *StMaker::ToWhiteBoard(const Char_t *name, TObject *dat, Int_t owner)
00507 {
00508 TObjectSet *envelop = new TObjectSet(name,dat,owner);
00509 envelop->SetTitle(".envelop");
00510 AddData(envelop,".data");
00511 return envelop;
00512 }
00513
00514 TDataSet *StMaker::ToWhiteConst(const Char_t *name, void *dat)
00515 {
00516 TObjectSet *envelop = new TObjectSet(name,(TObject*)dat,0);
00517 envelop->SetTitle(".envelop");
00518 AddData(envelop,".const");
00519 return envelop;
00520 }
00521
00522 TDataSet *StMaker::ToWhiteConst(const Char_t *name, TObject *dat)
00523 {
00524 TObjectSet *envelop = new TObjectSet(name,dat,0);
00525 envelop->SetTitle(".envelop");
00526 AddData(envelop,".const");
00527 return envelop;
00528 }
00529
00530 TDataSet *StMaker::WhiteBoard(const Char_t *name, void *v) const
00531 {
00532 void **dat = (void **)v;
00533 *dat = 0;
00534 TDataSet *ds = GetDataSet(name);
00535 if (!ds) return 0;
00536 if (strcmp(".envelop",ds->GetTitle())==0) {*dat = ds->GetObject();}
00537 else {*dat = ds ;}
00538 return ds;
00539 }
00540
00541 void StMaker::AddAlias(const Char_t *log, const Char_t *act,const Char_t *dir)
00542 {
00543 TDataSet *ali = new TDataSet(log);
00544 ali->SetTitle(act);
00545 AddData(ali,dir);
00546 }
00547
00548 void StMaker::SetNotify(const Char_t *about, StMaker *mk)
00549 {
00550 TDataSet *ali = new TObjectSet(about,mk,0);
00551 AddData(ali,".notify");
00552 }
00553
00554 void StMaker::NotifyEm(const Char_t *about, const void *ptr)
00555 {
00556
00557 TURN_LOGGER(this);
00558
00559 TDataSet *set = Find(".notify");
00560 if (!set) return;
00561 TDataSetIter iter(set);
00562 TObjectSet *os=0;
00563 while((os=(TObjectSet*)iter())) {
00564 if (strcmp(about,os->GetName())) continue;
00565 StMaker *mk=(StMaker*)os->GetObject();
00566 if (!mk) continue;
00567 TURN_LOGGER(mk);
00568 mk->NotifyMe(about,ptr);
00569 }
00570
00571 }
00572
00573 void StMaker::SetAlias(const Char_t *log, const Char_t *act,const Char_t *dir)
00574 {
00575 TDataSet *ali = GetData(log,dir);
00576 if (ali) {
00577 if (!strcmp(act,ali->GetTitle())) return;
00578 } else {
00579 ali = new TDataSet(log); AddData(ali,dir);
00580 }
00581 ali->SetTitle(act);
00582
00583 if (GetDebug()) {
00584 #ifdef STAR_LOGGER
00585 LOG_DEBUG << "<" << ClassName() << "(" << GetName() << "::SetAlias> "
00586 << log << " = " << act << endm;
00587 #else
00588 printf("<%s(%s)::SetAlias> %s = %s\n",ClassName(),GetName(),log,act);
00589 #endif
00590 }
00591 }
00592
00593 void StMaker::SetOutput(const Char_t *log,TDataSet *ds)
00594 {
00595 Int_t idx;
00596 const Char_t *logname = log;
00597 if (!logname || !logname[0]) logname = ds->GetName();
00598 TString act = ds->Path();
00599 while ((idx=act.Index(".make/"))>=0) act.Replace(0,idx+6,"");
00600 SetOutput(logname,act);
00601 }
00602
00603
00604 void StMaker::SetOutputAll(TDataSet *ds, Int_t level)
00605 {
00606 TDataSet *set;
00607 TDataSetIter next(ds,level);
00608 while ((set = next())) SetOutput(set);
00609 }
00610
00611
00612 TList *StMaker::GetMakeList() const
00613 { TDataSet *ds = Find(".make");
00614 if (!ds) return 0;
00615 return ds->GetList();
00616 }
00617
00618 TString StMaker::GetAlias(const Char_t *log,const Char_t *dir) const
00619 {
00620 Int_t nspn = strcspn(log," /");
00621 TString act(log,nspn);
00622 TDataSet *in = GetData(act,dir);
00623 act ="";
00624 if (in) {act = in->GetTitle(); act += log+nspn;}
00625 return act;
00626 }
00627
00628 TDataSet *StMaker::FindDataSet(const Char_t *logInput,
00629 const StMaker *uppMk,
00630 const StMaker *dowMk) const
00631 {
00632 TURN_LOGGER(this);
00633
00634 TDataSetIter nextMk(0);
00635 TString actInput,findString,tmp;
00636 TDataSet *dataset=0,*dir;
00637 StMaker *parent,*mk;
00638 Int_t icol,islas;
00639
00640 for (int itry=0;itry<2;itry++) {
00641 actInput = (!itry)? GetInput(logInput).Data():logInput;
00642 dataset = 0;
00643 if (actInput.IsNull()) continue;
00644
00645 if (actInput.Contains(".")) dataset = Find(actInput);
00646 if (dataset) goto FOUND;
00647
00648 if (actInput==GetName()) dataset = m_DataSet;
00649 if (dataset) goto FOUND;
00650
00651
00652
00653
00654 icol = actInput.Index(":");
00655 if (icol>=0) {
00656 tmp = actInput;
00657 tmp.Replace(0,0,".make/"); icol +=6;
00658 tmp.Replace(icol,1,"/.data/");
00659 dataset = Find((const char*)tmp);
00660 if (dataset) goto FOUND;
00661 dataset = Find((const char*)tmp+6);
00662 if (dataset) goto FOUND;
00663 tmp.Replace(icol,7,"/.const/");
00664 dataset = Find((const char*)tmp);
00665 if (dataset) goto FOUND;
00666 dataset = Find((const char*)tmp+6);
00667 if (dataset) goto FOUND;
00668 goto DOWN;
00669 }
00670
00671 if (m_DataSet) {
00672 islas = actInput.Index("/");
00673 if (islas>0) {
00674 tmp.Replace(0,999,actInput,islas);
00675 if (tmp == GetName()) {
00676 tmp = actInput;
00677 tmp.Replace(0,islas+1,"");
00678 dataset = m_DataSet->Find(tmp);
00679 if (dataset) goto FOUND;
00680 dataset = m_ConstSet->Find(tmp);
00681 if (dataset) goto FOUND;
00682 }
00683 }
00684
00685 dataset = m_DataSet->Find(actInput);
00686 if (dataset) goto FOUND;
00687 dataset = m_ConstSet->Find(actInput);
00688 if (dataset) goto FOUND;
00689 }
00690
00691
00692 DOWN: if (!(dir = Find(".make"))) goto UP;
00693
00694 nextMk.Reset(dir);
00695 while ((mk = (StMaker* )nextMk()))
00696 {
00697 if (mk==dowMk) continue;
00698 dataset = mk->FindDataSet(actInput,this,0);
00699 if (dataset) goto FOUND;
00700 }
00701
00702
00703 UP: if (uppMk) return 0;
00704
00705 parent = GetMaker(this); if (!parent) goto NOTFOUND;
00706 dataset = parent->FindDataSet(actInput,0,this);
00707 if (dataset) goto FOUND;
00708
00709
00710 NOTFOUND:
00711 if (!dowMk && GetDebug()>1)
00712 if ((MaxWarnings--) > 0) Warning("GetDataSet"," \"%s\" Not Found ***\n",(const char*)actInput);
00713 dataset = 0; continue;
00714
00715
00716 FOUND: if (uppMk || dowMk) return dataset;
00717 if (GetDebug()<2) return dataset;
00718 printf("Remark: <%s::%s> DataSet %s FOUND in %s\n"
00719 ,ClassName(),"GetDataSet",logInput,(const char*)dataset->Path());
00720 break;
00721 }
00722 return dataset;
00723
00724 }
00725
00726 TDataSet *StMaker::GetDataBase(const Char_t *logInput,const TDatime *td)
00727 {
00728 TURN_LOGGER(this);
00729 TDataSet *ds = 0;
00730 StMaker *mk = GetMakerInheritsFrom("St_db_Maker");
00731 if (mk) ds = mk->GetDataBase(logInput,td);
00732 return ds;
00733 }
00734
00735 StMaker *StMaker::GetMakerInheritsFrom (const Char_t *mktype) const
00736 {
00737 TURN_LOGGER(this);
00738 StMaker *mk = 0;
00739 StMakerIter mkiter(this);
00740 while ((mk = mkiter.NextMaker())) {
00741 if (mk->InheritsFrom(mktype)) break;
00742 }
00743 return mk;
00744 }
00745
00746 void StMaker::SetFlavor(const Char_t *flav,const Char_t *tabname)
00747 {
00748 StMaker *mk = GetMakerInheritsFrom("St_db_Maker");
00749 if (mk) mk->SetFlavor(flav,tabname);
00750 }
00751
00752 void StMaker::Clear(Option_t *option)
00753 {
00754 TURN_LOGGER(this);
00755
00756 m_MakeReturn = 0;
00757 if(option){};
00758 if (m_DataSet) m_DataSet->Delete();
00759
00760
00761
00762 TIter next(GetMakeList(),kIterBackward);
00763 StMaker *maker;
00764 Int_t curr = StMkDeb::GetCurrent();
00765 while ((maker = (StMaker* )next())) {
00766 assert(maker->TestBIT(kCleaBeg)==0);
00767 StMkDeb::SetCurrent(maker,3);
00768 maker->SetBIT(kCleaBeg);
00769 maker->StartTimer();
00770 if (maker->fMemStatClear && GetNumber()>20) maker->fMemStatClear->Start();
00771 TURN_LOGGER(maker);
00772 maker->Clear(option);
00773 if (maker->fMemStatClear && GetNumber()>20) maker->fMemStatClear->Stop();
00774 maker->StopTimer();
00775 maker->ResetBIT(kCleaBeg);
00776 StMkDeb::SetCurrent(curr);
00777 }
00778 TCollection::EmptyGarbageCollection();
00779 doPs(GetName(),"Clear");
00780
00781
00782
00783
00784 return;
00785
00786 }
00787
00788 Int_t StMaker::Init()
00789 {
00790 TURN_LOGGER(this);
00791 TObject *objLast,*objHist;
00792 TList *tl = GetMakeList();
00793 if (!tl) return kStOK;
00794
00795 TIter nextMaker(tl);
00796 StMaker *maker;
00797 Int_t curr = StMkDeb::GetCurrent();
00798 while ((maker = (StMaker* )nextMaker())) {
00799
00800 TURN_LOGGER(maker);
00801
00802 gROOT->cd();
00803 objLast = gDirectory->GetList()->Last();
00804
00805
00806
00807 assert( !( maker->TestBIT(kInitBeg) || maker->TestBIT(kInitEnd) ));
00808 StMkDeb::SetCurrent(maker,1);
00809 maker->SetBIT(kInitBeg);
00810 maker->StartTimer();
00811
00812 if (GetDebug()) {
00813 LOG_DEBUG << "*** Call << " << maker->ClassName() << ":Init() ***" << endm;
00814 }
00815 TString ts1(maker->ClassName()); ts1+="("; ts1+=maker->GetName(); ts1+=")::";
00816 TString ts2 = ts1; ts2+="Make ";
00817 maker->fMemStatMake = new StMemStat(ts2);
00818 ts2 = ts1; ts2+="Clear";
00819 maker->fMemStatClear = new StMemStat(ts2);
00820
00821 if ( maker->Init()) {
00822 LOG_ERROR << " Maker "<< maker->GetName() << " failed in Init" << endm;
00823 return kStErr;
00824 }
00825 maker->StopTimer();
00826
00827
00828
00829 gROOT->cd();
00830 TIter nextHist(gDirectory->GetList());
00831 Int_t ready = !objLast;
00832 while((objHist=nextHist())) {
00833 if (!ready && objHist!=objLast) continue;
00834 ready = 1999;
00835 if (objHist==objLast) continue;
00836 if (!objHist->InheritsFrom("TH1")) continue;
00837
00838
00839 ((TH1*)objHist)->SetDirectory(0);
00840 maker->AddHist((TH1*)objHist);
00841 }
00842 ::doPs(maker->GetName(),"Init");
00843 maker->ResetBIT(kInitBeg);
00844 maker->SetBIT (kInitEnd);
00845 StMkDeb::SetCurrent(curr);
00846 }
00847 return kStOK;
00848 }
00849
00850 void StMaker::StartMaker()
00851 {
00852
00853 if (!fLoggerHold) fLoggerHold = new StTurnLogger(GetLogger());
00854 if (!m_DataSet) {
00855 m_DataSet = Find(".data");
00856 if (!m_DataSet) {m_DataSet = new TObjectSet(".data"); Add(m_DataSet);}
00857 }
00858
00859 if (fMemStatMake && GetNumber()>20) fMemStatMake->Start();
00860
00861
00862
00863 StartTimer();
00864 }
00865
00866 void StMaker::EndMaker(Int_t ierr)
00867 {
00868 SetMakeReturn(ierr);
00869 fgTallyMaker[ierr%10]++;
00870 fTallyMaker [ierr%10]++;
00871 if (m_DataSet) m_DataSet->Pass(ClearDS,0);
00872 if (m_GarbSet) m_GarbSet->Delete();
00873 ::doPs(GetName(),"EndMaker");
00874
00875
00876 if (fMemStatMake && GetNumber()>20) fMemStatMake->Stop();
00877
00878 StopTimer();
00879
00880 if (fLoggerHold) { delete fLoggerHold; fLoggerHold = 0;}
00881
00882 }
00883
00884
00889 Int_t StMaker::Finish()
00890 {
00891 if (TestBIT(kFiniEnd)) return 1;
00892 TURN_LOGGER(this);
00893
00894 Int_t nerr = 0;
00895 Int_t run = GetRunNumber();
00896 if (run>-1) FinishRun(run);
00897
00898 TIter next(GetMakeList(),kIterBackward);
00899 StMaker *maker;
00900 Double_t totalCpuTime = 0;
00901 Double_t totalRealTime = 0;
00902 while ((maker = (StMaker* )next()))
00903 {
00904 totalCpuTime += maker->CpuTime();
00905 totalRealTime += maker->RealTime();
00906 }
00907
00908
00909 if (!totalRealTime) totalRealTime = 1;
00910 if (!totalCpuTime ) totalCpuTime = 1;
00911
00912 next.Reset();
00913 Int_t fst=1;
00914 while ((maker = (StMaker*)next())) {
00915 #ifdef STAR_LOGGER
00916 TURN_LOGGER(maker);
00917
00918 if (fst) {
00919 fst=0;
00920 LOG_QA <<
00921 Form("=================================================================================") << endm;
00922 LOG_QA <<
00923 Form("QAInfo:Chain %20s::%-20s Ast =%6.2f Cpu =%6.2f "
00924 ,ClassName(),GetName(),totalRealTime,totalCpuTime) << endm;
00925 }
00926 LOG_QA <<
00927 Form("QAInfo:Maker %20s::%-20s Ast =%6.2f(%4.1f%%) Cpu =%6.2f(%4.1f%%) "
00928 ,maker->ClassName(),maker->GetName()
00929 ,maker->RealTime()
00930 ,100*maker->RealTime()/totalRealTime
00931 ,maker->CpuTime()
00932 ,100*maker->CpuTime()/totalCpuTime) << endm;
00933
00934 static const Char_t *ee[]={"nStOK","nStWarn","nStEOF","nStErr","nStFatal"};
00935 TString tail("");
00936 for (Int_t j=0;j<=kStFatal;j++) {
00937 if (fTallyMaker[j]) tail += Form(" %s=%d",ee[j],fTallyMaker[j]);}
00938 if (tail != "") LOG_QA << (const Char_t *) tail << endm;
00939 #else
00940 if (fst) {
00941 fst=0;
00942 Printf("=================================================================================\n");
00943 Printf("QAInfo: Chain %20s::%-20s Ast =%6.2f Cpu =%6.2f "
00944 ,ClassName(),GetName(),totalRealTime,totalCpuTime);
00945 }
00946 printf("QAInfo: Maker %20s::%-20s Ast =%6.2f(%4.1f%%) Cpu =%6.2f(%4.1f%%) "
00947 ,maker->ClassName(),maker->GetName()
00948 ,maker->RealTime()
00949 ,100*maker->RealTime()/totalRealTime
00950 ,maker->CpuTime()
00951 ,100*maker->CpuTime()/totalCpuTime);
00952
00953 static const Char_t *ee[]={"nStOK","nStWarn","nStEOF","nStErr","nStFatal"};
00954 for (Int_t j=0;j<=kStFatal;j++) {
00955 if (fTallyMaker[j]) printf(" %s=%d",ee[j],fTallyMaker[j]);}
00956 printf("\n");
00957 #endif
00958 }
00959
00960 next.Reset();
00961 Int_t curr = StMkDeb::GetCurrent();
00962 while ((maker = (StMaker* )next()))
00963 {
00964 TURN_LOGGER(maker);
00965
00966 if (maker->TestBIT(kFiniEnd)) {
00967 maker->Warning("Finish","maker %s.%s Finished twice"
00968 ,maker->GetName(),maker->ClassName());
00969 continue;}
00970 StMkDeb::SetCurrent(maker,4);
00971 maker->SetBIT(kFiniBeg);
00972 if ( maker->Finish() ) nerr++;
00973 maker->ResetBIT(kFiniBeg);
00974 maker->SetBIT (kFiniEnd);
00975 StMkDeb::SetCurrent(curr);
00976 }
00977 if (!GetParent()) {
00978 #ifdef STAR_LOGGER
00979 LOG_INFO << "--------------Error Codes-------------------------" << endm;
00980 LOG_INFO << " nStOK nStWarn nStEOF nStErr nStFatal" << endm;
00981 TString tail("");
00982 for( Int_t i=0; i<=kStFatal; i++) tail += Form("%10d",fgTallyMaker[i]);
00983 if (tail != "")
00984 LOG_INFO << (const Char_t *)tail << endm;
00985 LOG_INFO << "--------------------------------------------------" << endm;
00986 #else
00987 printf("\n--------------Error Codes-------------------------\n");
00988 printf(" nStOK nStWarn nStEOF nStErr nStFatal \n");
00989 for( Int_t i=0; i<=kStFatal; i++) printf("%10d",fgTallyMaker[i]);
00990 printf("\n--------------------------------------------------\n");
00991 #endif
00992 }
00993
00994
00995 if (GetParent()==0) StMemStat::Summary();
00996
00997 return nerr;
00998 }
00999
01000
01011 Int_t StMaker::Make()
01012 {
01013 TURN_LOGGER(this);
01014
01015
01016 Int_t ret,run=-1,oldrun;
01017 TList *tl = GetMakeList();
01018 if (!tl) return kStOK;
01019 StEvtHddr *hd = GetEvtHddr();
01020 TIter nextMaker(tl);
01021 StMaker *maker;
01022 fgFailedMaker = 0;
01023 Int_t curr = StMkDeb::GetCurrent();
01024 while ((maker = (StMaker* )nextMaker())) {
01025 if (!maker->IsActive()) continue;
01026 TURN_LOGGER(maker);
01027 assert(!maker->TestBIT(kMakeBeg));
01028 maker->SetBIT(kMakeBeg);
01029 StMkDeb::SetCurrent(maker,2);
01030 oldrun = maker->m_LastRun;
01031 if (hd && hd->GetRunNumber()!=oldrun) {
01032 if (oldrun>-1) maker->FinishRun(oldrun);
01033 run = hd->GetRunNumber();
01034 if (Debug() && this == fgStChain && m_LastRun!=run){
01035 m_LastRun = run;
01036 #ifdef STAR_LOGGER
01037 LOG_INFO << " +++ New RunNumber found=" << run << " (previous = " << oldrun << ")" << endm;
01038 #else
01039 printf(" +++ New RunNumber found=%d (previous = %d)\n",run,oldrun);
01040 #endif
01041 hd->Print();
01042 }
01043 maker->InitRun(run);
01044 maker->m_LastRun=run;
01045 }
01046
01047 if (fgTestMaker) { fgTestMaker->SetNext(maker); fgTestMaker->Make();}
01048
01049 maker->StartMaker();
01050 ret = maker->Make();
01051 assert((ret%10)>=0 && (ret%10)<=kStFatal);
01052 maker->EndMaker(ret);
01053
01054 if (Debug() || ret) {
01055 #ifdef STAR_LOGGER
01056 LOG_INFO << "*** " << maker->ClassName() << "::Make() == "
01057 << RetCodeAsString(ret) << "(" << ret << ") ***"
01058 << endm;
01059 #else
01060 printf("*** %s::Make() == %s(%d) ***\n"
01061 ,maker->ClassName(),RetCodeAsString(ret),ret);
01062 #endif
01063 }
01064 maker->ResetBIT(kMakeBeg);
01065 StMkDeb::SetCurrent(curr);
01066 if ((ret%10)>kStWarn) {
01067 if ((ret%10) != kStERR) return ret;
01069 fgFailedMaker = maker;
01070 if (maker->IAttr(".Privilege")) return ret;
01071 continue;
01072 }
01073
01074 }
01075 return kStOK;
01076 }
01077
01078 void StMaker::FatalErr(Int_t Ierr, const Char_t *com)
01079 {
01080 #ifdef STAR_LOGGER
01081 LOG_QA << Form("QAInfo:%s::Fatal: Error %d %s",GetName(),Ierr,com) << endm;
01082 LOG_FATAL << Form("QAInfo:%s::Fatal: Error %d %s",GetName(),Ierr,com) << endm;
01083 #else
01084 printf("QAInfo:%s::Fatal: Error %d %s\n",GetName(),Ierr,com);
01085 #endif
01086 StMaker *parent = (StMaker *)GetParent();
01087 if (parent) ((StMaker*)parent)->FatalErr(Ierr,com);
01088 #ifndef STAR_LOGGER
01089 fflush(stdout);
01090 #endif
01091 }
01092
01093 StMaker *StMaker::GetMaker(const TDataSet *ds)
01094 {
01095 const TDataSet *par = ds;
01096 while (par && (par = par->GetParent()) && strncmp(".maker",par->GetTitle(),6)) {}
01097 return ( StMaker*) par;
01098 }
01099
01100
01106 EDataSetPass StMaker::ClearDS (TDataSet* ds,void * )
01107 {
01108 if (ds->InheritsFrom(TTable::Class())){
01109 TTable *table = (TTable *)ds;
01110 Int_t setSize = table->GetTableSize();
01111 table->ReAllocate();
01112 memset((void *)table->At(table->GetNRows()),127,table->GetRowSize());
01113
01114 if (setSize && table->GetTableSize() == 0){
01115 table->Warning("ReAllocate"," Table %s has purged from %d to %d "
01116 ,table->GetName(),setSize,(Int_t) table->GetTableSize());
01117 }
01118 table->NaN();
01119 }
01120 return kContinue;
01121 }
01122
01123 void StMaker::PrintInfo()
01124 {
01125 const char *cvs = GetCVS();
01126 const char *built = 0;
01127 if (cvs && cvs[0]) built = strstr(cvs,"built");
01128 else cvs = "No CVS tag was defined";
01129 #ifdef STAR_LOGGER
01130 if (built > cvs) { LOG_QA << Form("QAInfo:%-20s %s from %.*s",ClassName(),built,built-cvs,cvs)<< endm; }
01131 else { LOG_QA << Form("QAInfo:%-20s from %s",ClassName(),cvs) << endm; }
01132 #else
01133 if (built > cvs) printf("QAInfo:%-20s %s from %.*s\n",ClassName(),built,built-cvs,cvs);
01134 else printf("QAInfo:%-20s from %s\n",ClassName(),cvs);
01135 #endif
01136
01137 TIter next(GetMakeList());
01138 StMaker *maker;
01139 while ((maker = (StMaker* )next())) {
01140 maker->PrintInfo();
01141 }
01142 }
01143
01144
01146 Int_t StMaker::GetIventNumber() const
01147 {
01148 StEvtHddr *hd = GetEvtHddr();
01149 return hd->GetIventNumber();
01150 }
01151
01152
01153 void StMaker::SetIventNumber(Int_t iv)
01154 {
01155 StEvtHddr *hd = GetEvtHddr();
01156 hd->SetIventNumber(iv);
01157 }
01158
01159 Int_t StMaker::GetEventNumber() const
01160 {
01161 StEvtHddr *hd = GetEvtHddr();
01162 return hd->GetEventNumber();
01163 }
01164
01165
01167 Int_t StMaker::GetRunNumber() const
01168 {
01169 StEvtHddr *hd = GetEvtHddr();
01170 return hd->GetRunNumber();
01171 }
01172
01173 StMaker *StMaker::GetParentChain() const
01174 {
01175 const StMaker *mk = GetParentMaker();
01176 while(mk && !mk->IsChain()) {mk = mk->GetParentMaker();}
01177 return (StMaker*) mk;
01178 }
01179
01180 const TDatime &StMaker::GetDateTime() const
01181 {
01182 const StEvtHddr *hd = GetEvtHddr();
01183 return hd->GetDateTime();
01184 }
01185
01186 const TDatime &StMaker::GetDBTime() const
01187 {
01188 StMaker *mk = GetMakerInheritsFrom("St_db_Maker");
01189 assert(mk);
01190 return mk->GetDateTime();
01191 }
01192
01193
01194
01195 Int_t StMaker::GetDate() const {return GetDateTime().GetDate();}
01196
01197 Int_t StMaker::GetTime() const {return GetDateTime().GetTime();}
01198
01199 const Char_t *StMaker::GetEventType() const
01200 {
01201 StEvtHddr *hd = GetEvtHddr();
01202 return hd->GetEventType();
01203 }
01204
01205
01211 void StMaker::PrintTimer(Option_t *option)
01212 {
01213 if(option){};
01214 #ifdef STAR_LOGGER
01215 LOG_QA << Form("QAInfo:%-20s: Real Time = %6.2f seconds Cpu Time = %6.2f seconds, Entries = %d",GetName()
01216 ,m_Timer.RealTime(),m_Timer.CpuTime(),m_Timer.Counter()) << endm;
01217 #else
01218 Printf("QAInfo:%-20s: Real Time = %6.2f seconds Cpu Time = %6.2f seconds, Entries = %d",GetName()
01219 ,m_Timer.RealTime(),m_Timer.CpuTime(),m_Timer.Counter());
01220 #endif
01221 }
01222 void StMaker::lsMakers(const StMaker *top)
01223 {
01224 TDataSetIter iter((TDataSet*)top,20);
01225 Int_t N=0;
01226 for(const TDataSet *mk=top;mk;mk = iter.Next()) {
01227 if(strncmp(".maker",mk->GetTitle(),6)!=0) continue;
01228 Int_t l=iter.GetDepth();
01229 N++;
01230 Char_t space[20]; memset(space,' ',sizeof(space));space[l]=0;
01231
01232 printf("%3d(%d) - %s %s::%s\n",N,l/2,space,mk->ClassName(),mk->GetName());
01233 }
01234 }
01235
01236
01237
01238 #if 0
01239
01240 static void MakeAssociatedClassList(const TObject *obj, const Char_t *classDir=0)
01241 {
01258 if (!obj) return;
01259 const Char_t *thisDir = classDir;
01260 if (thisDir == 0 || thisDir[0] == 0)
01261 thisDir = gSystem->DirName(obj->IsA()->GetImplFileName());
01262 const Char_t *thisClassName = obj->IsA()->GetName();
01263
01264
01265 void *dirhandle = 0;
01266 TString className;
01267 if ( (dirhandle = gSystem->OpenDirectory(thisDir)) )
01268 {
01269 const Char_t *n = 0;
01270 ifstream headerFile;
01271 Char_t inBuffer[128] = {0};
01272 Int_t lBuf = sizeof(inBuffer);
01273 Char_t *nextSym = inBuffer;
01274 Int_t status = 0;
01275 const Char_t keyWord[] = "class";
01276 const Int_t lKeyWord = sizeof(keyWord);
01277
01278 while ( (n = gSystem->GetDirEntry(dirhandle)) ) {
01279
01280 if (!strstr(n,".h") || strstr(n,"Cint.h") ) continue;
01281 Char_t *fullFile = gSystem->ConcatFileName(thisDir,n);
01282 headerFile.open(fullFile);
01283 if (headerFile.fail()) continue;
01284 while (headerFile.getline(inBuffer,lBuf) && !headerFile.eof()) {
01285 nextSym = inBuffer;
01286 if (status==0) status = 1;
01287 do {
01288
01289
01290
01291
01292
01293
01294
01295
01296
01297
01298
01299
01300
01301
01302
01303
01304
01305
01306
01307
01308
01309
01310
01311
01312 switch (status) {
01313 case 1: {
01314 if (*nextSym == ' ' || *nextSym == '\t') break;
01315 const Char_t *classFound = strstr(nextSym,keyWord);
01316 if ( classFound && classFound == nextSym){
01317 status = 2;
01318 nextSym += lKeyWord-2;
01319 }
01320 else status = 0;
01321 break;
01322 }
01323 case 2: status = 0;
01324 if (*nextSym == ' ' || *nextSym == '\t') status = 3;
01325 break;
01326 case 3:
01327 if (*nextSym == ' ' || *nextSym == '\t') break;
01328 status = 0;
01329 if (isalpha(*nextSym)) {
01330 className = *nextSym;
01331 nextSym++;
01332 while (isalnum(*nextSym) || *nextSym == '_' ) {
01333 className += *nextSym++; status = 4;
01334 }
01335 nextSym--;
01336 }
01337 break;
01338 case 4:
01339 if (*nextSym == ' ' || *nextSym == '\t') break;
01340 status = 0;
01341 if (*nextSym == 0 || *nextSym == ':' || *nextSym == '{' ||
01342 ( *nextSym == '/' &&
01343 (*(nextSym+1) == '/' || *(nextSym+1) == '*')
01344 )
01345 ) status = 5;
01346 break;
01347 case 5:
01348 if (strcmp(thisClassName,className.Data())) {
01349 printf(" MakeDoc: %s\n", className.Data());
01350 TClass *cl = gROOT->GetClass(className.Data());
01351 if (cl && !cl->InheritsFrom("StMaker") ) {
01352 gHtml->MakeClass((Text_t *)className.Data());
01353 }
01354 }
01355 default: status = 1;
01356 break;
01357 };
01358 } while (*(++nextSym) && status );
01359 }
01360 headerFile.close();
01361 delete [] fullFile;
01362 }
01363 }
01364 }
01365
01366 void StMaker::MakeDoc(const TString &stardir,const TString &outdir, Bool_t baseClasses)
01367 {
01397
01398 TString STAR = stardir;
01399 TString delim = ":";
01400
01401
01402 if (strcmp(gSystem->GetName(),"WinNT") == 0 ) {
01403
01404 delim = ";";
01405 STAR.ReplaceAll("$(afs)","//sol/afs");
01406 }
01407 else
01408 STAR.ReplaceAll("$(afs)","/afs");
01409
01410 TString classname = IsA()->GetName();
01411
01412 THtml thisHtml;
01413
01414
01415
01416
01417
01418
01419
01420 const Char_t *source[] = {"StRoot/St_base" , "TDataSet" , "St_base"
01421 ,"StRoot/StChain" , "StMaker" , "StChain"
01422
01423 ,"StRoot/StarClassLibrary", "" , ""
01424 ,"StRoot/StEvent" , "StEvent" , "StEvent"
01425 ,"StRoot/St_TLA_Maker" , "St_TLA_Maker", "St_TLA_Maker"
01426 ,"include" , "" , ""
01427 ,"include/tables" , "" , ""
01428 };
01429
01430 const Int_t lsource = sizeof(source)/sizeof(const Char_t *);
01431
01432 TString classDir = gSystem->DirName(IsA()->GetImplFileName());
01433 TString lookup = STAR;
01434 lookup += delim;
01435
01436 lookup += STAR;
01437 lookup += "/";
01438 lookup += classDir;
01439 lookup += delim;
01440
01441 lookup += STAR;
01442 lookup += "/StRoot/";
01443 lookup += classname;
01444
01445
01446
01447 Int_t i = 0;
01448 for (i=0;i<lsource-3;i+=3) {
01449 lookup += delim;
01450 lookup += STAR;
01451 lookup += "/";
01452 lookup += source[i];
01453
01454 const Char_t *cl = source[i+1];
01455 const Char_t *so = source[i+2];
01456 if (cl && cl[0] && so && so[0] && !gROOT->GetClass(cl))
01457 {
01458 if (gSystem->Load(so))
01459 printf(" Failed to load the share library %s for class %s\n",so,cl);
01460 }
01461 }
01462
01463
01464
01465
01466
01467 lookup.ReplaceAll("//StRoot/","/StRoot/");
01468 thisHtml.SetSourceDir(lookup);
01469
01470 TString odir = outdir;
01471
01472 gSystem->ExpandPathName(odir);
01473 thisHtml.SetOutputDir(odir);
01474
01475
01476
01477 Char_t *classes[] = {
01478 "St_Module", "TTable"
01479 ,"TDataSet", "TDataSetIter", "TFileSet"
01480 ,"StMaker", "StChain"
01481 ,"table_head_st"
01482 };
01483 Int_t nclass = sizeof(classes)/4;
01484
01485 TString header = "$STAF/inc/table_header.h";
01486
01487 gSystem->ExpandPathName(header);
01488 header.ReplaceAll("//inc/","/inc/");
01489 gROOT->LoadMacro(header);
01490
01491 TClass header1("table_head_st",1,"table_header.h","table_header.h");
01492
01493
01494 static Bool_t makeAllAtOnce = kTRUE;
01495 if (makeAllAtOnce && baseClasses) {
01496 makeAllAtOnce = kFALSE;
01497
01498 for (i=0;i<nclass;i++) thisHtml.MakeClass(classes[i]);
01499 thisHtml.MakeIndex();
01500
01501 }
01502
01503 if (baseClasses) {gHtml= &thisHtml; MakeAssociatedClassList(this, classDir.Data()); }
01504
01505 printf(" Making html for <%s>\n",classname.Data());
01506 thisHtml.MakeClass((Char_t *)classname.Data());
01507
01508
01509 TList *tl = GetMakeList();
01510 if (tl) {
01511 TIter nextMaker(tl);
01512 StMaker *maker;
01513 while ((maker = (StMaker* )nextMaker()))
01514 maker->MakeDoc(stardir,outdir,kFALSE);
01515 }
01516 }
01517 #endif
01518
01519 static void doPs(const Char_t *who, const Char_t *where)
01520 {
01521 static const Char_t *ps =0;
01522 if (!ps) {
01523
01524 ps = gSystem->Getenv("StarEndMakerShell");
01525 ps = (ps) ? "yes" : "";
01526 }
01527 if (!ps[0]) return;
01528 #ifdef STAR_LOGGER_BUG
01529 LOG_QA << Form("QAInfo: doPs for %20s:%12s \t",who,where);
01530 #else
01531 printf("QAInfo: doPs for %20s:%12s \t",who,where);
01532 #endif
01533 StMemStat::PrintMem(0);
01534 #if 0
01535 #ifdef STAR_LOGGER_BUG
01536 LOG_QA << endm;
01537 #else
01538 printf("\n");
01539 #endif
01540 #endif
01541 }
01542
01543
01544 void StMaker::Streamer(TBuffer &)
01545 { LOG_FATAL << Form("%s::Streamer - attempt to write %s",ClassName(),GetName()) << endm;
01546 assert(0);
01547 }
01548
01549 StMaker *StMaker::New(const Char_t *classname, const Char_t *name, void *title)
01550 {
01551
01552
01553 StMaker *maker = 0;
01554 if (classname)
01555 {
01556 TClass *cl = gROOT->GetClass(classname);
01557 if (cl) {
01558 maker = (StMaker *)cl->New();
01559 if (maker) {
01560 if (name && strlen(name)) maker->SetName(name);
01561 if (title) maker->SetTitle((Char_t *) title);
01562 }
01563 }
01564 }
01565 return maker;
01566 }
01567
01568 void StMaker::SetDebug(Int_t l)
01569 {
01570 m_DebugLevel = l;
01571 StMessMgr *log = GetLogger();
01572 if (log) log->SetLevel(m_DebugLevel);
01573 }
01574
01575
01576 void StMaker::SetDEBUG(Int_t l)
01577 {
01578 SetDebug(l);
01579
01580 TList *tl = GetMakeList();
01581 if (!tl) return;
01582
01583 TIter nextMaker(tl);
01584 StMaker *maker;
01585 while ((maker = (StMaker* )nextMaker())) maker->SetDEBUG(l);
01586 }
01587
01601 Int_t StMaker::SetAttr(const Char_t *key, const Char_t *val, const Char_t *to)
01602 {
01603
01604 Int_t count = 0;
01605 TString tk(key);tk.ToLower();tk.ReplaceAll(" ","");tk.ReplaceAll("\t","");
01606 if (!val) val ="";
01607 TString tv(val);tv = tv.Strip(TString::kBoth) ;tv.ReplaceAll("\t","");
01608 if (!to || !to[0]) to =".";
01609 TString tt(to ); tt.ReplaceAll(" ","");tt.ReplaceAll("\t","");
01610 TString tn(tt),tc("*");
01611 Int_t idx = tt.Index("::");
01612 if (idx>=0) {
01613 tn.Replace(0 ,idx+2,""); if (!tn.Length()) tn = "*";
01614 tc=tt;
01615 tc.Replace(idx,999 ,""); if (!tc.Length()) tc = "*";
01616 }
01617 Int_t act=0;
01618 if (tn==".") {act = 1;}
01619 else if (tn=="*") {act = 5;}
01620 else if (tn==GetName()) {act = 1;}
01621 else {act = 4;}
01622
01623 if (tc=="*") {act |=2;}
01624 else if (InheritsFrom(tc.Data())) {act |=2;}
01625
01626 TString fullName(ClassName()); fullName+="::"; fullName+=GetName();
01627
01628 if ((act&3)==3) {
01629 count++;
01630 if (tk == ".call") {
01631 TString command("(("); command += ClassName(); command+="*)";
01632 Char_t buf[20]; sprintf(buf,"%p",(void*)this);
01633 command +=buf; command +=")->"; command+=tv;command+=";";
01634 gROOT->ProcessLineFast(command.Data(),0);}
01635 else {
01636 if (!m_Attr) m_Attr = new TAttr(GetName());
01637 m_Attr->SetAttr(tk.Data(), tv.Data());
01638 if (Debug() > 1) {
01639 LOG_DEBUG << Form("SetAttr(\"%s\",\"%s\",\"%s\")",tk.Data(),tv.Data(),fullName.Data()) << endm;
01640 }
01641 }
01642 }
01643 if (!(act&4)) return count;
01644
01645
01646 TList *tl = GetMakeList();
01647 if (!tl) return count;
01648
01649 TIter nextMaker(tl);
01650 StMaker *maker;
01651 while ((maker = (StMaker*)nextMaker())) count += maker->SetAttr(tk.Data(),tv.Data(),to);
01652 return count;
01653 }
01654 Int_t StMaker::SetAttr(const StMaker *mk)
01655 {
01656 if (!mk) return 0;
01657 if (!mk->m_Attr) return 0;
01658 if (!m_Attr) m_Attr = new TAttr;
01659 return m_Attr->SetAttr(mk->m_Attr);
01660 }
01661
01662 Int_t StMaker::SetAttr(const Char_t *key, Int_t val, const Char_t *to)
01663 {
01664 TString ts; ts+=val; return SetAttr(key, ts.Data(), to);
01665 }
01666
01667 Int_t StMaker::SetAttr(const Char_t *key, UInt_t val, const Char_t *to)
01668 {
01669 TString ts; ts+=val; return SetAttr(key, ts.Data(), to);
01670 }
01671
01672 Int_t StMaker::SetAttr(const Char_t *key, Double_t val, const Char_t *to)
01673 {
01674 TString ts; ts+=val; return SetAttr(key, ts.Data(), to);
01675 }
01676
01677
01678 const Char_t *StMaker::SAttr(const Char_t *key) const
01679 {
01680 if (!m_Attr) return "";
01681 return m_Attr->SAttr(key);
01682 }
01683
01684 Int_t StMaker::IAttr(const Char_t *key) const
01685 {
01686 if (!m_Attr) return 0;
01687 return m_Attr->IAttr(key);
01688 }
01689
01690 UInt_t StMaker::UAttr(const Char_t *key) const
01691 {
01692 if (!m_Attr) return 0;
01693 return m_Attr->UAttr(key);
01694 }
01695
01696 Double_t StMaker::DAttr(const Char_t *key) const
01697 {
01698 if (!m_Attr) return 0;
01699 return m_Attr->DAttr(key);
01700 }
01701
01702 void StMaker::PrintAttr() const
01703 {
01704 if (!m_Attr) return ;
01705 m_Attr->PrintAttr();
01706 }
01707
01708
01709 Int_t StMaker::InitRun (Int_t runumber) {return 0;}
01710
01711 Int_t StMaker::FinishRun(Int_t runumber) {return 0;}
01712
01713
01714 Int_t StMaker::Cleanup(TDataSet *&ds)
01715 {
01716
01717 if (!ds->TObject::TestBit(TObject::kNotDeleted)) {ds=0;return 0;}
01718 TSeqCollection *list = ds->TDataSet::GetCollection();
01719 if (!list) return 0;
01720 assert(list->IsA()==TList::Class() || list->IsA()==TObjArray::Class());
01721
01722 Int_t kount = 0;
01723 TIter iter(list);
01724 TDataSet *son;
01725 Int_t num = list->Capacity();
01726 for (Int_t i=0; i<num; i++) {
01727 son = (TDataSet*)iter.Next();
01728 if (!son) continue;
01729 if (!son->TObject::TestBit(TObject::kNotDeleted)) {list->Remove(son); continue;}
01730 TDataSet* par = son->TDataSet::GetParent();
01731 if ( par != ds) {list->Remove(son); continue;}
01732 assert (son->InheritsFrom(TDataSet::Class()));
01733 if (son->InheritsFrom(StMaker::Class())) continue;
01734 kount = Cleanup(son) + 1;
01735 }
01736 if (!ds->InheritsFrom(TObjectSet::Class())) return kount;
01737 TObjectSet *os = (TObjectSet*)ds;
01738 TObject *to = os->GetObject();
01739 if (!to) return kount;
01740 if (!to->TObject::TestBit(TObject::kNotDeleted)) {
01741 os->DoOwner(0); os->SetObject(0); return kount+1;}
01742 if (!os->IsOwner()) {os->SetObject(0); return kount;}
01743 if (!to->InheritsFrom(TDataSet::Class())) return kount;
01744 TDataSet *t = (TDataSet*)to;
01745 return kount + Cleanup(t);
01746 }
01747
01748 StEvtHddr *StMaker::GetEvtHddr() const
01749 {
01750 StEvtHddr *hddr = (StEvtHddr*)GetDataSet("EvtHddr");
01751 if(!hddr) hddr = new StEvtHddr((TDataSet*)m_ConstSet);
01752 return hddr;
01753 }
01754
01755 void StMaker::SetDateTime(Int_t idat,Int_t itim)
01756 {
01757 StEvtHddr *hddr = GetEvtHddr();
01758 hddr->SetDateTime(idat,itim);
01759 }
01760
01761
01762 const Char_t *StMaker::RetCodeAsString(Int_t kode)
01763 {
01764 static const Char_t *retCodes[] = {
01765 "StOK" ,"StWarn" ,"StEOF" ,"StERR" ,"StFATAL" ,0,0,0,0,0,
01766 "StOK!" ,"StWarn!" ,"StEOF!" ,"StSKIP" ,"StSTOP" ,0,0,0,0,0,
01767 "StOK!!","StWarn!!","StEOF!!","StSKIP!","StSTOP!" ,0,0,0,0,0};
01768
01769 assert(kode>=0);
01770 if (kode>=30) kode = kode%10+20;
01771 const Char_t *res = retCodes[kode];
01772 if (!res) res = "StUNKNOWN";
01773 return res;
01774
01775 }
01776
01777
01778 StMakerIter::StMakerIter(const StMaker *mk,Int_t secondary)
01779 {
01780 fState = 0;
01781 fMaker = mk;
01782 fMakerIter = 0;
01783 fIter = new TDataSetIter(fMaker->Find(".make"));
01784 fItWas = (TDataSet*)(-1);
01785 fSecond = secondary;
01786
01787 }
01788
01789 StMakerIter::~StMakerIter()
01790 {
01791 delete fIter; fIter = 0;
01792 delete fMakerIter; fMakerIter = 0;
01793 fMaker=0; fState = 0;
01794 }
01795
01796 StMaker *StMakerIter::NextMaker()
01797 {
01798 TDataSet *ds;
01799 if (!fMaker) return 0;
01800
01801 AGAIN: switch (fState) {
01802
01803 case 0:
01804 ds = fIter->Next();
01805 if (ds == fItWas) goto AGAIN;
01806 fState = 2; if (!ds) goto AGAIN;
01807 fState = 1;
01808 delete fMakerIter;
01809 fMakerIter = new StMakerIter((StMaker*)ds,1);
01810 goto AGAIN;
01811
01812 case 1:
01813 ds = fMakerIter->NextMaker();
01814 if (ds) return (StMaker* )ds;
01815 fState = 0; goto AGAIN;
01816
01817 case 2:
01818 delete fMakerIter; fMakerIter=0;
01819 delete fIter; fIter = 0;
01820 fState = 3;
01821 return (StMaker*)fMaker;
01822
01823 case 3:
01824 if (fSecond) return 0;
01825 TDataSet *par = fMaker->GetParent();
01826 fItWas = fMaker; fMaker = 0;
01827 if (!par) return 0;
01828 if (strcmp(".make",par->GetName())) return 0;
01829 fMaker = (StMaker* )par->GetParent();
01830 if (!fMaker) return 0;
01831 delete fIter; fIter = new TDataSetIter(par);
01832 fState = 0; goto AGAIN;
01833 }
01834 assert(0); return 0;
01835 }
01836
01837 Int_t StMaker::AliasDate(const Char_t *alias)
01838
01839 {
01840
01841 Int_t n = strcspn(alias," ."); if (n<3) return 0;
01842 Int_t i;
01843 for (i=0;fDbAlias[i].tag && strncmp(alias,fDbAlias[i].tag,n);i++) {}
01844 return fDbAlias[i].date;
01845 }
01846
01847 Int_t StMaker::AliasTime(const Char_t *alias)
01848
01849 {
01850
01851 Int_t n = strcspn(alias," ."); if (n<3) return 0;
01852 Int_t i;
01853 for (i=0;fDbAlias[i].tag && strncmp(alias,fDbAlias[i].tag,n);i++) {}
01854 return fDbAlias[i].time;
01855 }
01856
01857 const Char_t *StMaker::AliasGeometry(const Char_t *alias)
01858
01859 {
01860
01861 Int_t n = strcspn(alias," ."); if (n<3) return 0;
01862 Int_t i;
01863 for (i=0;fDbAlias[i].tag && strncmp(alias,fDbAlias[i].tag,n);i++) {}
01864 return fDbAlias[i].geometry;
01865 }
01866
01867 const DbAlias_t *StMaker::GetDbAliases() {return fDbAlias;}
01868
01869 const StChainOpt *StMaker::GetChainOpt() const
01870 {
01871 StMaker *mk = GetMaker(this);
01872 if (!mk) return 0;
01873 return mk->GetChainOpt();
01874 }
01875
01876 TFile *StMaker::GetTFile() const
01877 {
01878 const static Char_t *mktype = "StBFChain";
01879 StMaker *mk = 0;
01880 if (this->InheritsFrom(mktype)) {mk = (StMaker *) this;}
01881 else {
01882 StMakerIter mkiter(GetChain());
01883 while ((mk = mkiter.NextMaker())) {
01884 if (mk->InheritsFrom(mktype)) {
01885 const StChainOpt *opt = mk->GetChainOpt();
01886 if (!opt) continue;
01887 if (opt->GetTFile()) break;
01888 }
01889 }
01890 }
01891 if (! mk) return 0;
01892 const StChainOpt *opt = mk->GetChainOpt();
01893 if (!opt) return 0;
01894 return opt->GetTFile();
01895 }
01896
01897 ClassImp(StTestMaker)
01898
01899 StTestMaker::StTestMaker(const Char_t *name):StMaker(name)
01900 {
01901 fNext=0; fLast=0;
01902 if (fgStChain == this ) {fgStChain=0;}
01903 else {Shunt() ;}
01904 fgTestMaker = this;
01905 }
01906
01907 void StTestMaker::SetNext(StMaker *mk)
01908 {
01909 fLast=fNext;
01910 fNext=mk;
01911 }
01912
01913 void StTestMaker::Print(const Char_t *) const
01914 {
01915 #ifdef STAR_LOGGER
01916 if (fLast) { LOG_INFO << Form("%s: Last Maker %s::%s(%p)",
01917 ClassName(),fLast->ClassName(),fLast->GetName(),(void*)fLast)<< endm;}
01918 if (fNext) { LOG_INFO << Form("%s: Next Maker %s::%s(%p)",
01919 ClassName(),fNext->ClassName(),fNext->GetName(),(void*)fNext) << endm;}
01920 #else
01921 if (fLast) printf("%s: Last Maker %s::%s(%p)\n",
01922 ClassName(),fLast->ClassName(),fLast->GetName(),(void*)fLast);
01923 if (fNext) printf("%s: Next Maker %s::%s(%p)\n",
01924 ClassName(),fNext->ClassName(),fNext->GetName(),(void*)fNext);
01925 #endif
01926 }
01927
01928 Int_t StMaker::Skip(Int_t NoEventSkip)
01929 {
01930 TURN_LOGGER(this);
01931
01932 TList *tl = GetMakeList();
01933 if (!tl) return kStOK;
01934 TIter nextMaker(tl);
01935 StMaker *maker;
01936 fgFailedMaker = 0;
01937 while ((maker = (StMaker* )nextMaker())) {
01938 if (!maker->IsActive()) continue;
01939 maker->Skip(NoEventSkip);
01940 }
01941 return kStOK;
01942 }
01943
01944
01945
01946
01947
01948
01949
01950
01951
01952
01953
01954
01955
01956
01957
01958
01959
01960
01961
01962
01963
01964
01965
01966
01967
01968
01969
01970
01971
01972
01973
01974
01975
01976
01977
01978
01979
01980
01981
01982
01983
01984
01985
01986
01987
01988
01989
01990
01991
01992
01993
01994
01995
01996
01997
01998
01999
02000
02001
02002
02003
02004
02005
02006
02007
02008
02009
02010
02011
02012
02013
02014
02015
02016
02017
02018
02019
02020
02021
02022
02023
02024
02025
02026
02027
02028
02029
02030
02031
02032
02033
02034
02035
02036
02037
02038
02039
02040
02041
02042
02043
02044
02045
02046
02047
02048
02049
02050
02051
02052
02053
02054
02055
02056
02057
02058
02059
02060
02061
02062
02063
02064
02065
02066
02067
02068
02069
02070
02071
02072
02073
02074
02075
02076
02077
02078
02079
02080
02081
02082
02083
02084
02085
02086
02087
02088
02089
02090
02091
02092
02093
02094
02095
02096
02097
02098
02099
02100
02101
02102
02103
02104
02105
02106
02107
02108
02109
02110
02111
02112
02113
02114
02115
02116
02117
02118
02119
02120
02121
02122
02123
02124
02125
02126
02127
02128
02129
02130
02131
02132
02133
02134
02135
02136
02137
02138
02139
02140
02141
02142
02143
02144
02145
02146
02147
02148
02149
02150
02151
02152
02153
02154
02155
02156
02157
02158
02159
02160
02161
02162
02163
02164
02165
02166
02167
02168
02169
02170
02171
02172
02173
02174
02175
02176
02177
02178
02179
02180
02181
02182
02183
02184
02185
02186
02187
02188
02189
02190
02191
02192
02193
02194
02195
02196
02197
02198
02199
02200
02201
02202
02203
02204
02205
02206
02207
02208
02209
02210
02211
02212
02213
02214
02215
02216
02217
02218
02219
02220
02221
02222
02223
02224
02225
02226
02227
02228
02229
02230
02231
02232
02233
02234
02235
02236
02237
02238
02239
02240
02241
02242
02243
02244
02245
02246
02247
02248
02249
02250
02251
02252
02253
02254
02255
02256
02257
02258
02259
02260
02261
02262
02263
02264
02265
02266
02267
02268
02269
02270
02271
02272
02273
02274
02275
02276
02277
02278
02279
02280
02281
02282
02283
02284
02285
02286
02287
02288
02289
02290
02291
02292
02293
02294
02295
02296
02297
02298
02299
02300
02301
02302
02303
02304
02305
02306
02307
02308
02309
02310
02311
02312
02313
02314
02315
02316
02317
02318
02319
02320
02321
02322
02323
02324
02325
02326
02327
02328
02329
02330
02331
02332
02333
02334
02335
02336
02337
02338
02339
02340
02341
02342
02343
02344
02345
02346
02347
02348
02349
02350
02351
02352
02353
02354
02355
02356
02357
02358
02359
02360
02361
02362
02363
02364
02365
02366
02367
02368
02369
02370
02371
02372
02373
02374
02375
02376
02377
02378
02379
02380
02381
02382
02383
02384
02385
02386
02387
02388
02389
02390
02391
02392
02393
02394
02395
02396
02397
02398
02399
02400
02401
02402
02403
02404
02405
02406
02407
02408
02409
02410
02411
02412
02413
02414
02415
02416
02417
02418
02419
02420
02421
02422
02423
02424
02425
02426
02427
02428
02429
02430
02431
02432
02433
02434
02435
02436
02437
02438
02439
02440
02441
02442
02443
02444
02445
02446
02447
02448
02449
02450
02451
02452
02453
02454
02455
02456
02457
02458
02459
02460
02461
02462
02463
02464
02465
02466
02467
02468
02469
02470
02471
02472
02473
02474
02475
02476
02477
02478
02479
02480
02481
02482
02483
02484
02485
02486
02487
02488
02489
02490
02491
02492
02493
02494
02495
02496
02497
02498
02499
02500
02501
02502
02503
02504
02505
02506
02507
02508
02509
02510
02511
02512
02513
02514
02515
02516
02517
02518
02519
02520
02521
02522
02523
02524
02525
02526
02527
02528
02529
02530
02531
02532
02533
02534
02535
02536
02537
02538
02539
02540
02541
02542
02543
02544
02545
02546
02547
02548
02549
02550
02551
02552
02553
02554
02555
02556
02557
02558
02559
02560
02561
02562
02563
02564
02565
02566
02567
02568
02569
02570
02571
02572
02573
02574
02575
02576
02577
02578
02579
02580
02581
02582
02583
02584
02585
02586
02587
02588
02589
02590
02591
02592
02593
02594
02595
02596
02597
02598
02599
02600
02601
02602
02603
02604
02605
02606
02607
02608
02609
02610
02611
02612
02613
02614
02615
02616
02617
02618
02619
02620
02621
02622
02623
02624
02625
02626
02627
02628
02629
02630
02631
02632
02633
02634
02635
02636
02637
02638
02639
02640
02641
02642
02643
02644
02645
