ClassImp(AliEMCALClusterizerFixedWindow)
//__________________________________________________________________________________________
- AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow()
- : AliEMCALClusterizer(),
- fNphi(4),
- fNeta(4),
- fShiftPhi(2),
- fShiftEta(2),
- fTRUshift(0),
- fClustersArray(0)
+AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow() :
+ AliEMCALClusterizer(),
+ fNphi(4),
+ fNeta(4),
+ fShiftPhi(2),
+ fShiftEta(2),
+ fTRUshift(0),
+ fNEtaDigitsSupMod(0),
+ fNPhiDigitsSupMod(0),
+ fNTRUPhi(0),
+ fNTRUEta(0),
+ fNEtaDigits(0),
+ fNPhiDigits(0),
+ fMaxShiftPhi(0),
+ fMaxShiftEta(0),
+ fNDigitsCluster(0),
+ fNClusEtaNoShift(0),
+ fNClusPhiNoShift(0),
+ fNClusters(0),
+ fNTotalClus(0),
+ fClustersArray(0),
+ fInitialized(0)
{
// Constructor
}
//__________________________________________________________________________________________
-AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow(AliEMCALGeometry* geometry)
- : AliEMCALClusterizer(geometry),
- fNphi(4),
- fNeta(4),
- fShiftPhi(2),
- fShiftEta(2),
- fTRUshift(0),
- fClustersArray(0)
+AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow(AliEMCALGeometry* geometry) :
+ AliEMCALClusterizer(geometry),
+ fNphi(4),
+ fNeta(4),
+ fShiftPhi(2),
+ fShiftEta(2),
+ fTRUshift(0),
+ fNEtaDigitsSupMod(0),
+ fNPhiDigitsSupMod(0),
+ fNTRUPhi(0),
+ fNTRUEta(0),
+ fNEtaDigits(0),
+ fNPhiDigits(0),
+ fMaxShiftPhi(0),
+ fMaxShiftEta(0),
+ fNDigitsCluster(0),
+ fNClusEtaNoShift(0),
+ fNClusPhiNoShift(0),
+ fNClusters(0),
+ fNTotalClus(0),
+ fClustersArray(0),
+ fInitialized(0)
{
// Constructor
}
//__________________________________________________________________________________________
-AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow(AliEMCALGeometry* geometry, AliEMCALCalibData * calib, AliCaloCalibPedestal * caloped)
- : AliEMCALClusterizer(geometry, calib, caloped),
- fNphi(4),
- fNeta(4),
- fShiftPhi(2),
- fShiftEta(2),
- fTRUshift(0),
- fClustersArray(0)
+AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow(AliEMCALGeometry* geometry, AliEMCALCalibData * calib, AliCaloCalibPedestal * caloped) :
+ AliEMCALClusterizer(geometry, calib, caloped),
+ fNphi(4),
+ fNeta(4),
+ fShiftPhi(2),
+ fShiftEta(2),
+ fTRUshift(0),
+ fNEtaDigitsSupMod(0),
+ fNPhiDigitsSupMod(0),
+ fNTRUPhi(0),
+ fNTRUEta(0),
+ fNEtaDigits(0),
+ fNPhiDigits(0),
+ fMaxShiftPhi(0),
+ fMaxShiftEta(0),
+ fNDigitsCluster(0),
+ fNClusEtaNoShift(0),
+ fNClusPhiNoShift(0),
+ fNClusters(0),
+ fNTotalClus(0),
+ fClustersArray(0),
+ fInitialized(0)
{
// Constructor
}
AliEMCALClusterizerFixedWindow::~AliEMCALClusterizerFixedWindow()
{
// Destructor
-
- delete fClustersArray;
+
+ if (fClustersArray) {
+ for (Int_t i = 0; i < fNTotalClus; i++) {
+ if (fClustersArray[i]) {
+ delete[] fClustersArray[i];
+ fClustersArray[i] = 0;
+ }
+ delete[] fClustersArray;
+ fClustersArray = 0;
+ }
+ }
+
}
//__________________________________________________________________________________________
{
// Set fNphi; if clusterizer already initialized gives a warning and does nothing
- if (fClustersArray)
+ if (fInitialized != 0)
AliWarning("Clusterizer already initialized. Unable to change the parameters.");
else
fNphi = n;
{
// Set fNeta; if clusterizer already initialized gives a warning and does nothing
- if (fClustersArray)
+ if (fInitialized != 0)
AliWarning("Clusterizer already initialized. Unable to change the parameters.");
else
fNeta = n;
{
// Set fShiftPhi; if clusterizer already initialized gives a warning and does nothing
- if (fClustersArray)
+ if (fInitialized != 0)
AliWarning("Clusterizer already initialized. Unable to change the parameters.");
else
fShiftPhi = s;
{
// Set fShiftEta; if clusterizer already initialized gives a warning and does nothing
- if (fClustersArray)
+ if (fInitialized != 0)
AliWarning("Clusterizer already initialized. Unable to change the parameters.");
else
fShiftEta = s;
{
// Set fTRUshift; if clusterizer already initialized gives a warning and does nothing
- if (fClustersArray)
+ if (fInitialized != 0)
AliWarning("Clusterizer already initialized. Unable to change the parameters.");
else
fTRUshift = b;
void AliEMCALClusterizerFixedWindow::Digits2Clusters(Option_t * option)
{
// Steering method to perform clusterization for the current event
-
+
+ static Float_t cputime = 0;
+ static Float_t realtime = 0;
+
if (strstr(option,"tim"))
gBenchmark->Start("EMCALClusterizer");
if (strstr(option,"tim")) {
gBenchmark->Stop("EMCALClusterizer");
- printf("Exec took %f seconds for Clusterizing",
- gBenchmark->GetCpuTime("EMCALClusterizer"));
+ Printf("Exec took %f CPU time (%f real time) for clusterizing",
+ gBenchmark->GetCpuTime("EMCALClusterizer")-cputime,gBenchmark->GetRealTime("EMCALClusterizer")-realtime);
+ cputime = gBenchmark->GetCpuTime("EMCALClusterizer");
+ realtime = gBenchmark->GetRealTime("EMCALClusterizer");
}
}
//__________________________________________________________________________________________
-void AliEMCALClusterizerFixedWindow::MakeClusters()
+void AliEMCALClusterizerFixedWindow::ExecOnce()
{
- // Make clusters
-
- if (fGeom == 0)
- AliFatal("Did not get geometry from EMCALLoader");
-
- fNumberOfECAClusters = 0;
- fRecPoints->Delete();
-
- Int_t nSupMod=0, nModule=0, nIphi=0, nIeta=0, iphi=0, ieta=0;
+ // Initialize clusterizer.
+
+ fInitialized = -1;
+
+ if (!fGeom) {
+ AliError("Did not get geometry!");
+ return;
+ }
// Defining geometry and clusterization parameter
- Int_t nEtaDigitsSupMod = fGeom->GetNEta() * fGeom->GetNETAdiv(); // always 48?;
- Int_t nPhiDigitsSupMod = fGeom->GetNPhi() * fGeom->GetNPHIdiv(); // always 24?;
+ fNEtaDigitsSupMod = fGeom->GetNEta() * fGeom->GetNETAdiv(); // always 48?;
+ fNPhiDigitsSupMod = fGeom->GetNPhi() * fGeom->GetNPHIdiv(); // always 24?;
- Int_t nTRUPhi = 1;
- Int_t nTRUEta = 1;
+ fNTRUPhi = 1;
+ fNTRUEta = 1;
- Int_t nEtaDigits = nEtaDigitsSupMod * fGeom->GetNumberOfSuperModules() / fGeom->GetNPhiSuperModule();
- Int_t nPhiDigits = nPhiDigitsSupMod * fGeom->GetNPhiSuperModule();
+ fNEtaDigits = fNEtaDigitsSupMod * fGeom->GetNumberOfSuperModules() / fGeom->GetNPhiSuperModule();
+ fNPhiDigits = fNPhiDigitsSupMod * fGeom->GetNPhiSuperModule();
if (fTRUshift){
- nTRUPhi = fGeom->GetNPhiSuperModule() * 3;
- nTRUEta = fGeom->GetNumberOfSuperModules() / fGeom->GetNPhiSuperModule();
- nEtaDigits /= nTRUEta;
- nPhiDigits /= nTRUPhi;
+ fNTRUPhi = fGeom->GetNPhiSuperModule() * 3;
+ fNTRUEta = fGeom->GetNumberOfSuperModules() / fGeom->GetNPhiSuperModule();
+ fNEtaDigits /= fNTRUEta;
+ fNPhiDigits /= fNTRUPhi;
}
// Check if clusterizer parameter are compatible with calorimeter geometry
- if (nEtaDigits < fNeta){
- AliFatal(Form("Error: fNeta = %d is greater than nEtaDigits = %d.",fNeta,nEtaDigits));
+ if (fNEtaDigits < fNeta){
+ AliError(Form("Error: fNeta = %d is greater than nEtaDigits = %d.",fNeta,fNEtaDigits));
return;
}
- if (nPhiDigits < fNphi){
- AliFatal(Form("Error: fNphi = %d is greater than nPhiDigits = %d.",fNphi,nPhiDigits));
+ if (fNPhiDigits < fNphi){
+ AliError(Form("Error: fNphi = %d is greater than nPhiDigits = %d.",fNphi,fNPhiDigits));
return;
}
- if (nEtaDigits % fShiftEta != 0){
- AliFatal(Form("Error: fShiftEta = %d is such that clusters cannot slide the whole calorimeter (nEtaDigits = %d).",fShiftEta,nEtaDigits));
+ if (fNEtaDigits % fShiftEta != 0){
+ AliError(Form("Error: fShiftEta = %d is such that clusters cannot slide the whole calorimeter (nEtaDigits = %d).",fShiftEta,fNEtaDigits));
return;
}
- if (nPhiDigits % fShiftPhi != 0){
- AliFatal(Form("Error: fShiftPhi = %d is such that clusters cannot slide the whole calorimeter (nPhiDigits = %d).",fShiftPhi,nPhiDigits));
+ if (fNPhiDigits % fShiftPhi != 0){
+ AliError(Form("Error: fShiftPhi = %d is such that clusters cannot slide the whole calorimeter (nPhiDigits = %d).",fShiftPhi,fNPhiDigits));
return;
}
if (fNeta % fShiftEta != 0){
- AliFatal(Form("Error: fShiftEta = %d is not divisor of fNeta = %d.",fShiftEta,fNeta));
+ AliError(Form("Error: fShiftEta = %d is not divisor of fNeta = %d.",fShiftEta,fNeta));
return;
}
if (fNphi % fShiftPhi != 0){
- AliFatal(Form("Error: fShiftPhi = %d is not divisor of fNphi = %d).",fShiftPhi,fNphi));
+ AliError(Form("Error: fShiftPhi = %d is not divisor of fNphi = %d).",fShiftPhi,fNphi));
return;
}
- Int_t maxiShiftPhi = fNphi / fShiftPhi;
- Int_t maxiShiftEta = fNeta / fShiftEta;
-
- Int_t nDigitsCluster = fNphi * fNeta;
-
- Int_t nClusEtaNoShift = nEtaDigits / fNeta;
- Int_t nClusPhiNoShift = nPhiDigits / fNphi;
+ fMaxShiftPhi = fNphi / fShiftPhi;
+ fMaxShiftEta = fNeta / fShiftEta;
- Int_t nClusters = nClusEtaNoShift * nClusPhiNoShift * nTRUEta * nTRUPhi;
-
- Int_t nTotalClus = nClusters * maxiShiftEta * maxiShiftPhi;
-
- if (!fClustersArray) {
- fClustersArray = new AliEMCALDigit**[nTotalClus];
- for (Int_t i = 0; i < nTotalClus; i++)
- {
- fClustersArray[i] = NULL;
+ fNClusEtaNoShift = fNEtaDigits / fNeta;
+ fNClusPhiNoShift = fNPhiDigits / fNphi;
+
+ fNClusters = fNClusEtaNoShift * fNClusPhiNoShift * fNTRUEta * fNTRUPhi;
+
+ fNTotalClus = fNClusters * fMaxShiftEta * fMaxShiftPhi;
+
+ fNDigitsCluster = fNphi * fNeta;
+
+ if (fClustersArray) {
+ for (Int_t i = 0; i < fNTotalClus; i++) {
+ if (fClustersArray[i]) {
+ delete[] fClustersArray[i];
+ fClustersArray[i] = 0;
+ }
+ delete[] fClustersArray;
+ fClustersArray = 0;
+ }
+ }
+
+ fClustersArray = new AliEMCALDigit**[fNTotalClus];
+ for (Int_t i = 0; i < fNTotalClus; i++) {
+ fClustersArray[i] = new AliEMCALDigit*[fNDigitsCluster];
+ for (Int_t j = 0; j < fNDigitsCluster; j++) {
+ fClustersArray[i][j] = 0;
}
}
+
+ AliDebug(1,Form("****ExecOnce*****\n"
+ "fNphi = %d, fNeta = %d, fShiftPhi = %d, fShiftEta = %d, fTRUshift = %d\n"
+ "fNEtaDigitsSupMod = %d, fNPhiDigitsSupMod = %d, fNTRUPhi = %d, fNTRUEta = %d, fNEtaDigits = %d, fNPhiDigits = %d\n"
+ "fMaxShiftPhi = %d, fMaxShiftEta = %d, fNDigitsCluster = %d, fNClusEtaNoShift = %d, fNClusPhiNoShift = %d\n"
+ "fNClusters = %d, fNTotalClus = %d\n",
+ fNphi,fNeta,fShiftPhi,fShiftEta,fTRUshift,
+ fNEtaDigitsSupMod,fNPhiDigitsSupMod,fNTRUPhi,fNTRUEta,fNEtaDigits,fNPhiDigits,
+ fMaxShiftPhi,fMaxShiftEta,fNDigitsCluster,fNClusEtaNoShift,fNClusPhiNoShift,
+ fNClusters,fNTotalClus));
+
+ fInitialized = 1;
+}
+
+//__________________________________________________________________________________________
+void AliEMCALClusterizerFixedWindow::MakeClusters()
+{
+ // Make clusters.
+
+ fNumberOfECAClusters = 0;
+ fRecPoints->Delete();
+
+ if (fInitialized == 0)
+ ExecOnce();
+
+ if (fInitialized == -1) {
+ AliError(Form("%s: error initializing the clusterizer. No clusterization will be performed.",GetName()));
+ return;
+ }
// Set up TObjArray with pointers to digits to work on calibrated digits
TObjArray *digitsC = new TObjArray();
AliDebug(1,Form("MakeClusters: Number of digits %d -> (e %f), ehs %f\n",
fDigitsArr->GetEntries(),fMinECut,ehs));
- for (Int_t ishiftPhi = 0; ishiftPhi < maxiShiftPhi; ishiftPhi++){
- Int_t nClusPhi = (nPhiDigits - fShiftPhi * ishiftPhi) / fNphi;
+ Int_t nSupMod=0, nModule=0, nIphi=0, nIeta=0;
+ Int_t iphi=0, ieta=0; // cell eta-phi indexes in SM
+
+ for (Int_t ishiftPhi = 0; ishiftPhi < fMaxShiftPhi; ishiftPhi++){
+ Int_t nClusPhi = (fNPhiDigits - fShiftPhi * ishiftPhi) / fNphi;
- for (Int_t ishiftEta = 0; ishiftEta < maxiShiftEta; ishiftEta++) {
+ for (Int_t ishiftEta = 0; ishiftEta < fMaxShiftEta; ishiftEta++) {
- Int_t nClusEta = (nEtaDigits - fShiftEta * ishiftEta) / fNeta;
+ Int_t nClusEta = (fNEtaDigits - fShiftEta * ishiftEta) / fNeta;
- Int_t iTotalClus = nClusters * (ishiftPhi * maxiShiftEta + ishiftEta);
+ Int_t iTotalClus = fNClusters * (ishiftPhi * fMaxShiftEta + ishiftEta);
TIter nextdigitC(digitsC);
while ((digit = dynamic_cast<AliEMCALDigit*>(nextdigitC()))) { // scan over the list of digitsC
fGeom->GetCellIndex (digit->GetId(), nSupMod, nModule, nIphi, nIeta);
fGeom->GetCellPhiEtaIndexInSModule (nSupMod, nModule, nIphi, nIeta, iphi, ieta);
- Int_t iphi_eff = iphi - fShiftPhi * ishiftPhi + nPhiDigitsSupMod * (nSupMod / 2); // N supermodules along phi
+ Int_t iphi_eff = iphi - fShiftPhi * ishiftPhi + fNPhiDigitsSupMod * (nSupMod / 2); // N supermodules along phi
- Int_t iTRUphi = iphi_eff / nPhiDigits;
+ Int_t iTRUphi = iphi_eff / fNPhiDigits;
- iphi_eff -= iTRUphi * nPhiDigits;
+ iphi_eff -= iTRUphi * fNPhiDigits;
Int_t iClusPhi = iphi_eff / fNphi;
if (iphi_eff < 0 || iClusPhi >= nClusPhi)
continue;
- Int_t ieta_eff = ieta - fShiftEta * ishiftEta + nEtaDigitsSupMod * (nSupMod % 2); // 2 supermodules along eta
+ Int_t ieta_eff = ieta - fShiftEta * ishiftEta + fNEtaDigitsSupMod * (nSupMod % 2); // 2 supermodules along eta
- Int_t iTRUeta = ieta_eff / nEtaDigits;
+ Int_t iTRUeta = ieta_eff / fNEtaDigits;
- ieta_eff -= iTRUeta * nEtaDigits;
+ ieta_eff -= iTRUeta * fNEtaDigits;
Int_t iClusEta = ieta_eff / fNeta;
if (ieta_eff < 0 || iClusEta >= nClusEta)
continue;
- iphi_eff += iTRUphi * nPhiDigits;
+ iphi_eff += iTRUphi * fNPhiDigits;
iClusPhi = iphi_eff / fNphi;
- ieta_eff += iTRUeta * nEtaDigits;
+ ieta_eff += iTRUeta * fNEtaDigits;
iClusEta = ieta_eff / fNeta;
- Int_t iCluster = iClusPhi + iClusEta * nClusPhiNoShift * nTRUPhi;
+ Int_t iCluster = iClusPhi + iClusEta * fNClusPhiNoShift * fNTRUPhi;
Int_t iDigit = iphi_eff % fNphi + (ieta_eff % fNeta) * fNphi;
- if (iCluster >= nClusters){
- AliWarning(Form("iCluster out of range! iCluster = %d, nClusters = %d", iCluster, nClusters));
+ if (iCluster >= fNClusters){
+ AliError(Form("iCluster out of range! iCluster = %d, fNClusters = %d (should never happen...)", iCluster, fNClusters));
return;
}
iCluster += iTotalClus;
-
- if (fClustersArray[iCluster] == NULL){
- fNumberOfECAClusters++;
- fClustersArray[iCluster] = new AliEMCALDigit*[nDigitsCluster];
- for (Int_t i = 0; i < nDigitsCluster; i++){
- fClustersArray[iCluster][i] = NULL;
- }
+
+ if (iCluster >= fNTotalClus){
+ AliError(Form("iCluster out of range! iCluster = %d, fNTotalClus = %d (should never happen...)", iCluster, fNTotalClus));
+ return;
}
-
- if (fClustersArray[iCluster][iDigit] != NULL){
- AliWarning("Digit already added!");
+
+ if (iDigit >= fNDigitsCluster){
+ AliError(Form("iDigit out of range! iDigit = %d, fNDigitsCluster = %d (should never happen...)", iDigit, fNDigitsCluster));
+ return;
+ }
+
+ if (fClustersArray[iCluster][iDigit] != 0){
+ AliError("Digit already added! (should never happen...)");
return;
}
} // loop on eta shift
} // loop on phi shift
-
- if(fNumberOfECAClusters >= fRecPoints->GetSize())
- fRecPoints->Expand(fNumberOfECAClusters+1);
- Int_t iRecPoint = 0;
- for (Int_t iCluster = 0; iCluster < nTotalClus; iCluster++) {
-
- if (fClustersArray[iCluster] == NULL)
- continue;
+ AliEMCALRecPoint *recPoint = 0;
+ Bool_t recPointOk = kFALSE;
+ for (Int_t iCluster = 0; iCluster < fNTotalClus; iCluster++) {
+
+ if (!recPoint) {
+ if(fNumberOfECAClusters >= fRecPoints->GetSize()) fRecPoints->Expand(fNumberOfECAClusters*2+1);
- (*fRecPoints)[iRecPoint] = new AliEMCALRecPoint("");
- AliEMCALRecPoint *recPoint = dynamic_cast<AliEMCALRecPoint*> (fRecPoints->At(iRecPoint));
+ (*fRecPoints)[fNumberOfECAClusters] = new AliEMCALRecPoint("");
+ recPoint = static_cast<AliEMCALRecPoint*>(fRecPoints->At(fNumberOfECAClusters));
+ }
if (recPoint) {
- iRecPoint++;
recPoint->SetClusterType(AliVCluster::kEMCALClusterv1);
recPoint->SetUniqueID(iCluster);
+ fNumberOfECAClusters++;
- for (Int_t iDigit = 0; iDigit < nDigitsCluster; iDigit++){
- if (fClustersArray[iCluster][iDigit] == NULL) continue;
+ for (Int_t iDigit = 0; iDigit < fNDigitsCluster; iDigit++) {
+ if (fClustersArray[iCluster][iDigit] == 0) continue;
digit = fClustersArray[iCluster][iDigit];
recPoint->AddDigit(*digit, digit->GetCalibAmp(), kFALSE); //Time or TimeR?
- fClustersArray[iCluster][iDigit] = NULL;
+ fClustersArray[iCluster][iDigit] = 0;
+ recPointOk = kTRUE;
+ }
+
+ if (recPointOk) { // unset the pointer so that a new rec point will be allocated in the next iteration
+ recPoint = 0;
+ recPointOk = kFALSE;
}
}
-
- delete[] fClustersArray[iCluster];
- fClustersArray[iCluster] = NULL;
+ else {
+ AliError("Error allocating rec points!");
+ break;
+ }
+ }
+
+ if (!recPointOk) {
+ fRecPoints->RemoveLast();
+ fNumberOfECAClusters--;
}
delete digitsC;
void SetTRUshift(Bool_t b);
protected:
- virtual void MakeClusters();
+ void MakeClusters();
+ void ExecOnce();
Int_t fNphi; // Fixed window number of cells in phi direction
Int_t fNeta; // Fixed window number of cells in eta direction
Int_t fShiftPhi; // Shifting number of cells in phi direction
Int_t fShiftEta; // Shifting number of cells in eta direction
Bool_t fTRUshift; // Allows shifting inside a TRU (true) of through the whole calorimeter (false)
+ Int_t fNEtaDigitsSupMod; //!Number of digits per SM in eta
+ Int_t fNPhiDigitsSupMod; //!Number of digits per SM in phi
+ Int_t fNTRUPhi; //!Number of TRUs in phi
+ Int_t fNTRUEta; //!Number of TRUs in eta
+ Int_t fNEtaDigits; //!Total number of digits in eta
+ Int_t fNPhiDigits; //!Total number of digits in phi
+ Int_t fMaxShiftPhi; //!Max shift index in phi
+ Int_t fMaxShiftEta; //!Max shift index in eta
+ Int_t fNDigitsCluster; //!Digits per cluster
+ Int_t fNClusEtaNoShift; //!Max number of clusters in eta
+ Int_t fNClusPhiNoShift; //!Max number of clusters in phi
+ Int_t fNClusters; //!fNClusEtaNoShift x fNClusPhiNoShift
+ Int_t fNTotalClus; //!Maximum total number of clusters
AliEMCALDigit ***fClustersArray; //!Temporary array that contains clusters
+ Int_t fInitialized; //!Initialized clusterizer
private:
AliEMCALClusterizerFixedWindow(const AliEMCALClusterizerFixedWindow &); // not implemented
AliEMCALClusterizerFixedWindow & operator = (const AliEMCALClusterizerFixedWindow &); // not implemented
- ClassDef(AliEMCALClusterizerFixedWindow,4) // Clusterizer implementation version 1
+ ClassDef(AliEMCALClusterizerFixedWindow,4) // Clusterizer implementation fixed windows
};
#endif // AliEMCALCLUSTERIZERFIXEDWINDOW_H
cont->SetParticleArray(InputEvent());
}
- fTracks = GetParticleArray(0);
- if(!fTracks && fParticleCollArray.GetEntriesFast()>0) {
- AliError(Form("%s: Could not retrieve first track branch!", GetName()));
- return;
+ if (fParticleCollArray.GetEntriesFast()>0) {
+ fTracks = GetParticleArray(0);
+ if(!fTracks) {
+ AliError(Form("%s: Could not retrieve first track branch!", GetName()));
+ return;
+ }
}
//Load all requested cluster branches - each container knows name already
AliClusterContainer *cont = static_cast<AliClusterContainer*>(fClusterCollArray.At(i));
cont->SetClusterArray(InputEvent());
}
- if(fClusterCollArray.GetEntriesFast()>0)
+
+ if(fClusterCollArray.GetEntriesFast()>0) {
fCaloClusters = GetClusterArray(0);
- if(!fCaloClusters && fClusterCollArray.GetEntriesFast()>0) {
- AliError(Form("%s: Could not retrieve first cluster branch!", GetName()));
- return;
+ if(!fCaloClusters) {
+ AliError(Form("%s: Could not retrieve first cluster branch!", GetName()));
+ return;
+ }
}
if (!fCaloCellsName.IsNull() && !fCaloCells) {
if (fBeamType == kAA || fBeamType == kpA ) {
AliCentrality *aliCent = InputEvent()->GetCentrality();
if (aliCent) {
- fCent = aliCent->GetCentralityPercentile(fCentEst.Data());
+ fCent = aliCent->GetCentralityPercentile(fCentEst.Data());
if(fNcentBins==4) {
if (fCent >= 0 && fCent < 10) fCentBin = 0;
else if (fCent >= 10 && fCent < 30) fCentBin = 1;
AliWarning(Form("%s: fCentBin too large: cent = %f fCentBin = %d. Assuming 99", GetName(),fCent,fCentBin));
fCentBin = fNcentBins-1;
}
- if(fCentBin>=fNcentBins) {
- AliWarning(Form("%s: fCentBin too large: cent = %f fCentBin = %d. Assuming 99", GetName(),fCent,fCentBin));
- fCentBin = fNcentBins-1;
- }
}
} else {
AliWarning(Form("%s: Could not retrieve centrality information! Assuming 99", GetName()));
void AddClusterContainer(const char *n);
- AliParticleContainer *GetParticleContainer(const Int_t i) const;
- AliClusterContainer *GetClusterContainer(const Int_t i) const;
- void RemoveParticleContainer(Int_t i) { fParticleCollArray.RemoveAt(i);}
- void RemoveClusterContainer(Int_t i) { fClusterCollArray.RemoveAt(i);}
+ AliParticleContainer *GetParticleContainer(const Int_t i=0) const;
+ AliClusterContainer *GetClusterContainer(const Int_t i=0) const;
+ void RemoveParticleContainer(Int_t i=0) { fParticleCollArray.RemoveAt(i);}
+ void RemoveClusterContainer(Int_t i=0) { fClusterCollArray.RemoveAt(i);}
- TClonesArray *GetParticleArray(const Int_t i) const;
- TClonesArray *GetClusterArray(const Int_t i) const;
+ TClonesArray *GetParticleArray(const Int_t i=0) const;
+ TClonesArray *GetClusterArray(const Int_t i=0) const;
- AliVParticle *GetAcceptParticleFromArray(Int_t p, Int_t c) const;
- AliVCluster *GetAcceptClusterFromArray(Int_t cl, Int_t c) const;
+ AliVParticle *GetAcceptParticleFromArray(Int_t p, Int_t c=0) const;
+ AliVCluster *GetAcceptClusterFromArray(Int_t cl, Int_t c=0) const;
- Int_t GetNParticles(Int_t i) const;
- Int_t GetNClusters(Int_t i) const;
+ Int_t GetNParticles(Int_t i=0) const;
+ Int_t GetNClusters(Int_t i=0) const;
protected:
Bool_t AcceptCluster(AliVCluster *clus, Int_t c = 0) const;
EMCALJetTasks/AliRhoParameter.cxx
EMCALJetTasks/AliLocalRhoParameter.cxx
EMCALJetTasks/AliEmcalJetFinder.cxx
+ EMCALJetTasks/AliJetTriggerSelectionTask.cxx
EMCALJetTasks/UserTasks/AliAnalysisTaskCLQA.cxx
EMCALJetTasks/UserTasks/AliAnalysisTaskChargedJetsPA.cxx
EMCALJetTasks/UserTasks/AliAnalysisTaskEmcalBadCells.cxx
fLeadingHadronType(0),
fNLeadingJets(1),
fJetBitMap(0),
+ fJetTrigger(0),
fJets(0),
fRho(0),
fRhoVal(0)
fLeadingHadronType(0),
fNLeadingJets(1),
fJetBitMap(0),
+ fJetTrigger(0),
fJets(0),
fRho(0),
fRhoVal(0)
if (fJetMinPhi < 0) // if limits are given in (-pi, pi) range
jetPhi -= TMath::Pi() * 2;
+ if (fJetTrigger != 0 && !jet->IsTriggerJet(fJetTrigger))
+ return kFALSE;
+
return (Bool_t)(jetEta > fJetMinEta && jetEta < fJetMaxEta && jetPhi > fJetMinPhi && jetPhi < fJetMaxPhi);
}
class AliVCluster;
class AliVParticle;
+#include "AliVEvent.h"
#include "AliAnalysisTaskEmcal.h"
class AliAnalysisTaskEmcalJet : public AliAnalysisTaskEmcal {
void SetLeadingHadronType(Int_t t) { fLeadingHadronType = t ; }
void SetNLeadingJets(Int_t t) { fNLeadingJets = t ; }
void SetJetBitMap(UInt_t m) { fJetBitMap = m ; }
+ void SetJetTrigger(UInt_t t=AliVEvent::kEMCEJE) { fJetTrigger = t ; }
protected:
Float_t* GenerateFixedBinArray(Int_t n, Float_t min, Float_t max) const;
Int_t fLeadingHadronType; // 0 = charged, 1 = neutral, 2 = both
Int_t fNLeadingJets; // how many jets are to be considered the leading jet(s)
UInt_t fJetBitMap; // bit map of accepted jets
+ UInt_t fJetTrigger; // jet trigger
TClonesArray *fJets; //!jets
AliRhoParameter *fRho; //!event rho
Double_t fRhoVal; //!event rho value
AliAnalysisTaskEmcalJet(const AliAnalysisTaskEmcalJet&); // not implemented
AliAnalysisTaskEmcalJet &operator=(const AliAnalysisTaskEmcalJet&); // not implemented
- ClassDef(AliAnalysisTaskEmcalJet, 7) // EMCAL Jet base analysis task
+ ClassDef(AliAnalysisTaskEmcalJet, 8) // EMCAL Jet base analysis task
};
#endif
void AddJetContainer(const char *n, TString defaultCutType = "", Float_t jetRadius = 0.4);
void RemoveJetContainer(Int_t i) { fJetCollArray.RemoveAt(i);}
- AliJetContainer *GetJetContainer(Int_t i) const;
- TClonesArray *GetJetArray(Int_t i) const;
- AliEmcalJet *GetJetFromArray(Int_t j, Int_t c) const;
- AliEmcalJet *GetAcceptJetFromArray(Int_t j, Int_t c) const;
- Int_t GetNJets(Int_t i) const;
- Double_t GetRhoVal(Int_t i) const;
+ AliJetContainer *GetJetContainer(Int_t i=0) const;
+ TClonesArray *GetJetArray(Int_t i=0) const;
+ AliEmcalJet *GetJetFromArray(Int_t j, Int_t c=0) const;
+ AliEmcalJet *GetAcceptJetFromArray(Int_t j, Int_t c=0) const;
+ Int_t GetNJets(Int_t i=0) const;
+ Double_t GetRhoVal(Int_t i=0) const;
protected:
Float_t* GenerateFixedBinArray(Int_t n, Float_t min, Float_t max) const;
fMatched(2),
fMatchingType(0),
fPtSub(0),
- fPtVectSub(0)
+ fPtVectSub(0),
+ fTriggers(0)
{
// Constructor.
fMatched(2),
fMatchingType(0),
fPtSub(0),
- fPtVectSub(0)
+ fPtVectSub(0),
+ fTriggers(0)
{
// Constructor.
fMatched(2),
fMatchingType(0),
fPtSub(0),
- fPtVectSub(0)
+ fPtVectSub(0),
+ fTriggers(0)
{
// Constructor.
fMatched(jet.fMatched),
fMatchingType(jet.fMatchingType),
fPtSub(jet.fPtSub),
- fPtVectSub(jet.fPtVectSub)
+ fPtVectSub(jet.fPtVectSub),
+ fTriggers(jet.fTriggers)
{
// Copy constructor.
fMatched = jet.fMatched;
fPtSub = jet.fPtSub;
fPtVectSub = jet.fPtVectSub;
+ fTriggers = jet.fTriggers;
}
return *this;
#include "AliVParticle.h"
#include "AliVCluster.h"
+#include "AliVEvent.h"
class AliEmcalJet : public AliVParticle
{
void SetNEmc(Int_t n) { fNEmc = n; }
void SetPtEmc(Double_t pt) { fPtEmc = pt; }
void SetPtSub(Double_t ps) { fPtSub = ps; }
- void SetPtSubVect(Double_t ps) { fPtVectSub = ps; }
+ void SetPtSubVect(Double_t ps) { fPtVectSub = ps; }
+
+ // Trigger
+ Bool_t IsTriggerJet(UInt_t trigger=AliVEvent::kEMCEJE) const { return (Bool_t)((fTriggers & trigger) != 0); }
+ void SetTrigger(UInt_t trigger) { fTriggers = trigger; }
+ void AddTrigger(UInt_t trigger) { fTriggers |= trigger; }
// Matching
void SetClosestJet(AliEmcalJet *j, Double_t d) { fClosestJets[0] = j; fClosestJetsDist[0] = d ; }
UShort_t fMatchingType; //! matching type
Double_t fPtSub; //! background subtracted pt (not stored set from outside)
Double_t fPtVectSub; //! background vector subtracted pt (not stored set from outside)
+ UInt_t fTriggers; //! triggers that the jet might have fired (AliVEvent::EOfflineTriggerTypes)
ClassDef(AliEmcalJet,9) // Emcal jet class in cylindrical coordinates
};
#include <TClonesArray.h>
#include <TH2F.h>
+#include <TH3F.h>
#include <THnSparse.h>
#include <TList.h>
#include <TLorentzVector.h>
//________________________________________________________________________
AliAnalysisTaskSAJF::AliAnalysisTaskSAJF() :
AliAnalysisTaskEmcalJet("AliAnalysisTaskSAJF", kTRUE),
+ fHistoType(1),
fHistJetObservables(0)
{
fHistClustersJetPt[i] = 0;
fHistTracksPtDist[i] = 0;
fHistClustersPtDist[i] = 0;
+
+ fHistJetPtEtaPhi[i] = 0;
+ fHistJetPtArea[i] = 0;
+ fHistJetPtEP[i] = 0;
+ fHistJetPtNEF[i] = 0;
+ fHistJetPtZ[i] = 0;
+ fHistJetPtLeadingPartPt[i] = 0;
+ fHistJetCorrPtEtaPhi[i] = 0;
+ fHistJetCorrPtArea[i] = 0;
+ fHistJetCorrPtEP[i] = 0;
+ fHistJetCorrPtNEF[i] = 0;
+ fHistJetCorrPtZ[i] = 0;
+ fHistJetCorrPtLeadingPartPt[i] = 0;
+ fHistJetPtCorrPt[i] = 0;
+ fHistJetPtMCPt[i] = 0;
+ fHistJetMCPtCorrPt[i] = 0;
}
SetMakeGeneralHistograms(kTRUE);
//________________________________________________________________________
AliAnalysisTaskSAJF::AliAnalysisTaskSAJF(const char *name) :
AliAnalysisTaskEmcalJet(name, kTRUE),
+ fHistoType(1),
fHistJetObservables(0)
{
// Standard constructor.
fHistClustersJetPt[i] = 0;
fHistTracksPtDist[i] = 0;
fHistClustersPtDist[i] = 0;
+
+ fHistJetPtEtaPhi[i] = 0;
+ fHistJetPtArea[i] = 0;
+ fHistJetPtEP[i] = 0;
+ fHistJetPtNEF[i] = 0;
+ fHistJetPtZ[i] = 0;
+ fHistJetPtLeadingPartPt[i] = 0;
+ fHistJetCorrPtEtaPhi[i] = 0;
+ fHistJetCorrPtArea[i] = 0;
+ fHistJetCorrPtEP[i] = 0;
+ fHistJetCorrPtNEF[i] = 0;
+ fHistJetCorrPtZ[i] = 0;
+ fHistJetCorrPtLeadingPartPt[i] = 0;
+ fHistJetPtCorrPt[i] = 0;
+ fHistJetPtMCPt[i] = 0;
+ fHistJetMCPtCorrPt[i] = 0;
}
SetMakeGeneralHistograms(kTRUE);
}
//________________________________________________________________________
-void AliAnalysisTaskSAJF::UserCreateOutputObjects()
+void AliAnalysisTaskSAJF::AllocateTHnSparse()
{
- // Create user output.
-
- AliAnalysisTaskEmcalJet::UserCreateOutputObjects();
-
- TString title[20]= {""};
+ TString title[20]= {""};
Int_t nbins[20] = {0};
Double_t min[20] = {0.};
Double_t max[20] = {0.};
if (fForceBeamType != kpp) {
title[dim] = "Centrality (%)";
- nbins[dim] = 101;
- min[dim] = 0;
- max[dim] = 101;
+ nbins[dim] = 22;
+ min[dim] = -5;
+ max[dim] = 105;
dim++;
title[dim] = "#phi_{jet} - #psi_{RP}";
- nbins[dim] = fNbins/2;
- min[dim] = -TMath::Pi()/2;
- max[dim] = TMath::Pi()*5/2;
+ nbins[dim] = 100;
+ min[dim] = 0;
+ max[dim] = TMath::Pi();
dim++;
}
title[dim] = "#eta";
- nbins[dim] = fNbins/2;
+ nbins[dim] = 100;
min[dim] = -1;
max[dim] = 1;
dim++;
title[dim] = "#phi_{jet} (rad)";
- nbins[dim] = fNbins/2+1;
+ nbins[dim] = 201;
min[dim] = 0;
max[dim] = 2*TMath::Pi()*nbins[dim]/(nbins[dim]-1);
dim++;
title[dim] = "p_{T} (GeV/c)";
nbins[dim] = fNbins;
- min[dim] = 0;
- max[dim] = 250;
+ min[dim] = fMinBinPt;
+ max[dim] = fMaxBinPt;
dim++;
if (fIsEmbedded) {
title[dim] = "p_{T}^{MC} (GeV/c)";
nbins[dim] = fNbins;
- min[dim] = 0;
- max[dim] = 250;
+ min[dim] = fMinBinPt;
+ max[dim] = fMaxBinPt;
dim++;
}
if (!fRhoName.IsNull()) {
title[dim] = "p_{T}^{corr} (GeV/c)";
nbins[dim] = fNbins*2;
- min[dim] = -250;
- max[dim] = 250;
+ min[dim] = -fMaxBinPt;
+ max[dim] = fMaxBinPt;
dim++;
}
title[dim] = "A_{jet}";
- nbins[dim] = fNbins/2;
+ nbins[dim] = 150;
min[dim] = 0;
- max[dim] = 1;
+ max[dim] = 1.5;
dim++;
title[dim] = "NEF";
- nbins[dim] = fNbins/2;
+ nbins[dim] = 102;
min[dim] = 0;
- max[dim] = 1.25;
+ max[dim] = 1.02;
dim++;
title[dim] = "Z";
- nbins[dim] = fNbins/2;
+ nbins[dim] = 102;
min[dim] = 0;
- max[dim] = 1.25;
+ max[dim] = 1.02;
dim++;
title[dim] = "No. of constituents";
dim++;
title[dim] = "p_{T,particle}^{leading} (GeV/c)";
- nbins[dim] = fNbins/2;
+ nbins[dim] = 120;
min[dim] = 0;
- max[dim] = 125;
+ max[dim] = 120;
dim++;
fHistJetObservables = new THnSparseD("fHistJetObservables","fHistJetObservables",dim,nbins,min,max);
fOutput->Add(fHistJetObservables);
for (Int_t i = 0; i < dim; i++)
fHistJetObservables->GetAxis(i)->SetTitle(title[i]);
+}
+
+//________________________________________________________________________
+void AliAnalysisTaskSAJF::AllocateTHX()
+{
+ for (Int_t i = 0; i < 4; i++) {
+ TString histname;
+
+ histname = "fHistJetPtEtaPhi_";
+ histname += i;
+ fHistJetPtEtaPhi[i] = new TH3F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt, 20, -1, 1, 41, 0, 2*TMath::Pi()*41/40);
+ fHistJetPtEtaPhi[i]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
+ fHistJetPtEtaPhi[i]->GetYaxis()->SetTitle("#eta");
+ fHistJetPtEtaPhi[i]->GetZaxis()->SetTitle("#phi_{jet} (rad)");
+ fOutput->Add(fHistJetPtEtaPhi[i]);
+
+ histname = "fHistJetPtArea_";
+ histname += i;
+ fHistJetPtArea[i] = new TH2F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt, 150, 0, 1.5);
+ fHistJetPtArea[i]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
+ fHistJetPtArea[i]->GetYaxis()->SetTitle("A_{jet}");
+ fHistJetPtArea[i]->GetZaxis()->SetTitle("counts");
+ fOutput->Add(fHistJetPtArea[i]);
+
+ histname = "fHistJetPtEP_";
+ histname += i;
+ fHistJetPtEP[i] = new TH2F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt, 100, 0, TMath::Pi());
+ fHistJetPtEP[i]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
+ fHistJetPtEP[i]->GetYaxis()->SetTitle("#phi_{jet} - #psi_{RP}");
+ fHistJetPtEP[i]->GetZaxis()->SetTitle("counts");
+ fOutput->Add(fHistJetPtEP[i]);
+
+ histname = "fHistJetPtNEF_";
+ histname += i;
+ fHistJetPtNEF[i] = new TH2F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt, 102, 0, 1.02);
+ fHistJetPtNEF[i]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
+ fHistJetPtNEF[i]->GetYaxis()->SetTitle("NEF");
+ fHistJetPtNEF[i]->GetZaxis()->SetTitle("counts");
+ fOutput->Add(fHistJetPtNEF[i]);
+
+ histname = "fHistJetPtZ_";
+ histname += i;
+ fHistJetPtZ[i] = new TH2F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt, 102, 0, 1.02);
+ fHistJetPtZ[i]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
+ fHistJetPtZ[i]->GetYaxis()->SetTitle("z");
+ fHistJetPtZ[i]->GetZaxis()->SetTitle("counts");
+ fOutput->Add(fHistJetPtZ[i]);
+
+ histname = "fHistJetPtLeadingPartPt_";
+ histname += i;
+ fHistJetPtLeadingPartPt[i] = new TH2F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt, 120, 0, 120);
+ fHistJetPtLeadingPartPt[i]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
+ fHistJetPtLeadingPartPt[i]->GetYaxis()->SetTitle("p_{T,particle}^{leading} (GeV/c)");
+ fHistJetPtLeadingPartPt[i]->GetZaxis()->SetTitle("counts");
+ fOutput->Add(fHistJetPtLeadingPartPt[i]);
+
+ if (!fRhoName.IsNull()) {
+ histname = "fHistJetCorrPtEtaPhi_";
+ histname += i;
+ fHistJetCorrPtEtaPhi[i] = new TH3F(histname.Data(), histname.Data(), fNbins*2, -fMaxBinPt, fMaxBinPt, 20, -1, 1, 41, 0, 2*TMath::Pi()*201/200);
+ fHistJetCorrPtEtaPhi[i]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
+ fHistJetCorrPtEtaPhi[i]->GetYaxis()->SetTitle("#eta");
+ fHistJetCorrPtEtaPhi[i]->GetZaxis()->SetTitle("#phi_{jet} (rad)");
+ fOutput->Add(fHistJetCorrPtEtaPhi[i]);
+
+ histname = "fHistJetCorrPtArea_";
+ histname += i;
+ fHistJetCorrPtArea[i] = new TH2F(histname.Data(), histname.Data(), fNbins*2, -fMaxBinPt, fMaxBinPt, 150, 0, 1.5);
+ fHistJetCorrPtArea[i]->GetXaxis()->SetTitle("p_{T}^{corr} (GeV/c)");
+ fHistJetCorrPtArea[i]->GetYaxis()->SetTitle("A_{jet}");
+ fHistJetCorrPtArea[i]->GetZaxis()->SetTitle("counts");
+ fOutput->Add(fHistJetCorrPtArea[i]);
+
+ histname = "fHistJetCorrPtEP_";
+ histname += i;
+ fHistJetCorrPtEP[i] = new TH2F(histname.Data(), histname.Data(), fNbins*2, -fMaxBinPt, fMaxBinPt, 100, 0, TMath::Pi());
+ fHistJetCorrPtEP[i]->GetXaxis()->SetTitle("p_{T}^{corr} (GeV/c)");
+ fHistJetCorrPtEP[i]->GetYaxis()->SetTitle("#phi_{jet} - #psi_{RP}");
+ fHistJetCorrPtEP[i]->GetZaxis()->SetTitle("counts");
+ fOutput->Add(fHistJetCorrPtEP[i]);
+
+ histname = "fHistJetCorrPtNEF_";
+ histname += i;
+ fHistJetCorrPtNEF[i] = new TH2F(histname.Data(), histname.Data(), fNbins*2, -fMaxBinPt, fMaxBinPt, 102, 0, 1.02);
+ fHistJetCorrPtNEF[i]->GetXaxis()->SetTitle("p_{T}^{corr} (GeV/c)");
+ fHistJetCorrPtNEF[i]->GetYaxis()->SetTitle("NEF");
+ fHistJetCorrPtNEF[i]->GetZaxis()->SetTitle("counts");
+ fOutput->Add(fHistJetCorrPtNEF[i]);
+
+ histname = "fHistJetCorrPtZ_";
+ histname += i;
+ fHistJetCorrPtZ[i] = new TH2F(histname.Data(), histname.Data(), fNbins*2, -fMaxBinPt, fMaxBinPt, 102, 0, 1.02);
+ fHistJetCorrPtZ[i]->GetXaxis()->SetTitle("p_{T}^{corr} (GeV/c)");
+ fHistJetCorrPtZ[i]->GetYaxis()->SetTitle("z");
+ fHistJetCorrPtZ[i]->GetZaxis()->SetTitle("counts");
+ fOutput->Add(fHistJetCorrPtZ[i]);
+
+ histname = "fHistJetCorrPtLeadingPartPt_";
+ histname += i;
+ fHistJetCorrPtLeadingPartPt[i] = new TH2F(histname.Data(), histname.Data(), fNbins*2, -fMaxBinPt, fMaxBinPt, 120, 0, 120);
+ fHistJetCorrPtLeadingPartPt[i]->GetXaxis()->SetTitle("p_{T}^{corr} (GeV/c)");
+ fHistJetCorrPtLeadingPartPt[i]->GetYaxis()->SetTitle("p_{T,particle}^{leading} (GeV/c)");
+ fHistJetCorrPtLeadingPartPt[i]->GetZaxis()->SetTitle("counts");
+ fOutput->Add(fHistJetCorrPtLeadingPartPt[i]);
+
+ histname = "fHistJetPtCorrPt_";
+ histname += i;
+ fHistJetPtCorrPt[i] = new TH2F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt, fNbins*2, -fMaxBinPt, fMaxBinPt);
+ fHistJetPtCorrPt[i]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
+ fHistJetPtCorrPt[i]->GetYaxis()->SetTitle("p_{T}^{corr} (GeV/c)");
+ fHistJetPtCorrPt[i]->GetZaxis()->SetTitle("counts");
+ fOutput->Add(fHistJetPtCorrPt[i]);
+
+ if (fIsEmbedded) {
+ histname = "fHistJetMCPtCorrPt_";
+ histname += i;
+ fHistJetMCPtCorrPt[i] = new TH2F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt, fNbins*2, -fMaxBinPt, fMaxBinPt);
+ fHistJetMCPtCorrPt[i]->GetXaxis()->SetTitle("p_{T}^{MC} (GeV/c)");
+ fHistJetMCPtCorrPt[i]->GetYaxis()->SetTitle("p_{T}^{corr} (GeV/c)");
+ fHistJetMCPtCorrPt[i]->GetZaxis()->SetTitle("counts");
+ fOutput->Add(fHistJetMCPtCorrPt[i]);
+ }
+ }
+
+ if (fIsEmbedded) {
+ histname = "fHistJetPtMCPt_";
+ histname += i;
+ fHistJetPtMCPt[i] = new TH2F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt, fNbins, fMinBinPt, fMaxBinPt);
+ fHistJetPtMCPt[i]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
+ fHistJetPtMCPt[i]->GetYaxis()->SetTitle("p_{T}^{MC} (GeV/c)");
+ fHistJetPtMCPt[i]->GetZaxis()->SetTitle("counts");
+ fOutput->Add(fHistJetPtMCPt[i]);
+ }
+ }
+}
+
+//________________________________________________________________________
+void AliAnalysisTaskSAJF::UserCreateOutputObjects()
+{
+ // Create user output.
+
+ AliAnalysisTaskEmcalJet::UserCreateOutputObjects();
+
+ if (fHistoType == 0)
+ AllocateTHX();
+ else
+ AllocateTHnSparse();
for (Int_t i = 0; i < 4; i++) {
TString histname;
Float_t corrPt = jet->Pt() - fRhoVal * jet->Area();
// Fill THnSparse
- FillJetHisto(fCent, fEPV0, jet->Eta(), jet->Phi(), jet->Pt(), jet->MCPt(), corrPt, jet->Area(),
+ Double_t ep = jet->Phi() - fEPV0;
+ while (ep < 0) ep += TMath::Pi();
+ while (ep >= TMath::Pi()) ep -= TMath::Pi();
+
+ FillJetHisto(fCent, ep, jet->Eta(), jet->Phi(), jet->Pt(), jet->MCPt(), corrPt, jet->Area(),
jet->NEF(), ptLeading/jet->Pt(), jet->GetNumberOfConstituents(), ptLeading);
if (fTracks) {
void AliAnalysisTaskSAJF::FillJetHisto(Double_t cent, Double_t ep, Double_t eta, Double_t phi, Double_t pt, Double_t MCpt, Double_t corrpt, Double_t area,
Double_t NEF, Double_t z, Int_t n, Double_t leadingpt)
{
- Double_t contents[20]={0};
-
- for (Int_t i = 0; i < fHistJetObservables->GetNdimensions(); i++) {
- TString title(fHistJetObservables->GetAxis(i)->GetTitle());
- if (title=="Centrality (%)")
- contents[i] = cent;
- else if (title=="#phi_{jet} - #psi_{RP}")
- contents[i] = phi - ep;
- else if (title=="#eta")
- contents[i] = eta;
- else if (title=="#phi_{jet} (rad)")
- contents[i] = phi;
- else if (title=="p_{T} (GeV/c)")
- contents[i] = pt;
- else if (title=="p_{T}^{MC} (GeV/c)")
- contents[i] = MCpt;
- else if (title=="p_{T}^{corr} (GeV/c)")
- contents[i] = corrpt;
- else if (title=="A_{jet}")
- contents[i] = area;
- else if (title=="NEF")
- contents[i] = NEF;
- else if (title=="Z")
- contents[i] = z;
- else if (title=="No. of constituents")
- contents[i] = n;
- else if (title=="p_{T,particle}^{leading} (GeV/c)")
- contents[i] = leadingpt;
- else
- AliWarning(Form("Unable to fill dimension %s!",title.Data()));
+ if (fHistoType == 0) {
+ fHistJetPtEtaPhi[fCentBin]->Fill(pt,eta,phi);
+ fHistJetPtArea[fCentBin]->Fill(pt,area);
+ fHistJetPtEP[fCentBin]->Fill(pt,ep);
+ fHistJetPtNEF[fCentBin]->Fill(pt,NEF);
+ fHistJetPtZ[fCentBin]->Fill(pt,z);
+ fHistJetPtLeadingPartPt[fCentBin]->Fill(pt,leadingpt);
+ if (!fRhoName.IsNull()) {
+ fHistJetCorrPtEtaPhi[fCentBin]->Fill(corrpt,eta,phi);
+ fHistJetCorrPtArea[fCentBin]->Fill(corrpt,area);
+ fHistJetCorrPtEP[fCentBin]->Fill(corrpt,ep);
+ fHistJetCorrPtNEF[fCentBin]->Fill(corrpt,NEF);
+ fHistJetCorrPtZ[fCentBin]->Fill(corrpt,z);
+ fHistJetCorrPtLeadingPartPt[fCentBin]->Fill(corrpt,leadingpt);
+ fHistJetPtCorrPt[fCentBin]->Fill(pt,corrpt);
+ if (fIsEmbedded)
+ fHistJetMCPtCorrPt[fCentBin]->Fill(MCpt,corrpt);
+ }
+ if (fIsEmbedded)
+ fHistJetPtMCPt[fCentBin]->Fill(pt,MCpt);
}
+ else {
+
+ Double_t contents[20]={0};
+
+ for (Int_t i = 0; i < fHistJetObservables->GetNdimensions(); i++) {
+ TString title(fHistJetObservables->GetAxis(i)->GetTitle());
+ if (title=="Centrality (%)")
+ contents[i] = cent;
+ else if (title=="#phi_{jet} - #psi_{RP}")
+ contents[i] = ep;
+ else if (title=="#eta")
+ contents[i] = eta;
+ else if (title=="#phi_{jet} (rad)")
+ contents[i] = phi;
+ else if (title=="p_{T} (GeV/c)")
+ contents[i] = pt;
+ else if (title=="p_{T}^{MC} (GeV/c)")
+ contents[i] = MCpt;
+ else if (title=="p_{T}^{corr} (GeV/c)")
+ contents[i] = corrpt;
+ else if (title=="A_{jet}")
+ contents[i] = area;
+ else if (title=="NEF")
+ contents[i] = NEF;
+ else if (title=="Z")
+ contents[i] = z;
+ else if (title=="No. of constituents")
+ contents[i] = n;
+ else if (title=="p_{T,particle}^{leading} (GeV/c)")
+ contents[i] = leadingpt;
+ else
+ AliWarning(Form("Unable to fill dimension %s!",title.Data()));
+ }
- fHistJetObservables->Fill(contents);
+ fHistJetObservables->Fill(contents);
+ }
}
// $Id$
-#include <TH3F.h>
-
class TH2;
class THnSparse;
+#include <TH3F.h>
+
#include "AliAnalysisTaskEmcalJet.h"
class AliAnalysisTaskSAJF : public AliAnalysisTaskEmcalJet {
void UserCreateOutputObjects();
+ void SetHistoType(Int_t t) { fHistoType = t; }
+
protected:
- Bool_t FillHistograms() ;
+ void AllocateTHX();
+ void AllocateTHnSparse();
+
+ Bool_t FillHistograms();
void FillJetHisto(Double_t cent, Double_t ep, Double_t eta, Double_t phi, Double_t pt, Double_t MCpt, Double_t corrpt, Double_t area,
Double_t NEF, Double_t z, Int_t n, Double_t leadingpt);
+ Int_t fHistoType; // histogram type (0=TH2, 1=THnSparse)
+
// Inclusive jets histograms
- THnSparse *fHistJetObservables; //!Jet-wise observables
- TH2 *fHistTracksJetPt[4]; //!Track pt vs. jet pt
- TH2 *fHistClustersJetPt[4]; //!Cluster pt vs. jet pt
- TH2 *fHistTracksPtDist[4]; //!Track pt vs. distance form jet axis
- TH2 *fHistClustersPtDist[4]; //!Cluster pt vs. distance form jet axis
+ THnSparse *fHistJetObservables; //!Jet-wise observables
+
+ // TH2/TH3 versions
+ TH3 *fHistJetPtEtaPhi[4]; //!Jet Pt vs. Eta vs. Phi
+ TH2 *fHistJetPtArea[4]; //!Jet Pt vs. Area
+ TH2 *fHistJetPtEP[4]; //!Jet Pt vs. event plane
+ TH2 *fHistJetPtNEF[4]; //!Jet Pt vs. neutral energy fraction
+ TH2 *fHistJetPtZ[4]; //!Jet Pt vs. z
+ TH2 *fHistJetPtLeadingPartPt[4]; //!Jet Pt vs. leading particle pt
+ TH3 *fHistJetCorrPtEtaPhi[4]; //!Jet corrPt vs. Eta vs. Phi
+ TH2 *fHistJetCorrPtArea[4]; //!Jet corrPt vs. Area
+ TH2 *fHistJetCorrPtEP[4]; //!Jet corrPt vs. event plane
+ TH2 *fHistJetCorrPtNEF[4]; //!Jet corrPt vs. neutral energy fraction
+ TH2 *fHistJetCorrPtZ[4]; //!Jet corrPt vs. z
+ TH2 *fHistJetCorrPtLeadingPartPt[4]; //!Jet corrPt vs. leading particle pt
+ TH2 *fHistJetPtCorrPt[4]; //!Jet Pt vs. corrPt
+ TH2 *fHistJetPtMCPt[4]; //!Jet Pt vs. MCPt
+ TH2 *fHistJetMCPtCorrPt[4]; //!Jet MCPt vs. corrPt
+
+ TH2 *fHistTracksJetPt[4]; //!Track pt vs. jet pt
+ TH2 *fHistClustersJetPt[4]; //!Cluster pt vs. jet pt
+ TH2 *fHistTracksPtDist[4]; //!Track pt vs. distance form jet axis
+ TH2 *fHistClustersPtDist[4]; //!Cluster pt vs. distance form jet axis
private:
AliAnalysisTaskSAJF(const AliAnalysisTaskSAJF&); // not implemented
AliAnalysisTaskSAJF &operator=(const AliAnalysisTaskSAJF&); // not implemented
- ClassDef(AliAnalysisTaskSAJF, 15) // jet analysis task
+ ClassDef(AliAnalysisTaskSAJF, 16) // jet analysis task
};
#endif
#pragma link C++ class AliRhoParameter+;
#pragma link C++ class AliLocalRhoParameter+;
#pragma link C++ class AliEmcalJetFinder+;
+#pragma link C++ class AliJetTriggerSelectionTask+;
// user tasks
#pragma link C++ class AliAnalysisTaskCLQA+;
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff