Modifications to the trigger classes to have I/O. I
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 29 Mar 2006 17:35:20 +0000 (17:35 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 29 Mar 2006 17:35:20 +0000 (17:35 +0000)
also made changes in AliRunLoader and AliSimulation.

      the idea is to create a new file (Trigger.root) to store the CTP
information (one AliCentralTrigger object and a tree for the trigger class
mask event by event). I can change to galice.root if people think it is
better.

Each trigger detector object (with inputs) is store in the digits file in
the Event folder.

ZDC.Digits.root -\
                 |
                 |-Event0 -\
                 |         |-TreeD
                 |         \-Trigger
                 |
                 \-Event1-\
                          |-TreeD
                          \-Trigger
 added to AliRunLoader the following stuff:

 void                 MakeTrigger();
 Int_t                LoadTrigger(Option_t* option = "READ");
 void                 UnloadTrigger();
 TTree*               TreeCT() const; //returns the tree from folder;
shortcut method
 AliCentralTrigger*   GetTrigger() const;
 Int_t                WriteTrigger(Option_t* opt="");
 static TString       GetTriggerContainerName () {return
fgkTriggerContainerName;}
 static TString       GetTriggerBranchName () {return fgkTriggerBranchName;}
 static TString       GetTriggerFileName() { return
fgkDefaultTriggerFileName; }
 void                 CleanTrigger(){ Clean(fgkTriggerContainerName); }

 AliCentralTrigger    *fCTrigger; //! pointer to CEntral Trigger Processor
 static const TString   fgkDefaultTriggerFileName;//default file name with
trigger
 static const TString   fgkTriggerContainerName;   //default name of the
trigger container (TREE) name - TreeCT
 static const TString   fgkTriggerBranchName;      //default name of the
branch containing the trigger

 I also find an small error in AliRunLoader I think. In AliRunLoader::Open
when the session is open the method just print a warnnig and return the
loader but not update the internal pointer to the loader, so if after that
you ask with AliRunLoader::GetRunLoader() the aswer is 0x0.

So I change :

  AliWarningClass("Session is already opened and mounted in demanded folder");
  return result;
by
  AliWarningClass("Session is already opened and mounted in demanded folder");
  if (!fgRunLoader) fgRunLoader = result; //PH get access from any place
  return result;

to retrive the global class mask you can do:

   rl->LoadTrigger();
   AliCentralTrigger *aCTP = rl->GetTrigger();
   rl->GetEvent( i );
   cout << endl << "Event " << i
        << " Global Trigger Class Mask: 0x" << hex << aCTP->GetClassMask()
<< endl;
   rl->UnloadTrigger();

Regards
Ernesto

12 files changed:
STEER/AliCentralTrigger.cxx
STEER/AliCentralTrigger.h
STEER/AliRunLoader.cxx
STEER/AliRunLoader.h
STEER/AliSimulation.cxx
STEER/AliTriggerCondition.cxx
STEER/AliTriggerDescriptor.cxx
STEER/AliTriggerDescriptor.h
STEER/AliTriggerDetector.cxx
STEER/AliTriggerDetector.h
STEER/AliTriggerInput.cxx
STEER/AliTriggerInput.h

index 5ad12eb..3b15190 100644 (file)
@@ -36,6 +36,8 @@
 #include <TObjString.h>
 #include <TObjArray.h>
 #include <TStopwatch.h>
+#include <TFile.h>
+#include <TTree.h>
 
 #include "AliLog.h"
 #include "AliRun.h"
@@ -47,6 +49,9 @@
 #include "AliTriggerCondition.h"
 #include "AliTriggerDescriptor.h"
 #include "AliCentralTrigger.h"
+#include "AliDetectorEventHeader.h"
+#include "AliHeader.h"
+
 
 ClassImp( AliCentralTrigger )
 
@@ -69,14 +74,76 @@ AliCentralTrigger::AliCentralTrigger( TString & descriptor ) :
 }
 
 //_____________________________________________________________________________
+AliCentralTrigger::AliCentralTrigger( const AliCentralTrigger& ctp ):
+   TObject( ctp ),
+   fClassMask( ctp.fClassMask )
+{
+   // Copy constructor
+
+   Int_t ndes = ctp.fDescriptors.GetEntriesFast();
+   for( Int_t j=0; j<ndes; j++ ) {
+      fDescriptors.AddLast( new AliTriggerDescriptor( *(AliTriggerDescriptor*)(ctp.fDescriptors.At( j )) ) );
+   }
+
+   Int_t nInp = ctp.fInputs.GetEntriesFast();
+   for( Int_t j=0; j<nInp; j++ ) {
+      fInputs.AddLast( new AliTriggerInput( *(AliTriggerInput*)(ctp.fInputs.At( j )) ) );
+   }
+}
+
+//_____________________________________________________________________________
 AliCentralTrigger::~AliCentralTrigger()
 {
    // Destructor
+   DeleteDescriptors();
+}
+
+//_____________________________________________________________________________
+void AliCentralTrigger::DeleteDescriptors()
+{
+   // Reset Descriptors
+   fClassMask = 0;
    fDescriptors.SetOwner();
    fDescriptors.Delete();
 }
 
 //_____________________________________________________________________________
+void AliCentralTrigger::Reset()
+{
+   // Reset Class Mask and conditions
+   fClassMask = 0;
+   Int_t ndes = fDescriptors.GetEntriesFast();
+   for( Int_t i=0; i<ndes; i++ ) {
+      TObjArray* condArray = ((AliTriggerDescriptor*)fDescriptors.At( i ))->GetTriggerConditions();
+      Int_t ncond = condArray->GetEntriesFast();
+      for( Int_t j=0; j<ncond; j++ ) {
+         AliTriggerCondition* cond = (AliTriggerCondition*)condArray->At( j );
+         cond->Reset();
+      }
+   }
+}
+
+//_____________________________________________________________________________
+void AliCentralTrigger::MakeBranch( TString name, TTree * tree )
+{
+   // Make a branch to store only trigger class mask event by event
+
+   if( tree )  {
+      AliDebug( 1, "Got Tree from folder." );
+      TBranch* branch = tree->GetBranch( name );
+      if( branch == 0x0 ) {
+         AliDebug( 1, "Creating new branch" );
+         branch = tree->Branch( name, &(this->fClassMask), "fClassMask/l" );
+         branch->SetAutoDelete( kFALSE );
+      }
+      else {
+         AliDebug( 1, "Got Branch from Tree" );
+         branch->SetAddress( &(this->fClassMask) );
+      }
+   }
+}
+
+//_____________________________________________________________________________
 Bool_t AliCentralTrigger::LoadDescriptor( TString & descriptor )
 {
    // Load one or more pre-created Descriptors from database/file that match
@@ -84,7 +151,7 @@ Bool_t AliCentralTrigger::LoadDescriptor( TString & descriptor )
    // Ej: "Pb-Pb" or "p-p-DIMUON CALIBRATION-CENTRAL-BARREL"
 
    // Delete any descriptor
-   fDescriptors.Delete();
+   Reset();
 
    // Load the selected descriptors
    TObjArray* desArray = descriptor.Tokenize( " " );
@@ -132,51 +199,80 @@ TString AliCentralTrigger::GetDetectors()
 Bool_t AliCentralTrigger::RunTrigger( AliRunLoader* runLoader )
 {
    // run the trigger
-   
+
    if( fDescriptors.GetEntriesFast() == 0 ) {
-      AliError("not trigger descriptor loaded, skipping trigger");
+      AliError( "not trigger descriptor loaded, skipping trigger" );
+      return kFALSE;
+   }
+
+   TTree *tree = runLoader->TreeCT();
+   if( !tree ) {
+      AliError( "not folder with trigger loaded, skipping trigger" );
       return kFALSE;
    }
 
    TStopwatch stopwatch;
    stopwatch.Start();
-   
+
    // Process each event
    for( Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++ ) {
-      AliInfo( Form("\n ***** Processing event %d *****\n", iEvent) );
-      runLoader->GetEvent( iEvent );       
+      AliInfo( Form("  ***** Processing event %d *****\n", iEvent) );
+      runLoader->GetEvent( iEvent );
       // Get detectors involve
       TString detStr = GetDetectors();
+      AliInfo( Form(" Cluster Detectors %s \n", detStr.Data() ) );
       TObjArray* detArray = runLoader->GetAliRun()->Detectors();
       // Reset Mask
       fClassMask = 0;
-      TObjArray trgdetArray;
+      TObjArray trgdetArray; // use as garbage collector
       for( Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++ ) {
          AliModule* det = (AliModule*) detArray->At( iDet );
          if( !det || !det->IsActive() ) continue;
          if( IsSelected(det->GetName(), detStr) ) {
-            AliInfo( Form("triggering from digits for %s", det->GetName() ) );
+
+            AliInfo( Form("Triggering from digits for %s", det->GetName() ) );
             AliTriggerDetector* trgdet = det->CreateTriggerDetector();
             trgdet->CreateInputs();
-            trgdetArray.AddLast( trgdet );
             TStopwatch stopwatchDet;
             stopwatchDet.Start();
             trgdet->Trigger();
             AliInfo( Form("Execution time for %s: R:%.2fs C:%.2fs",
                      det->GetName(), stopwatchDet.RealTime(), stopwatchDet.CpuTime() ) );
+
             // Get the inputs
             TObjArray* detInp = trgdet->GetInputs();
             for( Int_t i=0; i<detInp->GetEntriesFast(); i++ ) {
                fInputs.AddLast( detInp->At(i) );
             }
+            trgdetArray.AddLast( trgdet );
+
+            // Write trigger detector in Event folder in Digits file
+            TString loadername = det->GetName();
+            loadername.Append( "Loader" );
+            AliLoader * loader = runLoader->GetLoader( loadername );
+            if( loader ) {
+               AliDataLoader * dataLoader = loader->GetDigitsDataLoader();
+               if( !dataLoader->IsFileOpen() ) {
+                  if( dataLoader->OpenFile( "UPDATE" ) ) {
+                     AliWarning( Form( "\n\nCan't write trigger for %s\n", det->GetName() ) );
+                  }
+               }
+               dataLoader->Cd();
+               if( gFile && !gFile->IsWritable() ) {
+                  gFile->ReOpen( "UPDATE" );
+                  dataLoader->Cd();
+               }
+               trgdet->Write( "Trigger", TObject::kOverwrite );
+               dataLoader->CloseFile();
+            }
+            else  AliWarning( Form( "Not loader found for %s", det->GetName() ) );
          }
       }
 
       // Check trigger conditions and create the trigger class mask
       CheckConditions();
-
       fInputs.Clear();
-      
+
       // Clear trigger detectors
       trgdetArray.SetOwner();
       trgdetArray.Delete();
@@ -187,15 +283,20 @@ Bool_t AliCentralTrigger::RunTrigger( AliRunLoader* runLoader )
          return kFALSE;
       }
 
-      // Write trigger ???? -> Event Header
-      // Write();
-      Print();
-
+      // Save trigger mask
+      tree->Fill();
+      AliInfo( Form("**************** Central Trigger Class Mask:0x%X", fClassMask ) );
    } // end event loop
-   return kTRUE;
-}
 
+   Reset();
+//   cout << endl <<  " Print " << endl;
+//   Print();
+
+   // Write
+   runLoader->WriteTrigger( "OVERWRITE" );
 
+   return kTRUE;
+}
 
 //_____________________________________________________________________________
 Long_t AliCentralTrigger::CheckConditions()
@@ -236,7 +337,6 @@ TObjArray* AliCentralTrigger::GetResultConditions()
    return result;
 }
 
-
 //_____________________________________________________________________________
 void AliCentralTrigger::Print( const Option_t*  ) const
 {
index 0a22e67..7ed4df4 100644 (file)
@@ -25,6 +25,7 @@
 #include <TObject.h>
 #include <TObjArray.h>
 
+class TTree;
 class AliRunLoader;
 
 class AliCentralTrigger : public TObject {
@@ -32,11 +33,15 @@ class AliCentralTrigger : public TObject {
 public:
                           AliCentralTrigger();
                           AliCentralTrigger( TString & descriptor );
+                          AliCentralTrigger( const AliCentralTrigger& ctp );
                virtual   ~AliCentralTrigger();
 
                 Bool_t    LoadDescriptor( TString & descriptor );
                 Bool_t    RunTrigger( AliRunLoader * runloader );
                 Long_t    CheckConditions();
+                  void    Reset();
+                  void    DeleteDescriptors();
+                  void    MakeBranch( TString name, TTree * tree );
   //  Getters
                TString    GetDetectors();
                 Long_t    GetClassMask() const { return fClassMask; }
@@ -45,7 +50,7 @@ public:
                   void    Print( const Option_t* opt ="" ) const;
 protected:
        //        TString    fRunCondition;     // Running modes Ej. Pb-Pb, p-p, p-A
-                Long_t    fClassMask;          // UID ( bitwise OR of conditions mask )
+             ULong64_t    fClassMask;          // UID ( bitwise OR of conditions mask )
              TObjArray    fDescriptors;        // Array of Trigger Descriptors (AliTriggerDescriptor)
              TObjArray    fInputs;             //! Array of Trigger Inputs
 
index 72dd12d..8c3e9bd 100644 (file)
@@ -64,21 +64,24 @@ class TTask;
 #include "AliDetector.h"
 #include "AliCDBManager.h"
 #include "AliCDBLocal.h"
+#include "AliCentralTrigger.h"
 
 ClassImp(AliRunLoader)
 
 AliRunLoader* AliRunLoader::fgRunLoader = 0x0;
 
 const TString AliRunLoader::fgkRunLoaderName("RunLoader");
-
 const TString AliRunLoader::fgkHeaderBranchName("Header");
+const TString AliRunLoader::fgkTriggerBranchName("ClassMask");
 const TString AliRunLoader::fgkHeaderContainerName("TE");
+const TString AliRunLoader::fgkTriggerContainerName("TreeCT");
 const TString AliRunLoader::fgkKineContainerName("TreeK");
 const TString AliRunLoader::fgkTrackRefsContainerName("TreeTR");
 const TString AliRunLoader::fgkKineBranchName("Particles");
 const TString AliRunLoader::fgkDefaultKineFileName("Kinematics.root");
 const TString AliRunLoader::fgkDefaultTrackRefsFileName("TrackRefs.root");
 const TString AliRunLoader::fgkGAliceName("gAlice");
+const TString AliRunLoader::fgkDefaultTriggerFileName("Trigger.root");
 /**************************************************************************/
 
 AliRunLoader::AliRunLoader():
@@ -88,6 +91,7 @@ AliRunLoader::AliRunLoader():
  fGAFile(0x0),
  fHeader(0x0),
  fStack(0x0),
+ fCTrigger(0x0),
  fKineDataLoader(0x0),
  fTrackRefsDataLoader(0x0),
  fNEventsPerFile(1),
@@ -106,6 +110,7 @@ AliRunLoader::AliRunLoader(const char* eventfoldername):
  fGAFile(0x0),
  fHeader(0x0),
  fStack(0x0),
+ fCTrigger(0x0),
  fKineDataLoader(new AliDataLoader(fgkDefaultKineFileName,fgkKineContainerName,"Kinematics")),
  fTrackRefsDataLoader(new AliDataLoader(fgkDefaultTrackRefsFileName,fgkTrackRefsContainerName,"Track References")),
  fNEventsPerFile(1),
@@ -125,6 +130,7 @@ AliRunLoader::AliRunLoader(const AliRunLoader &rl):
  fGAFile(0x0),
  fHeader(0x0),
  fStack(0x0),
+ fCTrigger(0x0),
  fKineDataLoader(0x0),
  fTrackRefsDataLoader(0x0),
  fNEventsPerFile(0),
@@ -157,6 +163,7 @@ AliRunLoader::~AliRunLoader()
   RemoveEventFolder();
   
   //fEventFolder is deleted by the way of removing - TopAliceFolder owns it
+  if( fCTrigger ) delete  fCTrigger;
   delete fHeader;
   delete fStack;
   delete fGAFile;
@@ -171,6 +178,7 @@ AliRunLoader::AliRunLoader(TFolder* topfolder):
  fGAFile(0x0),
  fHeader(0x0),
  fStack(0x0),
+ fCTrigger(0x0),
  fKineDataLoader(new AliDataLoader(fgkDefaultKineFileName,fgkKineContainerName,"Kinematics")),
  fTrackRefsDataLoader(new AliDataLoader(fgkDefaultTrackRefsFileName,fgkTrackRefsContainerName,"Track References")),
  fNEventsPerFile(1),
@@ -261,6 +269,14 @@ Int_t AliRunLoader::GetEvent(Int_t evno)
    {
      AliWarning("Stack not found in header");
    }
+
+   if( GetTrigger() && TreeCT() ) {
+      retval = TreeCT()->GetEvent(fCurrentEvent);
+      if ( retval )      {
+         AliError(Form("Error occured while GetEvent for Trigger. Event %d",evno));
+         return 2;
+      }
+   }
   
   retval = SetEvent();
   if (retval)
@@ -423,6 +439,7 @@ AliRunLoader* AliRunLoader::Open
      }
      
     AliWarningClass("Session is already opened and mounted in demanded folder");       
+    if (!fgRunLoader) fgRunLoader = result; //PH get access from any place
     return result;
   } //end of checking in case of existance of object named identically that folder session is being opened
  
@@ -566,14 +583,32 @@ void AliRunLoader::MakeStack()
      fStack->SetEventFolderName(fEventFolder->GetName());
    }
 }
+/**************************************************************************/
+
+void AliRunLoader::MakeTrigger()
+{
+ // Makes trigger object and connects it to trigger tree (if it exists)
+   AliDebug( 1, "" );
+   if( fCTrigger == 0x0 ) {
+      AliDebug( 1, "Creating new Trigger Object" );
+      fCTrigger = new AliCentralTrigger();
+   }
+   TTree* tree = TreeCT();
+   if( tree ) {
+      fCTrigger->MakeBranch( fgkTriggerBranchName, tree );
+      tree->GetEvent( fCurrentEvent );
+   }
 
+   AliDebug( 1, "Exiting MakeTrigger method" );
+}
 /**************************************************************************/
 
 void AliRunLoader::MakeTree(Option_t *option)
 {
 //Creates trees
-  const char *oK = strstr(option,"K"); //Kine  
-  const char *oE = strstr(option,"E"); //Header
+  const char *oK  = strstr(option,"K");  //Kine
+  const char *oE  = strstr(option,"E");  //Header
+  const char *oCT = strstr(option,"CT"); //Central Trigger
 
   if(oK && !TreeK())
    { 
@@ -599,6 +634,21 @@ void AliRunLoader::MakeTree(Option_t *option)
      WriteHeader("OVERWRITE");
    }
   
+   if(oCT && !TreeCT())
+   {
+      // create the CTP Trigger output file and tree
+      TFile* file = gROOT->GetFile( fgkDefaultTriggerFileName );
+      if( !file ) {
+         file = TFile::Open( gSystem->ConcatFileName( fUnixDirName.Data(), fgkDefaultTriggerFileName.Data() ), "RECREATE" ) ;
+      }
+
+      file->cd();
+      TTree* tree = new TTree( fgkTriggerContainerName, "Tree with Central Trigger Mask" );
+      GetEventFolder()->Add(tree);
+      MakeTrigger();
+  //    WriteHeader("OVERWRITE");
+   }
+
   TIter next(fLoaders);
   AliLoader *loader;
   while((loader = (AliLoader*)next()))
@@ -683,6 +733,50 @@ Int_t AliRunLoader::LoadHeader()
 }
 /**************************************************************************/
 
+Int_t AliRunLoader::LoadTrigger(Option_t* option)
+{
+   //Load treeCT
+
+   if( TreeCT() ) {
+      AliWarning("Trigger is already loaded. Nothing done");
+      return 0;
+   }
+   if( GetEventFolder() == 0x0 ) {
+      AliError("Event folder not specified yet");
+      return 1;
+   }
+   // get the CTP Trigger output file and tree
+   TString trgfile = gSystem->ConcatFileName( fUnixDirName.Data(),
+                                              fgkDefaultTriggerFileName.Data() );
+   TFile* file = gROOT->GetFile( trgfile );
+   if( !file ) {
+      file = TFile::Open( trgfile, option ) ;
+      if (!file || file->IsOpen() == kFALSE ) {
+         AliError( Form( "Can not open trigger file %s", trgfile.Data() ) );
+         return 2;
+      }
+   }
+   file->cd();
+
+   TTree* tree = dynamic_cast<TTree*>(file->Get( fgkTriggerContainerName ));
+   if( !tree ) {
+      AliError( Form( "Can not find trigger tree named %s in file %s",
+                      fgkTriggerContainerName.Data(), file->GetName() ) );
+      return 2;
+   }
+
+   CleanTrigger();
+
+   fCTrigger = dynamic_cast<AliCentralTrigger*>(file->Get( "AliCentralTrigger" ));
+   GetEventFolder()->Add( tree );
+   MakeTrigger();
+
+   return 0;
+}
+
+/**************************************************************************/
+
 Int_t AliRunLoader::LoadKinematics(Option_t* option)
 {
 //Loads the kinematics 
@@ -767,12 +861,29 @@ TTree* AliRunLoader::TreeE() const
 }
 /**************************************************************************/
 
+TTree* AliRunLoader::TreeCT() const
+{
+ //returns the tree from folder; shortcut method
+   if (AliDebugLevel() > 10) fEventFolder->ls();
+   TObject *obj = fEventFolder->FindObject(fgkTriggerContainerName);
+   return (obj)?dynamic_cast<TTree*>(obj):0x0;
+}
+/**************************************************************************/
+
 AliHeader* AliRunLoader::GetHeader() const
 {
 //returns pointer header object
  return fHeader;
 }
 /**************************************************************************/
+
+AliCentralTrigger* AliRunLoader::GetTrigger() const
+{
+//returns pointer trigger object
+   return fCTrigger;
+}
+
+/**************************************************************************/
  
 TTree* AliRunLoader::TreeK() const
 {
@@ -849,6 +960,44 @@ Int_t AliRunLoader::WriteHeader(Option_t* opt)
   
   return 0;
 }
+
+/**************************************************************************/
+
+Int_t AliRunLoader::WriteTrigger(Option_t* opt)
+{
+   //writes TreeCT
+   AliDebug( 1, "WRITING TRIGGER" );
+  
+   TTree* tree = TreeCT();
+   if ( tree == 0x0) {
+      AliWarning("Can not find Trigger Tree in Folder");
+      return 0;
+   }
+
+   TFile* file = gROOT->GetFile( gSystem->ConcatFileName( fUnixDirName.Data(), fgkDefaultTriggerFileName.Data() ) ) ;
+   if( !file || !file->IsOpen() ) {
+      AliError( "can't write Trigger, file is not open" );
+      return kFALSE;
+   }
+
+   TObject* obj = file->Get( fgkTriggerContainerName );
+   if( obj ) { //if they exist, see if option OVERWRITE is used
+      TString tmp(opt);
+      if( tmp.Contains( "OVERWRITE", TString::kIgnoreCase ) == 0) {
+         //if it is not used -  give an error message and return an error code
+         AliError( "Tree already exisists. Use option \"OVERWRITE\" to overwrite previous data" );
+         return 3;
+      }
+   }
+   file->cd();
+   fCTrigger->Write( 0, TObject::kOverwrite );
+   tree->Write( 0, TObject::kOverwrite );
+   file->Flush();
+
+   AliDebug(1, "WRITTEN\n\n");
+  
+   return 0;
+}
 /**************************************************************************/
 
 Int_t AliRunLoader::WriteAliRun(Option_t* /*opt*/)
@@ -1110,6 +1259,7 @@ void AliRunLoader::CleanFolders()
   CleanDetectors();
   CleanHeader();
   CleanKinematics();
+  CleanTrigger();
 }
 /**************************************************************************/
 
@@ -1740,6 +1890,7 @@ void AliRunLoader::Clean(const TString& name)
      AliDebug(1, Form("name=%s, cleaning %s.",GetName(),name.Data()));
      GetEventFolder()->Remove(obj);
      delete obj;
+     obj = 0x0;
    }
 }
 
@@ -1846,6 +1997,17 @@ void AliRunLoader::UnloadHeader()
 }
 /**************************************************************************/
 
+void AliRunLoader::UnloadTrigger()
+{
+ //removes TreeCT from folder and deletes it
+ // as well as fHeader object
+   CleanTrigger();
+   delete fCTrigger;
+   fCTrigger = 0x0;
+}
+
+/**************************************************************************/
+
 void AliRunLoader::UnloadKinematics()
 {
 //Unloads Kinematics
@@ -1981,6 +2143,9 @@ void AliRunLoader::Synchronize()
   
   fKineDataLoader->Synchronize();
   fTrackRefsDataLoader->Synchronize();
+
+  TFile* file = gROOT->GetFile( gSystem->ConcatFileName( fUnixDirName.Data(), fgkDefaultTriggerFileName.Data() ) ) ;
+  if( file ) file->Flush();
   
   if (fGAFile) fGAFile->Flush();
 }
index 9f8c906..93ed898 100644 (file)
@@ -44,7 +44,7 @@ class AliHeader;
 class AliStack;
 class AliRunDigitizer;
 class AliCDBEntry;
