#include "TROOT.h"
+#include "TDirectory.h"
#include "TKey.h"
#include "TList.h"
#include "TSystem.h"
#include "TH1F.h"
#include "TProfile.h"
#include "THnSparse.h"
+#include "TSeqCollection.h"
+#include "TMethodCall.h"
#include "TFile.h"
#include "TString.h"
#include "AliMCEvent.h"
#include "AliLog.h"
+#include "AliESDEvent.h"
#include "AliAODJet.h"
+#include "AliAODEvent.h"
#include "AliStack.h"
#include "AliGenEventHeader.h"
#include "AliGenCocktailEventHeader.h"
+#include <AliGenDPMjetEventHeader.h>
#include "AliGenPythiaEventHeader.h"
#include <fstream>
#include <iostream>
#include "AliAnalysisHelperJetTasks.h"
-
+#include "TMatrixDSym.h"
+#include "TMatrixDSymEigen.h"
+#include "TVector.h"
ClassImp(AliAnalysisHelperJetTasks)
-
+Int_t AliAnalysisHelperJetTasks::fgLastProcessType = -1;
AliGenPythiaEventHeader* AliAnalysisHelperJetTasks::GetPythiaEventHeader(AliMCEvent *mcEvent){
+ if(!mcEvent)return 0;
AliGenEventHeader* genHeader = mcEvent->GenEventHeader();
AliGenPythiaEventHeader* pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(genHeader);
if(!pythiaGenHeader){
}
+void AliAnalysisHelperJetTasks::MergeOutputDirs(const char* cFiles,const char* cPattern,const char *cOutFile,Bool_t bUpdate){
+ // Routine to merge only directories containing the pattern
+ //
+ TString outFile(cOutFile);
+ if(outFile.Length()==0)outFile = Form("%s.root",cPattern);
+ ifstream in1;
+ in1.open(cFiles);
+ // open all files
+ TList fileList;
+ char cFile[240];
+ while(in1>>cFile){// only open the first file
+ Printf("Adding %s",cFile);
+ TFile *f1 = TFile::Open(cFile);
+ fileList.Add(f1);
+ }
+
+ TFile *fOut = 0;
+ if(fileList.GetEntries()){// open the first file
+ TFile* fIn = dynamic_cast<TFile*>(fileList.At(0));
+ if(!fIn){
+ Printf("Input File not Found");
+ }
+ // fetch the keys for the directories
+ TList *ldKeys = fIn->GetListOfKeys();
+ for(int id = 0;id < ldKeys->GetEntries();id++){
+ // check if it is a directory
+ TKey *dKey = (TKey*)ldKeys->At(id);
+ TDirectory *dir = dynamic_cast<TDirectory*>(dKey->ReadObj());
+ if(dir){
+ TString dName(dir->GetName());
+ if(dName.Contains(cPattern)){
+ // open new file if first match
+ if(!fOut){
+ if(bUpdate)fOut = new TFile(outFile.Data(),"UPDATE");
+ else fOut = new TFile(outFile.Data(),"RECREATE");
+ }
+ // merge all the stuff that is in this directory
+ TList *llKeys = dir->GetListOfKeys();
+ TList *tmplist;
+ TMethodCall callEnv;
+
+ fOut->cd();
+ TDirectory *dOut = fOut->mkdir(dir->GetName());
+
+ for(int il = 0;il < llKeys->GetEntries();il++){
+ TKey *lKey = (TKey*)llKeys->At(il);
+ TObject *object = dynamic_cast<TObject*>(lKey->ReadObj());
+ // from TSeqCollections::Merge
+ if(!object)continue;
+ // If current object is not mergeable just skip it
+ if (!object->IsA()) {
+ continue;
+ }
+ callEnv.InitWithPrototype(object->IsA(), "Merge", "TCollection*");
+ if (!callEnv.IsValid()) {
+ continue;
+ }
+ // Current object mergeable - get corresponding objects in input lists
+ tmplist = new TList();
+ for(int i = 1; i < fileList.GetEntries();i++){
+ TDirectory *fInTmp = dynamic_cast<TDirectory*>(fileList.At(i));
+ if(!fInTmp){
+ Printf("File %d not found",i);
+ continue;
+ }
+ TDirectory *dTmp = (TDirectory*)fInTmp->Get(dName.Data());
+ if(!dTmp){
+ Printf("Directory %s not found",dName.Data());
+ continue;
+ }
+ TObject* oTmp = (TObject*)dTmp->Get(object->GetName());
+ if(!oTmp){
+ Printf("Object %s not found",object->GetName());
+ continue;
+ }
+ tmplist->Add(oTmp);
+ }
+ callEnv.SetParam((Long_t) tmplist);
+ callEnv.Execute(object);
+ delete tmplist;tmplist = 0;
+ dOut->cd();
+ object->Write(object->GetName(),TObject::kSingleKey);
+ }
+ }
+ }
+ }
+ if(fOut){
+ fOut->Close();
+ }
+ }
+}
-void AliAnalysisHelperJetTasks::MergeOutput(char* cFiles, char* cList){
+void AliAnalysisHelperJetTasks::MergeOutput(char* cFiles, char* cDir, char *cList,char *cOutFile,Bool_t bUpdate){
// This is used to merge the analysis-output from different
// data samples/pt_hard bins
Float_t nTrials[nMaxBins];
Float_t sf[nMaxBins];
TList *lIn[nMaxBins];
+ TDirectory *dIn[nMaxBins];
TFile *fIn[nMaxBins];
ifstream in1;
Int_t ibTotal = 0;
while(in1>>cFile){
fIn[ibTotal] = TFile::Open(cFile);
- lIn[ibTotal] = (TList*)fIn[ibTotal]->Get(cList);
- Printf("Merging file %s",cFile);
+ if(strlen(cDir)==0){
+ dIn[ibTotal] = gDirectory;
+ }
+ else{
+ dIn[ibTotal] = (TDirectory*)fIn[ibTotal]->Get(cDir);
+ }
+ if(!dIn[ibTotal]){
+ Printf("%s:%d No directory %s found, exiting...",__FILE__,__LINE__,cDir);
+ fIn[ibTotal]->ls();
+ return;
+ }
+
+ lIn[ibTotal] = (TList*)dIn[ibTotal]->Get(cList);
+ Printf("Merging file %s %s",cFile, cDir);
if(!lIn[ibTotal]){
Printf("%s:%d No list %s found, exiting...",__FILE__,__LINE__,cList);
fIn[ibTotal]->ls();
return;
}
- TFile *fOut = new TFile("allpt.root","RECREATE");
+ TFile *fOut = 0;
+ if(bUpdate)fOut = new TFile(cOutFile,"UPDATE");
+ else fOut = new TFile(cOutFile,"RECREATE");
+ TDirectory *dOut = fOut->mkdir(dIn[0]->GetName());
+ dOut->cd();
TList *lOut = new TList();
lOut->SetName(lIn[0]->GetName());
+
// for the start scale all...
for(int ie = 0; ie < lIn[0]->GetEntries();++ie){
TH1 *h1Add = 0;
if(h1Add)lOut->Add(h1Add);
else if(hnAdd)lOut->Add(hnAdd);
}
- fOut->cd();
+ dOut->cd();
lOut->Write(lOut->GetName(),TObject::kSingleKey);
fOut->Close();
}
}
return kTRUE;
}
+
+Bool_t AliAnalysisHelperJetTasks::PrintDirectorySize(const char* currFile){
+
+ TFile *fIn = TFile::Open(currFile);
+ if(!fIn){
+ // not a severe condition but inciate that we have no information
+ return kFALSE;
+ }
+ // find the tlists we want to be independtent of the name so use the Tkey
+ TList* keyList = fIn->GetListOfKeys();
+ Float_t memorySize = 0;
+ Float_t diskSize = 0;
+
+ for(int i = 0;i < keyList->GetEntries();i++){
+ TKey* ikey = (TKey*)keyList->At(i);
+
+ // TList *list = dynamic_cast<TList*>(key->ReadObj());
+ // TNamed *name = dynamic_cast<TNamed*>(ikey->ReadObj());
+ TDirectory *dir = dynamic_cast<TDirectory*>(ikey->ReadObj());
+
+
+
+
+ if(dir){
+ Printf("%03d : %60s %8d %8d ",i,dir->GetName(),ikey->GetObjlen(),ikey->GetNbytes());
+ TList * dirKeyList = dir->GetListOfKeys();
+ for(int j = 0;j<dirKeyList->GetEntries();j++){
+ TKey* jkey = (TKey*)dirKeyList->At(j);
+ TList *list = dynamic_cast<TList*>(jkey->ReadObj());
+
+ memorySize += (Float_t)jkey->GetObjlen()/1024./1024.;
+ diskSize += (Float_t)jkey->GetNbytes()/1024./1024.;
+ if(list){
+ Printf("%03d/%03d: %60s %5.2f MB %5.2f MB",i,j,list->GetName(),(Float_t)jkey->GetObjlen()/1024./1024.,(Float_t)jkey->GetNbytes()/1024./1024.);
+ }
+ else{
+ Printf("%03d/%03d: %60s %5.2f MB %5.2f MB",i,j,jkey->GetName(),(Float_t)jkey->GetObjlen()/1024./1024.,(Float_t)jkey->GetNbytes()/1024./1024.);
+ }
+ }
+ }
+ }
+ Printf("Total %5.2f MB %5.2f MB",memorySize,diskSize);
+ return kTRUE;
+}
+
+
+Bool_t AliAnalysisHelperJetTasks::Selected(Bool_t bSet,Bool_t bNew){
+ static Bool_t bSelected = kTRUE; // if service task is not run we acccpet all
+ if(bSet){
+ bSelected = bNew;
+ }
+ return bSelected;
+}
+
+Bool_t AliAnalysisHelperJetTasks::IsCosmic(){
+ return ((SelectInfo()&kIsCosmic)==kIsCosmic);
+}
+
+Bool_t AliAnalysisHelperJetTasks::IsPileUp(){
+ return ((SelectInfo()&kIsPileUp)==kIsPileUp);
+}
+
+
+Bool_t AliAnalysisHelperJetTasks::TestSelectInfo(UInt_t iMask){
+ return ((SelectInfo()&iMask)==iMask);
+}
+
+
+UInt_t AliAnalysisHelperJetTasks::SelectInfo(Bool_t bSet,UInt_t iNew){
+ static UInt_t iSelectInfo = 0; //
+ if(bSet){
+ iSelectInfo = iNew;
+ }
+ return iSelectInfo;
+}
+
+
+//___________________________________________________________________________________________________________
+
+Bool_t AliAnalysisHelperJetTasks::GetEventShapes(TVector3 &n01, TVector3 * pTrack, Int_t nTracks, Double_t * eventShapes)
+{
+ // ***
+ // Event shape calculation
+ // sona.pochybova@cern.ch
+
+ const Int_t kTracks = 1000;
+ if(nTracks>kTracks)return kFALSE;
+
+ //variables for thrust calculation
+ TVector3 pTrackPerp[kTracks];
+ Double_t psum2 = 0;
+
+ TVector3 psum;
+ TVector3 psum02;
+ TVector3 psum03;
+
+ Double_t psum1 = 0;
+ Double_t psum102 = 0;
+ Double_t psum103 = 0;
+
+ Double_t thrust[kTracks];
+ Double_t th = -3;
+ Double_t thrust02[kTracks];
+ Double_t th02 = -4;
+ Double_t thrust03[kTracks];
+ Double_t th03 = -5;
+
+ //Sphericity calculation variables
+ TMatrixDSym m(3);
+ Double_t s00 = 0;
+ Double_t s01 = 0;
+ Double_t s02 = 0;
+
+ Double_t s10 = 0;
+ Double_t s11 = 0;
+ Double_t s12 = 0;
+
+ Double_t s20 = 0;
+ Double_t s21 = 0;
+ Double_t s22 = 0;
+
+ Double_t ptot = 0;
+
+ Double_t c = -10;
+
+//
+//loop for thrust calculation
+//
+
+ for(Int_t i = 0; i < nTracks; i++)
+ {
+ pTrackPerp[i].SetXYZ(pTrack[i].X(), pTrack[i].Y(), 0);
+ psum2 += pTrackPerp[i].Mag();
+ }
+
+ //additional starting axis
+ TVector3 n02;
+ n02 = pTrack[1].Unit();
+ n02.SetZ(0.);
+ TVector3 n03;
+ n03 = pTrack[2].Unit();
+ n03.SetZ(0.);
+
+ //switches for calculating thrust for different starting points
+ Int_t switch1 = 1;
+ Int_t switch2 = 1;
+ Int_t switch3 = 1;
+
+ //indexes for iteration of different starting points
+ Int_t l1 = 0;
+ Int_t l2 = 0;
+ Int_t l3 = 0;
+
+ //maximal number of iterations
+ // Int_t nMaxIter = 100;
+
+ for(Int_t k = 0; k < nTracks; k++)
+ {
+
+ if(switch1 == 1){
+ psum.SetXYZ(0., 0., 0.);
+ psum1 = 0;
+ for(Int_t i = 0; i < nTracks; i++)
+ {
+ psum1 += (TMath::Abs(n01.Dot(pTrackPerp[i])));
+ if (n01.Dot(pTrackPerp[i]) > 0) psum += pTrackPerp[i];
+ if (n01.Dot(pTrackPerp[i]) < 0) psum -= pTrackPerp[i];
+ }
+ thrust[l1] = psum1/psum2;
+ }
+
+ if(switch2 == 1){
+ psum02.SetXYZ(0., 0., 0.);
+ psum102 = 0;
+ for(Int_t i = 0; i < nTracks; i++)
+ {
+ psum102 += (TMath::Abs(n02.Dot(pTrackPerp[i])));
+ if (n02.Dot(pTrackPerp[i]) > 0) psum02 += pTrackPerp[i];
+ if (n02.Dot(pTrackPerp[i]) < 0) psum02 -= pTrackPerp[i];
+ }
+ thrust02[l2] = psum102/psum2;
+ }
+
+ if(switch3 == 1){
+ psum03.SetXYZ(0., 0., 0.);
+ psum103 = 0;
+ for(Int_t i = 0; i < nTracks; i++)
+ {
+ psum103 += (TMath::Abs(n03.Dot(pTrackPerp[i])));
+ if (n03.Dot(pTrackPerp[i]) > 0) psum03 += pTrackPerp[i];
+ if (n03.Dot(pTrackPerp[i]) < 0) psum03 -= pTrackPerp[i];
+ }
+ thrust03[l3] = psum103/psum2;
+ }
+
+ //check whether thrust value converged
+ if(TMath::Abs(th-thrust[l1]) < 10e-7){
+ switch1 = 0;
+ }
+
+ if(TMath::Abs(th02-thrust02[l2]) < 10e-7){
+ switch2 = 0;
+ }
+
+ if(TMath::Abs(th03-thrust03[l3]) < 10e-7){
+ switch3 = 0;
+ }
+
+ //if it didn't, continue with the calculation
+ if(switch1 == 1){
+ th = thrust[l1];
+ n01 = psum.Unit();
+ l1++;
+ }
+
+ if(switch2 == 1){
+ th02 = thrust02[l2];
+ n02 = psum02.Unit();
+ l2++;
+ }
+
+ if(switch3 == 1){
+ th03 = thrust03[l3];
+ n03 = psum03.Unit();
+ l3++;
+ }
+
+ //if thrust values for all starting direction converged check if to the same value
+ if(switch2 == 0 && switch1 == 0 && switch3 == 0){
+ if(TMath::Abs(th-th02) < 10e-7 && TMath::Abs(th-th03) < 10e-7 && TMath::Abs(th02-th03) < 10e-7){
+ eventShapes[0] = th;
+ AliInfoGeneral(Form(" %s:%d",(char*)__FILE__,__LINE__),Form("===== THRUST VALUE FOUND AT %d :: %f\n", k, th));
+ break;
+ }
+ //if they did not, reset switches
+ else{
+ switch1 = 1;
+ // th = -1.;
+ switch2 = 1;
+ // th02 = -2.;
+ switch3 = 1;
+ // th03 = -4.;
+ }
+ }
+
+ // Printf("========== %d +++ th :: %f=============\n", l1, th);
+ // Printf("========== %d +++ th2 :: %f=============\n", l2, th02);
+ // Printf("========== %d +++ th3 :: %f=============\n", l3, th03);
+
+ }
+
+ //if no common limitng value was found, take the maximum and take the corresponding thrust axis
+ if(switch1 == 1 && switch2 == 1 && switch3 == 1){
+ eventShapes[0] = TMath::Max(thrust[l1-1], thrust02[l2-1]);
+ eventShapes[0] = TMath::Max(eventShapes[0], thrust03[l3-1]);
+ if(TMath::Abs(eventShapes[0]-thrust[l1-1]) < 10e-7)
+ n01 = n01;
+ if(TMath::Abs(eventShapes[0]-thrust02[l2-1]) < 10e-7)
+ n01 = n02;
+ if(TMath::Abs(eventShapes[0]-thrust03[l3-1]) < 10e-7)
+ n01 = n03;
+ Printf("NO LIMITING VALUE FOUND :: MAXIMUM = %f\n", eventShapes[0]);
+ }
+
+//
+//other event shapes variables
+//
+ for(Int_t j = 0; j < nTracks; j++)
+ {
+ s00 = s00 + (pTrack[j].Px()*pTrack[j].Px())/pTrack[j].Mag();
+ s01 = s01 + (pTrack[j].Px()*pTrack[j].Py())/pTrack[j].Mag();
+ s02 = s02 + (pTrack[j].Px()*pTrack[j].Pz())/pTrack[j].Mag();
+
+ s10 = s10 + (pTrack[j].Py()*pTrack[j].Px())/pTrack[j].Mag();
+ s11 = s11 + (pTrack[j].Py()*pTrack[j].Py())/pTrack[j].Mag();
+ s12 = s12 + (pTrack[j].Py()*pTrack[j].Pz())/pTrack[j].Mag();
+
+ s20 = s20 + (pTrack[j].Pz()*pTrack[j].Px())/pTrack[j].Mag();
+ s21 = s21 + (pTrack[j].Pz()*pTrack[j].Py())/pTrack[j].Mag();
+ s22 = s22 + (pTrack[j].Pz()*pTrack[j].Pz())/pTrack[j].Mag();
+
+ ptot += pTrack[j].Mag();
+ }
+
+ if(ptot > 0.)
+ {
+ m(0,0) = s00/ptot;
+ m(0,1) = s01/ptot;
+ m(0,2) = s02/ptot;
+
+ m(1,0) = s10/ptot;
+ m(1,1) = s11/ptot;
+ m(1,2) = s12/ptot;
+
+ m(2,0) = s20/ptot;
+ m(2,1) = s21/ptot;
+ m(2,2) = s22/ptot;
+
+ TMatrixDSymEigen eigen(m);
+ TVectorD eigenVal = eigen.GetEigenValues();
+
+ Double_t sphericity = (3/2)*(eigenVal(2)+eigenVal(1));
+ eventShapes[1] = sphericity;
+
+ Double_t aplanarity = (3/2)*(eigenVal(2));
+ eventShapes[2] = aplanarity;
+
+ c = 3*(eigenVal(0)*eigenVal(1)+eigenVal(0)*eigenVal(2)+eigenVal(1)*eigenVal(2));
+ eventShapes[3] = c;
+ }
+ return kTRUE;
+}
+
+
+
+ //__________________________________________________________________________________________________________________________
+// Trigger Decisions copid from PWG0/AliTriggerAnalysis
+
+
+Bool_t AliAnalysisHelperJetTasks::IsTriggerFired(const AliVEvent* aEv, Trigger trigger)
+{
+ // checks if an event has been triggered
+ // no usage of ofline trigger here yet
+
+ // here we do a dirty hack to take also into account the
+ // missing trigger bits and Bunch crossing paatern for real data
+
+
+ if(aEv->InheritsFrom("AliESDEvent")){
+ const AliESDEvent *esd = (AliESDEvent*)aEv;
+ switch (trigger)
+ {
+ case kAcceptAll:
+ {
+ return kTRUE;
+ break;
+ }
+ case kMB1:
+ {
+ if(esd->GetFiredTriggerClasses().Contains("CINT1B-"))return kTRUE;
+ // does the same but without or'ed V0s
+ if(esd->GetFiredTriggerClasses().Contains("CSMBB"))return kTRUE;
+ if(esd->GetFiredTriggerClasses().Contains("CINT6B-"))return kTRUE;
+ // this is for simulated data
+ if(esd->GetFiredTriggerClasses().Contains("MB1"))return kTRUE;
+ break;
+ }
+ case kMB2:
+ {
+ if(esd->GetFiredTriggerClasses().Contains("MB2"))return kTRUE;
+ break;
+ }
+ case kMB3:
+ {
+ if(esd->GetFiredTriggerClasses().Contains("MB3"))return kTRUE;
+ break;
+ }
+ case kSPDGFO:
+ {
+ if(esd->GetFiredTriggerClasses().Contains("CSMBB"))return kTRUE;
+ if(esd->GetFiredTriggerClasses().Contains("CINT6B-"))return kTRUE;
+ if(esd->GetFiredTriggerClasses().Contains("GFO"))return kTRUE;
+ break;
+ }
+ default:
+ {
+ Printf("IsEventTriggered: ERROR: Trigger type %d not implemented in this method", (Int_t) trigger);
+ break;
+ }
+ }
+ }
+ else if(aEv->InheritsFrom("AliAODEvent")){
+ const AliAODEvent *aod = (AliAODEvent*)aEv;
+ switch (trigger)
+ {
+ case kAcceptAll:
+ {
+ return kTRUE;
+ break;
+ }
+ case kMB1:
+ {
+ if(aod->GetFiredTriggerClasses().Contains("CINT1B"))return kTRUE;
+ // does the same but without or'ed V0s
+ if(aod->GetFiredTriggerClasses().Contains("CSMBB"))return kTRUE;
+ // for sim data
+ if(aod->GetFiredTriggerClasses().Contains("MB1"))return kTRUE;
+ break;
+ }
+ case kMB2:
+ {
+ if(aod->GetFiredTriggerClasses().Contains("MB2"))return kTRUE;
+ break;
+ }
+ case kMB3:
+ {
+ if(aod->GetFiredTriggerClasses().Contains("MB3"))return kTRUE;
+ break;
+ }
+ case kSPDGFO:
+ {
+ if(aod->GetFiredTriggerClasses().Contains("CSMBB"))return kTRUE;
+ if(aod->GetFiredTriggerClasses().Contains("GFO"))return kTRUE;
+ break;
+ }
+ default:
+ {
+ Printf("IsEventTriggered: ERROR: Trigger type %d not implemented in this method", (Int_t) trigger);
+ break;
+ }
+ }
+ }
+ return kFALSE;
+}
+
+
+ AliAnalysisHelperJetTasks::MCProcessType AliAnalysisHelperJetTasks::GetPythiaEventProcessType(AliGenEventHeader* aHeader, Bool_t adebug) {
+
+ AliGenPythiaEventHeader* pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(aHeader);
+
+ if (!pythiaGenHeader) {
+ // printf(" AliAnalysisHelperJetTasks::GetProcessType : Unknown gen Header type). \n");
+ return kInvalidProcess;
+ }
+
+
+ Int_t pythiaType = pythiaGenHeader->ProcessType();
+ fgLastProcessType = pythiaType;
+ MCProcessType globalType = kInvalidProcess;
+
+
+ if (adebug) {
+ printf(" AliAnalysisHelperJetTasks::GetProcessType : Pythia process type found: %d \n",pythiaType);
+ }
+
+
+ if(pythiaType==92||pythiaType==93){
+ globalType = kSD;
+ }
+ else if(pythiaType==94){
+ globalType = kDD;
+ }
+ //else if(pythiaType != 91){ // also exclude elastic to be sure... CKB??
+ else {
+ globalType = kND;
+ }
+ return globalType;
+}
+
+
+ AliAnalysisHelperJetTasks::MCProcessType AliAnalysisHelperJetTasks::GetDPMjetEventProcessType(AliGenEventHeader* aHeader, Bool_t adebug) {
+ //
+ // get the process type of the event.
+ //
+
+ // can only read pythia headers, either directly or from cocktalil header
+ AliGenDPMjetEventHeader* dpmJetGenHeader = dynamic_cast<AliGenDPMjetEventHeader*>(aHeader);
+
+ if (!dpmJetGenHeader) {
+ printf(" AliAnalysisHelperJetTasks::GetDPMjetProcessType : Unknown header type (not DPMjet or). \n");
+ return kInvalidProcess;
+ }
+
+ Int_t dpmJetType = dpmJetGenHeader->ProcessType();
+ fgLastProcessType = dpmJetType;
+ MCProcessType globalType = kInvalidProcess;
+
+
+ if (adebug) {
+ printf(" AliAnalysisHelperJetTasks::GetDPMJetProcessType : DPMJet process type found: %d \n",dpmJetType);
+ }
+
+
+ if (dpmJetType == 1 || dpmJetType == 4) { // explicitly inelastic plus central diffraction
+ globalType = kND;
+ }
+ else if (dpmJetType==5 || dpmJetType==6) {
+ globalType = kSD;
+ }
+ else if (dpmJetType==7) {
+ globalType = kDD;
+ }
+ return globalType;
+}
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff