MUONTrigger.C

Go to the documentation of this file.

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */


#if !defined(__CINT__) || defined(__MAKECINT__)
#include "AliRun.h"
#include "AliMUON.h"
#include "AliMUONDigit.h"
#include "AliMUONTriggerElectronics.h"
#include "AliMUONCalibrationData.h"
#include "AliCDBManager.h"
#include "AliMUONDataInterface.h"
#include "AliMUONMCDataInterface.h"
#include "AliMUONVTriggerStore.h"
#include "AliMUONDigitStoreV1.h"
#include <TClonesArray.h>
#include "AliMpCDB.h"
#include <TFile.h>
#endif

void MUONTrigger(const char* filename)
{
    // Creating Run Loader and openning file containing Digits 
    AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONLoader","UPDATE");
    if (RunLoader ==0x0) {
        printf(">>> Error : Error Opening %s file \n",filename);
        return;
    }
    // Loading AliRun master
    if (RunLoader->GetAliRun() == 0x0) RunLoader->LoadgAlice();
    gAlice = RunLoader->GetAliRun();
    
    // Loading MUON subsystem
    AliLoader* MUONLoader = RunLoader->GetDetectorLoader("MUON");
    MUONLoader->LoadDigits("READ");
    MUONLoader->LoadRecPoints("UPDATE"); // absolutely essential !!!    
    
    // Creating MUONTriggerDecision
    AliCDBManager* cdbManager = AliCDBManager::Instance();
    cdbManager->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
    
    Int_t runnumber = 0;
    cdbManager->SetRun(runnumber);
    AliMpCDB::LoadDDLStore();
    
    AliMUONCalibrationData *CalibrationData = new AliMUONCalibrationData(runnumber);
    AliMUONTriggerElectronics *TriggerProcessor = new AliMUONTriggerElectronics(CalibrationData);
    
    Int_t nevents = RunLoader->GetNumberOfEvents();
    AliMUONVDigitStore* digitStore=0x0;
    AliMUONVTriggerStore* triggerStore=0x0;
    
    for(Int_t ievent = 0; ievent < nevents; ievent++) {
  printf(">>> Event %i out of %i \n",ievent,nevents);
  RunLoader->GetEvent(ievent);
  
  MUONLoader->LoadRecPoints("update");
  MUONLoader->CleanRecPoints();
  MUONLoader->MakeRecPointsContainer();
  TTree* clustersTree = MUONLoader->TreeR();
  TFile* cfile = clustersTree->GetCurrentFile();
  if ( !cfile ) 
  {
      cout << " could not find Cluster file " << endl;
      return;
  }
  
  MUONLoader->LoadDigits("read");
  TTree* digitsTree = MUONLoader->TreeD();
  TFile* dfile = digitsTree->GetCurrentFile();
  if ( !dfile ) 
  {
      cout << " could not find Digit file " << endl;
      return;
  }
  
// here start reconstruction  
  if (!digitStore) digitStore = AliMUONVDigitStore::Create(*digitsTree);  
  if (!triggerStore) triggerStore = AliMUONVTriggerStore::Create(*digitsTree);
  // insure we start with empty stores
  if ( digitStore ) 
  {
      digitStore->Clear(); 
      Bool_t alone = ( triggerStore ? kFALSE : kTRUE );
      Bool_t ok = digitStore->Connect(*digitsTree,alone);
      if (!ok)
      {
    cerr << "Could not connect digitStore to digitsTree \n";
    return;
      }
  } else {
      cerr << "digitStore does not exist " << "\n";
      return;
  }
  
  digitsTree->GetEvent(0);
  
// process trigger response
  TriggerProcessor->Digits2Trigger(*digitStore,*triggerStore);
  
  //triggerStore->Print();
  
  Bool_t ok(kFALSE);
  if ( triggerStore ) {
      ok = triggerStore->Connect(*clustersTree,kTRUE);
      if (!ok)
      {
    cerr << "Could not create triggerStore branches in TreeR " << "\n";
    return;
      }
  } else {
      cerr << "triggerStore does not exist " << "\n";
      return;
  }

// fill TreeR
  clustersTree->Fill();
  MUONLoader->UnloadDigits();
  MUONLoader->WriteRecPoints("OVERWRITE");
  MUONLoader->UnloadRecPoints();

    }  // loop on events

}