/Go4Analysis/TGo4AnalysisStepManager.cxx Source File

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