EMCALJetTasks/AliEmcalJet.cxx
EMCALJetTasks/AliEmcalJetTask.cxx
EMCALJetTasks/AliHadCorrTask.cxx
+ EMCALJetTasks/AliJetModelBaseTask.cxx
EMCALJetTasks/AliJetEmbeddingTask.cxx
+ EMCALJetTasks/AliJetRandomizerTask.cxx
EMCALJetTasks/AliAnalysisTaskEmcalJetSpectra.cxx
EMCALJetTasks/AliAnalysisTaskRhoBase.cxx
EMCALJetTasks/AliAnalysisTaskRho.cxx
fOutputList->Add(fHistJetAreavsNtrack);
fOutputList->Add(fHistNjetvsNtrack);
- fOutputList->Add(fNewRhoFunction);
+ //fOutputList->Add(fNewRhoFunction);
PostData(1, fOutputList);
//________________________________________________________________________
void AliAnalysisTaskRho::Terminate(Option_t *)
{
+ /*
fHistRhovsCent->Fit(fNewRhoFunction, "NO");
PostData(1, fOutputList);
+ */
}
fOutputList->Add(fHistEtvsNtrack);
fOutputList->Add(fHistScalevsNtrack);
fOutputList->Add(fHistDeltaScalevsNtrack);
- fOutputList->Add(fNewScaleFunction);
+ //fOutputList->Add(fNewScaleFunction);
PostData(1, fOutputList);
}
//________________________________________________________________________
void AliAnalysisTaskScale::Terminate(Option_t *)
{
+ /*
fHistScalevsCent->Fit(fNewScaleFunction, "NO");
PostData(1, fOutputList);
+ */
}
//________________________________________________________________________
AliJetEmbeddingTask::AliJetEmbeddingTask() :
- AliAnalysisTaskSE("AliJetEmbeddingTask"),
- fGeomName(),
- fTracksName(),
- fOutTracksName(),
- fCaloName(),
- fOutCaloName(),
- fEtaMin(-1),
- fEtaMax(1),
- fPhiMin(0),
- fPhiMax(TMath::Pi() * 2),
- fPtMin(0),
- fPtMax(0),
- fCopyArray(kTRUE),
- fNEmbClusters(0),
- fNEmbTracks(0),
- fGeom(0),
- fClusters(0),
- fOutClusters(0),
- fTracks(0),
- fOutTracks(0)
+ AliJetModelBaseTask("AliJetEmbeddingTask")
{
// Default constructor.
+ SetSuffix("Embedded");
}
//________________________________________________________________________
AliJetEmbeddingTask::AliJetEmbeddingTask(const char *name) :
- AliAnalysisTaskSE(name),
- fGeomName(""),
- fTracksName("PicoTracks"),
- fOutTracksName("PicoTracksEmbedded"),
- fCaloName("CaloClustersCorr"),
- fOutCaloName("CaloClustersCorrEmbedded"),
- fEtaMin(-1),
- fEtaMax(1),
- fPhiMin(0),
- fPhiMax(TMath::Pi() * 2),
- fPtMin(50),
- fPtMax(60),
- fCopyArray(kTRUE),
- fNEmbClusters(0),
- fNEmbTracks(1),
- fGeom(0),
- fClusters(0),
- fOutClusters(0),
- fTracks(0),
- fOutTracks(0)
+ AliJetModelBaseTask(name)
{
// Standard constructor.
-
+ SetSuffix("Embedded");
}
//________________________________________________________________________
// Destructor
}
-//________________________________________________________________________
-void AliJetEmbeddingTask::Init()
-{
- // Init task.
-
- if (fPtMax < fPtMin) {
- AliWarning (Form("PtMax (%f) < PtMin (%f), setting PtMax = PtMin = %f", fPtMax, fPtMin, fPtMin));
- fPtMax = fPtMin;
- }
-
- if (fEtaMax < fEtaMin) {
- AliWarning (Form("EtaMax (%f) < EtaMin (%f), setting EtaMax = EtaMin = %f", fEtaMax, fEtaMin, fEtaMin));
- fEtaMax = fEtaMin;
- }
-
- if (fPhiMax < fPhiMin) {
- AliWarning (Form("PhiMax (%f) < PhiMin (%f), setting PhiMax = PhiMin = %f", fPhiMax, fPhiMin, fPhiMin));
- fPhiMax = fPhiMin;
- }
-
- if (fNEmbTracks > 0) {
- fTracks = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fTracksName));
-
- if (strcmp(fTracks->GetClass()->GetName(), "AliPicoTrack")) {
- AliError("Can only embed PicoTracks!");
- return;
- }
-
- if (!fTracks) {
- AliError(Form("Couldn't retrieve tracks with name %s!", fTracksName.Data()));
- return;
- }
-
- if (!fOutTracks) {
- fOutTracksName = fTracksName;
- if (fCopyArray) {
- fOutTracksName += "Embedded";
- fOutTracks = new TClonesArray(*fTracks);
- fOutTracks->SetName(fOutTracksName);
- }
- else {
- fOutTracks = fTracks;
- }
- }
-
- if (fCopyArray) {
- if (!(InputEvent()->FindListObject(fOutTracksName)))
- InputEvent()->AddObject(fOutTracks);
- fOutTracks->Clear();
- }
- }
-
- if (fNEmbClusters > 0) {
- fClusters = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fCaloName));
-
- if (!fClusters) {
- AliError(Form("Couldn't retrieve clusters with name %s!", fCaloName.Data()));
- return;
- }
-
- if (!fOutClusters) {
- fOutCaloName = fCaloName;
- if (fCopyArray) {
- fOutCaloName += "Embedded";
- fOutClusters = new TClonesArray(*fClusters);
- fOutClusters->SetName(fOutCaloName);
- }
- else {
- fOutClusters = fClusters;
- }
- }
-
- if (fCopyArray) {
- if (!(InputEvent()->FindListObject(fOutCaloName)))
- InputEvent()->AddObject(fOutClusters);
- fOutClusters->Clear();
- }
- }
-
- if (!fGeom) {
- if (fGeomName.Length()>0) {
- fGeom = AliEMCALGeometry::GetInstance(fGeomName);
- if (!fGeom)
- AliError(Form("Could not get geometry with name %s!", fGeomName.Data()));
- } else {
- fGeom = AliEMCALGeometry::GetInstance();
- if (!fGeom)
- AliError("Could not get default geometry!");
- }
- }
-}
//________________________________________________________________________
-void AliJetEmbeddingTask::Embed()
+void AliJetEmbeddingTask::Run()
{
// Embed particles.
- if (fNEmbClusters > 0 && fOutClusters) {
- Float_t emEtaMax = fEtaMax;
- Float_t emEtaMin = fEtaMin;
- Float_t emPhiMax = fPhiMax;
- Float_t emPhiMin = fPhiMin;
-
- // hard-coded Emcal boundaries
- const Float_t EmcalEtaMin = -0.7;
- const Float_t EmcalEtaMax = 0.7;
- const Float_t EmcalPhiMin = 80 * TMath::DegToRad();
- const Float_t EmcalPhiMax = 180 * TMath::DegToRad();
-
- if (emEtaMax > EmcalEtaMax) emEtaMax = EmcalEtaMax;
- if (emEtaMax < EmcalEtaMin) emEtaMax = EmcalEtaMin;
- if (emEtaMin > EmcalEtaMax) emEtaMin = EmcalEtaMax;
- if (emEtaMin < EmcalEtaMin) emEtaMin = EmcalEtaMin;
-
- if (emPhiMax > EmcalPhiMax) emPhiMax = EmcalPhiMax;
- if (emPhiMax < EmcalPhiMin) emPhiMax = EmcalPhiMin;
- if (emPhiMin > EmcalPhiMax) emPhiMin = EmcalPhiMax;
- if (emPhiMin < EmcalPhiMin) emPhiMin = EmcalPhiMin;
-
- const Int_t nClusters = fOutClusters->GetEntriesFast();
- TClonesArray digits("AliEMCALDigit", 1);
- for (Int_t i = 0; i < fNEmbClusters; ++i) {
-
- Double_t eta = 0;
- Double_t phi = 0;
- Int_t absId = 0;
-
- Int_t repeats = 0;
- do {
- eta = gRandom->Rndm() * (emEtaMax - emEtaMin) + emEtaMin;
- phi = gRandom->Rndm() * (emPhiMax - emPhiMin) + emPhiMin;
- fGeom->GetAbsCellIdFromEtaPhi(eta, phi, absId);
- repeats++;
- } while (absId == -1 && repeats < 100);
-
- if (!(absId > -1)) {
- AliWarning(Form("Could not embed cluster! Random eta-phi extracted more than 100 times!\n"
- "eta [%f, %f], phi [%f, %f]\n", emEtaMin, emEtaMax, emPhiMin, emPhiMax));
- continue;
- }
-
- Double_t pt = gRandom->Rndm() * (fPtMax - fPtMin) + fPtMin;
-
- TLorentzVector nPart;
- nPart.SetPtEtaPhiM(pt, eta, phi, 0);
- Double_t e = nPart.E();
-
- if (absId == -1) {
- AliWarning(Form("Unable to embed cluster in eta = %f, phi = %f!"
- " Maybe the eta-phi range is not inside the EMCal acceptance (eta = [%f, %f], phi = [%f, %f])",
- eta, phi, fEtaMin, fEtaMax, fPhiMin, fPhiMax));
- continue;
- }
-
- AliEMCALDigit *digit = static_cast<AliEMCALDigit*>(digits.New(0));
- digit->SetId(absId);
- digit->SetIndexInList(0);
- digit->SetType(AliEMCALDigit::kHG);
- digit->SetAmplitude(e);
-
- AliEMCALRecPoint recPoint("");
- recPoint.AddDigit(*digit, e, kFALSE);
- recPoint.EvalGlobalPosition(0, &digits);
-
- TVector3 gpos;
- recPoint.GetGlobalPosition(gpos);
- Float_t g[3];
- gpos.GetXYZ(g);
-
- AliVCluster *cluster = static_cast<AliVCluster*>(fOutClusters->New(nClusters + i));
- cluster->SetType(AliVCluster::kEMCALClusterv1);
- cluster->SetE(recPoint.GetEnergy());
- cluster->SetPosition(g);
- cluster->SetNCells(1);
- UShort_t shortAbsId = absId;
- cluster->SetCellsAbsId(&shortAbsId);
- Double32_t fract = 1;
- cluster->SetCellsAmplitudeFraction(&fract);
- cluster->SetID(nClusters + i);
- cluster->SetEmcCpvDistance(-1);
- cluster->SetChi2(100); // MC flag!
+ if (fNClusters > 0 && fOutClusters) {
+ for (Int_t i = 0; i < fNClusters; ++i) {
+ AddCluster();
}
}
- if (fNEmbTracks > 0 && fOutTracks) {
- Int_t nTracks = fOutTracks->GetEntriesFast();
- for (Int_t i = 0; i < fNEmbTracks; ++i) {
- Double_t pt = gRandom->Rndm() * (fPtMax - fPtMin) + fPtMin;
- Double_t eta = gRandom->Rndm() * (fEtaMax - fEtaMin) + fEtaMin;
- Double_t phi = gRandom->Rndm() * (fPhiMax - fPhiMin) + fPhiMin;
-
- new ((*fOutTracks)[nTracks + i]) AliPicoTrack(pt,
- eta,
- phi,
- 1,
- 100, // MC flag!
- 0,
- 0,
- kFALSE);
+ if (fNTracks > 0 && fOutTracks) {
+ for (Int_t i = 0; i < fNTracks; ++i) {
+ AddTrack();
}
}
}
Init();
- Embed();
+ Run();
}
class TClonesArray;
class AliEMCALGeometry;
-#include "AliAnalysisTaskSE.h"
+#include "AliJetModelBaseTask.h"
-class AliJetEmbeddingTask : public AliAnalysisTaskSE {
+class AliJetEmbeddingTask : public AliJetModelBaseTask {
public:
AliJetEmbeddingTask();
AliJetEmbeddingTask(const char *name);
virtual ~AliJetEmbeddingTask();
- void Init();
- void UserExec(Option_t* /*option*/);
- void Terminate(const Option_t* /*option*/) {;}
-
- void SetClusName(const char *n) { fCaloName = n; }
- void SetTracksName(const char *n) { fTracksName = n; }
- void SetEtaRange(Float_t min, Float_t max) { fEtaMin = min; fEtaMax = max; }
- void SetPhiRange(Float_t min, Float_t max) { fPhiMin = min; fPhiMax = max; }
- void SetPtRange(Float_t min, Float_t max) { fPtMin = min; fPtMax = max; }
- void SetCopyArray(Bool_t copy) { fCopyArray = copy; }
- void SetNClusters(Int_t n) { fNEmbClusters = n; }
- void SetNTracks(Int_t n) { fNEmbTracks = n; }
- void SetGeometryName(const char *n) { fGeomName = n; }
+ virtual void UserExec(Option_t* /*option*/);
protected:
- virtual void Embed(); // do embedding
-
- TString fGeomName; // EMCal geometry name
- TString fTracksName; // name of track collection
- TString fOutTracksName; // name of output track collection
- TString fCaloName; // name of calo cluster collection
- TString fOutCaloName; // name of output cluster collection
- Float_t fEtaMin; // eta minimum value
- Float_t fEtaMax; // eta maximum value
- Float_t fPhiMin; // phi minimum value
- Float_t fPhiMax; // phi maximum value
- Float_t fPtMin; // pt minimum value
- Float_t fPtMax; // pt maximum value
- Bool_t fCopyArray; // whether or not the array will be copied to a new one before embedding
- Int_t fNEmbClusters; // how many clusters are being embedded
- Int_t fNEmbTracks; // how many tracks are being embedded
- AliEMCALGeometry *fGeom; //!pointer to EMCal geometry
- TClonesArray *fClusters; //!cluster collection
- TClonesArray *fOutClusters; //!output cluster collection
- TClonesArray *fTracks; //!track collection
- TClonesArray *fOutTracks; //!output track collection
+ virtual void Run(); // do embedding
private:
AliJetEmbeddingTask(const AliJetEmbeddingTask&); // not implemented
AliJetEmbeddingTask &operator=(const AliJetEmbeddingTask&); // not implemented
- ClassDef(AliJetEmbeddingTask, 1) // Jet embedding task
+ ClassDef(AliJetEmbeddingTask, 2) // Jet embedding task
};
#endif
--- /dev/null
+// $Id$
+//
+// Jet modelling task.
+//
+// Author: Salvatore Aiola, Constantin Loizides
+
+#include <TClonesArray.h>
+#include <TLorentzVector.h>
+#include <TRandom3.h>
+
+#include "AliAnalysisManager.h"
+#include "AliVEvent.h"
+#include "AliVCluster.h"
+#include "AliEMCALDigit.h"
+#include "AliEMCALRecPoint.h"
+#include "AliPicoTrack.h"
+#include "AliEMCALGeometry.h"
+#include "AliLog.h"
+
+#include "AliJetModelBaseTask.h"
+
+ClassImp(AliJetModelBaseTask)
+
+//________________________________________________________________________
+AliJetModelBaseTask::AliJetModelBaseTask() :
+ AliAnalysisTaskSE("AliJetModelBaseTask"),
+ fGeomName(),
+ fTracksName(),
+ fOutTracksName(),
+ fCaloName(),
+ fOutCaloName(),
+ fSuffix(),
+ fEtaMin(-1),
+ fEtaMax(1),
+ fPhiMin(0),
+ fPhiMax(TMath::Pi() * 2),
+ fPtMin(0),
+ fPtMax(0),
+ fCopyArray(kTRUE),
+ fNClusters(0),
+ fNTracks(0),
+ fGeom(0),
+ fClusters(0),
+ fOutClusters(0),
+ fTracks(0),
+ fOutTracks(0)
+{
+ // Default constructor.
+}
+
+//________________________________________________________________________
+AliJetModelBaseTask::AliJetModelBaseTask(const char *name) :
+ AliAnalysisTaskSE(name),
+ fGeomName(""),
+ fTracksName("PicoTracks"),
+ fOutTracksName("PicoTracksEmbedded"),
+ fCaloName("CaloClustersCorr"),
+ fOutCaloName("CaloClustersCorrEmbedded"),
+ fSuffix("Processed"),
+ fEtaMin(-1),
+ fEtaMax(1),
+ fPhiMin(0),
+ fPhiMax(TMath::Pi() * 2),
+ fPtMin(50),
+ fPtMax(60),
+ fCopyArray(kTRUE),
+ fNClusters(0),
+ fNTracks(1),
+ fGeom(0),
+ fClusters(0),
+ fOutClusters(0),
+ fTracks(0),
+ fOutTracks(0)
+{
+ // Standard constructor.
+
+}
+
+//________________________________________________________________________
+AliJetModelBaseTask::~AliJetModelBaseTask()
+{
+ // Destructor
+}
+
+//________________________________________________________________________
+void AliJetModelBaseTask::Init()
+{
+ // Init task.
+
+ if (fPtMax < fPtMin) {
+ AliWarning (Form("PtMax (%f) < PtMin (%f), setting PtMax = PtMin = %f", fPtMax, fPtMin, fPtMin));
+ fPtMax = fPtMin;
+ }
+
+ if (fEtaMax < fEtaMin) {
+ AliWarning (Form("EtaMax (%f) < EtaMin (%f), setting EtaMax = EtaMin = %f", fEtaMax, fEtaMin, fEtaMin));
+ fEtaMax = fEtaMin;
+ }
+
+ if (fPhiMax < fPhiMin) {
+ AliWarning (Form("PhiMax (%f) < PhiMin (%f), setting PhiMax = PhiMin = %f", fPhiMax, fPhiMin, fPhiMin));
+ fPhiMax = fPhiMin;
+ }
+
+ if (fNTracks > 0) {
+ fTracks = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fTracksName));
+
+ if (strcmp(fTracks->GetClass()->GetName(), "AliPicoTrack")) {
+ AliError("Can only embed PicoTracks!");
+ return;
+ }
+
+ if (!fTracks) {
+ AliError(Form("Couldn't retrieve tracks with name %s!", fTracksName.Data()));
+ return;
+ }
+
+ if (!fOutTracks) {
+ fOutTracksName = fTracksName;
+ if (fCopyArray) {
+ fOutTracksName += fSuffix;
+ fOutTracks = new TClonesArray(*fTracks);
+ fOutTracks->SetName(fOutTracksName);
+ }
+ else {
+ fOutTracks = fTracks;
+ }
+ }
+
+ if (fCopyArray) {
+ if (!(InputEvent()->FindListObject(fOutTracksName)))
+ InputEvent()->AddObject(fOutTracks);
+ fOutTracks->Clear();
+ }
+ }
+
+ if (fNClusters > 0) {
+ fClusters = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fCaloName));
+
+ if (!fClusters) {
+ AliError(Form("Couldn't retrieve clusters with name %s!", fCaloName.Data()));
+ return;
+ }
+
+ if (!fOutClusters) {
+ fOutCaloName = fCaloName;
+ if (fCopyArray) {
+ fOutCaloName += fSuffix;
+ fOutClusters = new TClonesArray(*fClusters);
+ fOutClusters->SetName(fOutCaloName);
+ }
+ else {
+ fOutClusters = fClusters;
+ }
+ }
+
+ if (fCopyArray) {
+ if (!(InputEvent()->FindListObject(fOutCaloName)))
+ InputEvent()->AddObject(fOutClusters);
+ fOutClusters->Clear();
+ }
+ }
+
+ if (!fGeom) {
+ if (fGeomName.Length() > 0) {
+ fGeom = AliEMCALGeometry::GetInstance(fGeomName);
+ if (!fGeom)
+ AliError(Form("Could not get geometry with name %s!", fGeomName.Data()));
+ } else {
+ fGeom = AliEMCALGeometry::GetInstance();
+ if (!fGeom)
+ AliError("Could not get default geometry!");
+ }
+
+ // hard-coded Emcal boundaries
+ const Float_t EmcalEtaMin = -0.7;
+ const Float_t EmcalEtaMax = 0.7;
+ const Float_t EmcalPhiMin = 80 * TMath::DegToRad();
+ const Float_t EmcalPhiMax = 180 * TMath::DegToRad();
+
+ if (fEtaMax > EmcalEtaMax) fEtaMax = EmcalEtaMax;
+ if (fEtaMax < EmcalEtaMin) fEtaMax = EmcalEtaMin;
+ if (fEtaMin > EmcalEtaMax) fEtaMin = EmcalEtaMax;
+ if (fEtaMin < EmcalEtaMin) fEtaMin = EmcalEtaMin;
+
+ if (fPhiMax > EmcalPhiMax) fPhiMax = EmcalPhiMax;
+ if (fPhiMax < EmcalPhiMin) fPhiMax = EmcalPhiMin;
+ if (fPhiMin > EmcalPhiMax) fPhiMin = EmcalPhiMax;
+ if (fPhiMin < EmcalPhiMin) fPhiMin = EmcalPhiMin;
+ }
+}
+
+//________________________________________________________________________
+void AliJetModelBaseTask::GetRandomCell(Double_t &eta, Double_t &phi, Int_t &absId)
+{
+ Int_t repeats = 0;
+
+ do {
+ eta = gRandom->Rndm() * (fEtaMax - fEtaMin) + fEtaMin;
+ phi = gRandom->Rndm() * (fPhiMax - fPhiMin) + fPhiMin;
+ fGeom->GetAbsCellIdFromEtaPhi(eta, phi, absId);
+ repeats++;
+ } while (absId == -1 && repeats < 100);
+
+ if (!(absId > -1)) {
+ AliWarning(Form("Could not extract random cluster! Random eta-phi extracted more than 100 times!\n"
+ "eta [%f, %f], phi [%f, %f]\n", fEtaMin, fEtaMax, fPhiMin, fPhiMax));
+ }
+}
+
+//________________________________________________________________________
+Double_t AliJetModelBaseTask::GetRandomEta()
+{
+ return gRandom->Rndm() * (fEtaMax - fEtaMin) + fEtaMin;
+}
+
+//________________________________________________________________________
+Double_t AliJetModelBaseTask::GetRandomPhi()
+{
+ return gRandom->Rndm() * (fPhiMax - fPhiMin) + fPhiMin;
+}
+
+//________________________________________________________________________
+Double_t AliJetModelBaseTask::GetRandomPt()
+{
+ return gRandom->Rndm() * (fPtMax - fPtMin) + fPtMin;
+}
+
+//________________________________________________________________________
+AliVCluster* AliJetModelBaseTask::AddCluster(Double_t e, Double_t eta, Double_t phi)
+{
+ Int_t absId = 0;
+ if (eta < 0 || phi < 0) {
+ GetRandomCell(eta, phi, absId);
+ }
+ else {
+ fGeom->EtaPhiFromIndex(absId, eta, phi);
+ }
+
+ if (absId == -1) {
+ AliWarning(Form("Unable to embed cluster in eta = %f, phi = %f!"
+ " Maybe the eta-phi range is not inside the EMCal acceptance (eta = [%f, %f], phi = [%f, %f])",
+ eta, phi, fEtaMin, fEtaMax, fPhiMin, fPhiMax));
+ return 0;
+ }
+
+ if (e < 0) {
+ Double_t pt = GetRandomPt();
+ TLorentzVector nPart;
+ nPart.SetPtEtaPhiM(pt, eta, phi, 0);
+ e = nPart.E();
+ }
+
+ return AddCluster(e, absId);
+}
+
+//________________________________________________________________________
+AliVCluster* AliJetModelBaseTask::AddCluster(Double_t e, Int_t absId)
+{
+ const Int_t nClusters = fOutClusters->GetEntriesFast();
+
+ TClonesArray digits("AliEMCALDigit", 1);
+
+ AliEMCALDigit *digit = static_cast<AliEMCALDigit*>(digits.New(0));
+ digit->SetId(absId);
+ digit->SetIndexInList(0);
+ digit->SetType(AliEMCALDigit::kHG);
+ digit->SetAmplitude(e);
+
+ AliEMCALRecPoint recPoint("");
+ recPoint.AddDigit(*digit, e, kFALSE);
+ recPoint.EvalGlobalPosition(0, &digits);
+
+ TVector3 gpos;
+ recPoint.GetGlobalPosition(gpos);
+ Float_t g[3];
+ gpos.GetXYZ(g);
+
+ AliVCluster *cluster = static_cast<AliVCluster*>(fOutClusters->New(nClusters));
+ cluster->SetType(AliVCluster::kEMCALClusterv1);
+ cluster->SetE(recPoint.GetEnergy());
+ cluster->SetPosition(g);
+ cluster->SetNCells(1);
+ UShort_t shortAbsId = absId;
+ cluster->SetCellsAbsId(&shortAbsId);
+ Double32_t fract = 1;
+ cluster->SetCellsAmplitudeFraction(&fract);
+ cluster->SetID(nClusters);
+ cluster->SetEmcCpvDistance(-1);
+ cluster->SetChi2(100); // MC flag!
+
+ return cluster;
+}
+
+//________________________________________________________________________
+AliPicoTrack* AliJetModelBaseTask::AddTrack(Double_t pt, Double_t eta, Double_t phi)
+{
+ const Int_t nTracks = fOutTracks->GetEntriesFast();
+
+ if (pt < 0)
+ pt = GetRandomPt();
+ if (eta < 0)
+ eta = GetRandomEta();
+ if (phi < 0)
+ phi = GetRandomPhi();
+
+ AliPicoTrack *track = new ((*fOutTracks)[nTracks]) AliPicoTrack(pt,
+ eta,
+ phi,
+ 1,
+ 100, // MC flag!
+ 0,
+ 0,
+ kFALSE);
+ return track;
+}
+
+//________________________________________________________________________
+void AliJetModelBaseTask::Run()
+{
+
+}
+
+//________________________________________________________________________
+void AliJetModelBaseTask::UserExec(Option_t *)
+{
+ // Execute per event.
+
+ Init();
+
+ Run();
+
+}
--- /dev/null
+#ifndef ALIJETMODELBASETASK_H
+#define ALIJETMODELBASETASK_H
+
+// $Id$
+
+class TClonesArray;
+class AliEMCALGeometry;
+class AliVCluster;
+class AliPicoTrack;
+
+#include "AliAnalysisTaskSE.h"
+
+class AliJetModelBaseTask : public AliAnalysisTaskSE {
+ public:
+ AliJetModelBaseTask();
+ AliJetModelBaseTask(const char *name);
+ virtual ~AliJetModelBaseTask();
+
+ virtual void Init();
+ virtual void UserExec(Option_t* /*option*/);
+ virtual void Terminate(const Option_t* /*option*/) {;}
+
+ void SetClusName(const char *n) { fCaloName = n; }
+ void SetTracksName(const char *n) { fTracksName = n; }
+ void SetEtaRange(Float_t min, Float_t max) { fEtaMin = min; fEtaMax = max; }
+ void SetPhiRange(Float_t min, Float_t max) { fPhiMin = min; fPhiMax = max; }
+ void SetPtRange(Float_t min, Float_t max) { fPtMin = min; fPtMax = max; }
+ void SetCopyArray(Bool_t copy) { fCopyArray = copy; }
+ void SetNClusters(Int_t n) { fNClusters = n; }
+ void SetNTracks(Int_t n) { fNTracks = n; }
+ void SetGeometryName(const char *n) { fGeomName = n; }
+ void SetSuffix(const char *s) { fSuffix = s; }
+
+ protected:
+
+ virtual void Run(); // do jet model action
+ void GetRandomCell(Double_t &eta, Double_t &phi, Int_t &absId); // generate a random cell in the calorimeter
+ Double_t GetRandomEta(); // generate a random eta value in the given range
+ Double_t GetRandomPhi(); // generate a random phi value in the given range
+ Double_t GetRandomPt(); // generate a random pt value in the given range
+ AliVCluster *AddCluster(Double_t e = -1, Double_t eta = -1, Double_t phi = -1); // add a cluster; if values are -1 generate random parameters
+ AliVCluster *AddCluster(Double_t e, Int_t absId); // add a cluster with given energy and position
+ AliPicoTrack *AddTrack(Double_t pt = -1, Double_t eta = -1, Double_t phi = -1); // add a track; if values are -1 generate random parameters
+
+ TString fGeomName; // EMCal geometry name
+ TString fTracksName; // name of track collection
+ TString fOutTracksName; // name of output track collection
+ TString fCaloName; // name of calo cluster collection
+ TString fOutCaloName; // name of output cluster collection
+ TString fSuffix; // suffix to add in the name of new collections
+ Float_t fEtaMin; // eta minimum value
+ Float_t fEtaMax; // eta maximum value
+ Float_t fPhiMin; // phi minimum value
+ Float_t fPhiMax; // phi maximum value
+ Float_t fPtMin; // pt minimum value
+ Float_t fPtMax; // pt maximum value
+ Bool_t fCopyArray; // whether or not the array will be copied to a new one before modelling
+ Int_t fNClusters; // how many clusters are being processed
+ Int_t fNTracks; // how many tracks are being processed
+ AliEMCALGeometry *fGeom; //!pointer to EMCal geometry
+ TClonesArray *fClusters; //!cluster collection
+ TClonesArray *fOutClusters; //!output cluster collection
+ TClonesArray *fTracks; //!track collection
+ TClonesArray *fOutTracks; //!output track collection
+
+ private:
+ AliJetModelBaseTask(const AliJetModelBaseTask&); // not implemented
+ AliJetModelBaseTask &operator=(const AliJetModelBaseTask&); // not implemented
+
+ ClassDef(AliJetModelBaseTask, 1) // Jet modelling task
+};
+#endif
--- /dev/null
+// $Id$
+//
+// Jet embedding task.
+//
+// Author: Salvatore Aiola, Constantin Loizides
+
+#include <TClonesArray.h>
+#include <TLorentzVector.h>
+#include <TRandom3.h>
+
+#include "AliAnalysisManager.h"
+#include "AliVEvent.h"
+#include "AliVCluster.h"
+#include "AliEMCALDigit.h"
+#include "AliEMCALRecPoint.h"
+#include "AliPicoTrack.h"
+#include "AliEMCALGeometry.h"
+#include "AliLog.h"
+
+#include "AliJetRandomizerTask.h"
+
+ClassImp(AliJetRandomizerTask)
+
+//________________________________________________________________________
+AliJetRandomizerTask::AliJetRandomizerTask() :
+ AliJetModelBaseTask("AliJetRandomizerTask")
+{
+ // Default constructor.
+ SetSuffix("Randomized");
+}
+
+//________________________________________________________________________
+AliJetRandomizerTask::AliJetRandomizerTask(const char *name) :
+ AliJetModelBaseTask(name)
+{
+ // Standard constructor.
+ SetSuffix("Randomized");
+}
+
+//________________________________________________________________________
+AliJetRandomizerTask::~AliJetRandomizerTask()
+{
+ // Destructor
+}
+
+//________________________________________________________________________
+void AliJetRandomizerTask::Run()
+{
+ // Randomize particles.
+
+ if (fNClusters > 0 && fOutClusters) {
+ const Int_t nClusters = fOutClusters->GetEntriesFast();
+ for (Int_t i = 0; i < nClusters; ++i) {
+ AliVCluster *cluster = dynamic_cast<AliVCluster*>(fClusters->At(i));
+ if (!cluster)
+ continue;
+ if (!cluster->IsEMCAL())
+ continue;
+ AddCluster(cluster->E());
+ }
+ }
+
+ if (fNTracks > 0 && fOutTracks) {
+ const Int_t nTracks = fOutTracks->GetEntriesFast();
+ for (Int_t i = 0; i < nTracks; ++i) {
+ AliPicoTrack *track = dynamic_cast<AliPicoTrack*>(fTracks->At(i));
+ if (!track)
+ continue;
+ AddTrack(track->Pt());
+ }
+ }
+}
+
+//________________________________________________________________________
+void AliJetRandomizerTask::UserExec(Option_t *)
+{
+ // Execute per event.
+
+ if (!fCopyArray) {
+ AliWarning("fCopyArray == kFALSE not allowed for AliJetRandomizerTask, will set kTRUE");
+ fCopyArray = kTRUE;
+ }
+
+ Init();
+
+ Run();
+}
--- /dev/null
+#ifndef ALIJETRANDOMIZERTASK_H
+#define ALIJETRANDOMIZERTASK_H
+
+// $Id$
+
+class TClonesArray;
+
+#include "AliJetModelBaseTask.h"
+
+class AliJetRandomizerTask : public AliJetModelBaseTask {
+ public:
+ AliJetRandomizerTask();
+ AliJetRandomizerTask(const char *name);
+ virtual ~AliJetRandomizerTask();
+
+ virtual void UserExec(Option_t* /*option*/);
+
+ protected:
+
+ virtual void Run(); // do randomizing
+
+ private:
+ AliJetRandomizerTask(const AliJetRandomizerTask&); // not implemented
+ AliJetRandomizerTask &operator=(const AliJetRandomizerTask&); // not implemented
+
+ ClassDef(AliJetRandomizerTask, 1) // Jet randomizer task
+};
+#endif
--- /dev/null
+// $Id$
+
+AliJetRandomizerTask* AddTaskJetRandomizer(
+ const char *tracksName = "Tracks",
+ const char *clusName = "CaloClustersCorr",
+ const char *taskName = "JetEmbeddingTask",
+ const Double_t minEta = -1,
+ const Double_t maxEta = 1,
+ const Double_t minPhi = 0,
+ const Double_t maxPhi = TMath::Pi() * 2,
+ const Int_t nTracks = 1,
+ const Int_t nClus = 0,
+ const Bool_t copyArray = kFALSE
+)
+{
+ // Get the pointer to the existing analysis manager via the static access method.
+ //==============================================================================
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if (!mgr)
+ {
+ ::Error("AddTaskJetRandomizer", "No analysis manager to connect to.");
+ return NULL;
+ }
+
+ // Check the analysis type using the event handlers connected to the analysis manager.
+ //==============================================================================
+ if (!mgr->GetInputEventHandler())
+ {
+ ::Error("AddTaskJetRandomizer", "This task requires an input event handler");
+ return NULL;
+ }
+
+ //-------------------------------------------------------
+ // Init the task and do settings
+ //-------------------------------------------------------
+
+ AliJetRandomizerTask *jetRand = new AliJetRandomizerTask(taskName);
+ jetRand->SetTracksName(tracksName);
+ jetRand->SetClusName(clusName);
+ jetRand->SetEtaRange(minEta, maxEta);
+ jetRand->SetPhiRange(minPhi, maxPhi);
+ jetRand->SetCopyArray(copyArray);
+ jetRand->SetNClusters(nClus);
+ jetRand->SetNTracks(nTracks);
+
+ //-------------------------------------------------------
+ // Final settings, pass to manager and set the containers
+ //-------------------------------------------------------
+
+ mgr->AddTask(jetRand);
+
+ // Create containers for input/output
+ mgr->ConnectInput (jetRand, 0, mgr->GetCommonInputContainer() );
+
+ return jetRand;
+}
#pragma link C++ class AliEmcalJet+;
#pragma link C++ class AliEmcalJetTask+;
#pragma link C++ class AliHadCorrTask+;
+#pragma link C++ class AliJetModelBaseTask+;
+#pragma link C++ class AliJetRandomizerTask+;
#pragma link C++ class AliJetEmbeddingTask+;
#pragma link C++ class AliAnalysisTaskEmcalJetSpectra+;
#pragma link C++ class AliAnalysisTaskRhoBase+;
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff