~ejungwoo/geant4/G4FTFParameters_8cc_source.html

 //

 // ********************************************************************

 // * License and Disclaimer                                           *

 // *                                                                  *

 // * The  Geant4 software  is  copyright of the Copyright Holders  of *

 // * the Geant4 Collaboration.  It is provided  under  the terms  and *

 // * conditions of the Geant4 Software License,  included in the file *

 // * LICENSE and available at  http://cern.ch/geant4/license .  These *

 // * include a list of copyright holders.                             *

 // *                                                                  *

 // * Neither the authors of this software system, nor their employing *

 // * institutes,nor the agencies providing financial support for this *

 // * work  make  any representation or  warranty, express or implied, *

 // * regarding  this  software system or assume any liability for its *

 // * use.  Please see the license in the file  LICENSE  and URL above *

 // * for the full disclaimer and the limitation of liability.         *

 // *                                                                  *

 // * This  code  implementation is the result of  the  scientific and *

 // * technical work of the GEANT4 collaboration.                      *

 // * By using,  copying,  modifying or  distributing the software (or *

 // * any work based  on the software)  you  agree  to acknowledge its *

 // * use  in  resulting  scientific  publications,  and indicate your *

 // * acceptance of all terms of the Geant4 Software license.          *

 // ********************************************************************

 //

 //

 // $Id: G4FTFParameters.cc 109066 2018-03-23 12:59:45Z gcosmo $

 // GEANT4 tag $Name:  $

 //


 #include <utility>


 #include "G4FTFParameters.hh"


 #include "G4ios.hh"

 #include "G4PhysicalConstants.hh"

 #include "G4SystemOfUnits.hh"


 #include "G4ParticleDefinition.hh"


 #include "G4Proton.hh"

 #include "G4Neutron.hh"


 #include "G4PionPlus.hh"

 #include "G4PionMinus.hh"

 #include "G4KaonPlus.hh"

 #include "G4KaonMinus.hh"


 #include "G4Exp.hh"

 #include "G4Log.hh"

 #include "G4Pow.hh"


 #include "G4HadronicDeveloperParameters.hh"


 G4HadronicDeveloperParameters& HDP = G4HadronicDeveloperParameters::GetInstance();

 class G4FTFSettingDefaultHDP

 {

   public:

     // ctor

     G4FTFSettingDefaultHDP() {

     //

     // Cross sections for elementary processes

     //

     // these are for Inelastic interactions, i.e. Xinelastic=(Xtotal-Xelastix)>0.

     // for elastic, all the A's & B's, Atop & Ymin are zeros

     // general formula: Pp = A1*exp(B1*Y) + A2*exp(B2*Y) + A3

     // but if Y<Ymin, then Pp=max(0.,Atop)

     // for details, see also G4FTFParameters::GetProcProb( ProcN, y )

     //

     // Baryon projectile

     //

     /* JVY, Oct. 31, 2017: Per Alberto R. & Vladimir U., keep this group of parameters FIXED

     // Process=0 --> Qexchg w/o excitation

     //

     HDP.SetDefault( "FTF_BARYON_PROC0_A1",  13.71 );

     HDP.SetDefault( "FTF_BARYON_PROC0_B1",   1.75 );

     HDP.SetDefault( "FTF_BARYON_PROC0_A2",-214.5  );

     HDP.SetDefault( "FTF_BARYON_PROC0_B2",   4.25 );

     HDP.SetDefault( "FTF_BARYON_PROC0_A3",   0.0  );

     HDP.SetDefault( "FTF_BARYON_PROC0_ATOP", 0.5  );

     HDP.SetDefault( "FTF_BARYON_PROC0_YMIN", 1.1  );

     //

     // Process=1 --> Qexchg w/excitation

     //

     HDP.SetDefault( "FTF_BARYON_PROC1_A1",  25.   );

     HDP.SetDefault( "FTF_BARYON_PROC1_B1",   1.   );

     HDP.SetDefault( "FTF_BARYON_PROC1_A2", -50.34 );

     HDP.SetDefault( "FTF_BARYON_PROC1_B2",   1.5  );

     HDP.SetDefault( "FTF_BARYON_PROC1_A3",   0.   );

     HDP.SetDefault( "FTF_BARYON_PROC1_ATOP", 0.   );

     HDP.SetDefault( "FTF_BARYON_PROC1_YMIN", 1.4  );

     */

     //

     // NOTE: Process #2 & 3 are projectile & target diffraction

     //       they have more complex definition of A1 & A2

     //      (see around line 540 or so)

     // SetParams( 2, 6.0/Xinel, 0.0 ,-6.0/Xinel*16.28, 3.0 , 0.0, 0.0  ,     0.93);// Projectile diffraction

     // SetParams( 3, 6.0/Xinel, 0.0 ,-6.0/Xinel*16.28, 3.0 , 0.0, 0.0  ,     0.93);// Target diffraction

     //

     // Also, for ( AbsProjectileBaryonNumber > 1 ||  NumberOfTargetNucleons > 1 )

     // projectile and/or target diffraction (dissociation) may be switched ON/OFF

     //

     HDP.SetDefault( "FTF_BARYON_DIFF_DISSO_PROJ", false );

     HDP.SetDefault( "FTF_BARYON_DIFF_DISSO_TGT",  false ); // as in hadr-string-diff-V10-03-07

     //

     /* JVY, Oct. 31, 2017: Per Alberto R. & Vladimir U., keep this group of parameters FIXED

     // Process=4 --> Qexchg w/additional multiplier in excitation

     //

     HDP.SetDefault( "FTF_BARYON_PROC4_A1",  1.  );

     HDP.SetDefault( "FTF_BARYON_PROC4_B1",  0.  );

     HDP.SetDefault( "FTF_BARYON_PROC4_A2", -2.01);

     HDP.SetDefault( "FTF_BARYON_PROC4_B2",  0.5 );

     HDP.SetDefault( "FTF_BARYON_PROC4_A3",  0.  );

     HDP.SetDefault( "FTF_BARYON_PROC4_ATOP",0.  );

     HDP.SetDefault( "FTF_BARYON_PROC4_YMIN",1.4 );

     */

     //

     // Parameters of participating hadron (baryon) excitation

     //

     HDP.SetDefault( "FTF_BARYON_DELTA_PROB_QEXCHG", 0. );

     HDP.SetDefault( "FTF_BARYON_PROB_SAME_QEXCHG", 0. );

     HDP.SetDefault( "FTF_BARYON_DIFF_M_PROJ", 1.16, 1.16, 3. );

     HDP.SetDefault( "FTF_BARYON_NONDIFF_M_PROJ", 1.16, 1.16, 3. );

     HDP.SetDefault( "FTF_BARYON_DIFF_M_TGT", 1.16, 1.16, 3. );

     HDP.SetDefault( "FTF_BARYON_NONDIFF_M_TGT", 1.16, 1.16, 3. );

     HDP.SetDefault( "FTF_BARYON_AVRG_PT2", 0.3, 0.08, 1. );

     //

     // JVY, Oct. 6, 2017: Per Alberto R., keep these two settings fixed (for now)

     //

     // HDP.SetDefault( "FTF_BARYON_PROB_DISTR_PROJ", 0.3 );

     // HDP.SetDefault( "FTF_BARYON_PROB_DISTR_TGT", 0.3 );

     //

     // nuclear destruction - common parameters (with validity ranges, if applicable)

     //

     HDP.SetDefault( "FTF_NUCDESTR_P1_PROJ", 1., 0., 1. ); // in principle, it should be 1./NBRN - FIXME later !

     HDP.SetDefault( "FTF_NUCDESTR_P1_NBRN_PROJ", false );

     HDP.SetDefault( "FTF_NUCDESTR_P1_TGT", 1., 0., 1. );

     HDP.SetDefault( "FTF_NUCDESTR_P1_ADEP_TGT", false );

     // for now, keep fixed p2 & p3 for the tgt destruction

     HDP.SetDefault( "FTF_NUCDESTR_P2_TGT", 4.0, 2., 16. );

     HDP.SetDefault( "FTF_NUCDESTR_P3_TGT", 2.1, 0., 4. );

     HDP.SetDefault( "FTF_PT2_NUCDESTR_P1", 0.035, 0., 0.25 );

     HDP.SetDefault( "FTF_PT2_NUCDESTR_P2", 0.04, 0., 0.25 );

     HDP.SetDefault( "FTF_PT2_NUCDESTR_P3", 4.0, 2., 16. );

     HDP.SetDefault( "FTF_PT2_NUCDESTR_P4", 2.5, 0., 4. );

     //

     // nuclear desctruction - specific to baryon projectile

     //

     HDP.SetDefault( "FTF_BARYON_NUCDESTR_R2", 1.5*CLHEP::fermi*CLHEP::fermi, 0.5*CLHEP::fermi*CLHEP::fermi, 2.*CLHEP::fermi*CLHEP::fermi  );

     HDP.SetDefault( "FTF_BARYON_EXCI_E_PER_WNDNUCLN", 40.*CLHEP::MeV, 0., 100.*CLHEP::MeV );

     HDP.SetDefault( "FTF_BARYON_NUCDESTR_DOF", 0.3, 0.1, 0.4 );

     //

     // JVY, Oct. 6, 2017: Per Alberto R., this is just a technical parameter,

     //                    and it should NOT be changed

     //

     // HDP.SetDefault( "FTF_BARYON_NUCDESTR_MAXPT2", 1. * CLHEP::GeV*CLHEP::GeV  );

   }

 };

 G4FTFSettingDefaultHDP FTFDefaultsHDP;


 //============================================================================


 //#define debugFTFparams


 //============================================================================


 G4FTFParamCollection::G4FTFParamCollection()

 {

   Reset(); // zero out everything


   // general (i.e. for used for baryons,anti-baryons, and mesons)

   //

   HDP.DeveloperGet( "FTF_NUCDESTR_P1_PROJ", fNuclearProjDestructP1 );

   HDP.DeveloperGet( "FTF_NUCDESTR_P1_NBRN_PROJ",fNuclearProjDestructP1_NBRNDEP );

   HDP.DeveloperGet( "FTF_NUCDESTR_P1_TGT", fNuclearTgtDestructP1 );

   HDP.DeveloperGet( "FTF_NUCDESTR_P1_ADEP_TGT", fNuclearTgtDestructP1_ADEP );

   HDP.DeveloperGet( "FTF_NUCDESTR_P2_TGT", fNuclearTgtDestructP2 );

   HDP.DeveloperGet( "FTF_NUCDESTR_P3_TGT", fNuclearTgtDestructP3 );

   //

   HDP.DeveloperGet( "FTF_PT2_NUCDESTR_P1", fPt2NuclearDestructP1 );

   HDP.DeveloperGet( "FTF_PT2_NUCDESTR_P2", fPt2NuclearDestructP2 );

   HDP.DeveloperGet( "FTF_PT2_NUCDESTR_P3", fPt2NuclearDestructP3 );

   HDP.DeveloperGet( "FTF_PT2_NUCDESTR_P4", fPt2NuclearDestructP4 );

   //

   // fNuclearProjDestructP1 = 1.; // in 10.2.p03 & 10.3.ref04-ref07/08/09 it's 0.00481; in 10.3.p01/p02/p03, etc. it's be 1. (fixed)

   // fNuclearProjDestructP1_NBRNDEP = false;

   // fNuclearTgtDestructP1 = 1.;  // in 10.2.p03 & 10.3.ref04-ref07/08/09 it's 0.00481; in 10.3.p01/p02/p03, etc. it's be 1. (fixed)

   // fNuclearTgtDestructP1_ADEP = false;

   fNuclearProjDestructP2 = 4.0;

   fNuclearProjDestructP3 = 2.1;

   // fNuclearTgtDestructP2 = 4.0;

   // fNuclearTgtDestructP3 = 2.1;

   // fPt2NuclearDestructP1 = 0.035;

   // fPt2NuclearDestructP2 = 0.04;

   // fPt2NuclearDestructP3 = 4.0;

   // fPt2NuclearDestructP4 = 2.5;

 }


 void G4FTFParamCollection::Reset()

 {

   // parameters of excitation


   // Proc=0 --> Qexchg w/o excitation

   fProc0A1 = 0.;

   fProc0B1 = 0.;

   fProc0A2 = 0.;

   fProc0B2 = 0.;

   fProc0A3 = 0.;

   fProc0Atop = 0.;

   fProc0Ymin = 0.;


   // Proc=1 --> Qexchg w/excitation

   fProc1A1 = 0.;

   fProc1B1 = 0.;

   fProc1A2 = 0.;

   fProc1B2 = 0.;

   fProc1A3 = 0.;

   fProc1Atop = 0.;

   fProc1Ymin = 0.;


   // Proc=2 & Proc=3 for ( AbsProjectileBaryonNumber > 1  ||  NumberOfTargetNucleons > 1 )

   // Do NOT do anything as it's set once and for all !!!


   // Proc=4 --> Qexchg w/additional multiplier in excitation

   fProc4A1 = 0.;

   fProc4B1 = 0.;

   fProc4A2 = 0.;

   fProc4B2 = 0.;

   fProc4A3 = 0.;

   fProc4Atop = 0.;

   fProc4Ymin = 0.;


   // parameters of participating baryon excitation


   fDeltaProbAtQuarkExchange = 0.;

   fProbOfSameQuarkExchange = 0.;

   fProjMinDiffMass = 0.;

   fProjMinNonDiffMass = 0.;

   fTgtMinDiffMass = 0.;

   fTgtMinNonDiffMass = 0.;

   fAveragePt2 = 0.;

   fProbLogDistrPrD = 0.;

   fProbLogDistr = 0.;


   // parameters of nuclear distruction


   // COMMONs

   fNuclearProjDestructP1 = 0.;

   fNuclearTgtDestructP1 = 0.;

   fNuclearProjDestructP2 = 0.;

   fNuclearProjDestructP3 = 0.;

   fNuclearTgtDestructP2 = 0.;

   fNuclearTgtDestructP3 = 0.;

   fPt2NuclearDestructP1 = 0.;

   fPt2NuclearDestructP2 = 0.;

   fPt2NuclearDestructP3 = 0.;

   fPt2NuclearDestructP4 = 0.;


   // baryons

   fR2ofNuclearDestruct = 0.;

   fExciEnergyPerWoundedNucleon = 0.;

   fDofNuclearDestruct = 0.;

   fMaxPt2ofNuclearDestruct = 0.;


   return;

 }


 //============================================================================


 G4FTFParamCollBaryonProj::G4FTFParamCollBaryonProj()

    : G4FTFParamCollection()

 {


   // parameters of participating hadron (baryon) excitation

   //

   // baryons projectile

   //

   // Proc=0 --> Qexchg w/o excitation

   //

   /* As of Oct. 31, 2017 keep these fixed

   HDP.DeveloperGet( "FTF_BARYON_PROC0_A1",   fProc0A1 );

   HDP.DeveloperGet( "FTF_BARYON_PROC0_B1",   fProc0B1 );

   HDP.DeveloperGet( "FTF_BARYON_PROC0_A2",   fProc0A2 );

   HDP.DeveloperGet( "FTF_BARYON_PROC0_B2",   fProc0B2 );

   HDP.DeveloperGet( "FTF_BARYON_PROC0_A3",   fProc0A3 );

   HDP.DeveloperGet( "FTF_BARYON_PROC0_ATOP", fProc0Atop );

   HDP.DeveloperGet( "FTF_BARYON_PROC0_YMIN", fProc0Ymin );

   */

   //

   fProc0A1 =  13.71;

   fProc0B1 =   1.75;

   fProc0A2 = -30.69; // (or -214.5 as in Doc ?)

   fProc0B2 =   3.;   // ( or 4. as in Doc ?)

   fProc0A3 =   0.;

   fProc0Atop = 1.;   // ( or 0.5 as in Doc ?)

   fProc0Ymin = 0.93; // (or 1.1 as in Doc ?)

   //

   // Proc=1 --> Qexchg w/excitation

   //

   /* As of Oct. 31, 2017 keep these fixed

   HDP.DeveloperGet( "FTF_BARYON_PROC1_A1",   fProc1A1 );

   HDP.DeveloperGet( "FTF_BARYON_PROC1_B1",   fProc1B1 );

   HDP.DeveloperGet( "FTF_BARYON_PROC1_A2",   fProc1A2 );

   HDP.DeveloperGet( "FTF_BARYON_PROC1_B2",   fProc1B2 );

   HDP.DeveloperGet( "FTF_BARYON_PROC1_A3",   fProc1A3 );

   HDP.DeveloperGet( "FTF_BARYON_PROC1_ATOP", fProc1Atop );

   HDP.DeveloperGet( "FTF_BARYON_PROC1_YMIN", fProc1Ymin );

   */

   //

   fProc1A1 =  25.;

   fProc1B1 =   1.;

   fProc1A2 = -50.34;

   fProc1B2 =   1.5;

   fProc1A3 =   0.;

   fProc1Atop = 0.;

   fProc1Ymin = 1.4;

   //

   // Proc=2 & Proc=3 for the case ( AbsProjectileBaryonNumber > 1 ||  NumberOfTargetNucleons > 1 )

   // (diffraction dissociation)

   //

   HDP.DeveloperGet( "FTF_BARYON_DIFF_DISSO_PROJ", fProjDiffDissociation );

   HDP.DeveloperGet( "FTF_BARYON_DIFF_DISSO_TGT",  fTgtDiffDissociation );

   //

   // fProjDiffDissociation = false;

   // fTgtDiffDissociation  = true;

   //

   //

   // Proc=4 --> Qexchg "w/additional multiplier" in excitation

   //

   /* As of Oct. 31, 2017 keep these fixed

   HDP.DeveloperGet( "FTF_BARYON_PROC4_A1",   fProc4A1 );

   HDP.DeveloperGet( "FTF_BARYON_PROC4_B1",   fProc4B1 );

   HDP.DeveloperGet( "FTF_BARYON_PROC4_A2",   fProc4A2 );

   HDP.DeveloperGet( "FTF_BARYON_PROC4_B2",   fProc4B2 );

   HDP.DeveloperGet( "FTF_BARYON_PROC4_A3",   fProc4A3 );

   HDP.DeveloperGet( "FTF_BARYON_PROC4_ATOP", fProc4Atop );

   HDP.DeveloperGet( "FTF_BARYON_PROC4_YMIN", fProc4Ymin );

   */

   //

   fProc4A1 =   0.6; // (or 1. as in Doc ?)

   fProc4B1 =   0.;

   fProc4A2 =  -1.2; // (or -2.01 as in Doc ?)

   fProc4B2 =   0.5;

   fProc4A3 =   0.;

   fProc4Atop = 0.;

   fProc4Ymin = 1.4;

   //

   //

   HDP.DeveloperGet( "FTF_BARYON_DELTA_PROB_QEXCHG", fDeltaProbAtQuarkExchange );

   HDP.DeveloperGet( "FTF_BARYON_PROB_SAME_QEXCHG", fProbOfSameQuarkExchange );

   HDP.DeveloperGet( "FTF_BARYON_DIFF_M_PROJ", fProjMinDiffMass );

   HDP.DeveloperGet( "FTF_BARYON_NONDIFF_M_PROJ", fProjMinNonDiffMass );

   HDP.DeveloperGet( "FTF_BARYON_DIFF_M_TGT", fTgtMinDiffMass );

   HDP.DeveloperGet( "FTF_BARYON_NONDIFF_M_TGT", fTgtMinNonDiffMass );

   HDP.DeveloperGet( "FTF_BARYON_AVRG_PT2", fAveragePt2 );

   //

   // fDeltaProbAtQuarkExchange = 0.;

   // fProbOfSameQuarkExchange  = 0.;

   // fProjMinDiffMass          = 1.16; // it's supposed to be in GeV but do NOT do (*CLHEP::GeV)

                                        // because it'll be done in the G4FTFParameters::SetProjMinDiffMass

   // fProjMinNonDiffMass       = 1.16; // do NOT (*CLHEP::GeV) - same as above

   // fTgtMinDiffMass           = 1.16; // do NOT (*CLHEP::GeV) - same as above

   // fTgtMinNonDiffMass        = 1.16; // do NOT (*CLHEP::GeV) - same as above

   // fAveragePt2               = 0.15;  //  do NOT (*CLHEP::GeV*CLHEP::GeV)

   //

   // JVY - Per Alberto R., we're curretly keeping these two settings fixed,

   // thus they're defined here explicitly, rather than via HDP

   //

   // HDP.DeveloperGet( "FTF_BARYON_PROB_DISTR_PROJ", fProbLogDistrPrD );

   // HDP.DeveloperGet( "FTF_BARYON_PROB_DISTR_TGT", fProbLogDistr );

   fProbLogDistrPrD          = 0.55;

   fProbLogDistr             = 0.55;


   // nuclear destruction

   //

   // baryons

   //

   // ---> LATER !!! ---> fBaryonMaxNumberOfCollisions = 2.;

   //


   HDP.DeveloperGet( "FTF_BARYON_NUCDESTR_R2", fR2ofNuclearDestruct );

   HDP.DeveloperGet( "FTF_BARYON_EXCI_E_PER_WNDNUCLN", fExciEnergyPerWoundedNucleon );

   HDP.DeveloperGet( "FTF_BARYON_NUCDESTR_DOF", fDofNuclearDestruct );

   //

   // fR2ofNuclearDestruct         = 1.5 * CLHEP::fermi*CLHEP::fermi;

   // fExciEnergyPerWoundedNucleon = 40. * CLHEP::MeV;

   // fDofNuclearDestruct          = 0.3;

   //

   // NOTE-1: this parameter has changed from 1. to 9. between 10.2 and 10.3.ref07 !!!

   //         ... then it went back to 1. for the 10.4-candidate...

   // NOTE-2: this is a "technical" parameter, it should not be changed; this is why

   //         it is defined explicitly rather than via HDP

   // --> HDP.DeveloperGet( "FTF_BARYON_NUCDESTR_MAXPT2", fMaxPt2ofNuclearDestruct );

   fMaxPt2ofNuclearDestruct     = 9. * CLHEP::GeV*CLHEP::GeV;

 }


 //============================================================================


 G4ThreadLocal bool G4FTFParameters::chipsComponentXSisInitialized = false;

 G4ThreadLocal G4ChipsComponentXS* G4FTFParameters::chipsComponentXSinstance = 0;


 //============================================================================


 G4FTFParameters::G4FTFParameters()

 {


   FTFxsManager = 0;

   Reset();


   // Andrea Dotti (13Jan2013):

   // The following lines are changed for G4MT. Originally the code was:

   //   static G4ChipsComponentXS* _instance = new G4ChipsComponentXS();  // Witek Pokorski

   // Note the code could go back at original if _instance could be shared among threads

   if ( ! chipsComponentXSisInitialized ) {

     chipsComponentXSisInitialized = true;

     chipsComponentXSinstance = new G4ChipsComponentXS();

   }

   G4ChipsComponentXS* _instance = chipsComponentXSinstance;

   FTFxsManager = _instance;


 }


 //============================================================================


 G4FTFParameters::~G4FTFParameters() {}


 //============================================================================


 void G4FTFParameters::Reset()

 {


   FTFhNcmsEnergy  = 0.0;

   FTFXtotal = 0.0;

   FTFXelastic = 0.0;

   FTFXinelastic = 0.0;

   FTFXannihilation = 0.0;

   ProbabilityOfAnnihilation = 0.0;

   ProbabilityOfElasticScatt  = 0.0;

   RadiusOfHNinteractions2 = 0.0;

   FTFSlope = 0.0;

   AvaragePt2ofElasticScattering = 0.0;

   FTFGamma0 = 0.0;

   DeltaProbAtQuarkExchange = 0.0;

   ProbOfSameQuarkExchange = 0.0;

   ProjMinDiffMass = 0.0;

   ProjMinNonDiffMass = 0.0;

   ProbLogDistrPrD = 0.0;

   TarMinDiffMass = 0.0;

   TarMinNonDiffMass = 0.0;

   AveragePt2 = 0.0;

   ProbLogDistr  = 0.0;

   Pt2kink = 0.0;

   MaxNumberOfCollisions = 0.0;

   ProbOfInelInteraction = 0.0;

   CofNuclearDestructionPr = 0.0;

   CofNuclearDestruction = 0.0;

   R2ofNuclearDestruction  = 0.0;

   ExcitationEnergyPerWoundedNucleon  = 0.0;

   DofNuclearDestruction  = 0.0;

   Pt2ofNuclearDestruction = 0.0;

   MaxPt2ofNuclearDestruction = 0.0;


   for ( G4int i = 0; i < 4; i++ ) {

     for ( G4int j = 0; j < 7; j++ ) {

       ProcParams[i][j] = 0.0;

     }

   }


   return;


 }


 //============================================================================


 void G4FTFParameters::InitForInteraction( const G4ParticleDefinition* particle,

                                           G4int theA, G4int theZ, G4double PlabPerParticle )

 {


   Reset();


   G4int    ProjectilePDGcode    = particle->GetPDGEncoding();

   G4int    ProjectileabsPDGcode = std::abs( ProjectilePDGcode );

   G4double ProjectileMass       = particle->GetPDGMass();

   G4double ProjectileMass2      = ProjectileMass * ProjectileMass;


   G4int ProjectileBaryonNumber( 0 ), AbsProjectileBaryonNumber( 0 ), AbsProjectileCharge( 0 );

   G4bool ProjectileIsNucleus = false;


   if ( std::abs( particle->GetBaryonNumber() ) > 1 ) {  // The projectile is a nucleus

     ProjectileIsNucleus       = true;

     ProjectileBaryonNumber    = particle->GetBaryonNumber();

     AbsProjectileBaryonNumber = std::abs( ProjectileBaryonNumber );

     AbsProjectileCharge       = G4int( particle->GetPDGCharge() );

     if ( ProjectileBaryonNumber > 1 ) {

       ProjectilePDGcode = 2212; ProjectileabsPDGcode = 2212;  // Proton

     } else {

       ProjectilePDGcode = -2212; ProjectileabsPDGcode = 2212;  // Anti-Proton

     }

     ProjectileMass  = G4Proton::Proton()->GetPDGMass();

     ProjectileMass2 = sqr( ProjectileMass );

   }


   G4double TargetMass  = G4Proton::Proton()->GetPDGMass();

   G4double TargetMass2 = TargetMass * TargetMass;


   G4double Plab = PlabPerParticle;

   G4double Elab = std::sqrt( Plab*Plab + ProjectileMass2 );

   G4double KineticEnergy = Elab - ProjectileMass;


   G4double S = ProjectileMass2 + TargetMass2 + 2.0*TargetMass*Elab;


   #ifdef debugFTFparams

   G4cout << "--------- FTF Parameters --------------" << G4endl << "Proj Plab "

          << ProjectilePDGcode << " " << Plab << G4endl << "Mass KinE " << ProjectileMass

          << " " << KineticEnergy << G4endl << " A Z " << theA << " " << theZ << G4endl;

   #endif


   G4double Ylab, Xtotal, Xelastic, Xannihilation;

   G4int NumberOfTargetNucleons;


   Ylab = 0.5 * G4Log( (Elab + Plab)/(Elab - Plab) );


   G4double ECMSsqr = S/GeV/GeV;

   G4double SqrtS   = std::sqrt( S )/GeV;


   #ifdef debugFTFparams

   G4cout << "Sqrt(s) " << SqrtS << G4endl;

   #endif


   TargetMass     /= GeV; TargetMass2     /= (GeV*GeV);

   ProjectileMass /= GeV; ProjectileMass2 /= (GeV*GeV);


   /* JYV, Oct. 31, 2017: Keep it in the ctor


   // Andrea Dotti (13Jan2013):

   // The following lines are changed for G4MT. Originally the code was:

   //   static G4ChipsComponentXS* _instance = new G4ChipsComponentXS();  // Witek Pokorski

   // Note the code could go back at original if _instance could be shared among threads

   if ( ! chipsComponentXSisInitialized ) {

     chipsComponentXSisInitialized = true;

     chipsComponentXSinstance = new G4ChipsComponentXS();

   }

   G4ChipsComponentXS* _instance = chipsComponentXSinstance;

   FTFxsManager = _instance;

   */


   Plab /= GeV;

   G4double Xftf = 0.0;


   G4int NumberOfTargetProtons  = theZ;

   G4int NumberOfTargetNeutrons = theA - theZ;

   NumberOfTargetNucleons = NumberOfTargetProtons + NumberOfTargetNeutrons;


   if ( ProjectilePDGcode == 2212  ||  ProjectilePDGcode == 2112 ) {  // Projectile is nucleon

     G4ParticleDefinition* Proton = G4Proton::Proton();                                          //ALB

     G4double XtotPP = FTFxsManager->GetTotalElementCrossSection( Proton, KineticEnergy, 1, 0 ); //ALB


     G4ParticleDefinition* Neutron = G4Neutron::Neutron();

     G4double XtotPN = FTFxsManager->GetTotalElementCrossSection( Neutron, KineticEnergy, 1, 0 ); //ALB

     G4double XelPP  = FTFxsManager->GetElasticElementCrossSection( Proton, KineticEnergy, 1, 0 );

     G4double XelPN  = FTFxsManager->GetElasticElementCrossSection( Neutron, KineticEnergy, 1, 0 );


     #ifdef debugFTFparams

     G4cout << "XsPP " << XtotPP/millibarn << " " << XelPP/millibarn << G4endl

            << "XsPN " << XtotPN/millibarn << " " << XelPN/millibarn << G4endl;

     #endif


     if ( ! ProjectileIsNucleus ) {  // Projectile is hadron

       Xtotal   = ( NumberOfTargetProtons * XtotPP + NumberOfTargetNeutrons * XtotPN ) /

                  NumberOfTargetNucleons;

       Xelastic = ( NumberOfTargetProtons * XelPP  + NumberOfTargetNeutrons * XelPN  ) /

                  NumberOfTargetNucleons;

     } else {  // Projectile is a nucleus

       Xtotal = (

                   AbsProjectileCharge * NumberOfTargetProtons * XtotPP +

                   ( AbsProjectileBaryonNumber - AbsProjectileCharge ) *

                       NumberOfTargetNeutrons * XtotPP

                 +

                   ( AbsProjectileCharge * NumberOfTargetNeutrons +

                     ( AbsProjectileBaryonNumber - AbsProjectileCharge ) *

                         NumberOfTargetProtons ) * XtotPN

                 ) / ( AbsProjectileBaryonNumber * NumberOfTargetNucleons );

       Xelastic= (

                   AbsProjectileCharge * NumberOfTargetProtons * XelPP +

                   ( AbsProjectileBaryonNumber - AbsProjectileCharge ) *

                       NumberOfTargetNeutrons * XelPP

                  +

                   ( AbsProjectileCharge * NumberOfTargetNeutrons +

                     ( AbsProjectileBaryonNumber - AbsProjectileCharge ) *

                         NumberOfTargetProtons ) * XelPN

                 ) / ( AbsProjectileBaryonNumber * NumberOfTargetNucleons );

     }


     Xannihilation = 0.0;

     Xtotal /= millibarn;

     Xelastic /= millibarn;


   } else if ( ProjectilePDGcode < -1000 ) { // Projectile is anti_baryon


     G4double X_a( 0.0 ), X_b( 0.0 ), X_c( 0.0 ), X_d( 0.0 );

     G4double MesonProdThreshold = ProjectileMass + TargetMass +

                                   ( 2.0 * 0.14 + 0.016 ); // 2 Mpi + DeltaE;


     if ( PlabPerParticle < 40.0*MeV ) { // Low energy limits. Projectile at rest.

       Xtotal =   1512.9;    // mb

       Xelastic =  473.2;    // mb

       X_a =       625.1;    // mb

       X_b =         9.780;  // mb

       X_c =        49.989;  // mb

       X_d =         6.614;  // mb

     } else { // Total and elastic cross section of PbarP interactions a'la Arkhipov

       G4double LogS = G4Log( ECMSsqr / 33.0625 );

       G4double Xasmpt = 36.04 + 0.304*LogS*LogS;  // mb

       LogS = G4Log( SqrtS / 20.74 );

       G4double Basmpt = 11.92 + 0.3036*LogS*LogS;  // GeV^(-2)

       G4double R0 = std::sqrt( 0.40874044*Xasmpt - Basmpt );  // GeV^(-1)


       G4double FlowF = SqrtS / std::sqrt( ECMSsqr*ECMSsqr + ProjectileMass2*ProjectileMass2 +

                                           TargetMass2*TargetMass2 - 2.0*ECMSsqr*ProjectileMass2

                                           - 2.0*ECMSsqr*TargetMass2

                                           - 2.0*ProjectileMass2*TargetMass2 );


       Xtotal = Xasmpt * ( 1.0 + 13.55*FlowF/R0/R0/R0*

                                 (1.0 - 4.47/SqrtS + 12.38/ECMSsqr - 12.43/SqrtS/ECMSsqr) );  // mb


       Xasmpt = 4.4 + 0.101*LogS*LogS;  // mb

       Xelastic = Xasmpt * ( 1.0 + 59.27*FlowF/R0/R0/R0*

                                   (1.0 - 6.95/SqrtS + 23.54/ECMSsqr - 25.34/SqrtS/ECMSsqr ) ); // mb


       //G4cout << "Param Xtotal Xelastic " << Xtotal << " " << Xelastic << G4endl

       //       << "FlowF " << FlowF << " SqrtS " << SqrtS << G4endl

       //       << "Param Xelastic-NaN " << Xelastic << " "

       //       << 1.5*16.654/pow(ECMSsqr/2.176/2.176,2.2) << " " << ECMSsqr << G4endl;


       X_a = 25.0*FlowF;  // mb, 3-shirts diagram


       if ( SqrtS < MesonProdThreshold ) {

         X_b = 3.13 + 140.0*G4Pow::GetInstance()->powA( MesonProdThreshold - SqrtS, 2.5 );  // mb anti-quark-quark annihilation

         Xelastic -= 3.0*X_b;  // Xel-X(PbarP->NNbar)

       } else {

         X_b = 6.8/SqrtS;  // mb anti-quark-quark annihilation

         Xelastic -= 3.0*X_b;  // Xel-X(PbarP->NNbar)

       }


       X_c = 2.0*FlowF*sqr( ProjectileMass + TargetMass )/ECMSsqr;  // mb rearrangement


       X_d = 23.3/ECMSsqr;  // mb anti-quark-quark string creation

     }


     //G4cout << "Param Xtotal Xelastic " << Xtotal << " " << Xelastic << G4endl

     //       << "Para a b c d " << X_a << " " << X_b << " " << X_c << " " << X_d << G4endl;

     //       << "Para a b c d " << X_a << " " << 5.*X_b << " " << 5.*X_c << " " << 6.*X_d

     //       << G4endl;


     G4double Xann_on_P( 0.0), Xann_on_N( 0.0 );


     if ( ProjectilePDGcode == -2212 ) {  // Pbar+P/N

       Xann_on_P = X_a + X_b*5.0 + X_c*5.0 + X_d*6.0;

       Xann_on_N = X_a + X_b*4.0 + X_c*4.0 + X_d*4.0;

     } else if ( ProjectilePDGcode == -2112 ) {  // NeutrBar+P/N

       Xann_on_P = X_a + X_b*4.0 + X_c*4.0 + X_d*4.0;

       Xann_on_N = X_a + X_b*5.0 + X_c*5.0 + X_d*6.0;

     } else if ( ProjectilePDGcode == -3122 ) {  // LambdaBar+P/N

       Xann_on_P = X_a + X_b*3.0 + X_c*3.0 + X_d*2.0;

       Xann_on_N = X_a + X_b*3.0 + X_c*3.0 + X_d*2.0;

     } else if ( ProjectilePDGcode == -3112 ) {  // Sigma-Bar+P/N

       Xann_on_P = X_a + X_b*2.0 + X_c*2.0 + X_d*0.0;

       Xann_on_N = X_a + X_b*4.0 + X_c*4.0 + X_d*2.0;

     } else if ( ProjectilePDGcode == -3212 ) {  // Sigma0Bar+P/N

       Xann_on_P = X_a + X_b*3.0 + X_c*3.0 + X_d*2.0;

       Xann_on_N = X_a + X_b*3.0 + X_c*3.0 + X_d*2.0;

     } else if ( ProjectilePDGcode == -3222 ) {  // Sigma+Bar+P/N

       Xann_on_P = X_a + X_b*4.0 + X_c*4.0 + X_d*2.0;

       Xann_on_N = X_a + X_b*2.0 + X_c*2.0 + X_d*0.0;

     } else if ( ProjectilePDGcode == -3312 ) {  // Xi-Bar+P/N

       Xann_on_P = X_a + X_b*1.0 + X_c*1.0 + X_d*0.0;

       Xann_on_N = X_a + X_b*2.0 + X_c*2.0 + X_d*0.0;

     } else if ( ProjectilePDGcode == -3322 ) {  // Xi0Bar+P/N

       Xann_on_P = X_a + X_b*2.0 + X_c*2.0 + X_d*0.0;

       Xann_on_N = X_a + X_b*1.0 + X_c*1.0 + X_d*0.0;

     } else if ( ProjectilePDGcode == -3334 ) {  // Omega-Bar+P/N

       Xann_on_P = X_a + X_b*0.0 + X_c*0.0 + X_d*0.0;

       Xann_on_N = X_a + X_b*0.0 + X_c*0.0 + X_d*0.0;

     } else {

       G4cout << "Unknown anti-baryon for FTF annihilation" << G4endl;

     }


     //G4cout << "Sum          " << Xann_on_P << G4endl;


     if ( ! ProjectileIsNucleus ) {  // Projectile is anti-baryon

       Xannihilation = ( NumberOfTargetProtons * Xann_on_P  + NumberOfTargetNeutrons * Xann_on_N  )

                       / NumberOfTargetNucleons;

     } else {  // Projectile is a nucleus

       Xannihilation = (

                         ( AbsProjectileCharge * NumberOfTargetProtons +

                           ( AbsProjectileBaryonNumber - AbsProjectileCharge ) *

                           NumberOfTargetNeutrons ) * Xann_on_P

                        +

                         ( AbsProjectileCharge * NumberOfTargetNeutrons +

                           ( AbsProjectileBaryonNumber - AbsProjectileCharge ) *

                           NumberOfTargetProtons ) * Xann_on_N

                       ) / ( AbsProjectileBaryonNumber * NumberOfTargetNucleons );

     }


     //G4double Xftf = 0.0;

     MesonProdThreshold = ProjectileMass + TargetMass + (0.14 + 0.08); // Mpi + DeltaE

     if ( SqrtS > MesonProdThreshold ) {

       Xftf = 36.0 * ( 1.0 - MesonProdThreshold/SqrtS );

     }


     Xtotal = Xelastic + Xannihilation + Xftf;


     #ifdef debugFTFparams

     G4cout << "Plab Xtotal, Xelastic  Xinel Xftf " << Plab << " " << Xtotal << " " << Xelastic

            << " " << Xtotal - Xelastic << " " << Xtotal - Xelastic - Xannihilation << G4endl

            << "Plab Xelastic/Xtotal,  Xann/Xin " << Plab << " " << Xelastic/Xtotal << " "

            << Xannihilation/(Xtotal - Xelastic) << G4endl;

     #endif


   } else if ( ProjectilePDGcode == 211 ) {  // Projectile is PionPlus


     G4double XtotPiP = FTFxsManager->GetTotalElementCrossSection( particle, KineticEnergy, 1, 0 );

     G4ParticleDefinition* PionMinus = G4PionMinus::PionMinus();

     G4double XtotPiN = FTFxsManager->GetTotalElementCrossSection( PionMinus, KineticEnergy, 1, 0 );

     G4double XelPiP  = FTFxsManager->GetElasticElementCrossSection( particle, KineticEnergy, 1, 0 );

     G4double XelPiN  = FTFxsManager->GetElasticElementCrossSection( PionMinus, KineticEnergy, 1, 0 );

     Xtotal   = ( NumberOfTargetProtons * XtotPiP + NumberOfTargetNeutrons * XtotPiN )

                / NumberOfTargetNucleons;

     Xelastic = ( NumberOfTargetProtons * XelPiP  + NumberOfTargetNeutrons * XelPiN )

                / NumberOfTargetNucleons;

     Xannihilation = 0.0;

     Xtotal /= millibarn;

     Xelastic /= millibarn;


   } else if ( ProjectilePDGcode == -211 ) {  // Projectile is PionMinus


     G4double XtotPiP = FTFxsManager->GetTotalElementCrossSection( particle, KineticEnergy, 1, 0 );

     G4ParticleDefinition* PionPlus = G4PionPlus::PionPlus();

     G4double XtotPiN = FTFxsManager->GetTotalElementCrossSection( PionPlus, KineticEnergy, 1, 0 );

     G4double XelPiP  = FTFxsManager->GetElasticElementCrossSection( particle, KineticEnergy, 1, 0 );

     G4double XelPiN  = FTFxsManager->GetElasticElementCrossSection( PionPlus, KineticEnergy, 1, 0 );

     Xtotal   = ( NumberOfTargetProtons * XtotPiP + NumberOfTargetNeutrons * XtotPiN )

                / NumberOfTargetNucleons;

     Xelastic = ( NumberOfTargetProtons * XelPiP  + NumberOfTargetNeutrons * XelPiN )

                / NumberOfTargetNucleons;

     Xannihilation = 0.0;

     Xtotal /= millibarn;

     Xelastic /= millibarn;


   } else if ( ProjectilePDGcode == 111 ) {  // Projectile is PionZero


     G4ParticleDefinition* PionPlus = G4PionPlus::PionPlus();

     G4double XtotPipP = FTFxsManager->GetTotalElementCrossSection( PionPlus, KineticEnergy, 1, 0 );

     G4ParticleDefinition* PionMinus = G4PionMinus::PionMinus();

     G4double XtotPimP = FTFxsManager->GetTotalElementCrossSection( PionMinus, KineticEnergy, 1, 0 );

     G4double XelPipP = FTFxsManager->GetElasticElementCrossSection( PionPlus, KineticEnergy, 1, 0 );

     G4double XelPimP = FTFxsManager->GetElasticElementCrossSection( PionMinus, KineticEnergy, 1, 0 );

     G4double XtotPiP = ( XtotPipP + XtotPimP ) / 2.0;

     G4double XtotPiN = XtotPiP;

     G4double XelPiP = ( XelPipP  + XelPimP ) / 2.0;

     G4double XelPiN = XelPiP;

     Xtotal   = ( NumberOfTargetProtons * XtotPiP + NumberOfTargetNeutrons * XtotPiN )

                / NumberOfTargetNucleons;

     Xelastic = ( NumberOfTargetProtons * XelPiP  + NumberOfTargetNeutrons * XelPiN )

                / NumberOfTargetNucleons;

     Xannihilation = 0.0;

     Xtotal /= millibarn;

     Xelastic /= millibarn;


   } else if ( ProjectilePDGcode == 321 ) {  // Projectile is KaonPlus


     G4double XtotKP = FTFxsManager->GetTotalElementCrossSection( particle, KineticEnergy, 1, 0 );

     G4ParticleDefinition* KaonMinus = G4KaonMinus::KaonMinus();

     G4double XtotKN = FTFxsManager->GetTotalElementCrossSection( KaonMinus, KineticEnergy, 1, 0 );

     G4double XelKP  = FTFxsManager->GetElasticElementCrossSection( particle, KineticEnergy, 1, 0 );

     G4double XelKN  = FTFxsManager->GetElasticElementCrossSection( KaonMinus, KineticEnergy, 1, 0 );

     Xtotal   = ( NumberOfTargetProtons * XtotKP + NumberOfTargetNeutrons * XtotKN )

                / NumberOfTargetNucleons;

     Xelastic = ( NumberOfTargetProtons * XelKP  + NumberOfTargetNeutrons * XelKN )

                / NumberOfTargetNucleons;

     Xannihilation = 0.0;

     Xtotal /= millibarn;

     Xelastic /= millibarn;


   } else if ( ProjectilePDGcode == -321 ) {  // Projectile is KaonMinus


     G4double XtotKP = FTFxsManager->GetTotalElementCrossSection( particle, KineticEnergy, 1, 0 );

     G4ParticleDefinition* KaonPlus = G4KaonPlus::KaonPlus();

     G4double XtotKN = FTFxsManager->GetTotalElementCrossSection( KaonPlus, KineticEnergy, 1, 0 );

     G4double XelKP  = FTFxsManager->GetElasticElementCrossSection( particle, KineticEnergy, 1, 0 );

     G4double XelKN  = FTFxsManager->GetElasticElementCrossSection( KaonPlus, KineticEnergy, 1, 0 );

     Xtotal   = ( NumberOfTargetProtons * XtotKP + NumberOfTargetNeutrons * XtotKN )

                / NumberOfTargetNucleons;

     Xelastic = ( NumberOfTargetProtons * XelKP  + NumberOfTargetNeutrons * XelKN )

                / NumberOfTargetNucleons;

     Xannihilation = 0.0;

     Xtotal /= millibarn;

     Xelastic /= millibarn;


   } else if ( ProjectilePDGcode == 311  ||  ProjectilePDGcode == 130  ||

               ProjectilePDGcode == 310 ) {  // Projectile is KaonZero


     G4ParticleDefinition* KaonPlus = G4KaonPlus::KaonPlus();

     G4double XtotKpP = FTFxsManager->GetTotalElementCrossSection( KaonPlus, KineticEnergy, 1, 0 );

     G4ParticleDefinition* KaonMinus = G4KaonMinus::KaonMinus();

     G4double XtotKmP = FTFxsManager->GetTotalElementCrossSection( KaonMinus, KineticEnergy, 1, 0 );

     G4double XelKpP = FTFxsManager->GetElasticElementCrossSection( KaonPlus, KineticEnergy, 1, 0 );

     G4double XelKmP = FTFxsManager->GetElasticElementCrossSection( KaonMinus, KineticEnergy, 1, 0 );

     G4double XtotKP = ( XtotKpP + XtotKmP ) / 2.0;

     G4double XtotKN = XtotKP;

     G4double XelKP = ( XelKpP + XelKmP ) / 2.0;

     G4double XelKN = XelKP;

     Xtotal   = ( NumberOfTargetProtons * XtotKP + NumberOfTargetNeutrons * XtotKN )

                / NumberOfTargetNucleons;

     Xelastic = ( NumberOfTargetProtons * XelKP  + NumberOfTargetNeutrons * XelKN )

                / NumberOfTargetNucleons;

     Xannihilation = 0.0;

     Xtotal /= millibarn;

     Xelastic /= millibarn;


   } else {  // Projectile is undefined, Nucleon assumed


     G4ParticleDefinition* Proton = G4Proton::Proton();

     G4double XtotPP = FTFxsManager->GetTotalElementCrossSection( Proton, KineticEnergy, 1, 0 );

     G4ParticleDefinition* Neutron = G4Neutron::Neutron();

     G4double XtotPN = FTFxsManager->GetTotalElementCrossSection( Neutron, KineticEnergy, 1, 0 );

     G4double XelPP  = FTFxsManager->GetElasticElementCrossSection( Proton, KineticEnergy, 1, 0 );

     G4double XelPN  = FTFxsManager->GetElasticElementCrossSection( Neutron, KineticEnergy, 1, 0 );

     Xtotal   = ( NumberOfTargetProtons  * XtotPP + NumberOfTargetNeutrons * XtotPN )

                / NumberOfTargetNucleons;

     Xelastic = ( NumberOfTargetProtons  * XelPP  + NumberOfTargetNeutrons * XelPN )

                / NumberOfTargetNucleons;

     Xannihilation = 0.0;

     Xtotal /= millibarn;

     Xelastic /= millibarn;


   };


   // Geometrical parameters

   SetTotalCrossSection( Xtotal );

   SetElastisCrossSection( Xelastic );

   SetInelasticCrossSection( Xtotal - Xelastic );


   //G4cout << "Plab Xtotal, Xelastic Xinel Xftf " << Plab << " " << Xtotal << " " << Xelastic

   //       << " " << Xtotal - Xelastic << " " << Xtotal - Xelastic - Xannihilation << G4endl;

   //if (Xtotal - Xelastic != 0.0 ) {

   //  G4cout << "Plab Xelastic/Xtotal,  Xann/Xin " << Plab << " " << Xelastic/Xtotal

   //         << " " << Xannihilation / (Xtotal - Xelastic) << G4endl;

   //} else {

   //  G4cout << "Plab Xelastic/Xtotal,  Xann     " << Plab << " " << Xelastic/Xtotal

   //         << " " << Xannihilation << G4endl;

   //}

   //G4int Uzhi; G4cin >> Uzhi;


   // Interactions with elastic and inelastic collisions

   SetProbabilityOfElasticScatt( Xtotal, Xelastic );


 //G4cout<<"in PARAMS ProbabilityOfElasticScatt "<<GetProbabilityOfElasticScatt()<<G4endl; // Uzhi

 //SetProbabilityOfElasticScatt(0. * GetProbabilityOfElasticScatt());

 //G4cout<<"in PARAMS ProbabilityOfElasticScatt "<<GetProbabilityOfElasticScatt()<<G4endl;

 //{G4int Uzhi; G4cin>>Uzhi;}


   SetRadiusOfHNinteractions2( Xtotal/pi/10.0 );

   if ( Xtotal - Xelastic == 0.0 ) {

     SetProbabilityOfAnnihilation( 0.0 );

   } else {

     SetProbabilityOfAnnihilation( Xannihilation / (Xtotal - Xelastic) );

   }


   // No elastic scattering

   //SetProbabilityOfElasticScatt( Xtotal, 0.0 );

   //SetRadiusOfHNinteractions2( (Xtotal - Xelastic)/pi/10.0 );

   //SetProbabilityOfAnnihilation( 1.0 );

   //SetProbabilityOfAnnihilation( 0.0 );


   SetSlope( Xtotal*Xtotal/16.0/pi/Xelastic/0.3894 ); // Slope parameter of elastic scattering

                                                      // (GeV/c)^(-2))

   //G4cout << "Slope " << GetSlope() << G4endl;

   SetGamma0( GetSlope()*Xtotal/10.0/2.0/pi );


   // Parameters of elastic scattering

   // Gaussian parametrization of elastic scattering amplitude assumed

   SetAvaragePt2ofElasticScattering( 1.0/( Xtotal*Xtotal/16.0/pi/Xelastic/0.3894 )*GeV*GeV );

   //G4cout << "AvaragePt2ofElasticScattering " << GetAvaragePt2ofElasticScattering() << G4endl;


   // Parameters of excitations


   G4double Xinel = Xtotal - Xelastic;

   //G4cout << "Param ProjectilePDGcode " << ProjectilePDGcode << G4endl;


   if ( ProjectilePDGcode > 1000 ) {  // Projectile is baryon

     //        Proc#   A1      B1            A2       B2   A3   Atop       Ymin

     /* original hadr-string-diff-V10-03-07 (similar to 10.3.x)

     SetParams( 0,     13.71, 1.75,          -214.5, 4.25, 0.0, 0.5  ,     1.1 );  // Qexchange without Exc.

     SetParams( 1,      25.0, 1.0,           -50.34, 1.5 , 0.0, 0.0  ,     1.4 );  // Qexchange with    Exc.

     */

     // ---> JVY - update

     //

     SetParams( 0,     fParCollBaryonProj.GetProc0A1(),

                       fParCollBaryonProj.GetProc0B1(),

           fParCollBaryonProj.GetProc0A2(),

           fParCollBaryonProj.GetProc0B2(),

           fParCollBaryonProj.GetProc0A3(),

           fParCollBaryonProj.GetProc0Atop(),

           fParCollBaryonProj.GetProc0Ymin() );   // Qexchange without Exc.

     SetParams( 1,     fParCollBaryonProj.GetProc1A1(),

                       fParCollBaryonProj.GetProc1B1(),

           fParCollBaryonProj.GetProc1A2(),

           fParCollBaryonProj.GetProc1B2(),

           fParCollBaryonProj.GetProc1A3(),

           fParCollBaryonProj.GetProc1Atop(),

           fParCollBaryonProj.GetProc1Ymin() );   // Qexchange with Exc.

     // ---> end update

     if( Xinel > 0.) {

       SetParams( 2, 6.0/Xinel, 0.0 ,-6.0/Xinel*16.28, 3.0 , 0.0, 0.0  ,     0.93);// Projectile diffraction

       SetParams( 3, 6.0/Xinel, 0.0 ,-6.0/Xinel*16.28, 3.0 , 0.0, 0.0  ,     0.93);// Target diffraction

       /* original hadr-string-diff-V10-03-07

       SetParams( 4,       1.0, 0.0 ,          -2.01 , 0.5 , 0.0, 0.0  ,     1.4 );// Qexchange with Exc. Additional multiply

       */

       // JVY update

       SetParams( 4,     fParCollBaryonProj.GetProc4A1(),

                         fParCollBaryonProj.GetProc4B1(),

             fParCollBaryonProj.GetProc4A2(),

             fParCollBaryonProj.GetProc4B2(),

             fParCollBaryonProj.GetProc4A3(),

             fParCollBaryonProj.GetProc4Atop(),

             fParCollBaryonProj.GetProc4Ymin() );   // Qexchange with Exc. Additional multiply

       // ---> end update

     } else {

       SetParams( 2, 0.0, 0.0 ,0.0, 0.0 , 0.0, 0.0  ,     0.0);

       SetParams( 3, 0.0, 0.0 ,0.0, 0.0 , 0.0, 0.0  ,     0.0);

       SetParams( 4, 0.0, 0.0 ,0.0, 0.0 , 0.0, 0.0  ,     0.0);

     }


 //G4cout<<"fParCollBaryonProj.IsProjDiffDissociation() "<<fParCollBaryonProj.IsProjDiffDissociation()<<G4endl;

 //G4cout<<"fParCollBaryonProj.IsTgtDiffDissociation()  "<<fParCollBaryonProj.IsTgtDiffDissociation() <<G4endl;

 //{G4int Uzhi; G4cin>>Uzhi;}


 //    if ( AbsProjectileBaryonNumber > 1  ||  NumberOfTargetNucleons > 1 ) {

     if ( AbsProjectileBaryonNumber > 10  ||  NumberOfTargetNucleons > 10 ) {                          // Uzhi Dec. 2017 12 -> 10

       // It is not decided what to do with diffraction dissociation in Had-Nucl and Nucl-Nucl interactions

 //

       if ( ! fParCollBaryonProj.IsProjDiffDissociation() )

          SetParams( 2,       0.0, 0.0 ,           0.0  , 0.0 , 0.0, 0.0   , -100.0  );  // Projectile diffraction

       if ( ! fParCollBaryonProj.IsTgtDiffDissociation() )

          SetParams( 3,       0.0, 0.0 ,           0.0  , 0.0 , 0.0, 0.0   , -100.0  );  // Target diffraction

 //

     }


     /* original hadr-string-diff-V10-03-07

     SetDeltaProbAtQuarkExchange( 0.0 );

     if ( NumberOfTargetNucleons > 26 ) {

       SetProbOfSameQuarkExchange( 1.0);

     } else {

       SetProbOfSameQuarkExchange( 0.0 );

     }

     SetProjMinDiffMass( 1.16 );     // GeV

     SetProjMinNonDiffMass( 1.16 );  // GeV

     SetTarMinDiffMass( 1.16 );      // GeV

     SetTarMinNonDiffMass( 1.16 );   // GeV

     SetAveragePt2( 0.15 );          // GeV^2

     SetProbLogDistrPrD( 0.3 );      // Before it was: 0.5

     SetProbLogDistr(0.3 );          // Before it was: 0.5

     */

     // ---> JVY - update


     SetDeltaProbAtQuarkExchange( fParCollBaryonProj.GetDeltaProbAtQuarkExchange() );

     if ( NumberOfTargetNucleons > 26 ) {

       SetProbOfSameQuarkExchange( 1.0);

     } else {

       SetProbOfSameQuarkExchange( fParCollBaryonProj.GetProbOfSameQuarkExchange() );

     }

     SetProjMinDiffMass( fParCollBaryonProj.GetProjMinDiffMass() );     // GeV

     SetProjMinNonDiffMass( fParCollBaryonProj.GetProjMinNonDiffMass() );  // GeV

     SetTarMinDiffMass( fParCollBaryonProj.GetTgtMinDiffMass() );      // GeV

     SetTarMinNonDiffMass( fParCollBaryonProj.GetTgtMinNonDiffMass() );   // GeV

     SetAveragePt2( fParCollBaryonProj.GetAveragePt2() );           // GeV^2

     SetProbLogDistrPrD( fParCollBaryonProj.GetProbLogDistrPrD() );

     SetProbLogDistr( fParCollBaryonProj.GetProbLogDistr() );

     // ---> end update


   } else if( ProjectilePDGcode < -1000 ) {  // Projectile is anti_baryon


     //        Proc#   A1      B1            A2       B2   A3   Atop       Ymin

     SetParams( 0,      0.0 , 0.0 ,           0.0  , 0.0 , 0.0, 0.0  ,  1000.0  );  // Qexchange without Exc.

     SetParams( 1,      0.0 , 0.0 ,           0.0  , 0.0 , 0.0, 0.0  ,  1000.0  );  // Qexchange with    Exc.

     if( Xinel > 0.) {

       SetParams( 2, 6.0/Xinel, 0.0 ,-6.0/Xinel*16.28, 3.0 , 0.0, 0.0  ,     0.93);  // Projectile diffraction

       SetParams( 3, 6.0/Xinel, 0.0 ,-6.0/Xinel*16.28, 3.0 , 0.0, 0.0  ,     0.93);  // Target diffraction

       SetParams( 4,       1.0, 0.0 ,             0.0, 0.0 , 0.0, 0.0  ,    0.93 );  // Qexchange with    Exc. Additional multiply

     } else {

       SetParams( 2, 0.0, 0.0 ,0.0, 0.0 , 0.0, 0.0  ,     0.0);

       SetParams( 3, 0.0, 0.0 ,0.0, 0.0 , 0.0, 0.0  ,     0.0);

       SetParams( 4, 0.0, 0.0 ,0.0, 0.0 , 0.0, 0.0  ,     0.0);

     }


     if ( AbsProjectileBaryonNumber > 10  ||  NumberOfTargetNucleons > 10 ) {   // Uzhi Dec. 2017

       SetParams( 2,      0.0 , 0.0 ,           0.0  , 0.0 , 0.0, 0.0  ,  -100.0  );  // Projectile diffraction

       SetParams( 3,      0.0 , 0.0 ,           0.0  , 0.0 , 0.0, 0.0  ,  -100.0  );  // Target diffraction  Uzhi Dec. 2017

     }


     SetDeltaProbAtQuarkExchange( 0.0 );

     SetProbOfSameQuarkExchange( 0.0 );

     SetProjMinDiffMass( ProjectileMass + 0.22 );     // GeV

     SetProjMinNonDiffMass( ProjectileMass + 0.22 );  // GeV

     SetTarMinDiffMass( TargetMass + 0.22 );          // GeV

     SetTarMinNonDiffMass( TargetMass + 0.22 );       // GeV

     SetAveragePt2( 0.3 );                            // GeV^2

     SetProbLogDistrPrD( 0.55 );

     SetProbLogDistr( 0.55 );


   } else if ( ProjectileabsPDGcode == 211  ||  ProjectilePDGcode ==  111 ) {  // Projectile is Pion


     //        Proc#   A1      B1            A2       B2   A3   Atop       Ymin

     SetParams( 0,  150.0,    1.8 ,       -247.3,     2.3,    0.,   1. ,       2.3 );  // Uzhi July 2017

     SetParams( 1,   5.77,    0.6 ,        -5.77,     0.8,    0.,   0. ,       0.0 );

     SetParams( 2,   2.27,    0.5 ,     -98052.0,     4.0,    0.,   0. ,       3.0 );

     SetParams( 3,    7.0,    0.9,        -85.28,     1.9,  0.08,   0. ,       2.2 );

     SetParams( 4,    1.0,    0.0 ,       -11.02,     1.0,   0.0,   0. ,       2.4 );  // Qexchange with    Exc. Additional multiply


     if ( AbsProjectileBaryonNumber > 10  ||  NumberOfTargetNucleons > 10 ) {         // Uzhi Dec. 2017

       SetParams( 2,      0.0 , 0.0 ,           0.0  , 0.0 , 0.0, 0.0  ,  -100.0  );  // Projectile diffraction

       SetParams( 3,      0.0 , 0.0 ,           0.0  , 0.0 , 0.0, 0.0  ,  -100.0  );  // Target diffraction      Uzhi Dec. 2017-

     }


     SetDeltaProbAtQuarkExchange( 0.56 );  // (0.35)

     SetProjMinDiffMass( 1.0 );            // (0.5)  // GeV   Uzhi July 2017

     SetProjMinNonDiffMass( 1.0 );         // (0.5)  // GeV   Uzhi July 2017

     SetTarMinDiffMass( 1.16 );                      // GeV

     SetTarMinNonDiffMass( 1.16 );                   // GeV

     SetAveragePt2( 0.3 );                           // GeV^2 Uzhi July 2017

     SetProbLogDistrPrD( 0.55 );                         //   Uzhi July 2017

     SetProbLogDistr( 0.55 );                            //   Uzhi July 2017


   } else if ( ProjectileabsPDGcode == 321  ||  ProjectileabsPDGcode == 311  ||

               ProjectilePDGcode == 130     ||  ProjectilePDGcode == 310 ) {  // Projectile is Kaon


     //        Proc#   A1      B1            A2       B2   A3   Atop       Ymin

     SetParams( 0,     60.0 , 2.5 ,           0.0  , 0.0 , 0.0, 0.0  ,  -100.0  );  // Qexchange without Exc.

     SetParams( 1,      6.0 , 1.0 ,         -24.33 , 2.0 , 0.0, 0.0  ,     1.40 );  // Qexchange with    Exc.

     SetParams( 2,      2.76, 1.2 ,         -22.5  , 2.7 ,0.04, 0.0  ,     1.40 );  // Projectile diffraction

     SetParams( 3,      1.09, 0.5 ,          -8.88 , 2.  ,0.05, 0.0  ,     1.40 );  // Target diffraction

     SetParams( 4,       1.0, 0.0 ,           0.0  , 0.0 , 0.0, 0.0  ,     0.93 );  // Qexchange with    Exc. Additional multiply


     if ( AbsProjectileBaryonNumber > 10  ||  NumberOfTargetNucleons > 10 ) {     // Uzhi Dec. 2017

       SetParams( 2,      0.0 , 0.0 ,           0.0  , 0.0 , 0.0, 0.0  ,  -100.0  );  // Projectile diffraction

       SetParams( 3,      0.0 , 0.0 ,           0.0  , 0.0 , 0.0, 0.0  ,  -100.0  );  // Target diffraction // Uzhi Dec. 2017

     }


     SetDeltaProbAtQuarkExchange( 0.6 );

     SetProjMinDiffMass( 0.7 );     // (1.4) // (0.7) // GeV

     SetProjMinNonDiffMass( 0.7 );  // (1.4) // (0.7) // GeV

     SetTarMinDiffMass( 1.16 );                       // GeV

     SetTarMinNonDiffMass( 1.16 );                    // GeV

     SetAveragePt2( 0.3 );                            // GeV^2 // Uzhi Dec. 2017

     SetProbLogDistrPrD( 0.55 );                               // Uzhi Dec. 2017

     SetProbLogDistr( 0.55 );                                  // Uzhi Dec. 2017


    } else {  // Projectile is undefined, Nucleon assumed


     //        Proc#   A1      B1            A2       B2   A3   Atop       Ymin

     SetParams( 0,     13.71, 1.75,          -30.69, 3.0 , 0.0, 1.0  ,     0.93 );   // Qexchange without Exc.  // Uzhi Dec. 2017

     SetParams( 1,      25.0, 1.0,          -50.34,  1.5 , 0.0, 0.0  ,     1.4 );  // Qexchange with    Exc.

     if( Xinel > 0.) {

       SetParams( 2, 6.0/Xinel, 0.0 ,-6.0/Xinel*16.28, 3.0 , 0.0, 0.0  ,   0.93);  // Projectile diffraction

       SetParams( 3, 6.0/Xinel, 0.0 ,-6.0/Xinel*16.28, 3.0 , 0.0, 0.0  ,   0.93);  // Target diffraction

       SetParams( 4,       1.0, 0.0 ,          -2.01 , 0.5 , 0.0, 0.0  ,   1.4 );  // Qexchange with    Exc. Additional multiply

     } else {

       SetParams( 2, 0.0, 0.0 ,0.0, 0.0 , 0.0, 0.0  ,     0.0);

       SetParams( 3, 0.0, 0.0 ,0.0, 0.0 , 0.0, 0.0  ,     0.0);

       SetParams( 4, 0.0, 0.0 ,0.0, 0.0 , 0.0, 0.0  ,     0.0);

     }

     if ( AbsProjectileBaryonNumber > 10  ||  NumberOfTargetNucleons > 10 ) {         // Uzhi Dec. 2017 12 -> 10

       SetParams( 2,      0.0 , 0.0 ,            0.0 , 0.0 , 0.0, 0.0  ,  -100.0  );  // Projectile diffraction

       SetParams( 3,      0.0 , 0.0 ,            0.0 , 0.0 , 0.0, 0.0  ,  -100.0  );  // Target diffraction   // Uzhi Dec. 2017

     }

     SetDeltaProbAtQuarkExchange( 0.0 );              // 7 June 2011

     SetProbOfSameQuarkExchange( 0.0 );

     SetProjMinDiffMass( ProjectileMass + 0.22 );     // GeV

     SetProjMinNonDiffMass( ProjectileMass + 0.22 );  // GeV

     SetTarMinDiffMass( TargetMass + 0.22 );          // GeV

     SetTarMinNonDiffMass( TargetMass + 0.22 );       // GeV

     SetAveragePt2( 0.3 );                            // GeV^2  // Uzhi Dec. 2017

     SetProbLogDistrPrD( 0.55 );                                // Uzhi Dec. 2017

     SetProbLogDistr( 0.55 );                                   // Uzhi Dec. 2017


   }


   // Set parameters of a string kink

   //  SetPt2Kink( 6.0*GeV*GeV );

   SetPt2Kink( 0.0*GeV*GeV );  // Uzhi Oct 2014 to switch off kinky strings

   G4double Puubar( 1.0/3.0 ), Pddbar( 1.0/3.0 ), Pssbar( 1.0/3.0 );  // SU(3) symmetry

   //G4double Puubar( 0.41 ), Pddbar( 0.41 ), Pssbar( 0.18 );  // Broken SU(3) symmetry

   SetQuarkProbabilitiesAtGluonSplitUp( Puubar, Pddbar, Pssbar );


   // Set parameters of nuclear destruction

   if ( ProjectileabsPDGcode < 1000 ) {  // Meson projectile

     SetMaxNumberOfCollisions( Plab, 2.0 );  //  3.0 )

 //    SetCofNuclearDestruction( 1.0*                                                                  // AR-18May2016

     SetCofNuclearDestruction( 0.00481*G4double(NumberOfTargetNucleons)*         // Uzhi 3.05.2015   // Uzhi Dec. 2017

             G4Exp( 4.0*(Ylab - 2.1) )/( 1.0 + G4Exp( 4.0*(Ylab - 2.1) ) ) );

     SetR2ofNuclearDestruction( 1.5*fermi*fermi );

     SetDofNuclearDestruction( 0.3 );

     SetPt2ofNuclearDestruction( ( 0.035 + 0.04*G4Exp( 4.0*(Ylab - 2.5) )/

                                          ( 1.0 + G4Exp( 4.0*(Ylab - 2.5) ) ) )*GeV*GeV );

     SetMaxPt2ofNuclearDestruction( 1.0*GeV*GeV );

     SetExcitationEnergyPerWoundedNucleon( 40.0*MeV );

   } else if ( ProjectilePDGcode < -1000 ) {  // for anti-baryon projectile

     SetMaxNumberOfCollisions( Plab, 2.0 );  // 3.0 )

 //    SetCofNuclearDestruction( 1.0*                                                                   // AR-18May2016

     SetCofNuclearDestruction( 0.00481*G4double(NumberOfTargetNucleons)*             // Uzhi 3.05.2015  // Uzhi Dec. 2017

            G4Exp( 4.0*(Ylab - 2.1) )/( 1.0 + G4Exp( 4.0*(Ylab - 2.1) ) ) );

     SetR2ofNuclearDestruction( 1.5*fermi*fermi );

     SetDofNuclearDestruction( 0.3 );

     SetPt2ofNuclearDestruction( ( 0.035 + 0.04*G4Exp( 4.0*(Ylab - 2.5) )/

                                          ( 1.0 + G4Exp( 4.0*(Ylab - 2.5) ) ) )*GeV*GeV );

     SetMaxPt2ofNuclearDestruction( 1.0*GeV*GeV );

     SetExcitationEnergyPerWoundedNucleon( 40.0*MeV );

     if ( Plab < 2.0 ) {  // 2 GeV/c

       // For slow anti-baryon we have to garanty putting on mass-shell

       SetCofNuclearDestruction( 0.0 );

       SetR2ofNuclearDestruction( 1.5*fermi*fermi );

       SetDofNuclearDestruction( 0.01 );

       SetPt2ofNuclearDestruction( 0.035*GeV*GeV );

       SetMaxPt2ofNuclearDestruction( 0.04*GeV*GeV );

       //SetExcitationEnergyPerWoundedNucleon( 0.0 );   // ?????

     }

   } else {  // Projectile baryon assumed


     // NOTE: FIXME !!! (JVY) Will decide later how/if to make this one configurable...

     //

     SetMaxNumberOfCollisions( Plab, 2.0 ); // 3.0 )


     /* original hadr-string-diff-V10-03-07

     //AR-18May2016  SetCofNuclearDestructionPr( 0.00481*G4double(AbsProjectileBaryonNumber)*           // Uzhi 3.05.2015

     SetCofNuclearDestructionPr( 1.0*                                                                   // AR-18May2016

             G4Exp( 4.0*(Ylab - 2.1) )/( 1.0 + G4Exp( 4.0*(Ylab - 2.1) ) ) );

     //AR-18May2016  SetCofNuclearDestruction(   0.00481*G4double(NumberOfTargetNucleons)*             // Uzhi 3.05.2015

     SetCofNuclearDestruction(   1.0*                                                                  // AR-18May2016

             G4Exp( 4.0*(Ylab - 2.1) )/( 1.0 + G4Exp( 4.0*(Ylab - 2.1) ) ) );

     SetR2ofNuclearDestruction( 1.5*fermi*fermi );

     SetDofNuclearDestruction( 0.3 );

     SetPt2ofNuclearDestruction( ( 0.035 + 0.04*G4Exp( 4.0*(Ylab - 2.5) )/

                                          ( 1.0 + G4Exp( 4.0*(Ylab - 2.5) ) ) )*GeV*GeV );

     SetMaxPt2ofNuclearDestruction( 1.0*GeV*GeV );

     SetExcitationEnergyPerWoundedNucleon( 40.0*MeV );

     */


     // ---> JVY - update

     //

     // projectile destruction - does NOT matter for particle projectile, only for a nucleus projectile

     //

     double coeff = 0.;

     coeff = fParCollBaryonProj.GetNuclearProjDestructP1();

     //

     // NOTE (JVY): Set this switch to false/true on line 136

     //

     if ( fParCollBaryonProj.IsNuclearProjDestructP1_NBRNDEP() )

     {

       coeff *= G4double(AbsProjectileBaryonNumber);

     }

     double exfactor = G4Exp( fParCollBaryonProj.GetNuclearProjDestructP2()*(Ylab-fParCollBaryonProj.GetNuclearProjDestructP3()) );

     coeff *= exfactor;

     coeff /= ( 1.+ exfactor );

     SetCofNuclearDestructionPr( coeff );

     //

     // target desctruction

     coeff = fParCollBaryonProj.GetNuclearTgtDestructP1();

     //

     // NOTE (JVY): Set this switch to false/true on line 138

     //

     if ( fParCollBaryonProj.IsNuclearTgtDestructP1_ADEP() )

     {

       coeff *= G4double(NumberOfTargetNucleons);

     }

     exfactor = G4Exp( fParCollBaryonProj.GetNuclearTgtDestructP2()*(Ylab-fParCollBaryonProj.GetNuclearTgtDestructP3()) );

     coeff *= exfactor;

     coeff /= ( 1.+ exfactor );

     SetCofNuclearDestruction(   coeff );

     //

     SetR2ofNuclearDestruction( fParCollBaryonProj.GetR2ofNuclearDestruct() );

     SetDofNuclearDestruction( fParCollBaryonProj.GetDofNuclearDestruct() );

     //

     coeff = fParCollBaryonProj.GetPt2NuclearDestructP2();

     exfactor = G4Exp( fParCollBaryonProj.GetPt2NuclearDestructP3()*(Ylab-fParCollBaryonProj.GetPt2NuclearDestructP4())  );

     coeff *= exfactor;

     coeff /= ( 1. + exfactor );

     SetPt2ofNuclearDestruction( (fParCollBaryonProj.GetPt2NuclearDestructP1()+coeff)*CLHEP::GeV*CLHEP::GeV );

     //

     SetMaxPt2ofNuclearDestruction( fParCollBaryonProj.GetMaxPt2ofNuclearDestruct() );

     SetExcitationEnergyPerWoundedNucleon( fParCollBaryonProj.GetExciEnergyPerWoundedNucleon() );

     // end of update


   }


   //SetCofNuclearDestruction( 0.47*G4Exp( 2.0*(Ylab - 2.5) )/( 1.0 + G4Exp( 2.0*(Ylab - 2.5) ) ) );

   //SetPt2ofNuclearDestruction( ( 0.035 + 0.1*G4Exp( 4.0*(Ylab - 3.0) )/( 1.0 + G4Exp( 4.0*(Ylab - 3.0) ) ) )*GeV*GeV );


   //SetMagQuarkExchange( 120.0 );       // 210.0 PipP

   //SetSlopeQuarkExchange( 2.0 );

   //SetDeltaProbAtQuarkExchange( 0.6 );

   //SetProjMinDiffMass( 0.7 );          // GeV 1.1

   //SetProjMinNonDiffMass( 0.7 );       // GeV

   //SetProbabilityOfProjDiff( 0.0);     // 0.85*G4Pow::GetInstance()->powA( s/GeV/GeV, -0.5 ) ); // 40/32 X-dif/X-inel

   //SetTarMinDiffMass( 1.1 );           // GeV

   //SetTarMinNonDiffMass( 1.1 );        // GeV

   //SetProbabilityOfTarDiff( 0.0 );     // 0.85*G4Pow::GetInstance()->powA( s/GeV/GeV, -0.5 ) ); // 40/32 X-dif/X-inel


   //SetAveragePt2( 0.0 );               // GeV^2   0.3

   //------------------------------------

   //SetProbabilityOfElasticScatt( 1.0, 1.0);                            //(Xtotal, Xelastic);

   //SetProbabilityOfProjDiff( 1.0*0.62*G4Pow::GetInstance()->powA( s/GeV/GeV, -0.51 ) );  // 0->1

   //SetProbabilityOfTarDiff( 4.0*0.62*G4Pow::GetInstance()->powA( s/GeV/GeV, -0.51 ) );   // 2->4

   //SetAveragePt2( 0.3 );                                               // (0.15)

   //SetAvaragePt2ofElasticScattering( 0.0 );


   //SetMaxNumberOfCollisions( Plab, 6.0 ); //(4.0*(Plab + 0.01), Plab); // 6.0 );

   //SetAveragePt2( 0.15 );

   //SetCofNuclearDestruction(-1.);//( 0.75 );                           // (0.25)

   //SetExcitationEnergyPerWoundedNucleon(0.);//( 30.0*MeV );            // (75.0*MeV)

   //SetDofNuclearDestruction(0.);//( 0.2 ); //0.4                       // 0.3 0.5


 /*    Uzhi Nov. 20

 //SetAveragePt2(0.1);

 SetCofNuclearDestructionPr(0.);

 SetCofNuclearDestruction(0.);//( 0.5 );                           // (0.25)

 //SetExcitationEnergyPerWoundedNucleon(0.);//( 30.0*MeV );                    // (75.0*MeV)

 SetDofNuclearDestruction(0.);//( 0.2 ); //0.4                                     // 0.3 0.5

 SetPt2ofNuclearDestruction(0.);//(2.*0.075*GeV*GeV); //( 0.3*GeV*GeV ); // (0.168*GeV*GeV)

 */


 //SetMaxNumberOfCollisions( Plab, 4.0 ); // 3.0 )


 //SetRadiusOfHNinteractions2( Xtotal/pi/10.0 /2.);

 /*

 G4cout << "Pt2 " << GetAveragePt2()<<" "<<GetAveragePt2()/GeV/GeV<<G4endl;

 G4cout << "Cnd " << GetCofNuclearDestruction() << G4endl;

 G4cout << "Dnd " << GetDofNuclearDestruction() << G4endl;

 G4cout << "Pt2 " << GetPt2ofNuclearDestruction()/GeV/GeV << G4endl;

 G4int Uzhi; G4cin >> Uzhi;

 */


 }


 //============================================================================


 G4double G4FTFParameters::GetProcProb( const G4int ProcN, const G4double y ) {

   G4double Prob( 0.0 );

   if ( y < ProcParams[ProcN][6] ) {

     Prob = ProcParams[ProcN][5];

     if(Prob < 0.) Prob=0.;

     return Prob;

   }

   Prob = ProcParams[ProcN][0] * G4Exp( -ProcParams[ProcN][1]*y ) +

          ProcParams[ProcN][2] * G4Exp( -ProcParams[ProcN][3]*y ) +

          ProcParams[ProcN][4];

   if(Prob < 0.) Prob=0.;

   return Prob;

 }

G4FTFParamCollection::fProc4A3
double fProc4A3
Definition: G4FTFParameters.hh:177

G4FTFParameters::GetProcProb
G4double GetProcProb(const G4int ProcN, const G4double y)
Definition: G4FTFParameters.cc:1247

G4FTFParamCollection::fProc4A1
double fProc4A1
Definition: G4FTFParameters.hh:173

G4PionMinus::PionMinus
static G4PionMinus * PionMinus()
Definition: G4PionMinus.cc:98

G4FTFParameters::SetMaxNumberOfCollisions
void SetMaxNumberOfCollisions(const G4double aValue, const G4double bValue)
Definition: G4FTFParameters.hh:547

G4FTFParameters::SetSlope
void SetSlope(const G4double Slope)
Definition: G4FTFParameters.hh:471

G4Exp
G4double G4Exp(G4double initial_x)
Exponential Function double precision.
Definition: G4Exp.hh:183

G4PhysicalConstants.hh

G4FTFParamCollection::GetProc0A2
double GetProc0A2() const
Definition: G4FTFParameters.hh:61

G4FTFParamCollection::fPt2NuclearDestructP2
double fPt2NuclearDestructP2
Definition: G4FTFParameters.hh:220

G4FTFParameters::FTFGamma0
G4double FTFGamma0
Definition: G4FTFParameters.hh:378

G4FTFParameters::SetCofNuclearDestructionPr
void SetCofNuclearDestructionPr(const G4double aValue)
Definition: G4FTFParameters.hh:564

G4FTFParameters::R2ofNuclearDestruction
G4double R2ofNuclearDestruction
Definition: G4FTFParameters.hh:405

G4FTFParamCollection::fNuclearTgtDestructP3
double fNuclearTgtDestructP3
Definition: G4FTFParameters.hh:217

G4FTFParamCollection::IsProjDiffDissociation
bool IsProjDiffDissociation() const
Definition: G4FTFParameters.hh:72

G4FTFParamCollection::GetProc1B1
double GetProc1B1() const
Definition: G4FTFParameters.hh:76

G4FTFParameters::SetElastisCrossSection
void SetElastisCrossSection(const G4double Xelastic)
Definition: G4FTFParameters.hh:442

G4FTFParamCollection::fProbLogDistrPrD
double fProbLogDistrPrD
Definition: G4FTFParameters.hh:190

G4FTFParamCollection::GetProc1Atop
double GetProc1Atop() const
Definition: G4FTFParameters.hh:80

G4FTFParameters::SetPt2Kink
void SetPt2Kink(const G4double aValue)
Definition: G4FTFParameters.hh:534

G4FTFParameters::ProbOfInelInteraction
G4double ProbOfInelInteraction
Definition: G4FTFParameters.hh:401

