EMCAL/AliEMCALGeneratorFactory.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-2002, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /*
  17 $Log$
  18 */
  19 #include "assert.h"
  20 #include "TString.h"
  21 #include "AliEMCALGeneratorFactory.h"
  22 #include "AliGenerator.h"
  23 #include "AliGenFixed.h"
  24 #include "AliGenBox.h"
  25 #include "AliGenHIJINGpara.h"
  26 #include "AliGenHIJINGparaBa.h"
  27 #include "AliGenHijing.h"
  28 #include "AliGenCocktail.h"
  29 #include "AliGenPythia.h"
  30
  31 //*-- Authors: Aleksei Pavlinov (WSU)
  32 //*   Initial variant is in Config.C for EMCAL production.
  33 ClassImp(AliEMCALGeneratorFactory)
  34
  35 AliEMCALGeneratorFactory::AliEMCALGeneratorFactory(PprRunFact_t run, PprRadFact_t rad)
  36 {
  37     fGenerator = fBgGenerator = fSignalGenerator = 0;
  38     fRunType   = run;
  39     fRadiation = rad;
  40     fMomentum  = 0;
  41
  42     Int_t isw = 3;
  43     if (rad == kNoGluonRadiation) isw = 0;
  44     Float_t thmin=0, thmax=0;
  45
  46     AliGenFixed *genGG=0;
  47     AliGenBox   *genB=0;
  48     AliGenHIJINGparaBa *genHijParaB=0, *bg=0;
  49     AliGenHIJINGpara   *genHijPara=0;
  50     AliGenHijing       *genHij=0;
  51     AliGenCocktail     *genCoct=0;
  52     AliGenPythia       *genPy=0, *jets=0;
  53     //    AliPythia          *aliPy = 0;
  54
  55     fComment = new TString;
  56
  57     switch (run) {
  58     case kGammaGun:
  59         genGG = new AliGenFixed(1);
  60         genGG->SetMomentum(100.);
  61         genGG->SetPhi(240.);
  62         genGG->SetTheta(91.);
  63         genGG->SetPart(kGamma);
  64         fGenerator = (AliGenerator*)genGG;
  65      break;
  66
  67     case kGammaBox:
  68         genB = new AliGenBox(100);
  69         genB->SetMomentumRange(100., 100.1);
  70         genB->SetPhiRange(0,360);
  71         genB->SetThetaRange(45., 135.);
  72         genB->SetPart(kGamma);
  73         fGenerator = (AliGenerator*)genB;
  74         break;
  75
  76     case kTest50:
  77         genHijParaB = new AliGenHIJINGparaBa(50);
  78         genHijParaB->SetMomentumRange(0, 999999.);
  79         genHijParaB->SetPhiRange(-180., 180.);
  80         // Set pseudorapidity range from -8 to 8.
  81         thmin = EtaToTheta(8);   // theta min. <---> eta max
  82         thmax = EtaToTheta(-8);  // theta max. <---> eta min
  83         genHijParaB->SetThetaRange(thmin,thmax);
  84         fGenerator = (AliGenerator*)genHijParaB;
  85         break;
  86
  87     case kParam_8000:
  88         //coment= fComment.Append(":HIJINGparam N=8000");
  89         genHijPara = new AliGenHIJINGpara(86030);
  90         genHijPara->SetMomentumRange(0, 999999.);
  91         genHijPara->SetPhiRange(-180., 180.);
  92         // Set pseudorapidity range from -8 to 8.
  93         thmin = EtaToTheta(8);   // theta min. <---> eta max
  94         thmax = EtaToTheta(-8);  // theta max. <---> eta min
  95         genHijPara->SetThetaRange(thmin,thmax);
  96         fGenerator = (AliGenerator*)genHijPara;
  97         break;
  98     case kParam_4000:
  99         genHijPara = new AliGenHIJINGpara(43015);
 100         genHijPara->SetMomentumRange(0, 999999.);
 101         genHijPara->SetPhiRange(-180., 180.);
 102         // Set pseudorapidity range from -8 to 8.
 103         thmin = EtaToTheta(8);   // theta min. <---> eta max
 104         thmax = EtaToTheta(-8);  // theta max. <---> eta min
 105         genHijPara->SetThetaRange(thmin,thmax);
 106         fGenerator = (AliGenerator*)genHijPara;
 107         break;
 108     case kParam_2000:
 109         (*fComment) = "HIJINGparam N=2000";
 110         genHijPara = new AliGenHIJINGpara(21507);
 111         genHijPara->SetMomentumRange(0, 999999.);
 112         genHijPara->SetPhiRange(-180., 180.);
 113         // Set pseudorapidity range from -8 to 8.
 114         thmin = EtaToTheta(8);   // theta min. <---> eta max
 115         thmax = EtaToTheta(-8);  // theta max. <---> eta min
 116         genHijPara->SetThetaRange(thmin,thmax);
 117         fGenerator = (AliGenerator*)genHijPara;
 118         break;
 119
 120     case kParam_8000_Ecal:
 121         genHijParaB = new AliGenHIJINGparaBa(82534);
 122         genHijParaB->SetMomentumRange(0, 999999.);
 123         genHijParaB->SetPhiRange(-180., 180.);
 124         // Set pseudorapidity range from -8 to 8.
 125         thmin = EtaToTheta( 5);   // theta min. <---> eta max
 126         thmax = EtaToTheta(-5);  // theta max. <---> eta min
 127         genHijParaB->SetThetaRange(thmin,thmax);
 128         fGenerator = (AliGenerator*)genHijParaB;
 129         break;
 130
 131     case kParam_4000_Ecal:
 132         genHijParaB = new AliGenHIJINGparaBa(82534/2);
 133         genHijParaB->SetMomentumRange(0, 999999.);
 134         genHijParaB->SetPhiRange(-180., 180.);
 135         // Set pseudorapidity range from -8 to 8.
 136         thmin = EtaToTheta( 5);   // theta min. <---> eta max
 137         thmax = EtaToTheta(-5);  // theta max. <---> eta min
 138         genHijParaB->SetThetaRange(thmin,thmax);
 139         fGenerator = (AliGenerator*)genHijParaB;
 140         break;
 141 //
 142 //  Hijing Central
 143 //
 144     case kHijing_cent1:
 145         genHij = HijingStandard();
 146 // impact parameter range
 147         genHij->SetImpactParameterRange(0., 5.);
 148         fGenerator = (AliGenerator*)genHij;
 149         break;
 150     case kHijing_cent2:
 151         genHij = HijingStandard();
 152 // impact parameter range
 153         genHij->SetImpactParameterRange(0., 2.);
 154         fGenerator = (AliGenerator*)genHij;
 155         break;
 156 //
 157 // Hijing Peripheral
 158 //
 159     case kHijing_per1:
 160         genHij = HijingStandard();
 161 // impact parameter range
 162         genHij->SetImpactParameterRange(5., 8.6);
 163         fGenerator = (AliGenerator*)genHij;
 164         break;
 165     case kHijing_per2:
 166         //coment= comment.Append("HIJING per2");
 167         genHij = HijingStandard();
 168 // impact parameter range
 169         genHij->SetImpactParameterRange(8.6, 11.2);
 170         fGenerator = (AliGenerator*)genHij;
 171         break;
 172     case kHijing_per3:
 173         genHij = HijingStandard();
 174 // impact parameter range
 175         genHij->SetImpactParameterRange(11.2, 13.2);
 176         fGenerator = (AliGenerator*)genHij;
 177         break;
 178     case kHijing_per4:
 179         genHij = HijingStandard();
 180 // impact parameter range
 181         genHij->SetImpactParameterRange(13.2, 15.);
 182         fGenerator = (AliGenerator*)genHij;
 183         break;
 184     case kHijing_per5:
 185         //coment= comment.Append("HIJING per5");
 186         genHij = HijingStandard();
 187 // impact parameter range
 188         genHij->SetImpactParameterRange(15., 100.);
 189         fGenerator = (AliGenerator*)genHij;
 190         break;
 191 //
 192 //  Jet-Jet
 193 //
 194     case kHijing_jj25:
 195         //coment= comment.Append("HIJING Jet 25 GeV");
 196         genHij = HijingStandard();
 197 // impact parameter range
 198         genHij->SetImpactParameterRange(0., 5.);
 199         // trigger
 200         genHij->SetTrigger(1);
 201         genHij->SetPtJet(25.);
 202         genHij->SetSimpleJets(1);
 203         genHij->SetRadiation(isw);
 204         genHij->SetJetEtaRange(-0.3,0.3);
 205         genHij->SetJetPhiRange(15.,105.);
 206         fGenerator = (AliGenerator*)genHij;
 207         break;
 208
 209     case kHijing_jj50:
 210         //coment= comment.Append("HIJING Jet 50 GeV");
 211         genHij = HijingStandard();
 212 // impact parameter range
 213         genHij->SetImpactParameterRange(0., 5.);
 214         // trigger
 215         genHij->SetTrigger(1);
 216         genHij->SetPtJet(50.);
 217         genHij->SetSimpleJets(1);
 218         genHij->SetRadiation(isw);
 219         genHij->SetJetEtaRange(-0.3,0.3);
 220         genHij->SetJetPhiRange(15.,105.);
 221         fGenerator = (AliGenerator*)genHij;
 222         break;
 223
 224     case kHijing_jj75:
 225         //coment= comment.Append("HIJING Jet 75 GeV");
 226         genHij = HijingStandard();
 227 // impact parameter range
 228         genHij->SetImpactParameterRange(0., 5.);
 229         // trigger
 230         genHij->SetTrigger(1);
 231         genHij->SetPtJet(75.);
 232         genHij->SetSimpleJets(1);
 233         genHij->SetRadiation(isw);
 234         genHij->SetJetEtaRange(-0.3,0.3);
 235         genHij->SetJetPhiRange(15.,105.);
 236         fGenerator = (AliGenerator*)genHij;
 237         break;
 238
 239     case kHijing_jj100:
 240         //coment= comment.Append("HIJING Jet 100 GeV");
 241         genHij = HijingStandard();
 242 // impact parameter range
 243         genHij->SetImpactParameterRange(0., 5.);
 244         // trigger
 245         genHij->SetTrigger(1);
 246         genHij->SetPtJet(100.);
 247         genHij->SetSimpleJets(1);
 248         genHij->SetRadiation(isw);
 249         genHij->SetJetEtaRange(-0.3,0.3);
 250         genHij->SetJetPhiRange(15.,105.);
 251         fGenerator = (AliGenerator*)genHij;
 252         break;
 253
 254     case kHijing_jj125:
 255         //coment= comment.Append("HIJING Jet 125 GeV");
 256         genHij = HijingStandard();
 257 // impact parameter range
 258         genHij->SetImpactParameterRange(0., 5.);
 259         // trigger
 260         genHij->SetTrigger(1);
 261         genHij->SetPtJet(125.);
 262         genHij->SetSimpleJets(1);
 263         genHij->SetRadiation(isw);
 264         genHij->SetJetEtaRange(-0.3,0.3);
 265         genHij->SetJetPhiRange(15.,105.);
 266         fGenerator = (AliGenerator*)genHij;
 267         break;
 268 //
 269 // Gamma-Jet
 270 //
 271     case kHijing_gj25:
 272         //coment= comment.Append("HIJING Gamma 25 GeV");
 273         genHij = HijingStandard();
 274 // impact parameter range
 275         genHij->SetImpactParameterRange(0., 5.);
 276         // trigger
 277         genHij->SetTrigger(2);
 278         genHij->SetPtJet(25.);
 279         genHij->SetSimpleJets(1);
 280         genHij->SetRadiation(isw);
 281         genHij->SetJetEtaRange(-0.3,0.3);
 282         genHij->SetJetPhiRange(15.,105.);
 283         fGenerator = (AliGenerator*)genHij;
 284         break;
 285
 286     case kHijing_gj50:
 287         //coment= comment.Append("HIJING Gamma 50 GeV");
 288         genHij = HijingStandard();
 289 // impact parameter range
 290         genHij->SetImpactParameterRange(0., 5.);
 291         // trigger
 292         genHij->SetTrigger(2);
 293         genHij->SetPtJet(50.);
 294         genHij->SetSimpleJets(1);
 295         genHij->SetRadiation(isw);
 296         genHij->SetJetEtaRange(-0.3,0.3);
 297         genHij->SetJetPhiRange(15.,105.);
 298         fGenerator = (AliGenerator*)genHij;
 299         break;
 300
 301     case kHijing_gj75:
 302         //coment= comment.Append("HIJING Gamma 75 GeV");
 303         genHij = HijingStandard();
 304 // impact parameter range
 305         genHij->SetImpactParameterRange(0., 5.);
 306         // trigger
 307         genHij->SetTrigger(2);
 308         genHij->SetPtJet(75.);
 309         genHij->SetSimpleJets(1);
 310         genHij->SetRadiation(isw);
 311         genHij->SetJetEtaRange(-0.3,0.3);
 312         genHij->SetJetPhiRange(15.,105.);
 313         fGenerator = (AliGenerator*)genHij;
 314         break;
 315
 316     case kHijing_gj100:
 317         //coment= comment.Append("HIJING Gamma 100 GeV");
 318         genHij = HijingStandard();
 319 // impact parameter range
 320         genHij->SetImpactParameterRange(0., 5.);
 321         // trigger
 322         genHij->SetTrigger(2);
 323         genHij->SetPtJet(100.);
 324         genHij->SetSimpleJets(1);
 325         genHij->SetRadiation(isw);
 326         genHij->SetJetEtaRange(-0.3,0.3);
 327         genHij->SetJetPhiRange(15.,105.);
 328         fGenerator = (AliGenerator*)genHij;
 329         break;
 330
 331     case kHijing_gj125:
 332         //coment= comment.Append("HIJING Gamma 125 GeV");
 333         genHij = HijingStandard();
 334 // impact parameter range
 335         genHij->SetImpactParameterRange(0., 5.);
 336         // trigger
 337         genHij->SetTrigger(2);
 338         genHij->SetPtJet(125.);
 339         genHij->SetSimpleJets(1);
 340         genHij->SetRadiation(isw);
 341         genHij->SetJetEtaRange(-0.3,0.3);
 342         genHij->SetJetPhiRange(15.,105.);
 343         fGenerator = (AliGenerator*)genHij;
 344         break;
 345     case kJetPlusBg:
 346         genCoct = new AliGenCocktail();
 347         genCoct->SetMomentumRange(0, 999999.);
 348         genCoct->SetPhiRange(-180., 180.);
 349         // Set pseudorapidity range from -8 to 8.
 350         thmin = EtaToTheta( 5.);   // theta min. <---> eta max
 351         thmax = EtaToTheta(-5.);  // theta max. <---> eta min
 352         genCoct->SetThetaRange(thmin,thmax);
 353
 354 //
 355 //      Underlying Event
 356 //
 357 //      AliGenHIJINGparaBa *bg = new AliGenHIJINGparaBa(82534);
 358         bg = new AliGenHIJINGparaBa(10);
 359         fBgGenerator = (AliGenerator*)bg;
 360 //
 361 //      Jets from Pythia
 362 //
 363         jets = new AliGenPythia(-1);
 364         fSignalGenerator = (AliGenerator*)jets;
 365 //   Centre of mass energy
 366         jets->SetEnergyCMS(5500.);
 367 //   Process type
 368         jets->SetProcess(kPyJets);
 369 //   final state kinematic cuts
 370         jets->SetJetEtaRange(-0.3, 0.3);
 371         jets->SetJetPhiRange(15., 105.);
 372 //   Structure function
 373         jets->SetStrucFunc(kGRVLO98);
 374 //
 375 //   Pt transfer of the hard scattering
 376         jets->SetPtHard(100.,100.1);
 377 //   Decay type (semielectronic, semimuonic, nodecay)
 378         jets->SetForceDecay(kAll);
 379 //
 380 //      Add all to cockail ...
 381 //
 382         genCoct->AddGenerator(jets,"Jets",1);
 383         genCoct->AddGenerator(bg,"Underlying Event", 1);
 384         fGenerator = (AliGenerator*)genCoct;
 385
 386      break;
 387     case kGammaPlusBg:
 388         genCoct = new AliGenCocktail();
 389         genCoct->SetMomentumRange(0, 999999.);
 390         genCoct->SetPhiRange(-180., 180.);
 391         // Set pseudorapidity range from -8 to 8.
 392         thmin = EtaToTheta( 5.);   // theta min. <---> eta max
 393         thmax = EtaToTheta(-5.);  // theta max. <---> eta min
 394         genCoct->SetThetaRange(thmin,thmax);
 395 //
 396 //      Underlying Event
 397 //
 398         bg = new AliGenHIJINGparaBa(82534);
 399         fBgGenerator = (AliGenerator*)bg;
 400 //
 401 //      Jets from Pythia
 402 //
 403         jets = new AliGenPythia(-1);
 404         fSignalGenerator = (AliGenerator*)jets;
 405 //   Centre of mass energy
 406         jets->SetEnergyCMS(5500.);
 407 //   Process type
 408         jets->SetProcess(kPyDirectGamma);
 409 //   final state kinematic cuts
 410         jets->SetJetEtaRange(-0.3, 0.3);
 411         jets->SetJetPhiRange(15., 105.);
 412         jets->SetGammaEtaRange(-0.12, 0.12);
 413         jets->SetGammaPhiRange(220., 320.);
 414 //   Structure function
 415         jets->SetStrucFunc(kGRVLO98);
 416 //
 417 //   Pt transfer of the hard scattering
 418         jets->SetPtHard(100.,100.1);
 419 //   Decay type (semielectronic, semimuonic, nodecay)
 420         jets->SetForceDecay(kAll);
 421 //
 422 //      Add all to cockail ...
 423 //
 424         genCoct->AddGenerator(jets,"Jets",1);
 425         genCoct->AddGenerator(bg,"Underlying Event", 1);
 426         fGenerator = (AliGenerator*)genCoct;
 427
 428         break;
 429     case kJets_50:
 430 //  50 GeV Jets
 431         genPy = PythiaJets(50.);
 432         fGenerator = (AliGenerator*)genPy;
 433         break;
 434     case kJets_75:
 435 //  75 GeV Jets
 436         genPy = PythiaJets(75.);
 437         fGenerator = (AliGenerator*)genPy;
 438         break;
 439     case kJets_100:
 440 //  100 GeV Jets
 441         genPy = PythiaJets(100.);
 442         fGenerator = (AliGenerator*)genPy;
 443         break;
 444     case kJets_200:
 445 //  200 GeV Jets
 446         genPy = PythiaJets(200.);
 447         fGenerator = (AliGenerator*)genPy;
 448         break;
 449
 450     case kJets_100RadOn:
 451 //  100 GeV Jets with radiation on - 22-mar-2002
 452 //  See AliPythia.cxx for default
 453         genPy = PythiaJets(100.);
 454         //        genPy->SetKeyPartonJets(1);   // for jet partons
 455         //        genPy->DefineParametersForPartonsJets();
 456
 457         fGenerator = (AliGenerator*)genPy;
 458         break;
 459
 460     case kGammaJets_50:
 461 //  50 GeV Jets + Gamma
 462         genPy = PythiaJets(-1);
 463         genPy->SetEnergyCMS(5500.);
 464         genPy->SetProcess(kPyDirectGamma);
 465         genPy->SetJetEtaRange(-0.3,+0.3);
 466         genPy->SetJetPhiRange(15.,105.);
 467         genPy->SetGammaEtaRange(-0.12, 0.12);
 468         genPy->SetGammaPhiRange(220., 320.);
 469         genPy->SetStrucFunc(kGRVLO98);
 470         genPy->SetPtHard(50.,50.001);
 471         genPy->SetForceDecay(kAll);
 472         fGenerator = (AliGenerator*)genPy;
 473         break;
 474     case kGammaJets_75:
 475 //  75 GeV Jets + Gamma
 476         genPy = PythiaJets(-1);
 477         genPy->SetEnergyCMS(5500.);
 478         genPy->SetProcess(kPyDirectGamma);
 479         genPy->SetJetEtaRange(-0.3,+0.3);
 480         genPy->SetJetPhiRange(15.,105.);
 481         genPy->SetGammaEtaRange(-0.12, 0.12);
 482         genPy->SetGammaPhiRange(220., 320.);
 483         genPy->SetStrucFunc(kGRVLO98);
 484         genPy->SetPtHard(75.,75.001);
 485         genPy->SetForceDecay(kAll);
 486         fGenerator = (AliGenerator*)genPy;
 487         break;
 488     case kGammaJets_100:
 489 // 100 GeV Jets + Gamma
 490         genPy = PythiaJets(-1);
 491         genPy->SetEnergyCMS(5500.);
 492         genPy->SetProcess(kPyDirectGamma);
 493         genPy->SetJetEtaRange(-0.3,+0.3);
 494         genPy->SetJetPhiRange(15.,105.);
 495         genPy->SetGammaEtaRange(-0.12, 0.12);
 496         genPy->SetGammaPhiRange(220., 320.);
 497         genPy->SetStrucFunc(kGRVLO98);
 498         genPy->SetPtHard(100.,100.001);
 499         genPy->SetForceDecay(kAll);
 500         fGenerator = (AliGenerator*)genPy;
 501         break;
 502     case kGammaJets_200:
 503 //  200 GeV Jets + Gamma
 504         genPy = PythiaJets(-1);
 505         genPy->SetEnergyCMS(5500.);
 506         genPy->SetProcess(kPyDirectGamma);
 507         genPy->SetJetEtaRange(-0.3,+0.3);
 508         genPy->SetJetPhiRange(15.,105.);
 509         genPy->SetGammaEtaRange(-0.12, 0.12);
 510         genPy->SetGammaPhiRange(220., 320.);
 511         genPy->SetStrucFunc(kGRVLO98);
 512         genPy->SetPtHard(200.,200.001);
 513         genPy->SetForceDecay(kAll);
 514         fGenerator = (AliGenPythia*)genPy;
 515         break;
 516     case kGammaJets_250:
 517 //  250 GeV Jets + Gamma
 518         genPy = PythiaJets(-1);
 519         genPy->SetEnergyCMS(5500.);
 520         genPy->SetProcess(kPyDirectGamma);
 521         genPy->SetJetEtaRange(-0.3,+0.3);
 522         genPy->SetJetPhiRange(15.,105.);
 523         genPy->SetGammaEtaRange(-0.12, 0.12);
 524         genPy->SetGammaPhiRange(220., 320.);
 525         genPy->SetStrucFunc(kGRVLO98);
 526         genPy->SetPtHard(250.,250.001);
 527         genPy->SetForceDecay(kAll);
 528         fGenerator = (AliGenerator*)genPy;
 529         break;
 530     case kGammaJets_300:
 531 //  300 GeV Jets + Gamma
 532         genPy = PythiaJets(-1);
 533         genPy->SetEnergyCMS(5500.);
 534         genPy->SetProcess(kPyDirectGamma);
 535         genPy->SetJetEtaRange(-0.3,+0.3);
 536         genPy->SetJetPhiRange(15.,105.);
 537         genPy->SetGammaEtaRange(-0.12, 0.12);
 538         genPy->SetGammaPhiRange(220., 320.);
 539         genPy->SetStrucFunc(kGRVLO98);
 540         genPy->SetPtHard(300.,300.001);
 541         genPy->SetForceDecay(kAll);
 542         fGenerator = (AliGenerator*)genPy;
 543         break;
 544     default:
 545         printf("<I> wrong parameter for generator run %i rad %i\n", run, rad);
 546         assert(0);
 547     }
 548     if(fGenerator) fGenerator->SetPtRange(0.,1.e10); // discard the limit on pT
 549
 550 }
 551
 552 AliEMCALGeneratorFactory::AliEMCALGeneratorFactory(PprRunFact_t run, Float_t p)
 553 {
 554     fGenerator = fBgGenerator = fSignalGenerator = 0;
 555     fRunType   = run;
 556     fMomentum  = p;
 557
 558     AliGenBox   *genB=0;
 559
 560     switch (run) {
 561     case kGammaBoxOne:
 562         genB = OneParticleWithFixedEnergy(kGamma, p);
 563     break;
 564     case kPi0BoxOne:
 565         genB = OneParticleWithFixedEnergy(kPi0, p);
 566     break;
 567     default:
 568         printf("<I> wrong parameter for generator run %i \n",run);
 569         assert(0);
 570     }
 571     if(genB) fGenerator = (AliGenerator*)genB;
 572     //    if(fGenerator) fGenerator->SetPtRange(0.,1.e10); // discard the limit on pT - 23-aug-04
 573 }
 574
 575 AliGenHijing* AliEMCALGeneratorFactory::HijingStandard()
 576 {
 577     AliGenHijing *gener = new AliGenHijing(-1);
 578 // centre of mass energy
 579     gener->SetEnergyCMS(5500.);
 580 // reference frame
 581     gener->SetReferenceFrame("CMS");
 582 // projectile
 583     gener->SetProjectile("A", 208, 82);
 584     gener->SetTarget    ("A", 208, 82);
 585 // tell hijing to keep the full parent child chain
 586     gener->KeepFullEvent();
 587 // enable jet quenching
 588     gener->SetJetQuenching(1);
 589 // enable shadowing
 590     gener->SetShadowing(1);
 591 // neutral pion and heavy particle decays switched off
 592     gener->SetDecaysOff(1);
 593 // Don't track spectators
 594     gener->SetSpectators(0);
 595 // kinematic selection
 596     gener->SetSelectAll(0);
 597     return gener;
 598 }
 599
 600 AliGenPythia* AliEMCALGeneratorFactory::PythiaJets(Float_t energy)
 601 {
 602     AliGenPythia *gener = new AliGenPythia(-1);
 603 //   Centre of mass energy
 604     gener->SetEnergyCMS(5500.);
 605 //   Process type
 606     gener->SetProcess(kPyJets);
 607 //   final state kinematic cuts
 608     gener->SetJetEtaRange(-0.3, 0.3);
 609     gener->SetJetPhiRange(15., 105.);
 610 //   Structure function
 611     gener->SetStrucFunc(kGRVLO98);
 612 //
 613 //   Pt transfer of the hard scattering
 614     gener->SetPtHard(energy, energy+0.1);
 615 //   Decay type (semielectronic, semimuonic, nodecay)
 616     gener->SetForceDecay(kAll);
 617 //
 618     return gener;
 619 }
 620
 621
 622 AliGenPythia* AliEMCALGeneratorFactory::PythiaGamma(Float_t energy)
 623 {
 624     AliGenPythia *gener = new AliGenPythia(-1);
 625 //   Centre of mass energy
 626     gener->SetEnergyCMS(5500.);
 627 //   Process type
 628     gener->SetProcess(kPyDirectGamma);
 629 //   final state kinematic cuts
 630     gener->SetJetEtaRange(-0.3, 0.3);
 631     gener->SetJetPhiRange(15., 105.);
 632     gener->SetGammaEtaRange(-0.12, 0.12);
 633     gener->SetGammaPhiRange(220., 320.);
 634 //   Structure function
 635     gener->SetStrucFunc(kGRVLO98);
 636 //
 637 //   Pt transfer of the hard scattering
 638     gener->SetPtHard(energy, energy+0.1);
 639 //   Decay type (semielectronic, semimuonic, nodecay)
 640     gener->SetForceDecay(kAll);
 641 //
 642     return gener;
 643 }
 644
 645 //
 646 // Staff of Aleksei Pavlinov.
 647 //
 648 AliGenBox* AliEMCALGeneratorFactory::OneParticleWithFixedEnergy(Int_t type, Float_t p)
 649 {// one particle in EMCAL acceptance
 650    Float_t thmin  = EtaToTheta(0.7), thmax  = EtaToTheta(-0.7);
 651    Float_t phimin=0, phimax=120;
 652    Float_t pmin=p, pmax=p+0.01;
 653
 654    AliGenBox *gen = new AliGenBox(1);
 655    gen->SetPart(type);
 656    gen->SetNumberParticles(1);
 657    gen->SetThetaRange(thmin, thmax);
 658    gen->SetPhiRange(phimin, phimax);
 659    gen->SetMomentumRange(pmin, pmax);
 660
 661    printf("<I> AliEMCALGeneratorFactory::OneParticleWithFixedEnergy \n");
 662    printf("       type of particle -> %i \n", type);
 663    printf("    %6.4f <    eta   < %6.4f\n", thmin,  thmax);
 664    printf("    %6.4f <    phi   < %6.4f\n", phimin, phimax);
 665    printf("    %7.2f < Momentum < %7.2f\n", pmin, pmax);
 666    printf("     TestBit(kPtRange) %i | TestBit(kMomentumRange) %i\n",
 667    gen->TestBit(BIT(17)), gen->TestBit(BIT(19)));
 668    return gen;
 669 }