-
+class AliCentralTrigger;
 
 class AliRunLoader: public TNamed
 {
@@ -76,14 +76,17 @@ class AliRunLoader: public TNamed
 
     void        MakeTree(Option_t *option);
     void        MakeHeader();
+    void        MakeTrigger();
     void        MakeStack();
     
     Int_t       LoadgAlice();
     Int_t       LoadHeader();
     Int_t       LoadKinematics(Option_t* option = "READ");
+    Int_t       LoadTrigger(Option_t* option = "READ");
     Int_t       LoadTrackRefs(Option_t* option = "READ");
     
     void        UnloadHeader();
+    void        UnloadTrigger();
     void        UnloadKinematics();
     void        UnloadgAlice();
     void        UnloadTrackRefs();
@@ -92,7 +95,9 @@ class AliRunLoader: public TNamed
     void        SetTrackRefsFileName(const TString& fname){fTrackRefsDataLoader->SetFileName(fname);}
     
     TTree*      TreeE() const; //returns the tree from folder; shortcut method
+    TTree*      TreeCT() const; //returns the tree from folder; shortcut method
     AliHeader*  GetHeader() const;
+    AliCentralTrigger*  GetTrigger() const;
     
     AliStack*   Stack() const {return fStack;}
     
@@ -103,6 +108,7 @@ class AliRunLoader: public TNamed
         
     Int_t       WriteGeometry(Option_t* opt="");
     Int_t       WriteHeader(Option_t* opt="");
+    Int_t       WriteTrigger(Option_t* opt="");
     Int_t       WriteAliRun(Option_t* opt="");
     Int_t       WriteKinematics(Option_t* opt="");
     Int_t       WriteTrackRefs(Option_t* opt="");
@@ -192,10 +198,13 @@ class AliRunLoader: public TNamed
 
     static TString GetRunLoaderName () {return fgkRunLoaderName;}
     static TString GetHeaderContainerName () {return fgkHeaderContainerName;}
+    static TString GetTriggerContainerName () {return fgkTriggerContainerName;}
     static TString GetKineContainerName () {return fgkKineContainerName;}
     static TString GetTrackRefsContainerName () {return fgkTrackRefsContainerName;}
     static TString GetHeaderBranchName () {return fgkHeaderBranchName;}
+    static TString GetTriggerBranchName () {return fgkTriggerBranchName;}
     static TString GetKineBranchName () {return fgkKineBranchName;}
+    static TString GetTriggerFileName() { return fgkDefaultTriggerFileName; }
     static TString GetGAliceName () {return fgkGAliceName;}
      
 protected:
@@ -209,9 +218,10 @@ protected:
     
     Int_t          fCurrentEvent;//!Number of current event
     
-    TFile         *fGAFile;//!  pointer to main file with AliRun and Run Loader -> galice.root 
-    AliHeader     *fHeader;//!  pointer to header
-    AliStack      *fStack; //!  pointer to stack
+    TFile             *fGAFile;//!  pointer to main file with AliRun and Run Loader -> galice.root 
+    AliHeader         *fHeader;//!  pointer to header
+    AliStack          *fStack; //!  pointer to stack
+    AliCentralTrigger *fCTrigger; //! pointer to CEntral Trigger Processor
     
     AliDataLoader *fKineDataLoader;// kinematics data loader
     AliDataLoader *fTrackRefsDataLoader;//track reference data loader
@@ -220,6 +230,7 @@ protected:
     TString        fUnixDirName;    //! name of unix path to directory that contains event
     static const TString   fgkDefaultKineFileName;//default file name with kinamatics
     static const TString   fgkDefaultTrackRefsFileName;//default file name with kinamatics
+    static const TString   fgkDefaultTriggerFileName;//default file name with trigger
 
 
     /*********************************************/
@@ -240,6 +251,7 @@ protected:
     void  GetListOfDetectors(const char * namelist,TObjArray& pointerarray) const;
 
     void  CleanHeader(){Clean(fgkHeaderContainerName);}
+    void  CleanTrigger(){Clean(fgkTriggerContainerName);}
     void  Clean(const TString& name);
     
     Int_t SetEvent();
@@ -251,13 +263,15 @@ private:
 
     static const TString   fgkRunLoaderName;          //default name of the run loader
     static const TString   fgkHeaderContainerName;    //default name of the kinematics container (TREE) name - TreeE
+    static const TString   fgkTriggerContainerName;   //default name of the trigger container (TREE) name - TreeCT
     static const TString   fgkKineContainerName;      //default name of the kinematics container (TREE) name - TreeK
     static const TString   fgkTrackRefsContainerName; //default name of the track references container (TREE) name - TreeTR
     static const TString   fgkHeaderBranchName;       //default name of the branch containing the header
+    static const TString   fgkTriggerBranchName;      //default name of the branch containing the trigger
     static const TString   fgkKineBranchName;         //default name of the branch with kinematics
     static const TString   fgkGAliceName;             //default name for gAlice file    
     
-    ClassDef(AliRunLoader,1)
+    ClassDef(AliRunLoader,2)
 };
 
 #endif
index d400070..82c3217 100644 (file)
@@ -546,75 +546,32 @@ Bool_t AliSimulation::RunTrigger(const char* descriptors)
 {
   // run the trigger
 
-  TStopwatch stopwatch;
-  stopwatch.Start();
+   TStopwatch stopwatch;
+   stopwatch.Start();
 
-  AliRunLoader* runLoader = LoadRun("READ");
-  if (!runLoader) return kFALSE;
-  TString des = descriptors;
+   AliRunLoader* runLoader = LoadRun("READ");
+   if (!runLoader) return kFALSE;
+   TString des = descriptors;
+
+   runLoader->MakeTree( "CT" );
+   AliCentralTrigger* aCTP = runLoader->GetTrigger();
   // Load Descriptors
-  AliCentralTrigger* aCTP = new AliCentralTrigger( des );
+   aCTP->LoadDescriptor( des );
 
   // digits -> trigger
-  if( !aCTP->RunTrigger( runLoader ) ) {
-    if (fStopOnError) {
-      delete aCTP;
-      return kFALSE;
-    }
-  }
-
-/*
-  // Process each event
-  for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
-    AliInfo(Form("processing event %d", iEvent));
-    runLoader->GetEvent(iEvent);
-
-    TObjArray* detArray = runLoader->GetAliRun()->Detectors();
-    for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
-      AliModule* det = (AliModule*) detArray->At(iDet);
-      if (!det || !det->IsActive()) continue;
-      if (IsSelected(det->GetName(), detStr)) {
-        AliInfo(Form("triggering from digits for %s", det->GetName()));
-
-     //   AliLoader* loader = fLoader[iDet];
-     //   loader->LoadDigits("read");
-     //   TTree* digitsTree = loader->TreeD();
-     //   det->Trigger( digitsTree );
-     // or
-        AliTriggerDetector* tdet = det->CreateTriggerDetector();
-        TObjArray* detInp = dtrg->GetTriggerInputs();
-        for( Int_t i=0; i<detInp->GetEntriesFast(); i++ )
-               fInputs.AddLast( detInp->At(i) );
-
-        AliInfo(Form("Execution time for %s: R:%.2fs C:%.2fs",
-                det->GetName(),stopwatchDet.RealTime(),stopwatchDet.CpuTime()));
-      }
-    }
-
-    if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
-      AliError(Form("the following detectors were not found: %s",
-                    detStr.Data()));
+   if( !aCTP->RunTrigger( runLoader ) ) {
       if (fStopOnError) {
-         delete centralTP;
+    //  delete aCTP;
          return kFALSE;
       }
-    }
-
-    // Check trigger conditions
-    centralTP->TriggerConditions();
+   }
 
-    // Write trigger ????
-    centralTP->Write();
+   AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
+           stopwatch.RealTime(),stopwatch.CpuTime()));
 
-  } */
-
-  AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
-               stopwatch.RealTime(),stopwatch.CpuTime()));
+   delete runLoader;
 
-  delete aCTP;
-  delete runLoader;
-
-  return kTRUE;
+   return kTRUE;
 }
 
 