G4FTFParamCollection::fNuclearProjDestructP1
double fNuclearProjDestructP1
Definition: G4FTFParameters.hh:205

G4FTFParamCollection::GetProbOfSameQuarkExchange
double GetProbOfSameQuarkExchange() const
Definition: G4FTFParameters.hh:95

G4FTFParamCollection::fProc4B2
double fProc4B2
Definition: G4FTFParameters.hh:176

G4FTFParamCollection::fPt2NuclearDestructP1
double fPt2NuclearDestructP1
Definition: G4FTFParameters.hh:219

G4FTFParamCollection::fProbLogDistr
double fProbLogDistr
Definition: G4FTFParameters.hh:191

MeV
static constexpr double MeV
Definition: G4SIunits.hh:214

G4FTFParameters::SetProjMinNonDiffMass
void SetProjMinNonDiffMass(const G4double aValue)
Definition: G4FTFParameters.hh:508

G4FTFParamCollection::GetProc0B2
double GetProc0B2() const
Definition: G4FTFParameters.hh:62

G4FTFParamCollection::fProc1B1
double fProc1B1
Definition: G4FTFParameters.hh:154

G4FTFParamCollection::fDofNuclearDestruct
double fDofNuclearDestruct
Definition: G4FTFParameters.hh:226

G4FTFParamCollection::GetProc0A1
double GetProc0A1() const
Definition: G4FTFParameters.hh:59

G4FTFParamCollection::G4FTFParamCollection
G4FTFParamCollection()
Definition: G4FTFParameters.cc:167

G4FTFParamCollection::IsTgtDiffDissociation
bool IsTgtDiffDissociation() const
Definition: G4FTFParameters.hh:73

G4ChipsComponentXS
Definition: G4ChipsComponentXS.hh:76

G4FTFParameters::DofNuclearDestruction
G4double DofNuclearDestruction
Definition: G4FTFParameters.hh:409

G4ios.hh

G4FTFParamCollection::fTgtMinDiffMass
double fTgtMinDiffMass
Definition: G4FTFParameters.hh:187

G4FTFParamCollection::fProc0Atop
double fProc0Atop
Definition: G4FTFParameters.hh:150

G4endl
#define G4endl
Definition: G4ios.hh:61

y
Float_t y
Definition: compare.C:6

G4FTFParamCollection::GetPt2NuclearDestructP4
double GetPt2NuclearDestructP4() const
Definition: G4FTFParameters.hh:121

G4FTFParamCollection::fPt2NuclearDestructP3
double fPt2NuclearDestructP3
Definition: G4FTFParameters.hh:221

G4FTFParamCollection::fProc0A3
double fProc0A3
Definition: G4FTFParameters.hh:149

