Ignore:
Timestamp:
Nov 27, 2009, 4:50:05 PM (15 years ago)
Author:
garnier
Message:

CVS update

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/source/physics_lists/lists/src/G4HadronInelasticQBBC.cc

    r988 r1205  
    2424// ********************************************************************
    2525//
    26 // $Id: G4HadronInelasticQBBC.cc,v 1.16 2009/02/19 12:45:42 vnivanch Exp $
    27 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     26// $Id: G4HadronInelasticQBBC.cc,v 1.24 2009/11/25 18:55:56 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-cand-03 $
    2828//
    2929//---------------------------------------------------------------------------
    … …  
    3131// ClassName:   G4HadronInelasticQBBC
    3232//
    33 // Author: 11 April 2006 V. Ivanchenko
     33// Author: 2 October 2009 V. Ivanchenko
    3434//
    3535// Modified:
    36 // 05.07.2006 V.Ivanchenko fix problem of initialisation of HP
    37 // 15.04.2007 V.Ivanchenko include quasi-elastic and change FTF low energy
    3836//
    3937//----------------------------------------------------------------------------
    … …  
    4341
    4442#include "G4HadronInelasticProcess.hh"
     43#include "G4HadronicInteraction.hh"
    4544
    4645#include "G4ParticleDefinition.hh"
    4746#include "G4ProcessManager.hh"
    4847
    49 #include "G4MesonConstructor.hh"
    50 #include "G4BaryonConstructor.hh"
    51 
    52 #include "G4PiNuclearCrossSection.hh"
    5348#include "G4BGGNucleonInelasticXS.hh"
    5449#include "G4BGGPionInelasticXS.hh"
    55 
    56 #include "G4TheoFSGenerator.hh"
     50//#include "G4UInelasticCrossSection.hh"
     51#include "G4NeutronInelasticXS.hh"
     52#include "G4NeutronCaptureXS.hh"
     53
     54#include "G4ProtonInelasticCrossSection.hh"
     55#include "G4NeutronInelasticCrossSection.hh"
     56#include "G4PiNuclearCrossSection.hh"
     57
     58#include "G4QGSBuilder.hh"
     59#include "G4FTFBuilder.hh"
     60
    5761#include "G4QStringChipsParticleLevelInterface.hh"
    58 #include "G4StringChipsParticleLevelInterface.hh"
    59 #include "G4GeneratorPrecompoundInterface.hh"
    60 #include "G4QGSMFragmentation.hh"
    61 #include "G4LundStringFragmentation.hh"
    62 #include "G4ExcitedStringDecay.hh"
    63 
     62#include "G4CascadeInterface.hh"
    6463#include "G4BinaryCascade.hh"
    65 #include "G4HadronFissionProcess.hh"
    66 #include "G4HadronCaptureProcess.hh"
    67 #include "G4LFission.hh"
    6864#include "G4LCapture.hh"
    69 
    70 #include "G4NeutronHPInelastic.hh"
    71 #include "G4NeutronHPFission.hh"
    72 #include "G4NeutronHPCapture.hh"
    73 
    74 #include "G4UInelasticCrossSection.hh"
    75 
    76 G4HadronInelasticQBBC::G4HadronInelasticQBBC(const G4String& name,
    77     G4int ver, G4bool ftf, G4bool bert, G4bool chips, G4bool hp, G4bool glauber)
    78   : G4VPhysicsConstructor(name), verbose(ver), ftfFlag(ftf), bertFlag(bert),
    79     chipsFlag(chips), hpFlag(hp), glFlag(glauber), wasActivated(false)
     65#include "G4NeutronRadCapture.hh"
     66
     67enum QBBCType
    8068{
    81   if(verbose > 1) G4cout << "### HadronInelasticQBBC bertFlag= "
    82                          <<  bertFlag <<G4endl;
    83   theHPXSecI = 0;
    84   theHPXSecC = 0;
    85   theHPXSecF = 0;
    86   theCascade = 0;
    87   preCompound = 0;
    88   theCHIPSCascade   = 0;
    89   theQuasiElastic   = 0;
    90   theQGStringDecay  = 0;
    91   theQGStringModel  = 0;
    92   theFTFBStringDecay = 0;
    93   theFTFBStringModel = 0;
    94   theFTFCStringDecay = 0;
    95   theFTFCStringModel = 0;
     69  fQBBC = 0,
     70  fQBBC_XGG,
     71  fQBBC_XGGSN
     72};
     73
     74G4HadronInelasticQBBC::G4HadronInelasticQBBC(const G4String& name, G4int ver,
     75    G4bool, G4bool,G4bool, G4bool, G4bool)
     76  : G4VHadronPhysics("hInelastic"),verbose(ver),wasActivated(false)
     77{
     78  htype = name;
    9679}
    9780
    9881G4HadronInelasticQBBC::~G4HadronInelasticQBBC()
    99 {
    100   delete theCascade;
    101   delete preCompound;
    102   delete theCHIPSCascade;
    103   delete theQuasiElastic;
    104   delete theQGStringDecay;
    105   delete theQGStringModel;
    106   delete theFTFBStringDecay;
    107   delete theFTFCStringDecay;
    108   delete theFTFBStringModel;
    109   delete theFTFCStringModel;
    110   delete theHPXSecI;
    111   delete theHPXSecC;
    112   delete theHPXSecF;
    113 }
    114 
    115 void G4HadronInelasticQBBC::ConstructParticle()
    116 {
    117   G4MesonConstructor pMesonConstructor;
    118   pMesonConstructor.ConstructParticle();
    119 
    120   G4BaryonConstructor pBaryonConstructor;
    121   pBaryonConstructor.ConstructParticle();
    122 }
     82{}
    12383
    12484void G4HadronInelasticQBBC::ConstructProcess()
    … …  
    12787  wasActivated = true;
    12888
     89  // select type
     90  QBBCType fType = fQBBC;
     91  if("QBBC_XGG" == htype)        { fType = fQBBC_XGG; }
     92  else if("QBBC_XGGSN" == htype) { fType = fQBBC_XGGSN; }
     93
    12994  if(verbose > 1) {
    130     G4cout << "### HadronInelasticQBBC Construct Process"
    131            << " ftfFlag= " << ftfFlag << "  bertFlag= " << bertFlag
    132            << G4endl;
     95    G4cout << "### HadronInelasticQBBC Construct Process with type <"
     96           << htype << ">" << G4endl;
    13397  }
    134   G4double minEstring  = 9.5*GeV;
    135   G4double maxEcascade = 7.5*GeV;
    136   G4double minFTF      = 4.5*GeV;
    137   G4double maxFTF      = 25.*GeV;
    138 
    139   //Binary
    140   G4HadronicInteraction* theBIC = new G4BinaryCascade();
    141   theBIC->SetMinEnergy(0.0);
    142   theBIC->SetMaxEnergy(maxEcascade);
    143 
    144   //Bertini
    145   G4HadronicInteraction* theBERT = new G4CascadeInterface();
    146   theBERT->SetMinEnergy(0.0);
    147   theBERT->SetMaxEnergy(maxEcascade);
    148 
    149   //CHIPS
    150   G4HadronicInteraction* theCHIPS = new G4StringChipsParticleLevelInterface();
    151   theCHIPS->SetMinEnergy(0.0);
    152   theCHIPS->SetMaxEnergy(maxEcascade);
    153 
    154   //QGS
    155   theCascade = new G4BinaryCascade();
    156   preCompound = new G4GeneratorPrecompoundInterface();
    157 
    158   theCHIPSCascade = new G4QStringChipsParticleLevelInterface;
    159   G4TheoFSGenerator* theQGSModel = new G4TheoFSGenerator("QGSP");
    160   theQGStringModel  = new G4QGSModel< G4QGSParticipants >;
    161   theQGStringDecay  = new G4ExcitedStringDecay(new G4QGSMFragmentation());
    162   theQGStringModel->SetFragmentationModel(theQGStringDecay);
    163   theQGSModel->SetTransport(preCompound);
    164 
    165   theQuasiElastic = new G4QuasiElasticChannel();
    166   theQGSModel->SetQuasiElasticChannel(theQuasiElastic);
    167   theQGSModel->SetHighEnergyGenerator(theQGStringModel);
    168   theQGSModel->SetMinEnergy(minEstring);
    169   theQGSModel->SetMaxEnergy(100*TeV);
    170 
    171   //FTFB
    172   G4TheoFSGenerator* theFTFBModel = new G4TheoFSGenerator("FTFP");
    173   theFTFBStringModel = new G4FTFModel();
    174   theFTFBStringDecay = new G4ExcitedStringDecay(new G4LundStringFragmentation());
    175   theFTFBStringModel->SetFragmentationModel(theFTFBStringDecay);
    176 
    177   //  theFTFBModel->SetTransport(theCascade);
    178   theFTFBModel->SetTransport(preCompound);
    179   theFTFBModel->SetHighEnergyGenerator(theFTFBStringModel);
    180   theFTFBModel->SetMinEnergy(minFTF);
    181   theFTFBModel->SetMaxEnergy(100*TeV);
    182 
    183   //FTFP
    184   G4TheoFSGenerator* theFTFCModel = new G4TheoFSGenerator("FTFP");
    185   theFTFCStringModel = new G4FTFModel();
    186   theFTFCStringDecay = new G4ExcitedStringDecay(new G4LundStringFragmentation());
    187   theFTFCStringModel->SetFragmentationModel(theFTFCStringDecay);
    188 
    189   theFTFCModel->SetTransport(preCompound);
    190   theFTFCModel->SetHighEnergyGenerator(theFTFCStringModel);
    191   theFTFCModel->SetMinEnergy(minFTF);
    192   theFTFCModel->SetMaxEnergy(maxFTF);
    193 
     98
     99  // configure models
     100  G4HadronicInteraction* theQGSP =
     101    BuildModel(new G4QGSBuilder("QGSP",true,false),9.5*GeV,100.*TeV);
     102  G4HadronicInteraction* theFTFP =
     103    BuildModel(new G4FTFBuilder("FTFP"),4.5*GeV,25.*GeV);
     104  G4HadronicInteraction* theFTFP1 =
     105    BuildModel(new G4FTFBuilder("FTFP"),4.5*GeV,100.*TeV);
     106  G4HadronicInteraction* theBERT =
     107    NewModel(new G4CascadeInterface(),0.0,6.5*GeV);
     108  //G4HadronicInteraction* theBERT1 =
     109  //  NewModel(new G4CascadeInterface(),2.5*GeV,6.5*GeV);
     110  //G4HadronicInteraction* theBIC =
     111  //  NewModel(new G4BinaryCascade(),0.0,3.5*GeV);
     112  G4HadronicInteraction* theCHIPS =
     113    NewModel(new G4QStringChipsParticleLevelInterface(),0.0,7.5*GeV);
     114
     115  // loop over particles
    194116  theParticleIterator->reset();
    195117  while( (*theParticleIterator)() ) {
    196118    G4ParticleDefinition* particle = theParticleIterator->value();
    197119    G4String pname = particle->GetParticleName();
    198     if(verbose > 1) G4cout << "### HadronInelasticQBBC:  " << pname << G4endl;
     120    if(verbose > 1) { G4cout << "### HadronInelasticQBBC:  " << pname << G4endl; }
    199121    if(pname == "anti_lambda"  ||
    200122       pname == "anti_neutron" ||
    … …  
    217139       pname == "sigma-"    ||
    218140       pname == "sigma+"    ||
     141       pname == "sigma0"    ||
    219142       pname == "xi-"       ||
    220143       pname == "xi0") {
    221144     
     145      // common for all particles
     146      G4HadronicProcess* hp = FindInelasticProcess(particle);
     147      if(!hp) { continue; }
    222148      G4ProcessManager* pmanager = particle->GetProcessManager();
    223       G4HadronInelasticProcess* hp =
    224         new G4HadronInelasticProcess("hInelastic", particle);
    225149      pmanager->AddDiscreteProcess(hp);
    226150
     151      // model and X-section configuration
    227152      if(pname == "proton") {
    228         hp->AddDataSet(&theXSecP);
    229 
    230         hp->RegisterMe(theQGSModel);
    231         hp->RegisterMe(theFTFCModel);
    232         //if(ftfFlag) hp->RegisterMe(theFTFCModel);
    233         //else        hp->RegisterMe(theQGSModel);
    234  
    235         if(bertFlag) hp->RegisterMe(theBERT);
    236         else         hp->RegisterMe(theBIC);
    237      
    238         if(glFlag)
    239           hp->AddDataSet(new G4BGGNucleonInelasticXS(particle));
     153        if(fType == fQBBC) {
     154          hp->AddDataSet(new G4ProtonInelasticCrossSection());
     155        } else {
     156          hp->AddDataSet(new G4BGGNucleonInelasticXS(particle));
     157        }
     158        hp->RegisterMe(theQGSP);
     159        hp->RegisterMe(theFTFP);
     160        hp->RegisterMe(theBERT);
     161        //      hp->RegisterMe(theBERT1);
     162        //      hp->RegisterMe(theBIC);
    240163
    241164      } else if(pname == "neutron") {
    242         hp->AddDataSet(&theXSecN);
    243         hp->RegisterMe(theQGSModel);
    244         hp->RegisterMe(theFTFCModel);
    245         //if(ftfFlag) hp->RegisterMe(theFTFCModel);
    246         //else        hp->RegisterMe(theQGSModel);
    247 
    248         G4HadronCaptureProcess* theNeutronCapture =
    249           new G4HadronCaptureProcess("nCapture");
    250         G4HadronFissionProcess* theNeutronFission =
    251           new G4HadronFissionProcess("nFission");
    252         pmanager->AddDiscreteProcess(theNeutronCapture);
    253         pmanager->AddDiscreteProcess(theNeutronFission);
    254 
    255         G4double emin = 0.0;
    256         if(hpFlag) {
    257           emin = 19.5*MeV;
    258           theHPXSecI = new G4NeutronHPInelasticData;
    259           theHPXSecC = new G4NeutronHPCaptureData;
    260           theHPXSecF = new G4NeutronHPFissionData;
    261           hp->AddDataSet(theHPXSecI);
    262           theNeutronCapture->AddDataSet(theHPXSecC);
    263           theNeutronFission->AddDataSet(theHPXSecF);
    264           hp->RegisterMe(new G4NeutronHPInelastic());
    265           theNeutronCapture->RegisterMe(new G4NeutronHPCapture());
    266           theNeutronFission->RegisterMe(new G4NeutronHPFission());
    267         }
    268 
    269         G4HadronicInteraction* theB;
    270         if(bertFlag) theB = new G4CascadeInterface();
    271         else         theB = new G4BinaryCascade();
    272         theB->SetMinEnergy(emin);
    273         theB->SetMaxEnergy(maxEcascade);
    274         hp->RegisterMe(theB);
    275 
    276         if(glFlag)
    277           hp->AddDataSet(new G4BGGNucleonInelasticXS(particle));
    278 
    279         G4HadronicInteraction* theC = new G4LCapture();         
    280         theC->SetMinEnergy(emin);
    281         theNeutronCapture->RegisterMe(theC);
    282 
    283         G4HadronicInteraction* theF = new G4LFission();
    284         theF->SetMinEnergy(emin);
    285         theNeutronFission->RegisterMe(theF);
     165        if(fType == fQBBC) {
     166          hp->AddDataSet(new G4NeutronInelasticCrossSection());
     167        } else if(fType == fQBBC_XGG) {
     168          hp->AddDataSet(new G4BGGNucleonInelasticXS(particle));
     169        } else {
     170          hp->AddDataSet(new G4NeutronInelasticXS());
     171        }
     172
     173        hp->RegisterMe(theQGSP);
     174        hp->RegisterMe(theFTFP);
     175        //      hp->RegisterMe(theBERT1);
     176       
     177        G4HadronicProcess* capture = FindCaptureProcess();
     178        pmanager->AddDiscreteProcess(capture);
     179
     180        hp->RegisterMe(theBERT);
     181        //hp->RegisterMe(theBIC);
     182        capture->RegisterMe(new G4NeutronRadCapture());
     183        //capture->RegisterMe(new G4LCapture());
     184        if(fType == fQBBC_XGGSN) {
     185          capture->AddDataSet(new G4NeutronCaptureXS());
     186        }
    286187
    287188      } else if(pname == "pi-" || pname == "pi+") {
    288         hp->AddDataSet(&thePiCross);
    289         hp->RegisterMe(theQGSModel);
    290         hp->RegisterMe(theFTFCModel);
    291         //if(ftfFlag) hp->RegisterMe(theFTFCModel);
    292         //else        hp->RegisterMe(theQGSModel);
    293 
     189        if(fType == fQBBC) {
     190          hp->AddDataSet(new G4PiNuclearCrossSection());
     191        } else {
     192          hp->AddDataSet(new G4BGGPionInelasticXS(particle));
     193        }
     194        hp->RegisterMe(theQGSP);
     195        hp->RegisterMe(theFTFP);
    294196        hp->RegisterMe(theBERT);
    295         //if(bertFlag) hp->RegisterMe(theBERT);
    296         //else         hp->RegisterMe(theBIC);
    297 
    298         if(glFlag)
    299           hp->AddDataSet(new G4BGGPionInelasticXS(particle));
    300197
    301198      } else if(pname == "kaon-"     ||
    302199                pname == "kaon+"     ||
    303200                pname == "kaon0S"    ||
    304                 pname == "kaon0L") {
    305         hp->RegisterMe(theFTFBModel);
    306         hp->RegisterMe(theBERT);
    307         //hp->AddDataSet(new G4UInelasticCrossSection(particle));
    308 
    309       } else if(pname == "lambda"    ||
     201                pname == "kaon0L"    ||
     202                pname == "lambda"    ||
    310203                pname == "sigma-"    ||
    311204                pname == "sigma+"    ||
     205                pname == "sigma0"    ||
    312206                pname == "xi-"       ||
    313207                pname == "xi0") {
    314 
    315         hp->RegisterMe(theFTFBModel);
    316         hp->RegisterMe(theBERT);
    317         //hp->AddDataSet(new G4UInelasticCrossSection(particle));
    318 
    319       } else if(pname == "anti_proton" || pname == "anti_neutron") {
    320         hp->RegisterMe(theFTFBModel);
     208        hp->RegisterMe(theFTFP1);
     209        hp->RegisterMe(theBERT);
     210
     211      } else {
     212        hp->RegisterMe(theFTFP1);
    321213        hp->RegisterMe(theCHIPS);
    322         //hp->AddDataSet(new G4UInelasticCrossSection(particle));
    323 
    324       } else {
    325         hp->RegisterMe(theFTFBModel);
    326         hp->RegisterMe(theCHIPS);
    327         //hp->AddDataSet(new G4UInelasticCrossSection(particle));
     214
    328215      }
    329216
    330       if(verbose > 1)
     217      if(verbose > 1) {
    331218        G4cout << "### HadronInelasticQBBC: " << hp->GetProcessName()
    332219               << " added for " << pname << G4endl;
     220      }
    333221    }
    334222  }
Note: See TracChangeset for help on using the changeset viewer.