index 05ec093..2bdfcbf 100644 (file)
@@ -81,7 +81,7 @@ AliTriggerCondition& AliTriggerCondition::operator=(const AliTriggerCondition& r
    // AliTriggerCondition assignment operator.
 
    if (this != &rhs) {
-      TObject::operator=(rhs);
+      TNamed::operator=(rhs);
       fClassMask  = rhs.fClassMask;
       fCondition = rhs.fCondition;
    }
index feab539..17b2ac4 100644 (file)
 /* $Id$ */
 
 ///////////////////////////////////////////////////////////////////////////////
-//                                                                           
+//
 // This class for running and define a Trigger Descriptor 
-// 
+//
 // A Trigger Descriptor define a trigger setup for specific runnign
 // condition (Pb-Pb, p-p, p-A, Calibration, etc).
 // It keep:
 //    - cluster detector (List of detectors involved)
-//    - List of conditions                              
+//    - List of conditions
 //
 // Descriptors could be create in advance and store in a file.
 //
 //   Example how to create a Trigger Descriptor:
-//                                                                       
+//
 //   AliTriggerDescriptor descrip( "TEST", "Test Descriptor" );
 //
 //   // Define a Cluster Detector
@@ -44,7 +44,7 @@
 //                         "VO2_M3_ZDC1",
 //                         "Dummy",
 //                          0x0200 );
-//   
+//
 //   descrip.AddCondition( "VZERO_TEST3_L0 | MUON_Unlike_LPt_L0 | ZDC_TEST3_L0",
 //                         "VO3_M1_ZDC3",
 //                         "Dummy",
@@ -54,8 +54,8 @@
 //
 //   // save the descriptor to file 
 //   // (default file name $ALICE_ROOT/data/triggerDescriptor.root)
-//   AliTriggerDescriptor::WriteDescriptor( &descrip );
-//                                                                           
+//   descrip.WriteDescriptor(); or descrip.WriteDescriptor( filename );
+//
 ///////////////////////////////////////////////////////////////////////////////
 
 #include <TString.h>
@@ -100,6 +100,27 @@ AliTriggerDescriptor::AliTriggerDescriptor( const AliTriggerDescriptor& des ):
 TNamed( des ), fDetectorCluster( des.fDetectorCluster )
 {
    // Copy constructor
+   Int_t ncond = des.fConditions.GetEntriesFast();
+   for( Int_t j=0; j<ncond; j++ ) {
+      AddCondition( new AliTriggerCondition( *(AliTriggerCondition*)(des.fConditions.At( j )) ) );
+   }
+}
+
+//______________________________________________________________________________
+AliTriggerDescriptor& AliTriggerDescriptor::operator=(const AliTriggerDescriptor& des)
+{
+   // AliTriggerDescriptor assignment operator.
+
+   if (this != &des) {
+      TNamed::operator=(des);
+      fDetectorCluster = des.fDetectorCluster;
+      fConditions.Delete();
+      Int_t ncond = des.fConditions.GetEntriesFast();
+      for( Int_t j=0; j<ncond; j++ ) {
+         AddCondition( new AliTriggerCondition( *(AliTriggerCondition*)(des.fConditions.At( j )) ) );
+      }
+   }
+   return *this;
 }
 
 //_____________________________________________________________________________
@@ -170,7 +191,7 @@ AliTriggerDescriptor* AliTriggerDescriptor::LoadDescriptor( TString & descriptor
 TObjArray* AliTriggerDescriptor::GetAvailableDescriptors( const char* filename )
 {
    // Return an array of descriptor in the file
-   
+
    TString path;
    if( !filename[0] ) {
       path += gSystem->Getenv( "ALICE_ROOT" );
@@ -185,13 +206,13 @@ TObjArray* AliTriggerDescriptor::GetAvailableDescriptors( const char* filename )
    }
 
    TObjArray* desArray = new TObjArray();
-   
+
    TFile file( path.Data(), "READ" );
    if( file.IsZombie() ) {
       AliErrorGeneral( "AliTriggerDescriptor", Form( "Error opening file (%s)", path.Data() ) );
       return NULL;
    }
-   
+
    file.ReadAll();
 
    TKey* key;
@@ -229,7 +250,7 @@ void AliTriggerDescriptor::WriteDescriptor( const char* filename )
                         Form( "Can't open file (%s)", path.Data() ) );
       return;
    }
-   
+
    Bool_t result = (Write( GetName(), TObject::kOverwrite ) != 0);
    if( !result )
       AliErrorGeneral( "AliTriggerDescriptor",
@@ -237,9 +258,6 @@ void AliTriggerDescriptor::WriteDescriptor( const char* filename )
    file.Close();
 }
 
-
-
-
 //_____________________________________________________________________________
 Bool_t AliTriggerDescriptor::CheckInputsConditions( TString& configfile )
 {
index 824ac92..a81d98f 100644 (file)
@@ -33,7 +33,9 @@ public:
                           AliTriggerDescriptor( TString & name, TString & description );
                           AliTriggerDescriptor( const AliTriggerDescriptor& des );
                virtual   ~AliTriggerDescriptor() { fConditions.SetOwner(); fConditions.Delete(); }
-  //  Setters
+  AliTriggerDescriptor&   operator=(const AliTriggerDescriptor& des);
+
+   //  Setters
                 Bool_t    AddDetectorCluster( TString & cluster );
                   void    AddCondition( TString & cond,  TString & name,
                                         TString & description, Long_t mask  );
index 3f02d7d..e5f8eb2 100644 (file)
@@ -25,6 +25,7 @@
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
+#include <Riostream.h>
 #include <TNamed.h>
 #include <TString.h>
 #include <TObjArray.h>
@@ -133,3 +134,15 @@ void AliTriggerDetector::SetInput( Int_t mask )
    }
 }
 
+//_____________________________________________________________________________
+void AliTriggerDetector::Print( const Option_t* opt ) const
+{
+   // Print
+   cout << "Trigger Detector : " << GetName() << endl;
+   cout << "  Trigger Class Mask: 0x" << hex << GetMask() << dec << endl;
+   Int_t nInputs = fInputs.GetEntriesFast();
+   for( Int_t j=0; j<nInputs; j++ ) {
+      AliTriggerInput* in = (AliTriggerInput*)fInputs.At( j );
+      in->Print( opt );
+   }
+}
index 77ec3d6..07c8f9a 100644 (file)
@@ -13,7 +13,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #include <TObjArray.h>
-class TNamed;
+#include <TNamed.h>
 class TString;
 class AliTriggerInput;
 
@@ -41,6 +41,8 @@ public:
        AliTriggerInput*   GetInput( const char *  name ) {
                              return ((AliTriggerInput*)fInputs.FindObject( name ));
                           }
+          virtual void    Print( const Option_t* opt ="" ) const;
+
 protected:
                 Long_t    fMask;      // Trigger Mask ( bitwise OR of trigger inputs )
              TObjArray    fInputs;    // Array of Triggers Inputs (AliTriggerInput class)
index abe9e2e..c9e3735 100644 (file)
@@ -48,5 +48,5 @@ void AliTriggerInput::Print( const Option_t* ) const
    cout << "Trigger Input:" << endl; 
    cout << "  Name:        " << GetName() << endl;
    cout << "  Description: " << GetTitle() << endl;
-   cout << "  Value:       " << hex << fValue << dec << endl;
+   cout << "  Value:       " << hex << "Ox" << fValue << dec << endl;
 }
index 78046c2..659ef04 100644 (file)
@@ -38,6 +38,10 @@ public:
                                            : TNamed( name.Data(), description.Data() ),
                                              fMask( mask ),
                                              fValue( 0 ) {}
+                          AliTriggerInput( AliTriggerInput & inp )
+                                           : TNamed( inp ),
+                                             fMask( inp.fMask ),
+                                             fValue( inp.fValue ) {}
                virtual   ~AliTriggerInput() {}
 
   //  Setters