G4ChipsComponentXS::GetElasticElementCrossSection
virtual G4double GetElasticElementCrossSection(const G4ParticleDefinition *aParticle, G4double kinEnergy, G4int Z, G4double N)
Definition: G4ChipsComponentXS.cc:191

G4FTFParameters::FTFSlope
G4double FTFSlope
Definition: G4FTFParameters.hh:376

G4FTFParameters::SetCofNuclearDestruction
void SetCofNuclearDestruction(const G4double aValue)
Definition: G4FTFParameters.hh:568

G4FTFParamCollection::fDeltaProbAtQuarkExchange
double fDeltaProbAtQuarkExchange
Definition: G4FTFParameters.hh:183

G4FTFParamCollection::GetNuclearProjDestructP1
double GetNuclearProjDestructP1() const
Definition: G4FTFParameters.hh:110

G4FTFParamCollection::GetProc4A1
double GetProc4A1() const
Definition: G4FTFParameters.hh:85

G4FTFParameters::SetProbabilityOfElasticScatt
void SetProbabilityOfElasticScatt(const G4double Xtotal, const G4double Xelastic)
Definition: G4FTFParameters.hh:450

G4PionPlus::PionPlus
static G4PionPlus * PionPlus()
Definition: G4PionPlus.cc:98

G4FTFParamCollection::GetPt2NuclearDestructP3
double GetPt2NuclearDestructP3() const
Definition: G4FTFParameters.hh:120

G4FTFParamCollection::fTgtDiffDissociation
bool fTgtDiffDissociation
Definition: G4FTFParameters.hh:170

G4FTFParameters::ProbLogDistrPrD
G4double ProbLogDistrPrD
Definition: G4FTFParameters.hh:388

G4FTFParamCollection::GetProc1A1
double GetProc1A1() const
Definition: G4FTFParameters.hh:75

G4ParticleDefinition::GetPDGCharge
G4double GetPDGCharge() const
Definition: G4ParticleDefinition.hh:125

G4FTFParameters::chipsComponentXSinstance
static G4ThreadLocal G4ChipsComponentXS * chipsComponentXSinstance
Definition: G4FTFParameters.hh:424

G4HadronicDeveloperParameters::SetDefault
G4bool SetDefault(const std::string name, const G4bool value)
Definition: G4HadronicDeveloperParameters.cc:39

G4FTFParameters::AvaragePt2ofElasticScattering
G4double AvaragePt2ofElasticScattering
Definition: G4FTFParameters.hh:377

G4FTFParamCollection::fProjMinDiffMass
double fProjMinDiffMass
Definition: G4FTFParameters.hh:185

G4FTFSettingDefaultHDP::G4FTFSettingDefaultHDP
G4FTFSettingDefaultHDP()
Definition: G4FTFParameters.cc:60

G4FTFParamCollection::fProc1Ymin
double fProc1Ymin
Definition: G4FTFParameters.hh:159

G4FTFParamCollection::GetProc4A3
double GetProc4A3() const
Definition: G4FTFParameters.hh:89

G4FTFParamCollection::fR2ofNuclearDestruct
double fR2ofNuclearDestruct
Definition: G4FTFParameters.hh:224

G4FTFParameters::MaxNumberOfCollisions
G4double MaxNumberOfCollisions
Definition: G4FTFParameters.hh:400

G4FTFParamCollection::GetNuclearTgtDestructP1
double GetNuclearTgtDestructP1() const
Definition: G4FTFParameters.hh:112

G4Pow.hh

G4FTFParamCollection::fProc0A1
double fProc0A1
Definition: G4FTFParameters.hh:145

G4FTFParameters::InitForInteraction
void InitForInteraction(const G4ParticleDefinition *, G4int theA, G4int theZ, G4double s)
Definition: G4FTFParameters.cc:475

G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:93

G4FTFParamCollection::GetNuclearTgtDestructP2
double GetNuclearTgtDestructP2() const
Definition: G4FTFParameters.hh:116

G4FTFParamCollection::fExciEnergyPerWoundedNucleon
double fExciEnergyPerWoundedNucleon
Definition: G4FTFParameters.hh:225

G4KaonMinus::KaonMinus
static G4KaonMinus * KaonMinus()
Definition: G4KaonMinus.cc:113

G4FTFParamCollection::GetProbLogDistrPrD
double GetProbLogDistrPrD() const
Definition: G4FTFParameters.hh:101

G4ThreadLocal
#define G4ThreadLocal
Definition: tls.hh:69

G4FTFParamCollection::fPt2NuclearDestructP4
double fPt2NuclearDestructP4
Definition: G4FTFParameters.hh:222

G4ParticleDefinition::GetPDGMass
G4double GetPDGMass() const
Definition: G4ParticleDefinition.hh:123

G4KaonPlus::KaonPlus
static G4KaonPlus * KaonPlus()
Definition: G4KaonPlus.cc:113

G4FTFParamCollection::GetPt2NuclearDestructP1
double GetPt2NuclearDestructP1() const
Definition: G4FTFParameters.hh:118

G4Log
G4double G4Log(G4double x)
Definition: G4Log.hh:230

G4FTFParameters::SetTarMinDiffMass
void SetTarMinDiffMass(const G4double aValue)
Definition: G4FTFParameters.hh:512

S
double S(double temp)
Definition: G4DNAElectronHoleRecombination.cc:77

G4FTFParameters::AveragePt2
G4double AveragePt2
Definition: G4FTFParameters.hh:392

G4FTFParameters::chipsComponentXSisInitialized
static G4ThreadLocal bool chipsComponentXSisInitialized
Definition: G4FTFParameters.hh:423

HDP
G4HadronicDeveloperParameters & HDP
Definition: G4FTFParameters.cc:55

G4FTFParameters::ProbabilityOfAnnihilation
G4double ProbabilityOfAnnihilation
Definition: G4FTFParameters.hh:373

G4FTFParameters::SetR2ofNuclearDestruction
void SetR2ofNuclearDestruction(const G4double aValue)
Definition: G4FTFParameters.hh:572

G4FTFParameters::SetProbLogDistrPrD
void SetProbLogDistrPrD(const G4double aValue)
Definition: G4FTFParameters.hh:524

G4FTFParamCollection::GetProc1Ymin
double GetProc1Ymin() const
Definition: G4FTFParameters.hh:81

G4Exp.hh

Proton
Definition: G4RadioactiveDecayMode.hh:68

G4FTFParamCollection::fProc4Ymin
double fProc4Ymin
Definition: G4FTFParameters.hh:179

CLHEP::fermi
static constexpr double fermi
Definition: SystemOfUnits.h:83

G4FTFParamCollection::GetProc0A3
double GetProc0A3() const
Definition: G4FTFParameters.hh:63

G4FTFParameters::FTFXelastic
G4double FTFXelastic
Definition: G4FTFParameters.hh:370

G4FTFParamCollection::fNuclearTgtDestructP1_ADEP
bool fNuclearTgtDestructP1_ADEP
Definition: G4FTFParameters.hh:213

G4FTFParamCollection::fProc1A3
double fProc1A3
Definition: G4FTFParameters.hh:157

G4double
double G4double
Definition: G4Types.hh:76

G4bool
bool G4bool
Definition: G4Types.hh:79

fermi
static constexpr double fermi
Definition: G4SIunits.hh:103

G4FTFParamCollection::fProc4Atop
double fProc4Atop
Definition: G4FTFParameters.hh:178

G4FTFParameters::SetAvaragePt2ofElasticScattering
void SetAvaragePt2ofElasticScattering(const G4double aPt2)
Definition: G4FTFParameters.hh:480

millibarn
static constexpr double millibarn
Definition: G4SIunits.hh:106

G4Pow::GetInstance
static G4Pow * GetInstance()
Definition: G4Pow.cc:57

G4KaonPlus.hh

G4FTFParamCollection::fProc4B1
double fProc4B1
Definition: G4FTFParameters.hh:174

G4FTFParameters::~G4FTFParameters
~G4FTFParameters()
Definition: G4FTFParameters.cc:425

G4FTFParameters::SetProbOfSameQuarkExchange
void SetProbOfSameQuarkExchange(const G4double aValue)
Definition: G4FTFParameters.hh:500

G4PionPlus.hh

G4FTFParamCollection::GetProc4Ymin
double GetProc4Ymin() const
Definition: G4FTFParameters.hh:91

G4Pow::powA
G4double powA(G4double A, G4double y) const
Definition: G4Pow.hh:242

G4FTFParamCollection::GetProc4Atop
double GetProc4Atop() const
Definition: G4FTFParameters.hh:90

G4FTFParamCollection::GetProc0Atop
double GetProc0Atop() const
Definition: G4FTFParameters.hh:64

G4ParticleDefinition::GetBaryonNumber
G4int GetBaryonNumber() const
Definition: G4ParticleDefinition.hh:145

G4FTFParameters::TarMinDiffMass
G4double TarMinDiffMass
Definition: G4FTFParameters.hh:389

G4FTFParamCollection::fNuclearProjDestructP1_NBRNDEP
bool fNuclearProjDestructP1_NBRNDEP
Definition: G4FTFParameters.hh:211

Neutron
Definition: G4RadioactiveDecayMode.hh:68

G4FTFParamCollection::GetProc4A2
double GetProc4A2() const
Definition: G4FTFParameters.hh:87

G4FTFParamCollection::IsNuclearProjDestructP1_NBRNDEP
bool IsNuclearProjDestructP1_NBRNDEP() const
Definition: G4FTFParameters.hh:111

G4FTFParameters::SetTotalCrossSection
void SetTotalCrossSection(const G4double Xtotal)
Definition: G4FTFParameters.hh:438

G4FTFParamCollection::fProc0B1
double fProc0B1
Definition: G4FTFParameters.hh:146

G4FTFParamCollection::fProc1A1
double fProc1A1
Definition: G4FTFParameters.hh:153

