Ignore:
Timestamp:
Nov 5, 2010, 3:45:55 PM (14 years ago)
Author:
garnier
Message:

update ti head

Location:
trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include
Files:
33 edited

Legend:

Unmodified
Added
Removed

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4GNASHTransitions.hh

    r962 r1340  
    2424// ********************************************************************
    2525//
     26// $Id: G4GNASHTransitions.hh,v 1.4 2010/08/20 07:42:19 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
     28//
    2629#ifndef G4GNASHTransitions_hh
    2730#define G4GNASHTransitions_hh 1
    … …  
    3336{
    3437public:
    35   G4GNASHTransitions() {}
    36   virtual ~G4GNASHTransitions() {}
     38
     39  G4GNASHTransitions();
     40
     41  virtual ~G4GNASHTransitions();
     42
     43  virtual G4double CalculateProbability(const G4Fragment & aFragment);
     44 
     45  virtual void PerformTransition(G4Fragment & aFragment);
    3746
    3847private:
    3948
    40   G4GNASHTransitions(const G4GNASHTransitions &) : G4VPreCompoundTransitions() {}
    41 
    42   const G4GNASHTransitions& operator=(const G4GNASHTransitions &right);
     49G4GNASHTransitions(const G4GNASHTransitions &);
     50const G4GNASHTransitions& operator=(const G4GNASHTransitions &right);
    4351
    4452  G4bool operator==(const G4GNASHTransitions &right) const;
    … …  
    4654  G4bool operator!=(const G4GNASHTransitions &right) const;
    4755
    48 public:
    49 
    50   virtual G4double CalculateProbability(const G4Fragment & aFragment);
    51  
    52   virtual G4Fragment PerformTransition(const G4Fragment & aFragment);
    53 
    54 //JMQ 03/01/08
    55  public:
    56 // inline G4double GetTransitionProb1() const
    57 G4double GetTransitionProb1()
    58 {return 0;}
    59 // inline G4double GetTransitionProb2() const
    60 G4double GetTransitionProb2()
    61 {return 0;}
    62 // inline G4double GetTransitionProb3() const
    63 G4double GetTransitionProb3()
    64 {return 0;}
    65 //
    66 
    6756
    6857};

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4HETCAlpha.hh

    r819 r1340  
    2424// ********************************************************************
    2525//
     26// $Id: G4HETCAlpha.hh,v 1.3 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
     28//
    2629// by V. Lara
     30//
     31// Modified:
     32// 23.08.2010 V.Ivanchenko general cleanup, move constructor and destructor
     33//            the source, use G4Pow
    2734
    2835#ifndef G4HETCAlpha_h
    … …  
    3138#include "G4HETCChargedFragment.hh"
    3239#include "G4ReactionProduct.hh"
    33 #include "G4Alpha.hh"
    34 
    3540#include "G4AlphaCoulombBarrier.hh"
    36 
    3741
    3842class G4HETCAlpha : public G4HETCChargedFragment
    3943{
    4044public:
    41   // default constructor
    42   G4HETCAlpha():G4HETCChargedFragment(4,2,&theAlphaCoulombBarrier,"Alpha") {}
    4345
    44   // copy constructor
    45   G4HETCAlpha(const G4HETCAlpha &right): G4HETCChargedFragment(right) {}
     46  G4HETCAlpha();
    4647
    47   // destructor
    48   ~G4HETCAlpha() {}
     48  ~G4HETCAlpha();
    4949
    50   // operators 
    51   const G4HETCAlpha & operator=(const G4HETCAlpha &right)
    52   {
    53     if (&right != this) this->G4HETCChargedFragment::operator=(right);
    54     return *this;
    55   };
    56  
    57   G4bool operator==(const G4HETCAlpha &right) const
    58   {
    59     return G4HETCChargedFragment::operator==(right);
    60   }
     50protected:
    6151
    62  
    63   G4bool operator!=(const G4HETCAlpha &right) const
    64   {
    65     return G4HETCChargedFragment::operator!=(right);
    66   }
     52  virtual G4double GetAlpha();
    6753
     54  virtual G4double GetBeta();
    6855
    69   G4ReactionProduct * GetReactionProduct() const
    70   {
    71     G4ReactionProduct * theReactionProduct =
    72       new G4ReactionProduct(G4Alpha::AlphaDefinition());
    73     theReactionProduct->SetMomentum(GetMomentum().vect());
    74     theReactionProduct->SetTotalEnergy(GetMomentum().e());
    75 #ifdef PRECOMPOUND_TEST
    76     theReactionProduct->SetCreatorModel("G4PrecompoundModel");
    77 #endif
    78     return theReactionProduct;
    79   }   
    80    
    81 private:
    82   virtual G4double GetAlpha()
    83   {
    84     G4double C = 0.0;
    85     G4double aZ = GetZ() + GetRestZ();
    86     if (aZ <= 30)
    87       {
    88         C = 0.10;
    89       }
    90     else if (aZ <= 50)
    91       {
    92         C = 0.1 + -((aZ-50.)/20.)*0.02;
    93       }
    94     else if (aZ < 70)
    95       {
    96         C = 0.08 + -((aZ-70.)/20.)*0.02;
    97       }
    98     else
    99       {
    100         C = 0.06;
    101       }
    102     return 1.0+C;
    103   }
    104  
    105   virtual G4double GetBeta()
    106   {
    107     return -GetCoulombBarrier();
    108   }
    109  
    110 
    111   virtual G4double GetSpinFactor()
    112   {
    113     return 1.0;
    114   }
     56  virtual G4double GetSpinFactor();
    11557
    11658  virtual G4double K(const G4Fragment & aFragment);
    11759
     60private:
    11861
    119 private:
     62  // operators 
     63  G4HETCAlpha(const G4HETCAlpha &right);
     64  const G4HETCAlpha & operator=(const G4HETCAlpha &right);
     65  G4bool operator==(const G4HETCAlpha &right) const;
     66  G4bool operator!=(const G4HETCAlpha &right) const;
    12067
    12168  G4AlphaCoulombBarrier theAlphaCoulombBarrier;

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4HETCChargedFragment.hh

    r819 r1340  
    2424// ********************************************************************
    2525//
     26// $Id: G4HETCChargedFragment.hh,v 1.3 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
     28//
    2629// by V. Lara
    2730
    … …  
    3033
    3134#include "G4HETCFragment.hh"
    32 #include "G4VCoulombBarrier.hh"
    33 
    3435
    3536class G4HETCChargedFragment : public G4HETCFragment
    3637{
    37 protected:
    38   // default constructor
    39   G4HETCChargedFragment() {}
    40 
    4138public:
    4239
    43   // copy constructor
    44   G4HETCChargedFragment(const G4HETCChargedFragment &right):
    45     G4HETCFragment(right) {}
     40  G4HETCChargedFragment(const G4ParticleDefinition*,
     41                        G4VCoulombBarrier * aCoulombBarrier);
    4642
    47   // constructor 
    48   G4HETCChargedFragment(const G4double anA,
    49                         const G4double aZ,
    50                         G4VCoulombBarrier* aCoulombBarrier,
    51                         const G4String & aName):
    52     G4HETCFragment(anA,aZ,aCoulombBarrier,aName) {}
     43  virtual ~G4HETCChargedFragment();
    5344
    54   virtual ~G4HETCChargedFragment() {}
     45  virtual G4double GetKineticEnergy(const G4Fragment & aFragment);
     46
     47private:
    5548
    5649  // operators 
     50  G4HETCChargedFragment();
     51  G4HETCChargedFragment(const G4HETCChargedFragment &right);
    5752  const G4HETCChargedFragment &
    58   operator=(const G4HETCChargedFragment &right)
    59   {
    60     if (&right != this) this->G4HETCFragment::operator=(right);
    61     return *this;
    62   }
    63 
    64   G4bool operator==(const G4HETCChargedFragment &right) const
    65   {
    66     return G4HETCFragment::operator==(right);
    67   }
    68    
    69   G4bool operator!=(const G4HETCChargedFragment &right) const
    70   {
    71     return G4HETCFragment::operator!=(right);
    72   }
    73    
    74 
    75   virtual G4double GetKineticEnergy(const G4Fragment & aFragment);
    76    
     53  operator=(const G4HETCChargedFragment &right);
     54  G4bool operator==(const G4HETCChargedFragment &right) const;
     55  G4bool operator!=(const G4HETCChargedFragment &right) const;   
    7756   
    7857};

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4HETCDeuteron.hh

    r819 r1340  
    2424// ********************************************************************
    2525//
     26// $Id: G4HETCDeuteron.hh,v 1.3 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
     28//
    2629// by V. Lara
     30//
     31// Modified:
     32// 23.08.2010 V.Ivanchenko general cleanup, move constructor and destructor
     33//            the source, use G4Pow
     34//
    2735
    2836#ifndef G4HETCDeuteron_h
    … …  
    3139#include "G4HETCChargedFragment.hh"
    3240#include "G4ReactionProduct.hh"
    33 #include "G4Deuteron.hh"
    34 
    3541#include "G4DeuteronCoulombBarrier.hh"
    36 
    3742
    3843class G4HETCDeuteron : public G4HETCChargedFragment
    3944{
    4045public:
    41   // default constructor
    42   G4HETCDeuteron():G4HETCChargedFragment(2,1,&theDeuteronCoulombBarrier,"Deuteron") {}
    4346
    44   // copy constructor
    45   G4HETCDeuteron(const G4HETCDeuteron &right): G4HETCChargedFragment(right) {}
     47  G4HETCDeuteron();
     48
     49  ~G4HETCDeuteron();
    4650 
    47   // destructor
    48   ~G4HETCDeuteron() {}
    49  
    50   // operators 
    51   const G4HETCDeuteron & operator=(const G4HETCDeuteron &right)
    52   {
    53     if (&right != this) this->G4HETCChargedFragment::operator=(right);
    54     return *this;
    55   }
     51protected:
    5652
    57   G4bool operator==(const G4HETCDeuteron &right) const
    58   {
    59     return G4HETCChargedFragment::operator==(right);
    60   }
     53  virtual G4double GetAlpha();
    6154
    62  
    63   G4bool operator!=(const G4HETCDeuteron &right) const
    64   {
    65     return G4HETCChargedFragment::operator!=(right);
    66   }
     55  virtual G4double GetBeta();
    6756
     57  virtual G4double GetSpinFactor();
    6858
    69   G4ReactionProduct * GetReactionProduct() const
    70   {
    71     G4ReactionProduct * theReactionProduct =
    72       new G4ReactionProduct(G4Deuteron::DeuteronDefinition());
    73     theReactionProduct->SetMomentum(GetMomentum().vect());
    74     theReactionProduct->SetTotalEnergy(GetMomentum().e());
    75 #ifdef PRECOMPOUND_TEST
    76     theReactionProduct->SetCreatorModel("G4PrecompoundModel");
    77 #endif
    78     return theReactionProduct;
    79   }   
    80    
    81 private:
    82   virtual G4double GetAlpha()
    83   {
    84     G4double C = 0.0;
    85     G4double aZ = GetZ() + GetRestZ();
    86     if (aZ >= 70)
    87       {
    88         C = 0.10;
    89       }
    90     else
    91       {
    92         C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375;
    93       }
    94     return 1.0 + C/2.0;
    95   }
    96  
    97   virtual G4double GetBeta()
    98   {
    99     return -GetCoulombBarrier();
    100   }
    101 
    102   virtual G4double GetSpinFactor()
    103   {
    104     // 2s+1
    105     return 3.0;
    106   }
    107  
    10859  virtual G4double K(const G4Fragment & aFragment);
    109 
    11060
    11161private:
    11262
     63  // operators 
     64  G4HETCDeuteron(const G4HETCDeuteron &right);
     65  const G4HETCDeuteron & operator=(const G4HETCDeuteron &right);
     66  G4bool operator==(const G4HETCDeuteron &right) const;
     67  G4bool operator!=(const G4HETCDeuteron &right) const;
     68   
     69private:
     70 
    11371  G4DeuteronCoulombBarrier theDeuteronCoulombBarrier;
    11472

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4HETCEmissionFactory.hh

    r819 r1340  
    2424// ********************************************************************
    2525//
     26// $Id: G4HETCEmissionFactory.hh,v 1.3 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
     28//
     29//
     30
    2631#ifndef G4HETCEmissionFactory_hh
    2732#define G4HETCEmissionFactory_hh
    … …  
    2934#include "G4VPreCompoundEmissionFactory.hh"
    3035
    31 
    3236class G4HETCEmissionFactory : public G4VPreCompoundEmissionFactory
    3337{
    3438public:
    3539
    36   G4HETCEmissionFactory() {};
    37   virtual ~G4HETCEmissionFactory() {};
     40  G4HETCEmissionFactory();
     41  virtual ~G4HETCEmissionFactory();
     42
     43protected:
     44
     45  virtual std::vector<G4VPreCompoundFragment*> *  CreateFragmentVector();
    3846
    3947private:
    4048
    41   G4HETCEmissionFactory(const G4HETCEmissionFactory & ) : G4VPreCompoundEmissionFactory() {};
     49  G4HETCEmissionFactory(const G4HETCEmissionFactory & );
    4250  const G4HETCEmissionFactory & operator=(const G4HETCEmissionFactory & val);
    4351  G4bool operator==(const G4HETCEmissionFactory & val) const;
    4452  G4bool operator!=(const G4HETCEmissionFactory & val) const;
    4553
    46 private:
    47 
    48   virtual std::vector<G4VPreCompoundFragment*> *  CreateFragmentVector();
    49 
    5054};
    5155

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4HETCFragment.hh

    r819 r1340  
    2424// ********************************************************************
    2525//
     26// $Id: G4HETCFragment.hh,v 1.3 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
     28//
    2629// by V. Lara
     30//
     31// Modified: 
     32// 20.08.2010 V.Ivanchenko added G4Pow and G4PreCompoundParameters pointers
     33//                         use int Z and A and cleanup
    2734
    2835#ifndef G4HETCFragment_h
    … …  
    3037
    3138#include "G4VPreCompoundFragment.hh"
     39#include "Randomize.hh"
    3240
    3341class G4HETCFragment : public G4VPreCompoundFragment
    3442{
    35 protected:
    36   // default constructor
    37   G4HETCFragment() {};
    38    
    3943public: 
    40   // copy constructor
    41   G4HETCFragment(const G4HETCFragment &right);
    42    
    43   // constructor 
    44   G4HETCFragment(const G4double anA, const G4double aZ,
    45                  G4VCoulombBarrier * aCoulombBarrier,
    46                  const G4String &  aName);
     44
     45  G4HETCFragment(const G4ParticleDefinition*,
     46                 G4VCoulombBarrier * aCoulombBarrier);
    4747 
    4848  virtual ~G4HETCFragment();
    49  
    50   // ==========
    51   // operators
    52   // ==========
    53  
    54   const G4HETCFragment&
    55   operator= (const G4HETCFragment &right);
    56  
    57   G4int operator==(const G4HETCFragment &right) const;
    58  
    59   G4int operator!=(const G4HETCFragment &right) const;
    60  
     49
     50  G4double CalcEmissionProbability(const G4Fragment & aFragment);
     51
    6152protected:
    6253
    … …  
    6758  virtual G4double GetBeta() = 0;
    6859
    69 public:
    70    
     60  inline G4double BetaRand(const G4int N, const G4int L) const;
     61 
     62private:
    7163
    72   G4double CalcEmissionProbability(const G4Fragment & aFragment);
    73  
    74 private:       
    7564  // This method performs integration for probability function over
    7665  // fragment kinetic energy
    … …  
    7867                                        const G4double & Up,
    7968                                        const G4Fragment & aFragment); 
    80    
    81   // ============================
    82   // Data members access methods
    83   // ============================
    84  
    8569
    86   inline G4bool IsItPossible(const G4Fragment & aFragment) const;
     70  G4HETCFragment();
     71  G4HETCFragment(const G4HETCFragment &right);
     72  const G4HETCFragment&
     73  operator= (const G4HETCFragment &right); 
     74  G4int operator==(const G4HETCFragment &right) const;
     75  G4int operator!=(const G4HETCFragment &right) const;
    8776
    88 protected:
    89  
    90   inline G4double BetaRand(const G4int N, const G4int L) const;
    91  
     77  G4double r2norm;
    9278};
    9379
    94 #include "G4HETCFragment.icc"
     80inline G4double G4HETCFragment::
     81BetaRand(const G4int N, const G4int L) const
     82{
     83  G4double Y1 = CLHEP::RandGamma::shoot(N,1);
     84  G4double Y2 = CLHEP::RandGamma::shoot(L,1);
     85 
     86  return Y1/(Y1+Y2);
     87}
    9588
    9689#endif

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4HETCFragment.icc

    r819 r1340  
    2424// ********************************************************************
    2525//
     26// $Id: G4HETCFragment.icc,v 1.4 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
     28//
    2629// by V. Lara
    2730
    28 
    29 #include <CLHEP/Random/RandGamma.h>
    30 
    31 inline G4bool G4HETCFragment::
    32 IsItPossible(const G4Fragment & aFragment) const
    33 {
    34   G4int pplus = aFragment.GetNumberOfCharged();
    35   G4int pneut = aFragment.GetNumberOfParticles()-pplus;
    36   return (pneut >= (GetA()-GetZ()) && pplus >= GetZ());
    37 }
    38 
    39 inline G4double G4HETCFragment::
    40 BetaRand(const G4int N, const G4int L) const
    41 {
    42   G4double Y1 = CLHEP::RandGamma::shoot(N,1);
    43   G4double Y2 = CLHEP::RandGamma::shoot(L,1);
    44  
    45   return Y1/(Y1+Y2);
    46 }

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4HETCHe3.hh

    r819 r1340  
    2424// ********************************************************************
    2525//
     26// $Id: G4HETCHe3.hh,v 1.3 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
     28//
    2629// by V. Lara
     30//
     31// Modified:
     32// 23.08.2010 V.Ivanchenko general cleanup, move constructor and destructor
     33//            the source, use G4Pow
    2734
    2835#ifndef G4HETCHe3_h
    … …  
    3138#include "G4HETCChargedFragment.hh"
    3239#include "G4ReactionProduct.hh"
    33 #include "G4He3.hh"
    34 
    3540#include "G4He3CoulombBarrier.hh"
    36 
    3741
    3842class G4HETCHe3 : public G4HETCChargedFragment
    3943{
    4044public:
    41   // default constructor
    42   G4HETCHe3():G4HETCChargedFragment(3,2,&theHe3CoulombBarrier,"He3") {}
    4345
    44   // copy constructor
    45   G4HETCHe3(const G4HETCHe3 &right): G4HETCChargedFragment(right) {}
     46  G4HETCHe3();
    4647
    47   // destructor
    48   ~G4HETCHe3() {}
     48  ~G4HETCHe3();
    4949
    50   // operators 
    51   const G4HETCHe3 & operator=(const G4HETCHe3 &right)
    52   {
    53     if (&right != this) this->G4HETCChargedFragment::operator=(right);
    54     return *this;
    55   }
    56  
    57   G4bool operator==(const G4HETCHe3 &right) const
    58   {
    59     return G4HETCChargedFragment::operator==(right);
    60   }
     50protected:
    6151
    62  
    63   G4bool operator!=(const G4HETCHe3 &right) const
    64   {
    65     return G4HETCChargedFragment::operator!=(right);
    66   }
     52  virtual G4double GetAlpha();
    6753
     54  virtual G4double GetBeta();
    6855
    69   G4ReactionProduct * GetReactionProduct() const
    70   {
    71     G4ReactionProduct * theReactionProduct =
    72       new G4ReactionProduct(G4He3::He3Definition());
    73     theReactionProduct->SetMomentum(GetMomentum().vect());
    74     theReactionProduct->SetTotalEnergy(GetMomentum().e());
    75 #ifdef PRECOMPOUND_TEST
    76     theReactionProduct->SetCreatorModel("G4PrecompoundModel");
    77 #endif
    78     return theReactionProduct;
    79   }   
    80    
    81 private:
    82   virtual G4double GetAlpha()
    83   {
    84     G4double C = 0.0;
    85     G4double aZ = GetZ() + GetRestZ();
    86     if (aZ <= 30)
    87       {
    88         C = 0.10;
    89       }
    90     else if (aZ <= 50)
    91       {
    92         C = 0.1 + -((aZ-50.)/20.)*0.02;
    93       }
    94     else if (aZ < 70)
    95       {
    96         C = 0.08 + -((aZ-70.)/20.)*0.02;
    97       }
    98     else
    99       {
    100         C = 0.06;
    101       }
    102     return 1.0 + C*(4.0/3.0);
    103   }
    104  
    105 
    106   virtual G4double GetBeta()
    107   {
    108     return -GetCoulombBarrier();
    109   }
    110  
    111   //   virtual G4double FactorialFactor(const G4double N, const G4double P)
    112   //   {
    113   //     return
    114   //       (N-3.0)*(P-2.0)*(
    115   //                   (((N-2.0)*(P-1.0))/2.0) *(
    116   //                                             (((N-1.0)*P)/3.0)
    117   //                                             )
    118   //                   );
    119   //   }
    120  
    121   virtual G4double GetSpinFactor()
    122   {
    123     // 2s+1
    124     return 2.0;
    125   }   
     56  virtual G4double GetSpinFactor();
    12657
    12758  virtual G4double K(const G4Fragment & aFragment);
    … …  
    12960private:
    13061
     62  // operators 
     63  G4HETCHe3(const G4HETCHe3 &right);
     64  const G4HETCHe3 & operator=(const G4HETCHe3 &right);
     65  G4bool operator==(const G4HETCHe3 &right) const;
     66  G4bool operator!=(const G4HETCHe3 &right) const;
     67
    13168  G4He3CoulombBarrier theHe3CoulombBarrier;
    132 
    13369};
    13470

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4HETCNeutron.hh

    r819 r1340  
    2424// ********************************************************************
    2525//
     26// $Id: G4HETCNeutron.hh,v 1.4 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
     28//
    2629// by V. Lara
    27 
     30//
     31// Modified:
     32// 23.08.2010 V.Ivanchenko general cleanup, move constructor and destructor
     33//            the source, use G4Pow
    2834
    2935#ifndef G4HETCNeutron_h
    … …  
    3238#include "G4HETCFragment.hh"
    3339#include "G4ReactionProduct.hh"
    34 #include "G4Neutron.hh"
    35 #include "G4PreCompoundParameters.hh"
    36 #include "Randomize.hh"
    37 
    3840#include "G4NeutronCoulombBarrier.hh"
    39 
    4041
    4142class G4HETCNeutron : public G4HETCFragment
    4243{
    4344public:
    44   // default constructor
    45   G4HETCNeutron() : G4HETCFragment(1,0,&theNeutronCoulomBarrier,"Neutron") {}
    4645
    47   // copy constructor
    48   G4HETCNeutron(const G4HETCNeutron &right): G4HETCFragment(right) {}
     46  G4HETCNeutron();
    4947
    50   // destructor
    51   ~G4HETCNeutron() {}
     48  ~G4HETCNeutron();
     49
     50  virtual G4double GetKineticEnergy(const G4Fragment & aFragment);
     51
     52protected:
     53
     54  virtual G4double GetAlpha();
     55
     56  virtual G4double GetBeta();
     57
     58  virtual G4double GetSpinFactor();
     59
     60  virtual G4double K(const G4Fragment & aFragment);
     61
     62private:
    5263
    5364  // operators 
    54   const G4HETCNeutron & operator=(const G4HETCNeutron &right) {
    55     if (&right != this) this->G4HETCFragment::operator=(right);
    56     return *this;
    57   }
     65  G4HETCNeutron(const G4HETCNeutron &right);
     66  const G4HETCNeutron & operator=(const G4HETCNeutron &right);
     67  G4bool operator==(const G4HETCNeutron &right) const;
     68  G4bool operator!=(const G4HETCNeutron &right) const;
    5869
    59   G4bool operator==(const G4HETCNeutron &right) const
    60   { return G4HETCFragment::operator==(right);}
     70  G4NeutronCoulombBarrier theNeutronCoulombBarrier;
    6171 
    62   G4bool operator!=(const G4HETCNeutron &right) const
    63   { return G4HETCFragment::operator!=(right);}
    64 
    65 
    66   G4ReactionProduct * GetReactionProduct() const
    67   {
    68     G4ReactionProduct * theReactionProduct =
    69       new G4ReactionProduct(G4Neutron::NeutronDefinition());
    70     theReactionProduct->SetMomentum(GetMomentum().vect());
    71     theReactionProduct->SetTotalEnergy(GetMomentum().e());
    72 #ifdef PRECOMPOUND_TEST
    73     theReactionProduct->SetCreatorModel("G4PrecompoundModel");
    74 #endif
    75     return theReactionProduct;
    76   }
    77 
    78   virtual G4double GetKineticEnergy(const G4Fragment & aFragment);
    79  
    80 private:
    81   virtual G4double GetAlpha()
    82   {
    83     return 0.76+2.2/std::pow(GetRestA(),1.0/3.0);
    84   }
    85  
    86   virtual G4double GetBeta()
    87   {
    88     return (2.12/std::pow(GetRestA(),2.0/3.0)-0.05)*MeV/GetAlpha();
    89   }
    90 
    91   virtual G4double GetSpinFactor()
    92   {
    93     // (2s+1)
    94     return 2.0;
    95   }
    96  
    97   virtual G4double K(const G4Fragment& aFragment);
    98 
    99 private:
    100  
    101   G4NeutronCoulombBarrier theNeutronCoulomBarrier;
    102 
    10372};
    10473

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4HETCProton.hh

    r819 r1340  
    2424// ********************************************************************
    2525//
     26// $Id: G4HETCProton.hh,v 1.3 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
     28//
    2629// by V. Lara
     30//
     31// Modified:
     32// 23.08.2010 V.Ivanchenko general cleanup, move constructor and destructor
     33//            the source, use G4Pow
    2734
    2835#ifndef G4HETCProton_h
    … …  
    3138#include "G4HETCChargedFragment.hh"
    3239#include "G4ReactionProduct.hh"
    33 #include "G4Proton.hh"
    34 #include "G4PreCompoundParameters.hh"
    35 #include "Randomize.hh"
    36 
    3740#include "G4ProtonCoulombBarrier.hh"
    38 
    3941
    4042class G4HETCProton : public G4HETCChargedFragment
    4143{
    4244public:
    43   // default constructor
    44   G4HETCProton():G4HETCChargedFragment(1,1,&theProtonCoulombBarrier,"Proton") {}
    45  
    46   // copy constructor
    47   G4HETCProton(const G4HETCProton &right): G4HETCChargedFragment(right) {}
    4845
    49   // destructor
    50   ~G4HETCProton() {};
    51  
    52   // operators 
    53   const G4HETCProton & operator=(const G4HETCProton &right)
    54   {
    55     if (&right != this) this->G4HETCChargedFragment::operator=(right);
    56     return *this;
    57   }
     46  G4HETCProton();
    5847
    59   G4bool operator==(const G4HETCProton &right) const
    60   {
    61     return G4HETCChargedFragment::operator==(right);
    62   }
     48  ~G4HETCProton();
    6349
    64  
    65   G4bool operator!=(const G4HETCProton &right) const
    66   {
    67     return G4HETCChargedFragment::operator!=(right);
    68   }
     50protected:
    6951
     52  virtual G4double GetAlpha();
    7053
    71   G4ReactionProduct * GetReactionProduct() const
    72   {
    73     G4ReactionProduct * theReactionProduct =
    74       new G4ReactionProduct(G4Proton::ProtonDefinition());
    75     theReactionProduct->SetMomentum(GetMomentum().vect());
    76     theReactionProduct->SetTotalEnergy(GetMomentum().e());
    77 #ifdef PRECOMPOUND_TEST
    78     theReactionProduct->SetCreatorModel("G4PrecompoundModel");
    79 #endif
    80     return theReactionProduct;
    81   }
    82  
    83 private:
    84   virtual G4double GetAlpha()
    85   {
    86     G4double aZ = static_cast<G4double>(GetRestZ());
    87     G4double C = 0.0;
    88     if (aZ >= 70)
    89       {
    90         C = 0.10;
    91       }
    92     else
    93       {
    94         C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375;
    95       }
    96     return 1.0 + C;
    97   }
    98  
    99   virtual G4double GetBeta()
    100   {
    101     return -GetCoulombBarrier();
    102   }
    103  
    104   virtual G4double GetSpinFactor()
    105   {
    106     // 2s+1
    107     return 2.0;
    108   }
     54  virtual G4double GetBeta();
     55
     56  virtual G4double GetSpinFactor();
    10957
    11058  virtual G4double K(const G4Fragment & aFragment);
    11159
    11260private:
     61
     62  // operators 
     63  G4HETCProton(const G4HETCProton &right);
     64  const G4HETCProton & operator=(const G4HETCProton &right);
     65  G4bool operator==(const G4HETCProton &right) const;
     66  G4bool operator!=(const G4HETCProton &right) const;
    11367
    11468  G4ProtonCoulombBarrier theProtonCoulombBarrier;

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4HETCTriton.hh

    r819 r1340  
    2424// ********************************************************************
    2525//
     26// $Id: G4HETCTriton.hh,v 1.3 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
     28//
    2629// by V. Lara
     30//
     31// Modified:
     32// 23.08.2010 V.Ivanchenko general cleanup, move constructor and destructor
     33//            the source, use G4Pow
    2734
    2835#ifndef G4HETCTriton_h
    … …  
    3138#include "G4HETCChargedFragment.hh"
    3239#include "G4ReactionProduct.hh"
    33 #include "G4Triton.hh"
    34 
    3540#include "G4TritonCoulombBarrier.hh"
    36 
    3741
    3842class G4HETCTriton : public G4HETCChargedFragment
    3943{
    4044public:
    41   // default constructor
    42   G4HETCTriton():G4HETCChargedFragment(3,1,&theTritonCoulombBarrier,"Triton") {}
    4345
    44   // copy constructor
    45   G4HETCTriton(const G4HETCTriton &right): G4HETCChargedFragment(right) {}
     46  G4HETCTriton();
    4647
    47   // destructor
    48   ~G4HETCTriton() {}
     48  ~G4HETCTriton();
     49
     50protected:
     51
     52  virtual G4double GetAlpha();
     53
     54  virtual G4double GetBeta();
     55
     56  virtual G4double GetSpinFactor();
     57
     58  virtual G4double K(const G4Fragment & aFragment);
     59
     60private:
    4961
    5062  // operators 
    51   const G4HETCTriton & operator=(const G4HETCTriton &right)
    52   {
    53     if (&right != this) this->G4HETCChargedFragment::operator=(right);
    54     return *this;
    55   }
     63  G4HETCTriton(const G4HETCTriton &right);
     64  const G4HETCTriton & operator=(const G4HETCTriton &right);
     65  G4bool operator==(const G4HETCTriton &right) const;
     66  G4bool operator!=(const G4HETCTriton &right) const;
    5667
    57   G4bool operator==(const G4HETCTriton &right) const
    58   {
    59     return G4HETCChargedFragment::operator==(right);
    60   }
    61 
    62  
    63   G4bool operator!=(const G4HETCTriton &right) const
    64   {
    65     return G4HETCChargedFragment::operator!=(right);
    66   }
    67 
    68 
    69   G4ReactionProduct * GetReactionProduct() const
    70   {
    71     G4ReactionProduct * theReactionProduct =
    72       new G4ReactionProduct(G4Triton::TritonDefinition());
    73     theReactionProduct->SetMomentum(GetMomentum().vect());
    74     theReactionProduct->SetTotalEnergy(GetMomentum().e());
    75 #ifdef PRECOMPOUND_TEST
    76     theReactionProduct->SetCreatorModel("G4PrecompoundModel");
    77 #endif
    78     return theReactionProduct;
    79   }   
    80    
    81 private:
    82   virtual G4double GetAlpha()
    83   {
    84     G4double C = 0.0;
    85     G4double aZ = GetZ() + GetRestZ();
    86     if (aZ >= 70)
    87       {
    88         C = 0.10;
    89       }
    90     else
    91       {
    92         C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375;
    93       }
    94    
    95     return 1.0 + C/3.0;
    96   }
    97  
    98   virtual G4double GetBeta()
    99   {
    100     return -GetCoulombBarrier();
    101   }
    102 
    103 
    104 
    105   virtual G4double GetSpinFactor()
    106   {
    107     // 2s+1
    108     return 2.0;
    109   }
    110 
    111   virtual G4double K(const G4Fragment& aFragment);
    112 
    113 private:
    114  
    11568  G4TritonCoulombBarrier theTritonCoulombBarrier;
    116  
    11769};
    11870

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4LowEIonFragmentation.hh

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 // $Id: G4LowEIonFragmentation.hh,v 1.5 2010/06/11 15:34:18 vnivanch Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4LowEIonFragmentation.hh,v 1.6 2010/08/20 07:42:19 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2828//
    2929//---------------------------------------------------------------------------
    3030//
    31 // $Id: G4LowEIonFragmentation.hh,v 1.5 2010/06/11 15:34:18 vnivanch Exp $
    32 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     31// $Id: G4LowEIonFragmentation.hh,v 1.6 2010/08/20 07:42:19 vnivanch Exp $
     32// GEANT4 tag $Name: geant4-09-03-ref-09 $
    3333//
    3434// ClassName:   G4LowEIonFragmentation
    … …  
    5757  G4LowEIonFragmentation();
    5858
    59   ~G4LowEIonFragmentation();
     59  virtual ~G4LowEIonFragmentation();
    6060
    61 private:
    62  
    63   G4LowEIonFragmentation(const G4LowEIonFragmentation &);
    64  
    65   const G4LowEIonFragmentation& operator=(const G4LowEIonFragmentation &right);
    66 
    67   G4bool operator==(const G4LowEIonFragmentation &right) const;
    68  
    69   G4bool operator!=(const G4LowEIonFragmentation &right) const;
    70 
    71 public:
    72 
    73   G4HadFinalState * ApplyYourself(const G4HadProjectile & thePrimary, G4Nucleus & theNucleus);
     61  virtual G4HadFinalState * ApplyYourself(const G4HadProjectile & thePrimary,
     62                                          G4Nucleus & theNucleus);
    7463
    7564  static G4double GetCrossSection()
    7665  {
    77 //    clog << "area/millibarn = "<<area/millibarn<<G4endl;
    78 //    clog << "hits = "<<hits<<G4endl;
    79 //    clog << "totalTries = "<<totalTries<<G4endl;
     66    //    clog << "area/millibarn = "<<area/millibarn<<G4endl;
     67    //    clog << "hits = "<<hits<<G4endl;
     68    //    clog << "totalTries = "<<totalTries<<G4endl;
    8069    return area*static_cast<G4double>(hits)/static_cast<G4double>(totalTries)/millibarn;
    8170  }
     71
    8272private: 
    8373
     74  G4LowEIonFragmentation(const G4LowEIonFragmentation &); 
     75  const G4LowEIonFragmentation& operator=(const G4LowEIonFragmentation &right);
     76  G4bool operator==(const G4LowEIonFragmentation &right) const;
     77  G4bool operator!=(const G4LowEIonFragmentation &right) const;
     78
     79  // Members
    8480 
    8581  G4HadFinalState theResult;
    … …  
    8985 
    9086private:
     87
    9188  static G4int hits;
    9289  static G4int totalTries;

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4PreCompoundAlpha.hh

    r962 r1340  
    2424// ********************************************************************
    2525//
     26// $Id: G4PreCompoundAlpha.hh,v 1.12 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
     28//
    2629// by V. Lara
    2730//
    28 //J. M. Quesada (July 08)
    29 
     31// Modified:
     32// J. M. Quesada (July 08) cleanup
     33// 20.08.2010 V.Ivanchenko added int Z and A and cleanup; added
     34//                        G4ParticleDefinition to constructor,
     35//                        moved constructor and destructor to source
    3036
    3137#ifndef G4PreCompoundAlpha_h
    … …  
    3339
    3440#include "G4PreCompoundIon.hh"
    35 #include "G4ReactionProduct.hh"
    36 #include "G4Alpha.hh"
    3741#include "G4AlphaCoulombBarrier.hh"
    38 #include "G4PreCompoundParameters.hh"
    3942
    4043class G4PreCompoundAlpha : public G4PreCompoundIon
    4144{
    4245public:
    43   // default constructor
    44   G4PreCompoundAlpha():G4PreCompoundIon(4,2,&theAlphaCoulombBarrier,"Alpha") {}
    4546
    46   // copy constructor
    47   G4PreCompoundAlpha(const G4PreCompoundAlpha &right): G4PreCompoundIon(right){}
     47  G4PreCompoundAlpha();
    4848
    49   // destructor
    50   ~G4PreCompoundAlpha() {}
     49  virtual ~G4PreCompoundAlpha();
    5150
    52   // operators 
    53   const G4PreCompoundAlpha & operator=(const G4PreCompoundAlpha &right) {
    54     if (&right != this) this->G4PreCompoundIon::operator=(right);
    55     return *this;
    56   };
     51protected:
    5752
    58   G4bool operator==(const G4PreCompoundAlpha &right) const
    59   { return G4PreCompoundIon::operator==(right);}
     53  virtual G4double GetRj(G4int NumberParticles, G4int NumberCharged);
    6054
     55  virtual G4double CrossSection(G4double ekin) ;
     56
     57  virtual G4double FactorialFactor(G4int N, G4int P);
     58
     59  virtual G4double CoalescenceFactor(G4int A);
     60
     61  virtual G4double GetAlpha();
     62
     63  G4double GetOpt12(G4double K);
     64
     65  G4double GetOpt34(G4double K);
    6166 
    62   G4bool operator!=(const G4PreCompoundAlpha &right) const
    63   { return G4PreCompoundIon::operator!=(right);}
    64 
    65 
    66   G4ReactionProduct * GetReactionProduct() const;
    67 
    6867private:
    6968
    70   virtual G4double GetRj(const G4int NumberParticles, const G4int NumberCharged);
     69  // operators
     70  G4PreCompoundAlpha(const G4PreCompoundAlpha &right);
     71  const G4PreCompoundAlpha&
     72  operator= (const G4PreCompoundAlpha &right);
     73  G4int operator==(const G4PreCompoundAlpha &right) const;
     74  G4int operator!=(const G4PreCompoundAlpha &right) const;   
    7175
    72   virtual G4double CrossSection(const  G4double K) ;
    73 
    74   virtual G4double FactorialFactor(const G4double N, const G4double P);
    75 
    76   virtual G4double CoalescenceFactor(const G4double A);
    77 
    78   G4double GetOpt0(const G4double K);
    79   G4double GetOpt12(const G4double K);
    80   G4double GetOpt34(const G4double K);
    81 
    82   G4double GetAlpha();
    83  
    84   G4double GetBeta();
    85 
    86 //data members
    87 
    88       G4AlphaCoulombBarrier theAlphaCoulombBarrier;
    89       G4double ResidualA;
    90       G4double ResidualZ;
    91       G4double theA;
    92       G4double theZ;
    93       G4double ResidualAthrd;
    94       G4double FragmentA;
    95       G4double FragmentAthrd;
     76  G4AlphaCoulombBarrier theAlphaCoulombBarrier;
     77  G4double ResidualAthrd;
     78  G4double FragmentAthrd;
     79  G4int FragmentA;
     80  G4int ResidualA;
     81  G4int ResidualZ;
     82  G4int theA;
     83  G4int theZ;
    9684
    9785};

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4PreCompoundDeuteron.hh

    r962 r1340  
    2424// ********************************************************************
    2525//
     26// $Id: G4PreCompoundDeuteron.hh,v 1.13 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
     28//
    2629// by V. Lara
    2730//
    28 //J. M. Quesada (July 08)
     31// Modified:
     32// J. M. Quesada (July 08) cleanup
     33// 20.08.2010 V.Ivanchenko added int Z and A and cleanup; added
     34//                        G4ParticleDefinition to constructor,
     35//                        moved constructor and destructor to source
    2936
    3037#ifndef G4PreCompoundDeuteron_h
    … …  
    3239
    3340#include "G4PreCompoundIon.hh"
    34 #include "G4ReactionProduct.hh"
    35 #include "G4Deuteron.hh"
    3641#include "G4DeuteronCoulombBarrier.hh"
    37 #include "G4PreCompoundParameters.hh"
    38 
    3942
    4043class G4PreCompoundDeuteron : public G4PreCompoundIon
    4144{
    4245public:
    43   // default constructor
    44   G4PreCompoundDeuteron():G4PreCompoundIon(2,1,&theDeuteronCoulombBarrier,"Deuteron") {}
    4546
    46   // copy constructor
    47   G4PreCompoundDeuteron(const G4PreCompoundDeuteron &right): G4PreCompoundIon(right) {}
     47  G4PreCompoundDeuteron();
    4848
    49   // destructor
    50   ~G4PreCompoundDeuteron() {}
     49  ~G4PreCompoundDeuteron();
    5150
    52   // operators 
    53   const G4PreCompoundDeuteron & operator=(const G4PreCompoundDeuteron &right) {
    54     if (&right != this) this->G4PreCompoundIon::operator=(right);
    55     return *this;
    56   }
     51protected:
    5752
    58   G4bool operator==(const G4PreCompoundDeuteron &right) const
    59   { return G4PreCompoundIon::operator==(right);}
     53  virtual G4double GetRj(G4int NumberParticles, G4int NumberCharged);
    6054
     55  virtual G4double CrossSection(G4double ekin);
     56
     57  virtual G4double FactorialFactor(G4int N, G4int P);
     58
     59  virtual G4double CoalescenceFactor(G4int A);
     60
     61  virtual G4double GetAlpha();
    6162 
    62   G4bool operator!=(const G4PreCompoundDeuteron &right) const
    63   { return G4PreCompoundIon::operator!=(right);}
     63  G4double GetOpt12(G4double K);
    6464
     65  G4double GetOpt34(G4double K);
    6566
    66   G4ReactionProduct * GetReactionProduct() const;
    67 
    68  
    6967private:
    7068
    71   virtual G4double GetRj(const G4int NumberParticles, const G4int NumberCharged);
     69  // operators
     70  G4PreCompoundDeuteron(const G4PreCompoundDeuteron &right);
     71  const G4PreCompoundDeuteron&
     72  operator= (const G4PreCompoundDeuteron &right);
     73  G4int operator==(const G4PreCompoundDeuteron &right) const;
     74  G4int operator!=(const G4PreCompoundDeuteron &right) const;   
    7275
    73   virtual G4double CrossSection(const  G4double K) ;
     76  G4DeuteronCoulombBarrier theDeuteronCoulombBarrier;
     77  G4int ResidualA;
     78  G4int ResidualZ;
     79  G4int theA;
     80  G4int theZ;
     81  G4int FragmentA;
     82  G4double ResidualAthrd;
     83  G4double FragmentAthrd;
     84};
    7485
    75   virtual G4double FactorialFactor(const G4double N, const G4double P);
    76 
    77   virtual G4double CoalescenceFactor(const G4double A);
    78 
    79   G4double GetOpt0(const G4double K);
    80   G4double GetOpt12(const G4double K);
    81   G4double GetOpt34(const G4double K);
    82 
    83   G4double GetAlpha();
    84  
    85   G4double GetBeta();
    86 
    87 //data members
    88 
    89       G4DeuteronCoulombBarrier theDeuteronCoulombBarrier;
    90       G4double ResidualA;
    91       G4double ResidualZ;
    92       G4double theA;
    93       G4double theZ;
    94       G4double ResidualAthrd;
    95       G4double FragmentA;
    96       G4double FragmentAthrd;
    97 
    98 };
    9986#endif
    10087

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4PreCompoundEmission.hh

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 // $Id: G4PreCompoundEmission.hh,v 1.7 2009/11/12 14:33:44 gunter Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4PreCompoundEmission.hh,v 1.9 2010/09/01 14:51:21 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2828//
    2929// Hadronic Process: Nuclear Preequilibrium
    … …  
    3434// JMQ (06 September 2008) Also external choice has been added for:
    3535//                      - superimposed Coulomb barrier (if useSICB=true)
     36// 20.08.2010 V.Ivanchenko added G4Pow and G4PreCompoundParameters pointers
     37//                         use int Z and A and cleanup;
     38//                         inline methods moved from icc file to hh
    3639
    3740#ifndef G4PreCompoundEmission_h
    … …  
    4144#include "G4ReactionProduct.hh"
    4245#include "G4Fragment.hh"
    43 #include "Randomize.hh"
    44 #include "G4PreCompoundParameters.hh"
    4546#include "G4PreCompoundFragmentVector.hh"
    4647
    4748class G4VPreCompoundEmissionFactory;
    4849
     50class G4Pow;
     51class G4PreCompoundParameters;
    4952
    5053class G4PreCompoundEmission
    5154{
    5255public:
     56
    5357  G4PreCompoundEmission();
     58
    5459  ~G4PreCompoundEmission();
    5560
     61  void SetDefaultModel();
     62
     63  void SetHETCModel();
     64
     65  G4ReactionProduct * PerformEmission(G4Fragment & aFragment);
     66
     67  inline G4double GetTotalProbability(const G4Fragment & aFragment);
     68
     69  inline void Initialize(const G4Fragment & aFragment);
     70
     71  inline void SetOPTxs(G4int);
     72
     73  inline void UseSICB(G4bool);
     74
    5675private:
     76
     77  void AngularDistribution(G4VPreCompoundFragment * theFragment,
     78                           const G4Fragment& aFragment,
     79                           G4double KineticEnergy);
     80               
     81  G4double rho(G4int p, G4int h, G4double g, G4double E, G4double Ef) const;
     82
    5783  G4PreCompoundEmission(const G4PreCompoundEmission &right);
    5884  const G4PreCompoundEmission& operator=(const G4PreCompoundEmission &right);
    … …  
    6086  G4bool operator!=(const G4PreCompoundEmission &right) const;
    6187
    62 public:
    63 
    64   inline void SetUp(const G4Fragment & aFragment);
    65   inline void Initialize(const G4Fragment & aFragment);
    66        
    67   inline G4double GetTotalProbability(const G4Fragment & aFragment);
    68        
    69   G4ReactionProduct * PerformEmission(G4Fragment & aFragment);
    70 
    71   void SetDefaultModel();
    72   void SetHETCModel();
    73 
    74 private:
    75 
    76   G4ThreeVector AngularDistribution(G4VPreCompoundFragment * theFragment,
    77                                     const G4Fragment& aFragment,
    78                                     const G4double KineticEnergy) const;
    79                
    80 
    81 
    82   G4double rho(const G4double p, const G4double h, const G4double g,
    83                const G4double E, const G4double Ef) const;
    84 
    85   G4double factorial(G4double a) const;
    86   G4double logfactorial(G4double a) const;
    87 
    88   //for inverse cross section choice
    89 public:
    90   inline void SetOPTxs(G4int);
    91   //for superimposed CoulomBarrier for inverse cross sections
    92   inline void UseSICB(G4bool);
    93 
    94 
    9588  //==============
    9689  // Data Members
    9790  //==============
     91
     92  G4Pow* g4pow;
     93  G4PreCompoundParameters* theParameters;
    9894
    9995  // A vector with the allowed emission fragments
    … …  
    10197  G4VPreCompoundEmissionFactory * theFragmentsFactory;
    10298
    103   // Projectile energy
    104   G4double ProjEnergy;
    105 
    106   // Projectile direction
    107   G4ThreeVector theIncidentDirection;
    108 
     99  // Momentum of emitted fragment
     100  G4ThreeVector theFinalMomentum;
    109101};
    110102
    111 #include "G4PreCompoundEmission.icc"
     103inline G4double
     104G4PreCompoundEmission::GetTotalProbability(const G4Fragment& aFragment)
     105{
     106  return theFragmentsVector->CalculateProbabilities(aFragment);
     107}
     108
     109inline void
     110G4PreCompoundEmission::Initialize(const G4Fragment& aFragment)
     111{
     112  theFragmentsVector->Initialize(aFragment);
     113}
     114
     115inline void G4PreCompoundEmission::SetOPTxs(G4int opt)
     116{
     117  theFragmentsVector->SetOPTxs(opt);
     118}
     119
     120inline void G4PreCompoundEmission::UseSICB(G4bool use)
     121{
     122  theFragmentsVector->UseSICB(use);
     123}
    112124
    113125#endif

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4PreCompoundEmission.icc

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 // $Id: G4PreCompoundEmission.icc,v 1.5 2009/02/10 16:01:37 vnivanch Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4PreCompoundEmission.icc,v 1.6 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2828//
    2929//
    … …  
    3636//                      - superimposed Coulomb barrier (if useSICB=true)
    3737
    38 inline void G4PreCompoundEmission::Initialize(const G4Fragment & aFragment)
    39 {
    40   theFragmentsVector->Initialize(aFragment);
    41   return;
    42 }
    4338
    44 inline G4double G4PreCompoundEmission::GetTotalProbability(const G4Fragment & aFragment)
    45 {
    46   return theFragmentsVector->CalculateProbabilities(aFragment);
    47 }
    48 
    49 inline void G4PreCompoundEmission::SetUp(const G4Fragment & aFragment)
    50 {
    51   // This should be the projectile energy. If I would know which is the projectile (proton, neutron)
    52   // I could remove the binding energy. But, what happens if INC precedes precompound? This approximation
    53   // seems to work well enough
    54   ProjEnergy = aFragment.GetExcitationEnergy();
    55   theIncidentDirection = aFragment.GetMomentum().vect().unit();
    56   theFragmentsVector->ResetStage();
    57   return;
    58 }
    59 
    60 //for inverse cross section choice
    61 inline void G4PreCompoundEmission::SetOPTxs(G4int opt)
    62 {
    63   theFragmentsVector->SetOPTxs(opt);
    64   return;
    65 }
    66 //for superimposed Coumlomb Barrier for inverse cross sections
    67 inline void G4PreCompoundEmission::UseSICB(G4bool use)
    68 {
    69   theFragmentsVector->UseSICB(use);
    70   return;
    71 }
    72 

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4PreCompoundEmissionFactory.hh

    r819 r1340  
    2424// ********************************************************************
    2525//
     26// $Id: G4PreCompoundEmissionFactory.hh,v 1.3 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
     28//
     29//
     30
    2631#ifndef G4PreCompoundEmissionFactory_hh
    2732#define G4PreCompoundEmissionFactory_hh
    … …  
    2934#include "G4VPreCompoundEmissionFactory.hh"
    3035
    31 
    3236class G4PreCompoundEmissionFactory : public G4VPreCompoundEmissionFactory
    3337{
    3438public:
    3539
    36   G4PreCompoundEmissionFactory() {};
    37   virtual ~G4PreCompoundEmissionFactory() {};
     40  G4PreCompoundEmissionFactory();
     41  virtual ~G4PreCompoundEmissionFactory();
     42
     43protected:
     44
     45  virtual std::vector<G4VPreCompoundFragment*> *  CreateFragmentVector();
    3846
    3947private:
    4048
    41   G4PreCompoundEmissionFactory(const G4PreCompoundEmissionFactory & ) : G4VPreCompoundEmissionFactory() {};
    42   const G4PreCompoundEmissionFactory & operator=(const G4PreCompoundEmissionFactory & val);
     49  G4PreCompoundEmissionFactory(const G4PreCompoundEmissionFactory & );
     50  const G4PreCompoundEmissionFactory & operator=
     51  (const G4PreCompoundEmissionFactory & val);
    4352  G4bool operator==(const G4PreCompoundEmissionFactory & val) const;
    4453  G4bool operator!=(const G4PreCompoundEmissionFactory & val) const;
    45 
    46 private:
    47 
    48   virtual std::vector<G4VPreCompoundFragment*> *  CreateFragmentVector();
    4954
    5055};

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4PreCompoundFragment.hh

    r962 r1340  
    2424// ********************************************************************
    2525//
    26 //J. M. Quesada (August 2008). 
    27 //Based  on previous work by V. Lara
     26// $Id: G4PreCompoundFragment.hh,v 1.6 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2828//
    29 // Modif (03 September 2008) by J. M. Quesada for external choice of inverse
    30 // cross section option (default OPTxs=2)
    31 // JMQ (06 September 2008) Also external choice has been added for
    32 // superimposed Coulomb barrier (if useSICB=true, default false)
    33 
     29//  J. M. Quesada (August 2008). 
     30//  Based  on previous work by V. Lara
     31//
     32// Modified:
     33// 03.09.2008 by J. M. Quesada for external choice of inverse
     34//                    cross section option (default OPTxs=2)
     35// 06.09.2008 by JMQ Also external choice has been added for
     36//     superimposed Coulomb barrier (if useSICB=true, default false)
     37// 20.08.2010 V.Ivanchenko added int Z and A and cleanup; added
     38//                        G4ParticleDefinition to constructor
    3439
    3540#ifndef G4PreCompoundFragment_h
    … …  
    4045class G4PreCompoundFragment : public G4VPreCompoundFragment
    4146{
    42 protected:
    43   // default constructor
    44   G4PreCompoundFragment() {};
    45    
    4647public: 
    47   // copy constructor
    48   G4PreCompoundFragment(const G4PreCompoundFragment &right);
    49    
    50   // constructor 
    51   G4PreCompoundFragment(const G4double anA, const G4double aZ,
    52                         G4VCoulombBarrier * aCoulombBarrier,
    53                         const G4String &  aName);
     48
     49  G4PreCompoundFragment(const G4ParticleDefinition*,
     50                        G4VCoulombBarrier * aCoulombBarrier);
    5451 
    5552  virtual ~G4PreCompoundFragment();
    56  
    57   // ==========
    58   // operators
    59   // ==========
    60  
    61   const G4PreCompoundFragment&
    62   operator= (const G4PreCompoundFragment &right);
    63  
    64   G4int operator==(const G4PreCompoundFragment &right) const;
    65  
    66   G4int operator!=(const G4PreCompoundFragment &right) const;
    6753     
    68 public:
    69  
    70   // Initialization method
    71 //  void Initialize(const G4Fragment & aFragment);
    72    
    7354  // ================================================
    7455  // Methods for calculating the emission probability
    … …  
    8162  G4double GetKineticEnergy(const G4Fragment & aFragment);
    8263
     64protected:
     65
     66  virtual G4double
     67  ProbabilityDistributionFunction(G4double K,
     68                                  const G4Fragment & aFragment) = 0;
     69
    8370private:       
    8471  // This method performs integration for probability function over
    8572  // fragment kinetic energy
    86   G4double IntegrateEmissionProbability(const G4double & Low,
    87                                         const G4double & Up,
     73  G4double IntegrateEmissionProbability(G4double Low,
     74                                        G4double Up,
    8875                                        const G4Fragment & aFragment); 
    89 protected:
    9076
    91   virtual G4double
    92   ProbabilityDistributionFunction(const G4double K,
    93                                   const G4Fragment & aFragment) = 0;
     77  // default constructor
     78  G4PreCompoundFragment();
     79  // operators
     80  G4PreCompoundFragment(const G4PreCompoundFragment &right);
     81  const G4PreCompoundFragment&
     82  operator= (const G4PreCompoundFragment &right);
     83  G4int operator==(const G4PreCompoundFragment &right) const;
     84  G4int operator!=(const G4PreCompoundFragment &right) const;
    9485
    9586};

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4PreCompoundFragmentVector.hh

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 //
    27 // $Id: G4PreCompoundFragmentVector.hh,v 1.6 2009/02/10 16:01:37 vnivanch Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4PreCompoundFragmentVector.hh,v 1.7 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2928//
    3029// Hadronic Process: Nuclear Preequilibrium
    3130// by V. Lara
    3231//
    33 // Modif (03 September 2008) by J. M. Quesada for external choice of inverse
     32// Modified:
     33// 03.09.2008 by J. M. Quesada for external choice of inverse
    3434// cross section option
    35 // JMQ (06 September 2008) Also external choice has been added for:
    36 //                      - superimposed Coulomb barrier (if useSICB=true)
     35// 06.09.2008 JMQ Also external choice has been added for:
     36//                - superimposed Coulomb barrier (if useSICB=true)
     37// 27.08.2010 V.Ivanchenko simplify and make more efficient by adding extra
     38//            vector of probabilities, moved constructor and destructor to source,
     39//            simplify run time computations making inlined
     40//
    3741
    3842#ifndef G4PreCompoundFragmentVector_h
    … …  
    4044
    4145#include "G4VPreCompoundFragment.hh"
     46#include "G4DataVector.hh"
     47#include "Randomize.hh"
     48#include "globals.hh"
     49#include <vector>
     50
     51typedef std::vector<G4VPreCompoundFragment*>  pcfvector;
    4252
    4353class G4PreCompoundFragmentVector
    4454{
    45   typedef std::vector<G4VPreCompoundFragment*>  pcfvector;
    4655public:
    47   inline G4PreCompoundFragmentVector(pcfvector * avector);
    48   inline ~G4PreCompoundFragmentVector();
    49  
     56
     57  G4PreCompoundFragmentVector(pcfvector * avector);
     58
     59  ~G4PreCompoundFragmentVector();
     60
     61  void SetVector(pcfvector * avector);
     62
     63  void SetOPTxs(G4int);
     64
     65  void UseSICB(G4bool);
     66
     67  inline void Initialize(const G4Fragment & aFragment);
     68
     69  inline G4double CalculateProbabilities(const G4Fragment & aFragment);
     70       
     71  inline G4VPreCompoundFragment * ChooseFragment();
     72                 
    5073private:
     74
    5175  G4PreCompoundFragmentVector(const G4PreCompoundFragmentVector &right);
    5276  const G4PreCompoundFragmentVector&
    … …  
    5579  G4bool operator!=(const G4PreCompoundFragmentVector &right) const;   
    5680 
    57 public:
     81  pcfvector * theChannels;
     82  G4DataVector probabilities;
    5883
    59   inline void Initialize(const G4Fragment & aFragment);
    60   inline void ResetStage();
    61   inline void SetVector(pcfvector * avector);
    62 
    63   G4double CalculateProbabilities(const G4Fragment & aFragment);
    64        
    65   G4VPreCompoundFragment * ChooseFragment(void);
    66                
    67 private:
    68 
    69   pcfvector * theChannels;
    70 
    71   G4double TotalEmissionProbability;
    72 
    73 //for inverse cross section choice
    74 public:
    75   inline void SetOPTxs(G4int);
    76   //for superimposed CoulomBarrier for inverse cross sections
    77   inline void UseSICB(G4bool);
    78 
     84  G4int nChannels;
    7985
    8086};
    8187
    82 #include "G4PreCompoundFragmentVector.icc"
     88inline void
     89G4PreCompoundFragmentVector::Initialize(const G4Fragment & aFragment)
     90{
     91  for (G4int i=0; i< nChannels; ++i) {
     92    (*theChannels)[i]->Initialize(aFragment);
     93  }
     94}
     95
     96inline G4double
     97G4PreCompoundFragmentVector::CalculateProbabilities(const G4Fragment & aFragment)
     98{
     99  //G4cout << "## G4PreCompoundFragmentVector::CalculateProbabilities" << G4endl;
     100  G4double probtot = 0.0;
     101  for (G4int i=0; i< nChannels; ++i) {
     102    G4double prob = (*theChannels)[i]->CalcEmissionProbability(aFragment);
     103    probtot += prob;
     104    probabilities[i] = probtot;
     105    //G4cout<<" prob= "<<prob<<" for "<<(*theChannels)[i]->GetName()<<G4endl;
     106  }
     107  return probtot;
     108}
     109
     110inline G4VPreCompoundFragment* G4PreCompoundFragmentVector::ChooseFragment()
     111{
     112  G4double x = probabilities[nChannels-1]*G4UniformRand();
     113  G4int i=0;
     114  for (; i<nChannels; ++i) {
     115    if(x <= probabilities[i]) { break; }
     116  }
     117  return (*theChannels)[i]; 
     118}
    83119
    84120#endif

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4PreCompoundFragmentVector.icc

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4PreCompoundFragmentVector.icc,v 1.4 2008/09/22 10:18:36 ahoward Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4PreCompoundFragmentVector.icc,v 1.5 2010/08/28 15:16:55 vnivanch Exp $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030// Hadronic Process: Nuclear Preequilibrium
    … …  
    3636//                      - superimposed Coulomb barrier (if useSICB=true)
    3737
    38 inline G4PreCompoundFragmentVector::G4PreCompoundFragmentVector(pcfvector * avector) :
    39   theChannels(avector), TotalEmissionProbability(0.0)
    40 {
    41 }
    4238
    43 
    44 inline G4PreCompoundFragmentVector::~G4PreCompoundFragmentVector()
    45 {
    46 }
    47 
    48 inline void G4PreCompoundFragmentVector::SetVector(pcfvector * avector)
    49 {
    50   theChannels = avector;
    51 }
    52 
    53 inline void
    54 G4PreCompoundFragmentVector::
    55 Initialize(const G4Fragment & aFragment)
    56 {
    57     TotalEmissionProbability = 0.0;
    58     for (pcfvector::iterator i=theChannels->begin();
    59          i != theChannels->end(); i++) (*i)->Initialize(aFragment);
    60     return;
    61 }
    62 
    63 inline void G4PreCompoundFragmentVector::
    64 ResetStage()
    65 {
    66   for (pcfvector::iterator i=theChannels->begin(); i != theChannels->end(); i++)
    67     (*i)->ResetStage();
    68   return;
    69 }
    70 
    71 //for inverse cross section choice
    72 inline void G4PreCompoundFragmentVector::
    73 SetOPTxs(G4int opt)
    74 {   
    75   for (pcfvector::iterator i = theChannels->begin(); i != theChannels->end(); ++i)
    76     (*i)->SetOPTxs(opt);
    77   return;
    78 }
    79 
    80 //for superimposed Coulomb Barrier for inverse  cross sections
    81 inline void G4PreCompoundFragmentVector::
    82 UseSICB(G4bool use)
    83 {   
    84   for (pcfvector::iterator i = theChannels->begin(); i != theChannels->end(); ++i)
    85     (*i)->UseSICB(use);
    86   return;
    87 }

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4PreCompoundHe3.hh

    r962 r1340  
    2424// ********************************************************************
    2525//
     26// $Id: G4PreCompoundHe3.hh,v 1.11 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
     28//
    2629// by V. Lara
    2730//
    28 //J. M. Quesada (July 08)
     31// Modified:
     32// J. M. Quesada (July 08) cleanup
     33// 20.08.2010 V.Ivanchenko added int Z and A and cleanup; added
     34//                        G4ParticleDefinition to constructor,
     35//                        moved constructor and destructor to source
    2936
    3037#ifndef G4PreCompoundHe3_h
    … …  
    3239
    3340#include "G4PreCompoundIon.hh"
    34 #include "G4ReactionProduct.hh"
    35 #include "G4He3.hh"
    3641#include "G4He3CoulombBarrier.hh"
    37 #include "G4PreCompoundParameters.hh"
    3842
    3943class G4PreCompoundHe3 : public G4PreCompoundIon
    4044{
    4145public:
    42   // default constructor
    43   G4PreCompoundHe3():G4PreCompoundIon(3,2,&theHe3CoulombBarrier,"He3") {}
    4446
    45   // copy constructor
    46   G4PreCompoundHe3(const G4PreCompoundHe3 &right): G4PreCompoundIon(right) {}
     47  G4PreCompoundHe3();
    4748
    48   // destructor
    49   ~G4PreCompoundHe3() {}
     49  virtual ~G4PreCompoundHe3();
    5050
    51   // operators 
    52   const G4PreCompoundHe3 & operator=(const G4PreCompoundHe3 &right) {
    53     if (&right != this) this->G4PreCompoundIon::operator=(right);
    54     return *this;
    55   }
     51protected:
    5652
    57   G4bool operator==(const G4PreCompoundHe3 &right) const
    58   { return G4PreCompoundIon::operator==(right);}
     53  virtual G4double GetRj(G4int NumberParticles, G4int NumberCharged);
    5954
     55  virtual G4double CrossSection(G4double ekin) ;
     56
     57  virtual G4double FactorialFactor(G4int N, G4int P);
     58
     59  virtual G4double CoalescenceFactor(G4int A);
     60
     61  virtual G4double GetAlpha();
    6062 
    61   G4bool operator!=(const G4PreCompoundHe3 &right) const
    62   { return G4PreCompoundIon::operator!=(right);}
     63  G4double GetOpt12(G4double K);
    6364
    64 
    65   G4ReactionProduct * GetReactionProduct() const;
    66  
     65  G4double GetOpt34(G4double K);
    6766
    6867private:
    6968
    70   virtual G4double GetRj(const G4int NumberParticles, const G4int NumberCharged);
     69  // operators
     70  G4PreCompoundHe3(const G4PreCompoundHe3 &right);
     71  const G4PreCompoundHe3&
     72  operator= (const G4PreCompoundHe3 &right);
     73  G4int operator==(const G4PreCompoundHe3 &right) const;
     74  G4int operator!=(const G4PreCompoundHe3 &right) const;   
    7175
    72   virtual G4double CrossSection(const  G4double K) ;
     76  G4He3CoulombBarrier theHe3CoulombBarrier;
     77  G4double ResidualAthrd;
     78  G4double FragmentAthrd;
     79  G4int FragmentA;
     80  G4int ResidualA;
     81  G4int ResidualZ;
     82  G4int theA;
     83  G4int theZ;
     84};
    7385
    74   virtual G4double FactorialFactor(const G4double N, const G4double P);
    75 
    76   virtual G4double CoalescenceFactor(const G4double A);
    77 
    78   G4double GetOpt0(const G4double K);
    79   G4double GetOpt12(const G4double K);
    80   G4double GetOpt34(const G4double K);
    81 
    82   G4double GetAlpha();
    83  
    84   G4double GetBeta();
    85 
    86 //data members
    87 
    88       G4He3CoulombBarrier theHe3CoulombBarrier;
    89         G4double ResidualA;
    90       G4double ResidualZ;
    91       G4double theA;
    92       G4double theZ;
    93       G4double ResidualAthrd;
    94       G4double FragmentA;
    95       G4double FragmentAthrd;
    96 
    97 
    98 };
    9986#endif
    10087

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4PreCompoundIon.hh

    r962 r1340  
    2424// ********************************************************************
    2525//
    26 //J. M. Quesada (August 2008). 
    27 //Based  on previous work by V. Lara
     26// $Id: G4PreCompoundIon.hh,v 1.8 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2828//
     29// J. M. Quesada (August 2008). 
     30// Based  on previous work by V. Lara
     31//
     32// Modified:
     33// 20.08.2010 V.Ivanchenko added int Z and A and cleanup; added
     34//                        G4ParticleDefinition to constructor,
     35//                        moved constructor and destructor to source,
     36//                        added inline methods
    2937
    3038#ifndef G4PreCompoundIon_h
    … …  
    3543class G4PreCompoundIon : public G4PreCompoundFragment
    3644{
    37 protected:
    38   // default constructor
    39   G4PreCompoundIon() {}
    40 
    4145public:
    4246
    43   // copy constructor
    44   G4PreCompoundIon(const G4PreCompoundIon &right):
    45     G4PreCompoundFragment(right) {}
    46    
    47   // constructor 
    48   G4PreCompoundIon(const G4double anA,
    49                    const G4double aZ,
    50                    G4VCoulombBarrier* aCoulombBarrier,
    51                    const G4String & aName):
    52     G4PreCompoundFragment(anA,aZ,aCoulombBarrier,aName) {}
    53    
    54   virtual ~G4PreCompoundIon() {}
    55    
    56   // operators 
    57   const G4PreCompoundIon &
    58   operator=(const G4PreCompoundIon &right)
    59   {
    60     if (&right != this) this->G4PreCompoundFragment::operator=(right);
    61     return *this;
    62   }
    63    
    64   G4bool operator==(const G4PreCompoundIon &right) const
    65   {
    66     return G4PreCompoundFragment::operator==(right);
    67   }
    68    
    69   G4bool operator!=(const G4PreCompoundIon &right) const
    70   {
    71     return G4PreCompoundFragment::operator!=(right);
    72   }
    73    
    74   virtual G4double ProbabilityDistributionFunction(const G4double eKin,
    75                                                    const G4Fragment& aFragment);
     47  G4PreCompoundIon(const G4ParticleDefinition*,
     48                   G4VCoulombBarrier * aCoulombBarrier);
     49 
     50  virtual ~G4PreCompoundIon();
    7651
    77   private:
     52protected:
     53         
     54  virtual G4double
     55  ProbabilityDistributionFunction(G4double eKin,
     56                                  const G4Fragment& aFragment);
    7857
    79   G4bool IsItPossible(const G4Fragment& aFragment) ;
    80  
    81   protected:
     58  virtual G4double CrossSection(G4double ekin) = 0;
    8259
    83   virtual G4double CrossSection(const G4double ekin)=0;
     60  virtual G4double
     61  GetRj(G4int NumberParticles, G4int NumberCharged) = 0;
    8462
    85   virtual G4double GetRj(const G4int NumberParticles, const G4int NumberCharged) = 0;
     63  virtual G4double FactorialFactor(G4int N, G4int P) = 0;
    8664
    87   virtual G4double FactorialFactor(const G4double N, const G4double P) = 0;
     65  virtual G4double CoalescenceFactor(G4int A) = 0;
    8866
    89   virtual G4double CoalescenceFactor(const G4double A) = 0;
     67  virtual G4double GetAlpha() = 0;
    9068
    91    };
     69  inline G4double GetBeta();
     70
     71  inline G4double GetOpt0(G4double ekin);
     72
     73private:
     74
     75  // default constructor
     76  G4PreCompoundIon();
     77  // operators
     78  G4PreCompoundIon(const G4PreCompoundIon &right);
     79  const G4PreCompoundIon&
     80  operator= (const G4PreCompoundIon &right);
     81  G4int operator==(const G4PreCompoundIon &right) const;
     82  G4int operator!=(const G4PreCompoundIon &right) const;   
     83
     84  G4double fact;
     85};
     86
     87inline G4double G4PreCompoundIon::GetBeta()
     88{
     89  return -GetCoulombBarrier();
     90}
     91
     92// *********************** OPT=0 : Dostrovski's cross section  ***************
     93inline G4double G4PreCompoundIon::GetOpt0(G4double K)
     94{
     95  G4double r0 = theParameters->Getr0()*ResidualA13();
     96  // cross section is now given in mb (r0 is in mm) for the sake of consistency
     97  //with the rest of the options
     98  return 1.e+25*CLHEP::pi*r0*r0*ResidualA13()*GetAlpha()*(1.+GetBeta()/K);
     99}
    92100
    93101#endif

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4PreCompoundModel.hh

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 //
    27 // $Id: G4PreCompoundModel.hh,v 1.7 2009/11/19 10:19:31 vnivanch Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4PreCompoundModel.hh,v 1.9 2010/08/20 07:41:48 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2928//
    3029// by V. Lara
    31 
     30//
    3231// Class Description
    3332// Model implementation for pre-equilibrium decay models in geant4.
    … …  
    3736// Class Description - End
    3837//
    39 // Modif (03 September 2008) by J. M. Quesada for external choice of inverse
    40 // cross section option.(default OPTxs=3)
    41 // JMQ (06 September 2008) Also external choices have been added for:
     38// Modified:
     39// 03.09.2008 J.M.Quesada added external choice of inverse
     40//            cross section option.(default OPTxs=3)
     41// 06.09.2008 J.M.Quesada external choices have been added for:
    4242//                - superimposed Coulomb barrier (if useSICB=true, default false)
    4343//                - "never go back"  hipothesis (if useNGB=true, default false)
    4444//                - soft cutoff from preeq. to equlibrium (if useSCO=true, default false)
    4545//                - CEM transition probabilities (if useCEMtr=true)
    46 // J. M. Quesada (30.10.09) : CEM transition probabilities are set as default
     46// 30.10.2009 J.M.Quesada CEM transition probabilities are set as default
     47// 20.08.2010 V.Ivanchenko Cleanup of the code - changed data members and inline methods
    4748
    4849#ifndef G4PreCompoundModel_h
    … …  
    5051
    5152#include "G4VPreCompoundModel.hh"
    52 #include "G4LorentzVector.hh"
    53 
    54 
    55 #include "G4NucleiProperties.hh"
    56 #include "G4PreCompoundParameters.hh"
    57 #include "G4ExcitationHandler.hh"
    5853#include "G4Fragment.hh"
    59 #include "Randomize.hh"
    60 
    61 //#include "G4PreCompoundEmission.hh"
    62 
    63 #include "G4DynamicParticle.hh"
    6454#include "G4ReactionProductVector.hh"
    6555#include "G4ReactionProduct.hh"
    66 #include "G4ParticleTypes.hh"
    67 #include "G4ParticleTable.hh"
     56#include "G4ExcitationHandler.hh"
    6857
    69 //#define debug
    70 //#define verbose
     58class G4PreCompoundParameters;
     59class G4PreCompoundEmission;
     60class G4VPreCompoundTransitions;
     61class G4ParticleDefinition;
    7162
    7263class G4PreCompoundModel : public G4VPreCompoundModel
    73 {
    74  
     64{
    7565public:
    7666
    … …  
    7969  virtual ~G4PreCompoundModel();
    8070
    81 private:
     71  virtual G4HadFinalState * ApplyYourself(const G4HadProjectile & thePrimary,
     72                                          G4Nucleus & theNucleus);
    8273
    83   G4PreCompoundModel();
     74  virtual G4ReactionProductVector* DeExcite(G4Fragment& aFragment);
    8475
    85   G4PreCompoundModel(const G4PreCompoundModel &);
     76  void UseHETCEmission();
     77  void UseDefaultEmission();
     78  void UseGNASHTransition();
     79  void UseDefaultTransition();
    8680
    87   const G4PreCompoundModel& operator=(const G4PreCompoundModel &right);
    88   G4bool operator==(const G4PreCompoundModel &right) const;
    89   G4bool operator!=(const G4PreCompoundModel &right) const;
     81  //for cross section selection
     82  void SetOPTxs(G4int opt);
    9083
    91 public:
    92 
    93   G4HadFinalState * ApplyYourself(const G4HadProjectile & thePrimary, G4Nucleus & theNucleus);
    94 
    95   G4ReactionProductVector* DeExcite(const G4Fragment& aFragment) const;
     84  //for the rest of external choices
     85  void UseSICB();
     86  void UseNGB();
     87  void UseSCO();
     88  void UseCEMtr();
    9689
    9790#ifdef PRECOMPOUND_TEST
    … …  
    10295#endif
    10396
    104   inline void UseHETCEmission() { useHETCEmission = true; }
    105   inline void UseDefaultEmission() { useHETCEmission = false; }
    106   inline void UseGNASHTransition() { useGNASHTransition = true; }
    107   inline void UseDefaultTransition() { useGNASHTransition = false; }
    108 
    109  //for cross section selection
    110   inline void SetOPTxs(G4int opt) { OPTxs = opt; }
    111 //for the rest of external choices
    112   inline void UseSICB() { useSICB = true; }
    113   inline void UseNGB()  { useNGB = true; }
    114   inline void UseSCO()  { useSCO = true; }
    115   inline void UseCEMtr() { useCEMtr = true; }
    11697private: 
    11798
     99  inline
    118100  void PerformEquilibriumEmission(const G4Fragment & aFragment,
    119101                                  G4ReactionProductVector * theResult) const;
    120102
    121 private:
     103  G4PreCompoundModel();
     104  G4PreCompoundModel(const G4PreCompoundModel &);
     105  const G4PreCompoundModel& operator=(const G4PreCompoundModel &right);
     106  G4bool operator==(const G4PreCompoundModel &right) const;
     107  G4bool operator!=(const G4PreCompoundModel &right) const;
    122108
    123109#ifdef debug                             
    … …  
    131117  //==============
    132118
     119  G4PreCompoundParameters*   theParameters;
     120  G4PreCompoundEmission*     theEmission;
     121  G4VPreCompoundTransitions* theTransition;
    133122
     123  const G4ParticleDefinition* proton;
     124  const G4ParticleDefinition* neutron;
    134125
    135   G4bool           useHETCEmission;
    136   G4bool           useGNASHTransition;
     126  G4bool useHETCEmission;
     127  G4bool useGNASHTransition;
    137128
    138 //for cross section options
     129  //for cross section options
    139130  G4int OPTxs;
    140 //for the rest of external choices
     131
     132  //for the rest of external choices
    141133  G4bool useSICB;
    142134  G4bool useNGB;
    … …  
    144136  G4bool useCEMtr;
    145137
    146 
    147     G4HadFinalState theResult;
     138  G4HadFinalState theResult;
    148139
    149140#ifdef PRECOMPOUND_TEST
    … …  
    151142  static std::vector<G4String*> theCreatorModels;
    152143#endif
     144};
    153145
    154 };
     146inline void
     147G4PreCompoundModel::PerformEquilibriumEmission(const G4Fragment & aFragment,
     148                                               G4ReactionProductVector * Result) const
     149{
     150  G4ReactionProductVector* theEquilibriumResult =
     151    GetExcitationHandler()->BreakItUp(aFragment);
     152  Result->insert(Result->end(),theEquilibriumResult->begin(), theEquilibriumResult->end());
     153  delete theEquilibriumResult;
     154}
     155
    155156#endif
    156157

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4PreCompoundNeutron.hh

    r962 r1340  
    2424// ********************************************************************
    2525//
     26// $Id: G4PreCompoundNeutron.hh,v 1.13 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2628//
    27 //J. M. Quesada (July  08)
    28 
     29// by V. Lara
     30//
     31// Modified:
     32// J. M. Quesada (July 08) cleanup
     33// 20.08.2010 V.Ivanchenko added int Z and A and cleanup; added
     34//                        G4ParticleDefinition to constructor,
     35//                        moved constructor and destructor to source
    2936
    3037#ifndef G4PreCompoundNeutron_h
    … …  
    3239
    3340#include "G4PreCompoundNucleon.hh"
    34 #include "G4ReactionProduct.hh"
    35 #include "G4Neutron.hh"
    36 #include "G4PreCompoundParameters.hh"
    37 #include "Randomize.hh"
    3841#include "G4NeutronCoulombBarrier.hh"
    39 
    4042
    4143class G4PreCompoundNeutron : public G4PreCompoundNucleon
    4244{
    4345public:
    44   // default constructor
    45   G4PreCompoundNeutron() : G4PreCompoundNucleon(1,0,&theNeutronCoulombBarrier,"Neutron") {}
    4646
    47   // copy constructor
    48   G4PreCompoundNeutron(const G4PreCompoundNeutron &right): G4PreCompoundNucleon(right) {}
     47  G4PreCompoundNeutron();
    4948
    50   // destructor
    51   ~G4PreCompoundNeutron() {}
     49  virtual ~G4PreCompoundNeutron();
    5250
    53   // operators 
    54   const G4PreCompoundNeutron & operator=(const G4PreCompoundNeutron &right) {
    55     if (&right != this) this->G4PreCompoundNucleon::operator=(right);
    56     return *this;
    57   }
     51protected:
    5852
    59   G4bool operator==(const G4PreCompoundNeutron &right) const
    60   { return G4PreCompoundNucleon::operator==(right);}
    61  
    62   G4bool operator!=(const G4PreCompoundNeutron &right) const
    63   { return G4PreCompoundNucleon::operator!=(right);}
     53  virtual G4double GetRj(G4int NumberParticles, G4int NumberCharged);
    6454
     55  virtual G4double CrossSection(G4double ekin);
    6556
    66   G4ReactionProduct * GetReactionProduct() const;
    67  
     57  virtual G4double GetAlpha();
     58
     59  virtual G4double GetBeta();
     60
     61  G4double GetOpt12(G4double K);
     62
     63  G4double GetOpt34(G4double K);
     64
    6865private:
    6966
    70   virtual G4double GetRj(const G4int NumberParticles, const G4int NumberCharged);
     67  // operators
     68  G4PreCompoundNeutron(const G4PreCompoundNeutron &right);
     69  const G4PreCompoundNeutron&
     70  operator= (const G4PreCompoundNeutron &right);
     71  G4int operator==(const G4PreCompoundNeutron &right) const;
     72  G4int operator!=(const G4PreCompoundNeutron &right) const;   
    7173
    72   virtual G4double CrossSection(const  G4double K);
    73 
    74 
    75   G4double GetOpt0(const G4double K);
    76   G4double GetOpt12(const G4double K);
    77   G4double GetOpt34(const G4double K);
    78 
    79  
    80   G4double GetAlpha();
    81  
    82   G4double GetBeta();
    83  
    84 //data members
    85 
    86       G4NeutronCoulombBarrier theNeutronCoulombBarrier;
    87       G4double ResidualA;
    88       G4double ResidualZ;
    89       G4double theA;
    90       G4double theZ;
    91       G4double ResidualAthrd;
    92       G4double FragmentA;
    93       G4double FragmentAthrd;
    94 
    95  
     74  G4NeutronCoulombBarrier theNeutronCoulombBarrier;
     75  G4double ResidualAthrd;
     76  G4double FragmentAthrd;
     77  G4int FragmentA;
     78  G4int ResidualA;
     79  G4int ResidualZ;
     80  G4int theA;
     81  G4int theZ;
    9682};
    97 
    9883 
    9984#endif

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4PreCompoundNucleon.hh

    r962 r1340  
    2424// ********************************************************************
    2525//
    26 //J. M. Quesada (August 2008). 
    27 //Based  on previous work by V. Lara
     26// $Id: G4PreCompoundNucleon.hh,v 1.7 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2828//
     29// J. M. Quesada (August 2008). 
     30// Based  on previous work by V. Lara
     31//
     32// Modified:
     33// 20.08.2010 V.Ivanchenko added int Z and A and cleanup; added
     34//                        G4ParticleDefinition to constructor
    2935
    3036
    … …  
    3642class G4PreCompoundNucleon : public G4PreCompoundFragment
    3743{
     44public: 
     45
     46  G4PreCompoundNucleon(const G4ParticleDefinition*,
     47                       G4VCoulombBarrier * aCoulombBarrier);
     48 
     49  virtual ~G4PreCompoundNucleon();
     50   
     51protected:
     52
     53  virtual G4double
     54  ProbabilityDistributionFunction(G4double eKin,
     55                                  const G4Fragment& aFragment);
     56
     57  virtual G4double CrossSection(G4double ekin) = 0;
     58
     59  virtual G4double
     60  GetRj(G4int NumberParticles, G4int NumberCharged) = 0;
     61
     62  virtual G4double GetAlpha() = 0;
     63
     64  virtual G4double GetBeta() = 0;
     65
     66  inline G4double GetOpt0(G4double ekin);
     67
    3868private:
     69
    3970  // default constructor
    40   G4PreCompoundNucleon() {};
     71  G4PreCompoundNucleon();
     72  // operators
     73  G4PreCompoundNucleon(const G4PreCompoundNucleon &right);
     74  const G4PreCompoundNucleon&
     75  operator= (const G4PreCompoundNucleon &right);
     76  G4int operator==(const G4PreCompoundNucleon &right) const;
     77  G4int operator!=(const G4PreCompoundNucleon &right) const;   
    4178
    42 public:
    43  
    44   // copy constructor
    45   G4PreCompoundNucleon(const G4PreCompoundNucleon &right):
    46     G4PreCompoundFragment(right) {}
     79  G4double fact;
     80};
    4781
    48   // constructor 
    49   G4PreCompoundNucleon(const G4double anA,
    50                        const G4double aZ,
    51                        G4VCoulombBarrier* aCoulombBarrier,                     
    52                        const G4String & aName) :
    53     G4PreCompoundFragment(anA,aZ,aCoulombBarrier,aName) {}
    54 
    55 
    56   virtual ~G4PreCompoundNucleon() {}
    57 
    58   // operators 
    59   const G4PreCompoundNucleon &
    60   operator=(const G4PreCompoundNucleon &right)
    61   {
    62     if (&right != this) this->G4PreCompoundFragment::operator=(right);
    63     return *this;
    64   }
    65  
    66   G4bool operator==(const G4PreCompoundNucleon &right) const
    67   {
    68     return G4PreCompoundFragment::operator==(right);
    69   }
    70    
    71   G4bool operator!=(const G4PreCompoundNucleon &right) const
    72   {
    73     return G4PreCompoundFragment::operator!=(right);
    74   }
    75    
    76   virtual G4double ProbabilityDistributionFunction(const G4double eKin,
    77                                                    const G4Fragment& aFragment);
    78  
    79   private:
    80 
    81   G4bool IsItPossible(const G4Fragment&) ;   
    82    
    83  protected:
    84 
    85   virtual G4double CrossSection(const G4double ekin)=0;
    86 
    87   virtual G4double GetRj(const G4int NumberParticles, const G4int NumberCharged) = 0;
    88 
    89  };
     82// *********************** OPT=0 : Dostrovski's cross section  ***************
     83inline G4double G4PreCompoundNucleon::GetOpt0(G4double K)
     84{
     85  G4double r0 = theParameters->Getr0()*ResidualA13();
     86  // cross section is now given in mb (r0 is in mm) for the sake of consistency
     87  //with the rest of the options
     88  return 1.e+25*CLHEP::pi*r0*r0*ResidualA13()*GetAlpha()*(1.+GetBeta()/K);
     89}
    9090
    9191#endif

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4PreCompoundParameters.hh

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 //
    27 // $Id: G4PreCompoundParameters.hh,v 1.5 2008/05/08 10:34:25 quesada Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4PreCompoundParameters.hh,v 1.6 2010/08/18 14:07:24 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2928//
    3029// by V. Lara
    3130//
    32 //J. M. Quesada (Apr. 2008) Level density set to A/10 at preequilibrium
    33 
     31// 01.04.2008 J. M. Quesada Level density set to A/10 at preequilibrium
     32// 18.08.2010 V.Ivanchenko make this class as a standard singleton
     33//
    3434
    3535#ifndef G4PreCompoundParameters_h
    … …  
    4040class G4PreCompoundParameters
    4141{
    42 private:
    43     static G4PreCompoundParameters thePreCompoundParameters;
    44 
    45     // default constructor
    46 //    G4PreCompoundParameters() : theLevelDensity(0.125/MeV),
    47 //JMQ level density parameter  set to  A/10 at preequilibrium
    48     G4PreCompoundParameters() : theLevelDensity(0.10/MeV),
    49       r0(1.5*fermi),Transitions_r0(0.6*fermi),FermiEnergy(35.0*MeV)
    50         {}
    51 
    5242public:
    5343
    54     ~G4PreCompoundParameters() {};
     44  static G4PreCompoundParameters * GetAddress();
     45
     46  ~G4PreCompoundParameters();
    5547 
    56     static G4PreCompoundParameters * GetAddress();
     48  inline G4double GetLevelDensity();
    5749
    58     G4double GetLevelDensity()
    59         { return theLevelDensity; }
    60  
     50  inline G4double Getr0();
    6151
    62     G4double Getr0()
    63         { return r0; }
     52  inline G4double GetTransitionsr0();
    6453
    65     G4double GetTransitionsr0()
    66         { return Transitions_r0; }
    67 
    68 
    69     G4double GetFermiEnergy()
    70         { return FermiEnergy; }
     54  inline G4double GetFermiEnergy();
    7155
    7256private:
    73     // Level density parameter
    74     const G4double theLevelDensity;
    7557
    76     // Nuclear radius r0
    77     const G4double r0;
     58  G4PreCompoundParameters();
     59
     60  static G4PreCompoundParameters* theParameters;
     61
     62  // Level density parameter
     63  G4double fLevelDensity;
     64
     65  // Nuclear radius r0
     66  G4double fR0;
    7867       
    79     // Nuclear radius r0 for transitions
    80     const G4double Transitions_r0;
     68  // Nuclear radius r0 for transitions
     69  G4double fTransitions_r0;
    8170
    82     // Fermi energy level
    83     const G4double FermiEnergy;
    84  
     71  // Fermi energy level
     72  G4double fFermiEnergy;
    8573};
    8674
     75inline G4double G4PreCompoundParameters::GetLevelDensity()
     76{
     77  return fLevelDensity;
     78}
     79 
     80inline G4double G4PreCompoundParameters::Getr0()
     81{
     82  return fR0;
     83}
     84
     85inline G4double G4PreCompoundParameters::GetTransitionsr0()
     86{
     87  return fTransitions_r0;
     88}
     89
     90inline G4double G4PreCompoundParameters::GetFermiEnergy()
     91{
     92  return fFermiEnergy;
     93}
     94
    8795#endif

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4PreCompoundProton.hh

    r962 r1340  
    2424// ********************************************************************
    2525//
     26// $Id: G4PreCompoundProton.hh,v 1.13 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2628//
    27 //J. M. Quesada (July 08)
     29// by V. Lara
     30//
     31// Modified:
     32// J. M. Quesada (July 08) cleanup
     33// 20.08.2010 V.Ivanchenko added int Z and A and cleanup; added
     34//                        G4ParticleDefinition to constructor,
     35//                        moved constructor and destructor to source
    2836
    2937#ifndef G4PreCompoundProton_h
    … …  
    3139
    3240#include "G4PreCompoundNucleon.hh"
    33 #include "G4ReactionProduct.hh"
    34 #include "G4Proton.hh"
    35 #include "G4PreCompoundParameters.hh"
    36 #include "Randomize.hh"
    3741#include "G4ProtonCoulombBarrier.hh"
    3842
    … …  
    4044{
    4145public:
    42   // default constructor
    43   G4PreCompoundProton():G4PreCompoundNucleon(1,1,&theProtonCoulombBarrier,"Proton") {}
    4446
    45   // copy constructor
    46   G4PreCompoundProton(const G4PreCompoundProton &right): G4PreCompoundNucleon(right) {}
     47  G4PreCompoundProton();
    4748
    48   // destructor
    49   ~G4PreCompoundProton() {};
     49  virtual ~G4PreCompoundProton();
    5050
    51   // operators 
    52   const G4PreCompoundProton & operator=(const G4PreCompoundProton &right) {
    53     if (&right != this) this->G4PreCompoundNucleon::operator=(right);
    54     return *this;
    55   };
     51protected:
    5652
    57   G4bool operator==(const G4PreCompoundProton &right) const
    58   { return G4PreCompoundNucleon::operator==(right);}
     53  virtual G4double GetRj(G4int NumberParticles, G4int NumberCharged);
    5954
    60  
    61   G4bool operator!=(const G4PreCompoundProton &right) const
    62   { return G4PreCompoundNucleon::operator!=(right);}
     55  virtual G4double CrossSection(G4double ekin) ;
    6356
     57  virtual G4double GetAlpha();
    6458
    65   G4ReactionProduct * GetReactionProduct() const;
    66  
    67  
     59  virtual G4double GetBeta();
     60
     61  G4double GetOpt1(G4double K);
     62
     63  G4double GetOpt2(G4double K);
     64
     65  G4double GetOpt3(G4double K);
     66
    6867private:
    6968
    70 //JMQ (Sep. 07) combinatorial factor Rj
    71   virtual G4double GetRj(const G4int NumberParticles, const G4int NumberCharged);
     69  // operators
     70  G4PreCompoundProton(const G4PreCompoundProton &right);
     71  const G4PreCompoundProton&
     72  operator= (const G4PreCompoundProton &right);
     73  G4int operator==(const G4PreCompoundProton &right) const;
     74  G4int operator!=(const G4PreCompoundProton &right) const;   
    7275
    73   virtual G4double CrossSection(const  G4double K) ;
    74 
    75 
    76   G4double GetOpt0(const G4double K);
    77   G4double GetOpt1(const G4double K);
    78   G4double GetOpt2(const G4double K);
    79   G4double GetOpt3(const G4double K);
    80 
    81   G4double GetAlpha();
    82  
    83   G4double GetBeta();
    84 
    85 //data members
    86 
    87       G4ProtonCoulombBarrier theProtonCoulombBarrier;
    88        G4double ResidualA;
    89       G4double ResidualZ;
    90       G4double theA;
    91       G4double theZ;
    92       G4double ResidualAthrd;
    93       G4double FragmentA;
    94       G4double FragmentAthrd;
    95 
    96 
    97  
     76  G4ProtonCoulombBarrier theProtonCoulombBarrier;
     77  G4double ResidualAthrd;
     78  G4double FragmentAthrd;
     79  G4int FragmentA;
     80  G4int ResidualA;
     81  G4int ResidualZ;
     82  G4int theA;
     83  G4int theZ;
    9884};
    9985#endif

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4PreCompoundTransitions.hh

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 //
    27 // $Id: G4PreCompoundTransitions.hh,v 1.6 2008/09/22 10:18:36 ahoward Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4PreCompoundTransitions.hh,v 1.8 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2928//
    3029// by V. Lara
    31 // J. M. Quesada . New methods for accessing to individual transition probabilities (landa+, landa-, landa0) from
    32 // G4PreCompoundModel.cc 
    33 
     30// 01.05.2008 J. M. Quesada . New methods for accessing to individual transition
     31//                 probabilities (landa+, landa-, landa0) from G4PreCompoundModel 
     32// 20.08.2010 V.Ivanchenko move constructor and destructor to the source
    3433
    3534#ifndef G4PreCompoundTransitions_h
    … …  
    4847#include "globals.hh"
    4948#include "G4Fragment.hh"
    50 #include "G4PreCompoundParameters.hh"
    51 #include "G4Proton.hh"
    52 #include "Randomize.hh"
     49
     50class G4ParticleDefinition;
     51class G4Pow;
    5352
    5453class G4PreCompoundTransitions : public G4VPreCompoundTransitions
    55 
    5654{
    5755public:
    5856
    59   // Calculates transition probabilities with Delta N = +2 (Trans1) -2 (Trans2) and 0 (Trans3)
     57  G4PreCompoundTransitions();
    6058
    61   G4PreCompoundTransitions() : TransitionProb1(0.0), TransitionProb2(0.0), TransitionProb3(0.0){}
     59  virtual ~G4PreCompoundTransitions();
    6260
    63   virtual ~G4PreCompoundTransitions() {}
     61  virtual G4double CalculateProbability(const G4Fragment & aFragment);
     62 
     63  virtual void PerformTransition(G4Fragment & aFragment);
    6464
    6565private:
    6666 
    67   G4PreCompoundTransitions(const G4PreCompoundTransitions &) : G4VPreCompoundTransitions() {};
    68  
     67  G4PreCompoundTransitions(const G4PreCompoundTransitions &);
    6968  const G4PreCompoundTransitions& operator=(const G4PreCompoundTransitions &right);
    70 
    7169  G4bool operator==(const G4PreCompoundTransitions &right) const;
    72  
    7370  G4bool operator!=(const G4PreCompoundTransitions &right) const;
    7471
    75 public:
    76  
    77   virtual G4double CalculateProbability(const G4Fragment & aFragment);
    78  
    79   virtual G4Fragment PerformTransition(const G4Fragment & aFragment);
    80  
    81 private:
    82        
    83   G4double TransitionProb1;
    84   G4double TransitionProb2;
    85   G4double TransitionProb3;
     72  G4Pow* g4pow;
     73  const G4ParticleDefinition* proton;
    8674
    87 
    88   //J. M.Quesada (May. 08)
    89 public:
    90   // inline G4double GetTransitionProb1() const
    91   G4double GetTransitionProb1()
    92   {
    93     return TransitionProb1;
    94   }
    95   // inline G4double GetTransitionProb2() const
    96   G4double GetTransitionProb2()
    97   {
    98     return TransitionProb2;
    99   }
    100   // inline G4double GetTransitionProb3() const
    101   G4double GetTransitionProb3()
    102   {
    103     return TransitionProb3;
    104   }
    105 
     75  G4double FermiEnergy;
     76  G4double r0;  // Nuclear radius
     77  G4double aLDP;// Level density parameter
    10678};
    10779

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4PreCompoundTriton.hh

    r962 r1340  
    2424// ********************************************************************
    2525//
     26// $Id: G4PreCompoundTriton.hh,v 1.12 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2628//
    2729// by V. Lara
    2830//
    29 //J. M. Quesada (July 08)
     31// Modified:
     32// J. M. Quesada (July 08) cleanup
     33// 20.08.2010 V.Ivanchenko added int Z and A and cleanup; added
     34//                        G4ParticleDefinition to constructor,
     35//                        moved constructor and destructor to source
    3036
    3137#ifndef G4PreCompoundTriton_h
    … …  
    3339
    3440#include "G4PreCompoundIon.hh"
    35 #include "G4ReactionProduct.hh"
    36 #include "G4Triton.hh"
    3741#include "G4TritonCoulombBarrier.hh"
    38 #include "G4PreCompoundParameters.hh"
    39 
    4042
    4143class G4PreCompoundTriton : public G4PreCompoundIon
    4244{
    4345public:
    44   // default constructor
    45   G4PreCompoundTriton():G4PreCompoundIon(3,1,&theTritonCoulombBarrier,"Triton") {}
    4646
    47   // copy constructor
    48   G4PreCompoundTriton(const G4PreCompoundTriton &right): G4PreCompoundIon(right) {}
     47  G4PreCompoundTriton();
    4948
    50   // destructor
    51   ~G4PreCompoundTriton() {}
     49  virtual ~G4PreCompoundTriton();
    5250
    53   // operators 
    54 //  const G4PreCompoundTriton & operator=(const G4PreCompoundTriton &right) {
    55 //    if (&right != this) this->G4PreCompoundIon::operator=(right);
    56 //    return *this;
    57 //  }
     51protected:
    5852
    59 //  G4bool operator==(const G4PreCompoundTriton &right) const
    60 //  { return G4PreCompoundIon::operator==(right);}
     53  virtual G4double GetRj(G4int NumberParticles, G4int NumberCharged);
    6154
     55  virtual G4double CrossSection(G4double ekin) ;
     56
     57  virtual G4double FactorialFactor(G4int N, G4int P);
     58
     59  virtual G4double CoalescenceFactor(G4int A);
     60
     61  virtual G4double GetAlpha();
    6262 
    63 //  G4bool operator!=(const G4PreCompoundTriton &right) const
    64 //  { return G4PreCompoundIon::operator!=(right);}
     63  G4double GetOpt12(G4double K);
    6564
    66 
    67   G4ReactionProduct * GetReactionProduct() const;
    68  
     65  G4double GetOpt34(G4double K);
    6966
    7067private:
    7168
    72   virtual G4double GetRj(const G4int NumberParticles, const G4int NumberCharged);
     69  // operators
     70  G4PreCompoundTriton(const G4PreCompoundTriton &right);
     71  const G4PreCompoundTriton&
     72  operator= (const G4PreCompoundTriton &right);
     73  G4int operator==(const G4PreCompoundTriton &right) const;
     74  G4int operator!=(const G4PreCompoundTriton &right) const;   
    7375
    74   virtual G4double CrossSection(const  G4double K) ;
    75 
    76   virtual G4double FactorialFactor(const G4double N, const G4double P);
    77 
    78   virtual G4double CoalescenceFactor(const G4double A);
    79 
    80   G4double GetOpt0(const G4double K);
    81   G4double GetOpt12(const G4double K);
    82   G4double GetOpt34(const G4double K);
    83 
    84   G4double GetAlpha();
    85  
    86   G4double GetBeta();
    87 
    88 //data members
    89 
    90       G4TritonCoulombBarrier theTritonCoulombBarrier;
    91        G4double ResidualA;
    92       G4double ResidualZ;
    93       G4double theA;
    94       G4double theZ;
    95       G4double ResidualAthrd;
    96       G4double FragmentA;
    97       G4double FragmentAthrd;
     76  G4TritonCoulombBarrier theTritonCoulombBarrier;
     77  G4double ResidualAthrd;
     78  G4double FragmentAthrd;
     79  G4int FragmentA;
     80  G4int ResidualA;
     81  G4int ResidualZ;
     82  G4int theA;
     83  G4int theZ;
    9884};
    9985

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4VPreCompoundEmissionFactory.hh

    r819 r1340  
    2424// ********************************************************************
    2525//
    26 
     26// $Id: G4VPreCompoundEmissionFactory.hh,v 1.3 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
     28//
    2729// by V. Lara
    28 
     30//
    2931
    3032#ifndef G4VPreCompoundEmissionFactory_hh
    3133#define G4VPreCompoundEmissionFactory_hh
    32 
    3334
    3435#include "G4VPreCompoundFragment.hh"
    … …  
    3839{
    3940public:
    40   G4VPreCompoundEmissionFactory() : _fragvector(0) {};
     41
     42  G4VPreCompoundEmissionFactory();
     43
    4144  virtual ~G4VPreCompoundEmissionFactory();
    4245 
    43 private:
    44   G4VPreCompoundEmissionFactory(const G4VPreCompoundEmissionFactory & ) {};
    45   const G4VPreCompoundEmissionFactory & operator=(const G4VPreCompoundEmissionFactory & val);
    46   G4bool operator==(const G4VPreCompoundEmissionFactory & val) const;
    47   G4bool operator!=(const G4VPreCompoundEmissionFactory & val) const;
    48 
    49 public:
    50  
    51   std::vector<G4VPreCompoundFragment*> * GetFragmentVector();
     46  inline std::vector<G4VPreCompoundFragment*> * GetFragmentVector();
    5247
    5348protected:
    … …  
    5651
    5752private:
    58   std::vector<G4VPreCompoundFragment*> * _fragvector;
     53
     54  G4VPreCompoundEmissionFactory(const G4VPreCompoundEmissionFactory & );
     55  const G4VPreCompoundEmissionFactory & operator=
     56  (const G4VPreCompoundEmissionFactory & val);
     57  G4bool operator==(const G4VPreCompoundEmissionFactory & val) const;
     58  G4bool operator!=(const G4VPreCompoundEmissionFactory & val) const;
     59
     60  std::vector<G4VPreCompoundFragment*> * fragvector;
    5961
    6062  struct DeleteFragment
    … …  
    6870 
    6971};
     72
     73inline std::vector<G4VPreCompoundFragment*> *
     74G4VPreCompoundEmissionFactory::GetFragmentVector()
     75{
     76  if (fragvector == 0) { fragvector = CreateFragmentVector(); }
     77  return fragvector;
     78}
     79
    7080#endif

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4VPreCompoundFragment.hh

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 //
    27 // $Id: G4VPreCompoundFragment.hh,v 1.10 2009/02/10 16:01:37 vnivanch Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4VPreCompoundFragment.hh,v 1.11 2010/08/28 15:16:55 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2928//
    3029// J. M. Quesada (August 2008). 
    … …  
    3534// JMQ (06 September 2008) Also external choice has been added for:
    3635//                      - superimposed Coulomb barrier (if useSICB=true)
     36// 20.08.2010 V.Ivanchenko added int Z and A and cleanup; added
     37//                        G4ParticleDefinition to constructor,
     38//                        inline method to build G4ReactionProduct;
     39//                        remove string name
     40//                       
    3741
    3842#ifndef G4VPreCompoundFragment_h
    … …  
    4145#include "G4ios.hh"
    4246#include <iomanip>
    43 #include "G4ParticleTable.hh"
     47#include "G4ParticleDefinition.hh"
    4448#include "G4IonTable.hh"
    4549#include "G4Fragment.hh"
    4650#include "G4VCoulombBarrier.hh"
    47 
    48 class G4ReactionProduct;
     51#include "G4ReactionProduct.hh"
     52#include "G4PreCompoundParameters.hh"
     53#include "G4Pow.hh"
    4954
    5055class G4VPreCompoundFragment
    5156{
     57public: 
     58
    5259  // ============================
    5360  // Constructors and destructor
    5461  // ============================
    55  
    56 protected:
    57   // default constructor
    58   G4VPreCompoundFragment() {};
    5962   
    60 public: 
    61   // copy constructor
    62   G4VPreCompoundFragment(const G4VPreCompoundFragment &right);
    63    
    64   // constructor 
    65   G4VPreCompoundFragment(const G4double anA, const G4double aZ,
    66                          G4VCoulombBarrier * aCoulombBarrier,
    67                          const G4String &  aName);
    68 
     63  G4VPreCompoundFragment(const G4ParticleDefinition*,
     64                         G4VCoulombBarrier * aCoulombBarrier);
    6965 
    7066  virtual ~G4VPreCompoundFragment();
    … …  
    7369  // operators
    7470  // ==========
    75  
    76   const G4VPreCompoundFragment&
    77   operator= (const G4VPreCompoundFragment &right);
    78  
    79   G4int operator==(const G4VPreCompoundFragment &right) const;
    80  
    81   G4int operator!=(const G4VPreCompoundFragment &right) const;
    8271 
    8372  friend std::ostream&
    … …  
    8978  // Pure Virtual methods
    9079  // =====================
    91   virtual G4ReactionProduct * GetReactionProduct() const = 0;   
    9280 
    9381  // Initialization method
    … …  
    10391  virtual G4double GetKineticEnergy(const G4Fragment & aFragment) = 0;
    10492
    105 public:
    106   inline G4double GetA() const;
     93  inline G4ReactionProduct * GetReactionProduct() const;       
     94
     95  inline G4int GetA() const;
    10796 
    108   inline G4double GetZ() const;
     97  inline G4int GetZ() const;
    10998 
    110   inline G4double GetRestA() const;
     99  inline G4int GetRestA() const;
    111100 
    112   inline G4double GetRestZ() const;
     101  inline G4int GetRestZ() const;
     102
     103  inline G4double ResidualA13() const;
    113104 
    114105  inline G4double GetCoulombBarrier() const;
    … …  
    128119  inline G4double GetReducedMass() const;
    129120 
    130   inline const G4LorentzVector GetMomentum() const;
     121  inline const G4LorentzVector& GetMomentum() const;
    131122 
    132123  inline void  SetMomentum(const G4LorentzVector & value);
    133124 
    134   inline void  SetFragmentName(const G4String& aName);
    135  
    136125  inline const G4String GetName() const;
    137  
    138   inline void ResetStage();
    139 
    140   inline G4int GetStage() const;
    141 
    142   inline void IncrementStage();
    143126
    144127  //for inverse cross section choice
    … …  
    147130  inline void UseSICB(G4bool);
    148131
     132protected:
    149133
     134  inline G4bool IsItPossible(const G4Fragment & aFragment) const;
     135
     136private:
     137
     138  // default constructor
     139  G4VPreCompoundFragment();
     140  // copy constructor
     141  G4VPreCompoundFragment(const G4VPreCompoundFragment &right);
     142  const G4VPreCompoundFragment&
     143  operator= (const G4VPreCompoundFragment &right); 
     144  G4int operator==(const G4VPreCompoundFragment &right) const;
     145  G4int operator!=(const G4VPreCompoundFragment &right) const;
    150146
    151147  // =============
    … …  
    153149  // =============
    154150
    155 
    156 private:
    157  
    158   G4double theA;
    159  
    160   G4double theZ;
    161 private:
    162  
    163   G4double theRestNucleusA;
    164  
    165   G4double theRestNucleusZ;
    166 protected: 
    167   G4double theCoulombBarrier;
    168 private:
     151  const G4ParticleDefinition* particle;
    169152  G4VCoulombBarrier * theCoulombBarrierPtr;
    170153 
     154  G4int theA;
     155  G4int theZ;
     156  G4int theRestNucleusA;
     157  G4int theRestNucleusZ;
     158
     159  G4double theRestNucleusA13;
    171160  G4double theBindingEnergy;
     161  G4double theMaximalKineticEnergy;
     162  G4double theRestNucleusMass;
     163  G4double theReducedMass;
     164  G4double theMass;
    172165
    173   G4double theMaximalKineticEnergy;
     166  G4LorentzVector theMomentum;
    174167 
    175168protected:
     169
     170  G4PreCompoundParameters* theParameters;
     171  G4Pow* g4pow;
     172
    176173  G4double theEmissionProbability;
    177 private: 
    178   G4LorentzVector theMomentum;
    179  
    180   G4String theFragmentName;
     174  G4double theCoulombBarrier;
    181175
    182   G4int theStage;
    183 
    184 protected:
    185 //for inverse cross section choice
     176  //for inverse cross section choice
    186177  G4int OPTxs;
    187 //for superimposed Coulomb Barrier for inverse cross sections
     178  //for superimposed Coulomb Barrier for inverse cross sections
    188179  G4bool useSICB;
    189180};

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4VPreCompoundFragment.icc

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4VPreCompoundFragment.icc,v 1.7 2008/09/22 10:18:36 ahoward Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4VPreCompoundFragment.icc,v 1.8 2010/08/28 15:16:55 vnivanch Exp $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030// by V. Lara
    … …  
    3434// JMQ (06 September 2008) Also external choice has been added for:
    3535//                      - superimposed Coulomb barrier (if useSICB=true)
     36// 23.08.2010 V.Ivanchenko general cleanup, move constructor and destructor
     37//            the source, make GetReactionProduct() and IsItPossible inlined
    3638
    37 inline G4double G4VPreCompoundFragment::GetA() const
     39inline G4bool G4VPreCompoundFragment::
     40IsItPossible(const G4Fragment & aFragment) const
     41{
     42  G4int pplus = aFragment.GetNumberOfCharged();
     43  G4int pneut = aFragment.GetNumberOfParticles()-pplus;
     44  return ((pneut >= theA - theZ) && (pplus >= theZ)
     45        && (theMaximalKineticEnergy > 0));
     46}
     47
     48
     49inline
     50G4ReactionProduct * G4VPreCompoundFragment::GetReactionProduct() const
     51{
     52  G4ReactionProduct * theReactionProduct =
     53    new G4ReactionProduct(const_cast<G4ParticleDefinition*>(particle));
     54  theReactionProduct->SetMomentum(GetMomentum().vect());
     55  theReactionProduct->SetTotalEnergy(GetMomentum().e());
     56  return theReactionProduct;
     57}
     58
     59inline G4int G4VPreCompoundFragment::GetA() const
    3860{
    3961  return theA;
    4062}
    4163
    42 inline G4double G4VPreCompoundFragment::GetZ() const
     64inline G4int G4VPreCompoundFragment::GetZ() const
    4365{
    4466  return theZ;
    4567}
    4668
    47 inline G4double G4VPreCompoundFragment::GetRestA() const
     69inline G4int G4VPreCompoundFragment::GetRestA() const
    4870{
    4971  return theRestNucleusA;
    5072}
    5173   
    52 inline G4double G4VPreCompoundFragment::GetRestZ() const
     74inline G4int G4VPreCompoundFragment::GetRestZ() const
    5375{
    5476  return theRestNucleusZ;
     77}
     78
     79inline G4double G4VPreCompoundFragment::ResidualA13() const
     80{
     81  return theRestNucleusA13;
    5582}
    5683   
    … …  
    82109inline G4double G4VPreCompoundFragment::GetNuclearMass(void) const
    83110{
    84   return G4ParticleTable::GetParticleTable()->
    85       GetIonTable()->GetIonMass(static_cast<G4int>(theZ),static_cast<G4int>(theA));
     111  return theMass;
    86112}
    87 
    88113
    89114inline G4double G4VPreCompoundFragment::GetRestNuclearMass() const
    90115{
    91   return G4ParticleTable::GetParticleTable()->GetIonTable()->
    92     GetIonMass(static_cast<G4int>(theRestNucleusZ),static_cast<G4int>(theRestNucleusA));
     116  return theRestNucleusMass;
    93117}
    94 
    95118
    96119inline G4double G4VPreCompoundFragment::GetReducedMass() const
    97120{
    98   return GetRestNuclearMass()*GetNuclearMass()/
    99     (GetNuclearMass()+GetRestNuclearMass());
     121  return theReducedMass;
    100122}
    101123
    102 
    103 inline const G4LorentzVector G4VPreCompoundFragment::
    104 GetMomentum() const
     124inline
     125const G4LorentzVector& G4VPreCompoundFragment::GetMomentum() const
    105126{
    106127  return theMomentum;
    107128}
    108 
    109129   
    110 inline void G4VPreCompoundFragment::
    111 SetMomentum(const G4LorentzVector & value)
     130inline
     131void G4VPreCompoundFragment::SetMomentum(const G4LorentzVector & value)
    112132{
    113133  theMomentum = value;
    114 }
    115    
    116 inline void G4VPreCompoundFragment::
    117 SetFragmentName(const G4String& aName)
    118 {
    119   theFragmentName = aName;
    120134}
    121135
    … …  
    123137GetName() const
    124138{
    125   return theFragmentName;
    126 }
    127    
    128 inline void G4VPreCompoundFragment::ResetStage()
    129 {
    130   theStage = 1;
    131 }
    132 
    133 inline G4int G4VPreCompoundFragment::GetStage() const
    134 {
    135   return theStage;
    136 }
    137 
    138 inline void G4VPreCompoundFragment::IncrementStage()
    139 {
    140   theStage++;
     139  return particle->GetParticleName();
    141140}
    142141
    … …  
    145144{
    146145  OPTxs=opt;
    147   return;
    148146}
    149147
    … …  
    152150{
    153151  useSICB=use;
    154   return;
    155152}

  • trunk/source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4VPreCompoundTransitions.hh

    r962 r1340  
    2424// ********************************************************************
    2525//
    26 //J. M. Quesada (May 08). New virtual classes have been added
     26// $Id: G4VPreCompoundTransitions.hh,v 1.6 2010/08/20 07:42:19 vnivanch Exp $
     27// GEANT4 tag $Name: geant4-09-03-ref-09 $
     28//
     29// J. M. Quesada (May 08). New virtual classes have been added Prob1,2,3
    2730// JMQ (06 September 2008) Also external choices have been added for:
    2831//                      - "never go back"  hipothesis (useNGB=true)
    2932//                      - CEM transition probabilities (useCEMtr=true) 
     33// 20.08.2010 V.Ivanchenko move constructor and destructor to the source
    3034
    3135#ifndef G4VPreCompoundTransitions_hh
    … …  
    3842public:
    3943
    40   G4VPreCompoundTransitions():useNGB(false),useCEMtr(false) {}
    41   virtual ~G4VPreCompoundTransitions() {}
     44  G4VPreCompoundTransitions();
     45  virtual ~G4VPreCompoundTransitions();
    4246
    4347  virtual G4double CalculateProbability(const G4Fragment& aFragment) = 0;
    44   virtual G4Fragment PerformTransition(const G4Fragment&  aFragment) = 0;
    45 //J. M. Quesada (May.08) New virtual classes
    46   virtual G4double GetTransitionProb1()=0;
    47   virtual G4double GetTransitionProb2()=0;
    48   virtual G4double GetTransitionProb3()=0;
     48  virtual void PerformTransition(G4Fragment&  aFragment) = 0;
     49
     50  inline G4double GetTransitionProb1() const;
     51
     52  inline G4double GetTransitionProb2() const;
     53
     54  inline G4double GetTransitionProb3() const;
    4955
    5056  // for never go back hypothesis (if useNGB=true, default=false)
    … …  
    5359  inline void UseCEMtr(G4bool use){useCEMtr=use;}
    5460
     61private:
     62
     63  G4VPreCompoundTransitions(const G4VPreCompoundTransitions &);
     64  const G4VPreCompoundTransitions& operator=(const G4VPreCompoundTransitions &right);
     65  G4bool operator==(const G4VPreCompoundTransitions &right) const;
     66  G4bool operator!=(const G4VPreCompoundTransitions &right) const;
     67
    5568protected:
     69
    5670  G4bool useNGB;
    5771  G4bool useCEMtr;
     72
     73  G4double TransitionProb1;
     74  G4double TransitionProb2;
     75  G4double TransitionProb3;
    5876};
    5977
     78  //J. M.Quesada (May. 08)
     79  inline G4double G4VPreCompoundTransitions::GetTransitionProb1() const
     80  {
     81    return TransitionProb1;
     82  }
     83  inline G4double G4VPreCompoundTransitions::GetTransitionProb2() const
     84  {
     85    return TransitionProb2;
     86  }
     87  inline G4double G4VPreCompoundTransitions::GetTransitionProb3() const
     88  {
     89    return TransitionProb3;
     90  }
     91
     92
    6093#endif
Note: See TracChangeset for help on using the changeset viewer.