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