| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
24 // *******************************************
25 //
26 //
27 // Geant4 class G4HadronicBuilder
28 //
29 // Author V.Ivanchenko 14.05.2020
30 //
31
32 #include "G4HadronicBuilder.hh"
33 #include "G4HadParticles.hh"
34 #include "G4HadProcesses.hh"
35
36 #include "G4ParticleDefinition.hh"
37 #include "G4ParticleTable.hh"
38 #include "G4PhysicsListHelper.hh"
39 #include "G4SystemOfUnits.hh"
40
41 #include "G4HadronicParameters.hh"
42
43 #include "G4TheoFSGenerator.hh"
44 #include "G4FTFModel.hh"
45 #include "G4ExcitedStringDecay.hh"
46 #include "G4GeneratorPrecompoundInterface.hh"
47
48 #include "G4QGSModel.hh"
49 #include "G4QGSParticipants.hh"
50 #include "G4QGSMFragmentation.hh"
51 #include "G4QuasiElasticChannel.hh"
52
53 #include "G4CascadeInterface.hh"
54 #include "G4CrossSectionDataSetRegistry.hh"
55 #include "G4CrossSectionInelastic.hh"
56 #include "G4CrossSectionElastic.hh"
57 #include "G4HadronElastic.hh"
58 #include "G4CrossSectionDataSetRegistry.hh"
59
60 #include "G4HadronElasticProcess.hh"
61 #include "G4HadronInelasticProcess.hh"
62
63 #include "G4DecayTable.hh"
64 #include "G4VDecayChannel.hh"
65 #include "G4PhaseSpaceDecayChannel.hh"
66
67 #include "G4PreCompoundModel.hh"
68 #include "G4INCLXXInterface.hh"
69 #include "G4ComponentAntiNuclNuclearXS.hh"
70
71
72
73 void G4HadronicBuilder::BuildFTFP_BERT(const s
74 G4bool
75
76 G4HadronicParameters* param = G4HadronicPara
77 G4PhysicsListHelper* ph = G4PhysicsListHelpe
78
79 auto theModel = new G4TheoFSGenerator("FTFP"
80 auto theStringModel = new G4FTFModel();
81 theStringModel->SetFragmentationModel(new G4
82 theModel->SetHighEnergyGenerator( theStringM
83 theModel->SetTransport( new G4GeneratorPreco
84 theModel->SetMaxEnergy( param->GetMaxEnergy(
85
86 G4CascadeInterface* theCascade = nullptr;
87 if(bert) {
88 theCascade = new G4CascadeInterface();
89 theCascade->SetMaxEnergy( param->GetMaxEne
90 theModel->SetMinEnergy( param->GetMinEnerg
91 }
92
93 auto xsinel = G4HadProcesses::InelasticXS( x
94
95 G4ParticleTable* table = G4ParticleTable::Ge
96 for( auto & pdg : partList ) {
97
98 auto part = table->FindParticle( pdg );
99 if ( part == nullptr ) { continue; }
100
101 auto hadi = new G4HadronInelasticProcess(
102 hadi->AddDataSet( xsinel );
103 hadi->RegisterMe( theModel );
104 if( theCascade != nullptr ) hadi->Register
105 if( param->ApplyFactorXS() ) hadi->Multipl
106 ph->RegisterProcess(hadi, part);
107 }
108 }
109
110 void G4HadronicBuilder::BuildFTFQGSP_BERT(cons
111 G4bo
112
113 G4HadronicParameters* param = G4HadronicPara
114 G4PhysicsListHelper* ph = G4PhysicsListHelpe
115
116 auto theModel = new G4TheoFSGenerator("FTFQG
117 auto theStringModel = new G4FTFModel();
118 theStringModel->SetFragmentationModel(new G4
119 theModel->SetHighEnergyGenerator( theStringM
120 theModel->SetTransport( new G4GeneratorPreco
121 theModel->SetMaxEnergy( param->GetMaxEnergy(
122
123 G4CascadeInterface* theCascade = nullptr;
124 if(bert) {
125 theCascade = new G4CascadeInterface();
126 theCascade->SetMaxEnergy( param->GetMaxEne
127 theModel->SetMinEnergy( param->GetMinEnerg
128 }
129
130 auto xsinel = G4HadProcesses::InelasticXS( x
131
132 G4ParticleTable* table = G4ParticleTable::Ge
133 for( auto & pdg : partList ) {
134
135 auto part = table->FindParticle( pdg );
136 if ( part == nullptr ) { continue; }
137
138 auto hadi = new G4HadronInelasticProcess(
139 hadi->AddDataSet( xsinel );
140 hadi->RegisterMe( theModel );
141 if( theCascade != nullptr ) hadi->Register
142 if( param->ApplyFactorXS() ) hadi->Multipl
143 ph->RegisterProcess(hadi, part);
144 }
145 }
146
147 void G4HadronicBuilder::BuildQGSP_FTFP_BERT(co
148 G4
149 co
150
151 G4HadronicParameters* param = G4HadronicPara
152 G4PhysicsListHelper* ph = G4PhysicsListHelpe
153
154 auto theTransport = new G4GeneratorPrecompou
155
156 auto theHEModel = new G4TheoFSGenerator("QGS
157 G4QGSModel< G4QGSParticipants >* theQGSModel
158 theQGSModel->SetFragmentationModel( new G4Ex
159 theHEModel->SetTransport( theTransport );
160 theHEModel->SetHighEnergyGenerator( theQGSMo
161 if (quasiElastic) {
162 theHEModel->SetQuasiElasticChannel(new G4Q
163 }
164 theHEModel->SetMinEnergy( param->GetMinEnerg
165 theHEModel->SetMaxEnergy( param->GetMaxEnerg
166
167 auto theLEModel = new G4TheoFSGenerator("FTF
168 auto theFTFModel = new G4FTFModel();
169 theFTFModel->SetFragmentationModel(new G4Exc
170 theLEModel->SetHighEnergyGenerator( theFTFMo
171 theLEModel->SetTransport( theTransport );
172 theLEModel->SetMaxEnergy( param->GetMaxEnerg
173
174 G4CascadeInterface* theCascade = nullptr;
175 if(bert) {
176 theCascade = new G4CascadeInterface();
177 theCascade->SetMaxEnergy( param->GetMaxEne
178 theLEModel->SetMinEnergy( param->GetMinEne
179 }
180
181 auto xsinel = G4HadProcesses::InelasticXS( x
182
183 G4ParticleTable* table = G4ParticleTable::Ge
184 for( auto & pdg : partList ) {
185
186 auto part = table->FindParticle( pdg );
187 if ( part == nullptr ) { continue; }
188
189 auto hadi = new G4HadronInelasticProcess(
190 hadi->AddDataSet( xsinel );
191 hadi->RegisterMe( theHEModel );
192 hadi->RegisterMe( theLEModel );
193 if(theCascade != nullptr) hadi->RegisterMe
194 if( param->ApplyFactorXS() ) hadi->Multipl
195 ph->RegisterProcess(hadi, part);
196 }
197 }
198
199 void G4HadronicBuilder::BuildINCLXX(const std:
200 G4bool
201
202 // FTF
203 G4HadronicParameters* param = G4HadronicPara
204 G4PhysicsListHelper* ph = G4PhysicsListHelpe
205
206 auto theModel = new G4TheoFSGenerator("FTFP"
207 auto theStringModel = new G4FTFModel();
208 theStringModel->SetFragmentationModel(new G4
209 theModel->SetHighEnergyGenerator( theStringM
210 theModel->SetTransport( new G4GeneratorPreco
211 theModel->SetMaxEnergy( param->GetMaxEnergy(
212
213 G4CascadeInterface* theCascade = nullptr;
214 if(bert) {
215 theCascade = new G4CascadeInterface();
216 theCascade->SetMaxEnergy( param->GetMaxEne
217 theModel->SetMinEnergy( param->GetMinEnerg
218 }
219
220 // INCLXX
221 auto theModelINCLXX = new G4INCLXXInterface(
222 theModelINCLXX->SetMinEnergy( param->GetMinE
223 theModelINCLXX->SetMaxEnergy( param->GetMaxE
224
225 //
226 auto xsinel = G4HadProcesses::InelasticXS( x
227
228 G4ParticleTable* table = G4ParticleTable::Ge
229 for( auto & pdg : partList ) {
230
231 auto part = table->FindParticle( pdg );
232 if ( part == nullptr ) { continue; }
233
234 auto hadi = new G4HadronInelasticProcess(
235 if( pdg == -2212 ) { // pbar use INCLXX
236 hadi->AddDataSet( xsinel );
237 hadi->RegisterMe( theModelINCLXX );
238 if( param->ApplyFactorXS() ) hadi->Multi
239 ph->RegisterProcess(hadi, part);
240 } else { // other anti-X use FTF
241 hadi->AddDataSet( xsinel );
242 hadi->RegisterMe( theModel );
243 if( theCascade != nullptr ) hadi->Register
244 if( param->ApplyFactorXS() ) hadi->Multipl
245 ph->RegisterProcess(hadi, part);
246 }
247 }
248 }
249
250 void G4HadronicBuilder::BuildElastic(const std
251
252 G4HadronicParameters* param = G4HadronicPara
253 G4PhysicsListHelper* ph = G4PhysicsListHelpe
254
255 auto xsel = G4HadProcesses::ElasticXS("Glaub
256
257 auto elModel = new G4HadronElastic();
258 elModel->SetMaxEnergy( param->GetMaxEnergy()
259
260 G4ParticleTable* table = G4ParticleTable::Ge
261 for( auto & pdg : partList ) {
262
263 auto part = table->FindParticle( pdg );
264 if ( part == nullptr ) { continue; }
265
266 auto hade = new G4HadronElasticProcess();
267 hade->AddDataSet( xsel );
268 hade->RegisterMe( elModel );
269 if( param->ApplyFactorXS() ) hade->Multipl
270 ph->RegisterProcess(hade, part);
271 }
272 }
273
274 void G4HadronicBuilder::BuildHyperonsFTFP_BERT
275 // For hyperons, Bertini is used at low ener
276 // for anti-hyperons, FTFP can be used down
277 BuildFTFP_BERT(G4HadParticles::GetHyperons()
278 BuildFTFP_BERT(G4HadParticles::GetAntiHypero
279 }
280
281 void G4HadronicBuilder::BuildHyperonsFTFQGSP_B
282 // For hyperons, Bertini is used at low ener
283 // for anti-hyperons, FTFP can be used down
284 BuildFTFQGSP_BERT(G4HadParticles::GetHyperon
285 BuildFTFQGSP_BERT(G4HadParticles::GetAntiHyp
286 }
287
288 void G4HadronicBuilder::BuildHyperonsQGSP_FTFP
289 // For hyperons, Bertini is used at low ener
290 // for anti-hyperons, FTFP can be used down
291 // QGSP is used at high energies in all case
292 BuildQGSP_FTFP_BERT(G4HadParticles::GetHyper
293 BuildQGSP_FTFP_BERT(G4HadParticles::GetAntiH
294 }
295
296 void G4HadronicBuilder::BuildKaonsFTFP_BERT()
297 BuildFTFP_BERT(G4HadParticles::GetKaons(), t
298 }
299
300 void G4HadronicBuilder::BuildKaonsFTFQGSP_BERT
301 BuildFTFQGSP_BERT(G4HadParticles::GetKaons()
302 }
303
304 void G4HadronicBuilder::BuildKaonsQGSP_FTFP_BE
305 BuildQGSP_FTFP_BERT(G4HadParticles::GetKaons
306 }
307
308 void G4HadronicBuilder::BuildAntiLightIonsFTFP
309 BuildFTFP_BERT(G4HadParticles::GetLightAntiI
310 }
311
312 //void G4HadronicBuilder::BuildAntiLightIonsQG
313 // Note: currently QGSP cannot be applied for
314 // BuildQGSP_FTFP_BERT(G4HadParticles::GetLig
315 //}
316
317 void G4HadronicBuilder::BuildAntiLightIonsINCL
318 BuildINCLXX(G4HadParticles::GetLightAntiIons
319 }
320
321 void G4HadronicBuilder::BuildBCHadronsFTFP_BER
322 if( G4HadronicParameters::Instance()->Enable
323 // Bertini is not applicable for charm and
324 // down to zero kinetic energy (but at ver
325 // that returns the projectile heavy hadro
326 BuildFTFP_BERT(G4HadParticles::GetBCHadron
327 BuildDecayTableForBCHadrons();
328 }
329 }
330
331 void G4HadronicBuilder::BuildBCHadronsFTFQGSP_
332 if( G4HadronicParameters::Instance()->Enable
333 // Bertini is not applicable for charm and
334 // down to zero kinetic energy (but at ver
335 // that returns the projectile heavy hadro
336 BuildFTFQGSP_BERT(G4HadParticles::GetBCHad
337 BuildDecayTableForBCHadrons();
338 }
339 }
340
341 void G4HadronicBuilder::BuildBCHadronsQGSP_FTF
342 if( G4HadronicParameters::Instance()->Enable
343 // Bertini is not applicable for charm and
344 // down to zero kinetic energy (but at ver
345 // that returns the projectile heavy hadro
346 // QGSP is used at high energies in all ca
347 BuildQGSP_FTFP_BERT(G4HadParticles::GetBCH
348 BuildDecayTableForBCHadrons();
349 }
350 }
351
352 void G4HadronicBuilder::BuildDecayTableForBCHa
353 // Geant4 does not define the decay of most
354 // The reason is that most of these heavy ha
355 // decay channels, with a complex dynamics,
356 // phase space kinematical treatment used in
357 // High-energy experiments usually use dedic
358 // for the decays of charmed and bottom hadr
359 // hadrons, which are passed to Geant4 as pr
360 // decays. Moreover, no charmed or bottom se
361 // in Geant4 hadronic interactions before Ge
362 // With the extension of Geant4 hadronic int
363 // hadrons, in version Geant4 10.7, we do ne
364 // for these heavy hadrons, for two reasons:
365 // 1. For testing purposes, unless we pre-as
366 // (as the HEP experiments normally do by
367 // 2. To avoid crashes (due to missing decay
368 // bottom secondary hadrons are produced
369 // even with ordinary (i.e. not heavy) ha
370 // this case we cannot (easily!) pre-assi
371 // Given that 1. is just a convenience for t
372 // rarely in practice - because very few pri
373 // heavy hadrons fly enough to reach the bea
374 // having an inelastic interaction there, an
375 // to create a heavy hadrons from the string
376 // (i.e. not heavy) hadronic interactions -
377 // to define accurately the decays of heavy
378 // So, for our practical purposes, it is eno
379 // "dummy" decays of charmed and bottom hadr
380 // Here we use a single, fully hadronic chan
381 // daughters, for each of these heavy hadron
382 // decay channel a 100% branching ratio, alt
383 // channel is one between hundreds of possib
384 // real branching ratio is typical of a few
385 // the decay without any dynamics, i.e. with
386 // treatment.
387 // Note that some of the charmed and bottom
388 // SigmaC+, SigmaC0, SigmaB+, SigmaB0 and Si
389 // decay channel (to LambdaC/B + Pion) which
390 // This is not the case for EtaC, JPsi and U
391 // be defined here (although they decay so q
392 // interactions can be neglected, as we do f
393 // Note that our definition of the decay tab
394 // do not interfere with the pre-assign deca
395 // bottom tracks made by the HEP experiments
396 // have priority over (i.e. override) decay
397 static G4bool isFirstCall = true;
398 if ( ! isFirstCall ) return;
399 isFirstCall = false;
400 G4ParticleTable* particleTable = G4ParticleT
401 for ( auto & pdg : G4HadParticles::GetBCHadr
402 auto part = particleTable->FindParticle( p
403 if ( part == nullptr ) {
404 G4cout << "G4HadronicBuilder::BuildDecay
405 << pdg << " is not defined !" <<
406 continue;
407 }
408 if ( part->GetDecayTable() ) {
409 G4cout << "G4HadronicBuilder::BuildDecay
410 << pdg << " has already a decay t
411 continue;
412 }
413 G4DecayTable* decayTable = new G4DecayTabl
414 const G4int numberDecayChannels = 1;
415 G4VDecayChannel** mode = new G4VDecayChann
416 for ( G4int i = 0; i < numberDecayChannels
417 switch ( pdg ) {
418 // Charmed mesons
419 case 411 : // D+
420 mode[0] = new G4PhaseSpaceDecayChannel
421 break;
422 case -411 : // D-
423 mode[0] = new G4PhaseSpaceDecayChannel
424 break;
425 case 421 : // D0
426 mode[0] = new G4PhaseSpaceDecayChannel
427 break;
428 case -421 : // anti_D0
429 mode[0] = new G4PhaseSpaceDecayChannel
430 break;
431 case 431 : // Ds+
432 mode[0] = new G4PhaseSpaceDecayChannel
433 break;
434 case -431 : // Ds-
435 mode[0] = new G4PhaseSpaceDecayChannel
436 break;
437 // Bottom mesons
438 case 521 : // B+
439 mode[0] = new G4PhaseSpaceDecayChannel
440 break;
441 case -521 : // B-
442 mode[0] = new G4PhaseSpaceDecayChannel
443 break;
444 case 511 : // B0
445 mode[0] = new G4PhaseSpaceDecayChannel
446 break;
447 case -511 : // anti_B0
448 mode[0] = new G4PhaseSpaceDecayChannel
449 break;
450 case 531 : // Bs0
451 mode[0] = new G4PhaseSpaceDecayChannel
452 break;
453 case -531 : // anti_Bs0
454 mode[0] = new G4PhaseSpaceDecayChannel
455 break;
456 case 541 : // Bc+
457 mode[0] = new G4PhaseSpaceDecayChannel
458 break;
459 case -541 : // Bc-
460 mode[0] = new G4PhaseSpaceDecayChannel
461 break;
462 // Charmed baryons (and anti-baryons)
463 case 4122 : // lambda_c+
464 mode[0] = new G4PhaseSpaceDecayChannel
465 break;
466 case -4122 : // anti_lambda_c+
467 mode[0] = new G4PhaseSpaceDecayChannel
468 break;
469 case 4232 : // xi_c+
470 mode[0] = new G4PhaseSpaceDecayChannel
471 break;
472 case -4232 : // anti_xi_c+
473 mode[0] = new G4PhaseSpaceDecayChannel
474 break;
475 case 4132 : // xi_c0
476 mode[0] = new G4PhaseSpaceDecayChannel
477 break;
478 case -4132 : // anti_xi_c0
479 mode[0] = new G4PhaseSpaceDecayChannel
480 break;
481 case 4332 : // omega_c0
482 mode[0] = new G4PhaseSpaceDecayChannel
483 break;
484 case -4332 : // anti_omega_c0
485 mode[0] = new G4PhaseSpaceDecayChannel
486 break;
487 // Bottom baryons (and anti-baryons)
488 case 5122 : // lambda_b
489 mode[0] = new G4PhaseSpaceDecayChannel
490 break;
491 case -5122 : // anti_lambda_b
492 mode[0] = new G4PhaseSpaceDecayChannel
493 break;
494 case 5232 : // xi_b0
495 mode[0] = new G4PhaseSpaceDecayChannel
496 break;
497 case -5232 : // anti_xi_b0
498 mode[0] = new G4PhaseSpaceDecayChannel
499 break;
500 case 5132 : // xi_b-
501 mode[0] = new G4PhaseSpaceDecayChannel
502 break;
503 case -5132 : // anti_xi_b-
504 mode[0] = new G4PhaseSpaceDecayChannel
505 break;
506 case 5332 : // omega_b-
507 mode[0] = new G4PhaseSpaceDecayChannel
508 break;
509 case -5332 : // anti_omega_b-
510 mode[0] = new G4PhaseSpaceDecayChannel
511 break;
512 default :
513 G4cout << "G4HadronicBuilder::BuildDec
514 } // End of the switch
515
516 for ( G4int index = 0; index < numberDecay
517 delete [] mode;
518 part->SetDecayTable( decayTable );
519 } // End of the for loop over heavy hadrons
520 // Add now the decay for etac, JPsi and Upsi
521 // secondaries in hadronic interactions, whi
522 // hadrons included in G4HadParticles::GetBC
523 // and therefore their hadronic interactions
524 if ( ! G4Etac::Definition()->GetDecayTable()
525 G4DecayTable* decayTable = new G4DecayTabl
526 const G4int numberDecayChannels = 1;
527 G4VDecayChannel** mode = new G4VDecayChann
528 for ( G4int i = 0; i < numberDecayChannels
529 mode[0] = new G4PhaseSpaceDecayChannel( "e
530 for ( G4int index = 0; index < numberDecay
531 delete [] mode;
532 G4Etac::Definition()->SetDecayTable( decay
533 }
534 if ( ! G4JPsi::Definition()->GetDecayTable()
535 G4DecayTable* decayTable = new G4DecayTabl
536 const G4int numberDecayChannels = 1;
537 G4VDecayChannel** mode = new G4VDecayChann
538 for ( G4int i = 0; i < numberDecayChannels
539 mode[0] = new G4PhaseSpaceDecayChannel( "J
540 for ( G4int index = 0; index < numberDecay
541 delete [] mode;
542 G4JPsi::Definition()->SetDecayTable( decay
543 }
544 if ( ! G4Upsilon::Definition()->GetDecayTabl
545 G4DecayTable* decayTable = new G4DecayTabl
546 const G4int numberDecayChannels = 1;
547 G4VDecayChannel** mode = new G4VDecayChann
548 for ( G4int i = 0; i < numberDecayChannels
549 mode[0] = new G4PhaseSpaceDecayChannel( "U
550 for ( G4int index = 0; index < numberDecay
551 delete [] mode;
552 G4Upsilon::Definition()->SetDecayTable( de
553 }
554 }
555
556
557 void G4HadronicBuilder::BuildHyperNucleiFTFP_B
558 if ( G4HadronicParameters::Instance()->Enabl
559 // Bertini intra-nuclear cascade model is
560 // hypernuclei, therefore FTFP is used dow
561 // very low energies, a dummy model is use
562 // hypernucleus in the final state).
563 BuildFTFP_BERT( G4HadParticles::GetHyperNu
564 }
565 }
566
567
568 void G4HadronicBuilder::BuildHyperAntiNucleiFT
569 if ( G4HadronicParameters::Instance()->Enabl
570 // FTFP can be used down to zero kinetic e
571 BuildFTFP_BERT( G4HadParticles::GetHyperAn
572 }
573 }
574
575
576 void G4HadronicBuilder::BuildHyperNucleiFTFP_I
577 if ( G4HadronicParameters::Instance()->Enabl
578 BuildFTFP_INCLXX( G4HadParticles::GetHyper
579 }
580 }
581
582
583 void G4HadronicBuilder::BuildFTFP_INCLXX( cons
584 G4HadronicParameters* param = G4HadronicPara
585 G4PhysicsListHelper* ph = G4PhysicsListHelpe
586 auto theTheoFSModel = new G4TheoFSGenerator(
587 auto theStringModel = new G4FTFModel;
588 theStringModel->SetFragmentationModel( new G
589 theTheoFSModel->SetHighEnergyGenerator( theS
590 theTheoFSModel->SetTransport( new G4Generato
591 theTheoFSModel->SetMaxEnergy( param->GetMaxE
592 theTheoFSModel->SetMinEnergy( 15.0*CLHEP::Ge
593 G4VPreCompoundModel* thePrecoModel = new G4P
594 thePrecoModel->SetMinEnergy( 0.0 );
595 thePrecoModel->SetMaxEnergy( 2.0*CLHEP::MeV
596 G4INCLXXInterface* theINCLXXModel = new G4IN
597 theINCLXXModel->SetMinEnergy( 1.0*CLHEP::MeV
598 theINCLXXModel->SetMaxEnergy( 20.0*CLHEP::Ge
599 auto xsinel = G4HadProcesses::InelasticXS( x
600 G4ParticleTable* table = G4ParticleTable::Ge
601 for ( auto & pdg : partList ) {
602 auto part = table->FindParticle( pdg );
603 if ( part == nullptr ) continue;
604 auto hadi = new G4HadronInelasticProcess(
605 hadi->AddDataSet( xsinel );
606 hadi->RegisterMe( theTheoFSModel );
607 hadi->RegisterMe( theINCLXXModel );
608 if ( param->ApplyFactorXS() ) hadi->Multip
609 ph->RegisterProcess( hadi, part );
610 }
611 }
612