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
#include <TObjString.h>
#include <TObjArray.h>
#include <TStopwatch.h>
+#include <TFile.h>
+#include <TTree.h>
#include "AliLog.h"
#include "AliRun.h"
#include "AliTriggerCondition.h"
#include "AliTriggerDescriptor.h"
#include "AliCentralTrigger.h"
+#include "AliDetectorEventHeader.h"
+#include "AliHeader.h"
+
ClassImp( AliCentralTrigger )
LoadDescriptor( 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 )
{
// Ej: "Pb-Pb" or "p-p-DIMUON CALIBRATION-CENTRAL-BARREL"
// Delete any descriptor
- fDescriptors.Delete();
+ Reset();
// Load the selected descriptors
TObjArray* desArray = descriptor.Tokenize( " " );
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();
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()
return result;
}
-
//_____________________________________________________________________________
void AliCentralTrigger::Print( const Option_t* ) const
{
#include <TObject.h>
#include <TObjArray.h>
+class TTree;
class AliRunLoader;
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; }
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
#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():
fGAFile(0x0),
fHeader(0x0),
fStack(0x0),
+ fCTrigger(0x0),
fKineDataLoader(0x0),
fTrackRefsDataLoader(0x0),
fNEventsPerFile(1),
fGAFile(0x0),
fHeader(0x0),
fStack(0x0),
+ fCTrigger(0x0),
fKineDataLoader(new AliDataLoader(fgkDefaultKineFileName,fgkKineContainerName,"Kinematics")),
fTrackRefsDataLoader(new AliDataLoader(fgkDefaultTrackRefsFileName,fgkTrackRefsContainerName,"Track References")),
fNEventsPerFile(1),
fGAFile(0x0),
fHeader(0x0),
fStack(0x0),
+ fCTrigger(0x0),
fKineDataLoader(0x0),
fTrackRefsDataLoader(0x0),
fNEventsPerFile(0),
RemoveEventFolder();
//fEventFolder is deleted by the way of removing - TopAliceFolder owns it
+ if( fCTrigger ) delete fCTrigger;
delete fHeader;
delete fStack;
delete fGAFile;
fGAFile(0x0),
fHeader(0x0),
fStack(0x0),
+ fCTrigger(0x0),
fKineDataLoader(new AliDataLoader(fgkDefaultKineFileName,fgkKineContainerName,"Kinematics")),
fTrackRefsDataLoader(new AliDataLoader(fgkDefaultTrackRefsFileName,fgkTrackRefsContainerName,"Track References")),
fNEventsPerFile(1),
{
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)
}
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
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())
{
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()))
}
/**************************************************************************/
+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
}
/**************************************************************************/
+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
{
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*/)
CleanDetectors();
CleanHeader();
CleanKinematics();
+ CleanTrigger();
}
/**************************************************************************/
AliDebug(1, Form("name=%s, cleaning %s.",GetName(),name.Data()));
GetEventFolder()->Remove(obj);
delete obj;
+ obj = 0x0;
}
}
}
/**************************************************************************/
+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
fKineDataLoader->Synchronize();
fTrackRefsDataLoader->Synchronize();
+
+ TFile* file = gROOT->GetFile( gSystem->ConcatFileName( fUnixDirName.Data(), fgkDefaultTriggerFileName.Data() ) ) ;
+ if( file ) file->Flush();
if (fGAFile) fGAFile->Flush();
}
class AliStack;
class AliRunDigitizer;
class AliCDBEntry;
-
+class AliCentralTrigger;
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();
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;}
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="");
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:
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
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
/*********************************************/
void GetListOfDetectors(const char * namelist,TObjArray& pointerarray) const;
void CleanHeader(){Clean(fgkHeaderContainerName);}
+ void CleanTrigger(){Clean(fgkTriggerContainerName);}
void Clean(const TString& name);
Int_t SetEvent();
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
{
// 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;
}
// AliTriggerCondition assignment operator.
if (this != &rhs) {
- TObject::operator=(rhs);
+ TNamed::operator=(rhs);
fClassMask = rhs.fClassMask;
fCondition = rhs.fCondition;
}
/* $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
// "VO2_M3_ZDC1",
// "Dummy",
// 0x0200 );
-//
+//
// descrip.AddCondition( "VZERO_TEST3_L0 | MUON_Unlike_LPt_L0 | ZDC_TEST3_L0",
// "VO3_M1_ZDC3",
// "Dummy",
//
// // 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>
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;
}
//_____________________________________________________________________________
TObjArray* AliTriggerDescriptor::GetAvailableDescriptors( const char* filename )
{
// Return an array of descriptor in the file
-
+
TString path;
if( !filename[0] ) {
path += gSystem->Getenv( "ALICE_ROOT" );
}
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;
Form( "Can't open file (%s)", path.Data() ) );
return;
}
-
+
Bool_t result = (Write( GetName(), TObject::kOverwrite ) != 0);
if( !result )
AliErrorGeneral( "AliTriggerDescriptor",
file.Close();
}
-
-
-
//_____________________________________________________________________________
Bool_t AliTriggerDescriptor::CheckInputsConditions( TString& configfile )
{
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 );
// //
///////////////////////////////////////////////////////////////////////////////
+#include <Riostream.h>
#include <TNamed.h>
#include <TString.h>
#include <TObjArray.h>
}
}
+//_____________________________________________________________________________
+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 );
+ }
+}
///////////////////////////////////////////////////////////////////////////////
#include <TObjArray.h>
-class TNamed;
+#include <TNamed.h>
class TString;
class AliTriggerInput;
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)
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;
}
: TNamed( name.Data(), description.Data() ),
fMask( mask ),
fValue( 0 ) {}
+ AliTriggerInput( AliTriggerInput & inp )
+ : TNamed( inp ),
+ fMask( inp.fMask ),
+ fValue( inp.fValue ) {}
virtual ~AliTriggerInput() {}
// Setters
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff