Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

TGo4AnalysisStepManager.cxx

Go to the documentation of this file.
00001 //-------------------------------------------------------------
00002 //        Go4 Release Package v3.04-01 (build 30401)
00003 //                      28-November-2008
00004 //---------------------------------------------------------------
00005 //   The GSI Online Offline Object Oriented (Go4) Project
00006 //   Experiment Data Processing at EE department, GSI
00007 //---------------------------------------------------------------
00008 //
00009 //Copyright (C) 2000- Gesellschaft f. Schwerionenforschung, GSI
00010 //                    Planckstr. 1, 64291 Darmstadt, Germany
00011 //Contact:            http://go4.gsi.de
00012 //----------------------------------------------------------------
00013 //This software can be used under the license agreements as stated
00014 //in Go4License.txt file which is part of the distribution.
00015 //----------------------------------------------------------------
00016 #include "TGo4AnalysisStepManager.h"
00017 
00018 #include "Riostream.h"
00019 
00020 #include "TObjArray.h"
00021 #include "TFolder.h"
00022 #include "TList.h"
00023 #include "TThread.h"
00024 #include "TH1.h"
00025 #include "TTree.h"
00026 
00027 #include "TGo4Log.h"
00028 #include "TGo4LockGuard.h"
00029 #include "TGo4Condition.h"
00030 #include "TGo4MainTree.h"
00031 #include "TGo4AnalysisStep.h"
00032 #include "TGo4TreeStructure.h"
00033 
00034 #include "TGo4AnalysisStepException.h"
00035 #include "TGo4AnalysisStatus.h"
00036 #include "TGo4AnalysisImp.h"
00037 #include "TGo4EventErrorException.h"
00038 #include "TGo4EventProcessor.h"
00039 #include "TGo4EventTimeoutException.h"
00040 #include "TGo4CompositeEvent.h"
00041 #include "TGo4BackStore.h"
00042 
00043 TGo4AnalysisStepManager::TGo4AnalysisStepManager(const char* name) :
00044    TNamed(name,"The Go4 Analysis Step Manager"),
00045    fiFirstStepIndex(0),
00046    fiLastStepIndex(0),
00047    fiCurrentStepIndex(0),
00048    fbStepCheckingMode(kTRUE),
00049    fxCurrentStep(0),
00050    fxOutputEvent(0)
00051 {
00052    fxStepList = new TObjArray;
00053    fxStepMutex = new TMutex(kTRUE);
00054    fxStepIterator = fxStepList->MakeIterator();
00055 }
00056 
00057 TGo4AnalysisStepManager::~TGo4AnalysisStepManager()
00058 {
00059    delete fxStepMutex;
00060    delete fxStepIterator;
00061    delete fxStepList;
00062 }
00063 
00064 
00065 
00066 void TGo4AnalysisStepManager::CloseAnalysis()
00067 {
00068 TRACE((14,"TGo4AnalysisStepManager::CloseAnalysis()",__LINE__, __FILE__));
00069    //
00070    TGo4Analysis::Instance()->Message(0,"Analysis Step Manager  --  Closing Analysis Steps...");
00071    TGo4AnalysisStep* step=0;
00072       {
00073       //TGo4LockGuard   listguard(fxStepMutex);
00074          fxStepIterator->Reset();
00075          while((step= dynamic_cast<TGo4AnalysisStep*>( fxStepIterator->Next() ) ) !=0)
00076             {
00077                step->Close();
00078             }
00079       } // lock guard
00080    TGo4Analysis::Instance()->Message(-1,"Analysis Step Manager  --  Analysis Steps were closed.");
00081 }
00082 
00083 Bool_t TGo4AnalysisStepManager::InitEventClasses()
00084 {
00085 TRACE((14,"TGo4AnalysisStepManager::InitEventClasses()",__LINE__, __FILE__));
00086    //
00087    Bool_t rev=kTRUE;
00088    Bool_t firststepfound=kFALSE;
00089    Bool_t laststepfound=kFALSE;
00090    TGo4Analysis::Instance()->Message(0,"Analysis StepManager --  Initializing EventClasses...");
00091       TGo4AnalysisStep* step=0;
00092          {
00093          //TGo4LockGuard  listguard(fxStepMutex);
00094             fxStepIterator->Reset();
00095             fiCurrentStepIndex=0;
00096             //cout <<"IIIIIIII InitEventClasses with checking: "<<IsStepChecking() << endl;
00097             while((step= dynamic_cast<TGo4AnalysisStep*>( fxStepIterator->Next() ) ) !=0)
00098                {
00099                   step->InitEventClasses();
00100                   // last enabled step:
00101                   // for step checking off, take last step in list
00102                   if(firststepfound)
00103                      {
00104                         if((IsStepChecking() && step->IsProcessEnabled())
00105                               || !IsStepChecking())
00106                            {
00107                               fiLastStepIndex=fiCurrentStepIndex;
00108                               laststepfound=kTRUE;
00109                            }
00110                      }
00111                   // first enabled step is first step of chain:
00112                   // except for step checking is off, then take first
00113                   if(!firststepfound)
00114                      {
00115                         if((IsStepChecking() && step->IsProcessEnabled())
00116                               || !IsStepChecking())
00117                            {
00118                               fiFirstStepIndex=fiCurrentStepIndex;
00119                               firststepfound=kTRUE;
00120                            }
00121                      }
00122                   fiCurrentStepIndex++;
00123                }
00124             if(!laststepfound) fiLastStepIndex=fiFirstStepIndex; // for single step analysis
00125 
00126             if(IsStepChecking())
00127             {
00128                 // Test for steps valid:
00129                fxStepIterator->Reset();
00130                fiCurrentStepIndex=0;
00131                while((step= dynamic_cast<TGo4AnalysisStep*>( fxStepIterator->Next() ) ) !=0)
00132                   {
00133                         //cout << "match testing of analysis step " << step->GetName() << endl;
00134                         if(! step->IsMatchingPrevious() )
00135                            {
00136                               rev=kFALSE;
00137                               TGo4Analysis::Instance()->Message(3,"!!! AnalysisStepManager  --  ERROR: step %s is not matching previous !!!",
00138                                        step->GetName() );
00139                               break;
00140                            }
00141                         else
00142                            {
00143                               rev=kTRUE;
00144                            }
00145                   } // while
00146             }//if(IsStepChecking())
00147          } // lock guard
00148       TGo4Analysis::Instance()->Message(-1,"AnalysisStepManager  --  Initializing EventClasses done.");
00149       return rev;
00150 }
00151 Bool_t TGo4AnalysisStepManager::SetFirstStep(const Text_t* name)
00152 {
00153 TRACE((12,"TGo4AnalysisStepManager::SetFirstStep(const Text_t*)",__LINE__, __FILE__));
00154    //
00155    Bool_t result=kFALSE;
00156    if(name==0)
00157       {
00158          // reset to defaults:
00159          fiFirstStepIndex=0; // beginning of steplist
00160          TGo4Analysis::Instance()->Message(0,"Analysis: Setting first step to beginning of steplist");
00161          result=kTRUE;
00162       }
00163    else
00164       {
00165          TObject* obj=fxStepList->FindObject(name);
00166          if(obj==0)
00167             {
00168                result=kFALSE;
00169                TGo4Analysis::Instance()->Message(3,"!!! Analysis: SetFirstStep ERROR - no such step %s",
00170                         name);
00171             }
00172          else
00173             {
00174                Int_t ix=fxStepList->IndexOf(obj);
00175                if(ix <= fiLastStepIndex)
00176                   {
00177                      fiFirstStepIndex=ix;
00178                      TGo4Analysis::Instance()->Message(0,"Analysis: Setting first step to %s",
00179                               name);
00180                   }
00181                else
00182                   {
00183                      fiFirstStepIndex=fiLastStepIndex;
00184                      TGo4Analysis::Instance()->Message(0,"Analysis: Range WARNING - Setting first step to last step");
00185                   }
00186 
00187                result=kTRUE;
00188             }
00189 
00190    }
00191    return result;
00192 }
00193 Bool_t TGo4AnalysisStepManager::SetLastStep(const Text_t* name)
00194 {
00195 TRACE((12,"TGo4AnalysisStepManager::SetLastStep(Text_t*)",__LINE__, __FILE__));
00196    //
00197    Bool_t result=kTRUE;
00198    if(name==0)
00199       {
00200          // reset to defaults:
00201          fiLastStepIndex=fxStepList->GetLast() ; // end of steplist
00202          if(fiLastStepIndex<0)
00203             fiLastStepIndex=0; // case of empty steplist
00204          TGo4Analysis::Instance()->Message(0,"Analysis: Setting last step to end of steplist");
00205 
00206          result=kTRUE;
00207       }
00208    else
00209       {
00210          TObject* obj=fxStepList->FindObject(name);
00211          if(obj==0)
00212             {
00213                result=kFALSE;
00214                TGo4Analysis::Instance()->Message(3,"!!! Analysis: SetLastStep ERROR - no such step %s",
00215                         name);
00216 
00217             }
00218          else
00219             {
00220                Int_t ix=fxStepList->IndexOf(obj);
00221                if(ix >= fiFirstStepIndex)
00222                   {
00223                      fiLastStepIndex=ix;
00224                      TGo4Analysis::Instance()->Message(0,"Analysis: Setting last step to %s",
00225                               name);
00226                   }
00227                else
00228                   {
00229                      fiLastStepIndex=fiFirstStepIndex;
00230                      TGo4Analysis::Instance()->Message(0," Analysis: Range WARNING - Setting last step to first step");
00231 
00232                   }
00233 
00234 
00235                result=kTRUE;
00236          }
00237 
00238 
00239    }
00240    return result;
00241 }
00242 Bool_t TGo4AnalysisStepManager::SetStepStorage(const Text_t* name, Bool_t on)
00243 {
00244 TRACE((12,"TGo4AnalysisStepManager::SetStepStorage(Text_t*,Bool_t)",__LINE__, __FILE__));
00245    Bool_t result=kFALSE;
00246    TGo4AnalysisStep* step=GetAnalysisStep(name);
00247    if(step)
00248       {
00249          step->SetStoreEnabled(on);
00250          result=kTRUE;
00251       }
00252    else
00253       {
00254          result=kFALSE;
00255       }
00256 
00257    return result;
00258 
00259 }
00260 Bool_t TGo4AnalysisStepManager::NewStepStore(const Text_t * name, TGo4EventStoreParameter* par)
00261 {
00262 TRACE((12,"TGo4AnalysisStepManager::NewStepStore(Text_t *, TGo4EventStoreParameter*)",__LINE__, __FILE__));
00263    Bool_t result=kFALSE;
00264    TGo4AnalysisStep* step=0;
00265    if(name==0)
00266       {
00267          // zero name: use last step
00268          step=dynamic_cast<TGo4AnalysisStep*> (fxStepList->At(fiLastStepIndex));
00269       }
00270    else
00271       {
00272          // step specified by name:
00273          step=GetAnalysisStep(name);
00274       }
00275    if(step)
00276       {
00277          //step->SetEventStore(par); // remember parameter for next init
00278          step->NewEventStore(par); // create new store now
00279          result=kTRUE;
00280       }
00281    else
00282       {
00283          result=kFALSE;
00284       }
00285 
00286    return result;
00287 
00288 }
00289 Bool_t TGo4AnalysisStepManager::NewStepSource(const Text_t * name, TGo4EventSourceParameter * par)
00290 {
00291 TRACE((12,"TGo4AnalysisStepManager::NewStepSource(const Text_t *, TGo4EventSourceParameter *)",__LINE__, __FILE__));
00292    Bool_t result=kFALSE;
00293    TGo4AnalysisStep* step=0;
00294    if(name==0)
00295       {
00296          // zero name: use first step
00297          step=dynamic_cast<TGo4AnalysisStep*> (fxStepList->At(fiFirstStepIndex));
00298          //cout << "new step source: zero name"<< endl;
00299       }
00300    else
00301       {
00302          // step specified by name:
00303          step=GetAnalysisStep(name);
00304          //cout << "new step source: name="<< name << endl;
00305       }
00306    if(step)
00307       {
00308          //step->SetEventSource(par); // remember parameter for next init
00309          step->NewEventSource(par); // delete old, and create the new source now
00310          result=kTRUE;
00311          //cout << "new step source: step found"<< endl;
00312       }
00313    else
00314       {
00315          result=kFALSE;
00316          //cout << "new step source: step not found"<< endl;
00317       }
00318    return result;
00319 }
00320 
00321 Bool_t TGo4AnalysisStepManager::NewStepProcessor(const Text_t * name, TGo4EventProcessorParameter * par)
00322 {
00323 TRACE((12,"TGo4AnalysisStepManager::NewStepProcessor(const Text_t *, TGo4EventProcessorParameter *)",__LINE__, __FILE__));
00324    Bool_t result=kFALSE;
00325    TGo4AnalysisStep* step=GetAnalysisStep(name);
00326    if(step)
00327       {
00328          //step->SetEventProcessor(par); // remember parameter for next init
00329          step->NewEventProcessor(par); // create processor now
00330          result=kTRUE;
00331       }
00332    else
00333       {
00334          result=kFALSE;
00335       }
00336    return result;
00337 }
00338 
00339 
00340 Int_t TGo4AnalysisStepManager::Store(const Text_t * name, TGo4Parameter* par)
00341 {
00342    TGo4AnalysisStep* step=GetAnalysisStep(name);
00343    if(step!=0)
00344       return step->Store(par);
00345    else
00346       return 1;
00347 }
00348 
00349 Int_t TGo4AnalysisStepManager::Store(const Text_t * name, TGo4Condition* con)
00350 {
00351    TGo4AnalysisStep* step=GetAnalysisStep(name);
00352    if(step!=0)
00353       return step->Store(con);
00354    else
00355       return 1;
00356 }
00357 
00358 Int_t TGo4AnalysisStepManager::Store(const Text_t * name, TGo4Fitter* fit)
00359 {
00360    TGo4AnalysisStep* step=GetAnalysisStep(name);
00361    if(step)
00362       return(step->Store(fit));
00363    else
00364       return 1;
00365 }
00366 
00367 Int_t TGo4AnalysisStepManager::Store(const Text_t * name, TFolder* folder)
00368 {
00369    TGo4AnalysisStep* step=GetAnalysisStep(name);
00370    if(step)
00371      return(step->Store(folder));
00372    else
00373       return 1;
00374 }
00375 
00376 
00377 
00378 
00379 
00380 TGo4EventElement* TGo4AnalysisStepManager::GetInputEvent(const char* stepname)
00381 {
00382 TRACE((11,"TGo4AnalysisStepManager::GetInputEvent(Int_t)",__LINE__, __FILE__));
00383    TGo4EventElement* rev=0;
00384    TGo4AnalysisStep* step=GetAnalysisStep(stepname);
00385    if(step)
00386       {
00387          TGo4EventProcessor* pro=step->GetEventProcessor();
00388          if(pro)
00389             rev=pro->GetInputEvent(); // get true input event
00390       }
00391    else
00392       {
00393          rev=0;
00394       }
00395    return rev;
00396 }
00397 TGo4EventElement* TGo4AnalysisStepManager::GetInputEvent(Int_t stepindex)
00398 {
00399 TRACE((11,"TGo4AnalysisStepManager::GetInputEvent(Int_t)",__LINE__, __FILE__));
00400    TGo4EventElement* rev=0;
00401    TGo4AnalysisStep* step=0;
00402    step= dynamic_cast<TGo4AnalysisStep*> (fxStepList->At(stepindex) );
00403    if(step)
00404       {
00405          TGo4EventProcessor* pro=step->GetEventProcessor();
00406          if(pro)
00407             rev=pro->GetInputEvent(); // get true input event
00408          //rev=step->GetInputEvent();
00409       }
00410    else
00411       {
00412          rev=0;
00413       }
00414    return rev;
00415 }
00416 
00417 TGo4EventElement* TGo4AnalysisStepManager::GetOutputEvent(const char* stepname)
00418 {
00419 TRACE((11,"TGo4AnalysisStepManager::GetOutputEvent(const char*)",__LINE__, __FILE__));
00420    TGo4EventElement* rev=0;
00421    TGo4AnalysisStep* step=GetAnalysisStep(stepname);
00422    if(step)
00423       {
00424          rev=step->GetOutputEvent();
00425       }
00426    else
00427       {
00428          rev=0;
00429       }
00430    return rev;
00431 }
00432 TGo4EventElement* TGo4AnalysisStepManager::GetOutputEvent(Int_t stepindex)
00433 {
00434 TRACE((11,"TGo4AnalysisStepManager::GetOutputEvent(Int_t)",__LINE__, __FILE__));
00435    TGo4EventElement* rev=0;
00436    TGo4AnalysisStep* step=0;
00437    step= dynamic_cast<TGo4AnalysisStep*> ( fxStepList->At(stepindex) );
00438    if(step)
00439       {
00440          rev=step->GetOutputEvent();
00441       }
00442    else
00443       {
00444          rev=0;
00445       }
00446    return rev;
00447 }
00448 
00449 Bool_t  TGo4AnalysisStepManager::AddAnalysisStep(TGo4AnalysisStep* next)
00450 {
00451 TRACE((14,"TGo4AnalysisStepManager::AddAnalysisStep(TGo4AnalysisStep*)",__LINE__, __FILE__));
00452    //
00453    Bool_t rev=kFALSE;
00454    if(next)
00455       {
00456       //TGo4LockGuard  listguard(fxStepMutex);
00457       if(fxStepList->FindObject(next)==0)
00458          // is object already in list?
00459             {
00460                //no, add the new object
00461                TRACE((12,"TGo4AnalysisStepManager::AddAnalysisStep -- Adding new analysis step",__LINE__, __FILE__));
00462                fxStepList->AddLast(next);
00463                // set previous step:
00464                Int_t ix=fxStepList->IndexOf(next);
00465                if(ix>0)
00466                   {
00467                      TGo4AnalysisStep* previous= dynamic_cast<TGo4AnalysisStep*> ( fxStepList->At(ix-1) );
00468                      next->SetPreviousStep(previous);
00469                   }
00470                else
00471                   {
00472                      next->SetPreviousStep(0);
00473                   }
00474                fiLastStepIndex=ix;
00475                rev=kTRUE;
00476                TGo4Analysis::Instance()->Message(-1,"Analysis: Added analysis step %s",
00477                   next->GetName());
00478             }
00479          else
00480             {
00481                // yes, do nothing
00482                TRACE((12,"TGo4AnalysisStepManager::AddAnalysisStep -- Analysis step was already there",__LINE__, __FILE__));
00483                rev=kFALSE;
00484                TGo4Analysis::Instance()->Message(-1,"Analysis: WARNING - analysis step %s was already in steplist",
00485                   next->GetName() );
00486             }
00487       } //  if(next) ; TGo4LockGuard
00488    else
00489       {
00490        TRACE((12,"TGo4AnalysisStepManager::AddAnalysisStep -- Zero Analysis step pointer",__LINE__, __FILE__));
00491          rev=kFALSE;
00492          TGo4Analysis::Instance()->Message(-1,"Analysis: WARNING - did not add zero analysis step pointer to steplist");
00493       }
00494    return rev;
00495 }
00496 
00497 TGo4AnalysisStep * TGo4AnalysisStepManager::GetAnalysisStep(const char* name)
00498 {
00499 TRACE((11,"TGo4AnalysisStepManager::GetAnalysisStep(Text_t *)",__LINE__, __FILE__));
00500    TGo4AnalysisStep* step=0;
00501    if(name==0)
00502       {
00503          step=dynamic_cast<TGo4AnalysisStep*>( fxStepList->At(fiFirstStepIndex));
00504       }
00505       else
00506       {
00507       //TGo4LockGuard  listguard(fxStepMutex);
00508          step = dynamic_cast<TGo4AnalysisStep*>( fxStepList->FindObject(name) );
00509       }
00510    return step;
00511 }
00512 
00513 Int_t TGo4AnalysisStepManager::ProcessAnalysisSteps()
00514 {
00515 TRACE((11,"TGo4AnalysisStepManager::ProcessAnalysisSteps()",__LINE__, __FILE__));
00516    //
00517    Int_t rev=0;
00518    fxCurrentStep=0;
00519    fiCurrentStepIndex=0;
00520    Bool_t isfirststep=kTRUE;
00521    SetOutputEvent(0); // make sure that first step wont take output of last one
00522       {
00523       //TGo4LockGuard  listguard(fxStepMutex);
00524          for(fiCurrentStepIndex=fiFirstStepIndex; fiCurrentStepIndex<=fiLastStepIndex;fiCurrentStepIndex++)
00525             {
00526                fxCurrentStep=dynamic_cast<TGo4AnalysisStep*>(fxStepList->UncheckedAt(fiCurrentStepIndex));
00527                if(fxCurrentStep==0) break;
00528                      if(IsStepChecking() && isfirststep )
00529                         {
00530                            // check first step source:
00531                            isfirststep=kFALSE;
00532                            if(fxCurrentStep->IsSourceImplemented())
00533                               {
00534                                  fxCurrentStep->SetSourceEnabled();
00535                               }
00536                            else
00537                               {
00538                                  fxCurrentStep->SetStatusMessage("!!! No Event Source for first analysis step !!!");
00539                                  throw TGo4AnalysisStepException(fxCurrentStep);
00540                               }
00541                         } else { } //  if(IsStepChecking() && isfirststep)
00542                      fxCurrentStep->Process();
00543             } // for(...)
00544       } // lock guard
00545    // finally, we update maintree header if the steps use treesource/store instances:
00546    if(TGo4MainTree::Exists()) TGo4MainTree::Instance()->Update();
00547    return rev;
00548 }
00549 
00550 
00551 void TGo4AnalysisStepManager::UpdateStatus(TGo4AnalysisStatus* state)
00552 {
00553 TRACE((11,"TGo4AnalysisStepManager::UpdateStatus(TGo4AnalysisStatus*)",__LINE__, __FILE__));
00554    if(state!=0)
00555       {
00556          state->SetFirstStepIndex(fiFirstStepIndex);
00557          state->SetLastStepIndex(fiLastStepIndex);
00558          state->SetStepChecking(fbStepCheckingMode);
00559          {
00560             //TGo4LockGuard  listguard(fxStepMutex);
00561                fxCurrentStep=0;
00562                fxStepIterator->Reset();
00563                while((fxCurrentStep= dynamic_cast<TGo4AnalysisStep*>( fxStepIterator->Next() ) ) !=0)
00564                 {
00565                    TGo4AnalysisStepStatus* stepstate= fxCurrentStep->CreateStatus();
00566                    state->AddStepStatus(stepstate);
00567                 } // while(fxCurrentStep..)
00568          } // lockguard
00569       } // if(state!=0)
00570    else
00571       {
00572          // no state to update
00573       }
00574 
00575 }
00576 
00577 void TGo4AnalysisStepManager::SetStatus(TGo4AnalysisStatus * state)
00578 {
00579    TRACE((11,"TGo4AnalysisStepManager::SetStatus(TGo4AnalysisStatus*)",__LINE__, __FILE__));
00580    if(state!=0)
00581       {
00582          fiFirstStepIndex=state->GetFirstStepIndex();
00583          fiLastStepIndex=state->GetLastStepIndex();
00584          fbStepCheckingMode=state->IsStepChecking();
00585          // note: the step indices are not used for
00586          // initialization of analysis any more!
00587          // update internal states of steps:
00588             {
00589             //TGo4LockGuard  listguard(fxStepMutex);
00590                fxCurrentStep=0;
00591                fxStepIterator->Reset();
00592                while((fxCurrentStep= dynamic_cast<TGo4AnalysisStep*>( fxStepIterator->Next() ) ) !=0)
00593                 {
00594                    const Text_t* name= fxCurrentStep->GetName();
00595                    TGo4AnalysisStepStatus* stepstate= state->GetStepStatus(name);
00596                    fxCurrentStep->SetStatus(stepstate);
00597 
00598                 } // while(fxCurrentStep..)
00599             } // lockguard
00600       } // if(state!=0)
00601    else
00602       {
00603          // no state to set
00604       }
00605 }
00606 
00607 void TGo4AnalysisStepManager::AutoSave()
00608 {
00609 TRACE((12,"TGo4AnalysisStepManager::AutoSave()",__LINE__, __FILE__));
00610    //
00611    //TGo4LockGuard  autoguard(fxAutoSaveMutex);
00612    TGo4Analysis::Instance()->Message(0,"Analysis Step Manager  --  AutoSaving....");
00613    TGo4AnalysisStep* step=0;
00614       {
00615       //TGo4LockGuard   listguard(fxStepMutex);
00616          fxStepIterator->Reset();
00617          while((step= dynamic_cast<TGo4AnalysisStep*>( fxStepIterator->Next() ) ) !=0)
00618             {
00619                step->StoreCalibration();
00620             }
00621       } // lock guard
00622 
00623    // write maintree to file if existing...
00624   if(TGo4MainTree::Exists())
00625                {
00626                   TGo4MainTree::Instance()->Write();
00627                }   else { }
00628 }
00629 
00630 Int_t TGo4AnalysisStepManager::IsErrorStopEnabled()
00631 {
00632    return kTRUE; // workaraound, to be removed later!!! JA
00633    if(fxCurrentStep!=0)
00634        return fxCurrentStep->IsErrorStopEnabled();
00635    else
00636        return kTRUE;
00637 }
00638 
00639 //----------------------------END OF GO4 SOURCE FILE ---------------------

Generated on Fri Nov 28 12:59:04 2008 for Go4-v3.04-1 by  doxygen 1.4.2