G4FTFParamCollection
Definition: G4FTFParameters.hh:48

G4FTFParamCollection::GetProjMinNonDiffMass
double GetProjMinNonDiffMass() const
Definition: G4FTFParameters.hh:97

CLHEP::MeV
static constexpr double MeV
Definition: SystemOfUnits.h:174

G4FTFParamCollection::GetProbLogDistr
double GetProbLogDistr() const
Definition: G4FTFParameters.hh:102

G4SystemOfUnits.hh

G4FTFParamCollection::GetTgtMinNonDiffMass
double GetTgtMinNonDiffMass() const
Definition: G4FTFParameters.hh:99

G4FTFParamCollection::fAveragePt2
double fAveragePt2
Definition: G4FTFParameters.hh:189

G4ParticleDefinition
Definition: G4ParticleDefinition.hh:73

G4FTFParameters::SetRadiusOfHNinteractions2
void SetRadiusOfHNinteractions2(const G4double Radius2)
Definition: G4FTFParameters.hh:467

G4FTFParamCollection::fNuclearProjDestructP3
double fNuclearProjDestructP3
Definition: G4FTFParameters.hh:215

G4FTFParameters::CofNuclearDestruction
G4double CofNuclearDestruction
Definition: G4FTFParameters.hh:404

G4FTFParamCollection::GetTgtMinDiffMass
double GetTgtMinDiffMass() const
Definition: G4FTFParameters.hh:98

G4FTFParameters::GetSlope
G4double GetSlope()
Definition: G4FTFParameters.hh:605

G4ChipsComponentXS::GetTotalElementCrossSection
virtual G4double GetTotalElementCrossSection(const G4ParticleDefinition *aParticle, G4double kinEnergy, G4int Z, G4double N)
Definition: G4ChipsComponentXS.cc:83

G4FTFParamCollection::GetProc4B1
double GetProc4B1() const
Definition: G4FTFParameters.hh:86

G4FTFParamCollection::fProc1Atop
double fProc1Atop
Definition: G4FTFParameters.hh:158

G4FTFParamCollection::fProjDiffDissociation
bool fProjDiffDissociation
Definition: G4FTFParameters.hh:169

G4FTFParameters::Pt2kink
G4double Pt2kink
Definition: G4FTFParameters.hh:396

FTFDefaultsHDP
G4FTFSettingDefaultHDP FTFDefaultsHDP
Definition: G4FTFParameters.cc:159

G4FTFParameters::ExcitationEnergyPerWoundedNucleon
G4double ExcitationEnergyPerWoundedNucleon
Definition: G4FTFParameters.hh:407

G4FTFParamCollection::GetProc0Ymin
double GetProc0Ymin() const
Definition: G4FTFParameters.hh:65

G4FTFParamCollBaryonProj::G4FTFParamCollBaryonProj
G4FTFParamCollBaryonProj()
Definition: G4FTFParameters.cc:270

G4FTFParamCollection::GetProc1A2
double GetProc1A2() const
Definition: G4FTFParameters.hh:77

G4FTFParamCollection::GetDeltaProbAtQuarkExchange
double GetDeltaProbAtQuarkExchange() const
Definition: G4FTFParameters.hh:94

G4FTFParameters::TarMinNonDiffMass
G4double TarMinNonDiffMass
Definition: G4FTFParameters.hh:390

G4FTFParameters::ProcParams
G4double ProcParams[5][7]
Definition: G4FTFParameters.hh:381

G4FTFParameters::MaxPt2ofNuclearDestruction
G4double MaxPt2ofNuclearDestruction
Definition: G4FTFParameters.hh:411

G4FTFParameters::SetProbabilityOfAnnihilation
void SetProbabilityOfAnnihilation(const G4double aValue)
Definition: G4FTFParameters.hh:463

G4FTFParameters::SetProbLogDistr
void SetProbLogDistr(const G4double aValue)
Definition: G4FTFParameters.hh:528

G4FTFParamCollection::fProc1A2
double fProc1A2
Definition: G4FTFParameters.hh:155

G4FTFParameters::ProbOfSameQuarkExchange
G4double ProbOfSameQuarkExchange
Definition: G4FTFParameters.hh:384

G4FTFParamCollection::GetNuclearProjDestructP3
double GetNuclearProjDestructP3() const
Definition: G4FTFParameters.hh:115

G4FTFParameters::ProbabilityOfElasticScatt
G4double ProbabilityOfElasticScatt
Definition: G4FTFParameters.hh:374

G4FTFParamCollection::fNuclearProjDestructP2
double fNuclearProjDestructP2
Definition: G4FTFParameters.hh:214

G4FTFParameters::ProjMinNonDiffMass
G4double ProjMinNonDiffMass
Definition: G4FTFParameters.hh:387

G4FTFParameters::RadiusOfHNinteractions2
G4double RadiusOfHNinteractions2
Definition: G4FTFParameters.hh:375

G4FTFParamCollection::IsNuclearTgtDestructP1_ADEP
bool IsNuclearTgtDestructP1_ADEP() const
Definition: G4FTFParameters.hh:113

G4FTFParamCollection::GetProc1A3
double GetProc1A3() const
Definition: G4FTFParameters.hh:79

G4int
int G4int
Definition: G4Types.hh:78

G4Neutron.hh

G4FTFParamCollection::GetDofNuclearDestruct
double GetDofNuclearDestruct() const
Definition: G4FTFParameters.hh:127

G4FTFParameters::SetMaxPt2ofNuclearDestruction
void SetMaxPt2ofNuclearDestruction(const G4double aValue)
Definition: G4FTFParameters.hh:588

G4FTFParamCollection::fProc0B2
double fProc0B2
Definition: G4FTFParameters.hh:148

G4Proton.hh

G4FTFParameters::SetQuarkProbabilitiesAtGluonSplitUp
void SetQuarkProbabilitiesAtGluonSplitUp(const G4double Puubar, const G4double Pddbar, const G4double Pssbar)
Definition: G4FTFParameters.hh:538

G4FTFParamCollection::fProjMinNonDiffMass
double fProjMinNonDiffMass
Definition: G4FTFParameters.hh:186

G4Neutron::Neutron
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104

G4FTFParameters::G4FTFParameters
G4FTFParameters()
Definition: G4FTFParameters.cc:404

G4FTFParameters::SetExcitationEnergyPerWoundedNucleon
void SetExcitationEnergyPerWoundedNucleon(const G4double aValue)
Definition: G4FTFParameters.hh:576

G4FTFParameters::Pt2ofNuclearDestruction
G4double Pt2ofNuclearDestruction
Definition: G4FTFParameters.hh:410

G4KaonMinus.hh

G4HadronicDeveloperParameters::GetInstance
static G4HadronicDeveloperParameters & GetInstance()
Definition: G4HadronicDeveloperParameters.cc:28

G4FTFParamCollection::fProc0A2
double fProc0A2
Definition: G4FTFParameters.hh:147

G4FTFParameters::FTFXinelastic
G4double FTFXinelastic
Definition: G4FTFParameters.hh:371

G4FTFParamCollection::GetProc1B2
double GetProc1B2() const
Definition: G4FTFParameters.hh:78

G4Log.hh

G4HadronicDeveloperParameters.hh

G4FTFParamCollection::fNuclearTgtDestructP2
double fNuclearTgtDestructP2
Definition: G4FTFParameters.hh:216

G4FTFParamCollection::GetR2ofNuclearDestruct
double GetR2ofNuclearDestruct() const
Definition: G4FTFParameters.hh:125

G4ParticleDefinition::GetPDGEncoding
G4int GetPDGEncoding() const
Definition: G4ParticleDefinition.hh:147

G4cout
G4GLOB_DLL std::ostream G4cout

G4FTFParameters::ProjMinDiffMass
G4double ProjMinDiffMass
Definition: G4FTFParameters.hh:386

G4FTFParameters::CofNuclearDestructionPr
G4double CofNuclearDestructionPr
Definition: G4FTFParameters.hh:403

G4FTFParamCollection::Reset
void Reset()
Definition: G4FTFParameters.cc:199

G4FTFParameters::SetProjMinDiffMass
void SetProjMinDiffMass(const G4double aValue)
Definition: G4FTFParameters.hh:504

G4FTFParameters::FTFhNcmsEnergy
G4double FTFhNcmsEnergy
Definition: G4FTFParameters.hh:363

G4ParticleDefinition.hh

G4FTFParameters::SetDofNuclearDestruction
void SetDofNuclearDestruction(const G4double aValue)
Definition: G4FTFParameters.hh:580

G4FTFParameters::FTFXtotal
G4double FTFXtotal
Definition: G4FTFParameters.hh:369

G4FTFParamCollection::GetNuclearProjDestructP2
double GetNuclearProjDestructP2() const
Definition: G4FTFParameters.hh:114

G4FTFParameters.hh

G4FTFParamCollection::fNuclearTgtDestructP1
double fNuclearTgtDestructP1
Definition: G4FTFParameters.hh:212

G4FTFParameters::FTFxsManager
G4ChipsComponentXS * FTFxsManager
Definition: G4FTFParameters.hh:366

G4FTFParameters::SetAveragePt2
void SetAveragePt2(const G4double aValue)
Definition: G4FTFParameters.hh:520

G4PionMinus.hh

G4FTFParamCollection::GetMaxPt2ofNuclearDestruct
double GetMaxPt2ofNuclearDestruct() const
Definition: G4FTFParameters.hh:128

G4FTFParameters::SetPt2ofNuclearDestruction
void SetPt2ofNuclearDestruction(const G4double aValue)
Definition: G4FTFParameters.hh:584

sqr
T sqr(const T &x)
Definition: templates.hh:145

pi
static constexpr double pi
Definition: G4SIunits.hh:75

G4FTFParamCollection::GetNuclearTgtDestructP3
double GetNuclearTgtDestructP3() const
Definition: G4FTFParameters.hh:117

G4FTFParameters::DeltaProbAtQuarkExchange
G4double DeltaProbAtQuarkExchange
Definition: G4FTFParameters.hh:383

G4FTFParamCollection::GetProc0B1
double GetProc0B1() const
Definition: G4FTFParameters.hh:60

G4FTFParamCollection::fTgtMinNonDiffMass
double fTgtMinNonDiffMass
Definition: G4FTFParameters.hh:188

G4FTFParamCollection::GetExciEnergyPerWoundedNucleon
double GetExciEnergyPerWoundedNucleon() const
Definition: G4FTFParameters.hh:126

G4FTFParamCollection::GetPt2NuclearDestructP2
double GetPt2NuclearDestructP2() const
Definition: G4FTFParameters.hh:119

G4FTFParameters::SetTarMinNonDiffMass
void SetTarMinNonDiffMass(const G4double aValue)
Definition: G4FTFParameters.hh:516

G4HadronicDeveloperParameters::DeveloperGet
G4bool DeveloperGet(const std::string name, G4bool &value)
Definition: G4HadronicDeveloperParameters.cc:242

G4FTFParameters::SetInelasticCrossSection
void SetInelasticCrossSection(const G4double Xinelastic)
Definition: G4FTFParameters.hh:446

G4FTFParameters::fParCollBaryonProj
G4FTFParamCollBaryonProj fParCollBaryonProj
Definition: G4FTFParameters.hh:419

G4FTFParameters::FTFXannihilation
G4double FTFXannihilation
Definition: G4FTFParameters.hh:372

G4FTFParameters::ProbLogDistr
G4double ProbLogDistr
Definition: G4FTFParameters.hh:393

G4FTFParameters::SetGamma0
void SetGamma0(const G4double Gamma0)
Definition: G4FTFParameters.hh:475

CLHEP::GeV
static constexpr double GeV
Definition: SystemOfUnits.h:177

G4FTFParameters::SetDeltaProbAtQuarkExchange
void SetDeltaProbAtQuarkExchange(const G4double aValue)
Definition: G4FTFParameters.hh:496

G4HadronicDeveloperParameters
Definition: G4HadronicDeveloperParameters.hh:36

GeV
static constexpr double GeV
Definition: G4SIunits.hh:217

G4FTFParamCollection::GetProjMinDiffMass
double GetProjMinDiffMass() const
Definition: G4FTFParameters.hh:96

G4FTFParameters::Reset
void Reset()
Definition: G4FTFParameters.cc:429

G4FTFParamCollection::GetProc4B2
double GetProc4B2() const
Definition: G4FTFParameters.hh:88

G4FTFParamCollection::fMaxPt2ofNuclearDestruct
double fMaxPt2ofNuclearDestruct
Definition: G4FTFParameters.hh:228

G4FTFParamCollection::fProc1B2
double fProc1B2
Definition: G4FTFParameters.hh:156

G4FTFParamCollection::fProbOfSameQuarkExchange
double fProbOfSameQuarkExchange
Definition: G4FTFParameters.hh:184

G4FTFParamCollection::fProc0Ymin
double fProc0Ymin
Definition: G4FTFParameters.hh:151

G4FTFSettingDefaultHDP
Definition: G4FTFParameters.cc:56

G4FTFParamCollection::GetAveragePt2
double GetAveragePt2() const
Definition: G4FTFParameters.hh:100

G4FTFParamCollection::fProc4A2
double fProc4A2
Definition: G4FTFParameters.hh:175

G4FTFParameters::SetParams
void SetParams(const G4int ProcN, const G4double A1, const G4double B1, const G4double A2, const G4double B2, const G4double A3, const G4double Atop, const G4double Ymin)
Definition: G4FTFParameters.hh:486