#include "AliMUONTrack.h"
#include "AliMUONESDInterface.h"
#include "AliESDMuonTrack.h"
-#include "AliMUONRecoParam.h"
#include "AliESDEvent.h"
#include "TTree.h"
#include "TString.h"
return;
}
- AliMUONRecoParam* recoParam = AliMUONRecoParam::GetCosmicParam();
-
- cout << "FIXME: I should get the RecoParams from the OCDB at this point !" << endl;
-
Int_t nTracks = Int_t(esdEvent->GetNumberOfMuonTracks());
for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
esdTrack = esdEvent->GetMuonTrack(iTrack);
if (!esdTrack->ClustersStored()) continue;
- AliMUONESDInterface::ESDToMUON(recoParam,*esdTrack,muonTrack);
+ AliMUONESDInterface::ESDToMUON(*esdTrack,muonTrack);
nTrackParam = muonTrack.GetTrackParamAtCluster()->GetEntries();
for(Int_t iCluster = 0; iCluster < nTrackParam; iCluster++) {
trackParam = (AliMUONTrackParam *) muonTrack.GetTrackParamAtCluster()->At(iCluster);
delete esdEvent;
- delete recoParam;
-
esdFile->Close();
}
#include <AliMUONConstants.h>
#include <AliMUONESDInterface.h>
#include <AliMUONVCluster.h>
-#include <AliMUONRecoParam.h>
#include <TClonesArray.h>
#include <TStyle.h>
fTrack = new AliMUONTrack();
- AliMUONRecoParam* recoParam = AliMUONRecoParam::GetCosmicParam();
-
- cout << "FIXME: should get recoParam from OCDB here !" << endl;
-
// create a simple track from the ESD track
- AliMUONESDInterface::ESDToMUON(recoParam,*mtrack,*fTrack);
-
- delete recoParam;
+ AliMUONESDInterface::ESDToMUON(*mtrack,*fTrack);
// reset track parameters at vertex to the ones at DCA
AliMUONTrackParam paramAtDCA;
/// 2) loading a whole ESDEvent and using the finders and/or the iterators
/// to access the corresponding MUON objects
///
+/// note: You can set the recoParam used to refit the MUON track with ResetTracker(...);
+/// By default we use Kalman filter + Smoother
+///
/// \author Philippe Pillot
//-----------------------------------------------------------------------------
ClassImp(AliMUONESDInterface)
/// \endcond
+AliMUONRecoParam* AliMUONESDInterface::fgRecoParam = 0x0;
AliMUONVTrackReconstructor* AliMUONESDInterface::fgTracker = 0x0;
TString AliMUONESDInterface::fgTrackStoreName = "AliMUONTrackStoreV1";
TString AliMUONESDInterface::fgTriggerStoreName = "AliMUONTriggerStoreV1";
//_____________________________________________________________________________
-AliMUONESDInterface::AliMUONESDInterface(AliMUONRecoParam* recoParam)
+AliMUONESDInterface::AliMUONESDInterface()
: TObject(),
-fRecoParam(recoParam),
fTracks(0x0),
fDigits(0x0),
fTriggers(0x0),
if (!esdTrack->ContainTrackerData()) continue;
// add it to track store
- AliMUONTrack* track = Add(GetRecoParam(),*esdTrack, *fTracks);
+ AliMUONTrack* track = Add(*esdTrack, *fTracks);
// prepare cluster map
AliMpExMap* cMap = new AliMpExMap;
// static methods //
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
+//_____________________________________________________________________________
+void AliMUONESDInterface::ResetTracker(const AliMUONRecoParam* recoParam)
+{
+ /// Reset the MUON tracker using "recoParam" if provided.
+ /// If not provided, will use Kalman filter + Smoother
+
+ delete fgTracker;
+ delete fgRecoParam;
+
+ if (recoParam) {
+
+ fgRecoParam = new AliMUONRecoParam(*recoParam);
+
+ }else {
+
+ fgRecoParam = AliMUONRecoParam::GetLowFluxParam();
+ fgRecoParam->SetTrackingMode("KALMAN");
+ fgRecoParam->UseSmoother(kTRUE);
+ fgRecoParam->SetBendingVertexDispersion(10.);
+
+ }
+
+ fgTracker = AliMUONTracker::CreateTrackReconstructor(fgRecoParam,0x0);
+
+}
+
//_____________________________________________________________________________
AliMUONVTrackStore* AliMUONESDInterface::NewTrackStore()
{
}
//_____________________________________________________________________________
-void AliMUONESDInterface::ESDToMUON(const AliMUONRecoParam* recoParam, const AliESDMuonTrack& esdTrack, AliMUONTrack& track)
+void AliMUONESDInterface::ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONTrack& track)
{
/// Transfert data from ESDMuon track to MUON track
+ /// note: The MUON track recovered from ESD is refitted by using the provided recoParams.
+ /// If not provided (=0x0), the parameters at each cluster are simply the
+ /// extrapolation of parameters at the first one.
// if the ESDMuon track is a ghost then return an empty MUON track
if (!esdTrack.ContainTrackerData()) {
AliMUONTrackExtrap::ExtrapToZCov(firstTrackParam,firstTrackParam->GetClusterPtr()->GetZ());
// refit the track to get better parameters and covariances at each cluster (temporary disable track improvement)
- if (!fgTracker) fgTracker = AliMUONTracker::CreateTrackReconstructor(recoParam,0x0);
+ if (!fgTracker) ResetTracker();
if (!fgTracker->RefitTrack(track, kFALSE)) track.UpdateCovTrackParamAtCluster();
} else {
}
//___________________________________________________________________________
-AliMUONTrack*
-AliMUONESDInterface::Add(const AliMUONRecoParam* recoParam, const AliESDMuonTrack& esdTrack, AliMUONVTrackStore& trackStore)
+AliMUONTrack* AliMUONESDInterface::Add(const AliESDMuonTrack& esdTrack, AliMUONVTrackStore& trackStore)
{
/// Create MUON track from ESDMuon track and add it to the store
/// return a pointer to the track into the store (0x0 if the track already exist)
if(trackStore.FindObject(esdTrack.GetUniqueID())) return 0x0;
AliMUONTrack* track = trackStore.Add(AliMUONTrack());
- ESDToMUON(recoParam,esdTrack, *track);
+ ESDToMUON(esdTrack, *track);
return track;
}
{
public: // methods to play with internal objects
- AliMUONESDInterface(AliMUONRecoParam* recoParam);
+ AliMUONESDInterface();
virtual ~AliMUONESDInterface();
virtual void Clear(Option_t* = "");
TIterator* CreateDigitIteratorInCluster(UInt_t clusterId) const;
TIterator* CreateLocalTriggerIterator() const;
- const AliMUONRecoParam* GetRecoParam() const { return fRecoParam; }
public: // static methods
+ /// Reset the MUON tracker (using "recoParam" if provided)
+ static void ResetTracker(const AliMUONRecoParam* recoParam = 0x0);
+
/// Set the version of track store
static void UseTrackStore(TString name) {fgTrackStoreName = name;}
/// Set the version of cluster store
static void SetParamCov(const AliMUONTrackParam& trackParam, AliESDMuonTrack& esdTrack);
// ESDMuon objects --> MUON objects conversion
- static void ESDToMUON(const AliMUONRecoParam* recoParam, const AliESDMuonTrack& esdTrack, AliMUONTrack& track);
+ static void ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONTrack& track);
static void ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONLocalTrigger& locTrg);
static void ESDToMUON(const AliESDMuonCluster& esdCluster, AliMUONVCluster& cluster);
static void ESDToMUON(const AliESDMuonPad& esdPad, AliMUONVDigit& digit);
// Add ESD object into the corresponding MUON store
// return a pointer to the corresponding MUON object into the store
- static AliMUONTrack* Add(const AliMUONRecoParam* recoParam, const AliESDMuonTrack& esdTrack, AliMUONVTrackStore& trackStore);
+ static AliMUONTrack* Add(const AliESDMuonTrack& esdTrack, AliMUONVTrackStore& trackStore);
static void Add(const AliESDMuonTrack& esdTrack, AliMUONVTriggerStore& triggerStore);
static AliMUONVCluster* Add(const AliESDMuonCluster& esdCluster, AliMUONVClusterStore& clusterStore);
static AliMUONVDigit* Add(const AliESDMuonPad& esdPad, AliMUONVDigitStore& digitStore);
private:
- static AliMUONVTrackReconstructor* fgTracker; ///< track reconstructor for refitting
+ static AliMUONRecoParam* fgRecoParam; ///< reconstruction parameters for refitting
+ static AliMUONVTrackReconstructor* fgTracker; ///< track reconstructor for refitting
static TString fgTrackStoreName; ///< class name of the track store to use
static TString fgClusterStoreName; ///< class name of the cluster store to use
AliMpExMap* fClusterMap; ///< map of clusters
AliMpExMap* fDigitMap; ///< map of digits
- const AliMUONRecoParam* fRecoParam; ///< get reco param
ClassDef(AliMUONESDInterface,0)
};
#include "AliMUONVClusterStore.h"
#include "AliMUONConstants.h"
#include "AliMUONESDInterface.h"
-#include "AliMUONRecoParam.h"
#include "AliMCEventHandler.h"
#include "AliMCEvent.h"
#include "AliStack.h"
/// \endcond
//_____________________________________________________________________________
-AliMUONRecoCheck::AliMUONRecoCheck(AliMUONRecoParam* recoParam, Char_t *esdFileName, Char_t *pathSim)
+AliMUONRecoCheck::AliMUONRecoCheck(Char_t *esdFileName, Char_t *pathSim)
: TObject(),
-fRecoParam(recoParam),
fMCEventHandler(new AliMCEventHandler()),
fESDEvent(new AliESDEvent()),
fESDTree (0x0),
Int_t nTracks = (Int_t) fESDEvent->GetNumberOfMuonTracks();
for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
AliESDMuonTrack* esdTrack = fESDEvent->GetMuonTrack(iTrack);
- if (esdTrack->ContainTrackerData()) AliMUONESDInterface::Add(GetRecoParam(),*esdTrack, *fRecoTrackStore);
+ if (esdTrack->ContainTrackerData()) AliMUONESDInterface::Add(*esdTrack, *fRecoTrackStore);
}
}
class AliESDEvent;
class AliMCEventHandler;
class AliMUONVTrackStore;
-class AliMUONRecoParam;
class AliMUONRecoCheck : public TObject
{
public:
- AliMUONRecoCheck(AliMUONRecoParam* recoParam, Char_t *chLoader, Char_t *pathSim = "./");
+ AliMUONRecoCheck(Char_t *chLoader, Char_t *pathSim = "./");
virtual ~AliMUONRecoCheck();
/// Return the list of reconstructed tracks
/// Not implemented
AliMUONRecoCheck& operator = (const AliMUONRecoCheck& rhs);
- const AliMUONRecoParam* GetRecoParam() const { return fRecoParam; }
-
void ResetStores();
void MakeReconstructedTracks();
AliMUONVTrackStore* fRecoTrackRefStore; ///< current reconstructible tracks (owner)
AliMUONVTrackStore* fRecoTrackStore; ///< current reconstructed tracks (owner)
- const AliMUONRecoParam* fRecoParam; ///< pointer to reco param
-
ClassDef(AliMUONRecoCheck, 0) //Utility class to check reconstruction
};
#include "AliMUONRecoParam.h"
+#include "AliMUONPadStatusMaker.h"
+#include "AliRecoParam.h"
#include "AliLog.h"
-#include "AliMUONPadStatusMaker.h"
#include <Riostream.h>
fChargeSigmaCut(4.0)
{
/// Constructor
- SetNameTitle("MUON","MUON");
- SetDefaultLimits();
-
- // use the default parameters for low flux environment
- SetLowFluxParam();
+ SetNameTitle("Dummy","Dummy");
+ SetDefaultLimits();
}
//_____________________________________________________________________________
{
/// Set reconstruction parameters for low flux environment
+ SetNameTitle("Low Flux","Low Flux");
+ SetEventSpecie(AliRecoParam::kLowMult);
fMinBendingMomentum = 1.;
fMaxBendingMomentum = 3000.;
fMaxNonBendingSlope = 0.3;
{
/// Set reconstruction parameters for high flux environment
+ SetNameTitle("High Flux","High Flux");
+ SetEventSpecie(AliRecoParam::kHighMult);
fMinBendingMomentum = 1.;
fMaxBendingMomentum = 3000.;
fMaxNonBendingSlope = 0.3;
{
/// Set reconstruction parameters for high flux environment
+ SetNameTitle("Cosmic","Cosmic");
+ SetEventSpecie(AliRecoParam::kCosmic);
fMinBendingMomentum = 1.;
fMaxBendingMomentum = 10000000.;
fMaxNonBendingSlope = 0.3;
/// print reconstruction parameters
/// if option = FULL then print also unused parameters
- cout<<endl<<"\t------Reconstruction parameters------"<<endl;
+ cout<<endl<<"\t------Reconstruction parameters ("<<GetName()<<")------"<<endl;
+
+ if (IsDefault()) cout<<"\t\t*** Parameters used by default ***"<<endl;
cout<<Form("Calibration mode = %s",fCalibrationMode.Data())<<endl;
cout<<Form("Clustering mode = %s",fClusteringMode.Data())<<endl;
cout << Form("And we cut on charge >= %7.2f x ( pedestal sigma ) ",ChargeSigmaCut()) << endl;
- cout<<"\t-------------------------------------"<<endl<<endl;
+ cout<<"\t----------------------------------------------"<<endl<<endl;
}
///
/// Implementation of AliReconstructor for MUON subsystem.
///
-/// The clustering mode and the associated parameters can be changed by using
-/// AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLow(High)FluxParam();
-/// muonRecoParam->Set...(); // see methods in AliMUONRecoParam.h for details
-/// AliRecoParam::Instance()->RegisterRecoParam(muonRecoParam);
+/// The clustering mode and the associated parameters can be changed through the
+/// AliMUONRecoParam object set in the reconstruction macro or read from the CDB
+/// (see methods in AliMUONRecoParam.h file for details)
///
/// Valid modes are :
///
//-----------------------------------------------------------------------------
/// \class AliMUONRefitter
///
-/// create new MUON object from ESD objects given as input (through the ESDInterface):
+/// This class has been developped to simplify the re-reconstruction of the MUON tracks
+/// stored into ESD with different recoParams and/or after having re-calibrated the digits.
+/// It creates new MUON object from ESD objects given as input (through the ESDInterface) then:
///
/// - re-clusterize the ESD clusters using the attached ESD pads
/// (several new clusters can be reconstructed per ESD cluster)
//_____________________________________________________________________________
AliMUONRefitter::AliMUONRefitter(const AliMUONRecoParam* recoParam)
: TObject(),
+ fRecoParam(recoParam),
fGeometryTransformer(0x0),
fClusterServer(0x0),
fTracker(0x0),
private:
+ const AliMUONRecoParam* fRecoParam; ///< pointer to reco param (not owner)
AliMUONGeometryTransformer* fGeometryTransformer; ///< geometry transformer (owner)
AliMUONVClusterServer* fClusterServer; ///< clusterizer (owner)
AliMUONVTrackReconstructor* fTracker; ///< tracker (owner)
AliMUONESDInterface* fESDInterface; ///< container of MUON tracks/clusters/digits (not owner)
- const AliMUONRecoParam* fRecoParam; ///< pointer to reco param
ClassDef(AliMUONRefitter,0)
};
#include "AliMUONTrack.h"
#include "AliMUONReconstructor.h"
-#include "AliMUONRecoParam.h"
#include "AliMUONVCluster.h"
#include "AliMUONVClusterStore.h"
#include "AliMUONObjectPair.h"
Int_t nClusters = GetNClusters();
AliMUONTrackParam *trackParam;
Int_t currentStation(0);
+ UInt_t presentStationMask(0);
- UInt_t m(0);
-
- for (Int_t i = 0; i < nClusters; i++)
- {
+ for (Int_t i = 0; i < nClusters; i++) {
trackParam = (AliMUONTrackParam*) fTrackParamAtCluster->UncheckedAt(i);
-
- // skip unrequested stations
-// while (expectedStation < AliMUONConstants::NTrackingSt() &&
-// !AliMUONReconstructor::GetRecoParam()->RequestStation(expectedStation)) expectedStation++;
-//
-
currentStation = trackParam->GetClusterPtr()->GetChamberId()/2;
-
- m |= ( 1 << currentStation );
-
+ presentStationMask |= ( 1 << currentStation );
}
- return ( (requestedStationMask & m) == requestedStationMask ) ;
+ return ( (requestedStationMask & presentStationMask) == requestedStationMask );
}
//__________________________________________________________________________
#include "AliMUONTrackParam.h"
#include "AliMUONConstants.h"
#include "AliMUONReconstructor.h"
-#include "AliMUONRecoParam.h"
#include "AliMagF.h"
#include "AliMpVSegmentation.h"
#include "AliMpDEManager.h"
#include "AliMUONReconstructor.h"
-#include "AliMUONRecoParam.h"
#include "AliMUONTriggerTrack.h"
#include "AliMUONVTriggerTrackStore.h"
void CheckConstants() const;
+ const AliMUONRecoParam* fRecoParam; //!< pointer to reco parameters
const AliMUONGeometryTransformer& fTransformer; //!< geometry transformer
const AliMUONDigitMaker& fDigitMaker; //!< pointer to digit maker
kSlatEff,
kBoardEff
};
-
- const AliMUONRecoParam* fRecoParam; //!< pointer to reco parameters
ClassDef(AliMUONTrackHitPattern, 0) // MUON track hit pattern
};
/// re-fit the given track
// check validity of the track
- if (!track.IsValid(GetRecoParam()->RequestedStationMask())) {
+ if (track.GetNClusters() < 3) {
AliWarning("the track does not contain enough clusters --> unable to refit");
return kFALSE;
}
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
cout << "ComplementTracks: found one cluster in chamber(1..): " << chamberId+1 << endl;
bestTrackParamAtCluster.GetClusterPtr()->Print();
- cout<<endl<<"Track parameters and covariances at cluster:"<<endl;
- bestTrackParamAtCluster.GetParameters().Print();
- bestTrackParamAtCluster.GetCovariances().Print();
+ if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2)) {
+ cout<<endl<<"Track parameters and covariances at cluster:"<<endl;
+ bestTrackParamAtCluster.GetParameters().Print();
+ bestTrackParamAtCluster.GetCovariances().Print();
+ }
}
trackParam->SetRemovable(kTRUE);
/// re-fit the given track
// check validity of the track
- if (!track.IsValid(GetRecoParam()->RequestedStationMask())) {
+ if (track.GetNClusters() < 3) {
AliWarning("the track does not contain enough clusters --> unable to refit");
return kFALSE;
}
/// reconstruct tracks from recpoints
///
/// Actual tracking is performed by some AliMUONVTrackReconstructor children
-/// Tracking modes (ORIGINAL, KALMAN) and associated options and parameters
-/// can be changed by using:
-/// AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLow(High)FluxParam();
-/// muonRecoParam->Set...(); // see methods in AliMUONRecoParam.h for details
-/// AliMUONReconstructor::SetRecoParam(muonRecoParam);
+/// Tracking modes (ORIGINAL, KALMAN) and associated options and parameters can be changed
+/// through the AliMUONRecoParam object set in the reconstruction macro or read from the CDB
+/// (see methods in AliMUONRecoParam.h file for details)
///
/// \author Christian Finck and Laurent Aphecetche, SUBATECH Nantes
//-----------------------------------------------------------------------------
/// * ValidateTracksWithTrigger to match tracker/trigger tracks
///
/// Several options and adjustable parameters are available for both KALMAN and ORIGINAL
-/// tracking algorithms. They can be changed by using:
-/// AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLow(High)FluxParam();
-/// muonRecoParam->Set...(); // see methods in AliMUONRecoParam.h for details
-/// AliMUONReconstructor::SetRecoParam(muonRecoParam);
+/// tracking algorithms. They can be changed through the AliMUONRecoParam object
+/// set in the reconstruction macro or read from the CDB
+/// (see methods in AliMUONRecoParam.h file for details)
///
/// Main parameters and options are:
/// - *fgkSigmaToCutForTracking* : quality cut used to select new clusters to be
// Author: Philippe Pillot
#include "AliMUONReconstructor.h"
-#include "AliMUONRecoParam.h"
#include <TObject.h>
virtual Bool_t RefitTrack(AliMUONTrack &track, Bool_t enableImprovement = kTRUE) = 0;
- // methods previously got from the static muonrecoparam:
- //
- // MakeMoreTrackCandidates()
- //
- // ComplementTracks()
- //
- // ImproveTracks()
- //
- // GetMaxNonBendingSlope()
- // GetMaxBendingSlope()
- //
- // GetMinBendingMomentum()
- // GetMaxBendingMomentum()
- //
- // UseChamber(Int_t chamberId)
- //
- // GetMaxNonBendingDistanceToTrack()
- // GetSigmaCutForTracking()
- // GetMaxBendingDistanceToTrack()
- // GetSigmaCutForTracking()
- // TrackAllTracks()
- // RequestStation(Int_t stationId)
-
protected:
TClonesArray *fRecTracksPtr; ///< pointer to array of reconstructed tracks
#include "AliMUONTrackParam.h"
#include "AliMUONGeometryTransformer.h"
#include "AliMUONESDInterface.h"
-#include "AliMUONRecoParam.h"
#include "AliESDEvent.h"
#include "AliESDMuonTrack.h"
fBenMom->Fill(1./invBenMom);
if (TMath::Abs(invBenMom)<=1.04) {
AliMUONTrack track;
- AliMUONESDInterface::ESDToMUON(AliMUONRecoParam::GetLowFluxParam(),*esdTrack, track);
+ AliMUONESDInterface::ESDToMUON(*esdTrack, track);
alig->ProcessTrack(&track);
alig->LocalFit(iTrackOk++,trackParams,0);
}
void MUONClusterInfo(Int_t nevents = -1, const char* esdFileName = "AliESDs.root", const char* outFileName = "clusterInfo.root")
{
/// load ESD event in the ESDInterface to recover MUON objects;
+ /// track parameters at each cluster are recomputed by the interface using Kalman filter + Smoother
+ /// (It can be changed by resetting the tracker in the interface with a new recoParam object);
/// fill AliMUONESDClusterInfo object with ESD cluster + corresponding track parameters;
/// write results in a new root file.
exit(-1);
}
- // eventually set reconstruction parameters for refit (otherwise read from OCDB)
-/* AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLowFluxParam();
- muonRecoParam->Print("FULL");
- AliRecoParam::Instance()->RegisterRecoParam(muonRecoParam);
-*/
+ // Reset the reconstruction parameters for track refitting if needed
+ // (by default will use Kalman filter + Smoother)
+// AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLowFluxParam();
+// AliMUONESDInterface::ResetTracker(muonRecoParam);
+
}
//-----------------------------------------------------------------------
// prepare the refitting
gRandom->SetSeed(1);
Prepare();
+
+ // set reconstruction parameters used for refitting
+ AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLowFluxParam();
+ muonRecoParam->Print("FULL");
+
AliMUONESDInterface esdInterface;
- AliMUONRefitter refitter;
+ AliMUONRefitter refitter(muonRecoParam);
refitter.Connect(&esdInterface);
// open the ESD file and tree
TFile* esdFile = TFile::Open(esdFileNameIn);
TTree* esdTree = GetESDTree(esdFile);
- // create the ESD output tree
- gROOT->cd();
+ // create the ESD output file and tree
+ TFile* newESDFile = TFile::Open(esdFileNameOut, "RECREATE");
+ newESDFile->SetCompressionLevel(2);
TTree* newESDTree = esdTree->CloneTree(0);
// connect ESD event to the ESD tree
timer.Stop();
// write output ESD tree
- TFile* newESDFile = TFile::Open(esdFileNameOut, "RECREATE");
- newESDFile->SetCompressionLevel(2);
+ newESDFile->cd();
newESDTree->Write();
+ delete newESDTree;
newESDFile->Close();
// free memory
esdFile->Close();
- delete newESDTree;
delete esd;
cout<<endl<<"time to refit: R:"<<timer.RealTime()<<" C:"<<timer.CpuTime()<<endl<<endl;
exit(-1);
}
- // set reconstruction parameters
- AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLowFluxParam();
- muonRecoParam->CombineClusterTrackReco(kFALSE);
- muonRecoParam->Print("FULL");
- AliRecoParam::Instance()->RegisterRecoParam(muonRecoParam);
-
}
//-----------------------------------------------------------------------
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff