source: trunk/source/processes/hadronic/models/incl/src/G4Incl.cc @ 962

Last change on this file since 962 was 962, checked in by garnier, 15 years ago

update processes
File size: 228.6 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer                                           *
4// *                                                                  *
5// * The  Geant4 software  is  copyright of the Copyright Holders  of *
6// * the Geant4 Collaboration.  It is provided  under  the terms  and *
7// * conditions of the Geant4 Software License,  included in the file *
8// * LICENSE and available at  http://cern.ch/geant4/license .  These *
9// * include a list of copyright holders.                             *
10// *                                                                  *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work  make  any representation or  warranty, express or implied, *
14// * regarding  this  software system or assume any liability for its *
15// * use.  Please see the license in the file  LICENSE  and URL above *
16// * for the full disclaimer and the limitation of liability.         *
17// *                                                                  *
18// * This  code  implementation is the result of  the  scientific and *
19// * technical work of the GEANT4 collaboration.                      *
20// * By using,  copying,  modifying or  distributing the software (or *
21// * any work based  on the software)  you  agree  to acknowledge its *
22// * use  in  resulting  scientific  publications,  and indicate your *
23// * acceptance of all terms of the Geant4 Software license.          *
24// ********************************************************************
25//
26// $Id: G4Incl.cc,v 1.20 2008/11/06 10:11:27 kaitanie Exp $
27// Translation of INCL4.2/ABLA V3
28// Pekka Kaitaniemi, HIP (translation)
29// Christelle Schmidt, IPNL (fission code)
30// Alain Boudard, CEA (contact person INCL/ABLA)
31// Aatos Heikkinen, HIP (project coordination)
32
33#include "G4Incl.hh"
34#include <iostream>
35#include "Randomize.hh"
36#include "G4InclRandomNumbers.hh"
37#include "G4Ranecu.hh"
38
39G4Incl::G4Incl()
40{
41  verboseLevel = 0;
42
43  // Set functions to be used for integration routine. 
44  wsaxFunction = 0;
45  derivWsaxFunction = 1;
46  dmhoFunction = 2;
47  derivMhoFunction = 3;
48  derivGausFunction = 4;
49  densFunction = 5;
50
51  //  randomGenerator = new G4InclGeant4Random();
52  randomGenerator = new G4Ranecu();
53}
54
55G4Incl::G4Incl(G4Hazard *aHazard, G4Dton *aDton, G4Saxw *aSaxw, G4Ws *aWs)
56{
57  verboseLevel = 0;
58
59  // Set functions to be used for integration routine. 
60  wsaxFunction = 0;
61  derivWsaxFunction = 1;
62  dmhoFunction = 2;
63  derivMhoFunction = 3;
64  derivGausFunction = 4;
65  densFunction = 5;
66
67  // Set input data for testing.
68  hazard = aHazard;
69  dton = aDton;
70  saxw = aSaxw;
71  ws = aWs;
72
73  //randomGenerator = new G4Ranecu();
74  randomGenerator = new G4InclGeant4Random();
75}
76
77G4Incl::G4Incl(G4Hazard *aHazard, G4Calincl *aCalincl, G4Ws *aWs, G4Mat *aMat, G4VarNtp *aVarntp)
78{
79  verboseLevel = 0;
80
81  // Set functions to be used for integration routine.   
82  wsaxFunction = 0;
83  derivWsaxFunction = 1;
84  dmhoFunction = 2;
85  derivMhoFunction = 3;
86  derivGausFunction = 4;
87  densFunction = 5;
88
89  // Set input data for INCL run. 
90  hazard = aHazard;
91  calincl = aCalincl;
92  ws = aWs;
93  mat = aMat;
94  varntp = aVarntp;
95
96  //  randomGenerator = new G4InclGeant4Random();
97  randomGenerator = new G4Ranecu();
98  light_gaus_nuc = new G4LightGausNuc();
99  light_nuc = new G4LightNuc();
100  spl2 = new G4Spl2();
101  saxw = new G4Saxw();
102  dton = new G4Dton();
103  bl1 = new G4Bl1();
104  bl2 = new G4Bl2();
105  bl3 = new G4Bl3();
106  bl4 = new G4Bl4();
107  bl5 = new G4Bl5();
108  bl6 = new G4Bl6();
109  bl8 = new G4Bl8();
110  bl9 = new G4Bl9();
111  bl10 = new G4Bl10();
112  kindstruct = new G4Kind();
113  paul = new G4Paul();
114  varavat = new G4VarAvat();
115  varavat->kveux = 0;
116
117  volant = new G4Volant();
118  volant->iv = 0;
119  evaporationResult = new G4VarNtp();
120  evaporationResult->ntrack = -1;
121
122  // Initialize evaporation.
123  abla = new G4Abla(hazard, volant, evaporationResult);
124  abla->initEvapora();
125}
126
127G4Incl::~G4Incl()
128{
129  delete randomGenerator;
130  delete light_gaus_nuc;
131  delete light_nuc;
132  delete spl2;
133  delete saxw;
134  delete dton;
135  delete bl1;
136  delete bl2;
137  delete bl3;
138  delete bl4;
139  delete bl5;
140  delete bl6;
141  delete bl8;
142  delete bl9;
143  delete bl10;
144  delete kindstruct;
145  delete paul;
146  delete varavat;
147
148  delete abla;
149  delete evaporationResult;
150  delete volant;
151}
152
153/**
154 *Methods for debugging.
155 */
156G4double G4Incl::energyTest(G4int i)
157{
158  return am(bl1->p1[i]+bl1->p1[i],bl1->p2[i]+bl1->p2[i],bl1->p3[i]+bl1->p3[i],bl1->eps[i]+bl1->eps[i]);
159}
160
161void G4Incl::dumpBl5(std::ofstream& dumpOut)
162{
163  dumpOut <<"Dumping G4Bl5:" << G4endl;
164  for(G4int i = 0; i < 300; i++) {
165    dumpOut <<"i = " << i << " nesc[i] = " << bl5->nesc[i] << G4endl;
166  }
167}
168
169void G4Incl::dumpSaxw(std::ofstream& dumpOut)
170{
171  dumpOut << "Dumping G4Saxw" << G4endl;
172  dumpOut << "saxw->k    = " << saxw->k    << G4endl;
173  dumpOut << "saxw->n    = " << saxw->n    << G4endl;
174  dumpOut << "saxw->imat = " << saxw->imat << G4endl;
175  for(G4int i = 0; i < 30; i++) {
176    dumpOut <<"i = " << i << " x = " << saxw->x[i][0] << " y = " << saxw->y[i][0] << " s = " << saxw->s[i][0] << G4endl; 
177  }
178}
179
180void G4Incl::dumpBl1(std::ofstream& dumpOut)
181{
182  dumpOut <<"Dumping Bl1: " << G4endl;
183  dumpOut <<"bl1->ta = " << bl1->ta << G4endl;
184  for(G4int i = 0; i <= bl2->k; i++) {
185    dumpOut <<"i = " << i;
186    dumpOut <<" bl1->p1 = "   << bl1->p1[i]    << " bl1->p2 = "  << bl1->p2[i] <<" bl1->p3 = " << bl1->p3[i];
187    dumpOut <<" bl1->eps = "  << bl1->eps[i];
188    dumpOut <<" bl1->ind1 = " << bl1->ind1[i]  <<" bl1->ind2 = " << bl1->ind2[i] << G4endl;
189  }
190  dumpOut <<"End of Bl1 dump." << G4endl << G4endl;
191}
192
193void G4Incl::dumpBl2(std::ofstream& dumpOut)
194{
195  dumpOut <<"Dumping Bl2: bl2->k = " << bl2->k << G4endl;
196  for(G4int i = 0; i <= bl2->k; i++) {
197    dumpOut <<"i = " << i;
198    dumpOut <<" bl2->ind " << bl2->ind[i] << " bl2->jnd = " << bl2->jnd[i] <<" bl2->crois = " << bl2->crois[i] << G4endl;
199  }
200  dumpOut <<"End of Bl2 dump." << G4endl << G4endl;}
201
202
203void G4Incl::dumpBl3(std::ofstream& dumpOut)
204{
205  dumpOut <<"Dumping Bl3:" << G4endl;
206  dumpOut <<"r1   = " << bl3->r1   << " r2 = "  << bl3->r2  << G4endl;
207  dumpOut <<"ia1  = " << bl3->ia1  << " ia2 = " << bl3->ia2 << G4endl;
208  dumpOut <<"rab2 = " << bl3->rab2                          << G4endl;
209
210  for(G4int i = 0; i <= bl2->k; i++) {
211    dumpOut <<"i = "        << i;
212    dumpOut <<" bl3->x1 = " << bl3->x1[i] << " bl3->x2 = " << bl3->x2[i] <<" bl3->x3 = " << bl3->x3[i] << G4endl;
213  }
214  dumpOut <<"End of Bl2 dump." << G4endl << G4endl;
215}
216
217// End debug functions
218
219void G4Incl::setVerboseLevel(G4int level)
220{
221  verboseLevel = level;
222}
223
224G4int G4Incl::getVerboseLevel()
225{
226  return verboseLevel;
227}
228
229void G4Incl::setDtonData(G4Dton *newDton)
230{
231  dton = newDton;
232}
233
234void G4Incl::setWsData(G4Ws *newWs)
235{
236  ws = newWs;
237}
238
239void G4Incl::setHazardData(G4Hazard *newHazard)
240{
241  hazard = newHazard;
242}
243
244void G4Incl::setSaxwData(G4Saxw *newSaxw)
245{
246  saxw = newSaxw;
247}
248
249void G4Incl::setSpl2Data(G4Spl2 *newSpl2)
250{
251  spl2 = newSpl2;
252}
253
254void G4Incl::setCalinclData(G4Calincl *newCalincl)
255{
256  calincl = newCalincl;
257}
258
259void G4Incl::setMatData(G4Mat *newMat)
260{
261  mat = newMat;
262}
263
264void G4Incl::setLightNucData(G4LightNuc *newLightNuc)
265{
266  light_nuc = newLightNuc;
267}
268
269void G4Incl::setLightGausNucData(G4LightGausNuc *newLightGausNuc)
270{
271  light_gaus_nuc = newLightGausNuc;
272}
273
274void G4Incl::setBl1Data(G4Bl1 *newBl1)
275{
276  bl1 = newBl1;
277}
278
279void G4Incl::setBl2Data(G4Bl2 *newBl2)
280{
281  bl2 = newBl2;
282}
283
284void G4Incl::setBl3Data(G4Bl3 *newBl3)
285{
286  bl3 = newBl3;
287}
288
289void G4Incl::setBl4Data(G4Bl4 *newBl4)
290{
291  bl4 = newBl4;
292}
293
294void G4Incl::setBl5Data(G4Bl5 *newBl5)
295{
296  bl5 = newBl5;
297}
298
299void G4Incl::setBl6Data(G4Bl6 *newBl6)
300{
301  bl6 = newBl6;
302}
303
304void G4Incl::setBl8Data(G4Bl8 *newBl8)
305{
306  bl8 = newBl8;
307}
308
309void G4Incl::setBl9Data(G4Bl9 *newBl9)
310{
311  bl9 = newBl9;
312}
313
314void G4Incl::setBl10Data(G4Bl10 *newBl10)
315{
316  bl10 = newBl10;
317}
318
319void G4Incl::setKindData(G4Kind *newKind)
320{
321  kindstruct = newKind;
322}
323
324/**
325 * INCL main routines for event processing.
326 */
327
328void G4Incl::processEventIncl()
329{
330  const G4double uma = 931.4942;
331  const G4double melec = 0.511;
332
333  G4double   pcorem = 0.0;
334  G4double   pxrem = 0.0;
335  G4double   pyrem = 0.0;
336  G4double   pzrem = 0.0;
337
338  G4double ap = 0.0, zp = 0.0, mprojo = 0.0, pbeam = 0.0;
339
340  varntp->clear();
341  if(calincl->f[6] == 3.0) { // pi+
342    mprojo = 139.56995;
343    ap = 0.0;
344    zp = 1.0;
345  }
346
347  if(calincl->f[6] == 4.0) { // pi0
348    mprojo = 134.9764;
349    ap = 0.0;
350    zp = 0.0;
351  }
352
353  if(calincl->f[6] == 5.0) { // pi-
354    mprojo = 139.56995;
355    ap = 0.0;
356    zp = -1.0;
357  }
358
359  // Coulomb en entree seulement pour les particules ci-dessous.
360  if(calincl->f[6] == 1.0) { // proton
361    mprojo = 938.27231;
362    ap = 1.0;
363    zp = 1.0;
364  }
365 
366  if(calincl->f[6] == 2.0) { // neutron 
367    mprojo = 939.56563;
368    ap = 1.0;
369    zp = 0.0;
370  }
371 
372  if(calincl->f[6] == 6.0) { // deuteron
373    mprojo = 1875.61276;
374    ap = 2.0;
375    zp = 1.0;
376  }
377 
378  if(calincl->f[6] == 7.0) { // triton
379    mprojo = 2808.95;
380    ap = 3.0;
381    zp = 1.0;
382  }
383 
384  if(calincl->f[6] == 8.0) { // He3
385    mprojo = 2808.42;
386    ap = 3.0;
387    zp = 2.0;
388  }
389
390  if(calincl->f[6] == 9.0) { // Alpha
391    mprojo = 3727.42;
392    ap = 4.0;
393    zp = 2.0;
394  }
395
396  pbeam = std::sqrt(calincl->f[2]*(calincl->f[2] + 2.0*mprojo));         
397
398  G4double at = calincl->f[0];
399       
400  calincl->f[3] = 0.0;    // seuil sortie proton
401  calincl->f[7] = 0.0;    // seuil sortie neutron
402
403  G4int ibert = 1;
404
405  G4int nopart = 0;
406  G4int izrem = 0;
407  G4int iarem = 0;
408  G4double esrem = 0.0;
409  G4double erecrem = 0.0;
410  G4double berem = 0.0;
411  G4double garem = 0.0;
412  G4double bimpac = 0.0;
413  G4int jrem = 0;
414  G4double alrem = 0.0;
415
416  /**
417   * Coulomb barrier treatment.
418   */
419  G4double probaTrans = 0.0;
420  G4double rndm = 0.0;
421  if((calincl->f[6] == 1.0) || (calincl->f[6] >= 6.0)) {
422    probaTrans = coulombTransm(calincl->f[2],ap,zp,calincl->f[0],calincl->f[1]);
423    standardRandom(&rndm, &(hazard->ial));
424    if(rndm <= (1.0 - probaTrans)) {
425      varntp->ntrack = -1;
426      return;
427    }
428  }
429
430  /**
431   * Call the actual INCL routine.
432   */
433  pnu(&ibert, &nopart,&izrem,&iarem,&esrem,&erecrem,&alrem,&berem,&garem,&bimpac,&jrem);
434  forceAbsor(&nopart, &iarem, &izrem, &esrem, &erecrem, &alrem, &berem, &garem, &jrem);
435  G4double aprf = double(iarem); // mass number of the prefragment
436  G4double jprf = 0.0;           // angular momentum of the prefragment
437
438  // Mean angular momentum of prefragment.                                 
439  jprf = 0.165 * std::pow(at,(2.0/3.0)) * aprf * (at - aprf) / (at - 1.0);                               
440  if (jprf < 0) {
441    jprf = 0.0;
442  }
443
444  // Reference M. de Jong, Ignatyuk, Schmidt Nuc. Phys A 613, p442, 7th line
445  jprf = std::sqrt(2*jprf);
446  jprf = jrem;
447  varntp->jremn = jrem; // Copy jrem to output tuple.
448
449  G4double numpi = 0;  // Number  of pions.
450  G4double multn = 0;  // Number (multiplicity) of neutrons.
451  G4double multp = 0;  // Number (multiplicity) of protons.
452
453  // Ecriture dans le ntuple des particules de cascade (sauf remnant).     
454  varntp->ntrack = nopart; // Nombre de particules pour ce tir.
455  varntp->massini = iarem;
456  varntp->mzini = izrem;
457  varntp->exini = esrem;
458  varntp->bimpact = bimpac;
459 
460  /**
461   * Three ways to compute the mass of the remnant:
462   * -from the output of the cascade and the canonic mass
463   * -from energy balance (input - all emitted energies)
464   * -following the approximations of the cugnon code (esrem...)
465   */
466  G4double f0 = calincl->f[0];
467  G4double f1 = calincl->f[1];
468  G4double f2 = calincl->f[2];
469  G4double mcorem = mprojo + f2 + abla->pace2(f0, f1) + f0 * uma - f1 * melec;
470
471  G4double pxbil = 0.0;
472  G4double pybil = 0.0;
473  G4double pzbil = 0.0;         
474
475  if(nopart > -1) {
476    for(G4int j = 0; j < nopart; j++) {
477      varntp->itypcasc[j] = 1;
478      // kind(): 1=proton, 2=neutron, 3=pi+, 4=pi0, 5=pi -     
479      if(kind[j] == 1) { 
480        varntp->avv[j] = 1;
481        varntp->zvv[j] = 1;
482        varntp->plab[j] = std::sqrt(ep[j] * (ep[j] + 1876.5592)); // cugnon
483        multp = multp + 1;
484        mcorem = mcorem - ep[j] - 938.27231;
485        if(verboseLevel > 3) {
486          G4cout <<"G4Incl: Proton produced! " << G4endl;
487          G4cout <<"G4Incl: Momentum: "<< varntp->plab[j] << G4endl;
488        }
489      }
490
491      if(kind[j] == 2) { 
492        varntp->avv[j] = 1;
493        varntp->zvv[j] = 0;
494        varntp->plab[j] = std::sqrt(ep[j]*(ep[j]+1876.5592)); // cugnon
495        //varntp->plab[j] = std::sqrt(ep[j] * (ep[j] + 1879.13126)); // PK mass check
496        multn = multn + 1;
497        mcorem = mcorem - ep[j] - 939.56563;
498        if(verboseLevel > 3) {
499          G4cout <<"G4Incl: Neutron produced! " << G4endl;
500          G4cout <<"G4Incl: Momentum: "<< varntp->plab[j] << G4endl;
501        }
502      }
503
504      if(kind[j] == 3) { 
505        varntp->avv[j] = -1;
506        varntp->zvv[j] = 1;
507        varntp->plab[j] = std::sqrt(ep[j]*(ep[j]+276.0)); // cugnon
508        numpi = numpi + 1;
509        mcorem = mcorem - ep[j] - 139.56995;
510        if(verboseLevel > 3) {
511          G4cout <<"G4Incl: Pi+ produced! " << G4endl;
512          G4cout <<"G4Incl: Momentum: "<< varntp->plab[j] << G4endl;
513        }
514      }
515
516      if(kind[j] == 4) { 
517        varntp->avv[j] = -1;
518        varntp->zvv[j] = 0;
519        varntp->plab[j] = std::sqrt(ep[j]*(ep[j]+276.0)); // cugnon
520        numpi = numpi + 1;
521        mcorem = mcorem - ep[j] - 134.9764;
522        if(verboseLevel > 3) {
523          G4cout <<"G4Incl: Pi0 produced! " << G4endl;
524          G4cout <<"G4Incl: Momentum: "<< varntp->plab[j] << G4endl;
525        }
526      }
527
528      if(kind[j] == 5) { 
529        varntp->avv[j] = -1;
530        varntp->zvv[j] = -1;
531        varntp->plab[j] = std::sqrt(ep[j]*(ep[j]+276.0)); // cugnon
532        numpi = numpi + 1;
533        mcorem = mcorem - ep[j] - 139.56995;
534        if(verboseLevel > 3) {
535          G4cout <<"G4Incl: Pi+ produced! " << G4endl;
536          G4cout <<"G4Incl: Momentum: "<< varntp->plab[j] << G4endl;
537        }
538      }
539
540      if(kind[j] == 6) { 
541        varntp->avv[j] = 2;
542        varntp->zvv[j] = 1;
543        varntp->plab[j] = std::sqrt(ep[j]*(ep[j] + 2.0*1874.34)); // cugnon
544        numpi = numpi + 1;
545        mcorem = mcorem - ep[j] - 2806.359;
546        if(verboseLevel > 3) {
547          G4cout <<"G4Incl: Deuteron produced! " << G4endl;
548          G4cout <<"G4Incl: Momentum: "<< varntp->plab[j] << G4endl;
549        }
550      }
551
552      if(kind[j] == 7) { 
553        varntp->avv[j] = 3;
554        varntp->zvv[j] = 1;
555        varntp->plab[j] = std::sqrt(ep[j]*(ep[j] + 2.0*2806.359)); // cugnon
556        numpi = numpi + 1;
557        mcorem = mcorem - ep[j] - 2806.359;
558        if(verboseLevel > 3) {
559          G4cout <<"G4Incl: Triton produced! " << G4endl;
560          G4cout <<"G4Incl: Momentum: "<< varntp->plab[j] << G4endl;
561        }
562      }
563
564      if(kind[j] == 8) { 
565        varntp->avv[j] = 3;
566        varntp->zvv[j] = 2;
567        varntp->plab[j] = std::sqrt(ep[j]*(ep[j] + 2.0*2807.119)); // cugnon
568        numpi = numpi + 1;
569        mcorem = mcorem - ep[j] - 2807.119;
570        if(verboseLevel > 3) {
571          G4cout <<"G4Incl: He3 produced! " << G4endl;
572          G4cout <<"G4Incl: Momentum: "<< varntp->plab[j] << G4endl;
573        }
574      }
575
576      if(kind[j] == 9) { 
577        varntp->avv[j] = 4;
578        varntp->zvv[j] = 2;
579        varntp->plab[j] = std::sqrt(ep[j]*(ep[j] + 2.0*3724.818)); // cugnon
580        numpi = numpi + 1;
581        mcorem = mcorem - ep[j] - 3724.818;
582        if(verboseLevel > 3) {
583          G4cout <<"G4Incl: He4 produced! " << G4endl;
584          G4cout <<"G4Incl: Momentum: "<< varntp->plab[j] << G4endl;
585        }
586      }
587
588      varntp->enerj[j] = ep[j];
589      varntp->tetlab[j] = 180.0*std::acos(gam[j])/3.141592654;
590      varntp->philab[j] = 180.0*std::atan2(beta[j],alpha[j])/3.141592654;
591      pxbil = pxbil + varntp->plab[j]*alpha[j];
592      pybil = pybil + varntp->plab[j]*beta[j];
593      pzbil = pzbil + varntp->plab[j]*gam[j];
594
595      if(verboseLevel > 3) {
596        G4cout <<"Momentum: " << varntp->plab[j] << G4endl;
597        G4cout <<"Theta: " << varntp->tetlab[j] << G4endl;
598        G4cout <<"Phi: " << varntp->philab[j] << G4endl;
599      }
600    }
601
602    // calcul de la masse (impulsion) du remnant coherente avec la conservation d'energie:
603    pcorem=std::sqrt(erecrem*(erecrem +2.*938.2796*iarem));   // cugnon
604    mcorem = 938.2796*iarem;                               // cugnon
605               
606    // Note: Il faut negliger l'energie d'excitation (ESREM) pour que le bilan
607    // d'impulsion soit correct a la sortie de la cascade.....et prendre la
608    // masse MCOREM comme ci-dessus (fausse de ~1GeV par rapport aux tables...)       
609    pxrem=pcorem*alrem;
610    pyrem=pcorem*berem;
611    pzrem=pcorem*garem;
612       
613    pxbil=pxbil+pxrem;
614    pybil=pybil+pyrem;
615    pzbil=pzbil+pzrem;
616
617    if((std::fabs(pzbil-pbeam) > 5.0) || (std::sqrt(std::pow(pxbil,2)+std::pow(pybil,2)) >= 3.0)) {
618      if(verboseLevel > 3) {
619        G4cout <<"bad momentum conservation after incl:" << G4endl;
620      }
621    }
622       
623    volant->iv = 0;   // init du compteur des part evaporees
624    varntp->kfis = 0;  //drapeau de fission copie dans le ntuple
625    varntp->estfis = 0.0;
626    varntp->izfis = 0;
627    varntp->iafis = 0;
628
629    //  varntp->ntrack = varntp->ntrack + 1;  // on recopie le remnant dans le ntuple
630    varntp->massini = iarem;
631    varntp->mzini = izrem;
632    varntp->exini = esrem;
633    varntp->itypcasc[varntp->ntrack] = 1;
634    varntp->avv[varntp->ntrack] = iarem;
635    varntp->zvv[varntp->ntrack]= izrem;
636    varntp->plab[varntp->ntrack] = pcorem;
637    varntp->enerj[varntp->ntrack] = std::sqrt(std::pow(pcorem,2) + std::pow(mcorem,2)) - mcorem;
638    varntp->tetlab[varntp->ntrack] = 180.0*std::acos(garem)/3.141592654;
639    varntp->philab[varntp->ntrack] = 180.0*std::atan2(berem,alrem)/3.141592654;
640    varntp->ntrack++;
641    varntp->mulncasc = varntp->ntrack;
642    varntp->mulnevap = 0;
643    varntp->mulntot = varntp->mulncasc + varntp->mulnevap;
644    if(verboseLevel > 3) {
645      G4cout <<"G4Incl: Returning nucleus fragment. " << G4endl;
646      G4cout <<"G4Incl: Fragment A = " << varntp->avv[varntp->ntrack] << " Z = " << varntp->zvv[varntp->ntrack] << G4endl;
647      G4cout <<"Energy: " << varntp->enerj[varntp->ntrack] << G4endl;
648      G4cout <<"Momentum: " << varntp->plab[varntp->ntrack] << G4endl;
649      G4cout <<"Theta: " << varntp->tetlab[varntp->ntrack] << G4endl;
650      G4cout <<"Phi: " << varntp->philab[varntp->ntrack] << G4endl;
651    }
652  }
653  else {
654    if(nopart == -2) {
655      varntp->ntrack = -2; //FIX: Error flag to remove events containing unphysical events (Ekin > Ebullet).
656    }
657    else {
658      varntp->ntrack = -1;
659    }
660  }
661}
662
663
664void G4Incl::processEventInclAbla(G4int eventnumber)
665{
666  const G4double uma = 931.4942;
667  const G4double melec = 0.511;
668
669  G4double pcorem = 0.0;
670  G4double pxrem = 0.0;
671  G4double pyrem = 0.0;
672  G4double pzrem = 0.0;
673
674  G4double ap = 0.0, zp = 0.0, mprojo = 0.0, pbeam = 0.0;
675
676  varntp->clear();
677
678  // pi+
679  if(calincl->f[6] == 3.0) { 
680    mprojo = 139.56995;
681    ap = 0.0;
682    zp = 1.0;
683  }
684
685  // pi0
686  if(calincl->f[6] == 4.0) {
687    mprojo = 134.9764;
688    ap = 0.0;
689    zp = 0.0;
690  }
691
692  // pi-
693  if(calincl->f[6] == 5.0) {
694    mprojo = 139.56995;
695    ap = 0.0;
696    zp = -1.0;
697  }
698
699  // coulomb en entree seulement pour les particules ci-dessous
700
701  // proton
702  if(calincl->f[6] == 1.0) {
703    mprojo = 938.27231;
704    ap = 1.0;
705    zp = 1.0;
706  }
707
708  // neutron 
709  if(calincl->f[6] == 2.0) {
710    mprojo = 939.56563;
711    ap = 1.0;
712    zp = 0.0;
713  }
714
715  // deuteron
716  if(calincl->f[6] == 6.0) {
717    mprojo = 1875.61276;
718    ap = 2.0;
719    zp = 1.0;
720  }
721
722  // triton
723  if(calincl->f[6] == 7.0) {
724    mprojo = 2808.95;
725    ap = 3.0;
726    zp = 1.0;
727  }
728
729  // He3
730  if(calincl->f[6] == 8.0) {
731    mprojo = 2808.42;
732    ap = 3.0;
733    zp = 2.0;
734  }
735
736  // Alpha
737  if(calincl->f[6] == 9.0) {
738    mprojo = 3727.42;
739    ap = 4.0;
740    zp = 2.0;
741  }
742
743  pbeam = std::sqrt(calincl->f[2]*(calincl->f[2] + 2.0*mprojo));         
744
745  G4double at = calincl->f[0];
746       
747  calincl->f[3] = 0.0;    //     !seuil sortie proton
748  calincl->f[7] = 0.0;  //       !seuil sortie neutron
749
750  G4int ibert = 1;
751
752  G4int nopart = 0;
753  G4int izrem = 0;
754  G4int iarem = 0;
755  G4double esrem = 0.0;
756  G4double erecrem = 0.0;
757  G4double berem = 0.0;
758  G4double garem = 0.0;
759  G4double bimpac = 0.0;
760  G4int jrem = 0;
761  G4double alrem = 0.0;
762
763  // Coulomb barrier
764 
765  G4double probaTrans = 0.0;
766  G4double rndm = 0.0;
767
768  if((calincl->f[6] == 1.0) || (calincl->f[6] >= 6.0)) {
769    //    probaTrans = coulombTransm(calincl->f[2],apro,zpro,calincl->f[0],calincl->f[1]);
770    probaTrans = coulombTransm(calincl->f[2],ap,zp,calincl->f[0],calincl->f[1]);
771    standardRandom(&rndm, &(hazard->ial));
772    if(rndm <= (1.0 - probaTrans)) {
773      varntp->ntrack = -1;
774      return;
775    }
776  }
777
778  // Call the actual INCL routine:
779  pnu(&ibert, &nopart,&izrem,&iarem,&esrem,&erecrem,&alrem,&berem,&garem,&bimpac,&jrem);
780//   nopart=1;
781//   kind[0]=1;
782//   ep[0]=799.835;
783//   alpha[0]=0.08716;
784//   beta[0]=0.;
785//   gam[0]=0.99619;
786//   izrem=82;
787//   iarem=208;
788//   esrem=200.;
789//   erecrem=0.18870;
790//   alrem=-0.47101;
791//   berem=0.;
792//   garem=0.88213;
793//   bimpac=2.;
794  forceAbsor(&nopart, &iarem, &izrem, &esrem, &erecrem, &alrem, &berem, &garem, &jrem);
795  G4double aprf = double(iarem);    // mass number of the prefragment
796  G4double jprf = 0.0;                // angular momentum of the prefragment
797
798  // Mean angular momentum of prefragment                                 
799  jprf = 0.165 * std::pow(at,(2.0/3.0)) * aprf*(at - aprf)/(at - 1.0);                               
800  if (jprf < 0) {
801    jprf = 0.0;
802  }
803
804  // check m.de jong, ignatyuk, schmidt nuc.phys a 613, pg442, 7th line
805  jprf = std::sqrt(2*jprf);
806
807  jprf = jrem;
808  varntp->jremn = jrem;      // jrem copie dans le ntuple
809
810  G4double numpi = 0;  // compteurs de pions, neutrons protons
811  G4double multn = 0; 
812  G4double multp = 0;
813
814  // ecriture dans le ntuple des particules de cascade (sauf remnant)     
815  varntp->ntrack = nopart;          // nombre de particules pour ce tir
816  if(varntp->ntrack >= VARNTPSIZE) {
817    if(verboseLevel > 2) {
818      G4cout <<"G4Incl error: Output data structure not big enough." << G4endl;
819    }
820  }
821  varntp->massini = iarem;
822  varntp->mzini = izrem;
823  varntp->exini = esrem;
824  varntp->bimpact = bimpac;
825 
826  //  three ways to compute the mass of the remnant:
827  //                -from the output of the cascade and the canonic mass
828  //                -from energy balance (input - all emitted energies)
829  //                -following the approximations of the cugnon code (esrem...)
830  G4double mcorem = mprojo + calincl->f[2] + abla->pace2(double(calincl->f[0]),double(calincl->f[1]))
831    + calincl->f[0]*uma - calincl->f[1]*melec;
832
833  G4double pxbil = 0.0;
834  G4double pybil = 0.0;
835  G4double pzbil = 0.0;         
836
837  if(nopart > -1) {
838    for(G4int j = 0; j < nopart; j++) {
839      varntp->itypcasc[j] = 1;
840      // kind(): 1=proton, 2=neutron, 3=pi+, 4=pi0, 5=pi -     
841      if(kind[j] == 1) { 
842        varntp->avv[j] = 1;
843        varntp->zvv[j] = 1;
844        varntp->plab[j] = std::sqrt(ep[j]*(ep[j]+1876.5592)); // cugnon
845        multp = multp + 1;
846        mcorem = mcorem - ep[j] - 938.27231;
847        if(verboseLevel > 3) {
848          G4cout <<"G4Incl: Proton produced! " << G4endl;
849          G4cout <<"G4Incl: Momentum: "<< varntp->plab[j] << G4endl;
850        }
851      }
852
853      if(kind[j] == 2) { 
854        varntp->avv[j] = 1;
855        varntp->zvv[j] = 0;
856        varntp->plab[j] = std::sqrt(ep[j]*(ep[j]+1876.5592)); // cugnon
857        multn = multn + 1;
858        mcorem = mcorem - ep[j] - 939.56563;
859        if(verboseLevel > 3) {
860          G4cout <<"G4Incl: Neutron produced! " << G4endl;
861          G4cout <<"G4Incl: Momentum: "<< varntp->plab[j] << G4endl;
862        }
863      }
864     
865      if(kind[j] == 3) { 
866        varntp->avv[j] = -1;
867        varntp->zvv[j] = 1;
868        varntp->plab[j] = std::sqrt(ep[j]*(ep[j]+276.0)); // cugnon
869        numpi = numpi + 1;
870        mcorem = mcorem - ep[j] - 139.56995;
871        if(verboseLevel > 3) {
872          G4cout <<"G4Incl: Pi+ produced! " << G4endl;
873          G4cout <<"G4Incl: Momentum: "<< varntp->plab[j] << G4endl;
874        }
875      }
876
877      if(kind[j] == 4) { 
878        varntp->avv[j] = -1;
879        varntp->zvv[j] = 0;
880        varntp->plab[j] = std::sqrt(ep[j]*(ep[j]+276.0)); // cugnon
881        numpi = numpi + 1;
882        mcorem = mcorem - ep[j] - 134.9764;
883        if(verboseLevel > 3) {
884          G4cout <<"G4Incl: Pi0 produced! " << G4endl;
885          G4cout <<"G4Incl: Momentum: "<< varntp->plab[j] << G4endl;
886        }
887      }
888
889      if(kind[j] == 5) { 
890        varntp->avv[j] = -1;
891        varntp->zvv[j] = -1;
892        varntp->plab[j] = std::sqrt(ep[j]*(ep[j]+276.0)); // cugnon
893        numpi = numpi + 1;
894        mcorem = mcorem - ep[j] - 139.56995;
895        if(verboseLevel > 3) {
896          G4cout <<"G4Incl: Pi+ produced! " << G4endl;
897          G4cout <<"G4Incl: Momentum: "<< varntp->plab[j] << G4endl;
898        }
899      }
900
901      if(kind[j] == 6) { 
902        varntp->avv[j] = 2;
903        varntp->zvv[j] = 1;
904        varntp->plab[j] = std::sqrt(ep[j]*(ep[j] + 2.0*1874.34)); // cugnon
905        numpi = numpi + 1;
906        mcorem = mcorem - ep[j] - 2806.359;
907        if(verboseLevel > 3) {
908          G4cout <<"G4Incl: Deuteron produced! " << G4endl;
909          G4cout <<"G4Incl: Momentum: "<< varntp->plab[j] << G4endl;
910        }
911      }
912
913      if(kind[j] == 7) { 
914        varntp->avv[j] = 3;
915        varntp->zvv[j] = 1;
916        varntp->plab[j] = std::sqrt(ep[j]*(ep[j] + 2.0*2806.359)); // cugnon
917        numpi = numpi + 1;
918        mcorem = mcorem - ep[j] - 2806.359;
919        if(verboseLevel > 3) {
920          G4cout <<"G4Incl: Triton produced! " << G4endl;
921          G4cout <<"G4Incl: Momentum: "<< varntp->plab[j] << G4endl;
922        }
923      }
924
925      if(kind[j] == 8) { 
926        varntp->avv[j] = 3;
927        varntp->zvv[j] = 2;
928        varntp->plab[j] = std::sqrt(ep[j]*(ep[j] + 2.0*2807.119)); // cugnon
929        numpi = numpi + 1;
930        mcorem = mcorem - ep[j] - 2807.119;
931        if(verboseLevel > 3) {
932          G4cout <<"G4Incl: He3 produced! " << G4endl;
933          G4cout <<"G4Incl: Momentum: "<< varntp->plab[j] << G4endl;
934        }
935      }
936
937      if(kind[j] == 9) { 
938        varntp->avv[j] = 4;
939        varntp->zvv[j] = 2;
940        varntp->plab[j] = std::sqrt(ep[j]*(ep[j] + 2.0*3724.818)); // cugnon
941        numpi = numpi + 1;
942        mcorem = mcorem - ep[j] - 3724.818;
943        if(verboseLevel > 3) {
944          G4cout <<"G4Incl: He3 produced! " << G4endl;
945          G4cout <<"G4Incl: Momentum: "<< varntp->plab[j] << G4endl;
946        }
947      }
948
949      varntp->enerj[j] = ep[j];
950      varntp->tetlab[j] = 180.0*std::acos(gam[j])/3.141592654;
951      varntp->philab[j] = 180.0*std::atan2(beta[j],alpha[j])/3.141592654;
952      pxbil = pxbil + varntp->plab[j]*alpha[j];
953      pybil = pybil + varntp->plab[j]*beta[j];
954      pzbil = pzbil + varntp->plab[j]*gam[j];
955
956      if(verboseLevel > 3) {
957        G4cout <<"Momentum: " << varntp->plab[j]   << G4endl;
958        G4cout <<"Theta: "    << varntp->tetlab[j] << G4endl;
959        G4cout <<"Phi: "      << varntp->philab[j] << G4endl;
960      }
961    }
962
963    // calcul de la masse (impulsion) du remnant coherente avec la conservation d'energie:
964    pcorem = std::sqrt(erecrem*(erecrem + 2.0 * 938.2796 * iarem));   // cugnon
965    mcorem = 938.2796 * iarem;                               // cugnon
966    varntp->pcorem = pcorem;
967    varntp->mcorem = mcorem;
968    // Note: Il faut negliger l'energie d'excitation (ESREM) pour que le bilan
969    // d'impulsion soit correct a la sortie de la cascade.....et prendre la
970    // masse MCOREM comme ci-dessus (fausse de ~1GeV par rapport aux tables...)       
971    pxrem = pcorem * alrem;
972    pyrem = pcorem * berem;
973    pzrem = pcorem * garem;
974    varntp->pxrem = pxrem;
975    varntp->pyrem = pyrem;
976    varntp->pzrem = pzrem;
977    pxbil = pxbil + pxrem;
978    pybil = pybil + pyrem;
979    pzbil = pzbil + pzrem;
980
981    if((std::fabs(pzbil - pbeam) > 5.0) || (std::sqrt(std::pow(pxbil,2) + std::pow(pybil,2)) >= 3.0)) {
982      if(verboseLevel > 3) {
983        G4cout <<"bad momentum conservation after incl:" << G4endl;
984      }
985    }
986       
987    volant->iv = 0;   // init du compteur des part evaporees
988    varntp->kfis = 0;  //drapeau de fission copie dans le ntuple
989    varntp->estfis = 0.0;
990    varntp->izfis = 0;
991    varntp->iafis = 0;
992
993    // on recopie le remnant dans le ntuple
994    // varntp->ntrack = varntp->ntrack + 1;
995    varntp->massini = iarem;
996    varntp->mzini = izrem;
997    varntp->exini = esrem;
998
999    if(verboseLevel > 2) {
1000      G4cout << __FILE__ << ":" << __LINE__ << "Dump varntp after cascade: " << G4endl;
1001      varntp->dump();
1002    }
1003    // Evaporation/fission:
1004    evaporationResult->ntrack = 0;
1005    abla->breakItUp(varntp->massini, varntp->mzini, mcorem, varntp->exini, varntp->jremn,
1006                    erecrem, pxrem, pyrem, pzrem, eventnumber);
1007
1008    if(verboseLevel > 2) {
1009      G4cout << __FILE__ << ":" << __LINE__ << "Dump evaporationResult after evaporation: " << G4endl;
1010      evaporationResult->dump();
1011    }
1012    for(G4int evaporatedParticle = 0; evaporatedParticle < evaporationResult->ntrack; evaporatedParticle++) {
1013      if(evaporationResult->avv[evaporatedParticle] == 0 && evaporationResult->zvv[evaporatedParticle] == 0) { //Fix: Skip "empty" particles with A = 0 and Z = 0
1014        // continue;
1015      }
1016      varntp->kfis = evaporationResult->kfis;
1017      varntp->itypcasc[varntp->ntrack] = evaporationResult->itypcasc[evaporatedParticle];
1018      varntp->avv[varntp->ntrack] = evaporationResult->avv[evaporatedParticle];
1019      varntp->zvv[varntp->ntrack]= evaporationResult->zvv[evaporatedParticle];
1020      varntp->plab[varntp->ntrack] = evaporationResult->plab[evaporatedParticle];
1021      varntp->enerj[varntp->ntrack] = evaporationResult->enerj[evaporatedParticle];
1022      varntp->tetlab[varntp->ntrack] = evaporationResult->tetlab[evaporatedParticle];
1023      varntp->philab[varntp->ntrack] = evaporationResult->philab[evaporatedParticle];
1024      varntp->ntrack++;
1025      if(verboseLevel > 3) {
1026        G4cout <<"G4Incl: Returning evaporation result"           << G4endl;
1027        G4cout <<"G4Incl: A = " << varntp->avv[varntp->ntrack]    << " Z = " << varntp->zvv[varntp->ntrack] << G4endl;
1028        G4cout <<"Energy: "     << varntp->enerj[varntp->ntrack]  << G4endl;
1029        G4cout <<"Momentum: "   << varntp->plab[varntp->ntrack]   << G4endl;
1030        G4cout <<"Theta: "      << varntp->tetlab[varntp->ntrack] << G4endl;
1031        G4cout <<"Phi: "        << varntp->philab[varntp->ntrack] << G4endl;
1032      }
1033    }
1034    if(verboseLevel > 2) {
1035      G4cout <<"G4Incl: ntrack = "          << varntp->ntrack << G4endl;
1036      G4cout <<"G4Incl: Done extracting..." << G4endl;
1037    }
1038  }
1039  if(nopart == -2) {
1040    varntp->ntrack = -2; //FIX: Error flag to remove events containing unphysical events (Ekin > Ebullet).
1041    evaporationResult->ntrack = -2; //FIX: Error flag to remove events containing unphysical events (Ekin > Ebullet).
1042  }
1043  else if(nopart == -1) {
1044    varntp->ntrack = -1;
1045    evaporationResult->ntrack = -1;
1046  }
1047  if(verboseLevel > 2) {
1048    G4cout << __FILE__ << ":" << __LINE__ << "Dump varntp after combining: " << G4endl;
1049    varntp->dump();
1050  }
1051}
1052
1053// Initialization routines
1054void G4Incl::initIncl(G4bool initRandomSeed)
1055{
1056  // Subroutine for initialisation of intranuclear cascade incl
1057  //
1058  // this will  read some specific parameters for incl,
1059  // prepare the saxon-wood density for each nucleus
1060  // compute the deuteron momentum space density from paris pot.
1061  // print some global informations
1062  //
1063  // input: should contain z and a for nbmat nucleus considered in this problem
1064  //
1065  // input: should contain a seed (ial, odd and of 5 digits) to start the work.     
1066
1067  G4double xrand = 0.0;
1068  G4double ialdep = 0.0;
1069  G4int imat = 0;
1070  G4int iamat = 0, izmat = 0;
1071
1072  // for the 19 secondary seeds of hazard:
1073  G4int nbtirhaz[IGRAINESIZE] = {38,82,76,18,39,31,41,59,26,54,
1074                                 14,84,13,15,91,89,10,6,52};
1075
1076  // specific parameters for incl:       
1077  // espace de phases test (r et p) pour pauli:
1078  // valeur recommandee par j.c. v-test=0.592 h**3:
1079  G4double rbl = 2.;
1080
1081  // valeur pour avoir v-test=2 h**3 (avec pbl=200)
1082  rbl = 3.1848;
1083
1084  // preparation of 19 other seeds (can also be initialized from outside):
1085  if(initRandomSeed) {
1086    ialdep=hazard->ial;
1087    for(G4int i = 0; i < IGRAINESIZE; i++) {
1088      for(G4int j = 0; j < nbtirhaz[i]; j++) {
1089        standardRandom(&xrand,&(hazard->ial));
1090      }
1091
1092      // Zero is not accepted as random seed!
1093      do {
1094        standardRandom(&xrand,&(hazard->ial));
1095      } while(xrand == 0);
1096
1097      xrand = xrand * 100000;
1098
1099      while(xrand < 10000) {
1100        xrand = xrand * 10;
1101      }
1102      hazard->igraine[i] = (int) xrand;
1103      if(hazard->igraine[i] == ((hazard->igraine[i] / 2) * 2)) {
1104        hazard->igraine[i] = hazard->igraine[i] + 1;
1105      }
1106    }
1107
1108    hazard->ial = int(ialdep);
1109  }
1110
1111  // calculation with realistic nuclear density (saxon-wood)
1112  if (ws->nosurf <= 0) {
1113    // prepare nucleus density for nbmat nucleus defined in struct mat
1114    if(mat->nbmat >= 500) {
1115      if(verboseLevel > 2) {
1116        G4cout <<"You need " << mat->nbmat << " nuclei in your problem. The maximum number of nuclei is 500 " << G4endl;
1117      }
1118      return;
1119    }
1120
1121    for(G4int i = 0; i < mat->nbmat; i++) {
1122      imat = i;
1123      izmat = int(mat->zmat[i]);
1124      iamat = int(mat->amat[i]);
1125
1126      initMaterial(izmat, iamat, imat);
1127    }
1128  }
1129
1130  // deuteron density in momentum space:
1131  densDeut();
1132}
1133
1134
1135void G4Incl::initMaterial(G4int izmat, G4int iamat, G4int imat)
1136{
1137  G4double res_dws = 0.0;
1138  G4double fnor = 0.0;
1139
1140  G4double rcour = 0.0, geom = 0.0;
1141  G4int nbr = 0;
1142
1143  G4double step = 0.0, f_r = 0.0;
1144
1145  // rms espace r, espace p, fermi momentum and energy for light gauss nuc.     
1146  const G4double datarms1t[LGNSIZE] = {0.0, 0.0, 0.0, 0.0, 0.0, 2.10, 1.80, 1.80, 1.63};
1147  const G4double datapf1t[LGNSIZE] = {0.0, 0.0, 0.0, 0.0, 0.0, 77.0, 110.0, 110.0, 153.0};
1148
1149  for(G4int i = 0; i < LGNSIZE; i++) {
1150    light_gaus_nuc->rms1t[i] = datarms1t[i];
1151    light_gaus_nuc->pf1t[i] = datapf1t[i];
1152  }
1153
1154  // fermi 2 param from a=19 to 28, modified harm oscil a=6 to 18
1155  // (h. de vries et al. at. data and nuc. data tab. 36 (1987) 495)
1156  const G4double datarln[LNSIZE] = {0.0,0.0,0.0,0.0,0.0,0.334,0.327,0.479,0.631,0.838,
1157                                    0.811,1.07,1.403,1.335,1.25,1.544,1.498,1.513,
1158                                    2.58,2.77, 2.775,2.78,2.88,2.98,3.22,3.03,2.84,
1159                                    3.14,0.0,0.0};
1160
1161  const G4double dataaln[LNSIZE] = {0.0,0.0,0.0,0.0,0.0,1.78,1.77,1.77,1.77,1.71,
1162                                    1.69,1.69,1.635,1.730,1.81,1.833,1.798,
1163                                    1.841,0.567,0.571, 0.560,0.549,0.550,0.551,
1164                                    0.580,0.575,0.569,0.537,0.0,0.0};
1165
1166  for(G4int i = 0; i < LNSIZE; i++) {
1167    light_nuc->r[i] = datarln[i];
1168    light_nuc->a[i] = dataaln[i];
1169  }
1170
1171  if(verboseLevel > 3) {
1172    G4cout <<"Nuclear density for nucleus (z, a): " << izmat << " " << iamat << " " << imat << G4endl;
1173  }
1174 
1175  const G4double fmp = 938.2796; // From INCL data
1176
1177  // parametres moyens de densite de la cible (fermi 2 parametres)
1178  if (iamat >= 28) {
1179    ws->r0 = (2.745e-4*iamat+1.063)*std::pow(G4double(iamat), 0.33333333);
1180    ws->adif = 1.63e-4*iamat+0.510;
1181    ws->rmaxws = ws->r0 + (ws->xfoisa)*(ws->adif);
1182  }
1183  else if(iamat >= 19) {
1184    ws->r0 = light_nuc->r[iamat-1];
1185    ws->adif = light_nuc->a[iamat-1];
1186    ws->rmaxws = ws->r0 + (ws->xfoisa)*(ws->adif);
1187  }
1188  else if(iamat >= 6) {
1189    ws->r0 = light_nuc->r[iamat-1];
1190    ws->adif = light_nuc->a[iamat-1];
1191    ws->rmaxws = 5.5 + 0.3*(double(iamat)-6.)/12.;
1192  }
1193  else if(iamat >= 2) {
1194    if(iamat == 2) {
1195      ws->r0=light_gaus_nuc->rms1t[5]; // Orig: rms1t(6)
1196      light_gaus_nuc->pfln[5] = light_gaus_nuc->pf1t[5]*1.291;  // Orig [6], std::sqrt(5/3)=1.291
1197      light_gaus_nuc->tfln[5] = std::sqrt(std::pow(light_gaus_nuc->pfln[5],2) + fmp*fmp) - fmp;
1198      light_gaus_nuc->vnuc[5] = light_gaus_nuc->tfln[5] + 2.22;
1199      if(verboseLevel > 2) {
1200        G4cout <<"Nuclear potential: " << light_gaus_nuc->vnuc[5] << "MeV, Fermi momentum and energy: " << light_gaus_nuc->pfln[5] << " " << light_gaus_nuc->tfln[5] << G4endl;
1201      }
1202    }
1203    if(iamat == 3 && izmat == 1) {
1204      ws->r0=light_gaus_nuc->rms1t[6]; // Orig: rms1t(7)
1205      light_gaus_nuc->pfln[6] = light_gaus_nuc->pf1t[6]*1.291;  // Orig [7], std::sqrt(5/3)=1.291
1206      light_gaus_nuc->tfln[6] = std::sqrt(std::pow(light_gaus_nuc->pfln[6],2) + fmp*fmp) - fmp;
1207      light_gaus_nuc->vnuc[6] = light_gaus_nuc->tfln[6] + 4.24;
1208      if(verboseLevel > 2) {
1209        G4cout <<"Nuclear potential: " << light_gaus_nuc->vnuc[6] << "MeV, Fermi momentum and energy: " << light_gaus_nuc->pfln[6] << " " << light_gaus_nuc->tfln[6] << G4endl;
1210      }
1211    }
1212    if(iamat == 3 && izmat == 2) {
1213      ws->r0 = light_gaus_nuc->rms1t[7]; // Orig: rms1t(8)
1214      light_gaus_nuc->pfln[7] = light_gaus_nuc->pf1t[7]*1.291;   //!std::sqrt(5/3)=1.291
1215      light_gaus_nuc->tfln[7] = std::sqrt(std::pow(light_gaus_nuc->pfln[7],2) + fmp*fmp) - fmp;
1216      light_gaus_nuc->vnuc[7] = light_gaus_nuc->tfln[7] + 3.86;
1217      if(verboseLevel > 2) {
1218        G4cout <<"Nuclear potential: " << light_gaus_nuc->vnuc[7] << "MeV, Fermi momentum and energy: " << light_gaus_nuc->pfln[7] << " " << light_gaus_nuc->tfln[7] << G4endl;
1219      }
1220    }
1221    if(iamat == 4) {
1222      ws->r0 = light_gaus_nuc->rms1t[8]; // Orig: rms1t(9)
1223      light_gaus_nuc->pfln[8] = light_gaus_nuc->pf1t[8]*1.291;   // !std::sqrt(5/3)=1.291
1224      light_gaus_nuc->tfln[8] = std::sqrt(std::pow(light_gaus_nuc->pfln[8],2) + fmp*fmp) - fmp;
1225      light_gaus_nuc->vnuc[8] = light_gaus_nuc->tfln[8] + 9.43;
1226      if(verboseLevel > 2) {
1227        G4cout <<"Nuclear potential: " << light_gaus_nuc->vnuc[8] << "MeV, Fermi momentum and energy: " << light_gaus_nuc->pfln[8] << " " << light_gaus_nuc->tfln[8] << G4endl;
1228      }
1229    }
1230    ws->adif = 0.57735*ws->r0;
1231    ws->rmaxws = ws->r0 + 2.5;
1232  }
1233  ws->drws = (ws->rmaxws)/29.0;
1234
1235  // bmax for sigma geom and various projectiles (p,n,pion/d/t/he3/he4/)
1236  G4int j = 0;
1237  for(G4int i = 0; i < MATGEOSIZE; i++) { // Orig: do i=1,6
1238    j = i;
1239    if(i >= 2) {
1240      j = i + 3;
1241    }
1242    mat->bmax_geo[i][imat] = (ws->rmaxws) + (light_gaus_nuc->rms1t[j]);
1243  }
1244
1245  // preparation de la distribution w.s.:
1246  if (iamat >= 19) {
1247    G4double step = 0.2;
1248    res_dws = integrate(0.0, 13.5, step, derivWsaxFunction);
1249  }
1250  else { 
1251    // preparation de la distribution m.h.o.:
1252    if(iamat >= 6) {
1253      step=0.1;
1254      res_dws = integrate(0.0, 10.0, step, derivMhoFunction);
1255    }
1256    else {
1257      // preparation de la distribution gaussienne:
1258      //         G4double cte = std::pow(ws->adif,3)*std::sqrt(2.*3.141592654);       
1259      res_dws = 3.0*(std::pow(ws->adif, 3)*std::sqrt(2.0*3.141592654))/2.0;
1260    }
1261  }
1262  fnor = res_dws;
1263
1264  // calcul de q/pf=f(r)     
1265  nbr = int(std::floor((ws->rmaxws)/(ws->drws) + 1.5));
1266  rcour = -1*(ws->drws);
1267
1268  j = 0;
1269  for(G4int i = 0; i < nbr; i++) { // do i=1,nbr
1270    rcour = rcour + (ws->drws);
1271    if(i == 0) { // 1->0
1272      f_r = 0.0;
1273      saxw->x[j][imat] = f_r;
1274      saxw->y[j][imat] = 0.0;           //!on impose x(1)=0., y(1)=0.
1275      res_dws = 0.0;
1276    }
1277    else {
1278      step = rcour/20.;
1279      if(step >= 0.05) {
1280        step = 0.05;
1281      }
1282      if (iamat >= 19) {
1283        //integ(ws, dton, 0.,rcour,step,&derivwsax,&res_dws);
1284        res_dws = integrate(0.0, rcour, step, derivWsaxFunction);
1285        f_r = res_dws/fnor;
1286      }
1287      else { 
1288        if(iamat >= 6) {
1289          //integ(ws, dton, 0.,rcour,step,&derivmho,&res_dws);
1290          res_dws = integrate(0.0, rcour, step, derivMhoFunction);
1291          f_r = res_dws/fnor;
1292        }
1293        else { 
1294          //integ(ws, dton, 0.,rcour,step,&derivgaus,&res_dws);
1295          res_dws = integrate(0.0, rcour, step, derivGausFunction);
1296          f_r = res_dws/fnor;
1297        }
1298      }
1299      // modif le 20/10/2003; éviter les valeurs négatives avant **1/3 !
1300      //       }
1301      if(f_r >= 0.0)  {
1302        f_r = std::pow(f_r,(1./3.));
1303        saxw->x[j][imat] = f_r;
1304        saxw->y[j][imat] = rcour;
1305      }
1306    }
1307    j = j + 1;
1308  }
1309  saxw->n = j;
1310  saxw->x[j-1][imat] = 1.; // !on impose saxw->x[nbpinter-1]=1. (y=rmax)
1311
1312  // interpolation de f_inv(r) (fonction inverse de f(r))       
1313  // flin2(imat, saxw, ws);
1314  firstDerivative(imat);
1315
1316  if(verboseLevel > 3) {
1317    if(iamat >= 19) {
1318      G4cout <<"Wood-Saxon density, r0 = " << ws->r0 << " a = " << ws->adif << G4endl;
1319    }
1320    if(iamat >= 6 && iamat <= 19) {
1321      G4cout <<"Modif. harm. oscil. density, alpha = " << ws->r0 << " a = " << ws->adif << G4endl;
1322    }
1323    if(iamat >= 2 && iamat <= 6) {
1324      G4cout <<"Gaussian density, r.m.s = " << ws->r0 << " sigma = " << ws->adif << G4endl;
1325    }
1326  }
1327 
1328  geom = 31.41592653*std::pow(ws->rmaxws,2);
1329
1330  if(verboseLevel > 3) {
1331    G4cout <<"For incident nucleons or pions rmax = " << ws->rmaxws << " and geometrical (pi*rmaxws*rmaxws) reaction cross section (mb) is " << geom << G4endl;
1332    for(G4int k = 2; k < MATGEOSIZE; k++) {
1333      G4cout << "Rmaxws for d/t/3he/4he = " << mat->bmax_geo[k][imat] << G4endl;
1334    }
1335
1336    G4cout <<"Exact calculation of the r(q) function for the target nucleus density q/pf  r(q/pf)" << G4endl;
1337  }
1338}
1339
1340G4double G4Incl::deutv(G4int l, G4double q)
1341{
1342  G4double res = 0.0;
1343
1344  if (l == 0) {
1345    for(G4int i = 0; i < DTONSIZE; i++) {
1346      res = res + dton->c[i]/(std::pow(q,2) + fm2(i+1));
1347    }
1348  }
1349  if(l != 0) {
1350    for(G4int i = 0; i < DTONSIZE; i++) { 
1351      res = res + dton->d[i]/(std::pow(q,2) + fm2(i+1));
1352    }
1353  }
1354
1355  return res*std::sqrt(2./CLHEP::pi)*dton->fn; // See G4InclDataDefs.hh
1356}
1357
1358G4double G4Incl::fm2(G4int j)
1359{
1360  /**
1361   * In implementation Returns the values of the function:
1362   * \f[
1363   * (0.23162461 + (j - 1))^2
1364   * \f]
1365   * @param j an integer parameter
1366   * @return a double value
1367   */
1368 
1369  return std::pow((0.23162461 + (j - 1)),2);
1370}
1371
1372G4double G4Incl::interpolateFunction(G4double xv)
1373{
1374  // fonction d'interpolation au point xv ( meme hors bornes )             
1375  // de la fn x->y dont les derivees premieres (s) ont ete                 
1376  // evaluees par l'appel prealable de flin2                             
1377  // les indices vont de 1 a n
1378
1379  saxw->k = saxw->imat;
1380  G4double tz = xv - saxw->x[0][saxw->imat];
1381  G4int j = 0;
1382   
1383  if(tz < 0) {
1384    return (saxw->y[0][saxw->imat] + saxw->s[0][saxw->imat]*tz);
1385  }
1386  else if(tz == 0) {
1387    return (saxw->y[0][saxw->imat]);
1388  }
1389  else {
1390    for(G4int i = 1; i < saxw->n; i++) {
1391      j = i - 1;
1392      tz = xv - saxw->x[j][saxw->imat];
1393      if(tz < 0) {
1394        break;
1395      }
1396      else if(tz == 0) {
1397        return saxw->y[j][saxw->imat];
1398      }
1399    }
1400  }
1401
1402  G4double dgx = xv - saxw->x[j][saxw->imat];
1403  return(saxw->y[j][saxw->imat] + saxw->s[j][saxw->imat]*dgx);
1404}
1405
1406void G4Incl::firstDerivative(G4int k)
1407{
1408  for(G4int i=0; i < saxw->n-1; i++) {
1409    saxw->s[i][k] = (saxw->y[i+1][k] - saxw->y[i][k]) / (saxw->x[i+1][k] - saxw->x[i][k]);
1410  }
1411  saxw->s[saxw->n-1][k] = saxw->s[saxw->n-2][k];
1412}
1413
1414G4double G4Incl::wsax(G4double r) {
1415  return std::pow(r,2) / (1.0+std::exp(r-(ws->r0)/(ws->adif)));
1416}
1417
1418G4double G4Incl::derivWsax(G4double r)
1419{
1420  G4double derivwsax = std::pow(r,3)*std::exp((r-(ws->r0))/(ws->adif))/std::pow((1.0+std::exp((r-(ws->r0))/(ws->adif))),2);
1421  return derivwsax/(ws->adif);
1422}
1423
1424G4double G4Incl::dmho(G4double r)
1425{
1426  G4double arg=std::pow((r/(ws->adif)),2);
1427  return r*r*(1.+(ws->r0)*arg)*std::exp(-arg);
1428}
1429
1430G4double G4Incl::derivMho(G4double r)
1431{
1432  G4double arg=std::pow((r/(ws->adif)),2);
1433  return -2.*r*r*arg*((ws->r0) -1.-(ws->r0)*arg)*std::exp(-arg);
1434}
1435
1436G4double G4Incl::derivGaus(G4double r)
1437{
1438  G4double arg=std::pow((r/(ws->adif)),2);
1439  return r*r*arg*std::exp(-arg/2.);     
1440}
1441
1442void G4Incl::densDeut()
1443{
1444  // ce subroutine appele sur le premier tir va calculer la densite du deuton
1445  // dans l'espace des impulsions et preparer l'interpolation permettant ensuite
1446  // le tir au hasard d'un module de l'impulsion (q).
1447  // ce subroutine remplit le common /spl2/:
1448  // xsp(0:1), ysp integrale normalisee de la densite de 0 a q.
1449  // a(),b(),c() coefs des nsp points pour une interpolation du second degre.
1450  // q est en fm-1.
1451
1452  //    495           dimension q(100),f(100)
1453  //    496           common/spl2/ xsp(100),ysp(100),a(100),b(100),cc(100),nbp
1454  G4double cData[DTONSIZE] = {0.88688076e+00,-0.34717093e+00,-.30502380e+01,
1455                              .56207766e+02,-.74957334e+03,.53365279e+04,-.22706863e+05,
1456                              .60434469e+05,-.10292058e+06,.11223357e+06,-.75925226e+05,
1457                              .29059715e+05,-.48157368e+04};
1458
1459  G4double dData[DTONSIZE] = {.23135193e-01,-.85604572e+00,.56068193e+01,
1460                              -.69462922e+02,.41631118e+03,-.12546621e+04,.12387830e+04,
1461                              .33739172e+04,-.13041151e+05,.19512524e+05,-.15634324e+05,
1462                              .66231089e+04,-.11698185e+04};
1463
1464  G4double fnData = 0.28212e+00;
1465
1466  for(G4int i = 0; i < DTONSIZE; i++) {
1467    dton->c[i] = cData[i];
1468    dton->d[i] = dData[i];
1469  }
1470  dton->fn = fnData;
1471
1472  //    509     c avec fn=.28212 les fo radiales suivantes sont normalisees a:          deu00470
1473  //    510     c somme(0,infini)(deut0(q)**2 + deut2(q)**2))*q*q*dq = 1./4*pi          deu00480
1474  //    511     c et ceci dans l'espace r et dans l'espace q. pd=5.74%                  deu00490
1475  //    512     cjcd
1476  //    513           common /inout/ in, io, itty, iscrt                               
1477  //    514     cjcd
1478
1479  const G4int qsize = 100;
1480  G4double q[qsize];
1481  G4double f[qsize];
1482  for(G4int init_i = 0; init_i < qsize; init_i++) {
1483    q[init_i] = 0.0;
1484    f[init_i] = 0.0;
1485  }
1486
1487  G4double dq=0.01;
1488  q[0]=0.0;
1489  for(G4int i = 1; i < 50; i++) {
1490    q[i] = q[i-1] + dq;
1491    f[i] = 0.0;
1492  }
1493
1494  spl2->n = 77; // nombre de points de calcul
1495
1496  dq=0.1;
1497  for(G4int i = 50; i < spl2->n; i++) {
1498    q[i] = q[i-1] + dq;
1499  }
1500
1501  f[0]=0.0;
1502
1503  G4double sumint=0.0;
1504
1505  // the id if the function we wish to integrate (in this case: G4Incl::dens
1506  for(G4int i = 1; i < spl2->n; i++) {
1507    dq = (q[i]-q[i-1])/10.0;
1508    sumint = sumint + integrate(q[i-1], q[i], dq, densFunction);
1509    f[i] = sumint;
1510  }
1511
1512  for(G4int i = 0; i < spl2->n; i++) {
1513    spl2->x[i] = f[i]/f[spl2->n-1];
1514    spl2->y[i] = q[i];
1515  }
1516
1517  spl2ab();
1518
1519  if(verboseLevel > 3) {
1520    G4cout << "deuteron density in q space from Paris potential: " << spl2->n << " Exact values from 0 to " 
1521              << q[spl2->n-1] << " fm-1 " << G4endl;
1522  }
1523}
1524
1525G4double G4Incl::integrate(G4double ami, G4double ama, G4double step, G4int functionChoice)
1526{
1527  G4double res = 0.0;
1528  G4double x1[5];
1529  for(G4int init_i = 0; init_i < 5; init_i++) {
1530    x1[init_i] = 0.0;
1531  }
1532  G4double ri = ami;
1533  G4double ra = ama;
1534  G4int nb = 0;
1535  G4double acont = 1.0;
1536  G4double dr = step;
1537
1538  if(ama <= ami) {
1539    acont = -1.0;
1540    ri = ama;
1541    ra = ami;
1542  }
1543 
1544  x1[0] = 95.0/288.0;
1545  x1[1] = 317.0/240.0;
1546  x1[2] = 23.0/30.0;
1547  x1[3] = 793.0/720.0;
1548  x1[4] = 157.0/160.0;
1549  nb = int(std::floor(((ra - ri)/step + 1.0000000001))); // 1.0000000001 -> 0.0
1550  dr = (ra - ri)/(double(nb - 1)); 
1551  res = 0.0;
1552
1553  if(nb < 10) {
1554    if(verboseLevel > 2) {
1555      G4cout <<"pas assez de points d'integration" << G4endl;
1556    }
1557    return 0.0;
1558  }
1559 
1560  for(G4int i = 0; i < 5; i++) {
1561    res = res + (callFunction(functionChoice, ri) + callFunction(functionChoice, ra))*x1[i];
1562    ri = ri + dr;
1563    ra = ra - dr;
1564  }
1565
1566  nb = nb - 10;
1567
1568  if(nb == 0) {
1569    return (res*dr*acont);
1570  }
1571
1572  for(G4int i = 0; i < nb; i++) {
1573    res = res + callFunction(functionChoice, ri);
1574    ri = ri + dr;
1575  }
1576
1577  return(res*dr*acont);
1578}
1579
1580
1581G4double G4Incl::dens(G4double q)
1582{
1583  return q*q*(std::pow(deutv(0,q),2)+std::pow(deutv(2,q),2));
1584}
1585
1586void G4Incl::spl2ab() 
1587{
1588  G4int i = 0, j = 0, k = 0;
1589
1590  for(i=0; i <= spl2->n-3; i++) {
1591    j = i + 1;
1592    k = i + 2;
1593
1594    spl2->c[i] = ((spl2->y[k]-spl2->y[i])*(spl2->x[j]-spl2->x[i])-(spl2->x[k]-spl2->x[i])*(spl2->y[j]-spl2->y[i]))
1595      /((spl2->x[j]-spl2->x[i])*(spl2->x[k]-spl2->x[i])*(spl2->x[k]-spl2->x[j]));
1596
1597    spl2->b[i] = (spl2->y[j]-spl2->y[i])/(spl2->x[j]-spl2->x[i]);
1598
1599    spl2->a[i] = spl2->y[i];
1600  }
1601
1602  for(i = spl2->n-2; i < spl2->n; i++) {
1603    spl2->c[i] = spl2->c[spl2->n-3];
1604    spl2->b[i] = spl2->b[spl2->n-3];
1605    spl2->a[i] = spl2->a[spl2->n-3]; 
1606  }
1607}
1608
1609G4double G4Incl::splineab(G4double xv)
1610{
1611  G4double tz = xv-spl2->x[0];
1612  G4int j;
1613
1614  if(tz < 0) {
1615    return spl2->a[0] + spl2->b[0] * tz + spl2->c[0] * tz * (xv - spl2->x[1]);
1616  }
1617  if(tz == 0) {
1618    return spl2->y[0];                                                       
1619  }
1620  if(tz > 0) {
1621    for(G4int i = 1; i <= spl2->n-1; i++) {
1622      j = i;
1623      tz = xv - spl2->x[i];                                 
1624
1625      if(tz < 0) { 
1626        j = j - 1;
1627        tz = xv - spl2->x[j];
1628        return spl2->a[j] + spl2->b[j] * tz + spl2->c[j] * tz * (xv - spl2->x[j+1]);
1629      }
1630      if(tz == 0) {
1631        return spl2->y[j];                                                   
1632      }
1633    }
1634  }
1635
1636  // Returns 0.0 if the point xv is outside the defined region (xv > spl2->x[spl2->n-1])
1637  if(verboseLevel > 2) {
1638    G4cout <<"G4Incl::splineab : requested point outside defined region! Returning 0.0." << G4endl;
1639  }
1640  return 0.0; 
1641}
1642
1643// Actual calculation
1644
1645void G4Incl::pnu(G4int *ibert_p, G4int *nopart_p, G4int *izrem_p, G4int *iarem_p, G4double *esrem_p,
1646                 G4double *erecrem_p, G4double *alrem_p, G4double *berem_p, G4double *garem_p,
1647                 G4double *bimpact_p, G4int *l_p)
1648{
1649  G4int ibert = (*ibert_p);
1650  //  float f[15]; // = (*f_p);
1651  G4int nopart = (*nopart_p);
1652//   G4int kind[300]; //= (*kind_p);
1653//   G4double ep[300]; // = (*ep_p);
1654//   G4double alpha[300]; // = (*alpha_p);
1655//   G4double beta[300]; // = (*beta_p);
1656//   G4double gam[300]; // = (*gam_p);
1657  G4int izrem = (*izrem_p);
1658  G4int iarem = (*iarem_p);
1659  G4double esrem = (*esrem_p); 
1660  G4double erecrem = (*erecrem_p);
1661  G4double alrem = (*alrem_p);
1662  G4double berem = (*berem_p);
1663  G4double garem = (*garem_p);
1664  G4double bimpact = (*bimpact_p);
1665  G4int l = (*l_p);
1666
1667  G4double minus_b1 = 0.0, minus_b2 = 0.0, minus_b3 = 0.0;
1668  G4double aml1 = 0.0;
1669  G4double aml2 = 0.0;
1670  G4double amlnew = 0.0;
1671  G4double arg = 0.0;
1672  G4double b1 = 0.0;
1673  G4double b2 = 0.0;
1674  G4double b3 = 0.0;
1675  G4double bb2 = 0.0;
1676  G4double be = 0.0;
1677  G4double bmass[2000]; 
1678  for(G4int init_i = 0; init_i < 2000; init_i++) {
1679    bmass[init_i] = 0.0;
1680  }
1681  G4double bmax2 = 0.0;
1682  G4double c1 = 0.0;
1683  G4double c2 = 0.0;
1684  G4double cb0 = 0.0;
1685  G4double cchi = 0.0;
1686  G4double ccr = 0.0;
1687  G4double cg = 0.0;
1688  G4double cif = 0.0;
1689  G4double cmultn = 0.0;
1690  G4double cobe = 0.0;
1691  G4double coeffb0 = 0.0;
1692  G4double comom = 0.0;
1693  G4double cstet = 0.0;
1694  G4double dis1 = 0.0;
1695  G4double dis2 = 0.0;
1696  G4double dis3 = 0.0;
1697  G4double dist = 0.0;
1698  G4double eb0 = 0.0;
1699  G4double ecoreh5 = 0.0;
1700  G4double efer = 0.0;
1701  G4double egs = 0.0;
1702  G4double eh5 = 0.0;
1703  G4double eh6 = 0.0;
1704  G4double eij = 0.0;
1705  G4double ekout = 0.0;
1706  G4double elead = 0.0;
1707  G4double energie_in = 0.0;
1708  G4double ener_max = 0.0;
1709  G4double eout = 0.0;
1710  G4double eps_c[BL1SIZE]; 
1711  for(G4int init_i = 0; init_i < BL1SIZE; init_i++) {
1712    eps_c[init_i] = 0.0;
1713  }
1714  G4double epsv = 0.0;
1715  G4double erecg = 0.0;
1716  G4double erem = 0.0;
1717  G4double exi = 0.0;
1718  G4double expob0 = 0.0;
1719  G4double factemp = 0.0;
1720  G4double fffc = 0.0;
1721  G4double fm = 0.0;
1722  G4double g1 = 0.0;
1723  G4double g2 = 0.0;
1724  G4double ge = 0.0;
1725  G4double geff = 0.0;
1726  G4double gg = 0.0;
1727  G4double gl1 = 0.0;
1728  G4double gl2 = 0.0;
1729  G4double gpsg = 0.0;
1730  G4int i1 = 0;
1731  G4int i20 = 0;
1732  G4int ic33 = 0;
1733  G4int ich1 = 0;
1734  G4int ich2 = 0;
1735  G4int ich3 = 0;
1736  G4int ich4 = 0;
1737  G4int ichd = 0;
1738  G4int ichpion = 0;
1739  G4int idecf = 0;
1740  G4int idep = 0;
1741  G4int iej = 0;
1742  G4int iejn = 0;
1743  G4int iejp = 0;
1744  G4int i_emax = 0;
1745  G4int iflag = 0;
1746  G4int iflag20 = 0; 
1747  G4int iflag40 = 0; 
1748  G4int iflag60 = 0; 
1749  G4int ilm = 0; 
1750  G4int imin = 0;
1751  G4int indic[3000]; 
1752  for(G4int init_i = 0; init_i < 3000; init_i++) {
1753    indic[init_i] = 0;
1754  }
1755  G4int inrem = 0;
1756  G4int ip = 0;
1757  G4int ipi[2000]; 
1758  for(G4int init_i = 0; init_i < 2000; init_i++) {
1759    ipi[init_i] = 0;
1760  }
1761  G4int iqe = 0;
1762  G4int irem = 0;
1763  G4int irst_avatar = 0;
1764  G4int isos = 0; 
1765  G4int itch = 0;
1766  G4int iteste = 0;
1767  G4int itt = 0;
1768  G4int ixr1 = 0;
1769  G4int ixr2 = 0;
1770  G4int ixr3 = 0;
1771  //  G4int k;
1772  G4int kcol = 0;
1773  G4int kd = 0;
1774  //  G4int klm = 0;
1775//   G4int l1;
1776//   G4int l2;
1777  G4int ldel = 0;
1778  G4int lead = 0;
1779  G4int led = 0;
1780  G4int lnew = 0;
1781  G4int lp = 0; 
1782  G4int lp1 = 0;
1783  G4double mcdd = 0.0;
1784  //G4double mg;
1785  G4int mg = 0;
1786  G4double mpaul1 = 0.0;
1787  G4double mpaul2 = 0.0;
1788  G4double mrdd = 0.0;
1789  G4double mrdn = 0.0;
1790  G4double mrdp = 0.0;
1791  G4double mrnd = 0.0;
1792  G4double mrnn = 0.0;
1793  G4double mrpd = 0.0;
1794  G4int n20 = 0;
1795  G4int nbalttf = 0;
1796  G4int nbquit = 0;
1797  G4int nbtest = 0;
1798  G4int nc[300];
1799  G4int npproj[300];
1800  for(G4int init_i = 0; init_i < 300; init_i++) {
1801    nc[init_i] = 0;
1802    npproj[init_i] = 0;
1803  }
1804  G4int ncol = 0;
1805  G4int ncol_2c = 0;
1806  G4int next = 0;
1807  G4int nmiss = 0;
1808  G4int np = 0;
1809  G4int npidir = 0;
1810  G4int npion = 0;
1811  G4int npx = 0;
1812  G4int nsum_col = 0;
1813  G4double p1v = 0.0;
1814  G4double p2v = 0.0;
1815  G4double p3v = 0.0;
1816  G4double pfrem1 = 0.0;
1817  G4double pfrem2 = 0.0;
1818  G4double pfrem3 = 0.0;
1819  G4double pfreml = 0.0;
1820  G4double pfreml2 = 0.0;
1821  G4double phi = 0.0;
1822  G4double p_mod = 0.0;
1823  G4double pot = 0.0;
1824  G4double pout1 = 0.0;
1825  G4double pout2 = 0.0;
1826  G4double pout3 = 0.0;
1827  G4double pppp = 0.0;
1828  G4double prem1 = 0.0;
1829  G4double prem2 = 0.0;
1830  G4double prem3 = 0.0;
1831  G4double psf = 0.0;
1832  G4double pspr = 0.0;
1833  G4double ptotl = 0.0;
1834  G4double qdeut = 0.0;
1835  G4double qqq = 0.0;
1836  G4double r22 = 0.0;
1837  G4double rcm1 = 0.0;
1838  G4double rcm2 = 0.0;
1839  G4double rcm3 = 0.0;
1840  G4double rcorr = 0.0;
1841  G4double rhopi = 0.0;
1842  G4double rndm = 0.0;
1843  G4double rr = 0.0;
1844  G4double rrrr = 0.0;
1845  G4double s = 0.0;
1846  G4double s1t1 = 0.0;
1847  G4double s2t1 = 0.0;
1848  G4double s3t1 = 0.0;
1849  G4double schi = 0.0;
1850  G4double sepa = 0.0;
1851  G4double sif = 0.0;
1852  G4double sitet = 0.0;
1853  G4double sp1t1 = 0.0;
1854  G4double sp2t1 = 0.0;
1855  G4double sp3t1 = 0.0;
1856  G4double sq = 0.0;
1857  G4double sueps = 0.0;
1858  G4double t[50];
1859  for(G4int init_i = 0; init_i < 50; init_i++) {
1860    t[init_i] = 0.0;
1861  }
1862  G4double t0 = 0.0;
1863  G4double t1 = 0.0;
1864  G4double t2 = 0.0;
1865  G4double t3 = 0.0;
1866  G4double t33 = 0.0;
1867  G4double t4 = 0.0;
1868  G4double t5 = 0.0;
1869  G4double t6 = 0.0;
1870  G4double t7 = 0.0;
1871  G4double t8 = 0.0;
1872  G4double tau = 0.0;
1873  G4double tbid = 0.0;
1874  G4double tdel = 0.0;
1875  G4double temfin = 0.0;
1876  G4double tim = 0.0;
1877  G4double timi = 0.0;
1878  G4double tlabu = 0.0;
1879  G4double tp = 0.0;
1880  G4double tref = 0.0;
1881  G4double tri = 0.0;
1882  G4double tt31 = 0.0;
1883  G4double tt32 = 0.0;
1884  G4double tt33 = 0.0;
1885  G4double tt34 = 0.0;
1886  G4double tt35 = 0.0;
1887  G4double tt36 = 0.0;
1888  G4double tte = 0.0;
1889  G4double u = 0.0;
1890  G4double v = 0.0;
1891  G4double var_ab = 0.0;
1892  G4double x = 0.0;
1893  G4double x1l1 = 0.0;
1894  G4double x1l2 = 0.0;
1895  G4double x1_target = 0.0; 
1896  G4double x2_target = 0.0; 
1897  G4double x3_target = 0.0; 
1898  G4double x2cour = 0.0;
1899  G4double x2l1 = 0.0;
1900  G4double x2l2 = 0.0;
1901  G4double x3l1 = 0.0;
1902  G4double x3l2 = 0.0;
1903  G4double xapres = 0.0;
1904  G4double xavant = 0.0;
1905  G4double xbl1 = 0.0;
1906  G4double xbl2 = 0.0;
1907  G4double xc = 0.0;
1908  G4double xe = 0.0;
1909  G4double xga = 0.0;
1910  G4double xl1 = 0.0;
1911  G4double xl2 = 0.0;
1912  G4double xl3 = 0.0;
1913  G4double xlab = 0.0;
1914  G4double xleng = 0.0;
1915  G4double xlengm = 0.0;
1916  G4double xmodp = 0.0;
1917  G4double xpb = 0.0;
1918  G4double xq = 0.0;
1919  G4double xr1 = 0.0;
1920  G4double xr2 = 0.0;
1921  G4double xr3 = 0.0;
1922  G4double xr4 = 0.0;
1923  G4double xr5 = 0.0;
1924  G4double xr6 = 0.0;
1925  G4double xr7 = 0.0;
1926  G4double xr8 = 0.0;
1927  G4double xv = 0.0;
1928  G4double xxx = 0.0;
1929  G4double xy1 = 0.0;
1930  G4double xy2 = 0.0;
1931  G4double xy3 = 0.0;
1932  G4double xye = 0.0;
1933  G4double y = 0.0;
1934  G4double p3_c[BL1SIZE];
1935  G4double q1[BL1SIZE];
1936  G4double q2[BL1SIZE];
1937  G4double q3[BL1SIZE];
1938  G4double q4[BL1SIZE];
1939  G4double ym[BL1SIZE];
1940  for(G4int init_i = 0; init_i < BL1SIZE; init_i++) {
1941    q1[init_i] = 0.0;
1942    q2[init_i] = 0.0;
1943    q3[init_i] = 0.0;
1944    q4[init_i] = 0.0;
1945    ym[init_i] = 0.0;
1946  }
1947  G4double y1[BL3SIZE];
1948  G4double y2[BL3SIZE];
1949  G4double y3[BL3SIZE];
1950  for(G4int init_i = 0; init_i < BL1SIZE; init_i++) {
1951    y1[init_i] = 0.0;
1952    y2[init_i] = 0.0;
1953    y3[init_i] = 0.0;
1954  }
1955  G4double z = 0.0;
1956  G4double za_i = 0.0;
1957  G4double zai2 = 0.0;
1958  G4double zshif = 0.0;
1959  G4double ztouch = 0.0; 
1960  G4double ztu = 0.0;
1961
1962  // LIEGE INC-model as a subroutine
1963
1964  // The Liege INC model has been applied to several systems and in
1965  // several conditions. Refinements are still in progress.
1966
1967  // PLEASE refer to this version as INCL4.1 in order to avoid
1968  // confusion when comparing to the results of your colleagues.
1969
1970  // DIFFERENT from INCL2.0 in the sense that the cascade is stopped
1971  // when the excitation energy vanishes if this occurs before the
1972  // predetermined stopping time (herein denoted as temfin) Special
1973  // are taken to avoid emission of slow particles due to the
1974  // imperfect Pauli blocking
1975
1976  // PLEASE notice: There are basically only two parameters in the
1977  // model: the average potential depth, denoted as V0, and the time
1978  // at which the cascade is stopped denoted as temfin. In this
1979  // program, the "standard" values (those G4introduced in the ref
1980  // NPA620(1997)475) are V0=40MeV and temfin=1.25*some function of
1981  // incident energy and impact parameter. You may, of course, change
1982  // these parameters V0 and the numerical coefficient in temfin,
1983  // within reasonable limits (i.e. V0 cannot be lower than 38MeV;
1984  // V0=45MeV is recommended for heavy nuclei). If you do, PLEASE
1985  // indicate your choice, once again, for the same reason as above.
1986
1987  // The description of the cascade model(incl2.0) can be found in:
1988  // J.C., C.VOLANT & S.VUILLIER, NPA620(1997)475 It is basically the
1989  // same model as described in J.C. NPA462(1987)751 (version 7 (in
1990  // our jargon), sketched below) + a refinement of the
1991  // parametrization of the cross-sections, based on J.C., D. L'HOTE,
1992  // J.VANDERMEULEN, NIM B111(1996)215 and J.C., S.LERAY, E.MARTINEZ,
1993  // Y.PATIN & S.VUILLIER PRC56(1998)2431
1994
1995  // technical notes:
1996  // 1.for the parametrizations of cross  sections, see
1997  //   notes of 4/10/96, 9/10/96, 31/12/97 and 13/10/98
1998  // 2.temfin=1.25*... 18/6/98
1999  // 3.sepa in concordance with v0-tf 2/7/98
2000  // 4.special care for stopping the cascade before t=temfin 27/04/99
2001
2002  //     84     c+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2003  //     85     C                                                                       P-N00030
2004  //     86     C     VERSION 7:  2/2/93                                                P-N00040
2005  //     87     C
2006  //     88     C++++++++++++ DESCRIPTION OF INPUT AND OUTPUT+++++++++++++++++++++++++++++
2007  //     89     C
2008  //     90     C **INPUT DATA**
2009  //     91     C
2010  //     92     C  IBERT=O IN THE FIRST CALL
2011  //     93     C        1 IN THE SUBSEQUENT CALLS
2012  //     94     C
2013  //     95     C  F= (REAL) ARRAY OF DIMENSION 8
2014  //     96     C
2015  //     97     C    F(1)= A (TARGET)
2016  //     98     C    F(2)= Z (TARGET)
2017  //     99     C    F(3)= KINETIC ENERGY (IN MEV) OF THE INCIDENT PARTICLE
2018  //    100     C    F(4)= SUPPOSED TO BE THE MINIMUM  PROTON ENERGY REQUIRED TO LEAVE
2019  //    101     C          THE TARGET. IN THIS CASCADE MODEL, IT IS ZERO
2020  //    102     C    F(5)= Nuclear potential V0 (standard value=45 MeV for heavy nuclei)
2021  //    103     C    F(6)= Rescale the cascade duration (the standard value t0 is MULTIPLIED
2022  //    104     c          by this value. F(6)=1. is the standard)
2023  //    105     C    F(7)= TYPE OF INCIDENT PARTICLE
2024  //    106     C           1.00 FOR PROTON
2025  //    107     C           2.00 FOR NEUTRON
2026  //    108     C           3.00 FOR PI+
2027  //    109     C           4.00 FOR PI0
2028  //    110     C           5.00 FOR PI-
2029  //    111     C           6.00 FOR DEUTERON
2030  //    112     C           7.00 FOR TRITON
2031  //    113     C           8.00 FOR HE3
2032  //    114     C           9.00 FOR HE4
2033  //    115     C    F(8)= SUPPOSED TO BE THE MINIMUM NEUTRON ENERGY REQUIRED TO LEAVE
2034  //    116     C          THE TARGET. IN THIS CASCADE MODEL, IT IS ZERO
2035  //    117     C
2036  //    118     C                                 NOSURF=1 Sharp density (hard sphere),
2037  //    119     C                                 NOSURF=0 Wood-Saxon density, stopping time "70"
2038  //    120     C                                                without B (impact) dependence.
2039  //    121     C                                 NOSURF=-1 Wood-Saxon density, stopping time "70"
2040  //    122     C                                                with B (impact) dependence
2041  //    123     C                                 (on peut toujours nenormaliser ces fonctions
2042  //    124     C                                  de temps avec le facteur F(6): t=t0*F(6) )
2043  //    125     C                                XFOISA      Rmaxws = R0 + XFOISA*A
2044  //    126     C                                            Bmax = Rmaxws for pions and nucleons
2045  //    127     C                                            Bmax = Rmaxws + rms1t (data) for composits
2046  //    128     C         Pauli strict (1) or statistic (0) or without pauli (2):     NPAULSTR
2047  //    129     C
2048  //    130     C    F(9)= imat, target material identifier for the right choose of Sax.-Wood density
2049  //    131     c
2050  //    132     c common/hazard/ial,IY1,IY2,IY3,IY4,IY5,IY6,IY7,IY8,IY9,IY10,
2051  //    133     c     s               IY11,IY12,IY13,IY14,IY15,IY16,IY17,IY18,IY19
2052  //    134     c ......20 numbers in the main routine to initialize the random numbers
2053  //    135     c
2054  //    136     C **OUTPUT DATA**
2055  //    137     C
2056  //    138     C  NOPART=-1 PSEUDO REACTION (VOID EVENT)
2057  //    139     C          0 ABSORPTION
2058  //    140     C         >0 TRUE EVENT, = NUMBER OF PARTICLES EMITTED (EXCLUDING THE REMNANT)
2059  //    141     C
2060  //    142     C  FOR N=1,NOPART:
2061  //    143     C  KIND(N)= TYPE OF PARTICLES (SAME CONVENTION AS FOR F(7), BUT IN G4INTEGERS)
2062  //    144     C
2063  //    145     C  EP(N)=  KINETIC ENERGY
2064  //    146     C
2065  //    147     C  ALPHA(N),BETA(N),GAM(N)= DIRECTION COSINES
2066  //    148     C
2067  //    149     C  IZREM= Z (REMNANT)
2068  //    150     C
2069  //    151     C  IAREM= A (REMNANT)
2070  //    152     C
2071  //    153     C  ESREM= EXCITATION ENERGY OF THE REMNANT
2072  //    154     C
2073  //    155     C  ERECREM= RECOIL ENERGY OF THE REMNANT
2074  //    156     C
2075  //    157     C  ALREM,BEREM,GAREM=DIRECTION COSINES OF THE REMNANT
2076  //    158     C
2077  //    159     C  BIMPACT impact parameter
2078  //    160     C
2079  //    161     C  L G4intrinsic momentum of the remnant in units of h/2pi=hbar=197.328
2080  //    162     C+++++++++ DESCRIPTION OF THE INC MODEL ++++++++++++++++++++++++++++++++++++
2081  //    163     C
2082  //    164     C     MODEL DESCRIBED IN J.CUGNON (NP A462(1987)751)                    P-N00050
2083  //    165     C     =MODEL (DR) OF J.CUGNON,D.KINET,J.VANDERMEULEN(NP A379(1982)567)  P-N00060
2084  //    166     C                                                                       P-N00110
2085  //    167     C        +REFLECTION OR TRANSMISSION ON THE POTENTIAL WALL              P-N00120
2086  //    168     C              (THE POTENTIAL DEPTH IS THE SAME FOR NUCLEONS & DELTA'S) P-N00130
2087  //    169     C              (CONTAINS A COULOMB BARRIER)                             P-N00140
2088  //    170     C                                                                       P-N00150
2089  //    171     C        +ABSORPTION OF THE PION ABOVE THE (3,3) RESONANCE (NOT IN      P-N00160
2090  //    172     C                VERSION 2)                                             P-N00170
2091  //    173     C                                                                       P-N00180
2092  //    174     C        +POSSIBLE PAULI BLOCKING OF TWO BODY COLLISIONS                P-N00190
2093  //    175     C        +POSSIBLE PAULI BLOCKING OF DELTA DECAY                        P-N00200
2094  //    176     C                 THE PAULI BLOCKING IS APPLIED TO THE NUCLEONS         P-N00210
2095  //    177     C                 ONLY.THE PAULI BLOCKING FACTORS ARE EVALUATED         P-N00220
2096  //    178     C                 BY COUNTING THE NUCLEONS INSIDE A VOLUME IN           P-N00230
2097  //    179     C                 PHASE SPACE.THE EXTENSION OF THIS VOLUME IS           P-N00240
2098  //    180     C                 OF THE ORDER OF H**3                                  P-N00250
2099  //    181     C                                                                       P-N00260
2100  //    182     C    ADDITIONAL FEATURES:                                               P-N00270
2101  //    183     C                                                                       P-N00280
2102  //    184     C        +ISOSPIN (WITH NEW PN BACKWARD-FORWARD ASYMMETRY)              P-N00290
2103  //    185     C                                                                       P-N00300
2104  //    186     C        +"LONGITUDINAL GROWTH" OF THE BARYONS (NOT ACTIVATED HERE)
2105  //    187     C
2106  //    188     C        + PARTICLE #1 IS ALWAYS THE FASTEST PARTICLE IN THE Z-DIRECTIONP-N00100
2107  //    189     C                                 (NOT ACTIVATED HERE)
2108  //    190     C        +SIMPLIFIED NEUTRON EVAPORATION AT THE END OF THE CASCADE      P-N00310
2109  //    191     C                                 (NOT PRESENT HERE)
2110  //    192     C                 
2111  //    193     C        +POSSIBLE CONSERVATION OF ANGULAR MOMENTUM (NOT ACTIVATED
2112  //    194     C                    HERE, COPIED FROM P_NUCJ)
2113  //    195     C        P-NU7=SAME AS P-NU6 + EVAPORATION                              P-N00330
2114  //    196     C+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++P-N00340
2115  //    197     
2116  //    198           DIMENSION f(15),kind(300),ep(300),alpha(300),beta(300),gam(300)
2117  //    199           DIMENSION bmass(300)
2118  //    200           COMMON/hazard/ial,IY1,IY2,IY3,IY4,IY5,IY6,IY7,IY8,IY9,IY10,
2119  //    201          s               IY11,IY12,IY13,IY14,IY15,IY16,IY17,IY18,IY19
2120  //    202           COMMON/kind/kindf7
2121  //    203           DIMENSION IND(20000),JND(20000)                                   P-N00350
2122  //    204           DIMENSION INDIC(3000)                                             P-N00360
2123  //    205           DIMENSION NPAR(625,15),NIMP(600,15),NNCO(15),NIMPP(600)           P-N00370
2124  //    206           DIMENSION NENTR(10,8,20,10),NOUT1(15),NOUT2(15)                   P-N00380
2125  //    207     
2126  //    208     c     DIMENSION TEM(15),NSR(40),NSP(40),NSR1(40),NSP1(40)               P-N00400
2127  //    209           DIMENSION TEM(15),NSR1(40),NSP1(40)                               P-N00400
2128  //    210           DIMENSION T(200),LINE(132),Q1(200),Q2(200),Q3(200),Q4(200),NC(300)P-N00410
2129  //    211           DIMENSION Y1(200),Y2(200),Y3(200),YM(200),IPI(200)                P-N00420
2130  //    212           DIMENSION NRNN(15),NRND(15),NRDD(15),NRDN(15),NRDP(15),NRPD(15),NCP-N00430
2131  //    213          -DD(15),NPAUL1(15),NPAUL2(15)                                      P-N00440
2132  //    214           DIMENSION NPDIR(600)                                              P-N00450
2133  //    215           DIMENSION NEJ(6,15),NRES(6,15),NPIA(6,15),NCHPRO(15),NDEL(15)     P-N00460
2134  //    216           DIMENSION EDEP1(15),EDEP2(15),EDEP3(15),EDEP4(15),NG4INT(15)        P-N00470
2135  //    217          -,EPAR1(15),EPAR2(15),EPAR3(15),EPAR4(15),ENPI(15),E1(15),EZ3(15)  P-N00480
2136  //    218           DIMENSION IHF1(50),IHF2(50),IHF3(50),IHF4(50),IHP(2,100),IHC(50), P-N00490
2137  //    219          -IHE(2,100),IHF5(100),IHREM(100,100)
2138  //    220         
2139  //    221           DIMENSION JPARTICIP(300),eps_c(4),p3_c(4)
2140  //    222         
2141  //    223     C Dialogue with INCL: function R(q/pf) for each nucleus
2142  //    224           COMMON/SAXW/ XX(30,500),YY(30,500),SS(30,500),NBPG4INTER,IMAT
2143  //    225           COMMON/WS/R0,ADIF,RMAXWS,DRWS,NOSURF,XFOISA,NPAULSTR,BMAX     
2144  //    226     
2145  //    227     C RMS espace R, espace P, Fermi momentum and energy for light gauss nuc.     
2146  //    228           COMMON/light_gaus_nuc/rms1t(9),pf1t(9),pfln(9),tfln(9),vnuc(9)
2147  //    229           
2148  //    230     C Fermi 2 param from A=19 to 28, modified harm oscil A=6 to 18
2149  //    231     C (H. De Vries et al. At. Data and Nuc. Data Tab. 36 (1987) 495)
2150  //    232           COMMON/light_nuc/R_light_nuc(30),a_light_nuc(30)     
2151  //    233     
2152  //    234     c common for study of avatars through an ntuple optionally produced
2153  //    235           real*4 bavat,timeavat,energyavat
2154  //    236           G4integer bloc_paul,bloc_cdpp,go_out,avm,del1avat,del2avat
2155  //    237           parameter (avm=1000)
2156  //    238           common/var_avat/kveux,bavat,nopartavat,ncolavat,
2157  //    239          s r1_in(3),r1_first_avat(3),
2158  //    240          s epsd(250),eps2(250),eps4(250),eps6(250),epsf(250),
2159  //    241          s nb_avat,
2160  //    242          s timeavat(avm),l1avat(avm),l2avat(avm),jpartl1(avm),jpartl2(avm),
2161  //    243          s del1avat(avm),del2avat(avm),energyavat(avm),
2162  //    244          s bloc_paul(avm),bloc_cdpp(avm),go_out(avm)
2163  //    245     
2164  //    246           dimension npproj(300)
2165  //    247           common/spl2/ xsp(100),ysp(100),ad(100),bd(100),cd(100),ndeut
2166  //    248     c deutons     
2167  //    249     c     dimension ltt(15)                                                 p-n00520
2168  //    250           common/bl1/p1(300),p2(300),p3(300),eps(300),ind1(300),ind2(300),tap-n00530
2169  //    251           common/bl2/crois(19900),k,ind,jnd                                 p-n00540
2170  //    252           common/bl3/r1,r2,x1(300),x2(300),x3(300),ia1,ia2,rab2             p-n00550
2171  //    253           common/bl4/tmax5                                                  p-n00560
2172  //    254           common/bl5/tlg(300),nesc(300)                                     p-n00570
2173  //    255           common/bl6/xx10,isa                                               p-n00580
2174  //    256           common/bl8/rathr,ramass
2175  //    257           common/bl9/hel(300),l1,l2
2176  //    258           common/bl10/ri4,rs4,r2i,r2s,pf
2177  //    259           common/paul/ct0,ct1,ct2,ct3,ct4,ct5,ct6,pr,pr2,xrr,xrr2,
2178  //    260          s            cp0,cp1,cp2,cp3,cp4,cp5,cp6
2179  //    261         
2180  //    262           dimension ia1t(9),iz1t(9),fmpinct(9)     
2181  //    264           data line/132*1h*/,hc,fmp,fmd,fmpi/197.328,938.2796,1232.,138.00/ p-n00590
2182  G4double hc = 197.328;
2183  G4double fmp = 938.2796;
2184  G4double fmpi = 138.00;
2185  //    265           data /ia1t,iz1t,fmpinct/1,1,0,0,0,2,3,3,4,1,0,1,0,-1,1,1,2,2,
2186  //    266          -938.2796,938.2796,138.0,138.0,138.0,1874.35,2806.8,2806.8,3727.
2187  G4int ia1t[9] = {1,1,0,0,0,2,3,3,4};
2188  G4int iz1t[9] = {1,0,1,0,-1,1,1,2,2};
2189  G4double fmpinct[9] = {938.2796,938.2796,138.0,138.0,138.0,1874.35,2806.8,2806.8,3727.};
2190
2191  // Initialize array:
2192   for(G4int i = 0; i < 300; i++) {
2193     npproj[i] = 0;
2194     nc[i] = 0;
2195   }
2196
2197  //    266         
2198  //    267     c      data rms1t,pf1t/0.,0.,0.,0.,0.,2.10,1.80,1.80,1.63,
2199  //    268     c     -0.,0.,0.,0.,0.,77.,110.,110.,153./
2200  //    269     
2201  //    270     
2202  //    271     c deutons
2203  //    272           data nentr/16000*0/                                               p-n00620
2204  //    389     c                                                                       p-n01700
2205  //    390     ccc   reading of the data                                               p-n01710
2206  //    391     c                                                                       p-n01720
2207  //    392     c-------explanation of some physical quantities------------------------ p-n01730
2208  //    393     c           (basically input data, when run as a program)
2209  //    394     c                                                                       p-n01740
2210  //    395     c     ia1=mass number of the incident ion                               p-n01750
2211  //    396     c                                                                       p-n01760
2212  //    397     c     ia2=mass number of the target                                     p-n01770
2213  //    398     c     iz1=atomic number of the projectile                               p-n01780
2214  //    399     c                                                                       p-n01790
2215  //    400     c     iz2=atomic number of the target                                   p-n01800
2216  //    401     c     r01=radius parameter of the projectile                            p-n01810
2217  //    402     c           r01 should be put to 1.000                                  p-n01820
2218  //    403     c     r02=radius parameter of the target                                p-n01830
2219  //    404     c     adif1=diffuseness of the projectile                               p-n01840
2220  //    405     c           adif1 should be put to 1.0000                               p-n01850
2221  //    406     c     adif2=diffuseness of the target                                   p-n01860
2222  //    407     c                                                                       p-n01870
2223  //    408     c     tlab = incident energy  (in mev)                                  p-n01880
2224  //    409     c                                                                       p-n01890
2225  //    410     c     k1=1 reference frame=c.m. of the covering matter                  p-n01900
2226  //    411     c     k1=2 reference frame=c.m. frame of the incident ion and its       p-n01910
2227  //    412     c          G4intercept                                                    p-n01920
2228  //    413     c     k1=3 reference frame=c.m. frame of a n-n system with the same     p-n01930
2229  //    414     c          kinematics as the two ions                                   p-n01940
2230  //    415     c     k1=4 reference frame=c.m. frame for the total  system             p-n01950
2231  //    416     c     k1=5 reference frame=lab system                                   p-n01960
2232  //    417     c              k1 should be put to 5 in this version                    p-n01970
2233  //    418     c     k2=0 relativistic kinematics                                      p-n01980
2234  //    419     c     k2=1 non-relativistic kinematics(abandonned in this version)      p-n01990
2235  //    420     c     k3=0  deltas are produced                                         p-n02000
2236  //    421     c     k3=1  no delta production                                         p-n02010
2237  //    422     c     k4=0 the delta is given a vanishing lifetime                      p-n02020
2238  //    423     c     k4=1 the delta has a very large lifetime                          p-n02030
2239  //    424     c     k4=2 the delta has a exponentially random lifetime                p-n02040
2240  //    425     c     k5=0 no delta-nucleon,delta-delta G4interactions                    p-n02050
2241  //    426     c     k5=1 delta-nucleon=delta-delta=nucleon-nucleon elastic x-section  p-n02060
2242  //    427     c     k6=0 no angular momentum conservation                             p-n02070
2243  //    428     c     k6=1 angular momentum conservation                                p-n02080
2244  //    429     c                                                                       p-n02090
2245  //    430     c     b=impact parameter                                                p-n02100
2246  //    431     c                                                                       p-n02110
2247  //    432     c     rbl(pbl) is the radius in real(momentum) space of the volume      p-n02120
2248  //    433     c         on which the nucleons are counted to evaluate the pauli       p-n02130
2249  //    434     c         blocking factors                                              p-n02140
2250  //    435     c     recommended values are 2 fm and 200 mev/c respectively            p-n02150
2251  //    436     c                                                                       p-n02160
2252  //    437     c     nrun= number of  runs (irrelevant here)                           p-n02170
2253  //    438     c                                                                       p-n02180
2254  //    439     c     ntm=number of G4intermediate times at which the spatial and momentump-n02190
2255  //    440     c         distributions are stored (not relevant here)                  p-n02200
2256  //    441     c                                                                       p-n02210
2257  //    442     c     tem(it)=values of the G4intermediate times                          p-n02220
2258  //    443     c                                                                       p-n02230
2259  //    444     c     v0=depth of the nucleon potential                                 p-n02240
2260  //    445     c     v1=depth of the delta potential                                   p-n02250
2261  //    446     c         in this version v1 should be equal to v0                      p-n02260
2262  //    447     c         (attention! a  v0 > 0 corresponds to an attractive potential) p-n02270
2263  //    448     c                                                                       p-n02280
2264  //    449     c     ncase=number of cells necessary to depict the spatial distributionp-n02290
2265  //    450     c         in the x and z directions                                     p-n02300
2266  //    451     c                                                                       p-n02310
2267  //    452     c     xp,xg,zp,zg=limits of the box in the x and z directions           p-n02320
2268  //    453     c     in order to have the same scale in the two directions ,put xg-xp= p-n02330
2269  //    454     c         0.9*(zg-zp)                                                   p-n02340
2270  //    455     c     dy=dimension of the box in the y direction                        p-n02350
2271  //    456     c                                                                       p-n02360
2272  //    457     c     rap1,rap2,pp1,pp2=limits of the box in the rapidity-p(perpendicu- p-n02370
2273  //    458     c          -lar) space                                                  p-n02380
2274  //    459     c     the box is divided G4into 15 cells along p(perp) and 40 cells along p-n02390
2275  //    460     c         the rapidity                                                  p-n02400
2276  //    461     c                                                                       p-n02410
2277  //    462     c     en,sn=average energy carried away by a nucleon,separation energy  p-n02420
2278  //    463     c                                                                       p-n02430
2279  //    464     c       (ntm,ncase,xp,...,sn are not used here)
2280  //    465     c-----------------------------------------------------------------------p-n02440
2281
2282  // for logging
2283  //  std::ofstream dumpOut("inclDump.txt");
2284  // end for logging
2285
2286  G4int jparticip[BL1SIZE];
2287  for(G4int i = 0; i < BL1SIZE; i++) {
2288    jparticip[i] = 0;
2289  }
2290
2291  G4double beproj = 0.;
2292  bl3->ia2 = G4int(std::floor(calincl->f[0] + 0.1)); // f(1)->f[0] and so on..., calincl added
2293  G4int iz2 = G4int(std::floor(calincl->f[1] + 0.1));
2294  G4double r02 = 1.12;
2295  kindstruct->kindf7 = int(std::floor(calincl->f[6] + 0.1));
2296
2297  bl3->ia1 = ia1t[G4int(kindstruct->kindf7)-1];
2298  G4int iz1 = iz1t[G4int(kindstruct->kindf7)-1];
2299  G4double fmpinc = fmpinct[G4int(kindstruct->kindf7)-1];
2300  G4double rms1 = light_gaus_nuc->rms1t[G4int(kindstruct->kindf7)-1];
2301  G4double pf1 = light_gaus_nuc->pf1t[G4int(kindstruct->kindf7)-1];
2302  G4double tlab = calincl->f[2];
2303
2304  G4int k2 = 0;
2305  G4int k3 = 0;
2306  //  G4int k3 = 1; // No deltas!
2307  G4int k4 = 2;
2308  G4int k5 = 1;
2309  G4int k6 = 0;
2310
2311  // material number:     
2312  saxw->imat = G4int(std::floor(calincl->f[8] + 0.5)); // f(9) -> f[8]
2313  // espace de phases test (r et p) pour pauli:
2314  // valeur recommandee par j.c. v-test=0.589 h**3:
2315  G4double rbl = 2.0;
2316  G4double pbl=200.0;
2317
2318  paul->xrr = rbl;
2319  paul->xrr2 = (paul->xrr) * (paul->xrr);
2320  paul->pr=pbl;
2321  paul->pr2 = paul->pr*(paul->pr);
2322
2323  G4double tem[10];
2324  tem[0] = 100000.0;  // tem(1) -> tem[0]
2325  // temfin (time at which the inc is stopped), tmax5 defined after chosing b
2326
2327  G4double v0 = calincl->f[4]; // f(5)->f[4]
2328  G4double v1 = v0;
2329  bl8->rathr = 0.;
2330  bl8->ramass = 0.;
2331
2332  // constants and derived data
2333  bl10->pf = 1.37*hc;
2334  G4double tf = std::sqrt(bl10->pf*(bl10->pf)+fmp*fmp)-fmp;
2335  G4double g0 = 115.0;
2336  G4double th = 0.;
2337  G4double pm2 = fmp*fmp;
2338  G4int ia = bl3->ia1 + bl3->ia2;
2339  G4int a2 = bl3->ia2;
2340  bl3->r2 = r02*std::pow(G4double(a2),0.33333333);
2341
2342  // parametres moyens de densite de la cible (fermi 2 parametres)
2343  if (bl3->ia2 >= 28) { //then
2344    ws->r0 = (2.745e-4*bl3->ia2+1.063)*std::pow(G4double(bl3->ia2),0.33333333);
2345    ws->adif = 1.63e-4*bl3->ia2 + 0.510;
2346    ws->rmaxws = ws->r0 + ws->xfoisa*(ws->adif);
2347  }
2348  else if(bl3->ia2 >= 19) { //then
2349    ws->r0 = light_nuc->r[bl3->ia2-1];
2350    ws->adif = light_nuc->a[bl3->ia2-1];
2351    ws->rmaxws = ws->r0 + ws->xfoisa*(ws->adif);
2352  }
2353  else if(bl3->ia2>=6) { //then
2354    ws->r0 = 1.581*(light_nuc->a[bl3->ia2-1]) * (2.0 + 5.0 * (light_nuc->r[bl3->ia2-1]))/(2.0 + 3.0*(light_nuc->r[bl3->ia2-1]));
2355    ws->adif = light_nuc->a[bl3->ia2-1];
2356    ws->rmaxws = 5.5 + 0.3*(double(bl3->ia2) - 6.0)/12.0;
2357  }
2358  else if(bl3->ia2 >= 2) { // then
2359    if(bl3->ia2 == 2) { //then
2360      ws->r0 = light_gaus_nuc->rms1t[5]; // rms1t(6) -> rms1t[5]
2361      bl10->pf = light_gaus_nuc->pfln[5]; //pfln(6)->pfln[5]
2362      tf = light_gaus_nuc->tfln[5]; // tfln(6) -> tfln[5]
2363      v0 = light_gaus_nuc->vnuc[5]; // vnuc(6) -> vnuc(5)
2364    } //endif
2365    if(bl3->ia2 == 3 && iz2 == 1) { //then
2366      ws->r0 = light_gaus_nuc->rms1t[6]; //rms1t(7)->rms1t[6] and so on...
2367      bl10->pf = light_gaus_nuc->pfln[6];
2368      tf = light_gaus_nuc->tfln[6];
2369      v0 = light_gaus_nuc->vnuc[6];
2370    } //endif
2371    if(bl3->ia2 == 3 && iz2 == 2) { //then
2372      ws->r0 = light_gaus_nuc->rms1t[7]; //rms1t(8)->rms1t[7] and so on...
2373      bl10->pf = light_gaus_nuc->pf1t[7];
2374      tf = light_gaus_nuc->tfln[7];
2375      v0 = light_gaus_nuc->vnuc[7];
2376    } //endif
2377    if(bl3->ia2 == 4) { //then
2378      ws->r0 = light_gaus_nuc->rms1t[8]; // rms1t(9) -> rms1t[8] and so on...
2379      bl10->pf = light_gaus_nuc->pf1t[8];
2380      tf = light_gaus_nuc->tfln[8];
2381      v0 = light_gaus_nuc->vnuc[8];
2382    } //endif
2383    v1 = v0;
2384    ws->adif = 0.57735*(ws->r0);
2385    ws->rmaxws = ws->r0+2.5;
2386  } // end if
2387  if(ws->nosurf > 0) { //then
2388    ws->adif=0.0;
2389    ws->rmaxws=ws->r0;
2390  } //end if
2391  ws->drws = ws->rmaxws/29.0;
2392
2393  // on impose le rayon du noyau:
2394  // ....voir coherence function wsax(r) et derivwsax(r)
2395  bl3->r2 = ws->r0;
2396  if(verboseLevel > 3) {
2397    G4cout <<"Radius bl3->r2 = " << bl3->r2 << G4endl;
2398  }
2399 
2400  G4double tnr = tlab;
2401  G4double binc = std::sqrt(tnr*tnr + 2.0*tlab*fmpinc)/(tnr+fmpinc);
2402  G4double ginc=1.0/std::sqrt(1.0 - binc*binc);
2403  G4double pinc = fmpinc*binc*ginc;
2404
2405  for(G4int bli = 0; bli < BL1SIZE; bli++) {
2406    bl1->eps[bli] = 0.0;
2407    bl1->p1[bli] = 0.0;
2408    bl1->p2[bli] = 0.0;
2409    bl1->p3[bli] = 0.0;
2410    q1[bli] = 0.0;
2411    q2[bli] = 0.0;
2412    q3[bli] = 0.0;
2413    q4[bli] = 0.0;
2414  }
2415
2416  // skip initialisations
2417  G4double efrun = 0.0;
2418  G4int iavat = 0;
2419
2420  // generation of the initial distribution in the rest frame of the iop-n03870
2421  // surface
2422  //    700     c      bmax=r2+2.2*adif
2423  //    701     c      r2i=(r2-2.2*adif)
2424  //    702     c      r2s=(r2+2.2*adif)
2425  //    703     c **********
2426  //    704           
2427
2428  ws->bmax = ws->rmaxws;                // maximum extension of the nucleus ( w.s.)
2429
2430  //  fin surface (que faire aux pions ?)
2431  //    709     c      if (kindf7.gt.2) bmax=r2+2.2
2432  //    710     c      if (kindf7.gt.2) bmax=bmax       ! a.b. (avec w.s., idem les nucleons)
2433  // deutons cv 22/01/2001
2434  if (kindstruct->kindf7 <= 2)  { //then
2435    ws->bmax = ws->bmax;     // comme alain
2436  }
2437  else {
2438    if (kindstruct->kindf7 < 6) { // then   
2439      ws->bmax = ws->bmax;   // comme alain
2440    }
2441    else {
2442      beproj = fmpinc - bl3->ia1*fmp;
2443      ws->bmax = ws->rmaxws + rms1;     // maximum extension of the nucleus ( w.s.)
2444    }
2445  }
2446
2447  // deutons     
2448  G4double al;
2449  standardRandom(&al, &(hazard->ial));
2450  G4double b = std::sqrt(al)*(ws->bmax);
2451  G4double bred = b/bl3->r2;
2452  //G4double bimpact=b;
2453  bimpact = b;
2454  G4double tnor;
2455
2456  if(ws->nosurf != -2) { // la suite, c'est la version temps avant 2001
2457    if(ws->nosurf <= 0) {
2458      tnor = 70.0/30.6349;         
2459    }
2460    // PK endif removed
2461    else {
2462      tnor=1.;
2463    } //endif               
2464    if(ws->nosurf == 0) {
2465      bred = 0.;
2466    }
2467    if (kindstruct->kindf7 <= 2) {
2468      if (tlab < 400.0) {
2469        cb0 = 6.86 - 0.0035 * tlab;
2470        eb0 = 0.32 - 0.00005 * tlab;
2471      }
2472      else {
2473        if (tlab < 1000.0) { //then
2474          cb0 = 5.23 + 0.000575 * tlab;
2475          eb0 = 0.32 - 0.00005 * tlab;
2476        }
2477        else {
2478          cb0 = 5.73 + 0.00007 * tlab;
2479          eb0 = 0.283 - 0.000013 * tlab;
2480        }
2481      }
2482      temfin = 1.25*cb0/amax1(1.0,0.854 + 0.438*bred)*std::pow(G4double(bl3->ia2),(eb0/amax1(1.0,0.941+0.177*bred)));
2483      temfin = temfin*tnor;
2484    }
2485    else {
2486      if (kindstruct->kindf7 < 6) {
2487        // here for pions:
2488        temfin = 30.0*std::pow((float(bl3->ia2)/208.0),0.25)*(1.0 - 0.2*bred)*(1.0 - tlab/1250.0);
2489        // correction for pions in the case nosurf=0 or -1 (a.b., c.v. 2/2002)
2490        temfin = temfin*tnor;
2491      }
2492      else {
2493        // deutons
2494        tlabu = tlab/double(bl3->ia1);
2495        if (tlabu <= 400) {
2496          coeffb0 = -0.0035*tlabu + 6.86;
2497          expob0 = -0.00005*tlabu + 0.32;
2498        }
2499        else {
2500          if (tlabu <= 1000) { //then   
2501            coeffb0 = 0.000575*tlabu + 5.23;
2502            expob0 = -0.00005*tlabu + 0.32;
2503          }
2504          else {
2505            coeffb0 = 0.00007*tlabu + 5.73;
2506            expob0 = -0.000013*tlabu + 0.283;
2507          }
2508        }
2509        if (bred <= 0.33333) {
2510          xc = 1.0;
2511          xe = 1.0;
2512        }
2513        else {
2514          xc = 0.438*bred + 0.854;
2515          xe = 0.177*bred + 0.941;
2516        }
2517        temfin = 1.25*(coeffb0/xc)*std::pow(G4double(bl3->ia2),(expob0/xe));
2518        // same renormalisation of time for p,n and composit particles.
2519        temfin = temfin*tnor;
2520      }
2521    }
2522  }
2523  else { //ici,nosurf=-2 c'est la fonction temps 2001 (avec surface).
2524    if(kindstruct->kindf7 >= 3 && kindstruct->kindf7 <= 5) {
2525      // here for pions (arbitrary multiplied by 2 for surface) (a.b., c.v.) 2/2002:
2526      // temfin=60.*(float(ia2)/208.)**0.25*(1.-0.2*bred)*(1.-tlab/1250.)
2527      // modified in april 2003 (more reasonable but not yet checked!)
2528      temfin = 25.5*std::pow(G4double(bl3->ia2),0.16);  // pb208->60fm/c
2529    }
2530    else {
2531      // here for other hadrons
2532      temfin = 29.8*std::pow(G4double(bl3->ia2),0.16);  // pb208->70fm/c
2533    }
2534  }
2535
2536  // deutons
2537  // a way to change stopping time f[5] not used here
2538  factemp = calincl->f[5]; // f(6)->f[5]
2539  // attention !!! 30/04/2001 scaling time is now a multiplication factor
2540  temfin = temfin*factemp;
2541
2542  exi = 0.0;
2543  nbquit = 0;
2544  iqe = 0;
2545  idecf = 0;
2546  bl4->tmax5 = temfin+0.1;
2547  npion = 0;
2548  efer = 0.0;
2549
2550  // deutons
2551  if (bl3->ia1 > 1) {
2552    goto pnu7;
2553  }
2554
2555  // deutons
2556  if (bl3->ia1 == 1) { //then
2557    //    bl5->nesc[0] = 0; // nesc(1)->nesc[0] and so on...
2558    bl5->nesc[1] = 0;
2559    //    bl1->ind2[0] = 2*iz1 - 1;
2560    bl1->ind2[1] = 2*iz1 - 1;
2561    bl1->ind1[1] = 0;
2562    bl3->x1[1] = 0.0;
2563    bl3->x2[1] = 0.0;
2564    bl3->x3[1] = 0.0;
2565    bl1->p1[1] = 0.0;
2566    bl1->p2[1] = 0.0;
2567    bl1->p3[1] = 0.0;
2568    bl9->hel[0] = 0.0;
2569    bl9->hel[1] = 0.0;
2570    jparticip[0] = 0;
2571    jparticip[1] = 1;
2572  }
2573  else {
2574    npion = 1;
2575    ipi[1] = 8 - 2*(kindstruct->kindf7);
2576    y1[1] = 0.0;
2577    y2[1] = 0.0;
2578    y3[1] = 0.0;
2579    q1[1] = 0.0;
2580    q2[1] = 0.0;
2581    q3[1] = 0.0;
2582    q4[1] = fmpi;
2583  }
2584
2585  // deutons
2586  goto pnu9;
2587  //    850     
2588 pnu7: 
2589  s1t1 = 0.0;
2590  s2t1 = 0.0;
2591  s3t1 = 0.0;
2592  sp1t1 = 0.0;
2593  sp2t1 = 0.0;
2594  sp3t1 = 0.0;
2595  for(G4int i = 1; i <= bl3->ia1; i++) {
2596  //for(G4int i = 1; i <= (bl3->ia1-1); i++) {
2597  //  for(G4int i = 1; i < (bl3->ia1-1); i++) {
2598    bl9->hel[i] = 0;
2599    bl5->nesc[i] = 0;
2600    bl1->ind2[i] = 1;
2601    if (i > iz1) {
2602      bl1->ind2[i] = -1;
2603    }
2604    bl1->ind1[i] = 0;
2605    // deutons
2606    jparticip[i] = 1;
2607
2608    // deutons
2609    gaussianRandom(&xga);
2610    bl3->x1[i] = xga*rms1*0.57735;
2611    s1t1 = s1t1 + bl3->x1[i];
2612    gaussianRandom(&xga);
2613    bl3->x2[i] = xga*rms1*0.57735;
2614    s2t1 = s2t1 + bl3->x2[i];
2615    gaussianRandom(&xga);
2616    bl3->x3[i] = xga*rms1*0.57735; 
2617    s3t1 = s3t1 + bl3->x3[i];
2618
2619    if(kindstruct->kindf7 == 6) { //then
2620      // deuteron density from paris potential in q space:     
2621      standardRandom(&xq, &(hazard->igraine[9]));
2622      qdeut = splineab(xq) * 197.3289;
2623      standardRandom(&u, &(hazard->igraine[10]));
2624      cstet = u*2 - 1;
2625      sitet = std::sqrt(1.0 - std::pow(cstet,2));
2626      standardRandom(&v, &(hazard->igraine[11]));
2627      phi = 2.0*3.141592654*v;
2628
2629      bl1->p1[i] = qdeut*sitet*std::cos(phi);
2630      bl1->p2[i] = qdeut*sitet*std::sin(phi);
2631      bl1->p3[i] = qdeut*cstet;
2632    }
2633    else {
2634      // density of composite as a gaussien in q space:
2635      gaussianRandom(&xga);
2636      bl1->p1[i] = xga*pf1*0.57735;
2637      gaussianRandom(&xga);
2638      bl1->p2[i] = xga*pf1*0.57735;
2639      gaussianRandom(&xga);
2640      bl1->p3[i] = xga*pf1*0.57735;
2641    }
2642
2643    bl1->eps[i] = w(bl1->p1[i],bl1->p2[i],bl1->p3[i],fmp);
2644
2645    sp1t1 = sp1t1 + bl1->p1[i];
2646    sp2t1 = sp2t1 + bl1->p2[i];
2647    sp3t1 = sp3t1 + bl1->p3[i];
2648  }
2649
2650  bl9->hel[bl3->ia1] = 0;
2651  bl5->nesc[bl3->ia1] = 0;
2652  bl1->ind2[bl3->ia1] = -1;
2653  bl1->ind1[bl3->ia1] = 0;
2654  bl3->x1[bl3->ia1] = -s1t1;
2655  bl3->x2[bl3->ia1] = -s2t1;
2656  bl3->x3[bl3->ia1] = -s3t1;
2657  bl1->p1[bl3->ia1] = -sp1t1;
2658  bl1->p2[bl3->ia1] = -sp2t1;
2659  bl1->p3[bl3->ia1] = -sp3t1;
2660  bl1->eps[bl3->ia1] = w(bl1->p1[bl3->ia1],bl1->p2[bl3->ia1],bl1->p3[bl3->ia1],fmp);
2661 
2662  // deutons
2663  jparticip[bl3->ia1] = 1;
2664  if(verboseLevel > 3) {
2665    G4cout <<"Particle " << bl3->ia1-1 << " is now participant." << G4endl;
2666  }
2667 pnu9: // continue
2668  // deutons
2669  // target preparation for 1 < a < 5 (with sum of momentum =0)
2670  if(bl3->ia2 >= 2 && bl3->ia2 <= 4) {
2671  pnu1633: 
2672    s1t1 = 0.0;
2673    s2t1 = 0.0;
2674    s3t1 = 0.0;
2675    sp1t1 = 0.0;
2676    sp2t1 = 0.0;
2677    sp3t1 = 0.0;
2678    efer = 0.0;
2679    for(G4int i = bl3->ia1+1; i <= ia; i++) {
2680    //    for(G4int i = bl3->ia1; i < ia-1; i++) {
2681    //    for(G4int i = bl3->ia1; i < ia; i++) {
2682      bl1->ind2[i] = 1;
2683      bl5->nesc[i] = 0;
2684      if (i > (iz2+bl3->ia1)) {
2685        bl1->ind2[i] = -1;
2686      }
2687      for(G4int j = 0; j < 7; j++) {
2688        standardRandom(&t[j], &(hazard->ial));
2689      }
2690
2691      t[1] = -1.0 + 2.0*t[1];      // t(2)->t[1]                                       
2692      t[2] = 6.283185*t[2];   // t(3)->t[2]                                     
2693      t[4] = -1.0 + 2.0*t[4];     // t(5)->t[4]                                 
2694      t[5] = 6.283185*t[5];   // t(6) -> t[5]                                     
2695      t1 = t[1];              // t(2)->t[1]                                           
2696      t2 = std::sqrt(1.0 - t1*t1);                                       
2697      t3 = std::cos(t[2]);  //t(3)->t[2]                                           
2698      t4 = std::sin(t[2]);   //t(3)->t[2]                                                                                     
2699      t5 = t[4];       // t(5)->t[4]                                                 
2700      t6 = std::sqrt(1.0 - t5*t5);                                         
2701      t7 = std::cos(t[5]);   //t(6) -> t[5]                                             
2702      t8 = std::sin(t[5]);   // t(6)->t[5]                                         
2703      if (ws->nosurf == 1) {
2704        x = bl3->r2*std::pow(t[0],0.33333333); // t(1)->t[0]                                     
2705        y = (bl10->pf)*std::pow(t[3],0.33333333); // t(4)->t[3] 
2706      }
2707      else {
2708        // surface..w.s.: impulsion (sphere dure), puis r(q)
2709        t33 = std::pow(t[6],0.33333333); // t(7)->t[6]
2710        y = (bl10->pf)*t33;
2711
2712        rr = interpolateFunction(t33);
2713        x = rr*std::pow(t[3],0.33333333); // t(4)->t[3]
2714        // fin surface on a redefini x et y
2715      }
2716      bl3->x1[i] = x*t2*t3;                                               
2717      bl3->x2[i] = x*t2*t4; 
2718      bl3->x3[i] = x*t1;                                                   
2719      s1t1 = s1t1 + bl3->x1[i];
2720      s2t1 = s2t1 + bl3->x2[i];
2721      s3t1 = s3t1+bl3->x3[i];
2722      bl1->p1[i] = y*t6*t7; 
2723      bl1->p2[i] = y*t6*t8;                                                 
2724      bl1->p3[i] = y*t5;                                                   
2725      sp1t1 = sp1t1+bl1->p1[i];
2726      sp2t1 = sp2t1+bl1->p2[i];
2727      sp3t1 = sp3t1+bl1->p3[i];
2728      bl1->ind1[i] = 0;                                                     
2729      bl1->eps[i] = w(bl1->p1[i],bl1->p2[i],bl1->p3[i],fmp);                           
2730      bl9->hel[i] = 0.0;
2731      efer = efer + bl1->eps[i] - fmp;                                       
2732    }
2733
2734    bl9->hel[ia] = 0; 
2735    bl5->nesc[ia] = 0;
2736    bl1->ind2[ia] = -1;
2737    bl1->ind1[ia] = 0;
2738    bl3->x1[ia] = -s1t1;
2739    bl3->x2[ia] = -s2t1;
2740    bl3->x3[ia] = -s3t1;
2741    bl1->p1[ia] = -sp1t1;
2742    bl1->p2[ia] = -sp2t1;
2743    bl1->p3[ia] = -sp3t1;
2744
2745    p_mod = std::sqrt(std::pow(bl1->p1[ia],2) + std::pow(bl1->p2[ia],2) + std::pow(bl1->p3[ia],2));
2746    if(p_mod > ((bl10->pf)+0.05)) {
2747      goto pnu1633;
2748    }
2749
2750    bl1->eps[ia] = w(bl1->p1[ia],bl1->p2[ia],bl1->p3[ia],fmp);
2751   
2752    efer = efer + bl1->eps[ia]-fmp;                                       
2753
2754  } //end if       !(bl3->ia2 >= 2 && bl3->ia2 <= 4)
2755
2756  // target preparation for a > 4
2757  if(bl3->ia2 > 4) {
2758    x1_target = 0.0;
2759    x2_target = 0.0;
2760    x3_target = 0.0;
2761    for(G4int i = bl3->ia1+1; i <= ia; i++) { //do 1 i=bl3->ia1+1,ia
2762      bl5->nesc[i] = 0;
2763      bl1->ind2[i] = 1;
2764      if (i > (iz2+bl3->ia1)) {
2765        bl1->ind2[i] = -1;
2766      }
2767      // surface ajout de t(7) surface.f avait do 6 j=2,7 ici 1,6 ?
2768      for(G4int j = 0; j < 7; j++) {
2769        standardRandom(&t[j], &(hazard->ial));
2770      }
2771
2772      //    pnu6: // continue
2773      t[1] = -1.0 + 2.0*t[1]; //t(2)->t[1]
2774      t[2] = 6.283185*t[2];
2775      t[4] = -1.0 + 2.0*t[4]; // t(5)->t[4]
2776      t[5] = 6.283185*t[5]; //t(6)->t[5]
2777      t1 = t[1]; // t(2)->t[1]
2778      t2 = std::sqrt(1.0 - t1*t1);
2779      t3 = std::cos(t[2]);  //t(3)->t[2]
2780      t4 = std::sin(t[2]); //t(3)->t[2]
2781      t5 = t[4]; //t(5)->t[4]
2782      t6 = std::sqrt(1.0 - t5*t5);
2783      t7 = std::cos(t[5]);  //t(6)->t[5]
2784      t8 = std::sin(t[5]);   // t(6)->t[5]
2785
2786      if (ws->nosurf == 1) {
2787        x = bl3->r2*std::pow(t[0],0.33333333); // t(1)->t[0]
2788        y = bl10->pf*std::pow(t[3],0.33333333); // t(4)->t3
2789      }
2790      else {
2791        // surface..w.s.: impulsion (sphere dure), puis r(q)
2792        t33 = std::pow(t[6],0.33333333); // t(7)->t[6]
2793        y=bl10->pf*t33;
2794        rr=interpolateFunction(t33);
2795        x=rr*std::pow(t[3],0.33333333); // t(4)->t[3]       
2796        // fin surface on a redefini x et y
2797      }
2798      bl3->x1[i] = x*t2*t3;
2799      bl3->x2[i] = x*t2*t4;
2800      bl3->x3[i] = x*t1;
2801      bl1->p1[i] = y*t6*t7;
2802      bl1->p2[i] = y*t6*t8;
2803      bl1->p3[i] = y*t5;
2804      x1_target = x1_target + bl3->x1[i];
2805      x2_target = x2_target + bl3->x2[i];
2806      x3_target = x3_target + bl3->x3[i];
2807      bl1->ind1[i] = 0;
2808      bl1->eps[i] = w(bl1->p1[i],bl1->p2[i],bl1->p3[i],fmp);
2809
2810      bl9->hel[i] = 0.0;
2811      efer = efer + bl1->eps[i] - fmp;
2812    }
2813    x1_target = x1_target/double(bl3->ia2);
2814    x2_target = x2_target/double(bl3->ia2);
2815    x3_target = x3_target/double(bl3->ia2);
2816  }
2817
2818  efrun = efrun + efer;
2819
2820  // location of incident particle at point (b,z)
2821  r22 = bl3->r2*(bl3->r2);
2822  z = ws->bmax * (ws->bmax) - b*b;       // for the wood-saxon density...
2823
2824  if (z < 0.0) {
2825    z=0.0;
2826  }
2827
2828  z = std::sqrt(z);
2829  // random azimuthal direction of the impact parameter (sept 99)
2830
2831  if (kindstruct->kindf7 <= 2) {
2832    G4long testseed = hazard->igraine[13];
2833    //    standardRandom(&tbid, &(hazard->igraine[13]));
2834    standardRandom(&tbid, &testseed);
2835    hazard->igraine[13] = testseed;
2836    tbid = tbid*6.283185;
2837    bl3->x1[1] = bl3->x1[1] + b*std::cos(tbid);  //x1(1)->x1[1]                                       
2838    bl3->x2[1] = bl3->x2[1] + b*std::sin(tbid); //x2(1)->x2[1]
2839    bl3->x3[1] = bl3->x3[1] - z;
2840    // pour le ntuple des avatars:
2841    if(varavat->kveux == 1) {
2842      varavat->r1_in[0] = bl3->x1[1]; //r1_in(1)->r1_in[0] and x1(1)->x1[0]
2843      varavat->r1_in[1] = bl3->x2[1]; //r1_in(2)->r1_in[1] and x1(2)->x1[1]
2844      varavat->r1_in[2] = bl3->x3[1]; //r1_in(3)->r1_in[2] and x1(3)->x1[2]
2845    } //endif
2846  }
2847  else {
2848    if (kindstruct->kindf7 < 6) { //then ! pour les pions on laisse
2849      //call standardRandom(tbid,iy14)
2850      standardRandom(&tbid, &(hazard->igraine[13]));
2851      tbid = tbid*6.283185;
2852      y1[1] = y1[1] + b*std::cos(tbid); //y1(1)->y1[0]
2853      y2[1] = y2[1] + b*std::sin(tbid); //y2(1)->y2[0]
2854      y3[1] = y3[1] - z;
2855    }
2856    else {
2857      // deutons
2858      //nmiss=0.;
2859      nmiss = 0;
2860      xlengm=1000.0;
2861     
2862      for(G4int i = 1; i <= bl3->ia1; i++) {
2863      //      for(G4int i = 1; i < bl3->ia1; i++) {
2864        bl3->x3[i] = bl3->x3[i]/ginc;
2865        zai2 = ws->rmaxws*(ws->rmaxws) - std::pow((b+bl3->x1[i]),2) - std::pow(bl3->x2[i],2);
2866        if (zai2 < 0.0) {
2867          goto pnu22;
2868        }
2869        ztu = -std::sqrt(zai2);
2870        // r22 remplace par rmaxws*rmaxws et r2 par rmaxws cv correct ?
2871        za_i = 2.0*(ws->rmaxws) + ztu;
2872        xleng = za_i - bl3->x3[i];
2873        if (xleng > xlengm) {
2874          //  goto pnu21;
2875          continue;
2876        }
2877        ilm = i;
2878        xlengm = xleng;
2879        ztouch = ztu;
2880        //      goto pnu21;
2881        continue;
2882      pnu22:
2883        nmiss = nmiss + 1; 
2884      }
2885      //    pnu21:
2886      if (nmiss == bl3->ia1) { //then
2887        nopart = -1;
2888        //      return;
2889        if(verboseLevel > 3) {
2890          G4cout <<"nmiss == bl3->ia1" << G4endl;
2891          G4cout <<"End of algorithm after pnu21." << G4endl;
2892        }
2893        goto pnureturn;
2894      }
2895      else {
2896        zshif = bl3->x3[ilm] - ztouch;
2897        standardRandom(&tbid, &(hazard->igraine[13]));
2898        tbid = tbid*6.283185;
2899        for(G4int i = 1; i <= bl3->ia1; i++) {
2900          xxx = bl3->x1[i] + b;
2901          bl3->x1[i] = xxx*std::cos(tbid) - bl3->x2[i]*std::sin(tbid);
2902          bl3->x2[i] = xxx*std::sin(tbid) + bl3->x2[i]*std::cos(tbid);
2903          bl3->x3[i] = bl3->x3[i] - zshif;
2904        }
2905        if (std::fabs(std::pow(bl3->x1[ilm],2)+std::pow(bl3->x2[ilm],2)+std::pow(bl3->x3[ilm],2)-ws->rmaxws*(ws->rmaxws)) > 0.01) {
2906          if(verboseLevel > 2) {
2907            G4cout <<"wrong position" << G4endl;
2908          }
2909        }
2910      }
2911    }
2912  }
2913
2914  // initial momentum for all type of incident particles:
2915  xl1 = b*pinc*std::sin(tbid);                                 
2916  xl2 = -b*pinc*std::cos(tbid);                                         
2917  xl3 = 0.0;                                           
2918
2919  // transcription in the general frame of reference
2920  // (here,=lab frame)
2921
2922  be = 0.0;
2923  ge = 1.0;
2924  b1 = (binc - be)/(1.0 - be*binc);
2925  b2 = -be;
2926  g1 = 1.0/std::sqrt(1.0 - b1*b1);
2927  g2 = 1.0;
2928  // deutons
2929  // here for nucleons
2930  if (kindstruct->kindf7 <= 2) {
2931    bl1->eps[1] = g1*fmp + v0;
2932    bl1->p3[1] = std::sqrt(std::pow(bl1->eps[1],2) - std::pow(fmp,2));
2933  }
2934  else {
2935    // here for pions
2936    if (kindstruct->kindf7 < 6) { //then
2937      q4[1] = g1*fmpi; // q4(1)->q4[0]
2938      q3[1] = b1*q4[1];
2939    }
2940    else {
2941      // here for composite projectiles:
2942      // the kinetic energy is below the threshold. put all
2943      // fermi momentum to 0... projectile nucleons not on shell!
2944      energie_in = tlab + fmpinc;
2945      if((energie_in) <= (bl3->ia1*fmp)) {
2946        for(G4int i = 1; i <= bl3->ia1; i++) {
2947          bl1->eps[i] = energie_in/double(bl3->ia1);
2948          bl1->p1[i] = 0.0;
2949          bl1->p2[i] = 0.0;
2950          bl1->p3[i] = pinc/double(bl3->ia1);
2951        }
2952        goto pnu1871;
2953      }
2954      // here the composit is above threshold
2955      for(G4int i = 1; i <= bl3->ia1; i++) { //do i=1,bl3->ia1  !save e,p in the composit rest frame
2956        eps_c[i] = bl1->eps[i];
2957        p3_c[i] = bl1->p3[i];
2958      } //enddo
2959
2960      nbtest = bl3->ia1 - 1;
2961      if(kindstruct->kindf7 == 6) {
2962        nbtest = 2;
2963      }
2964      iflag = 0;
2965    pnu1870:
2966      sueps = 0.0;
2967
2968      iflag = iflag + 1;
2969
2970      for(G4int i = 1; i <= bl3->ia1; i++) { //do i=1,bl3->ia1
2971        tte = eps_c[i];
2972        bl1->eps[i] = g1*(eps_c[i] + b1*p3_c[i]);
2973        bl1->p3[i] = g1*(b1*tte + p3_c[i]);
2974        sueps = sueps + bl1->eps[i];
2975      } //enddo
2976
2977      cobe = (tlab + fmpinc)/sueps;
2978
2979      // off shell problem for incident clusters (a.b. 2/2002)
2980
2981      if(iflag == nbtest) { // too much..all momentum to 0
2982        for(G4int klm = 1; klm <= bl3->ia1; klm++) { //do klm=1,bl3->ia1
2983          eps_c[klm] = fmp;
2984          bl1->p1[klm] = 0.0;
2985          bl1->p2[klm] = 0.0;
2986          p3_c[klm] = 0;
2987        }
2988        goto pnu1870;
2989      }
2990      for(G4int i = 1; i <= bl3->ia1; i++) { //do i=1,bl3->ia1
2991        arg = std::pow((cobe*(bl1->eps[i])),2)-pm2;
2992        if (arg <= 0.) { //then ! put maximum momentum to 0.
2993          i_emax = 1; //        !find maximum
2994          ener_max = bl1->eps[1];
2995          for(G4int klm = 2; klm <= bl3->ia1; klm++) { //do klm=2,bl3->ia1     
2996            if(bl1->eps[klm] > ener_max) {
2997              ener_max = bl1->eps[klm];
2998              i_emax = klm;
2999            }
3000          }
3001          eps_c[i_emax] = fmp;
3002          bl1->p1[i_emax] = 0.0;
3003          bl1->p2[i_emax] = 0.0;
3004          p3_c[i_emax] = 0.0;
3005
3006          if(i_emax == bl3->ia1) { //    circular permut if the last one
3007            epsv = eps_c[bl3->ia1]; //   permutation circulaire
3008            p1v = bl1->p1[bl3->ia1];
3009            p2v = bl1->p2[bl3->ia1];
3010            p3v = p3_c[bl3->ia1];
3011            for(bl2->k = bl3->ia1-1; bl2->k >= 1; bl2->k = bl2->k - 1) { //do k=bl3->ia1-1,1,-1
3012              eps_c[bl2->k+1] = eps_c[bl2->k];
3013              bl1->p1[bl2->k+1] = bl1->p1[bl2->k];
3014              bl1->p2[bl2->k+1] = bl1->p2[bl2->k];
3015              p3_c[bl2->k+1] = p3_c[bl2->k];
3016            }
3017            eps_c[1] = epsv;
3018            bl1->p1[1] = p1v;
3019            bl1->p2[1] = p2v;
3020            p3_c[1] = p3v;      // fin permut.
3021          }
3022          sp1t1 = 0.0;   // re-compute the last one
3023          sp2t1 = 0.0;
3024          sp3t1 = 0.0;
3025          for(G4int j = 1; j <= bl3->ia1-1; j++) { //do j=1,bl3->ia1-1
3026            sp1t1 = sp1t1 + bl1->p1[j];
3027            sp2t1 = sp2t1 + bl1->p2[j];
3028            sp3t1 = sp3t1 + p3_c[j];
3029          }
3030          bl1->p1[bl3->ia1] = -sp1t1;
3031          bl1->p2[bl3->ia1] = -sp2t1;
3032          p3_c[bl3->ia1] = -sp3t1;
3033          eps_c[bl3->ia1] = w(bl1->p1[bl3->ia1],bl1->p2[bl3->ia1],p3_c[bl3->ia1],fmp); 
3034
3035          goto pnu1870;  // ..and boost all of them.
3036        }
3037      }
3038
3039      for(G4int i = 1; i <= bl3->ia1; i++) { //do i=1,bl3->ia1
3040      //      for(G4int i = 1; i < bl3->ia1; i++) { //do i=1,bl3->ia1
3041        arg = std::pow((cobe*(bl1->eps[i])),2) - pm2;
3042        comom = std::sqrt(arg/(std::pow(bl1->eps[i],2) - pm2));
3043        bl1->p1[i] = comom*(bl1->p1[i]);
3044        bl1->p2[i] = comom*(bl1->p2[i]);
3045        bl1->p3[i] = comom*(bl1->p3[i]);
3046        bl1->eps[i] = bl1->eps[i]*cobe;
3047        if (std::fabs(am(bl1->p1[i],bl1->p2[i],bl1->p3[i],bl1->eps[i])-fmp) > 0.01) {
3048          if(verboseLevel > 2) {
3049            G4cout <<"wrong correction " << i << G4endl;                 
3050          }
3051        }
3052      }
3053      bl1->eps[ilm] = bl1->eps[ilm] + v0; 
3054    }
3055  }
3056
3057 pnu1871:
3058  // evaluation of the times t(a,b)
3059  bl2->k = 0;
3060  kcol = 0;
3061  if (kindstruct->kindf7 <= 2) {
3062    // modif s.vuillier tient compte propagation projectile,1e collision
3063    // imposee pour lui (c'est une maniere de faire!!)
3064    G4int ioldk = 0;
3065    for(G4int i = 1; i <= ia; i++) { //do 40 i=1,ia
3066      ioldk = bl2->k;
3067      //   bl2->k = bl2->k + 1;
3068      //                tref=ref(x1(i),x2(i),x3(i),p1(i),p2(i),p3(i),eps(i),r22)          p-n04740
3069      tref = ref(bl3->x1[i], bl3->x2[i], bl3->x3[i], bl1->p1[i], bl1->p2[i], bl1->p3[i], bl1->eps[i], r22); 
3070      if (tref > bl4->tmax5) {
3071        goto pnu45;
3072      }
3073
3074      bl2->k = bl2->k + 1;
3075      bl2->crois[bl2->k]=tref;
3076      bl2->ind[bl2->k]=i;
3077      bl2->jnd[bl2->k]=-1;
3078    pnu45:
3079      i1=i-1;
3080      if (i == 1) {
3081        //goto pnu40;
3082        continue;
3083      }
3084      //   1326 c ici on ne calcule que les G4interactions nn impliquant le projectile !!! (2/02)
3085      if (i1 > bl3->ia1) {
3086        i1=bl3->ia1;
3087      }
3088      for(G4int j = 1; j <= i1; j++) { //do 41 j=1,i1
3089        // no collisions before the first collision of the incident particle
3090        time (i, j);
3091        if (bl1->ta < 0.0) {
3092          continue;
3093        }
3094        if(bl1->ta > bl4->tmax5) {
3095          continue;
3096        }
3097        eij=am(bl1->p1[i]+bl1->p1[j],bl1->p2[i]+bl1->p2[j],bl1->p3[i]+bl1->p3[j],bl1->eps[i]+bl1->eps[j]);
3098        if (eij < 1925.0) {
3099          continue;
3100        }
3101        isos=bl1->ind2[i]+bl1->ind2[j];
3102
3103        if (31.0*(bl3->rab2) > totalCrossSection(eij,0,isos)) {
3104          continue;
3105        }
3106
3107        bl2->k = bl2->k + 1;
3108        if (j == 1) {
3109          kcol = kcol + 1;
3110        }
3111        bl2->crois[bl2->k]=bl1->ta;
3112        bl2->ind[bl2->k]=i;
3113        bl2->jnd[bl2->k]=j;
3114      }
3115      if(verboseLevel > 3) {
3116        if(bl2->k == (ioldk + 2)) {
3117          if(verboseLevel > 2) {
3118            G4cout <<"bl2->k incremented twice!" << G4endl;
3119          }
3120        }
3121      }
3122    }
3123  }
3124  else {
3125    // deutons
3126    if (kindstruct->kindf7 < 6) { //then
3127      // here for incoming pions:
3128      for(G4int i = bl3->ia1+1; i <= ia; i++) { //do i=ia1+1,ia
3129        tref = ref(bl3->x1[i], bl3->x2[i], bl3->x3[i], bl1->p1[i], bl1->p2[i], bl1->p3[i], bl1->eps[i], r22); 
3130        if (tref < bl4->tmax5) {
3131          bl2->k = bl2->k + 1;
3132          bl2->crois[bl2->k] = tref;
3133          bl2->ind[bl2->k] = i;
3134          bl2->jnd[bl2->k] = -1;
3135        }
3136      }
3137      new2(y1[1], y2[1], y3[1], q1[1], q2[1], q3[1], q4[1], 1, 0);
3138
3139      //   modif a.b. 21/06/2002: should check at least one valid collision
3140      //   1361 c    with incoming pion.
3141      //   1362 c      kcol=1
3142      if(bl2->k != 0) {
3143        kcol = 1;
3144      }
3145    }
3146    else {
3147      for(G4int i = 1; i <= bl3->ia1; i++) { //do 38 i=1,ia1
3148        bl5->nesc[i] = 1;
3149        if (i != ilm) { 
3150          goto pnu36;
3151        }
3152        tref = ref(bl3->x1[i], bl3->x2[i], bl3->x3[i], bl1->p1[i], bl1->p2[i], bl1->p3[i], bl1->eps[i], r22);
3153        if(verboseLevel > 3) {
3154          if(tref < 0.0) {
3155            if(verboseLevel > 2) {
3156              G4cout <<"G4Incl: Reflection time < 0! (line 2579)" << G4endl;
3157            }
3158          }
3159        }
3160        bl5->nesc[i] = 0;
3161        npproj[i] = 0;
3162        goto pnu37;
3163      pnu36:
3164        t1 = bl3->x1[i]*(bl1->p1[i])+bl3->x2[i]*(bl1->p2[i])+bl3->x3[i]*(bl1->p3[i]);                     
3165        t2 = bl1->p1[i]*(bl1->p1[i])+bl1->p2[i]*(bl1->p2[i])+bl1->p3[i]*(bl1->p3[i]);               
3166        t3 = t1/t2;
3167        t4 = bl3->x1[i]*(bl3->x1[i])+bl3->x2[i]*(bl3->x2[i])+bl3->x3[i]*(bl3->x3[i]); 
3168        //   1379       c incoming nucleons enter potential at maximum radius (modif. 13/06/01)
3169        t5 = t3*t3 + ((ws->rmaxws)*(ws->rmaxws) - t4)/t2;
3170        if(verboseLevel > 3) {
3171          G4cout <<"x1 = " << bl3->x1[i] <<" x2 = " << bl3->x2[i] <<" x3 = " << bl3->x3[i] << G4endl; 
3172          G4cout <<"t1 = " << t1 << G4endl;
3173          G4cout <<"t2 = " << t2 << G4endl;
3174          G4cout <<"t3 = " << t3 << G4endl;
3175          G4cout <<"t4 = " << t4 << G4endl;
3176          G4cout <<"rmaxws = " << ws->rmaxws << G4endl;
3177          G4cout <<"t5 = " << t5 << G4endl;
3178        }
3179        if (t5 < 0.) {
3180          continue;
3181        }
3182        tref = (-1.0*t3 - std::sqrt(t5))*(bl1->eps[i]); 
3183        if (tref > bl4->tmax5) {
3184          continue;
3185        }
3186        npproj[i] = 1;
3187      pnu37:
3188        bl2->k = bl2->k + 1; 
3189        bl2->crois[bl2->k] = tref; 
3190        bl2->ind[bl2->k] = i; 
3191        bl2->jnd[bl2->k] = -1;
3192      }
3193      kcol = 1;
3194     
3195      //      for(G4int i = bl3->ia1+1; i < ia; i++) { //do  39 i=ia1+1,ia
3196      for(G4int i = bl3->ia1+1; i <= ia; i++) { //do  39 i=ia1+1,ia
3197        npproj[i] = 0;
3198        tref = ref(bl3->x1[i], bl3->x2[i], bl3->x3[i], bl1->p1[i], bl1->p2[i], bl1->p3[i], bl1->eps[i], r22); // line 2609
3199        if(verboseLevel > 3) {
3200          if(tref < 0.0) {
3201            G4cout <<"G4Incl: Reflection time < 0! (line 2609)" << G4endl;
3202          }
3203        }
3204
3205        if (tref < bl4->tmax5) { //then
3206          bl2->k = bl2->k + 1;
3207          bl2->crois[bl2->k]=tref;
3208          bl2->ind[bl2->k]=i;
3209          bl2->jnd[bl2->k]=-1;
3210        } //endif
3211
3212        time (i, ilm);
3213        if (bl1->ta < 0.) {
3214          continue;
3215        }
3216        if (bl1->ta > bl4->tmax5) {
3217          continue;
3218        }
3219        eij=am(bl1->p1[i]+bl1->p1[ilm],bl1->p2[i]+bl1->p2[ilm],bl1->p3[i]+bl1->p3[ilm],bl1->eps[i]+bl1->eps[ilm]);
3220        if (eij < 1925.0) {
3221          continue;
3222        }
3223        isos=bl1->ind2[i]+bl1->ind2[ilm];                                             
3224        if (31.*(bl3->rab2) > totalCrossSection(eij,0,isos)) {
3225          continue;
3226        }                                                               
3227        bl2->k = bl2->k + 1;                                                             
3228        kcol=kcol+1; 
3229        bl2->crois[bl2->k]=bl1->ta;                                                     
3230        bl2->ind[bl2->k]=i; 
3231        bl2->jnd[bl2->k]=ilm;
3232      }
3233    }
3234  }
3235
3236  //  dumpBl3(dumpOut);
3237
3238  if(verboseLevel > 3) {
3239    G4cout <<"Variables after time evaluation:" << G4endl;
3240
3241    G4cout <<"bl3->ia1 + bl3->ia2 = ia " << G4endl;
3242    G4cout << bl3->ia1 << "         " << bl3->ia2 << "          " << ia << G4endl; 
3243    G4cout <<"B11" << G4endl;
3244
3245    for(G4int idebugtest = 0; idebugtest <= bl2->k; idebugtest++) {
3246      G4cout <<"index = " << idebugtest << " ind1 = " << bl1->ind1[idebugtest] << " ind2 = " << bl1->ind2[idebugtest] << " p1 = " << bl1->p1[idebugtest] << " p2 = " << bl1->p2[idebugtest] << " p3 = " << bl1->p3[idebugtest] << " bl1->eps = " << bl1->eps[idebugtest] << G4endl;
3247    }
3248   
3249    G4cout <<"Bl2" << G4endl;
3250    for(G4int idebugtest = 0; idebugtest <= bl2->k; idebugtest++) {
3251      G4cout <<"index = " << idebugtest << " ind = " << bl2->ind[idebugtest] << " jnd = " << bl2->jnd[idebugtest] << " crois = " << bl2->crois[idebugtest] << G4endl;
3252    }
3253
3254    G4cout <<"jparticip[i]" << G4endl;
3255    for(G4int idebugtest = 0; idebugtest < 300; idebugtest++) {
3256      G4cout <<" " << jparticip[idebugtest];
3257    }
3258    G4cout << G4endl;
3259  }
3260 
3261
3262  // deutons
3263  if (kcol != 0) {
3264    if(verboseLevel > 3) {
3265      G4cout <<"After time evaluation: kcol != 0!" << G4endl;
3266    }
3267    goto pnu48;
3268  }
3269  nopart = -1;
3270  // Pour eviter renvoi des resultats du run precedent cv 7/7/98
3271  iarem = bl3->ia2;
3272  izrem = iz2;
3273  esrem = 0.0;
3274  erecrem = 0.0;
3275
3276  if(verboseLevel > 3) {
3277    G4cout <<"kcol == 0. No collisions..." << G4endl;
3278    G4cout <<"End of algorithm because kcol == 0." << G4endl;
3279    G4cout <<"kcol = " << kcol << G4endl;
3280    G4cout <<"Return after pnu39." << G4endl;
3281  }
3282  // fin ajout cv
3283  goto pnureturn;
3284
3285  // Initialization  at the beginning of the run
3286 pnu48:
3287  if(verboseLevel > 3) {
3288    G4cout <<"Beginning a run..." << G4endl;
3289  }
3290  timi = 0.0;
3291  tim = 0.0;
3292  ncol = 0;
3293
3294  // compteur des collisions a deux corps (call collis acceptes par pauli)
3295  ncol_2c = 0;
3296
3297  //C  npion=0;
3298  mrnn = 0;
3299  mrnd = 0;
3300  mrdd = 0;
3301  mrdn = 0;
3302  mrdp = 0;
3303  mrpd = 0;
3304  mcdd = 0;
3305  mpaul2 = 0;
3306  mpaul1 = 0;
3307
3308  // approx. (not considering escaping protons of incident clusters) 11/03 a.b.
3309  itch = iz1 + iz2 - 1;
3310  for(G4int i = 1; i <= ia; i++)  { //do 47 i=1,ia
3311    bl5->tlg[i] = 0.0;
3312    nc[i] = 0;
3313  }
3314  itt = 1;
3315
3316  // tableau des energies a l'initialisation
3317  if(varavat->kveux == 1) {
3318    for(G4int i = bl3->ia1+1; i <= ia; i++) {
3319      varavat->epsd[i] = bl1->eps[i];
3320    }
3321    iflag20 = 0;
3322    iflag40 = 0;
3323    iflag60 = 0;
3324  }
3325
3326  // search for the smallest positive t(a,b)
3327  // pour tests, =0 G4interdit les  reflexions avant un avatar du projectile,
3328  //             =1 comme avant (reflexions autorisees). (a.b. 3/2002)
3329  irst_avatar = 1;
3330
3331  if(verboseLevel > 3) {
3332    G4cout <<"Now arriving to label pnu449." << G4endl;
3333  }
3334 pnu449:
3335  if(verboseLevel > 3) {
3336    G4cout <<"Now at 449" << G4endl;
3337    G4cout <<"G4Incl: Now at label pnu449." << G4endl;
3338  }
3339  next = 1;
3340  indic[next] = 1;
3341
3342 pnu44:
3343  if(verboseLevel > 3) {
3344    G4cout <<"Now at 44" << G4endl;
3345    G4cout <<"Starting a new loop at pnu44..." << G4endl;
3346  }
3347  if(next == 0) {
3348    if(verboseLevel > 3) {
3349      G4cout <<"next == 0. Returning to label pnu449." << G4endl;
3350      G4cout <<"next == 0" << G4endl;
3351    }
3352    goto pnu449;
3353  }
3354 
3355  idep = indic[next] + 1;
3356  tau = bl2->crois[idep-1];
3357
3358  if(idep > bl2->k) {
3359    if(verboseLevel > 3) {
3360      G4cout <<"G4Incl: idep > bl2->k. Going to pnu448." << G4endl;
3361    }
3362    goto pnu448;
3363  }
3364  for(G4int i = idep; i <= bl2->k; i++) { //do 42 i=idep,k
3365    if (bl2->crois[i] > tau) {
3366      continue;
3367    }
3368    tau = bl2->crois[i]; 
3369    next = next + 1;
3370    indic[next] = i;
3371  }
3372
3373  if(verboseLevel > 3) {
3374    G4cout <<"next = " << next << G4endl;
3375  }
3376 pnu448:
3377  imin = indic[next];
3378  bl9->l1 = bl2->ind[imin]; //NOTE: l1 changed to bl9->l1.
3379  bl9->l2 = bl2->jnd[imin]; //NOTE: l2 changed to bl9->l2.
3380
3381  // test le 20/3/2003: tue sinon le dernier avatar?
3382  if (bl2->k == 0) {
3383    if(verboseLevel > 2) {
3384      G4cout <<"k == 0. Going to the end of the avatar." << G4endl;
3385    }
3386    goto pnu230;
3387  }
3388  bl2->k = bl2->k - 1; // bugfix k belongs to struct bl2!
3389  next = next - 1;
3390
3391  // correction s.vuillier 25/1/96 decalage temps correct
3392  if (imin > bl2->k) {
3393    goto pnu46;
3394  }
3395
3396  for(G4int i = imin; i <= bl2->k; i++) { //do 43 i=imin,k
3397    bl2->crois[i] = bl2->crois[i+1];
3398    bl2->ind[i] = bl2->ind[i+1];
3399    bl2->jnd[i] = bl2->jnd[i+1];
3400  }
3401 pnu46:
3402  if(verboseLevel > 3) {
3403    G4cout <<"G4Incl: Now at pnu46." << G4endl;
3404  }
3405  tim = timi + tau;
3406
3407  // tableau des energies a t=20,40,60 fm/c
3408  if(varavat->kveux == 1) {
3409    if(iflag20 == 0 && tim >= 20.0) {
3410      iflag20 = 1;
3411      for(G4int i = 1; i <= ia; i++) {
3412        if(bl5->nesc[i] == 0) {
3413          if(jparticip[i] == 1) {
3414            varavat->eps2[i] = bl1->eps[i];
3415          }
3416          else {
3417            varavat->eps2[i] = 0.0;
3418          }
3419        }
3420        else {
3421          varavat->eps2[i] = 0.;
3422        }
3423      }
3424    }
3425   
3426    if(iflag40 == 0 && tim >= 40.0) {
3427      iflag40 = 1;
3428      for(G4int i = 1; i <= ia; i++) {
3429        if(bl5->nesc[i] == 0) {
3430          if(jparticip[i] == 1) {
3431            varavat->eps4[i] = bl1->eps[i];
3432          }
3433          else {
3434            varavat->eps4[i] = 0.0;
3435          }
3436        }
3437        else {
3438          varavat->eps4[i] = 0.0;
3439        }
3440      }
3441    }
3442   
3443    if(iflag60 == 0 && tim >= 60.) {
3444      iflag60=1;
3445      for(G4int i = 1; i <= ia; i++) {
3446        if(bl5->nesc[i] == 0) {
3447          if(jparticip[i] == 1) {
3448            varavat->eps6[i] = bl1->eps[i];
3449          }
3450          else {
3451            varavat->eps6[i] = 0.0;
3452          }
3453        }
3454        else {
3455          varavat->eps6[i] = 0.0;
3456        }
3457      }
3458    }
3459  }
3460
3461  // modif: pas de reflexions avant au moins un avatar du (des) nucleon incident
3462  // celui-ci ne peut etre qu'une collision nn (ou pin)
3463
3464  if((irst_avatar == 0) && (bl9->l2 == -1)) {
3465    if(verboseLevel > 3) {
3466      G4cout <<"Interaction type: reflection (l2 = " << bl9->l2 << "). No first interaction with a participant yet." << G4endl;
3467    }
3468    goto pnu44;
3469  }
3470
3471  irst_avatar = irst_avatar+1;
3472
3473  if (tim < temfin) {
3474    if(verboseLevel > 3) {
3475      G4cout <<"G4Incl: tim < temfin. Going to pnu49 (line 2886)" << G4endl;
3476    }
3477    goto pnu49; // line 2886
3478  }
3479
3480  goto pnu255;
3481 pnu49:
3482  if(verboseLevel > 3) {
3483    G4cout <<"G4Incl: Now at pnu49. " << G4endl;
3484  }
3485 
3486  if (bl2->k == 0) {
3487    if(verboseLevel > 3) {
3488      G4cout <<"G4Incl: bl2->k == 0. Going to pnu255." << G4endl;
3489    }
3490    goto pnu255;
3491  }
3492  // l1 va a la surface du noyau:
3493  if (bl9->l2 == -1) {
3494    if(verboseLevel > 3) {
3495      G4cout <<"G4Incl: l2 == -1. Going to pnu220." << G4endl;
3496    }
3497    goto pnu220;
3498  }
3499
3500  if((k4-1) <= 0) {
3501    if(verboseLevel > 3) {
3502      G4cout <<"G4Incl: (k4 - 1) <= 0. Going to pnu803." << G4endl;
3503    }
3504    goto pnu803;
3505  }
3506  if((k4-1) > 0) {
3507    if(verboseLevel > 3) {
3508      G4cout <<"G4Incl: (k4 - 1) > 0. Going to pnu830." << G4endl;
3509    }
3510    goto pnu830;
3511  }
3512
3513  // l1 est un delta:
3514 pnu830:
3515  if(verboseLevel > 3) {
3516    G4cout <<"G4Incl: Now at pnu830." << G4endl;
3517  }
3518 
3519  if(bl9->l2 == 0) {
3520    goto pnu220;
3521  }
3522  // interaction pi(l1-ia)-nucleon(l2)
3523  if(bl9->l1 > ia) { // line 2916
3524    if(verboseLevel > 3) {
3525      G4cout <<"G4Incl: l1 > ia (line 2916)" << G4endl;
3526    }
3527    goto pnu801;
3528  }
3529 pnu803:
3530  // pas de collision entre 2 non participants:
3531  if(jparticip[bl9->l1] == 0 && jparticip[bl9->l2] == 0) {
3532    if(verboseLevel > 3) {
3533      G4cout <<"G4Incl: both particles are spectators. No collision. " << G4endl;
3534    }
3535    goto pnu44;
3536  }
3537
3538  // parameters for the next colliding pair
3539  t[9] = bl1->eps[bl9->l1] + bl1->eps[bl9->l2]; //t(10)->t[9]
3540  t0 = 1.0/t[9]; // t(10)->t[9]
3541  b1 = (bl1->p1[bl9->l1] + bl1->p1[bl9->l2])*t0;
3542  b2 = (bl1->p2[bl9->l1] + bl1->p2[bl9->l2])*t0;
3543  b3 = (bl1->p3[bl9->l1] + bl1->p3[bl9->l2])*t0;
3544  s = (1.0 - b1*b1 - b2*b2 - b3*b3)*t[9]*t[9]; //t(10)->t[9]
3545  sq = std::sqrt(s);
3546
3547  if(sq < 1925.5) {
3548    if(verboseLevel > 3) {
3549      G4cout <<"sq < 1925.5" << G4endl;
3550      G4cout <<"Particles: l1 = " << bl9->l1 << " l2 = " << bl9->l2 << G4endl;
3551      G4cout <<"eps[bl9->l1] = " << bl1->eps[bl9->l1] << " eps[bl9->l2] = " << bl1->eps[bl9->l2] << G4endl;
3552      G4cout <<"p1[bl9->l1] = " << bl1->p1[bl9->l1] << " p1[bl9->l2] = " << bl1->p1[bl9->l2] << G4endl;
3553      G4cout <<"p2[bl9->l1] = " << bl1->p2[bl9->l1] << " p2[bl9->l2] = " << bl1->p2[bl9->l2] << G4endl;
3554      G4cout <<"p3[bl9->l1] = " << bl1->p3[bl9->l1] << " p3[bl9->l2] = " << bl1->p3[bl9->l2] << G4endl;
3555      G4cout <<"sq = " << sq << G4endl;
3556    }
3557    goto pnu44;
3558  }
3559
3560  bl1->ta = tau/bl1->eps[bl9->l1];
3561  x1l1 = bl3->x1[bl9->l1] + bl1->p1[bl9->l1]*(bl1->ta);
3562  x2l1 = bl3->x2[bl9->l1] + bl1->p2[bl9->l1]*(bl1->ta);
3563  x3l1 = bl3->x3[bl9->l1] + bl1->p3[bl9->l1]*(bl1->ta);
3564
3565  bl1->ta = tau/bl1->eps[bl9->l2];
3566  x1l2 = bl3->x1[bl9->l2] + bl1->p1[bl9->l2]*(bl1->ta);
3567  x2l2 = bl3->x2[bl9->l2] + bl1->p2[bl9->l2]*(bl1->ta);
3568  x3l2 = bl3->x3[bl9->l2] + bl1->p3[bl9->l2]*(bl1->ta);
3569
3570  // test on the minimum distance of approach
3571  t[10] = x1l1 - x1l2; //t(11)->t[10]
3572  t[11] = x2l1 - x2l2; //t(12)->t[11]
3573  t[12] = x3l1 - x3l2; //t(13)->t[12]
3574  t[13] = t[10]*t[10] + t[11]*t[11] + t[12]*t[12]; //t(N)->t[N-1]
3575  t[14] = b1*t[10] + b2*t[11] + b3*t[12]; //t(N)->t[N-1]
3576  t[15] = b1*b1 + b2*b2 + b3*b3; //t(16)->t[15]
3577  bb2 = t[13] + t[14]*t[14]/(1.0 - t[15]); //t(N)->t[N-1]
3578
3579  if(verboseLevel > 3) {
3580    G4cout <<"Minimum dist. of approach tested..." << G4endl;
3581  }
3582 
3583  // Replaced goto structure:
3584  // if (k3 == 1) go to 260
3585  // if (k4 == 0) go to 260
3586  if(k3 != 1 && k4 != 0) {
3587    mg=bl1->ind1[bl9->l1]+bl1->ind1[bl9->l2];
3588    isos=bl1->ind2[bl9->l1]+bl1->ind2[bl9->l2];
3589  }
3590  if((k3 != 1) && (k4 != 0) && (mg == 1)) {
3591    // if (mg != 1) go to 260
3592    ldel = bl9->l2;
3593    if(mg-bl1->ind1[bl9->l1] == 0) {
3594      ldel = bl9->l1;
3595    }
3596    bl6->xx10 = std::sqrt(std::pow(bl1->eps[ldel],2) - std::pow(bl1->p1[ldel],2) - std::pow(bl1->p2[ldel],2) - std::pow(bl1->p3[ldel],2));
3597    bl6->isa = bl1->ind2[ldel];
3598    bmax2 = totalCrossSection(sq,mg,isos)/31.415926;
3599    if (k5 == 0 && mg != 0) {
3600      bmax2 = bmax2 - lowEnergy(sq,mg,isos)/31.415926;
3601    }
3602    // go to 261
3603  }
3604  else {
3605    bmax2 = totalCrossSection(sq,mg,isos)/31.41592;
3606  }
3607
3608  if (bb2 < bmax2) {
3609    goto pnu220;
3610  }
3611  if (bl2->k == 0) {
3612    goto pnu230;
3613  }
3614
3615  if(verboseLevel > 3) {
3616    G4cout <<"bb2 >= bmax2 or bl2->k == 0" << G4endl;
3617  }
3618  goto pnu44;
3619  // loop while((bb2 >= bmax2) && (k != 0)) (PK)
3620  // evaluation of the positions at time = tim
3621 pnu220:
3622  timi = tim;
3623   if(verboseLevel > 3) {
3624     G4cout <<"Evaluating positions at time = tim" << G4endl;
3625     G4cout <<"tim = " << tim << G4endl;
3626   }
3627
3628//   dumpSaxw(dumpOut);
3629//   dumpBl1(dumpOut);
3630//   dumpBl2(dumpOut);
3631//   dumpBl3(dumpOut);
3632
3633  if(varavat->kveux == 1) { //then
3634    iavat = iavat + 1;
3635    varavat->timeavat[iavat] = tim;
3636    varavat->l1avat[iavat] = bl9->l1;
3637    varavat->l2avat[iavat] = bl9->l2;
3638    varavat->energyavat[iavat] = sq;
3639
3640    if(bl9->l1 <= ia) {
3641      varavat->jpartl1[iavat] = jparticip[bl9->l1];
3642    }
3643    else {
3644      varavat->jpartl1[iavat] = 0;
3645    }
3646
3647    if(bl9->l2 > 0) {
3648      varavat->jpartl2[iavat] = jparticip[bl9->l2];
3649    }
3650    else {
3651      varavat->jpartl2[iavat] = 0;
3652    }
3653  }
3654
3655  // gel des nucleons non participants sur le premier avatar (nn)=(l1,1)     
3656  if (irst_avatar == 1) {
3657    for(G4int i = 1; i <= bl9->l1; i = i + bl9->l1 - 1) { // bugfix!
3658      bl1->ta = tau/bl1->eps[i];                                               
3659      bl3->x1[i] = bl3->x1[i] + bl1->p1[i]*(bl1->ta);                                     
3660      bl3->x2[i] = bl3->x2[i] + bl1->p2[i]*(bl1->ta);                                   
3661      bl3->x3[i] = bl3->x3[i] + bl1->p3[i]*(bl1->ta);
3662      if(verboseLevel > 3) {
3663        G4cout <<"G4Incl: i = " << G4endl;
3664      }
3665    }
3666    for(G4int i = 1; i <= bl2->k; i++) {
3667      bl2->crois[i] = bl2->crois[i] + tau;
3668    }
3669  }
3670  else {
3671    for(G4int i = 1; i <= ia; i++) {
3672      bl1->ta = tau/bl1->eps[i];
3673      bl3->x1[i] = bl3->x1[i] + bl1->p1[i]*(bl1->ta);
3674      bl3->x2[i] = bl3->x2[i] + bl1->p2[i]*(bl1->ta);
3675      bl3->x3[i] = bl3->x3[i] + bl1->p3[i]*(bl1->ta);
3676    }
3677  }
3678
3679  //  if(npion != 0) {
3680  if(npion > 0) {
3681    for(G4int i = 1; i <= npion; i++) {
3682      bl1->ta = tau/q4[i];
3683      y1[i] = y1[i] + q1[i]*(bl1->ta);
3684      y2[i] = y2[i] + q2[i]*(bl1->ta);
3685      y3[i] = y3[i] + q3[i]*(bl1->ta);
3686    }
3687  }
3688
3689  if(bl9->l2 == 0) {
3690    if(verboseLevel > 3) {
3691      G4cout <<"G4Incl: l2 == 0. Going to pnu805." << G4endl;
3692    }
3693    goto pnu805;
3694  }
3695  // Candidate: if(l2!=0)...
3696
3697  // reflexions sur le potentiel, sortie eventuelle de la particule:
3698  if (bl9->l2 == -1) {
3699    if(verboseLevel > 3) {
3700      G4cout <<"G4Incl: l2 == -1. Going to pnu600." << G4endl;
3701    }
3702    goto pnu600;
3703  }
3704
3705  if(bl9->l1 > ia) {
3706    if(verboseLevel > 3) {
3707      G4cout <<"G4Incl: l1 > ia. Going to pnu831." << G4endl;
3708    }
3709    goto pnu831;
3710  }
3711
3712  // collision of particles l1 and l2
3713  if(verboseLevel > 3) {
3714    G4cout <<"Particles l1 and l2 collide!" << G4endl;
3715  }
3716 
3717  ich1 = bl1->ind1[bl9->l1];
3718  ich2 = bl1->ind1[bl9->l2];
3719  ich3 = bl1->ind2[bl9->l1];
3720  ich4 = bl1->ind2[bl9->l2];
3721  aml1 = std::sqrt(std::pow(bl1->eps[bl9->l1],2) - std::pow(bl1->p1[bl9->l1],2) - std::pow(bl1->p2[bl9->l1],2) - std::pow(bl1->p3[bl9->l1],2));
3722  aml2 = std::sqrt(std::pow(bl1->eps[bl9->l2],2) - std::pow(bl1->p1[bl9->l2],2) - std::pow(bl1->p2[bl9->l2],2) - std::pow(bl1->p3[bl9->l2],2));
3723  gl1 = bl1->eps[bl9->l1]/aml1;
3724  gl2 = bl1->eps[bl9->l2]/aml2;
3725  // l-conservation
3726  if (k6 == 1) {
3727    t[30] = (aml1*(bl3->x1[bl9->l1]) + aml2*(bl3->x1[bl9->l2]))/(aml1 + aml2); //t(31)->t[30]
3728    t[31] = (aml1*(bl3->x2[bl9->l1]) + aml2*(bl3->x2[bl9->l2]))/(aml1 + aml2); //t(32)->t[31]
3729    t[32] = (aml1*(bl3->x3[bl9->l1]) + aml2*(bl3->x3[bl9->l2]))/(aml1 + aml2); //t(33)->t[32]
3730    tt31 = bl3->x1[bl9->l1] - bl3->x1[bl9->l2];
3731    tt32 = bl3->x2[bl9->l1] - bl3->x2[bl9->l2];
3732    tt33 = bl3->x3[bl9->l1] - bl3->x3[bl9->l2];
3733    t[33] = (aml2*(bl1->p1[bl9->l1]) - aml1*(bl1->p1[bl9->l2]))/(aml1 + aml2); //t(34)->t[33]
3734    t[34] = (aml2*(bl1->p2[bl9->l1]) - aml1*(bl1->p2[bl9->l2]))/(aml1 + aml2); //t(35)->t[34]
3735    t[35] = (aml2*(bl1->p3[bl9->l1]) - aml1*(bl1->p3[bl9->l2]))/(aml1 + aml2); //t(36)->t[35]
3736    tt34 = bl1->p1[bl9->l1] + bl1->p1[bl9->l2];
3737    tt35 = bl1->p2[bl9->l1] + bl1->p2[bl9->l2];
3738    tt36 = bl1->p3[bl9->l1] + bl1->p3[bl9->l2];
3739  }
3740
3741  // l-conservation
3742  t[20] = bl1->p1[bl9->l1]; //t(21)->t[20]
3743  t[21] = bl1->p2[bl9->l1]; //t(22)->t[21]
3744  t[22] = bl1->p3[bl9->l1]; //t(23)->t[22]
3745  t[23] = bl1->eps[bl9->l1]; //t(24)->t[23]
3746  t[24] = bl1->p1[bl9->l2]; //t(25)->t[24]
3747  t[25] = bl1->p2[bl9->l2]; //t(26)->t[25]
3748  t[26] = bl1->p3[bl9->l2]; //t(27)->t[26]
3749  t[27] = bl1->eps[bl9->l2]; //t(28)->t[27]
3750
3751  // info delta ou nucleon:
3752  if(varavat->kveux == 1) {
3753    varavat->del1avat[iavat] = bl1->ind1[bl9->l1];
3754    varavat->del2avat[iavat] = bl1->ind1[bl9->l2];                                               
3755  }
3756
3757  minus_b1 = -1.0*b1;
3758  minus_b2 = -1.0*b2;
3759  minus_b3 = -1.0*b3;
3760  loren(&(bl1->p1[bl9->l1]), &(bl1->p2[bl9->l1]), &(bl1->p3[bl9->l1]), &minus_b1, &minus_b2, &minus_b3, &(bl1->eps[bl9->l1]));
3761  loren(&(bl1->p1[bl9->l2]), &(bl1->p2[bl9->l2]), &(bl1->p3[bl9->l2]), &minus_b1, &minus_b2, &minus_b3, &(bl1->eps[bl9->l2]));
3762
3763  if(verboseLevel > 3) {
3764    G4cout <<"Calling collis..." << G4endl;
3765    G4cout <<"Energy eps[bl9->l1] = " << bl1->eps[bl9->l1] << G4endl;
3766    G4cout <<"Momentum: p1 = " << bl1->p1[bl9->l1] << " p2 = " << bl1->p2[bl9->l1] << " p3 = " << bl1->p3[bl9->l1] << G4endl;
3767    G4cout <<"Energy eps[bl9->l2] = " << bl1->eps[bl9->l2] << G4endl;
3768    G4cout <<"Momentum: p1 = " << bl1->p1[bl9->l2] << " p2 = " << bl1->p2[bl9->l2] << " p3 = " << bl1->p3[bl9->l2] << G4endl;
3769  }
3770//   bl9->l1 = l1;
3771//   bl9->l2 = l2;
3772  collis(&(bl1->p1[bl9->l1]), &(bl1->p2[bl9->l1]), &(bl1->p3[bl9->l1]),
3773         &(bl1->eps[bl9->l1]), &(bl1->p1[bl9->l2]), &(bl1->p2[bl9->l2]), &(bl1->p3[bl9->l2]), &(bl1->eps[bl9->l2]),
3774         &(t[11]), &(t[12]), &(t[13]), &(t[14]), &np, &ip, &k2, &k3, &k4, &k5,
3775         &(bl1->ind1[bl9->l1]), &(bl1->ind1[bl9->l2]), &(bl1->ind2[bl9->l1]), &(bl1->ind2[bl9->l2]));
3776//   l1 = bl9->l1;
3777//   l2 = bl9->l2;
3778  if(verboseLevel > 3) {
3779    G4cout <<"End of collis call" << G4endl;
3780    G4cout <<"Energy eps[bl9->l1] = " << bl1->eps[bl9->l1] << G4endl;
3781    G4cout <<"Energy eps[bl9->l2] = " << bl1->eps[bl9->l2] << G4endl;
3782  }
3783 
3784  if(verboseLevel > 3) {
3785    G4cout <<"Variables after collis call: "<< G4endl;
3786    G4cout <<"bl1->p1[" << bl9->l1 <<"] = " << bl1->p1[bl9->l1] <<" bl1->p2[" << bl9->l1 <<"] = " << bl1->p2[bl9->l1] <<" bl1->p3[" << bl9->l1 <<"] = " << bl1->p3[bl9->l1] <<" bl1->eps[" << bl9->l1 <<"] = " << bl1->eps[bl9->l1] << G4endl;
3787    G4cout <<"bl1->p1[" << bl9->l2 <<"] = " << bl1->p1[bl9->l2] <<" bl2->p2[" << bl9->l2 <<"] = " << bl1->p2[bl9->l2] <<" bl2->p3[" << bl9->l2 <<"] = " << bl1->p3[bl9->l2] <<" bl1->eps[" << bl9->l2 <<"] = " << bl1->eps[bl9->l2] << G4endl;
3788  }
3789 
3790  loren(&(bl1->p1[bl9->l1]), &(bl1->p2[bl9->l1]), &(bl1->p3[bl9->l1]), &b1, &b2, &b3, &(bl1->eps[bl9->l1]));
3791  loren(&(bl1->p1[bl9->l2]), &(bl1->p2[bl9->l2]), &(bl1->p3[bl9->l2]), &b1, &b2, &b3, &(bl1->eps[bl9->l2]));
3792
3793  if (bl1->ind1[bl9->l1] == 1) { // bugfix 1 -> 0
3794    goto pnu243;
3795  }
3796  xbl1 = pauliBlocking(bl9->l1, rbl, pbl);
3797  standardRandom(&rndm,&(hazard->igraine[10])); 
3798  if (rndm > (1.0 - xbl1)) {
3799    goto pnu248;
3800  }
3801 pnu243:
3802  if (bl1->ind1[bl9->l2] == 1) { // bugfix 1 -> 0
3803    goto pnu241;
3804  }
3805  xbl2 = pauliBlocking(bl9->l2, rbl, pbl);
3806  standardRandom(&rndm,&(hazard->igraine[10]));
3807  if (rndm > (1.0 - xbl2)) {
3808    goto pnu248;
3809  }
3810  goto pnu241;
3811 pnu248:
3812  if(verboseLevel > 3) {
3813    G4cout <<"Pauli blocked transition!" << G4endl;
3814  }
3815 
3816  mpaul1 = mpaul1 + 1;
3817  if(varavat->kveux == 1) {
3818    varavat->bloc_paul[iavat] = 1;
3819  }
3820  // restitution de l1 et l2 si rejet de la col. par pauli:
3821  bl1->p1[bl9->l1] = t[20]; //t(21)->t[20]
3822  bl1->p2[bl9->l1] = t[21]; //t(22)->t[21]
3823  bl1->p3[bl9->l1] = t[22]; //t(23)->t[22]
3824  bl1->eps[bl9->l1] = t[23]; //t(24)->t[23]
3825  bl1->p1[bl9->l2] = t[24]; //t(25)->t[24]
3826  bl1->p2[bl9->l2] = t[25]; //t(26)->t[25]
3827  bl1->p3[bl9->l2] = t[26]; //t(27)->t[26]
3828  bl1->eps[bl9->l2] = t[27]; //t(28)->t[27]
3829  bl1->ind1[bl9->l1] = ich1;
3830  bl1->ind1[bl9->l2] = ich2;
3831  bl1->ind2[bl9->l1] = ich3;
3832  bl1->ind2[bl9->l2] = ich4;
3833
3834  if (bl2->k == 0) {
3835    goto pnu230;
3836  }
3837  for(G4int i = 1; i <= bl2->k; i++) {
3838    bl2->crois[i] = bl2->crois[i] - tau;
3839  }
3840
3841  // pour le temps de calcul (a.b. 02/2002)
3842  if(verboseLevel > 3) {
3843    G4cout <<"G4Incl: bl2->k != 0" << G4endl;
3844  }
3845  goto pnu44;
3846
3847 pnu241:
3848
3849  // la premiere collision a deux corps ne peut pas baisser l'energie
3850  // du nucleon de recul (bloque par pauli dans un noyau cible froid).
3851  // (ici, toujours l2 < l1)
3852  ncol_2c = ncol_2c + 1;
3853  if(ncol_2c == 1) {
3854    for (G4int icomp = 1; icomp <= bl3->ia1; icomp++) {
3855      // test on the first collision modified 4/07/2001 for direct and exchange.
3856      if(icomp == bl9->l1 || icomp == bl9->l2) {
3857        xavant = min(t[23],t[27]); //t(24)->t[23], t(28)->t[27]
3858        xapres = min(bl1->eps[bl9->l1],bl1->eps[bl9->l2]);
3859        if(xapres <= xavant) {
3860          if(varavat->kveux == 1) {
3861            varavat->bloc_cdpp[iavat] = 1;
3862          }
3863          goto pnu248;
3864        }
3865      }
3866    }
3867
3868    // pour le ntuple des avatars:
3869    if(varavat->kveux == 1) { //then
3870      varavat->r1_first_avat[0] = bl3->x1[1]; //(N)->[N-1]
3871      varavat->r1_first_avat[1] = bl3->x2[1]; //(N)->[N-1]
3872      varavat->r1_first_avat[2] = bl3->x3[1]; //(N)->[N-1]
3873    } //endif
3874  }
3875  else {
3876    // les collisions suivantes ne penvent conduire a un noyau de a nucleons
3877    // sous l'energie de fermi et dans une config. d'energie inferieure a
3878    // efer-(ia2-nbalttf)*tf).
3879    egs = 0.0;
3880    nbalttf = 0;
3881    //    for(G4int i = 1; i <= ia-1; i++) {
3882    for(G4int i = 1; i <= ia; i++) {
3883      if(bl5->nesc[i] == 0) {
3884        if(std::sqrt(std::pow(bl1->p1[i],2)+std::pow(bl1->p2[i],2)+std::pow(bl1->p3[i],2)) < bl10->pf) {
3885          nbalttf = nbalttf + 1;
3886          egs = egs + bl1->eps[i] - fmp;
3887        }
3888      }
3889    }
3890
3891    if(egs < (efer- double(bl3->ia2-nbalttf)*tf)) {
3892      if(varavat->kveux == 1) {
3893        varavat->bloc_cdpp[iavat] = 1;
3894      }
3895      goto pnu248;
3896    }
3897  }
3898
3899  if(varavat->kveux == 1) {
3900    varavat->bloc_cdpp[iavat] = 0;
3901    varavat->bloc_paul[iavat] = 0;
3902  }
3903
3904  jparticip[bl9->l1] = 1;
3905  jparticip[bl9->l2] = 1;
3906  if(verboseLevel > 3) {
3907    G4cout <<"Particle " << bl9->l1 << " is now participant." << G4endl;
3908    G4cout <<"Particle " << bl9->l2 << " is now participant." << G4endl;
3909  }
3910 
3911  if (ws->nosurf <= 0) {
3912    // surface
3913    pppp = std::sqrt(std::pow(bl1->p1[bl9->l1],2) + std::pow(bl1->p2[bl9->l1],2) + std::pow(bl1->p3[bl9->l1],2));
3914    rrrr = std::sqrt(std::pow(bl3->x1[bl9->l1],2) + std::pow(bl3->x2[bl9->l1],2) + std::pow(bl3->x3[bl9->l1],2));
3915    if (pppp <= bl10->pf) {
3916      xv = pppp/bl10->pf;
3917      rcorr = interpolateFunction(xv);
3918      if (rrrr > rcorr) {
3919        bl3->x1[bl9->l1] = bl3->x1[bl9->l1]*rcorr/rrrr;
3920        bl3->x2[bl9->l1] = bl3->x2[bl9->l1]*rcorr/rrrr;
3921        bl3->x3[bl9->l1] = bl3->x3[bl9->l1]*rcorr/rrrr;
3922      }
3923    }
3924    pppp = std::sqrt(std::pow(bl1->p1[bl9->l2],2) + std::pow(bl1->p2[bl9->l2],2) + std::pow(bl1->p3[bl9->l2],2));
3925    rrrr = std::sqrt(std::pow(bl3->x1[bl9->l2],2) + std::pow(bl3->x2[bl9->l2],2) + std::pow(bl3->x3[bl9->l2],2));
3926    if (pppp <= bl10->pf) {
3927      xv = pppp/bl10->pf;
3928      rcorr = interpolateFunction(xv);
3929      if (rrrr > rcorr) {
3930        bl3->x1[bl9->l2] = bl3->x1[bl9->l2]*rcorr/rrrr;
3931        bl3->x2[bl9->l2] = bl3->x2[bl9->l2]*rcorr/rrrr;
3932        bl3->x3[bl9->l2] = bl3->x3[bl9->l2]*rcorr/rrrr;
3933      }
3934    }
3935  }
3936 
3937  if (np == 0) {
3938    goto pnu240;
3939  }
3940
3941  npion = npion + 1;
3942  loren(&(t[11]), &(t[12]), &(t[13]), &b1, &b2, &b3, &(t[14])); //t(N)->t[N-1]
3943  q1[npion] = t[11]; //t(12)->t[11]
3944  q2[npion] = t[12]; //t(13)->t[12]
3945  q3[npion] = t[13]; //t(14)->t[13]
3946  q4[npion] = t[14]; //t(15)->t[14]
3947 pnu240:
3948  ncol = ncol + 1;
3949  if (bl9->l2 != 1) {
3950    goto pnu870;
3951  }
3952
3953  // critere pour la leading particle: avant impulsion longitudinale max l=1
3954  // change en fevrier 2002: leading part. = energie totale max (l=1)
3955  if (bl1->p3[bl9->l2] > bl1->p3[bl9->l1]) { 
3956    goto pnu870;
3957  }
3958
3959  // attention, il faut mieux faire et selectionner la plus grande energie
3960  // des particules participantes (jparticip()=1) et dans le noyau (nesc()=0)!
3961
3962  xr1 = bl1->p1[bl9->l1];
3963  xr2 = bl1->p2[bl9->l1];
3964  xr3 = bl1->p3[bl9->l1];
3965  xr4 = bl1->eps[bl9->l1];
3966  xr5 = bl3->x1[bl9->l1];
3967  xr6 = bl3->x2[bl9->l1];
3968  xr7 = bl3->x3[bl9->l1];
3969  xr8 = gl1;
3970  ixr1 = bl1->ind1[bl9->l1];
3971  ixr2 = bl1->ind2[bl9->l1];
3972  ixr3 = ich1;
3973  bl1->p1[bl9->l1] = bl1->p1[bl9->l2];
3974  bl1->p2[bl9->l1] = bl1->p2[bl9->l2];
3975  bl1->p3[bl9->l1] = bl1->p3[bl9->l2];
3976  bl1->eps[bl9->l1] = bl1->eps[bl9->l2];
3977
3978  bl3->x1[bl9->l1] = bl3->x1[bl9->l2];
3979  bl3->x2[bl9->l1] = bl3->x2[bl9->l2];
3980  bl3->x3[bl9->l1] = bl3->x3[bl9->l2];
3981  gl1 = gl2;
3982  bl1->ind1[bl9->l1] = bl1->ind1[bl9->l2];
3983  bl1->ind2[bl9->l1] = bl1->ind2[bl9->l2];
3984  ich1 = ich2;
3985  bl1->p1[bl9->l2] = xr1;
3986  bl1->p2[bl9->l2] = xr2;
3987  bl1->p3[bl9->l2] = xr3;
3988  bl1->eps[bl9->l2] = xr4;
3989 
3990  bl3->x1[bl9->l2] = xr5;
3991  bl3->x2[bl9->l2] = xr6;
3992  bl3->x3[bl9->l2] = xr7;
3993  gl2 = xr8;
3994  bl1->ind1[bl9->l2] = ixr1;
3995  bl1->ind2[bl9->l2] = ixr2;
3996  ich2 = ixr3;
3997
3998  if(ich1 + ich2 - bl1->ind1[bl9->l1] - bl1->ind1[bl9->l2] != 0 || (ich1 + ich2) != 1) {
3999    goto pnu870;
4000  }
4001  if (bl2->k == 0) {
4002    goto pnu870;
4003  }
4004
4005  for(G4int i = 1; i <= bl2->k; i++) {
4006    if((bl2->ind[i] != 1) || (bl2->jnd[i] != 0)) {
4007      if((bl2->ind[i] != bl9->l1) || (bl2->jnd[i] != 0)) {
4008        continue;
4009      }
4010      bl2->ind[i] = 1;
4011      break;
4012    }
4013
4014    bl2->ind[i] = bl9->l1;
4015    break;
4016  }
4017
4018  pnu870:
4019  bl5->tlg[bl9->l1] = th*(bl1->eps[bl9->l1])/std::sqrt(std::pow(bl1->eps[bl9->l1],2)-std::pow(bl1->p1[bl9->l1],2)-std::pow(bl1->p2[bl9->l1],2)-std::pow(bl1->p3[bl9->l1],2));
4020  bl5->tlg[bl9->l2] = th*(bl1->eps[bl9->l2])/std::sqrt(std::pow(bl1->eps[bl9->l2],2)-std::pow(bl1->p1[bl9->l2],2)-std::pow(bl1->p2[bl9->l2],2)-std::pow(bl1->p3[bl9->l2],2));
4021  nc[bl9->l1] = nc[bl9->l1] + 1;
4022  nc[bl9->l2] = nc[bl9->l2] + 1;
4023  led = 0;
4024
4025  if((ich1+ich2-bl1->ind1[bl9->l1]-bl1->ind1[bl9->l2]) < 0) {
4026    mrnd = mrnd + 1;
4027  }
4028  if((ich1+ich2-bl1->ind1[bl9->l1]-bl1->ind1[bl9->l2]) == 0) {
4029    if((ich1+ich2-1) < 0) {
4030      mrnn = mrnn + 1;
4031    }
4032    if((ich1+ich2-1) == 0) {
4033      mrdd = mrdd + 1;
4034      led = 1;
4035    }
4036    if((ich1+ich2-1) > 0) {
4037      mcdd = mcdd + 1;
4038      led = 1;
4039    }
4040  }
4041  if((ich1+ich2-bl1->ind1[bl9->l1]-bl1->ind1[bl9->l2]) > 0) {
4042    mrdn = mrdn + 1;
4043  }
4044
4045
4046  // reevaluation of the times t(a,b) for (a or b)=(l1 or l2)
4047
4048  // l-conservation
4049  if (k6 == 1) {
4050    aml1 = am(bl1->p1[bl9->l1],bl1->p2[bl9->l1],bl1->p3[bl9->l1],bl1->eps[bl9->l1]);
4051    aml2 = am(bl1->p1[bl9->l2],bl1->p2[bl9->l2],bl1->p3[bl9->l2],bl1->eps[bl9->l2]);
4052   
4053    t[36] = (aml2*(bl1->p1[bl9->l1]) - aml1*(bl1->p1[bl9->l2]))/(aml1+aml2); //t(37)->t[36]
4054    t[37] = (aml2*(bl1->p2[bl9->l1]) - aml1*(bl1->p2[bl9->l2]))/(aml1+aml2); //t(38)->t[37]
4055    t[38] = (aml2*(bl1->p3[bl9->l1]) - aml1*(bl1->p3[bl9->l2]))/(aml1+aml2); //t(39)->t[38]
4056    t[39] = std::sqrt(t[33]*t[33] + t[34]*t[34] + t[35]*t[35]); //t(N)->t[N-1]
4057    t[40] = std::sqrt(t[36]*t[36] + t[37]*t[37] + t[38]*t[38]); //t(N)->t[N-1]
4058    rhopi = tt31*t[33] + tt32*t[34] + tt33*t[35]; //t(N)->t[N-1]
4059    t[42] = tt31 - rhopi*t[33]/std::pow(t[39],2); //t(N)->t[N-1]
4060    t[43] = tt32 - rhopi*t[34]/std::pow(t[39],2); //t(N)->t[N-1]
4061    t[44] = tt33 - rhopi*t[35]/std::pow(t[39],2); //t(N)->t[N-1]
4062    t[45] = std::sqrt(t[42]*t[42] + t[43]*t[43] + t[44]*t[44]); //t(N)->t[N-1]
4063    t[42] = t[42]/t[45]; //t(N)->t[N-1]
4064    t[43] = t[43]/t[45]; //t(N)->t[N-1]
4065    t[44] = t[44]/t[45];
4066    cif = (t[33]*t[36] + t[34]*t[37] + t[35]*t[38])/t[39]/t[40]; //t(N)->t[N-1]
4067   
4068    // trouble with forward scattering 22/3/95
4069    if(std::fabs(cif) > 1.) {
4070      cif = sign(1.0,cif);
4071    }
4072    sif = std::sqrt(1.0 - cif*cif);
4073    t[36] = (t[33]*cif/t[39] + t[42]*sif)*t[40]; //t(N)->t[N-1]
4074    t[37] = (t[34]*cif/t[39] + t[43]*sif)*t[40]; //t(N)->t[N-1]
4075    t[38] = (t[35]*cif/t[39] + t[44]*sif)*t[40]; //t(N)->t[N-1]
4076    tri = std::sqrt(tt31*tt31 + tt32*tt32 + tt33*tt33);
4077    cchi = rhopi/tri/t[39]; //t(40)->t[39]
4078    schi = std::sqrt(1.0 - cchi*cchi);
4079    c1 = cif*cchi - sif*schi;
4080    c2 = sif*cchi + cif*schi;
4081    tt31 = (c1*t[33]/t[39] + c2*t[42])*tri*t[39]/t[40]; //t(N)->t[N-1]
4082    tt32 = (c1*t[34]/t[39] + c2*t[43])*tri*t[39]/t[40]; //t(N)->t[N-1]
4083    tt33 = (c1*t[35]/t[39] + c2*t[44])*tri*t[39]/t[40]; //t(N)->t[N-1]
4084    bl3->x1[bl9->l1] = t[30] + aml2*tt31/(aml1 + aml2); //t(31)->t[30]
4085    bl3->x2[bl9->l1] = t[31] + aml2*tt32/(aml1 + aml2); //t(32)->t[30]
4086    bl3->x3[bl9->l1] = t[32] + aml2*tt33/(aml1 + aml2); //t(33)->t[32]
4087    bl3->x1[bl9->l2] = t[30] - aml1*tt31/(aml1 + aml2); //t(31)->t[30]
4088    bl3->x2[bl9->l2] = t[31] - aml1*tt32/(aml1 + aml2); //t(32)->t[31]
4089    bl3->x3[bl9->l2] = t[32] - aml1*tt33/(aml1 + aml2); //t(33)->t[32]
4090    bl1->p1[bl9->l1] = aml1*tt34/(aml1 + aml2) + t[36]; //t(37)->t[36]
4091    bl1->p2[bl9->l1] = aml1*tt35/(aml1 + aml2) + t[37]; //t(38)->t[37]
4092    bl1->p3[bl9->l1] = aml1*tt36/(aml1 + aml2) + t[38]; //t(39)->t[38]
4093    bl1->eps[bl9->l1] = w(bl1->p1[bl9->l1],bl1->p2[bl9->l1],bl1->p3[bl9->l1],aml1);
4094    bl1->p1[bl9->l2] = aml2*tt34/(aml1 + aml2) - t[36]; //t(37)->t[36]
4095    bl1->p2[bl9->l2] = aml2*tt35/(aml1 + aml2) - t[37]; //t(38)->t[37]
4096    bl1->p3[bl9->l2] = aml2*tt36/(aml1 + aml2) - t[38]; //t(39)->t[38]
4097    bl1->eps[bl9->l2] = w(bl1->p1[bl9->l2],bl1->p2[bl9->l2],bl1->p3[bl9->l2],aml2);
4098  }
4099  // l-conservation
4100
4101  if(bl2->k != 0) {
4102    kd = 0;
4103    ccr = tau;
4104//     for(G4int i = 1; i <= bl2->k; i++) {
4105//       i20 = i - kd;
4106//       if (k4 != 2 || led != 1) {
4107//      if((bl2->ind[i] == l1) || (bl2->ind[i] == l2) || (bl2->jnd[i] == l1) || (bl2->jnd[i] == l2)) {
4108//        kd = kd + 1;
4109//        continue;
4110//      }
4111//       }
4112//       else {
4113//      if(bl2->jnd[i] == 0) {
4114//        if (bl2->ind[i] == l1 && bl1->ind1[l1] == 1) {
4115//          bl2->crois[i]=(bl2->crois[i]-ccr)*(bl1->eps[l1])/std::sqrt(std::pow(bl1->eps[l1],2)-std::pow(bl1->p1[l1],2)-std::pow(bl1->p2[l1],2)-std::pow(bl1->p3[l1],2))/gl1+ccr;
4116//        }
4117//        if (bl2->ind[i] == l2 && bl1->ind1[l2] == 1) {
4118//          bl2->crois[i]=(bl2->crois[i]-ccr)*(bl1->eps[l2])/std::sqrt(std::pow(bl1->eps[l2],2)-std::pow(bl1->p1[l2],2)-std::pow(bl1->p2[l2],2)-std::pow(bl1->p3[l2],2))/gl2+ccr;
4119//        }
4120//      }
4121//       }
4122   
4123//       bl2->crois[i20]=bl2->crois[i]-ccr;
4124//       bl2->ind[i20]=bl2->ind[i];
4125//       bl2->jnd[i20]=bl2->jnd[i];
4126//     }
4127
4128    for(G4int i = 1; i <= bl2->k; i++) { //do 50 i=1,k                                                       p-n09070
4129      i20 = i - kd;
4130      if(k4 != 2 || led != 1) { //if (k4.ne.2.or.led.ne.1) go to 512                                p-n09090
4131        goto pnu512;
4132      }
4133      if(bl2->jnd[i] == 0) {//if (jnd(i).eq.0) go to 511                                        p-n09100
4134        goto pnu511;
4135      }
4136    pnu512:
4137      if(bl2->ind[i] == bl9->l1) {//if (ind(i).eq.l1) go to 52                                        p-n09120
4138        goto pnu52; 
4139
4140      }
4141      if(bl2->ind[i] == bl9->l2) {//if (ind(i).eq.l2) go to 52                                        p-n09130
4142        goto pnu52;
4143        }
4144      if(bl2->jnd[i] == bl9->l2) {//if (jnd(i).eq.l2) go to 52                                        p-n09140
4145        goto pnu52;
4146      }
4147      if(bl2->jnd[i] == bl9->l1) {//if (jnd(i).eq.l1) go to 52                                        p-n09150
4148        goto pnu52;
4149      }
4150      goto pnu513;
4151    pnu511:
4152      //if (ind(i).eq.l1.and.ind1(l1).eq.1) crois(i)=(crois(i)-ccr)*eps(l1p-n09170
4153      //-)/std::sqrt(eps(l1)**2-p1(l1)**2-p2(l1)**2-p3(l1)**2)/gl1+ccr          p-n09180
4154      if(bl2->ind[i] == bl9->l1 && bl1->ind1[bl9->l1] == 1) {
4155        bl2->crois[i]=(bl2->crois[i]-ccr)*bl1->eps[bl9->l1]/std::sqrt(std::pow(bl1->eps[bl9->l1],2)-std::pow(bl1->p1[bl9->l1],2)-std::pow(bl1->p2[bl9->l1],2)-std::pow(bl1->p3[bl9->l1],2))/gl1+ccr;
4156      }
4157      //if (ind(i).eq.l2.and.ind1(l2).eq.1) crois(i)=(crois(i)-ccr)*eps(l2p-n09190
4158      //-)/std::sqrt(eps(l2)**2-p1(l2)**2-p2(l2)**2-p3(l2)**2)/gl2+ccr          p-n09200
4159      if(bl2->ind[i] == bl9->l2 && bl1->ind1[bl9->l2] == 1) {
4160        bl2->crois[i]=(bl2->crois[i]-ccr)*bl1->eps[bl9->l2]/std::sqrt(std::pow(bl1->eps[bl9->l2],2)-std::pow(bl1->p1[bl9->l2],2)-std::pow(bl1->p2[bl9->l2],2)-std::pow(bl1->p3[bl9->l2],2))/gl1+ccr;
4161      }
4162 pnu513:
4163      bl2->crois[i20]=bl2->crois[i]-ccr;
4164      bl2->ind[i20]=bl2->ind[i];
4165      bl2->jnd[i20]=bl2->jnd[i];
4166      continue; // goto pnu50
4167    pnu52:
4168      kd=kd+1;
4169    }
4170 
4171    bl2->k = bl2->k - kd;
4172  }
4173
4174  newt(bl9->l1,bl9->l2);
4175
4176  tref=ref(bl3->x1[bl9->l1], bl3->x2[bl9->l1], bl3->x3[bl9->l1], bl1->p1[bl9->l1], bl1->p2[bl9->l1], bl1->p3[bl9->l1], bl1->eps[bl9->l1],r22); // line 3502
4177 
4178  if(verboseLevel > 3) {
4179    if(tref < 0.0) {
4180      G4cout <<"G4Incl: Reflection time < 0! (line 3502)" << G4endl;
4181    }
4182  }
4183
4184  if(tref <= bl4->tmax5) {
4185    bl2->k = bl2->k + 1;
4186    bl2->crois[bl2->k] = tref;
4187    bl2->ind[bl2->k] = bl9->l1;
4188    bl2->jnd[bl2->k] = -1;
4189  }
4190
4191  tref=ref(bl3->x1[bl9->l2], bl3->x2[bl9->l2], bl3->x3[bl9->l2], bl1->p1[bl9->l2], bl1->p2[bl9->l2], bl1->p3[bl9->l2], bl1->eps[bl9->l2],r22); // line 3516
4192 
4193  if(verboseLevel > 3) {
4194    if(tref < 0.0) {
4195      G4cout <<"G4Incl: Reflection time < 0! (line 3516)" << G4endl;
4196    }
4197  }
4198
4199  if(tref <= bl4->tmax5) {
4200    bl2->k = bl2->k + 1;
4201    bl2->crois[bl2->k] = tref;
4202    bl2->ind[bl2->k] = bl9->l2;
4203    bl2->jnd[bl2->k] = -1;
4204  }
4205
4206  if (k4 == 2) {
4207    goto pnu848;
4208  }
4209
4210  if(bl2->k < 0) {
4211    goto pnu230;
4212  }
4213  if(bl2->k == 0) {
4214    goto pnu230;
4215  }
4216  if(bl2->k > 0) {
4217    if(verboseLevel > 3) {
4218      G4cout <<"G4Incl: bl2->k > 0 at line 3488. Going back to label pnu449." << G4endl;
4219    }
4220    goto pnu449;
4221  }
4222
4223 pnu848:
4224  if (npion == 0) {
4225    goto pnu844;
4226  }
4227  if (bl1->ind1[bl9->l1] == 1) {
4228    goto pnu843;
4229  }
4230  for(G4int k20 = 1; k20 <= npion; k20++) {
4231    if(verboseLevel > 3) {
4232      G4cout <<"G4Incl: calling G4Incl::new3" << G4endl;
4233    }
4234    new3((y1[k20]), (y2[k20]), (y3[k20]), (q1[k20]), (q2[k20]), (q3[k20]), (q4[k20]), k20, bl9->l1);
4235    if(verboseLevel > 3) {
4236      G4cout <<"G4Incl: After new3:" << G4endl;
4237      G4cout <<"y1[" << k20 << "] = " << y1[k20] <<" y2[" << k20 << "] = " << y2[k20] <<" y3[" << k20 << "] = " << y3[k20] << G4endl;
4238      G4cout <<"q1[" << k20 << "] = " << q1[k20] <<" q2[" << k20 << "] = " << q2[k20] <<" q3[" << k20 << "] = " << q3[k20] << G4endl;
4239    }
4240  }
4241
4242 pnu843:
4243  if(bl1->ind1[bl9->l2] != 1) {
4244    for(G4int k20 = 1; k20 <= npion; k20++) {
4245      //new3(y1[k20], y2[k20], y3[k20], q1[k20], q2[k20], q3[k20], q4[k20], -k20, l2);
4246      new3(y1[k20], y2[k20], y3[k20], q1[k20], q2[k20], q3[k20], q4[k20], k20, bl9->l2);
4247    }
4248  }
4249 pnu844:
4250
4251  if(bl1->ind1[bl9->l1]+bl1->ind1[bl9->l2] <= ich1+ich2) {
4252    goto pnu849;
4253  }
4254  if(bl1->ind1[bl9->l1]-ich1 != 1) {
4255    goto pnu820;
4256  }
4257  lnew = bl9->l1;
4258  goto pnu821;
4259 pnu820:
4260  if(bl1->ind1[bl9->l2]-ich2 != 1) {
4261    goto pnu849;
4262  }
4263  lnew = bl9->l2;
4264
4265 pnu821:
4266  standardRandom(&rndm,&(hazard->igraine[16]));
4267  // largeur variable du delta (phase space factor G4introduced 4/2001)
4268  amlnew = std::sqrt(std::pow(bl1->eps[lnew],2)-std::pow(bl1->p1[lnew],2)-std::pow(bl1->p2[lnew],2)-std::pow(bl1->p3[lnew],2)); 
4269 
4270  geff = bl1->eps[lnew]/amlnew;
4271  qqq = std::sqrt((std::pow(amlnew,2) - std::pow((fmp+fmpi),2))*(std::pow(amlnew,2) - std::pow((fmp-fmpi),2)))/(2.0*amlnew);
4272 
4273  psf = std::pow(qqq,3)/(std::pow(qqq,3) + 5832000.0);
4274  tdel = -hc/(g0*psf)*std::log(rndm)*geff;                                 
4275 
4276  if(tdel <= bl4->tmax5) {
4277    bl2->k = bl2->k + 1;
4278    bl2->crois[bl2->k] = tdel;
4279    bl2->ind[bl2->k] = lnew;
4280    bl2->jnd[bl2->k] = 0;
4281  }
4282
4283 pnu849:
4284  if (bl2->k == 0) { 
4285    goto pnu230;
4286  }
4287  if(verboseLevel > 3) {
4288    G4cout <<"G4Incl: bl2->k != 0. Going back to label pnu449." << G4endl;
4289  }
4290  goto pnu449;
4291
4292  // decay of the delta particle                                       p-n09780
4293 pnu805:
4294  npion = npion + 1;
4295  ichd = bl1->ind2[bl9->l1];
4296  t[30] = bl1->p1[bl9->l1];   //t(31)->t[30]
4297  t[31] = bl1->p2[bl9->l1]; //t(32)->t[31]
4298  t[32] = bl1->p3[bl9->l1]; //t(33)->t[32]
4299  t[33] = bl1->eps[bl9->l1]; //t(34)->t[33]
4300  var_ab = std::pow(bl1->eps[bl9->l1],2) - std::pow(bl1->p1[bl9->l1],2) - std::pow(bl1->p2[bl9->l1],2) - std::pow(bl1->p3[bl9->l1],2);
4301  ym[npion] = 0.0;
4302
4303  if(var_ab > 0.0) {
4304    ym[npion] = std::sqrt(var_ab);
4305  }
4306
4307  //PK: This workaround avoids a NaN problem encountered with
4308  //geant4. The problem does not seem to exist if we run in standalone
4309  //mode.
4310  //  if(((std::pow(ym[npion],2)-std::pow(fmp+fmpi,2))*(std::pow(ym[npion],2)-std::pow(fmp-fmpi,2))) < 0) {
4311  //    ym[npion] = ym[npion]+fmpi+100.0;
4312  //  }
4313  // PK
4314  if(varavat->kveux == 1) {
4315    varavat->del1avat[iavat] = bl1->ind1[bl9->l1];
4316    varavat->energyavat[iavat] = ym[npion];
4317  }
4318
4319  if(verboseLevel > 3) {
4320    G4cout <<"Calling decay2 from pnu" << G4endl;
4321    G4cout <<"npion = " << npion << G4endl;
4322    G4cout <<"q1 = " << q1[npion] << " q2 = " << q2[npion] << " q3 = " << q3[npion] << " q4 = " << q4[npion] << G4endl;
4323  }
4324  decay2(&(bl1->p1[bl9->l1]), &(bl1->p2[bl9->l1]), &(bl1->p3[bl9->l1]), &(bl1->eps[bl9->l1]), &(q1[npion]), &(q2[npion]), &(q3[npion]),
4325         &(q4[npion]), &(ym[npion]), &fmp, &fmpi, &(bl9->hel[bl9->l1]));
4326
4327  if(verboseLevel > 3) {
4328    G4cout <<"Quantities after decay2: " << G4endl;
4329    G4cout <<"l1 = " << bl9->l1 << " bl1->p1[l1] = " << bl1->p1[bl9->l1] << " bl1->p2[l1] = " << bl1->p2[bl9->l1] << " bl1->p3[l1] = " << bl1->p3[bl9->l1] << " bl1->eps[l1] = " << bl1->eps[bl9->l1] << G4endl;
4330  }
4331 
4332  // decay
4333  if (bl1->ind2[bl9->l1]*(bl1->ind2[bl9->l1]) == 9) {
4334    goto pnu806;
4335  }
4336 
4337  standardRandom(&rndm, &(hazard->ial));
4338  if (rndm < 0.333333333) {
4339    goto pnu837;
4340  }
4341 
4342  ipi[npion]=0;
4343  goto pnu809;
4344
4345 pnu837:
4346  ipi[npion]=bl1->ind2[bl9->l1]*2;
4347  bl1->ind2[bl9->l1]=-1*(bl1->ind2[bl9->l1]);
4348  goto pnu809;
4349 pnu806:
4350  bl1->ind2[bl9->l1]=bl1->ind2[bl9->l1]/3;
4351  ipi[npion]=2*(bl1->ind2[bl9->l1]);
4352 pnu809: // continue
4353  bl1->ind1[bl9->l1]=0;
4354  bl5->tlg[bl9->l1]=0.;
4355
4356  // escape ?
4357  if (bl5->nesc[bl9->l1] > 0) {
4358    goto pnu850;
4359  }
4360
4361  iteste = 0;
4362  xpb = pauliBlocking(bl9->l1, rbl, pbl);
4363  standardRandom(&rndm,&(hazard->igraine[10])); 
4364
4365  // pauli blocking?
4366  if (rndm <= xpb) {
4367    goto pnu1848;
4368  }
4369  // le decay ne peut conduire a un noyau de a nucleons
4370  // sous l'energie de fermi et dans une config. d'energie inferieure a
4371  // c  efer-(ia2-nbalttf)*tf).
4372  egs = 0.0;
4373  nbalttf = 0;
4374  iteste = 1;
4375  for(G4int i = 1; i <= ia; i++) {
4376    if(bl5->nesc[i] == 0) {
4377      if(std::sqrt(std::pow(bl1->p1[i],2)+std::pow(bl1->p2[i],2)+std::pow(bl1->p3[i],2)) < bl10->pf) {
4378        nbalttf = nbalttf + 1;
4379        egs = egs + bl1->eps[i] - fmp;
4380      }
4381    }
4382  }
4383  if(egs >= (efer - double(bl3->ia2-nbalttf)*tf)) {
4384    goto pnu850;
4385  }
4386
4387  // attention, logique negative!!! liberer le goto si on veut supprimer la
4388  // sequence precedente (cdpp sur delta-> pi n)
4389
4390  if(varavat->kveux == 1) {
4391    varavat->bloc_cdpp[iavat] = 1;
4392  }
4393
4394  // it is blocked!     
4395 pnu1848:
4396  mpaul2 = mpaul2 + 1;
4397  if(varavat->kveux == 1) {
4398    varavat->bloc_paul[iavat] = 1;
4399  }
4400
4401  // largeur variable du delta (phase space factor G4introduced 4/2001)
4402  // (180.**3 = 5832000.)
4403  qqq = std::sqrt((std::pow(ym[npion],2) - std::pow((fmp+fmpi),2))*(std::pow(ym[npion],2) - std::pow((fmp-fmpi),2)))/(2.*ym[npion]);
4404  psf = std::pow(qqq,3)/(std::pow(qqq,3)+5832000.0);
4405  tdel = hc*t[33]/(g0*psf*ym[npion]); //t(34)->t[33]                                 
4406
4407  if (iteste == 0) {
4408    tdel = tdel*xpb/(1.000001-xpb);
4409  }
4410
4411  if(tdel <= bl4->tmax5) {
4412    bl2->k = bl2->k + 1;
4413    bl2->crois[bl2->k] = tdel;
4414    bl2->ind[bl2->k] = bl9->l1;
4415    bl2->jnd[bl2->k] = 0;
4416  }
4417
4418  bl1->p1[bl9->l1] = t[30]; //t(31)->t[30]
4419  bl1->p2[bl9->l1] = t[31]; //t(32)->t[31]
4420  bl1->p3[bl9->l1] = t[32]; //t(33)->t[32]
4421  bl1->eps[bl9->l1] = t[33]; //t(34)->t[33]
4422  bl1->ind1[bl9->l1] = 1;
4423  bl1->ind2[bl9->l1] = ichd;
4424  npion = npion - 1;
4425
4426  if (bl2->k == 0) {
4427    goto pnu230;
4428  }
4429
4430  for(G4int i = 1; i <= bl2->k; i++) {
4431    bl2->crois[i] = bl2->crois[i] - tau;
4432  }
4433
4434  if(verboseLevel > 3) {
4435    G4cout <<"G4Incl: Going back to label pnu449 after a loop from 1 to bl2->k" << G4endl;
4436  }
4437  goto pnu449;
4438
4439  // valid decay of the delta
4440 pnu850:
4441  if(varavat->kveux == 1) {
4442    varavat->bloc_paul[iavat] = 0;
4443    varavat->bloc_cdpp[iavat] = 0;
4444  }
4445
4446  if (ws->nosurf <= 0) {
4447    // surface
4448    pppp = std::sqrt(std::pow(bl1->p1[bl9->l1],2) + std::pow(bl1->p2[bl9->l1],2) + std::pow(bl1->p3[bl9->l1],2));
4449    rrrr = std::sqrt(std::pow(bl3->x1[bl9->l1],2) + std::pow(bl3->x2[bl9->l1],2) + std::pow(bl3->x3[bl9->l1],2));
4450    if (pppp <= bl10->pf) {
4451      xv = pppp/bl10->pf;
4452      rcorr = interpolateFunction(xv);
4453      if (rrrr > rcorr) {
4454        bl3->x1[bl9->l1] = bl3->x1[bl9->l1]*rcorr/rrrr;
4455        bl3->x2[bl9->l1] = bl3->x2[bl9->l1]*rcorr/rrrr;
4456        bl3->x3[bl9->l1] = bl3->x3[bl9->l1]*rcorr/rrrr;
4457      }
4458    }
4459  }
4460
4461  ncol = ncol + 1;
4462  mrdp = mrdp + 1;
4463  y1[npion] = bl3->x1[bl9->l1];
4464  y2[npion] = bl3->x2[bl9->l1];
4465  y3[npion] = bl3->x3[bl9->l1];
4466
4467  if (bl2->k == 0) {
4468    goto pnu4047;
4469  }
4470 
4471  kd = 0;
4472  ccr = tau;
4473  for(G4int i = 1; i <= bl2->k; i++) {
4474    i20 = i - kd;
4475
4476    if((bl2->ind[i] == bl9->l1) || (bl2->jnd[i] == bl9->l1)) {
4477      kd = kd + 1;
4478    }
4479    else {
4480      bl2->crois[i20] = bl2->crois[i] - ccr;
4481      bl2->ind[i20] = bl2->ind[i];
4482      bl2->jnd[i20] = bl2->jnd[i];
4483    }
4484  }
4485  bl2->k = bl2->k - kd;
4486 
4487 pnu4047:
4488  if (bl5->nesc[bl9->l1] != 0) {
4489    goto pnu845;
4490  }
4491
4492  new1(bl9->l1);
4493  bl2->k = bl2->k + 1;
4494  bl2->crois[bl2->k] = ref(bl3->x1[bl9->l1], bl3->x2[bl9->l1], bl3->x3[bl9->l1], bl1->p1[bl9->l1], bl1->p2[bl9->l1], bl1->p3[bl9->l1], bl1->eps[bl9->l1],r22);
4495  bl2->ind[bl2->k] = bl9->l1;
4496  bl2->jnd[bl2->k] = -1;
4497  if(verboseLevel > 3) {
4498    if(bl2->crois[bl2->k] < 0.0) {
4499      G4cout <<"G4Incl: Reflection time < 0! (line 3797)" << G4endl;
4500    }
4501  }
4502
4503
4504  if(npion > 1) {
4505    n20 = npion - 1;
4506    for(G4int k20 = 1; k20 <= n20; k20++) {
4507      new3(y1[k20], y2[k20], y3[k20], q1[k20], q2[k20], q3[k20], q4[k20], k20, bl9->l1);
4508    }
4509  }
4510
4511 pnu845: 
4512  new2(y1[npion], y2[npion], y3[npion], q1[npion], q2[npion], q3[npion], q4[npion], npion, bl9->l1);
4513  if(bl2->k == 0) {
4514    goto pnu230;
4515  }
4516
4517  if(verboseLevel > 3) {
4518    G4cout <<"G4Incl: bl2->k == 0 after a call to new2. Going back to label pnu449." << G4endl;
4519  }
4520  goto pnu449;
4521
4522  // pion-nucleon collision
4523 pnu801:
4524  if(verboseLevel > 3) {
4525    G4cout <<"Pion-nucleon collision!" << G4endl;
4526  }
4527  lp = bl9->l1 - ia;
4528  dis1 = bl3->x1[bl9->l2]-y1[lp] + (bl1->p1[bl9->l2]/bl1->eps[bl9->l2] - q1[lp]/q4[lp])*tau;
4529  dis2 = bl3->x2[bl9->l2]-y2[lp] + (bl1->p2[bl9->l2]/bl1->eps[bl9->l2] - q2[lp]/q4[lp])*tau;
4530  dis3 = bl3->x3[bl9->l2]-y3[lp] + (bl1->p3[bl9->l2]/bl1->eps[bl9->l2] - q3[lp]/q4[lp])*tau;
4531  dist = dis1*dis1 + dis2*dis2 + dis3*dis3;
4532  t[9] = bl1->eps[bl9->l2] + q4[lp]; //t(10)->t[9]
4533  t0 = 1.0/t[9]; //t(10)->t[9]
4534  b1 = (bl1->p1[bl9->l2] + q1[lp])*t0;
4535  b2 = (bl1->p2[bl9->l2] + q2[lp])*t0;
4536  b3 = (bl1->p3[bl9->l2] + q3[lp])*t0;
4537  s = (1.0 - b1*b1 - b2*b2 - b3*b3)*t[9]*t[9]; //t(10)->t[9]
4538  sq = std::sqrt(s);
4539  cg = 4+bl1->ind2[bl9->l2]*ipi[lp];
4540
4541  if(verboseLevel > 3) {
4542    G4cout <<"Pion-Nucleon collision done! " << G4endl;
4543  }
4544 
4545  if(sq > 3000.0) {
4546    if(verboseLevel > 3) {
4547      G4cout <<"sq = " << sq << G4endl;
4548    }
4549    goto pnu832;
4550  }
4551  if(31.41592*dist > pionNucleonCrossSection(sq)*cg/6.0) {
4552    goto pnu832;
4553  }
4554
4555  if(verboseLevel > 3) {
4556    G4cout <<"Going to pnu220!" << G4endl;
4557  }
4558 
4559  goto pnu220;
4560
4561 pnu832:
4562  if (bl2->k == 0) {
4563    goto pnu230;
4564  }
4565
4566  if(verboseLevel > 3) {
4567    G4cout <<"G4Incl: bl2->k != 0. Going back to pnu44." << G4endl;
4568  }
4569  goto pnu44;
4570 pnu831:
4571  standardRandom(&rndm, &(hazard->igraine[18]));
4572  geff = t[9]/sq; //t(10)->t[9]
4573  gg = g0;
4574  if (sq > 1500.0) {
4575    gg=200.0;
4576  }
4577
4578  // largeur variable du delta (phase space factor G4introduced 4/2001)
4579  // (180.**3 = 5832000.)
4580  qqq = std::sqrt((std::pow(sq,2) - std::pow((fmp+fmpi),2))*(std::pow(sq,2) - std::pow((fmp-fmpi),2)))/(2.0*sq);
4581  psf = std::pow(qqq,3)/(std::pow(qqq,3)+5832000.);
4582  tdel = -hc/(gg*psf)*std::log(rndm)*geff;         
4583
4584  bl1->ind1[bl9->l2] = 1;
4585  bl1->ind2[bl9->l2] = bl1->ind2[bl9->l2] + ipi[lp];
4586  nc[bl9->l2] = nc[bl9->l2] + 1;
4587  bl1->eps[bl9->l2] = t[9]; //t(10)->t[9]
4588  bl1->p1[bl9->l2] = bl1->p1[bl9->l2] + q1[lp];
4589  bl1->p2[bl9->l2] = bl1->p2[bl9->l2] + q2[lp];
4590  bl1->p3[bl9->l2] = bl1->p3[bl9->l2] + q3[lp]; 
4591
4592  // ce nucleon (ici delta) devient un participant:
4593  jparticip[bl9->l2] = 1;
4594  if(verboseLevel > 3) {
4595    G4cout <<"Particle " << bl9->l2 << " is now participant." << G4endl;
4596  }
4597 
4598  if (ws->nosurf <= 0) {
4599    // surface
4600    pppp = std::sqrt(std::pow(bl1->p1[bl9->l2],2) + std::pow(bl1->p2[bl9->l2],2) + std::pow(bl1->p3[bl9->l2],2));
4601    rrrr = std::sqrt(std::pow(bl3->x1[bl9->l2],2) + std::pow(bl3->x2[bl9->l2],2) + std::pow(bl3->x3[bl9->l2],2));
4602    if (pppp <= bl10->pf) {
4603      xv = pppp/bl10->pf;
4604      rcorr = interpolateFunction(xv);
4605      if (rrrr > rcorr) {
4606        bl3->x1[bl9->l2] = bl3->x1[bl9->l2]*rcorr/rrrr;
4607        bl3->x2[bl9->l2] = bl3->x2[bl9->l2]*rcorr/rrrr;
4608        bl3->x3[bl9->l2] = bl3->x3[bl9->l2]*rcorr/rrrr;
4609      }
4610    }
4611    // fin surface
4612  }
4613
4614  // difference with standard cascade :
4615  // the delta is located at the nucleon site to avoid problems
4616  // with the reflexion on the wall
4617  if(lp != npion) {
4618    lp1 = lp + 1;
4619    //    for(G4int i10 = lp1; i10 <= npion; lp1++) {
4620    for(G4int i10 = lp1; i10 <= npion; i10++) {
4621      ipi[i10-1] = ipi[i10];
4622      ym[i10-1] = ym[i10];
4623      q1[i10-1] = q1[i10];
4624      q2[i10-1] = q2[i10];
4625      q3[i10-1] = q3[i10];
4626      q4[i10-1] = q4[i10];
4627      y1[i10-1] = y1[i10];
4628      y2[i10-1] = y2[i10];
4629      y3[i10-1] = y3[i10];
4630    }
4631  }
4632  npion = npion-1;
4633  ncol = ncol+1;
4634  mrpd = mrpd+1;
4635
4636  if(bl2->k != 0) {
4637    kd = 0;
4638    ccr = tau;
4639    for(G4int i = 1; i <= bl2->k; i++) {
4640      i20 = i - kd;
4641      if((bl2->ind[i] == bl9->l1) || (bl2->ind[i] == bl9->l2) || (bl2->jnd[i] == bl9->l1) || (bl2->jnd[i] == bl9->l2)) {
4642        kd = kd + 1;
4643      }
4644      else {
4645        bl2->crois[i20] = bl2->crois[i] - ccr;
4646        bl2->ind[i20] = bl2->ind[i];
4647        bl2->jnd[i20] = bl2->jnd[i];
4648      }
4649    }
4650
4651    bl2->k = bl2->k - kd;
4652    for(G4int i10 = 1; i10 <= bl2->k; i10++) {
4653      if(bl2->ind[i10] <= bl9->l1) {
4654        continue;
4655      }
4656      else {
4657        bl2->ind[i10] = bl2->ind[i10] - 1;
4658      }
4659    }
4660  }
4661
4662  new1(bl9->l2);
4663
4664  if(tdel <= bl4->tmax5) {
4665    bl2->k = bl2->k + 1;
4666    bl2->crois[bl2->k] = tdel;
4667    bl2->ind[bl2->k] = bl9->l2;
4668    bl2->jnd[bl2->k] = 0;
4669  }
4670
4671  bl2->k = bl2->k + 1;
4672  bl2->crois[bl2->k] = ref(bl3->x1[bl9->l2], bl3->x2[bl9->l2], bl3->x3[bl9->l2], bl1->p1[bl9->l2], bl1->p2[bl9->l2], bl1->p3[bl9->l2], bl1->eps[bl9->l2],r22);
4673  if(verboseLevel > 3) {
4674    if(bl2->crois[bl2->k] < 0.0) {
4675      G4cout <<"G4Incl: Reflection time < 0! (line 3955)" << G4endl;
4676    }
4677  }
4678  bl2->ind[bl2->k] = bl9->l2;
4679  bl2->jnd[bl2->k] = -1;
4680
4681  if(verboseLevel > 3) {
4682    G4cout <<"G4Incl: Going back to pnu449 at line 3917." << G4endl;
4683  }
4684  goto pnu449; // Line 3917
4685
4686  // reflection on or transmission through the potential wall
4687 pnu600:
4688  // deutons pas bien compris ici cv ?
4689  if (npproj[bl9->l1] == 0) {
4690    if(verboseLevel > 3) {
4691      G4cout <<"G4Incl: npproj[l1] == 0. Going to pnu608." << G4endl;
4692    }
4693    goto pnu608;
4694  }
4695 
4696  if (bl1->ind1[bl9->l1] != 0) {
4697    if(verboseLevel > 3) {
4698      G4cout <<"wrong reentering particle (ind1[l1] != 0)" << G4endl;
4699      G4cout <<"ind1[" << bl9->l1 << "] = " << bl1->ind1[bl9->l1] << G4endl;
4700    }
4701  }
4702 
4703  if (bl3->x1[bl9->l1]*(bl1->p1[bl9->l1])+bl3->x2[bl9->l1]*(bl1->p2[bl9->l1])+bl3->x3[bl9->l1]*(bl1->p3[bl9->l1]) > 0.0) {
4704    if(verboseLevel > 3) {
4705      G4cout <<"wrong reentering particle" << G4endl;
4706      G4cout <<"particle: l1 = " << bl9->l1 << G4endl;
4707    }
4708  }
4709 
4710  var_ab = std::pow(bl1->p1[bl9->l1],2) + std::pow(bl1->p2[bl9->l1],2) + std::pow(bl1->p3[bl9->l1],2);
4711  gpsg = 0.0;
4712  if (var_ab > 0.0) {
4713    gpsg = std::sqrt((std::pow(bl1->eps[bl9->l1]+v0,2)-pm2)/var_ab); 
4714  }
4715 
4716  bl1->p1[bl9->l1] = gpsg*(bl1->p1[bl9->l1]);                                               
4717  bl1->p2[bl9->l1] = gpsg*(bl1->p2[bl9->l1]);                                               
4718  bl1->p3[bl9->l1] = gpsg*(bl1->p3[bl9->l1]);                                               
4719  bl1->eps[bl9->l1] = bl1->eps[bl9->l1] + v0;
4720  npproj[bl9->l1] = 0;
4721  bl5->nesc[bl9->l1] = 0;
4722
4723  // reevaluation of the times tab after entrance of 2nd,..nucleon
4724  // of the projectile (goto 602 instead of 607 modif. 13/06/01)
4725  goto pnu602;
4726
4727  // deutons
4728  // pour un non participant la transmission est impossible:
4729 pnu608:
4730  if(varavat->kveux == 1) {
4731    varavat->del1avat[iavat] = bl1->ind1[bl9->l1];
4732    varavat->energyavat[iavat] = bl1->eps[bl9->l1] - fmp;
4733  }
4734  if(jparticip[bl9->l1] == 0) {
4735    if(verboseLevel > 3) {
4736      G4cout <<"G4Incl: jparticip[l1] == 0. Going to pnu601." << G4endl;
4737    }
4738    goto pnu601;
4739  }
4740  if(varavat->kveux == 1) {
4741    varavat->go_out[iavat]=1;
4742  }
4743  if (bl1->ind1[bl9->l1] == 0) {
4744    goto pnu605;
4745  }
4746  fm = am(bl1->p1[bl9->l1],bl1->p2[bl9->l1],bl1->p3[bl9->l1],bl1->eps[bl9->l1]);
4747  pot = v1;
4748  goto pnu606;
4749
4750 pnu605:
4751  fm = fmp;
4752  pot = v0;
4753
4754 pnu606:
4755  if(verboseLevel > 3) {
4756    G4cout <<"G4Incl: Now at pnu606. Calculating transmission probability." << G4endl;
4757  }
4758  tp = transmissionProb(bl1->eps[bl9->l1]-fm,bl1->ind2[bl9->l1],itch,bl3->r2,v0);
4759  if(varavat->kveux == 1) {
4760    varavat->energyavat[iavat] = bl1->eps[bl9->l1] - fm;
4761  }
4762  standardRandom(&rndm,&(hazard->igraine[10]));
4763
4764  if (rndm > tp) {
4765    if(verboseLevel > 3) {
4766      G4cout <<"G4Incl:" << G4endl;
4767    }
4768    goto pnu601;
4769  }
4770
4771  // ici la particule l1 s'échappe du noyau:
4772  bl5->nesc[bl9->l1] = 1;
4773  nbquit = nbquit + 1;
4774  itch = itch - (1 + bl1->ind2[bl9->l1])/2;
4775  var_ab = std::pow(bl1->p1[bl9->l1],2) + std::pow(bl1->p2[bl9->l1],2) + std::pow(bl1->p3[bl9->l1],2);
4776  gpsg = 0.0;
4777  if(var_ab > 0.0) {
4778    gpsg = std::sqrt((std::pow(bl1->eps[bl9->l1]-pot,2) - fm*fm)/(var_ab));
4779  }
4780  bl1->p1[bl9->l1] = gpsg*(bl1->p1[bl9->l1]);
4781  bl1->p2[bl9->l1] = gpsg*(bl1->p2[bl9->l1]);
4782  bl1->p3[bl9->l1] = gpsg*(bl1->p3[bl9->l1]);
4783  bl1->eps[bl9->l1] = bl1->eps[bl9->l1] - pot;
4784
4785  // comptage des particules hors du noyau (7/6/2002):
4786  // (remnant minimum=1 nucleon)
4787  if(nbquit >= (ia-1)) {
4788    if(verboseLevel > 3) {
4789      G4cout <<"G4Incl: nbquit >= (ia - 1). Going to pnu255." << G4endl;
4790    }
4791    goto pnu255;
4792  }
4793
4794  if(verboseLevel > 3) {
4795    G4cout <<"G4Incl: Going to pnu 602." << G4endl;
4796  }
4797  goto pnu602;
4798
4799  // here no transmission possible
4800 pnu601:
4801  pspr=bl3->x1[bl9->l1]*(bl1->p1[bl9->l1])+bl3->x2[bl9->l1]*(bl1->p2[bl9->l1])+bl3->x3[bl9->l1]*(bl1->p3[bl9->l1]);
4802  if(varavat->kveux == 1) {
4803    varavat->go_out[iavat]=0;
4804  }
4805
4806  // surface: modif a.b. pour tenir compte du rayon variable du noyau.
4807  // (x2cour remplace r22 le rayon**2 fixe du noyau)
4808  x2cour = std::pow(bl3->x1[bl9->l1],2) + std::pow(bl3->x2[bl9->l1],2) + std::pow(bl3->x3[bl9->l1],2);
4809  bl1->p1[bl9->l1] = bl1->p1[bl9->l1] - 2.0*(bl3->x1[bl9->l1])*pspr/x2cour;
4810  bl1->p2[bl9->l1] = bl1->p2[bl9->l1] - 2.0*(bl3->x2[bl9->l1])*pspr/x2cour;
4811  bl1->p3[bl9->l1] = bl1->p3[bl9->l1] - 2.0*(bl3->x3[bl9->l1])*pspr/x2cour;
4812  // fin modif surface a.b.             
4813
4814 pnu602:
4815  if(verboseLevel > 3) {
4816    G4cout <<"G4Incl: Now at pnu602." << G4endl;
4817  }
4818 
4819  if(bl2->k != 0) {
4820    kd = 0;
4821    ccr = tau;
4822    for(G4int i = 1; i <= bl2->k; i++) {
4823      i20 = i - kd;
4824
4825      if((bl2->jnd[i] == bl9->l1) || ((bl2->ind[i] == bl9->l1) && (bl2->jnd[i] != 0))) {
4826        kd = kd + 1;
4827        continue;
4828      }
4829     
4830      bl2->crois[i20] = bl2->crois[i] - ccr;
4831      bl2->ind[i20] = bl2->ind[i];
4832      bl2->jnd[i20] = bl2->jnd[i];
4833    }
4834    bl2->k = bl2->k - kd;
4835
4836    if (bl5->nesc[bl9->l1] == 1) {
4837      goto pnu613;
4838    }
4839  }
4840
4841  if(verboseLevel > 3) {
4842    G4cout <<"G4Incl: Now calling new1(l1) (new1(" << bl9->l1 << "))" << G4endl;
4843  }
4844  new1(bl9->l1);
4845
4846  if(verboseLevel > 3) {
4847    G4cout <<"G4Incl: Now calling ref." << G4endl;
4848    G4cout <<"x1 = " << bl3->x1[bl9->l1] <<" x2 = " << bl3->x2[bl9->l1] <<" x3 = " << bl3->x3[bl9->l1] << G4endl;
4849    G4cout <<"p1 = " << bl1->p1[bl9->l1] <<" p2 = " << bl1->p2[bl9->l1] <<" p3 = " << bl1->p3[bl9->l1] <<" eps = " << bl1->eps[bl9->l1] << G4endl;
4850  }
4851  tref = ref(bl3->x1[bl9->l1],bl3->x2[bl9->l1],bl3->x3[bl9->l1],bl1->p1[bl9->l1],bl1->p2[bl9->l1],bl1->p3[bl9->l1],bl1->eps[bl9->l1],r22); // line 4101
4852  if(verboseLevel > 3) {
4853    G4cout <<"Returned from function ref. tref = " << tref << G4endl;
4854  }
4855 
4856  if(verboseLevel > 3) {
4857    if(tref < 0.0) {
4858      G4cout <<"G4Incl: Reflection time < 0 (line 4101)!" << G4endl;
4859      G4cout <<"G4Incl: bl1->eps[" << bl9->l1 << "] = " << bl1->eps[bl9->l1] << G4endl;
4860    }
4861  }
4862 
4863  if (tref > bl4->tmax5) {
4864    goto pnu615;
4865  }
4866  bl2->k = bl2->k + 1;
4867  bl2->crois[bl2->k] = tref;
4868  bl2->ind[bl2->k] = bl9->l1;
4869  bl2->jnd[bl2->k] = -1;
4870
4871 pnu615:
4872  if(verboseLevel > 3) {
4873    G4cout <<"G4Incl: Now at pnu615." << G4endl;
4874  }
4875 
4876  if (npion == 0) {
4877    goto pnu613;
4878  }
4879  if (bl1->ind1[bl9->l1] == 1) {
4880    goto pnu613;
4881  }
4882  for(G4int k20 = 1; k20 <= npion; k20++) { //do 614 k20=1,npion
4883    new3(y1[k20], y2[k20], y3[k20], q1[k20], q2[k20], q3[k20], q4[k20], k20, bl9->l1);
4884  }
4885 pnu613:
4886  if(verboseLevel > 3) {
4887    G4cout <<"G4Incl: Now at pnu613." << G4endl;
4888  }
4889
4890  if (bl2->k == 0) {
4891    goto pnu230;
4892  }
4893
4894  if(verboseLevel > 3) {
4895    G4cout <<"G4Incl. bl2->k != 0. Going back to pnu449 from line 4077." << G4endl;
4896    G4cout <<"G4Incl: bl2->k = " << bl2->k << G4endl;
4897    for(G4int myindex = 0; myindex <= bl2->k; myindex++) {
4898      G4cout <<"index = " << myindex << " ind = " << bl2->ind[myindex] << " jnd = " << bl2->jnd[myindex] << " crois = " << bl2->crois[myindex] << G4endl;
4899      if(bl2->crois[myindex] < 0.0) {
4900        G4cout <<"Negative time!!! Dumping information on collision: " << G4endl;
4901        G4int part1 = bl2->ind[myindex];
4902        G4int part2 = bl2->jnd[myindex];
4903        G4cout <<"particle 1 index = " << bl2->ind[myindex] << " \t particle 2 index = " << bl2->jnd[myindex] << G4endl;
4904        if(part1 >= 0) {
4905          G4cout <<"Particle 1: " << G4endl;
4906          G4cout <<"p1 = " << bl1->p1[part1] <<"p2 = " << bl1->p2[part1] <<"p3 = " << bl1->p3[part1] <<" eps = " << bl1->eps[part1] << G4endl;
4907          G4cout <<"x1 = " << bl3->x1[part1] <<"x2 = " << bl3->x2[part1] <<"x3 = " << bl3->x3[part1] << G4endl;
4908        }
4909        if(part2 >= 0) {
4910          G4cout <<"Particle 2: " << G4endl;
4911          G4cout <<"p1 = " << bl1->p1[part2] <<"p2 = " << bl1->p2[part2] <<"p3 = " << bl1->p3[part2] <<" eps = " << bl1->eps[part2] << G4endl;
4912          G4cout <<"x1 = " << bl3->x1[part2] <<"x2 = " << bl3->x2[part2] <<"x3 = " << bl3->x3[part2] << G4endl;
4913        }
4914      }
4915    }
4916  }
4917
4918  goto pnu449; // Line 4077
4919
4920  // decay of the surviving deltas
4921 pnu230:
4922  if(verboseLevel > 3) {
4923    G4cout <<"G4Incl: Now at pnu230." << G4endl;
4924  }
4925  // decay of the surviving deltas
4926pnu255:
4927  if(verboseLevel > 3) {
4928    G4cout <<"G4Incl: Now at pnu6255." << G4endl;
4929  }
4930
4931  if (k3 == 1) {
4932    goto pnu256;
4933  }
4934  if (k4 == 0) {
4935    goto pnu256;
4936  }
4937
4938  npidir = npion;
4939  for(G4int i = 1; i <= ia; i++) {
4940    if (bl1->ind1[i] == 0) {
4941      continue;
4942    }
4943    npion = npion + 1;
4944    var_ab = std::pow(bl1->eps[i],2) - std::pow(bl1->p1[i],2) - std::pow(bl1->p2[i],2) - std::pow(bl1->p3[i],2);
4945    ym[npion] = 0.0;
4946
4947    if(var_ab > 0.0) {
4948      ym[npion] = std::sqrt(var_ab);
4949    }
4950    xy1 = bl1->p1[i];
4951    xy2 = bl1->p2[i];
4952    xy3 = bl1->p3[i];
4953    xye = bl1->eps[i];
4954    if(varavat->kveux == 1) {
4955      iavat = iavat + 1;
4956      varavat->timeavat[iavat] = tim;
4957      varavat->l1avat[iavat] = i;
4958      varavat->l2avat[iavat] = -2;
4959      varavat->energyavat[iavat] = ym[npion];
4960      varavat->bloc_paul[iavat] = 0;
4961      varavat->bloc_cdpp[iavat] = 0;
4962      varavat->del1avat[iavat] = bl1->ind1[bl9->l1];
4963      varavat->jpartl1[iavat] = 1;
4964      varavat->jpartl2[iavat] = 0;
4965    }
4966
4967    decay2(&(bl1->p1[i]), &(bl1->p2[i]), &(bl1->p3[i]), &(bl1->eps[i]), &(q1[npion]), &(q2[npion]), &(q3[npion]),
4968           &(q4[npion]), &(ym[npion]), &fmp, &fmpi, &(bl9->hel[i]));
4969
4970    if(verboseLevel > 3) {
4971      G4cout <<"Quantities after decay2: " << G4endl;
4972      G4cout <<"i = " << i << " bl1->p1[i] = " << bl1->p1[i] << " bl1->p2[i] = " << bl1->p2[i] << " bl1->p3[i] = " << bl1->p3[i] << " bl1->eps[i] = " << bl1->eps[i] << G4endl;
4973    }
4974   
4975    if(bl5->nesc[i] == 0) {
4976      idecf = 1;
4977    }
4978
4979    if (ws->nosurf <= 0) {
4980      // surface
4981      if (bl5->nesc[i] == 0.0) {
4982        pppp = std::sqrt(std::pow(bl1->p1[i],2) + std::pow(bl1->p2[i],2) + std::pow(bl1->p3[i],2));
4983        rrrr = std::sqrt(std::pow(bl3->x1[i],2) + std::pow(bl3->x2[i],2) + std::pow(bl3->x3[i],2));
4984        if (pppp <= bl10->pf) {
4985          xv = pppp/bl10->pf;
4986          rcorr = interpolateFunction(xv);
4987          if (rrrr > rcorr) { //then
4988            bl3->x1[i] = bl3->x1[i]*rcorr/rrrr;
4989            bl3->x2[i] = bl3->x2[i]*rcorr/rrrr;
4990            bl3->x3[i] = bl3->x3[i]*rcorr/rrrr;
4991          }
4992        }
4993      }
4994      // fin surface
4995    }
4996
4997    if (bl1->ind2[i]*(bl1->ind2[i]) == 9) {
4998      goto pnu280;
4999    }
5000
5001    standardRandom(&rndm, &(hazard->ial));
5002
5003    if (rndm*3. < 1.0) {
5004      goto pnu283;
5005    }
5006    ipi[npion] = 0;
5007    goto pnu285;
5008
5009  pnu283:
5010    if(verboseLevel > 3) {
5011      G4cout <<"G4Incl: Now at pnu283." << G4endl;
5012    }
5013
5014    ipi[npion] = bl1->ind2[i]*2;
5015    bl1->ind2[i] = -1*(bl1->ind2[i]);
5016    goto pnu285;
5017
5018  pnu280:
5019    if(verboseLevel > 3) {
5020      G4cout <<"G4Incl: Now at pnu280." << G4endl;
5021    }
5022
5023    bl1->ind2[i] = bl1->ind2[i]/3;
5024    ipi[npion] = 2*(bl1->ind2[i]);
5025
5026  pnu285:
5027    if(verboseLevel > 3) {
5028      G4cout <<"G4Incl: Now at pnu285." << G4endl;
5029    }
5030
5031    y1[npion] = bl3->x1[i];
5032    y2[npion] = bl3->x2[i];
5033    y3[npion] = bl3->x3[i];
5034  }
5035
5036  if(verboseLevel > 3) {
5037    G4cout <<"out of the loop..." << G4endl;
5038  }
5039 
5040  if(varavat->kveux == 1) {
5041    varavat->bavat = b;
5042    varavat->nopartavat = nopart;
5043    varavat->ncolavat = ncol;
5044    varavat->nb_avat = iavat;
5045  }
5046
5047  // final properties of the incoming nucleon and of the remnant
5048  // before evaporation
5049
5050  // tableau des energies a la fin (avatar.hbk)
5051  if(varavat->kveux == 1) {
5052    for(G4int i = 1; i <= ia; i++) {
5053      if(bl5->nesc[i] == 0) {
5054        if(jparticip[i] == 1) {
5055          varavat->epsf[i] = bl1->eps[i];
5056        }
5057        else {
5058          varavat->epsf[i] = 0.0;
5059        }
5060      }
5061      else {
5062        varavat->epsf[i] = 0.0;
5063      }
5064    }
5065  }
5066
5067 pnu256:
5068  if(verboseLevel > 3) {
5069    G4cout <<"G4Incl: Now at pnu256." << G4endl;
5070  }
5071
5072  elead = 0.0;
5073  lead = 0;
5074  npx = 0;
5075  erem = 0.;
5076  izrem = 0;
5077  inrem = 0;
5078  iarem = 0;
5079  rcm1 = 0.0;
5080  rcm2 = 0.0;
5081  rcm3 = 0.0;
5082  prem1 = 0.0;
5083  prem2 = 0.0;
5084  prem3 = 0.0;
5085  pout1 = 0.0;
5086  pout2 = 0.0;
5087  pout3 = 0.0;
5088  eout = 0.0;
5089  cmultn = 0.0;
5090
5091  if (kindstruct->kindf7 <= 2) {
5092    if (ncol == 0 || nc[1] == 0) { // then nc(1)->nc[0]
5093      if(verboseLevel > 3) {
5094        G4cout <<"no collisioms" << G4endl;
5095      }
5096      goto pnu9100;
5097    }
5098  }
5099  else {
5100    if (kindstruct->kindf7 <= 5) {
5101      if (ncol == 0) {
5102        if(verboseLevel > 3) {
5103          G4cout <<"no collisioms" << G4endl;
5104        }
5105        goto pnu9100;
5106      }
5107    }
5108    else {
5109      // ici faisceau composite: modif a.b. 2/2002 pour tous les composites:
5110      nsum_col = 0;
5111      for(G4int i = 1; i <= bl3->ia1; i++) {
5112        nsum_col = nsum_col + nc[i];
5113      }
5114      if (ncol == 0 || nsum_col == 0) { //then
5115        goto pnu9100;
5116      }
5117    }
5118  }
5119
5120  goto pnu9101;
5121  // pour eviter renvoi des resultats du run precedent cv 20/11/98
5122 pnu9100:
5123  iarem = bl3->ia2;
5124  izrem = iz2;
5125  esrem = 0.0;
5126  erecrem = 0.0;
5127  nopart = -1;
5128  // fin ajout cv
5129  if(verboseLevel > 3) {
5130    G4cout <<"End of algorithm after pnu9100." << G4endl;
5131  }
5132  goto pnureturn;
5133
5134 pnu9101:
5135  if(verboseLevel > 3) {
5136    G4cout <<"G4Incl: Now at pnu9101." << G4endl;
5137  }
5138
5139  nopart = 0;
5140  ekout = 0.0;
5141
5142  for(G4int i = 1; i <= ia; i++) {
5143    if(bl5->nesc[i] != 0) {
5144      xl1 = xl1-bl3->x2[i]*(bl1->p3[i]) + (bl3->x3[i])*(bl1->p2[i]);
5145      xl2 = xl2-bl3->x3[i]*(bl1->p1[i]) + bl3->x1[i]*(bl1->p3[i]);
5146      xl3 = xl3-bl3->x1[i]*(bl1->p2[i]) + bl3->x2[i]*(bl1->p1[i]);
5147
5148      // ici ajout de pout cv le 5/7/95
5149      pout1 = pout1 + bl1->p1[i];
5150      pout2 = pout2 + bl1->p2[i];
5151      pout3 = pout3 + bl1->p3[i];
5152      eout = eout+bl1->eps[i] - fmp;
5153      //      ic33 = int((std::floor(double(bl1->ind2[i]+3))/double(2)));
5154      ic33 = (bl1->ind2[i]+3)/2;
5155      //nopart = nopart + 1;
5156      kind[nopart] = 3 - ic33;
5157      if(verboseLevel > 3) {
5158        G4cout <<"kind[" << nopart << "] = " << kind[nopart] << G4endl;
5159      }
5160      ep[nopart] = bl1->eps[i] - fmp;
5161      if(verboseLevel > 2) {
5162        if(ep[nopart] > calincl->f[2]) {
5163          G4cout <<"ep[" << nopart << "] = " << ep[nopart] << " > " << calincl->f[2] << G4endl;
5164          G4cout <<"E = " << bl1->eps[nopart] << G4endl;
5165          G4cout <<"px = " << bl1->p1[nopart] << " py = " << bl1->p2[nopart] << " pz = " << bl1->p3[nopart] << G4endl;
5166          G4cout <<"Particle mass = " << fmp << G4endl;
5167        }
5168      }
5169      bmass[nopart] = fmp;
5170      ekout = ekout + ep[nopart];
5171      ptotl = std::sqrt(std::pow(bl1->p1[i],2) + std::pow(bl1->p2[i],2) + std::pow(bl1->p3[i],2));
5172      alpha[nopart] = bl1->p1[i]/ptotl;
5173      beta[nopart] = bl1->p2[i]/ptotl;
5174      gam[nopart] = bl1->p3[i]/ptotl;
5175      nopart = nopart + 1;
5176      continue;
5177    }
5178   
5179    t[3] = bl3->x1[i]*(bl3->x1[i]) + bl3->x2[i]*(bl3->x2[i]) + bl3->x3[i]*(bl3->x3[i]); //t(4)->t[3]
5180    erem = erem + bl1->eps[i] - fmp;
5181    rcm1 = rcm1 + bl3->x1[i];
5182    rcm2 = rcm2 + bl3->x2[i];
5183    rcm3 = rcm3 + bl3->x3[i];
5184    prem1 = prem1 + bl1->p1[i];
5185    prem2 = prem2 + bl1->p2[i];
5186    prem3 = prem3 + bl1->p3[i];
5187    izrem = izrem + (1 + bl1->ind2[i])/2;
5188    iarem = iarem + 1;
5189  }
5190
5191  //  correction pions 21/3/95 jc
5192  ichpion = 0;
5193  if(npion != 0) {
5194    for(G4int ipion = 1; ipion <= npion; ipion++) {
5195      pout1 = pout1 + q1[ipion];
5196      pout2 = pout2 + q2[ipion];
5197      pout3 = pout3 + q3[ipion];
5198      eout = eout + q4[ipion];
5199      xl1 = xl1 - y2[ipion]*q3[ipion] + y3[ipion]*q2[ipion];
5200      xl2 = xl2 - y3[ipion]*q1[ipion] + y1[ipion]*q3[ipion];
5201      xl3 = xl3 - y1[ipion]*q2[ipion] + y2[ipion]*q1[ipion];
5202      ichpion = ichpion + ipi[ipion]/2;
5203      //      nopart = nopart + 1;
5204      kind[nopart] = 4 - ipi[ipion]/2;
5205      ptotl = std::sqrt(std::pow(q1[ipion],2) + std::pow(q2[ipion],2) + std::pow(q3[ipion],2));
5206      ep[nopart] = q4[ipion] - fmpi;
5207      bmass[nopart] = fmpi;
5208      ekout = ekout + ep[nopart];
5209      alpha[nopart] = q1[ipion]/ptotl;
5210      beta[nopart] = q2[ipion]/ptotl;
5211      gam[nopart] = q3[ipion]/ptotl;
5212      nopart++;
5213    }
5214  }
5215 
5216  // fin correction pions sur impulsion et moment angulaire et charge
5217  // ici ajout de pfrem cv le 5/7/95
5218  pfrem1 = -pout1;
5219  pfrem2 = -pout2;
5220  pfrem3 = pinc - pout3;
5221
5222  inrem = iarem - izrem;
5223  iejp = iz2 - izrem;
5224  iejn = bl3->ia2 - inrem - iz2;
5225  irem = inrem + izrem;
5226
5227  // intrinsic momentum of the remnant (a.b. 05/2001):
5228  // momentum of projectile minus momentum of all outgoing particles
5229  // minus angular momentum of the remnant computed
5230  // from the sum of all inside nucleons.
5231  //   2675     c      xl1=xl1-rcm2/irem*prem3+rcm3/irem*prem2
5232  //   2676     c      xl2=xl2-rcm3/irem*prem1+rcm1/irem*prem3
5233  //   2677     c      xl3=xl3-rcm1/irem*prem2+rcm2/irem*prem1
5234  //   2678     c                           here the remnant momentum is pin - sig(pout),
5235  //   2679     c   and the distance with respect to the barycenter of the actual target
5236  xl1 = xl1 - (rcm2/irem - x2_target)*pfrem3+(rcm3/irem - x3_target)*pfrem2;
5237  xl2 = xl2 - (rcm3/irem - x3_target)*pfrem1+(rcm1/irem - x1_target)*pfrem3;
5238  xl3 = xl3 - (rcm1/irem - x1_target)*pfrem2+(rcm2/irem - x2_target)*pfrem1;
5239  l = int(std::sqrt(xl1*xl1 + xl2*xl2 + xl3*xl3)/hc + 0.5);
5240
5241  iej = bl3->ia2 - irem;
5242
5243  eh5 = erem - std::pow(double(irem)/double(a2),1.666667)*efer;
5244  if(verboseLevel > 3) {
5245    G4cout <<"erem used for excitation energy calculation = " << erem << G4endl;
5246    G4cout <<"irem used for excitation energy calculation = " << irem << G4endl;
5247    G4cout <<"a2 used for excitation energy calculation = " << a2 << G4endl;
5248    G4cout <<"eh5 used for excitation energy calculation = " << eh5 << G4endl;
5249  }
5250  sepa = (bl3->ia2 - irem)*(v0 - tf);
5251  eh6 = eh5;
5252
5253  // deutons ajout beproj ?????? on retire beproj (18/06/2002 ab cv)
5254  // eh5=erem-efer-beproj+(ia2-irem)*tf
5255  eh5 = erem - efer + (bl3->ia2 - irem)*tf;
5256  if (eh5 < 0.0) {
5257    eh5 = 0.00000001;
5258  }
5259
5260  xlab = tlab - eout - eh5 - sepa;
5261  ecoreh5 = 0.0;
5262
5263  if (iqe == 1) {
5264    eh5=0.00000001;
5265  }
5266  else {
5267    if (eh5 < 0.0) {
5268      if (npion == 0) {
5269        nopart = -1;
5270        if(verboseLevel > 3) {
5271          G4cout <<"npion == 0" << G4endl;
5272          G4cout <<"End of algorithm because npion == 0" << G4endl;
5273        }
5274        goto pnureturn;
5275      }
5276      else {
5277        ecoreh5 = -eh5;
5278        eh5 = 0.000000001;
5279      }
5280    }
5281  }
5282  if (idecf != 0 && eh5 < 0.0) {
5283    ecoreh5 = -eh5;
5284    eh5 = 0.000001;
5285  }
5286
5287  iarem = irem;
5288  pfreml2 = std::pow(pfrem1,2) + std::pow(pfrem2,2) + std::pow(pfrem3,2);
5289  if (pfreml2 > 1.0e-12) {
5290    pfreml = std::sqrt(pfreml2);
5291    alrem = pfrem1/pfreml;
5292    berem = pfrem2/pfreml;
5293    garem = pfrem3/pfreml;
5294  }
5295  else {
5296    alrem = 0.0;
5297    berem = 0.0;
5298    garem = 1.0;
5299  }
5300
5301  erecrem = pfreml2/(std::sqrt(pfreml2 + std::pow((fmp*iarem),2)) + fmp*iarem);
5302
5303  if(iarem == 1) {
5304    erecrem = erecrem + eh5;
5305  }
5306
5307  // correction recul
5308  erecg = erecrem + ecoreh5;
5309  // correction energie d'excitation pour une absorption (a.b., c.v. 2/2002)
5310  esrem = eh5;
5311
5312  if (ekout < 0.001) {
5313    if(verboseLevel > 3) {
5314      G4cout <<"ekout < 0.001" << G4endl;
5315      G4cout <<"End of algorithm because kout < 0.001" << G4endl;
5316    }
5317    goto pnureturn;
5318  }
5319 
5320  // on ote l'instruction precedente car esrem toujours nulle 14/9/99
5321
5322  if (erecg > 0.25) {
5323    fffc = (ekout - erecg)/ekout;
5324    if (fffc < 0.0) {
5325      fffc = 0.0;
5326    }
5327
5328    for(G4int ipart = 0; ipart < nopart; ipart++) {
5329      ep[ipart] = ep[ipart]*fffc;
5330    }
5331  }
5332
5333  // modif boudard juillet 99 (il faut tenir compte de la renormalisation
5334  // des energies pour les impulsions.)
5335  pfrem1 = 0.0;
5336  pfrem2 = 0.0;
5337  pfrem3 = pinc;
5338  for(G4int ipart = 0; ipart < nopart; ipart++) {
5339    xmodp = std::sqrt(ep[ipart]*(2.0*bmass[ipart] + ep[ipart]));
5340    pfrem1 = pfrem1 - alpha[ipart]*xmodp;
5341    pfrem2 = pfrem2 - beta[ipart]*xmodp;
5342    pfrem3 = pfrem3 - gam[ipart]*xmodp;
5343  }
5344  // fin modif a.b.
5345
5346  pfreml2 = std::pow(pfrem1,2) + std::pow(pfrem2,2) + std::pow(pfrem3,2);
5347  erecrem = pfreml2/(std::sqrt(pfreml2 + std::pow((fmp*iarem),2)) + fmp*iarem);
5348
5349  if (pfreml2 > 1.0e-12) {
5350    pfreml = std::sqrt(pfreml2);
5351    alrem = pfrem1/pfreml;
5352    berem = pfrem2/pfreml;
5353    garem = pfrem3/pfreml;
5354  }
5355  else {
5356    alrem = 0.0;
5357    berem = 0.0;
5358    garem = 1.0;
5359  }
5360  // fin  modif a.b. pour incl3
5361
5362  esrem = eh5;
5363
5364  // if the remnant is a nucleon, no excitation energy
5365  if(iarem == 1) {
5366    esrem = 0.0;
5367  }
5368
5369  if(verboseLevel > 3) {
5370    G4cout <<"Reached end of routine..." << G4endl;
5371  }
5372  goto pnureturn;
5373
5374  if(verboseLevel > 3) {
5375    G4cout <<"ia1 > 1 ! " << G4endl;
5376  }
5377 pnureturn:
5378  (*ibert_p) = ibert;
5379  (*nopart_p) = nopart;
5380  (*izrem_p) = izrem;
5381  (*iarem_p) = iarem;
5382  (*esrem_p) = esrem; 
5383  (*erecrem_p) = erecrem;
5384  (*alrem_p) = alrem;
5385  (*berem_p) = berem;
5386  (*garem_p) = garem;
5387  (*bimpact_p) = bimpact;
5388  (*l_p) = l;
5389}
5390
5391
5392void G4Incl::collis(G4double *p1_p, G4double *p2_p, G4double *p3_p, G4double *e1_p, G4double *pout11_p, G4double *pout12_p, 
5393                    G4double *pout13_p, G4double *eout1_p, G4double *q1_p, G4double *q2_p, G4double *q3_p,
5394                    G4double *q4_p, G4int *np_p, G4int *ip_p, G4int *k2_p, G4int *k3_p, G4int *k4_p, 
5395                    G4int *k5_p, G4int *m1_p, G4int *m2_p, G4int *is1_p, G4int *is2_p)
5396{
5397  G4double p1 = (*p1_p);
5398  G4double p2 = (*p2_p);
5399  G4double p3 = (*p3_p);
5400
5401  G4double e1 = (*e1_p);
5402
5403  G4double debugOutput = 0.0;
5404  debugOutput = am(p1,p2,p3,e1);
5405
5406  G4double pout11 = (*pout11_p);
5407  G4double pout12 = (*pout12_p);
5408  G4double pout13 = (*pout13_p);
5409  G4double eout1 = (*eout1_p);
5410
5411  G4double q1 = (*q1_p);
5412  G4double q2 = (*q2_p);
5413  G4double q3 = (*q3_p);
5414  //  G4double q4 = -1*(*q4_p);
5415  G4double q4 = (*q4_p);
5416
5417  G4int np = (*np_p);
5418  G4int ip = (*ip_p);
5419
5420  G4int k2 = (*k2_p);
5421  G4int k3 = (*k3_p);
5422  G4int k4 = (*k4_p);
5423  G4int k5 = (*k5_p);
5424
5425  G4int m1 = (*m1_p);
5426  G4int m2 = (*m2_p);
5427
5428  G4int is1 = (*is1_p);
5429  G4int is2 = (*is2_p);
5430
5431  // Variables:
5432  G4double a = 0.0;
5433  G4double aaa = 0.0;
5434  G4double aac = 0.0;
5435  //  G4double alog;
5436  G4double alphac = 0.0;
5437  //  G4double amax1;
5438  G4double apt = 0.0;
5439  G4double argu = 0.0;
5440  G4double b = 0.0;
5441  G4double btmax = 0.0;
5442  G4double cfi = 0.0;
5443  G4double cpt = 0.0;
5444  G4double ctet = 0.0;
5445  G4double e3 = 0.0;
5446  G4double ecm = 0.0;
5447  G4double ex[3];
5448  G4double ey[3];
5449  G4double ez[3];
5450  G4double qq[3];
5451  for(G4int init_i = 0; init_i < 3; init_i++) {
5452    ex[init_i] = 0.0;
5453    ey[init_i] = 0.0;
5454    ez[init_i] = 0.0;
5455    qq[init_i] = 0.0;
5456  }
5457  G4double f3 = 0.0;
5458  G4double f3max = 0.0;
5459  G4double fi = 0.0;
5460  G4double fracpn = 0.0;
5461  G4double heli = 0.0;
5462  G4int iexpi = 0;
5463  G4int ii = 0;
5464  G4int index = 0;
5465  G4int index2 = 0;
5466  G4int isi = 0;
5467  G4double pin = 0.0;
5468  G4double pl = 0.0;
5469  G4double pnorm = 0.0;
5470  //  G4double pq = 0.0;
5471  G4double psq = 0.0;
5472  G4double qq4 = 0.0;
5473  G4double ranres = 0.0;
5474  G4double rndm = 0.0;
5475  G4double s = 0.0;
5476  G4double s1 = 0.0;
5477  //  G4double sel;
5478  G4double sfi = 0.0;
5479  G4double stet = 0.0;
5480  G4double t = 0.0;
5481  G4double x = 0.0;
5482  G4double xkh = 0.0;
5483  G4double xp1 = 0.0;
5484  G4double xp2 = 0.0;
5485  G4double xp3 = 0.0;
5486  G4double xx = 0.0;
5487  G4double y = 0.0;
5488  G4double yn = 0.0;
5489  G4double z = 0.0;
5490  G4double zn = 0.0;
5491  G4double zz = 0.0;
5492
5493  // !!!  q4 = -1*q4;
5494  //   2837     c
5495  //   2838     c collis                                                                p-n17770
5496  //   2839           subroutine collis(p1,p2,p3,e1,pout11,pout12,pout13,eout1,q1,q2,q3,p-n17780
5497  //   2840          -q4,np,ip,k2,k3,k4,k5,m1,m2,is1,is2)                               p-n17790
5498
5499  //   2841           common/bl6/xx10,isa                                               p-n17800
5500  //   2842           common/bl8/rathr,ramass                                           p-n17810
5501  //   2843           common/hazard/ial,iy1,iy2,iy3,iy4,iy5,iy6,iy7,iy8,iy9,iy10,
5502  //   2844          s               iy11,iy12,iy13,iy14,iy15,iy16,iy17,iy18,iy19
5503  //   2845           common/bl9/hel(300),l1,l2
5504  //  2846            dimension ex(3),ey(3),ez(3),qq(3)                                 p-n17820
5505  //  2847            data xm,xm2,xmdel,ezero,xpi/938.2796,8.8037e5,1232.,1876.6,138./  p-n17830
5506  G4double xm = 938.2796;
5507  G4double xm2 = 8.8037e5;
5508  G4double xmdel = 1232.0;
5509  G4double xpi = 138.0;
5510
5511  //   2848     c      data iy1,iy2,iy3,iy4,iy5,iy6,iy7,iy8,iy10,iy11,iy12,iy13/         p-n17840
5512  //   2849     c     1 12345,22345,32345,42345,52345,62345,72345,82345,34567,47059,21033p-n17850
5513  //   2850     c     1 12345,22345,32345,42345,52345,62345,72345,82341,34567,47059,21033p-n17850
5514  //   2851     c     2,32835/                                                           p-n17860
5515  //   2852     c      data iy9/15637/
5516  //  2853            pcm(e,a,c)=0.5*std::sqrt((e**2-(a+c)**2)*(e**2-(a-c)**2))/e            p-n17870
5517  G4int iso = is1 + is2;
5518  np = 0;
5519  psq = p1*p1 + p2*p2 + p3*p3;
5520  pnorm = std::sqrt(psq);
5521  ecm = e1 + eout1;
5522 
5523  if(ecm < 1925.0) {
5524    goto collis160;
5525  }
5526
5527  if (k3 == 1) {
5528    goto collis17;
5529  }
5530
5531  if(ecm < (2065.0 + bl8->rathr)) {
5532    goto collis17;
5533  }
5534
5535  if((k4-1) < 0) {
5536    goto collis18;
5537  }
5538  if((k4-1) == 0) {
5539    goto collis10;
5540  }
5541  if((k4-1) > 0) {
5542    goto collis20;
5543  }
5544
5545 collis10:
5546  if((m1+m2-1) < 0) {
5547    goto collis19;
5548  }
5549  if((m1+m2-1) == 0) {
5550    goto collis14;
5551  }
5552  if((m1+m2-1) > 0) {
5553    goto collis13;
5554  }
5555
5556 collis19:
5557  if((ecm-2170.4-bl8->ramass) <= 0) {
5558    goto collis17;
5559  }
5560  if((ecm-2170.4-bl8->ramass) > 0) {
5561    goto collis18;
5562  }
5563
5564 collis20:
5565  if((m1+m2-1) < 0) {
5566    goto collis18;
5567  }
5568  if((m1+m2-1) == 0) {
5569    goto collis14;
5570  }
5571  if((m1+m2-1) > 0) {
5572    goto collis13;
5573  }
5574
5575  // test on the recombination possibility for the n-delta system
5576 collis14:
5577  if (k5 == 0) {
5578    goto collis170;
5579  }
5580
5581  standardRandom(&rndm, &(hazard->igraine[10]));
5582
5583  s1 = lowEnergy(ecm, 1, iso);
5584 
5585  if(m1 != 0) {
5586    bl6->xx10=std::sqrt(e1*e1-psq);
5587    bl6->isa=is1;
5588  }
5589  else {
5590    bl6->xx10 = std::sqrt(std::pow(eout1,2)-psq);
5591    bl6->isa = is2;
5592  }
5593
5594  s = s1 + srec(ecm,bl6->xx10, iso,int(bl6->isa));
5595  a = (s - s1)/s;
5596 
5597  if((rndm-a) <= 0) {
5598    goto collis170;
5599  }
5600  if((rndm-a) > 0) {
5601    goto collis17;
5602  }
5603
5604  // test for the behaviour of the delta-delta system
5605 collis13:
5606  if (k5 == 0) {
5607    goto collis160;
5608  }
5609  goto collis17;
5610
5611  // test on the inelasticity
5612 collis18:
5613  standardRandom(&rndm, &(hazard->igraine[0]));
5614  s = lowEnergy(ecm,0,iso);
5615  a = deltaProductionCrossSection(ecm,iso);
5616  a = s/(s+a);
5617  if(rndm > a) {
5618    goto collis100;
5619  }
5620
5621  // elastic scattering
5622  // fit of the b parameter in the differential x-section:
5623  // taken from :j.c.,d.l'hote, j.vandermeulen,nimb111(1996)215
5624  // for pn :improvement of the backward scattering according
5625  // j.c et al, prc56(1997)2431
5626 collis17:
5627  pl = 0.5*ecm*std::sqrt(std::pow(ecm,2) - 4.0*xm2)/xm;
5628  x = 0.001*pl;
5629 
5630  if (iso == 0) {
5631    goto collis80;
5632  }
5633  if (pl > 2000.0) {
5634    goto collis81;
5635  }
5636  x = x*x;
5637  x = std::pow(x,4);
5638  b = 5.5e-6*x/(7.7+x);
5639  goto collis82;
5640
5641 collis81:
5642  b = (5.34 + 0.67*(x-2.0))*1.e-6;
5643  goto collis82;
5644
5645 collis80: 
5646  if (pl < 800.) {
5647    b = (7.16 - 1.63*x)*1.e-6;
5648    b = b/(1.0 + std::exp(-(x - 0.45)/0.05));
5649  }
5650  else {
5651    if (pl < 1100.) {
5652      b = (9.87 - 4.88*x)*1.e-6;
5653    }
5654    else {
5655      b = (3.68 + 0.76*x)*1.e-6;
5656    }
5657  }
5658
5659 collis82:
5660  debugOutput = am(p1,p2,p3,e1);
5661 
5662  btmax = 4.0*psq*b;
5663  z = std::exp(-btmax);
5664  standardRandom(&rndm, &(hazard->igraine[1]));
5665  ranres = rndm; 
5666  y = 1.0 - rndm*(1.0 - z);
5667  t = std::log(y)/b;
5668  iexpi = 0;
5669
5670  if (((m1+m2) == 0) && (iso == 0)) {
5671    apt = 1.0;                                                       
5672    if (pl > 800.) {
5673      apt = std::pow((800.0/pl),2);                                         
5674      cpt = amax1(6.23*std::exp(-1.79*x),0.3);
5675      alphac = 100.0*1.e-6;
5676      aaa = (1 + apt)*(1 - std::exp(-btmax))/b;
5677      argu = psq*alphac;
5678
5679      if (argu >= 8) {
5680        argu = 0.0;
5681      }
5682      else {
5683        argu = std::exp(-4.0*argu);
5684      }
5685
5686      aac = cpt*(1.0 - argu)/alphac;
5687      fracpn = aaa/(aac + aaa);
5688      standardRandom(&rndm, &(hazard->igraine[7]));
5689      if (rndm > fracpn) {
5690        z = std::exp(-4.0*psq*alphac);
5691        iexpi = 1;
5692        //      y = 1.0 - ranres*(10.0 - z);
5693        y = 1.0 - ranres*(1.0 - z);
5694        t = std::log(y)/alphac;
5695      }
5696    }
5697  }
5698
5699  ctet = 1.0 + 0.5*t/psq;
5700  if(std::fabs(ctet) > 1.0) {
5701    ctet = sign(1.0,ctet);
5702  }     
5703
5704  stet = std::sqrt(1.0 - std::pow(ctet,2));
5705  standardRandom(&rndm, &(hazard->igraine[2]));
5706  fi = 6.2832*rndm;
5707  cfi = std::cos(fi);
5708  sfi = std::sin(fi);
5709  xx = p1*p1 + p2*p2;
5710  zz = p3*p3;   
5711
5712  debugOutput = am(p1,p2,p3,e1);
5713
5714  if(xx >= (zz*1.0e-8)) {
5715    yn=std::sqrt(xx);
5716    zn=yn*pnorm;
5717    ez[0] = p1/pnorm; // ez(1) -> ez[0] and so on...
5718    ez[1] = p2/pnorm;
5719    ez[2] = p3/pnorm;
5720    ex[0] = p2/yn;
5721    ex[1] = -p1/yn;
5722    ex[2] = 0.0;     
5723    ey[0] = p1*p3/zn;
5724    ey[1] = p2*p3/zn;
5725    ey[2] = -xx/zn;
5726    p1 = (ex[0]*cfi*stet + ey[0]*sfi*stet + ez[0]*ctet)*pnorm;
5727    p2 = (ex[1]*cfi*stet + ey[1]*sfi*stet + ez[1]*ctet)*pnorm;
5728    p3 = (ex[2]*cfi*stet + ey[2]*sfi*stet + ez[2]*ctet)*pnorm;
5729  }
5730  else {
5731    p1 = p3*cfi*stet;
5732    p2 = p3*sfi*stet;
5733    p3 = p3*ctet;
5734  }
5735  pout11 = -p1;
5736  pout12 = -p2;
5737  pout13 = -p3;
5738  debugOutput = am(p1,p2,p3,e1);
5739
5740  // backward scattering according the parametrization of ref
5741  // prc56(1997)1
5742
5743  if(((m1+m2) != 1) || (iso == 0)) {
5744    standardRandom(&rndm, &(hazard->igraine[7]));
5745    apt = 1.0;
5746    if (pl > 800.0) {
5747      apt = std::pow((800.0/pl),2);
5748    }
5749    if ((iexpi == 1) || (rndm > (1./(1.+apt)))) {
5750      ii = is1;
5751      is1 = is2;
5752      is2 = ii;
5753    }
5754  }
5755
5756  debugOutput = am(p1,p2,p3,e1);
5757  goto exitRoutine;
5758
5759  // delta production
5760  // the production is not isotropic in this version
5761  // it has the same std::exp(b*t) structure as the nn elastic scatteringp-n19170
5762  // (formula 2.3 of j.cugnon et al, nucl phys a352(1981)505)
5763  // parametrization of b taken from ref. prc56(1997)2431
5764 collis100:
5765  if (k4 != 1) {
5766    goto collis101;
5767  }
5768  xmdel = 1232.0 + bl8->ramass;
5769  goto collis103;
5770 collis101: 
5771  //call ribm(rndm,iy10)
5772  standardRandom(&rndm, &(hazard->igraine[9]));
5773
5774  y = std::tan(3.1415926*(rndm - 0.5));
5775  x = 1232.0 + 0.5*130.0*y + bl8->ramass;
5776  if (x < (xm+xpi+2.0)) {
5777    goto collis101;
5778  }
5779  if (ecm < (x+xm+1.)) {
5780    goto collis101;
5781  }
5782
5783  // generation of the delta mass with the penetration factor
5784  // (see prc56(1997)2431)
5785  y = std::pow(ecm,2);
5786  q2 = (y - std::pow(1076.0,2))*(y - std::pow(800.0,2))/y/4.0;                                 
5787  q3 = std::pow((std::sqrt(q2)),3);                                                 
5788  f3max = q3/(q3 + std::pow(180.0,3));                                     
5789  y = std::pow(x,2);
5790  q2 = (y - std::pow(1076.0,2))*(y - std::pow(800.0,2))/y/4.0;                                 
5791  q3 = std::pow((std::sqrt(q2)),3);                                                 
5792  f3 = q3/(q3 + std::pow(180.0,3));
5793
5794  standardRandom(&rndm, &(hazard->igraine[10]));
5795  if (rndm > (f3/f3max)) {
5796    goto collis101;
5797  }                         
5798  xmdel = x;
5799
5800 collis103:
5801  pin = pnorm;
5802  pnorm = pcm(ecm,xm,xmdel);
5803  if (pnorm <= 0) {
5804    pnorm = 0.000001;
5805  }
5806  index = 0;
5807  index2 = 0;
5808
5809  standardRandom(&rndm, &(hazard->igraine[3]));
5810  if (rndm < 0.5) {
5811    index = 1;
5812  }
5813 
5814  if (iso == 0) {
5815    standardRandom(&rndm, &(hazard->igraine[4]));
5816    if (rndm < 0.5) {
5817      index2 = 1;
5818    } 
5819  }
5820
5821  standardRandom(&rndm, &(hazard->igraine[5]));
5822  x = 0.001*0.5*ecm*std::sqrt(std::pow(ecm,2) - 4.0*xm2)/xm;
5823  if(x < 1.4) {
5824    b = (5.287/(1.0 + std::exp((1.3 - x)/0.05)))*1.e-6;
5825  }
5826  else {
5827    b = (4.65 + 0.706*(x - 1.4))*1.e-6;
5828  }
5829
5830  xkh = 2.0*b*pin*pnorm;
5831  ctet=1.0 + std::log(1.0 - rndm*(1.0 - std::exp(-2.0*xkh)))/xkh;
5832  if(std::fabs(ctet) > 1.0) {
5833    ctet = sign(1.0,ctet);
5834  }
5835 
5836  stet = std::sqrt(1.0 - std::pow(ctet,2));
5837  standardRandom(&rndm, &(hazard->igraine[6]));
5838  fi = 6.2832*rndm;
5839  cfi = std::cos(fi);
5840  sfi = std::sin(fi);
5841
5842  // delta production: correction of the angular distribution 02/09/02
5843  xx = p1*p1 + p2*p2;
5844  zz = p3*p3;
5845  if(xx >= (zz*1.0e-8)) {
5846    yn = std::sqrt(xx);
5847    zn = yn*pin;
5848    ez[0] = p1/pin; // ez(1) -> ez[0] and so on...
5849    ez[1] = p2/pin;
5850    ez[2] = p3/pin;
5851    ex[0] = p2/yn;
5852    ex[1] = -p1/yn;
5853    ex[2] = 0.0;
5854    ey[0] = p1*p3/zn;
5855    ey[1] = p2*p3/zn;
5856    ey[2] = -xx/zn;
5857    xp1 = (ex[0]*cfi*stet + ey[0]*sfi*stet + ez[0]*ctet)*pnorm;
5858    xp2 = (ex[1]*cfi*stet + ey[1]*sfi*stet + ez[1]*ctet)*pnorm;
5859    xp3 = (ex[2]*cfi*stet + ey[2]*sfi*stet + ez[2]*ctet)*pnorm;
5860  }
5861  else {
5862    xp1 = pnorm*stet*cfi;
5863    xp2 = pnorm*stet*sfi;
5864    xp3 = pnorm*ctet;
5865  }
5866  // end of correction angular distribution of delta production
5867
5868  e3 = std::sqrt(xp1*xp1 + xp2*xp2 + xp3*xp3 + xm*xm);
5869  if(k4 != 0) {
5870    goto collis161;
5871  }
5872 
5873  // decay of the delta particle (k4=0)
5874  np = 1;
5875  ip = 0;
5876  qq[0] = xp1; //qq(1) -> qq[0]
5877  qq[1] = xp2;
5878  qq[2] = xp3;
5879  qq4 = std::sqrt(xp1*xp1 + xp2*xp2 + xp3*xp3 + xmdel*xmdel);
5880  heli = std::pow(ctet,2);
5881
5882  if(verboseLevel > 3) {
5883    G4cout <<"Caling decay2 from collis" << G4endl;
5884  }
5885  decay2(&qq[0],&qq[1],&qq[2],&qq4,&q1,&q2,&q3,&q4,&xmdel,&xm,&xpi,&heli);
5886
5887  if(index != 0) {
5888    p1 = qq[0]; //qq(1) -> qq[0] and so on...
5889    p2 = qq[1];
5890    p3 = qq[2];
5891    pout11 = -xp1;
5892    pout12 = -xp2;
5893    pout13 = -xp3;
5894    eout1 = e3;
5895  }
5896  else {
5897    pout11 = qq[0]; //qq(1) -> qq[0] and so on...
5898    pout12 = qq[1];
5899    pout13 = qq[2];
5900    eout1 = e1;
5901    p1 = -xp1;
5902    p2 = -xp2;
5903    p3 = -xp3;
5904    e1 = e3;
5905  }
5906  debugOutput = am(p1,p2,p3,e1);
5907
5908  if (iso == 0) {
5909    goto collis150;
5910  }
5911  if (rndm > 0.333333) {
5912    debugOutput = am(p1,p2,p3,e1);
5913    goto exitRoutine;
5914  }
5915
5916  is1 = -is1;
5917  ip = -2*is1;
5918
5919 collis150:
5920  if (index == 1) {
5921    debugOutput = am(p1,p2,p3,e1);
5922    goto exitRoutine;
5923  }
5924  if (rndm < 0.5) {
5925    goto collis152;
5926  }
5927  is1 = 1;
5928  is2 = 1;
5929  ip = -2;
5930  debugOutput = am(p1,p2,p3,e1);
5931  goto exitRoutine;
5932
5933 collis152: 
5934  is1 = -1;
5935  is2 = -1;
5936  ip = 2;
5937  debugOutput = am(p1,p2,p3,e1);
5938  goto exitRoutine;
5939
5940 collis160:
5941  pout11 = -p1;
5942  pout12 = -p2;
5943  pout13 = -p3;
5944  debugOutput = am(p1,p2,p3,e1);
5945  goto exitRoutine;
5946
5947  // long-lived delta
5948 collis161:
5949  if(index != 1) {
5950    p1=xp1;
5951    p2=xp2;
5952    p3=xp3;
5953    eout1=e3;
5954    e1=ecm-eout1;
5955    m1=1;
5956  }
5957  else {
5958    p1=-xp1;
5959    p2=-xp2;
5960    p3=-xp3;
5961    eout1=e3;
5962    e1=ecm-eout1;
5963    m1=1;
5964  }
5965  debugOutput = am(p1,p2,p3,e1);
5966
5967  // symmetrization of charges in pn -> n delta
5968  // the test on "index" above symetrizes the excitation of one
5969  // of the nucleons with respect to the delta excitation
5970  // (see note 16/10/97)
5971  if (iso == 0) {
5972   if (index2 == 1) {
5973     isi = is1;
5974     is1 = is2;
5975     is2 = isi;
5976   }
5977   goto collis160;
5978  }
5979
5980  bl9->hel[bl9->l1] = std::pow(ctet,2);
5981  standardRandom(&rndm, &(hazard->igraine[7]));
5982  if (rndm < 0.25) {
5983    goto collis160;
5984  }
5985
5986  is1=3*is1*m1-(1-m1)*is1;
5987  is2=3*is2*m2-(1-m2)*is2;
5988  goto collis160;
5989
5990  // recombination process
5991 collis170: 
5992  pnorm = pcm(ecm,xm,xm);
5993  standardRandom(&rndm, &(hazard->igraine[11]));
5994  ctet = -1.0 + 2.0*rndm;
5995  if(std::fabs(ctet) > 1.0) {
5996    ctet = sign(1.0,ctet);
5997  }
5998  stet = std::sqrt(1.0 - ctet*ctet);
5999  standardRandom(&rndm, &(hazard->igraine[12]));
6000  fi = 6.2832*rndm;
6001  cfi = std::cos(fi);
6002  sfi = std::sin(fi);
6003  p1 = pnorm*stet*cfi;
6004  p2 = pnorm*stet*sfi;
6005  p3 = pnorm*ctet;
6006  m1 = 0;
6007  m2 = 0;
6008  e1 = std::sqrt(p1*p1 + p2*p2 + p3*p3 + xm*xm);
6009  eout1 = ecm - e1;
6010  debugOutput = am(p1,p2,p3,e1);
6011
6012  if (iso == 0) {
6013    goto collis160;
6014  }
6015  is1=iso/2;
6016  is2=iso/2;
6017  goto collis160;
6018 
6019 exitRoutine:
6020  debugOutput = am(p1,p2,p3,e1);
6021  (*p1_p) = p1;// Was pq
6022  (*p2_p) = p2;
6023  (*p3_p) = p3;
6024
6025  (*e1_p) = e1;
6026
6027  debugOutput = am(pout11,pout12,pout13,eout1);
6028  (*pout11_p) = pout11;
6029  (*pout12_p) = pout12;
6030  (*pout13_p) = pout13;
6031  (*eout1_p) = eout1;
6032
6033  (*q1_p) = q1;
6034  (*q2_p) = q2;
6035  (*q3_p) = q3;
6036  (*q4_p) = q4;
6037
6038  (*np_p) = np;
6039  (*ip_p) = np;
6040
6041  (*k2_p) = k2;
6042  (*k3_p) = k2;
6043  (*k4_p) = k4;
6044  (*k5_p) = k5;
6045
6046  (*m1_p) = m1;
6047  (*m2_p) = m2;
6048
6049  (*is1_p) = is1;
6050  (*is2_p) = is2;
6051}
6052
6053void G4Incl::decay2(G4double *p1_p, G4double *p2_p, G4double *p3_p, G4double *wp_p, G4double *q1_p, 
6054                    G4double *q2_p, G4double *q3_p, G4double *wq_p, G4double *xi_p, G4double *x1_p, G4double *x2_p, 
6055                    G4double *hel_p)
6056{           
6057  // This routine describes the anisotropic decay of a particle of mass
6058  // xi into 2 particles of masses x1,x2                             
6059  // the anisotropy is supposed to follow a 1+3*hel*(std::cos(theta))**2
6060  // law with respect to the direction of the incoming particle
6061  // in the input, p1,p2,p3 is the momentum of particle xi
6062  // in the output, p1,p2,p3 is the momentum of particle x1 , while
6063  // q1,q2,q3 is the momentum of particle x2
6064
6065  // Temporary variables for input/output data:
6066
6067  G4double p1 = (*p1_p);
6068  G4double p2 = (*p2_p);
6069  G4double p3 = (*p3_p);
6070
6071  G4double q1 = (*q1_p);
6072  G4double q2 = (*q2_p);
6073  G4double q3 = (*q3_p);
6074
6075  G4double wp = (*wp_p);
6076  G4double wq = (*wq_p);
6077
6078  G4double xi = (*xi_p);
6079  G4double x1 = (*x1_p);
6080  G4double x2 = (*x2_p);
6081  G4double hel = (*hel_p);
6082
6083  G4double rndm = 0.0;
6084
6085  G4double xe = wp;
6086  G4double b1 = p1/xe;
6087  G4double b2 = p2/xe;
6088  G4double b3 = p3/xe;                                                         
6089  // PK: NaN workaround
6090  // if(((std::pow(xi,2)-std::pow(x1+x2,2))*(std::pow(xi,2)-std::pow(x1-x2,2))) < 0) {
6091  //   xi = xi+x2+100.0;
6092  // }
6093  // PK
6094  G4double xq = pcm(xi,x1,x2);                                                 
6095  G4double ctet = 0.0, stet = 0.0;
6096
6097  G4double fi = 0.0, cfi = 0.0, sfi = 0.0;
6098  G4double sal = 0.0, cal = 0.0;
6099  G4double t1 = 0.0, t2 = 0.0;
6100  G4double w1 = 0.0;
6101  G4double beta = 0.0;
6102
6103  if(verboseLevel > 3) {
6104    G4cout <<"Delta decay in progress: " << G4endl;
6105    G4cout <<"Starting values: " << G4endl;
6106    G4cout <<"p1 = " << p1 << " p2 = " << p2 << " p3 = " << p3 << " wp = " << wp << G4endl;
6107    G4cout <<"q1 = " << q1 << " q2 = " << q2 << " q3 = " << q3 << " wq = " << wq << G4endl;
6108  }
6109
6110  do {
6111    standardRandom(&rndm, &(hazard->igraine[7]));
6112    ctet = -1.0 + 2.0*rndm;
6113    if(std::fabs(ctet) > 1.0) {
6114      ctet = sign(1.0,ctet);
6115    }
6116    stet = std::sqrt(1.0 - std::pow(ctet,2));
6117    standardRandom(&rndm, &(hazard->igraine[9]));
6118  } while(rndm > ((1.0 + 3.0*hel*std::pow(ctet,2))/(1.0 + 3.0*hel)));
6119 
6120  standardRandom(&rndm, &(hazard->igraine[8]));
6121  fi = 6.2832*rndm;
6122  cfi = std::cos(fi);
6123  sfi = std::sin(fi);
6124  beta = std::sqrt(b1*b1+b2*b2+b3*b3);
6125
6126  sal = std::sqrt(std::pow(b1,2) + std::pow(b2,2))/beta;
6127  cal = b3/beta;
6128
6129  if((beta >= 1.0e-10) || (sal >= 1.0e-6)) {
6130    t1 = ctet + cal*stet*sfi/sal;
6131    t2 = stet/sal;                                                       
6132    q1 = xq*(b1*t1 + b2*t2*cfi)/beta;
6133    q2 = xq*(b2*t1 - b1*t2*cfi)/beta;
6134    q3 = xq*(b3*t1/beta - t2*sfi);
6135  }
6136  else {
6137    q1 = xq*stet*cfi;                                                   
6138    q2 = xq*stet*sfi;                                                   
6139    q3 = xq*ctet;
6140  }
6141 
6142  hel = 0.0;                                                       
6143  w1 = q1*q1 + q2*q2 + q3*q3;
6144  wq = std::sqrt(w1 + x2*x2);
6145  p1 = -q1;
6146  p2 = -q2;
6147  p3 = -q3;
6148  wp = std::sqrt(w1+x1*x1);
6149  loren(&q1, &q2, &q3, &b1, &b2, &b3, &wq);
6150  loren(&p1, &p2, &p3, &b1, &b2, &b3, &wp);
6151
6152  // Return calculated values:
6153  (*p1_p) = p1;
6154  (*p2_p) = p2;
6155  (*p3_p) = p3;
6156
6157  (*q1_p) = q1;
6158  (*q2_p) = q2;
6159  (*q3_p) = q3;
6160
6161  (*wp_p) = wp;
6162  (*wq_p) = wq;
6163
6164  (*xi_p) = xi;
6165  (*x1_p) = x1;
6166  (*x2_p) = x2;
6167  (*hel_p) = hel;
6168}
6169
6170void G4Incl::time(G4int i, G4int j)
6171{
6172  // time
6173  G4double t[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
6174
6175  t[0] = bl1->p1[i]/bl1->eps[i] - bl1->p1[j]/bl1->eps[j]; // t(1)->t[0]
6176  t[1] = bl1->p2[i]/bl1->eps[i] - bl1->p2[j]/bl1->eps[j]; // t(2)->t[1] and so on ...
6177  t[2] = bl1->p3[i]/bl1->eps[i] - bl1->p3[j]/bl1->eps[j]; 
6178  t[3] = bl3->x1[i] - bl3->x1[j];
6179  t[4] = bl3->x2[i] - bl3->x2[j];
6180  t[5] = bl3->x3[i] - bl3->x3[j];
6181
6182  t[6] = t[0]*t[3] + t[1]*t[4] + t[2]*t[5];
6183  t[9] = t[0]*t[0] + t[1]*t[1] + t[2]*t[2];
6184
6185  if(t[9] <= 1.0e-10) {
6186    bl1->ta = 100000;
6187  }
6188  else {       
6189    bl1->ta = -1.0*t[6]/t[9];
6190  }
6191
6192  bl3->rab2 = t[3]*t[3] + t[4]*t[4] + t[5]*t[5] + bl1->ta*t[6];
6193}
6194
6195void G4Incl::newt(G4int l1, G4int l2)
6196{
6197  G4int ig = 0, id = 0, kg = 0, kd = 0;
6198  G4int iy = 0, ix = 0;
6199  G4double E = 0.0;
6200
6201  G4int ia = bl3->ia1 + bl3->ia2;
6202  for(G4int i = 1; i <= ia; i++) { // do 52 i=1,ia
6203    if (bl5->nesc[i] != 0) {
6204      continue;
6205    }
6206    //    if (i-l2) 53,52,54
6207    if((i-l2) < 0) {
6208      goto newt53;
6209    }
6210    if((i-l2) == 0) {
6211      continue;
6212    }
6213    if((i-l2) > 0) {
6214      goto newt54;
6215    }
6216  newt53: 
6217    ig=l2;
6218    id=i;
6219    kg=l1;
6220    kd=i;
6221    goto newt55;
6222  newt54:
6223    //      if (i-l1) 56,52,57
6224    if((i-l1) == 0) {
6225      continue;
6226    }
6227    if((i-l1) < 0) {
6228      goto newt56;
6229    }
6230    if((i-l1) > 0) {
6231      goto newt57;
6232    }
6233  newt56:
6234    kg=l1;
6235    kd=i; 
6236    goto newt58;
6237  newt57:
6238    kg=i;
6239    kd=l1;
6240  newt58:
6241    ig=i;
6242    id=l2;
6243  newt55:
6244    //  call time(ig,id)
6245    time(ig, id);
6246    if (bl1->ta < 0.0) {
6247      goto newt50;
6248    }
6249    if(bl1->ta > bl4->tmax5) {
6250      goto newt50;
6251    }
6252    if (bl1->ta < bl5->tlg[l1]) { // tlg(12)->tlg[11]
6253      goto newt50;
6254    }
6255    if ((bl1->ind1[ig]+bl1->ind1[id]) > 0) {
6256      goto newt60;
6257    }
6258
6259    E=am(bl1->p1[ig]+bl1->p1[id],bl1->p2[ig]+bl1->p2[id],bl1->p3[ig]+bl1->p3[id],bl1->eps[ig]+bl1->eps[id]);
6260    if (E < 1925.0) {
6261      goto newt50;
6262    }
6263    iy=bl1->ind1[ig]+bl1->ind1[id];
6264    if (iy != 1) {
6265      goto newt61;
6266    }
6267    ix=ig*(bl1->ind1[ig])+id*(bl1->ind1[id]);
6268    bl6->xx10=am(bl1->p1[ix],bl1->p2[ix],bl1->p3[ix],bl1->eps[ix]);
6269    bl6->isa=bl1->ind2[ix];
6270  newt61:
6271    if ((31.*(bl3->rab2)) > totalCrossSection(E,iy,bl1->ind2[ig]+bl1->ind2[id])) {
6272      goto newt50;
6273    }
6274  newt60: // continue
6275    bl2->k=bl2->k+1;
6276    bl2->crois[bl2->k]=bl1->ta;
6277    bl2->ind[bl2->k]=ig;
6278    bl2->jnd[bl2->k]=id;
6279  newt50:
6280    time(kg,kd);
6281    if (bl1->ta < 0.) {
6282      continue;
6283    }
6284    if(bl1->ta > bl4->tmax5) {
6285      continue;
6286    }
6287    if (bl1->ta < bl5->tlg[10]) { //tlg(11)->tlg[10]
6288      continue;
6289    }
6290    if ((bl1->ind1[kg]+bl1->ind1[kd]) > 0) {
6291      goto newt62;
6292    }
6293    E=am(bl1->p1[kg]+bl1->p1[kd],bl1->p2[kg]+bl1->p2[kd],bl1->p3[kg]+bl1->p3[kd],bl1->eps[kg]+bl1->eps[kd]);
6294    if (E < 1925.) {
6295      continue;
6296    }
6297    iy=bl1->ind1[kg]+bl1->ind1[kd];
6298    if (iy != 1) {
6299      goto newt63;
6300    }
6301    ix=kg*(bl1->ind1[kg])+kd*(bl1->ind1[kd]);
6302    bl6->xx10=am(bl1->p1[ix],bl1->p2[ix],bl1->p3[ix],bl1->eps[ix]);
6303    bl6->isa=bl1->ind2[ix];
6304  newt63: 
6305    if ((31.*(bl3->rab2)) > totalCrossSection(E,iy,bl1->ind2[kg]+bl1->ind2[kd])) {
6306      continue;
6307    }
6308  newt62:
6309    bl2->k=bl2->k+1;
6310    bl2->crois[bl2->k]=bl1->ta;
6311    bl2->ind[bl2->k]=kg;
6312    bl2->jnd[bl2->k]=kd;
6313  }
6314}
6315
6316void G4Incl::new1(G4int l1)
6317{
6318  G4int ia = 0, iy = 0, ix = 0;
6319  G4double E = 0.0;
6320
6321  ia=bl3->ia1+bl3->ia2;
6322  for(G4int i = 1; i <= ia; i++) {
6323    if (bl5->nesc[i] != 0) {
6324      continue;
6325    }
6326    //if(i-l1) 53,52,54
6327    if((i-l1) < 0) {
6328      goto new153;
6329    }
6330    if((i-l1) == 0) {
6331      continue;
6332    }
6333    if((i-l1) > 0) {
6334      goto new154;
6335    }
6336  new153: 
6337    time(i, l1);
6338    if(bl1->ta < 0.0) {
6339      continue;
6340    }
6341    if(bl1->ta > bl4->tmax5) {
6342      continue;
6343    }
6344    if (bl1->ind1[i]+bl1->ind1[l1] > 0) {
6345      goto new160;
6346    }
6347    E=am(bl1->p1[i]+bl1->p1[l1],bl1->p2[i]+bl1->p2[l1],bl1->p3[i]+bl1->p3[l1],bl1->eps[i]+bl1->eps[l1]);
6348    if (E < 1925.0) {
6349      continue;
6350    }
6351    iy=bl1->ind1[i]+bl1->ind1[l1];
6352    if (iy != 1) {
6353      goto new161;
6354    }
6355    ix=i*(bl1->ind1[i])+l1*(bl1->ind1[l1]);
6356    bl6->xx10=am(bl1->p1[ix],bl1->p2[ix],bl1->p3[ix],bl1->eps[ix]);
6357    bl6->isa=bl1->ind2[ix];
6358  new161: 
6359    if ((31.*(bl3->rab2)) > totalCrossSection(E ,iy,bl1->ind2[i]+bl1->ind2[l1])) {
6360      continue;
6361    }
6362  new160: //continue
6363    bl2->k=bl2->k+1;
6364    bl2->crois[bl2->k]=bl1->ta;
6365    bl2->ind[bl2->k]=l1;
6366    bl2->jnd[bl2->k]=i;
6367    continue;
6368  new154:
6369    time(i, l1);
6370    if(bl1->ta < 0.) {
6371      continue;
6372    }
6373    if(bl1->ta > bl4->tmax5) {
6374      continue;
6375    }
6376    if ((bl1->ind1[i]+bl1->ind1[l1]) > 0) {
6377      goto new170;
6378    }
6379    E=am(bl1->p1[i]+bl1->p1[l1],bl1->p2[i]+bl1->p2[l1],bl1->p3[i]+bl1->p3[l1],bl1->eps[i]+bl1->eps[l1]);
6380    if (E < 1925.0) {
6381      continue;
6382    }
6383    iy=bl1->ind1[i]+bl1->ind1[l1];
6384    if (iy != 1) {
6385      goto new171;
6386    }
6387    ix=i*(bl1->ind1[i])+l1*(bl1->ind1[l1]);
6388    bl6->xx10=am(bl1->p1[ix],bl1->p2[ix],bl1->p3[ix],bl1->eps[ix]);
6389    bl6->isa=bl1->ind2[ix];
6390  new171: 
6391    if ((31.0*(bl3->rab2)) > totalCrossSection(E,iy,bl1->ind2[i]+bl1->ind2[l1])) {
6392      continue;
6393    }
6394  new170: 
6395    bl2->k=bl2->k+1;
6396    bl2->crois[bl2->k]=bl1->ta;
6397    bl2->ind[bl2->k]=i;
6398    bl2->jnd[bl2->k]=l1;
6399  }
6400  //  std::ofstream newout("new1Dump.out");
6401  //  dumpBl2(newout);
6402  //  dumpBl5(newout);
6403  //  newout.close();
6404  //  exit(0);
6405}
6406
6407void G4Incl::new2(G4double y1, G4double y2, G4double y3, G4double q1, G4double q2, G4double q3, 
6408                  G4double q4, G4int npion, G4int l1)
6409{
6410  G4double t[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
6411
6412  G4int ia = bl3->ia1 + bl3->ia2;
6413  for(G4int i = 1; i <= ia; i++) {
6414    if (bl5->nesc[i] != 0) {
6415      continue;
6416    }
6417    if(i == l1) {
6418      continue;
6419    }
6420    if(bl1->ind1[i] == 1) {
6421      continue;
6422    }
6423
6424    t[0] = bl1->p1[i]/bl1->eps[i] - q1/q4;
6425    t[1] = bl1->p2[i]/bl1->eps[i] - q2/q4;
6426    t[2] = bl1->p3[i]/bl1->eps[i] - q3/q4;
6427    t[3] = bl3->x1[i] - y1;
6428    t[4] = bl3->x2[i] - y2;
6429    t[5] = bl3->x3[i] - y3;
6430    t[6] = t[0]*t[3] + t[1]*t[4] + t[2]*t[5];
6431
6432    if(t[6] > 0.0) {
6433      continue;
6434    }
6435
6436    t[9] = t[0]*t[0] + t[1]*t[1] + t[2]*t[2];
6437    bl1->ta = -1 * t[6]/t[9];
6438    if(bl1->ta > bl4->tmax5) {
6439      continue;
6440    }
6441    G4double xx2 = t[3]*t[3] + t[4]*t[4] + t[5]*t[5] + (bl1->ta)*t[6];
6442    G4double E = std::sqrt(std::pow((bl1->eps[i]+q4),2) - std::pow((bl1->p1[i]+q1),2) - std::pow((bl1->p2[i]+q2),2) - std::pow((bl1->p3[i]+q3),2));
6443    if ((31.0*xx2) > pionNucleonCrossSection(E)) {
6444      continue;
6445    }
6446    bl2->k=bl2->k+1;
6447    bl2->crois[bl2->k]=bl1->ta;
6448    bl2->ind[bl2->k]=ia+npion;
6449    bl2->jnd[bl2->k]=i;
6450  }
6451}
6452
6453void G4Incl::new3(G4double y1, G4double y2, G4double y3, G4double q1, G4double q2, G4double q3, 
6454                  G4double q4, G4int npion, G4int l1)
6455{
6456  G4double t[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
6457  G4double E = 0.0, xx2 = 0.0;
6458  G4int ia = 0;
6459
6460  if(bl5->nesc[l1] > 0) {
6461    return;
6462  }
6463
6464  t[0] = bl1->p1[l1]/bl1->eps[l1] - q1/q4;
6465  t[1] = bl1->p2[l1]/bl1->eps[l1] - q2/q4;
6466  t[2] = bl1->p3[l1]/bl1->eps[l1] - q3/q4;
6467  t[3] = bl3->x1[l1] - y1;
6468  t[4] = bl3->x2[l1] - y2;
6469  t[5] = bl3->x3[l1] - y3;
6470  t[6] = t[0]*t[3] + t[1]*t[4] + t[2]*t[5];
6471
6472  if(t[6] > 0.0) {
6473    return;
6474  }
6475
6476  t[9] = t[0]*t[0] + t[1]*t[1] + t[2]*t[2];
6477  bl1->ta = -1 * t[6]/t[9];
6478  if(bl1->ta > bl4->tmax5) {
6479    return;
6480  }
6481  if (bl1->ta < bl5->tlg[l1]) {
6482    return;
6483  }
6484  xx2 = t[3]*t[3] + t[4]*t[4] + t[5]*t[5] + (bl1->ta)*t[6];
6485  E = std::sqrt(std::pow((bl1->eps[l1]+q4),2) - std::pow((bl1->p1[l1]+q1),2) - std::pow((bl1->p2[l1]+q2),2) - std::pow((bl1->p3[l1]+q3),2));
6486  if ((31.0*xx2) > pionNucleonCrossSection(E)) {
6487    return;
6488  }
6489 
6490  bl2->k = bl2->k + 1;
6491  bl2->crois[bl2->k] = bl1->ta;
6492  ia = bl3->ia1+bl3->ia2;
6493  bl2->ind[bl2->k] = ia + npion;
6494  bl2->jnd[bl2->k] = l1;
6495}
6496
6497void G4Incl::loren(G4double *q1, G4double *q2, G4double *q3, G4double *b1, G4double *b2, G4double *b3, G4double *E)
6498{
6499  // Transforms momentum q and energy E from a frame moving with
6500  // velocity beta
6501
6502  G4double bb2 = (*b1) * (*b1) + (*b2) * (*b2) + (*b3) * (*b3);
6503  G4double bq = (*b1) * (*q1) + (*b2) * (*q2) + (*b3) * (*q3);
6504  G4double gam2 = 1.0/(1.0 - bb2);
6505  G4double gam = std::sqrt(gam2);
6506  G4double c = gam2/(gam + 1.0);
6507  G4double g = c * bq + gam*(*E);
6508  (*E) = gam * ((*E) + bq);
6509  (*q1) = (*q1) + (*b1) * g;
6510  (*q2) = (*q2) + (*b2) * g; 
6511  (*q3) = (*q3) + (*b3) * g;
6512}
6513
6514G4double G4Incl::pauliBlocking(G4int l, G4double xr, G4double pr)
6515{
6516  //   G4int l = (*l_p);
6517  //   G4double xr = (*xr_p);
6518  //   G4double pr = (*pr_p);
6519  //   G4double f = (*f_p);
6520
6521  // This subroutine calculates the occupation in phase space around
6522  // nucleon l , by counting the particles in a volume around l the
6523  // volume is the product of a sphere of radius xr in r-space by a
6524  // sphere of radius pr in momentum space average is taken on the spin
6525  // only
6526
6527  //   3756           common/bl1/p1(300),p2(300),p3(300),eps(300),ind1(300),ind2(300),tap-n24950
6528  //   3757           common/bl3/r1,r2,x1(300),x2(300),x3(300),ia1,ia2,rab2             p-n24960
6529  //   3758           common/bl5/tlg(300),nesc(300)                                     p-n24970
6530  //   3759           common/saxw/ xx(30,500),yy(30,500),ss(30,500),nbpG4inter,imat
6531  //   3760           common/ws/r0,adif,rmaxws,drws,nosurf,xfoisa,npaulstr,bmax
6532
6533  G4double pmod = 0.0, pr2 = 0.0;
6534  G4double xr2 = 0.0, rdeq = 0.0, dx2 = 0.0, dp2 = 0.0;
6535  G4double rs = 0.0, vol = 0.0;
6536  G4int nl = 0;
6537  G4int ia = 0;
6538
6539  if (ws->npaulstr == 2) {
6540    return 0.0;
6541  }
6542
6543  if (ws->npaulstr == 1) {
6544    // pauli strict
6545    pmod = std::sqrt(std::pow(bl1->p1[l],2) + std::pow(bl1->p2[l],2) + std::pow(bl1->p3[l],2));
6546    if (pmod < 270.0) {
6547      return 1.0;
6548    } else {
6549      return 0.0;
6550    }
6551  } else {
6552    // Statistic Pauli blocking
6553    xr2 = xr*xr;
6554    pr2 = pr*pr;
6555    vol = std::pow((40.0*3.1415926/3.0),2) * (std::pow((xr*pr)/(2.0*3.1415926*197.13),3));
6556    rs = std::sqrt(bl3->x1[l]*bl3->x1[l] + bl3->x2[l]*bl3->x2[l] + bl3->x3[l]*bl3->x3[l]);
6557    if (ws->nosurf <= 0) {
6558      // modifs a.b.: r2 -> rmaxws pour la densite en w.s.
6559      rdeq = ws->rmaxws;
6560    } else {
6561      rdeq = ws->r0;
6562    }
6563
6564    if ((rs - xr) <= rdeq) {
6565      if ((rs + xr) > rdeq) {
6566        vol = vol*0.5*(rdeq-rs+xr)/xr;
6567      }
6568
6569      ia = bl3->ia1 + bl3->ia2;
6570      nl = 0;
6571
6572      for(G4int i = 1; i <= ia; i++) {
6573        dx2 = std::pow((bl3->x1[l]-bl3->x1[i]),2) + std::pow((bl3->x2[l]-bl3->x2[i]),2) + std::pow((bl3->x3[l]-bl3->x3[i]),2);
6574        dp2 = std::pow((bl1->p1[l]-bl1->p1[i]),2) + std::pow((bl1->p2[l]-bl1->p2[i]),2) + std::pow((bl1->p3[l]-bl1->p3[i]),2);
6575     
6576        if((bl5->nesc[i] > 0) || (bl1->ind1[i] > 0) || (bl1->ind2[i] != bl1->ind2[l]) || (dx2 > xr2) || (dp2 > pr2)) {
6577          if(((nl - 1)/vol/2.0) > 1.0) {
6578            return 1.0;
6579          } else {
6580            return ((nl - 1)/vol/2.0);
6581          }
6582        }
6583        nl = nl + 1;
6584      }
6585    } else {
6586      return 0.0;
6587    }
6588  }
6589
6590  return 0.0; // The algorithm is not supposed to reach this point.
6591}
6592
6593G4double G4Incl::lowEnergy(G4double E, G4double m, G4double i)
6594{
6595  // fit by j.vandermeulen
6596  // low enrgy fit of j.c., d. l'hote, j. vdm, nim b111(1996)215
6597  // i = 2,0,-2  for pp,pn,nn
6598  // m = 0,1,2 for nucleon-nucleon,nucleon-delta,delta,delta
6599
6600  G4double scale = 1.0;
6601  G4double plab = E*std::sqrt(E*E-3.52e6)/1876.6;
6602  G4double p1 = 0.001*plab;
6603  G4double alp = 0.0;
6604
6605  if(plab > 2000.0) {
6606    // goto sel13;
6607    // sel13:
6608    return ((77.0/(p1 + 1.5))*scale);
6609  }
6610
6611  if((m-1) < 0) {
6612    if (i == 0) {
6613      if (plab < 800.0) {
6614        if (plab < 450.0) {
6615          alp = std::log(p1);
6616          return(6.3555*std::exp(-3.2481*alp - 0.377*alp*alp));
6617        }
6618        else {
6619          return((33.0 + 196.0*std::sqrt(std::fabs(std::pow((p1 - 0.95),5))))*scale);
6620        }
6621      }
6622      else {
6623        return(31.0/std::sqrt(p1)*scale);
6624      }
6625    }
6626  }
6627
6628  if (plab < 800.0) {
6629    if (plab < 440.0) {
6630      return(34.0*std::pow((p1/0.4),(-2.104)));
6631    }
6632    else {
6633      return((23.5 + 1000.*std::pow((p1 - 0.7),4))*scale);
6634    }
6635  }
6636  else if(plab > 2000.0) {
6637    return ((77.0/(p1 + 1.5))*scale);
6638  }
6639  else {
6640    return((1250.0/(50.0 + p1) - 4.0*std::pow((p1 - 1.3),2))*scale);
6641  }
6642}
6643
6644G4double G4Incl::totalCrossSection(G4double E, G4int m, G4int i)
6645{
6646  // total cross-sections
6647  // i=2,0,-2  for pp,pn,nn
6648  // m=0,1,2 for nucleon-nucleon,nucleon-delta,delta,delta
6649
6650  G4double stotResult = 0.0;
6651  G4double sine = 0.0;
6652
6653  if((m-1) < 0) {
6654    sine = deltaProductionCrossSection(E,int(i));
6655  }
6656
6657  if((m-1) == 0) {
6658    sine = srec(E,(bl6->xx10),i,int(bl6->isa));
6659  }
6660
6661  if((m-1) > 0) {
6662    sine = 0.0;
6663  }
6664
6665  stotResult = sine + lowEnergy(E,m,i);
6666  return stotResult;
6667}
6668
6669G4double G4Incl::srec(G4double Ein, G4double d, G4int i, G4int isa)
6670{
6671  G4double E = Ein;
6672  G4double s = 0.0;
6673  G4double x = 0.0, y = 0.0;
6674  G4double srecResult = 0.0;
6675
6676  if (i*i == 16) {
6677    return 0.0;
6678  }
6679
6680  if(E <= (938.3 + d)) {
6681    return 0.0;
6682  } else {
6683    if(E < (938.3 + d + 2.0)) {
6684      E = 938.3 + d + 2.0;
6685    }
6686    s = E*E;
6687    x = (s - 3.523e6)/(s - std::pow((938.3 + d),2));
6688    y = s/(s - std::pow((d - 938.3),2));
6689    srecResult = 0.5*x*y*deltaProductionCrossSection(E, i);
6690    srecResult = srecResult*(32.0 + i*i*(isa*isa - 5))/64.0;
6691    srecResult = srecResult/(1.0 + 0.25*i*i);
6692    srecResult = 3.0*srecResult;  //pi absorption increased also for internal pions (7/3/01)
6693
6694    return srecResult;
6695  }
6696}
6697
6698G4double G4Incl::deltaProductionCrossSection(G4double E, G4int i)
6699{
6700  // delta production cross-sections
6701  // fit by j.vandermeulen
6702  // i = 2,0,-2  for pp,pn,nn
6703
6704//   G4double scali = 1.0;
6705//   G4double plab;
6706//   G4double p1;
6707//   G4double sproResult;
6708
6709//   G4double EE = E - bl8->rathr;
6710
6711//   if(EE*EE-3.53e6 < 0) {
6712//     return 0.0;
6713//   }
6714//   else {
6715//     plab = EE*std::sqrt(EE*EE-3.52e6)/1876.6;
6716//     p1 = 0.001*plab;
6717//     if (plab > 800.0) {
6718//       //goto spro1;
6719//       //  spro1:
6720//       if (i*i == 4) {
6721//      //      goto spro10;
6722//      //spro10:
6723//      if (plab < 2000.0) {
6724//        //    goto spro11;
6725//        //  spro11:
6726//        if (plab < 1500.0) {
6727//          //      goto spro12;
6728//          // spro12:
6729//          sproResult = 23.5 + 24.6/(1.0 + std::exp(-10.0*p1 + 12.0)) - 1250.0/(p1+50.0)+4.0*std::pow((p1-1.3),2);
6730//          return (sproResult*scali);
6731//        }
6732//        else {
6733//          sproResult = 41.0 + 60.0*(p1 - 0.9)*std::exp(-1.2*p1) - 1250.0/(p1+50.0) + 4.*std::pow((p1 - 1.3),2);
6734//          return (sproResult*scali);
6735//        }
6736//      }
6737//      else {
6738//        return ((41.0 + (60.0*p1 - 54.0)*std::exp(-1.2*p1) - 77.0/(p1 + 1.5))*scali);
6739//      }
6740//       }
6741//       else {
6742//      if (plab < 2000.0) {
6743//        //goto spro2;
6744//        //  spro2:
6745//        if (plab < 1000.0) {
6746//          //goto spro3;
6747//          //  spro3:
6748//          return ((33.0 + 196.0*std::sqrt(std::pow(std::fabs(p1 - 0.95),5)) - 31.1/std::sqrt(p1))*scali);
6749//        }
6750//        else {
6751//          return ((24.2 + 8.9*p1 - 31.1/std::sqrt(p1))*scali);
6752//        }
6753//      }
6754//      else {
6755//        return ((42.-77./(p1+1.5))*scali);
6756//      }
6757//       }
6758//     }
6759//     // plab <= 800.0
6760//     else {
6761//       return 0.0;
6762//     }
6763//   }
6764  double scali=1.0;
6765  double plab = 0.0;
6766  double p1 = 0.0;
6767  double sproResult = 0.0;
6768
6769  double EE = E -(bl8->rathr);
6770
6771  if(EE*EE-3.53e6 < 0) {
6772    goto spro22;
6773  }
6774  plab = EE * std::sqrt(EE*EE - 3.52e6)/1876.6;
6775  p1 = 0.001*plab;
6776  if (plab > 800.) {
6777    goto spro1;
6778  }
6779  spro22:
6780  sproResult = 0.0;
6781  return sproResult;
6782
6783  spro1:
6784  if (i*i == 4) {
6785    goto spro10;
6786  }
6787  if (plab < 2000.) {
6788    goto spro2;
6789  }
6790  sproResult=(42.-77./(p1+1.5))*scali;
6791  return sproResult;
6792  spro2: if (plab < 1000.) {
6793    goto spro3;
6794  }
6795  sproResult=(24.2+8.9*p1-31.1/std::sqrt(p1))*scali;
6796  return sproResult;
6797  spro3: sproResult = (33.0 + 196.0*std::sqrt(std::pow(std::fabs(p1 - 0.95),5)) - 31.1/std::sqrt(p1))*scali;
6798  return sproResult;
6799  spro10: if (plab < 2000.) {
6800    goto spro11;
6801  }
6802  sproResult = (41.0 + (60.0*p1 - 54.0)*std::exp(-1.2*p1) - 77.0/(p1 + 1.5))*scali;
6803  return sproResult;
6804  spro11: if (plab < 1500.) {
6805    goto spro12;
6806  }
6807  sproResult = 41.0 + 60.0*(p1 - 0.9)*std::exp(-1.2*p1) - 1250.0/(p1 + 50.0)+4.0*std::pow((p1-1.3),2);
6808  sproResult = sproResult*scali;
6809  return sproResult;
6810 spro12: sproResult=23.5 + 24.6/(1.0 + std::exp(-10.0*p1 + 12.0)) - 1250.0/(p1 + 50.0) + 4.0*std::pow((p1 - 1.3),2);
6811  sproResult=sproResult*scali;
6812  return sproResult;
6813}
6814
6815G4double G4Incl::pionNucleonCrossSection(G4double x)
6816{
6817  //   sigma(pi+ + p) in the (3,3) region
6818  //   new fit by j.vandermeulen + constant value above the (3,3)
6819  //   resonance
6820
6821  G4double y = x*x;
6822  G4double q2 = (y-std::pow(1076.0,2))*(y-std::pow(800.0,2))/y/4.0;
6823  G4double q3 = 0.0, f3 = 0.0;
6824  G4double spn = 0.0;
6825
6826  if(q2 <= 0) {
6827    return 0.0;
6828  } else {
6829    q3 = std::pow((std::sqrt(q2)),3);
6830    f3 = q3/(q3+std::pow(180.0,3));
6831    spn = 326.5/(std::pow(((x - 1215.0 - bl8->ramass)*2.0/110.0),2)+1.0);
6832    spn = spn*(1.0 - 5.0 * (bl8->ramass/1215.0));
6833    return (spn*f3);
6834  }
6835}
6836
6837G4double G4Incl::transmissionProb(G4double E, G4double iz, G4double izn, G4double r, G4double v0)
6838{
6839  // transmission probability for a nucleon of kinetic energy
6840  // E on the edge of the well of depth v0 (nr approximation)
6841  // iz is the isospin of the nucleon,izn the instanteneous charge
6842  // of the nucleus and r is the target radius
6843
6844  G4double x = 0.0;
6845  G4double barr = 0.0;
6846
6847  // We need enough energy to escape from the potential well.
6848  if (E > v0) {
6849    x = std::sqrt(E*(E - v0));
6850    barr = 4.0*x/(E + E - v0 + x + x);
6851    if (iz > 0) {
6852      G4double b = izn*1.44/r;
6853      G4double px = std::sqrt((E - v0)/b);
6854     
6855      if (px < 1.0) {
6856        G4double g = izn/137.03*std::sqrt(2.0*938.3/(E - v0))*(std::acos(px) - px*std::sqrt(1.0 - px*px));
6857        if (g > 35.){
6858          barr=0.0;
6859        } else {
6860          barr = barr*std::exp(-2.0*g);
6861        }
6862        return barr;
6863      } else {
6864        return barr;
6865      }
6866    } else {
6867      return barr;
6868    }
6869  } else {
6870    return barr;
6871  }
6872}
6873
6874G4double G4Incl::ref(G4double x1, G4double x2, G4double x3, G4double p1, G4double p2, G4double p3, G4double E, G4double r2)
6875{
6876  const G4double  pf = 270.339 , pf2 = 73083.4;
6877
6878  G4double ref = 0.0;
6879  G4double t1 = 0.0, t3 = 0.0, t4 = 0.0, t5 = 0.0;
6880 
6881  G4double t2 = p1*p1 + p2*p2 + p3*p3;
6882  G4double p = std::sqrt(t2);
6883  G4double r = r2;
6884  G4double xv = 0.0;
6885  G4double s = 0.0;
6886 
6887  if (ws->nosurf <= 0) {
6888    xv = p/pf;
6889    r = interpolateFunction(xv);
6890    r = r*r;
6891    if (t2 > pf2) {
6892      r = std::pow(ws->rmaxws,2);
6893    }
6894  }
6895
6896  t4 = x1*x1 + x2*x2 + x3*x3;
6897  while(t4 > r) {
6898    s = std::sqrt(r*0.99/t4);
6899    x1 = x1*s;
6900    x2 = x2*s;
6901    x3 = x3*s;
6902    t4 = x1*x1 + x2*x2 + x3*x3;
6903  }
6904 
6905  t1 = x1*p1 + x2*p2 + x3*p3;
6906  t3 = t1/t2;
6907
6908  t5 = t3*t3 + (r - t4)/t2;   
6909  if (t5 > 0) {
6910    ref = (-t3 + std::sqrt(t5))*E;
6911    return ref;
6912  }
6913  else {
6914    ref = 10000.0;
6915    return ref;
6916  }
6917}
6918
6919// void G4Incl::forceAbsor(G4int nopart, G4double iarem, G4double izrem, G4double esrem, G4double erecrem,
6920//                      G4double alrem, G4double berem, G4double garem, G4double jrem)
6921void G4Incl::forceAbsor(G4int *nopart, G4int *iarem, G4int *izrem, G4double *esrem, G4double *erecrem,
6922                        G4double *alrem, G4double *berem, G4double *garem, G4int *jrem)
6923{ 
6924  //  4341        C------------------------------------------------------------------------------
6925  //   4342             SUBROUTINE FORCE_ABSOR(nopart,F,IAREM,IZREM,ESREM,ERECREM,
6926  //   4343            s  ALREM,BEREM,GAREM,JREM)
6927
6928  //   4346             DIMENSION F(15)
6929  //   4347             REAL*4 ia1,iz1
6930  //   4348             
6931  //   4349             COMMON/hazard/ial,IY(19)
6932  //   4350       C Dialogue with INCL for nucleus density and parameters.
6933  //   4351             COMMON/WS/R0,ADIF,RMAXWS,DRWS,NOSURF,XFOISA,NPAULSTR,BMAX
6934  //   4352       C RMS espace R, espace P, Fermi momentum and energy for light gauss nuc.     
6935  //   4353             COMMON/light_gaus_nuc/rms1t(9),pf1t(9),pfln(9),tfln(9),vnuc(9)
6936
6937  G4int itg = 0;
6938  G4double sep = 0.0;
6939  G4double iz1 = 0.0;
6940  G4double del = 0.0;
6941  G4double bmaxt = 0.0;
6942  G4double proba, proba_trans;
6943  G4double alea;
6944
6945  if((*nopart) != -1) {
6946    return;
6947  }
6948
6949  bl3->ia2 = int(std::floor(calincl->f[0] + 0.1)); // f(1) -> f[0]
6950  sep = 6.8309;
6951
6952  if(bl3->ia2 <= 4) {
6953    if(bl3->ia2 == 2) {
6954      itg = 6 - 1;
6955    }
6956    if(bl3->ia2 == 3 && calincl->f[1] == 1) {
6957      itg = 7 - 1;
6958    }
6959    if(bl3->ia2 == 3 && calincl->f[1] == 2) {
6960      itg = 8 - 1;
6961    }
6962    if(bl3->ia2 == 4) {
6963      itg = 9 - 1;
6964    }
6965    sep = light_gaus_nuc->vnuc[itg] - light_gaus_nuc->tfln[itg]; // :::BUG::: Off-by-one!!!
6966  }
6967
6968  if((calincl->f[2] >= 10.0) && (calincl->f[2] <= 100.0)) {
6969    if(calincl->f[6] == 1.0) {
6970      bl3->ia1 = int(1.0);
6971      iz1 = 1.0;
6972      G4double fmpinc = 938.2796;
6973      G4double pbeam2 = calincl->f[2]*(calincl->f[2] + 2.0*fmpinc);
6974      bmaxt = ws->bmax;
6975      proba_trans = coulombTransm(calincl->f[2],bl3->ia1,iz1,calincl->f[0],calincl->f[1]);
6976      proba = forceAbs(1,calincl->f[0],calincl->f[1],calincl->f[2],bmaxt,proba_trans);
6977     
6978      standardRandom(&alea,&(hazard->igraine[4]));
6979      if(alea > proba) {
6980        return;
6981      }
6982
6983      (*iarem) = int(calincl->f[0]) + bl3->ia1;
6984      (*izrem) = int(calincl->f[1]) + int(iz1);
6985     
6986      del = std::sqrt(std::pow(((calincl->f[0] + 1.0)*fmpinc + calincl->f[2]),2) - pbeam2);
6987     
6988      (*erecrem) = pbeam2/((calincl->f[0] + 1.0)*fmpinc+calincl->f[2] + del);
6989
6990      (*esrem) = calincl->f[2] + sep - (*erecrem);
6991
6992      (*alrem) = 0.00001;
6993      (*berem) = 0.0;
6994      (*garem) = 0.99999;
6995      (*jrem) = 0;
6996      (*nopart) = 0;
6997      return;
6998    }
6999    else if((calincl->f[6] == 2) && (calincl->f[2] >= 20.0)) {
7000      bl3->ia1 = int(1.0);
7001      iz1 = 0.0;
7002      G4double fmpinc = 938.2796;
7003      G4double pbeam2 = calincl->f[2]*(calincl->f[2] + 2.0*fmpinc);
7004      bmaxt = ws->bmax;
7005      proba_trans = coulombTransm(calincl->f[2],bl3->ia1,iz1,calincl->f[0],calincl->f[1]);
7006      proba = forceAbs(1,calincl->f[0],calincl->f[1],calincl->f[2],bmaxt,proba_trans);
7007     
7008      standardRandom(&alea,&(hazard->igraine[4]));
7009      if(alea > proba) {
7010        return;
7011      }
7012
7013      (*iarem) = int(calincl->f[0]) + bl3->ia1;
7014      (*izrem) = int(calincl->f[1]) + int(iz1);
7015     
7016      del = std::sqrt(std::pow(((calincl->f[0]+1.)*fmpinc+calincl->f[2]),2)-pbeam2);
7017     
7018      (*erecrem) = pbeam2/((calincl->f[0] + 1.0)*fmpinc + calincl->f[2] + del);
7019
7020      (*esrem) = calincl->f[2] + sep - (*erecrem);
7021
7022      (*alrem) = 0.00001;
7023      (*berem) = 0.0;
7024      (*garem) = 0.99999;
7025      (*jrem) = 0;
7026      (*nopart) = 0;
7027      return;
7028    }
7029  } //      end if
7030}
7031
7032G4double G4Incl::forceAbs(G4double iprojo, G4double at, G4double zt, G4double ep, G4double bmax, G4double pt)
7033{
7034  // Results of xabs2 and sig_reac
7035  G4double sig_exp, sig_incl;
7036  G4double proba;
7037 
7038  G4double ap,zp,A,Z,E; 
7039  A=at;
7040  Z=zt;
7041  E=ep;
7042  double sig_g = 31.41592654*bmax*bmax;
7043  if(iprojo == 1) {
7044    ap = 1.0;
7045    zp = 1.0;
7046  }
7047  else {
7048    ap=1.0;
7049    zp=0.0;
7050  }
7051
7052  sig_exp = xabs2(zp, ap, zt, at, ep);
7053  sig_incl = crossSection(int(iprojo), ep, at);
7054 
7055  proba = (sig_exp-pt*sig_incl)/(pt*(sig_g - sig_incl));
7056  if(proba <= 0.0) {
7057    proba = 0.0;
7058  }
7059  if(proba > 1.0) {
7060    proba = 1.0;
7061  }
7062
7063  return proba;
7064}
7065
7066G4double G4Incl::xabs2(G4double zp, G4double ap, G4double zt, G4double at, G4double ep)
7067{                                         
7068  G4double sig = 0.0;
7069 
7070  G4double Const, xzt, xat, Const1 = 0.0, t1, gcm, bcm, plab, ecmp, ecmt, rela, ecm, rm, bigr, bigb;
7071  G4double xm, x1, sl, phst, ce, term1, delta, beta, twxsec;
7072  G4double xsec;
7073
7074  const G4double dp0 = 0.e0, dp1 = 1.e0, dp2 = 2.e0, dp3 = 3.e0, dph = 0.5e0;
7075  const G4double dp10 = 1.e1, dpth = dp1/dp3, dppi = 3.1415926535898;
7076
7077  // absoprption xsec revised version rkt-97/5 neutron data from
7078  // barashenkov this gives absorption xsec for given zp,ap,zt,at,e
7079  // (mev/nucleon) arguement changed to mev; then e=ep/ap mev/nucleon
7080  // can be used for neutrons also.  this has coulomb as ours
7081
7082  G4double E = ep/ap;
7083
7084  //   nucleon-nucleon inelastc xsec not included here                       
7085  if ((nint(ap*at) == 1) || (nint(zp+zt) == 1)) {                   
7086    return dp0;
7087  }
7088  G4double rp = radius(ap);                                                     
7089  G4double rt = radius(at);                                                     
7090  G4double vp = (dp1 + dpth)*dppi*std::pow(rp,3);                                         
7091  G4double vt = (dp1 + dpth)*dppi*std::pow(rt,3);                                         
7092  G4double density = dph*((ap/vp) + (at/vt));                                     
7093  Const=1.75e0*density/8.824728e-02;                                 
7094
7095  if ((zt < zp) || ((zt == zp) && (at < ap))) {
7096    xzt = zp;                                                         
7097    xat = ap;                                                         
7098    zp = zt;                                                           
7099    ap = at;                                                           
7100    zt = xzt;                                                         
7101    at = xat;                                                         
7102  }
7103
7104  if (nint(ap) == 1) {
7105    Const=2.05;
7106  }                                   
7107  if ((nint(zp) == 2) && (nint(ap) == 4)) {
7108    Const1 = 2.77 - at*8.0e-03 + (at*at)*1.8e-05;                         
7109  }
7110  if (nint(zp) == 3) {
7111    Const=Const/3.0;
7112  }                                 
7113  t1=40.0;                                                         
7114  if (nint(zp) == 0) {
7115    if ((nint(at) >= 11) && (nint(at) < 40)) {
7116      t1=30.0;                 
7117    }
7118    if (nint(zt) == 14) {
7119      t1=35.0;
7120    }                                     
7121    if (nint(zt) == 26) {
7122      t1=30.0;
7123    }                                     
7124  }
7125
7126  gcm = (ap*(dp1 + E/938.0) + at)/(std::pow((std::pow(ap,2) + std::pow(at,2) + dp2*ap*(E + 938.0)*at/938.e0),dph));
7127  bcm = std::sqrt(dp1-dp1/(std::pow(gcm,2)));
7128 
7129  plab = ap*std::sqrt(dp2*938.0*E + E*E);                                   
7130  ecmp = gcm*(E+938.0)*ap - bcm*gcm*plab - ap*938.0;                     
7131  ecmt = gcm*938.0*at - at*938.0;
7132  rela = ecmp + ecmt;                                                   
7133  ecm = rela;                                                         
7134  if (ecm < (0.1*rela)) {
7135    ecm = 0.1*rela;
7136  }                             
7137  rm = (197.32/137.01)*zp*zt/ecm;                                     
7138  bigr = rp + rt + 1.2*(std::pow(ap,dpth) + std::pow(at,dpth))/(std::pow(ecm,dpth));                   
7139
7140  bigb = 1.44*zp*zt/bigr;                                             
7141 
7142  if ((nint(zp) == 1) && (nint(at) > 56)) {
7143    bigb = 0.90*bigb;
7144  }             
7145  if ((nint(ap) > 56) && (nint(zt) == 1)) {
7146    bigb = 0.90*bigb;
7147  }             
7148  if ((nint(ap) == 1) && (nint(at) == 12)) {
7149    bigb = 3.5*bigb;
7150  }               
7151  if (nint(ap) == 1) {
7152    if ((nint(at) <= 16) && (nint(at) >= 13)) {
7153      bigb = (at/7.)*bigb;                                             
7154    }
7155    if (nint(zt) == 12) {
7156      bigb = 1.8*bigb;
7157    }                               
7158    if (nint(zt) == 14) {
7159      bigb = 1.4*bigb;
7160    }                               
7161    if (nint(zt) == 20) {
7162      bigb = 1.3*bigb;
7163    }                               
7164  }
7165  if ((nint(ap) == 1) && (nint(at) < 4)) {
7166    bigb = 21.0*bigb;
7167  }               
7168  if ((nint(ap) < 4) && (nint(at) == 1)) {
7169    bigb = 21.0*bigb;
7170  }               
7171  if ((nint(ap) == 1) && (nint(at) == 4)) {
7172    bigb = 27.0*bigb;
7173  }               
7174  if ((nint(ap) == 4) && (nint(at) == 1)) {
7175    bigb = 27.0*bigb;
7176  }               
7177  if ((nint(zp) == 0) || (nint(zt) == 0)) {
7178    bigb = dp0;
7179  }                         
7180  xsec = dp10*dppi*bigr*bigr*(dp1-bigb/ecm);                                           
7181  xm=1.0;                                                             
7182  if (nint(zp) == 0) {
7183    if (nint(at) < 200) {
7184      x1 = 2.83 - 3.1e-02*at + 1.7e-04*at*at;                             
7185      if (x1 <= 1) {
7186        x1=1.0;
7187      }                                           
7188      sl=dp1;                                                       
7189      if (nint(at) == 12) {
7190        sl=1.6;
7191      }                                   
7192      if (nint(at) < 12) {
7193        sl=0.6;
7194      }                                   
7195      xm = (1 - x1*std::exp(-E/(sl*x1)));                                     
7196      if (E < 20) {
7197        //      cout <<"e,xm= " << e << " " << xm << endl;
7198      }
7199    }                           
7200    else {                                                           
7201      xm = (1-0.3*std::exp(-(E-1)/15))*(1 - std::exp(-(E-0.9)));
7202    }
7203  }
7204  if ((nint(zp) == 2) && (nint(ap) == 4)) {
7205    Const = Const1 - 0.8/(1 + std::exp((250.0-E)/75.0));                     
7206  }
7207  if ((nint(zp) == 1) && (nint(ap) == 1)) {
7208    if (nint(at) > 45) {
7209      t1 = 40.0 + at/dp3;                                               
7210    }
7211    if (nint(at) < 4) {
7212      t1 = 55;                                                         
7213    }
7214    Const = 2.05 - 0.05/(1 + std::exp((250.0-E)/75.0));                     
7215    if (nint(at) < 4) {
7216      Const = 1.7;
7217    }                                   
7218    if (nint(zt) == 12) {
7219      t1=40.0;                                                     
7220      Const=2.05 - dp3/(1.0 + safeExp((E - 20.0)/dp10));                   
7221    }
7222    if (nint(zt) == 14) {
7223      t1 = 40.0;                                                     
7224      Const = 2.05 - 1.75/(1.0 + safeExp((E - 20.0)/dp10));                 
7225    }                                   
7226    if (nint(zt) == 18) {
7227      t1 = 40.0;                                                     
7228      Const = 2.05 - dp2/(1.0 + safeExp((E - 20.0)/dp10));                   
7229    }                 
7230    if (nint(zt) == 20) {
7231      t1 = 40.0;                                                     
7232      Const = 2.05 - dp1/(1.0 + safeExp((E - 40.0)/dp10));                   
7233      Const = Const - 0.25/(1 + std::exp((250.0 - E)/75.0));                 
7234    }
7235    if (nint(zt) >= 35) {
7236      phst = (nint(zt)-35.e0)/260.e0;                                   
7237      Const = Const - phst/(1 + std::exp((250.0 - E)/75.0));                   
7238    }
7239  }
7240
7241  if ((nint(zp) == 0) && (nint(ap) == 1)) {
7242    Const = 2*(0.134457/density);                                     
7243    if ((nint(at) > 140) && (nint(at) <200)) {
7244      Const = Const - 1.5*(at - dp2*zt)/at;                                                       
7245    }
7246    if (nint(at) < 60) {
7247      Const = Const - 1.5*(at - dp2*zt)/at;
7248    }           
7249    if (nint(at) <= 40) {
7250      Const = Const + 0.25/(dp1 + safeExp(-(170.0 - E)/100.0));                                                         
7251    }
7252    if (nint(zt) > 82) {
7253      Const = Const - zt/(at - zt);                     
7254    }
7255    if (nint(zt) >= 82) {
7256      Const = Const - dp2/(1.0 + safeExp((E - 20.0)/20.0));
7257    } 
7258    if ((nint(zt) <= 20) && (nint(zt) >= 10)) {
7259      Const = Const - dp1/(dp1 + safeExp((E - 20.0)/dp10));
7260    }                                               
7261  }
7262 
7263  ce = Const * (1.0 - std::exp(-E/t1)) - 0.292*std::exp(-E / 792) * std::cos(0.229*std::pow(E,0.453));   
7264  term1 = std::pow((at*ap),dpth)/(std::pow(at,dpth) + std::pow(ap,dpth));                           
7265  delta = 1.615*term1 - 0.873*ce;                                     
7266  delta = delta + 0.140*term1/(std::pow(ecm,dpth));                                 
7267  delta = delta + 0.794*(at - dp2*zt)*zp/(at*ap);                       
7268  delta = -delta;                   
7269  beta = 1.0;                                                           
7270  twxsec = dp10*dppi*1.26e0*1.26e0*beta*std::pow((0.873e0*std::pow(ap,dpth) + 0.873e0*std::pow(at,dpth)-delta),2);   
7271  sig = twxsec*(dp1-bigb/ecm)*xm;
7272  if (sig < dp0) {
7273    sig = dp0;
7274  }
7275
7276  return sig;
7277}
7278
7279void G4Incl::standardRandom(G4double *rndm, G4long *seed)
7280{
7281  (*seed) = (*seed); // Avoid warning during compilation.
7282  // Use Geant4 G4UniformRand
7283  //  (*rndm) = G4UniformRand();
7284  (*rndm) = randomGenerator->getRandom();
7285}
7286
7287void G4Incl::gaussianRandom(G4double *rndm)
7288{
7289  // Gaussian random number generator
7290 
7291  G4double tempRandom = 0.0, random = 0.0, randomShuffle = 0.0;
7292 
7293  do {
7294    random = 0.0;
7295   
7296    for(G4int i = 0; i < 12; i++) {
7297      standardRandom(&tempRandom, &(hazard->ial));
7298      random = random + tempRandom;
7299    }
7300
7301    random = random - 6.0;
7302  } while(random*random > 9);
7303
7304  // Shuffle the random seeds
7305  standardRandom(&randomShuffle, &(hazard->igraine[10]));
7306
7307  if(randomShuffle > 0.5) {
7308    standardRandom(&tempRandom, &(hazard->ial));
7309  }
7310
7311  (*rndm) = random;
7312}
7313
7314G4double G4Incl::safeExp(G4double x)
7315{                                               
7316  if (x < -80.0) {
7317    x = -80.0;                                         
7318  }
7319  if (x > 80.0) {
7320    x = 80.0;
7321  }                                           
7322
7323  return std::exp(x);
7324}
7325
7326G4double G4Incl::radius(G4double A)
7327{                                               
7328  const G4double dp1 = 1.0, dp3 = 3.0; 
7329  const G4double dp5 = 5.0, dpth = dp1/dp3;
7330  const G4int naSize = 23;
7331  const G4int rmsSize = naSize;
7332
7333  const G4int na[naSize] = {1,2,3,4,6,7,9,10,11,12,13,14,15,16,17,18,19,20,22,23,24,25,26};
7334 
7335  const G4double rms[rmsSize] = {0.85,2.095,1.976,1.671,2.57,2.41,2.519,2.45,
7336                                 2.42,2.471,2.440,2.58,2.611,2.730,2.662,2.727,
7337                                 2.900,3.040,2.969,2.94,3.075,3.11,3.06};
7338             
7339  G4double fact = std::sqrt(dp5/dp3);                                               
7340  G4int ia = int(std::floor(A+0.4));                                                       
7341  G4double result = fact * (0.84 * std::pow(A,dpth) + 0.55);                               
7342  for(G4int i = 0; i < naSize; i++) {
7343    if (ia == na[i]) {
7344      result = fact*rms[i];
7345    }
7346  }
7347 
7348  return result;                                                           
7349}
7350
7351G4double G4Incl::crossSection(G4int projectile, G4double E, G4double A) 
7352{
7353  const G4double coefp[4][3] = {{ -5.9260e-9, 6.89450e-6, -6.0980e-6},
7354                                {  2.1544e-6,-1.84800e-3, -5.9820e-4},
7355                                { -2.5900e-4, 0.17595e+0,  1.1741e+0},
7356                                {  1.1504e-3, 2.82810e+0,-28.7300e+0}};
7357 
7358  const G4double coefn[4][3] = {{1.6105e-9,3.3985e-7,1.4678e-5},
7359                                {-5.35e-7,-3.465e-4,-0.01633e+0},
7360                                {-4.755e-6,0.07608e+0,2.8135e+0},
7361                                {-3.622e-3,3.5924e+0,-38.294e+0}};
7362 
7363  const G4double coef2p[5][3] = {{6.8108e-9,-2.163e-7,2.1898e-6},
7364                                 {-2.187e-6,7.8331e-5,-7.164e-4},
7365                                 {2.3651e-4,-9.690e-3,0.076424e+0},
7366                                 {-9.195e-3,0.5030e+0,-2.4979e+0},
7367                                 {-0.01087e+0,2.6494e+0,-2.5173e+0}}; 
7368
7369  G4double apow[3] = {0.0, 0.0, 0.0}, epow[5] = {0.0, 0.0, 0.0};
7370  G4int ii = 0, jj = 0;
7371
7372  if(A >= 27.0) {
7373    ii = 3;       
7374    jj = 4;
7375  } else {
7376    ii = 3;
7377    jj = 5;
7378  }
7379
7380  for(int i = 1; i <= ii; i++) {
7381    apow[i-1] = std::pow(A,(ii-i));
7382  }
7383
7384  for(int j = 1; j <= jj; j++) {
7385    epow[j-1] = std::pow(E,(jj-j));
7386  }
7387
7388  double result = 0.0;
7389
7390  if(A >= 27.0) { 
7391    if(projectile == 1) {
7392      for(G4int i = 0; i < ii; i++) {
7393        for(G4int j = 0; j < jj; j++) {
7394          result = result + coefp[j][i]*apow[i]*epow[j];
7395        }
7396      }
7397    } else {
7398      for(G4int i = 0; i < ii; i++ ) {
7399        for(G4int j = 0; j < jj; j++) {
7400          result = result + coefn[j][i]*apow[i]*epow[j];
7401        }
7402      }
7403    }
7404  } else {
7405    for(G4int i = 0; i < ii; i++) {
7406      for(G4int j = 0; j < jj; j++) {
7407        result = result + coef2p[j][i]*apow[i]*epow[j];
7408      }
7409    }
7410  }
7411
7412  return result;
7413}
7414
7415G4double G4Incl::coulombTransm(G4double E, G4double fm1, G4double z1, G4double fm2, G4double z2)
7416{
7417  G4double eta = 0.0, rho = 0.0;
7418  const G4double c2 = 0.00516;
7419  const G4double c3 = 0.007165;
7420  const G4double uma = 938.0;
7421  G4double ml = 0.0;
7422 
7423  G4double ecm = E*fm2/(fm1+fm2);
7424  G4double fm = fm1*fm2*uma/(fm1+fm2);
7425  G4double r1 = 0.0;
7426  G4double r2 = 0.0;
7427  if(fm1 >= 2.0) {
7428    r1 = 1.2*std::pow(fm1,0.33333333);
7429  }
7430  r2 = 1.2*std::pow(fm2,0.33333333);
7431  eta = c2*z1*z2*std::sqrt(fm/ecm);
7432  rho = c3*(r1+r2)*std::sqrt(fm*ecm);
7433
7434  return clmb1(rho,eta,&ml);
7435}
7436
7437G4double G4Incl::clmb1(G4double rho, G4double eta, G4double *ml) 
7438{                                       
7439  const G4double dp1 = 1.0, dp2 = 2.e0, dp4 = 4.e0, dph = 0.5, dp5 = 5.0; 
7440
7441  const G4double prm1 = 69.06;                                         
7442  const G4int ln0 = 81, lt0 = 21;                                       
7443  const G4int ln1 = 61, lt1 = 61;                                       
7444  static G4double psi0[ln0], trans0[lt0][ln0], x0[lt0], f0[ln0], psi1[ln1];
7445  static G4double trans1[lt1][ln1], x1[lt1], f1[ln1];                               
7446
7447  const G4double pi = 3.14159;                                               
7448  const G4double c0 = 0.11225, c1 = dph, gamma = 0.5772157e0, s3 = 0.2020569;
7449  const G4double s4 = 0.08232323;
7450  static G4double y = dp2*eta;                                                         
7451  static G4double psi = rho*y;                                                         
7452
7453  static G4int i0 = 0, j0 = 0;
7454 
7455  static G4double prob = 0.0;
7456  static G4double dumm = 0.0, x = 0.0, cx = 0.0;
7457  static G4double t = 0.0, t1 = 0.0, t2 = 0.0, t3 = 0.0;
7458  static G4double f = 0.0, g = 0.0;
7459  static G4double temp = 0.0, temp1 = 0.0, temp2 = 0.0;
7460  static G4double xk = 0.0, delp0 = 0.0, delp1 = 0.0, delx0 = 0.0, delx1 = 0.0;
7461
7462  if (rho > y) {                                                 
7463    if (psi > dp4 && psi < 50.0) {                           
7464      prob = clmb2(rho,eta,&dumm);                                       
7465    } else {
7466      x = std::exp(std::log(eta)/6.0);
7467      prob = std::sqrt(dp1 - y*x/(c0 + c1 * std::pow(x,3) + rho * x));
7468    } 
7469    (*ml) = 0;
7470  } else {
7471    x = rho/y;                                                         
7472    if (psi <= psi0[0]) {
7473      t = min(pi*y,prm1);                                             
7474      cx = t/(std::exp(t) - dp1);                                             
7475      t1 = std::cos(rho) * (dp1-0.75*std::pow(psi,2) + dp5 * x * std::pow(psi,2)) - dph * psi * rho * std::sin(rho);
7476      t2 = dp1 + dph * psi * (dp1 - x/6.0);                                   
7477      if (eta > dp1) {                                         
7478        t3 = std::log(psi)+dp2*gamma - dp1 + dp1/(12.e0*std::pow(eta,2))+dp1/(12.e1*std::pow(eta,4));
7479      } else {                                                         
7480        t3 = std::log(dp2*rho) + gamma - dp1/(dp1 + std::pow(eta,2)) + s3*std::pow(eta,2) + s4*std::pow(eta,4);   
7481      }
7482      g = t1 + psi*t2*t3;                                               
7483      f = cx*rho*t2;                                                   
7484      prob = cx/(std::pow(g,2)+std::pow(f,2));                                           
7485      (*ml) = 3;
7486    } else if (psi <= psi0[ln0-1]) {
7487      if (x <= x0[0]) {
7488        temp = std::log(psi/psi0[0]);
7489        j0 = 1 + int(temp/delp0);                                       
7490        j0 = min(max(j0,1),(ln0-1));                                     
7491        temp = temp - (j0-1)*delp0;                                     
7492        t = f0[j0] + (f0[j0+1] - f0[j0])*temp/delp0;                       
7493        xk = x*std::sqrt(psi);                                             
7494        prob = (dp1+3.33e-1*x+3.e-1*xk+1.e-1*std::pow(xk,2))*std::exp(t);           
7495        t = min(pi*y,prm1);                                           
7496        cx = t/(std::exp(t)-dp1);                                           
7497        prob = cx/std::pow(prob,2);                                             
7498        (*ml) = 1;
7499      } else {                                                         
7500        temp1 = std::log(x/x0[0]);
7501        i0 = min(max(1 + int(temp1/delx0),1),lt0-1);                                     
7502        temp1 = temp1 - (i0 - 1)*delx0;                                   
7503        temp2 = std::log(psi/psi0[0]);
7504        j0 = min(max(1+int(temp2/delp0),1),ln0-1);                                     
7505        temp2 = temp2-(j0-1)*delp0;                                   
7506        t1 = trans0[i0][j0] + (trans0[i0+1][j0] - trans0[i0][j0]) * temp1/delx0;
7507        t2 = trans0[i0][j0+1] + (trans0[i0+1][j0+1] - trans0[i0][j0+1]) * temp1/delx0;
7508        prob = std::exp(t1 + (t2 - t1)*temp2/delp0);                                   
7509        (*ml)=2;                                                       
7510      }
7511    } else if (psi <= psi1[ln1-1]) {
7512      if (x <= x1[0]) {
7513        temp = std::log(psi/psi1[0]);
7514        j0 = min(max(1+int(temp/delp1), 1), ln1-1);
7515        t = f1[j0]+(f1[j0+1]-f1[j0])*(temp - (j0 - 1)*delp1)/delp1;                       
7516        xk = x*std::sqrt(psi);                                             
7517        prob = (dp1+3.33e-1*x+3.0e-1*xk+1.e-1*std::pow(xk,2))*std::exp(t);           
7518        t = min(pi*y,prm1);                                           
7519        cx = t/(std::exp(t)-dp1);                                           
7520        prob = cx/std::pow(prob,2);                                             
7521        (*ml) = 1;
7522      } else {                                                         
7523        temp1 = std::log(x/x1[0]);
7524        i0 = min(max(1+int(temp1/delx1),1),lt1-1);                                   
7525        temp1 = temp1-(i0-1)*delx1;                                   
7526        temp2 = std::log(psi/psi1[0]);
7527        j0 = min(max(1+int(temp2/delp1),1),ln1-1);                                     
7528        temp2 = temp2 - (j0-1)*delp1;                                   
7529        t1 = trans1[i0][j0] + (trans1[i0+1][j0] - trans1[i0][j0])*temp1/delx1;
7530        t2 = trans1[i0][j0+1] + (trans1[i0+1][j0+1] - trans1[i0][j0+1])*temp1/delx1;                                                     
7531        prob = std::exp(t1 + (t2-t1)*temp2/delp1);                                   
7532        (*ml)=2;                                                       
7533      }
7534    } else {
7535      prob = clmb2(rho,eta,&dumm);                                       
7536      (*ml) = 4;                                             
7537    }
7538  }
7539
7540  return prob;
7541}
7542
7543G4double G4Incl::clmb2(G4double rho, G4double eta, G4double *t1)
7544{
7545  const G4double dp0 = 0.0, dp1 = 1.0, dp2 = 2.0, dp3 = 3.0;
7546  const G4double dph = 0.5, dpth = dp1/dp3;                                                   
7547  const G4int ln = 102;
7548
7549  const G4double t0[ln] = {0.0, dp0,.1083,.1369,.1572,.1736,.1876,.2,.2113,
7550                           0.2216,.2312,.2403,.2489,.2571,.265,.2725,.2798,
7551                           .2869,.2938,.3006,.3071,.3136,.3199,.3261,.3322,
7552                           .3382,.3442,.3499,.3557,.3615,.3672,.3729,.3785,
7553                           .3841,.3897,.3952,.4008,.4063,.4118,.4173,.4228,
7554                           .4283,.4338,.4393,.4448,.4504,.4559,.4615,.4671,
7555                           .4728,.4784,.4841,.4899,.4957,.5015,.5074,.5133,
7556                           .5193,.5253,.5315,.5376,.5439,.5503,.5567,.5632,
7557                           .5698,.5765,.5833,.5903,.5973,.6045,.6118,.6193,
7558                           .6269,.6346,.6426,.6507,.659,.6675,.6763,.6853,
7559                           .6945,.704,.7139,.724,.7345,.7453,.7566,.7683,
7560                           .7805,.7932,.8065,.8205,.8352,.8508,.8673,.8849,
7561                           .9038,.9243,.9467,.9715,dp1};                                           
7562  const G4double x1 = 0.01;
7563  const G4double xi = 100;                                       
7564  static G4double x = 0.0, temp = 0.0, prob = 0.0;
7565  static G4int i = 0;
7566
7567  x = dp1/(dp1 + std::sqrt(dph*rho*eta));                                     
7568  if (x < x1) {                                                 
7569    temp = t0[2] * std::pow((x/x1),dpth);
7570  } else {
7571    i = int(std::floor(xi*x));                                                         
7572    i = i + 1;
7573    if(i == 101) {
7574      i = 100;
7575    }
7576    i = max(min(i,ln-1),2); // 2->1
7577    temp = t0[i] + (t0[i+1] - t0[i]) * (x - i * x1)/x1;                         
7578  }
7579  (*t1) = dp1 - temp;                                                       
7580  prob = dp1 - dp2 * (*t1) * eta/rho;                                           
7581
7582  return (max(prob,dp0));
7583}
7584
7585// Utilities
7586
7587G4double G4Incl::min(G4double a, G4double b)
7588{
7589  if(a < b) {
7590    return a;
7591  } else {
7592    return b;
7593  }
7594}
7595
7596G4int G4Incl::min(G4int a, G4int b)
7597{
7598  if(a < b) {
7599    return a;
7600  } else {
7601    return b;
7602  }
7603}
7604
7605G4double G4Incl::max(G4double a, G4double b)
7606{
7607  if(a > b) {
7608    return a;
7609  } else {
7610    return b;
7611  }
7612}
7613
7614G4int G4Incl::max(G4int a, G4int b)
7615{
7616  if(a > b) {
7617    return a;
7618  } else {
7619    return b;
7620  }
7621}
7622
7623G4int G4Incl::nint(G4double number)
7624{
7625  G4double intpart;
7626  G4double fractpart;
7627  fractpart = std::modf(number, &intpart);
7628  if(number == 0) {
7629    return 0;
7630  }
7631  if(number > 0) {
7632    if(fractpart < 0.5) {
7633      return int(std::floor(number));
7634    } else {
7635      return int(std::ceil(number));
7636    }
7637  }
7638  if(number < 0) {
7639    if(fractpart < -0.5) {
7640      return int(std::floor(number));
7641    } else {
7642      return int(std::ceil(number));
7643    }
7644  }
7645 
7646  return 0;
7647}
7648
7649G4double G4Incl::callFunction(G4int functionChoice, G4double r)
7650{
7651  if(functionChoice == wsaxFunction) {
7652    return wsax(r);
7653  }
7654  else if(functionChoice == derivWsaxFunction) {
7655    return derivWsax(r);
7656  }
7657  else if(functionChoice == dmhoFunction) {
7658    return dmho(r);
7659  }
7660  else if(functionChoice == derivMhoFunction) {
7661    return derivMho(r);
7662  }
7663  else if(functionChoice  == derivGausFunction) {
7664    return derivGaus(r);
7665  }
7666  else if(functionChoice == densFunction) {
7667    return dens(r);
7668  }
7669
7670  return 0.0;
7671}
7672
7673G4double G4Incl::am(G4double a, G4double b, G4double c, G4double d) 
7674{
7675  return std::sqrt(d*d-a*a-b*b-c*c);
7676}
7677
7678G4double G4Incl::pcm(G4double E, G4double A, G4double C)
7679{
7680  return (0.5*std::sqrt((std::pow(E,2)-std::pow((A+C),2))*(std::pow(E,2)-std::pow((A-C),2)))/E);
7681}
7682
7683G4double G4Incl::sign(G4double a, G4double b)
7684{
7685  if(b >= 0) {
7686    return utilabs(a);
7687  }
7688  if(b < 0) {
7689    return (-1.0*utilabs(a));
7690  }
7691
7692  if(verboseLevel > 2) {
7693    G4cout <<"Error: sign function failed. " << G4endl;
7694  }
7695  return a; // The algorithm is never supposed to reach this point.
7696}
7697
7698G4double G4Incl::utilabs(G4double a)
7699{
7700  if(a > 0) {
7701    return a;
7702  }
7703  if(a < 0) {
7704    return (-1.0*a);
7705  }
7706  if(a == 0) {
7707    return a;
7708  }
7709
7710  if(verboseLevel > 2) {
7711    G4cout <<"Error: utilabs function failed. " << G4endl;
7712  }
7713  return a;
7714}
7715
7716G4double G4Incl::amax1(G4double a, G4double b)
7717{
7718  if(a > b) {
7719    return a;
7720  }
7721  else if(b > a) {
7722    return b;
7723  }
7724  else if(a == b) {
7725    return a;
7726  }
7727
7728  return a; // The algorithm is never supposed to reach this point.
7729}
7730
7731G4double G4Incl::w(G4double a, G4double b, G4double c, G4double d)
7732{
7733  return (std::sqrt(a*a+b*b+c*c+d*d));
7734}
7735
7736G4int G4Incl::idnint(G4double a)
7737{
7738  G4int value = 0;
7739
7740  G4int valueCeil = int(std::ceil(a));
7741  G4int valueFloor = int(std::floor(a));
7742
7743  if(std::abs(value - valueCeil) < std::abs(value - valueFloor)) {
7744    return valueCeil;
7745  }
7746  else {
7747    return valueFloor;
7748  }
7749}
Note: See TracBrowser for help on using the repository browser.