Geant4  10.03.p03
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4FermiFragmentsPool Class Reference

#include <G4FermiFragmentsPool.hh>

Public Member Functions

 ~G4FermiFragmentsPool ()
 
G4bool IsApplicable (G4int Z, G4int A, G4double mass) const
 
const std::vector< const
G4FermiConfiguration * > * 
GetConfigurationList (G4int Z, G4int A, G4double mass) const
 
const G4VFermiFragmentGetFragment (G4int Z, G4int A) const
 
const G4FermiPhaseSpaceDecayGetFermiPhaseSpaceDecay () const
 
G4int GetMaxZ () const
 
G4int GetMaxA () const
 
void DumpFragment (const G4VFermiFragment *f) const
 
void Dump () const
 

Static Public Member Functions

static G4FermiFragmentsPoolInstance ()
 

Detailed Description

Definition at line 44 of file G4FermiFragmentsPool.hh.

Constructor & Destructor Documentation

G4FermiFragmentsPool::~G4FermiFragmentsPool ( )

Definition at line 73 of file G4FermiFragmentsPool.cc.

74 {
75  size_t nn;
76  for(size_t i=0; i<17; ++i) {
77  nn = list1[i].size();
78  if(0 < nn) { for(size_t j=0; j<nn; ++j) { delete (list1[i])[j]; }}
79  nn = list2[i].size();
80  if(0 < nn) { for(size_t j=0; j<nn; ++j) { delete (list2[i])[j]; }}
81  nn = list3[i].size();
82  if(0 < nn) { for(size_t j=0; j<nn; ++j) { delete (list3[i])[j]; }}
83  nn = list4[i].size();
84  if(0 < nn) { for(size_t j=0; j<nn; ++j) { delete (list4[i])[j]; }}
85  }
86  nn = fragment_pool.size();
87  if(0 < nn) { for(size_t j=0; j<nn; ++j) { delete fragment_pool[j]; }}
88 }

Member Function Documentation

void G4FermiFragmentsPool::Dump ( ) const

Definition at line 674 of file G4FermiFragmentsPool.cc.

675 {
676  G4cout << "##### List of Fragments in the Fermi Fragment Pool #####"
677  << G4endl;
678  G4int nfrag = fragment_pool.size();
679  for(G4int i=0; i<nfrag; ++i) {
680  DumpFragment(fragment_pool[i]);
681  }
682  G4cout << G4endl;
683 }
int G4int
Definition: G4Types.hh:78
G4GLOB_DLL std::ostream G4cout
void DumpFragment(const G4VFermiFragment *f) const
#define G4endl
Definition: G4ios.hh:61

Here is the call graph for this function:

void G4FermiFragmentsPool::DumpFragment ( const G4VFermiFragment f) const

Definition at line 665 of file G4FermiFragmentsPool.cc.

666 {
667  if(f) {
668  G4cout << "Z= " << f->GetZ() << " A= " << f->GetA()
669  << " Mass(GeV)= " << f->GetFragmentMass()/GeV
670  << " Eexc(MeV)= " << f->GetExcitationEnergy() << G4endl;
671  }
672 }
G4int GetZ(void) const
G4int GetA(void) const
G4GLOB_DLL std::ostream G4cout
static constexpr double GeV
Definition: G4SIunits.hh:217
G4double GetExcitationEnergy(void) const
G4double GetFragmentMass(void) const
#define G4endl
Definition: G4ios.hh:61

Here is the call graph for this function:

Here is the caller graph for this function:

const std::vector< const G4FermiConfiguration * > * G4FermiFragmentsPool::GetConfigurationList ( G4int  Z,
G4int  A,
G4double  mass 
) const

Definition at line 494 of file G4FermiFragmentsPool.cc.

495 {
496  std::vector<const G4FermiConfiguration*>* v =
497  new std::vector<const G4FermiConfiguration*>;
498  if(Z >= maxZ || A >= maxA) { return v; }
499 
500  //G4cout << "G4FermiFragmentsPool::GetConfigurationList:"
501  // << " Z= " << Z << " A= " << A << " Mass(GeV)= " << mass/GeV<< G4endl;
502 
503  // look into pair list
504  size_t nz = list2[A].size();
505  if(0 < nz) {
506  for(size_t j=0; j<nz; ++j) {
507  const G4FermiConfiguration* conf = (list2[A])[j];
508  if(Z == conf->GetZ() && mass >= conf->GetMass()) {
509  v->push_back(conf);
510  }
511  //G4cout << "Pair dM(MeV)= " << mass - conf->GetMass() << G4endl; }
512  }
513  }
514  // look into triple list
515  nz = list3[A].size();
516  if(0 < nz) {
517  for(size_t j=0; j<nz; ++j) {
518  const G4FermiConfiguration* conf = (list3[A])[j];
519  if(Z == conf->GetZ() && mass >= conf->GetMass()) {
520  v->push_back(conf);
521  }
522  //G4cout << "Triple dM(MeV)= " << mass - conf->GetMass() << G4endl; }
523  }
524  }
525  // look into quartet list
526  nz = list4[A].size();
527  if(0 < nz) {
528  for(size_t j=0; j<nz; ++j) {
529  const G4FermiConfiguration* conf = (list4[A])[j];
530  if(Z == conf->GetZ() && mass >= conf->GetMass()) {
531  v->push_back(conf);
532  }
533  // G4cout << "Quartet dM(MeV)= " << mass - conf->GetMass() << G4endl; }
534  }
535  }
536  // return if vector not empty
537  if(0 < v->size()) {
538  if(verbose > 0) {
540  G4cout<<"Total number of configurations = "<<v->size()<<" for A= "
541  <<A<<" Z= "<<Z<<" E*= "<< ExEn<<" MeV"<<G4endl;
542  size_t size_vector_conf = v->size();
543  for(size_t jc=0; jc<size_vector_conf; ++jc) {
544  const std::vector<const G4VFermiFragment*>* v_frag =
545  (*v)[jc]->GetFragmentList();
546  size_t size_vector_fragments = v_frag->size();
547  G4cout<<size_vector_fragments<<"-body configuration "<<jc+1<<": ";
548  for(size_t jf=0;jf<size_vector_fragments;++jf){
549  G4int af= (*v_frag)[jf]->GetA();
550  G4int zf= (*v_frag)[jf]->GetZ();
551  G4double ex=(*v_frag)[jf]->GetExcitationEnergy();
552  G4cout<<"(a="<<af<<", z="<<zf<<", ex="<<ex<<") ";
553  }
554  G4cout<<G4endl;
555  G4cout<<"-----------------------------------------------------"<<G4endl;
556  }
557  }
558  return v;
559  }
560 
561  // search in the pool and if found then return vector with one element
562  nz = list1[A].size();
563  if(0 < nz) {
564  for(size_t j=0; j<nz; ++j) {
565  const G4FermiConfiguration* conf = (list1[A])[j];
566 
567  // G4cout << "Single dM(MeV)= " << mass - conf->GetMass() << G4endl; }
568  if(Z == conf->GetZ() && mass >= conf->GetMass()) {
569  if(!(*(conf->GetFragmentList()))[0]->IsStable()) {
570  v->push_back(conf);
571 
572  if(verbose > 0) {
574  G4cout<<"Only 1 configurations for A= "
575  <<A<<" Z= "<<Z<<" E*= "<< ExEn<<" MeV"<<G4endl;
576  const std::vector<const G4VFermiFragment*>* v_frag
577  = (*v)[0]->GetFragmentList();
578  size_t size_vector_fragments=v_frag->size();
579  G4cout<<"1 Fragment configuration: ";
580  for(size_t jf=0;jf<size_vector_fragments;++jf){
581  G4int af= (*v_frag)[jf]->GetA();
582  G4int zf= (*v_frag)[jf]->GetZ();
583  G4double ex=(*v_frag)[jf]->GetExcitationEnergy();
584  G4cout<<"(a="<<af<<", z="<<zf<<", ex="<<ex<<") ";
585  }
586  G4cout<<G4endl;
587  G4cout<<"-----------------------------------------------------"<<G4endl;
588  }
589  return v;
590  }
591  }
592  }
593  }
594  //failer
595  if(verbose > 0) {
596  G4cout << "G4FermiFragmentsPool::GetConfigurationList: WARNING: not "
597  << "able decay fragment Z= " << Z << " A= " << A
598  << " Mass(GeV)= " << mass/GeV<< G4endl;
599  }
600  return v;
601 }
static G4double GetNuclearMass(const G4double A, const G4double Z)
G4double GetMass() const
int G4int
Definition: G4Types.hh:78
G4GLOB_DLL std::ostream G4cout
double A(double temperature)
tuple v
Definition: test.py:18
static constexpr double GeV
Definition: G4SIunits.hh:217
#define G4endl
Definition: G4ios.hh:61
double G4double
Definition: G4Types.hh:76
const std::vector< const G4VFermiFragment * > * GetFragmentList() const

Here is the call graph for this function:

const G4FermiPhaseSpaceDecay * G4FermiFragmentsPool::GetFermiPhaseSpaceDecay ( ) const

Definition at line 111 of file G4FermiFragmentsPool.cc.

112 {
113  return &thePhaseSpace;
114 }

Here is the caller graph for this function:

const G4VFermiFragment * G4FermiFragmentsPool::GetFragment ( G4int  Z,
G4int  A 
) const

Definition at line 649 of file G4FermiFragmentsPool.cc.

650 {
651  const G4VFermiFragment* f = 0;
652  if(Z < maxZ && A < maxA) {
653  size_t nz = list1[A].size();
654  for(size_t j=0; j<nz; ++j) {
655  const G4FermiConfiguration* conf = (list1[A])[j];
656  if(Z == conf->GetZ()) {
657  f = (*(conf->GetFragmentList()))[0];
658  break;
659  }
660  }
661  }
662  return f;
663 }
double A(double temperature)
const std::vector< const G4VFermiFragment * > * GetFragmentList() const

Here is the call graph for this function:

G4int G4FermiFragmentsPool::GetMaxA ( ) const

Definition at line 105 of file G4FermiFragmentsPool.cc.

106 {
107  return maxA;
108 }
G4int G4FermiFragmentsPool::GetMaxZ ( ) const

Definition at line 100 of file G4FermiFragmentsPool.cc.

101 {
102  return maxZ;
103 }
G4FermiFragmentsPool * G4FermiFragmentsPool::Instance ( void  )
static

Definition at line 56 of file G4FermiFragmentsPool.cc.

57 {
58  if(0 == theInstance) {
60  theInstance = &instance;
61  }
62  return theInstance;
63 }
static MCTruthManager * instance

Here is the caller graph for this function:

G4bool G4FermiFragmentsPool::IsApplicable ( G4int  Z,
G4int  A,
G4double  mass 
) const

Definition at line 452 of file G4FermiFragmentsPool.cc.

453 {
454  if(Z >= maxZ || A >= maxA || A <= 0) { return false; }
455  // look into pair list
456  size_t nz = list2[A].size();
457  if(0 < nz) {
458  for(size_t j=0; j<nz; ++j) {
459  const G4FermiConfiguration* conf = (list2[A])[j];
460  if(Z == conf->GetZ() && mass >= conf->GetMass()) { return true; }
461  }
462  }
463  // look into triple list
464  nz = list3[A].size();
465  if(0 < nz) {
466  for(size_t j=0; j<nz; ++j) {
467  const G4FermiConfiguration* conf = (list3[A])[j];
468  if(Z == conf->GetZ() && mass >= conf->GetMass()) { return true; }
469  }
470  }
471  // look into quartet list
472  nz = list4[A].size();
473  if(0 < nz) {
474  for(size_t j=0; j<nz; ++j) {
475  const G4FermiConfiguration* conf = (list4[A])[j];
476  if(Z == conf->GetZ() && mass >= conf->GetMass()) { return true; }
477  }
478  }
479 
480  // search in the pool and if found then return vector with one element
481  nz = list1[A].size();
482  if(0 < nz) {
483  for(size_t j=0; j<nz; ++j) {
484  const G4FermiConfiguration* conf = (list1[A])[j];
485  if(Z == conf->GetZ() && mass >= conf->GetMass()) {
486  if(!(*(conf->GetFragmentList()))[0]->IsStable()) { return true; }
487  }
488  }
489  }
490  return false;
491 }
G4double GetMass() const
double A(double temperature)
const std::vector< const G4VFermiFragment * > * GetFragmentList() const

Here is the call graph for this function:

Here is the caller graph for this function:


The documentation for this class was generated from the following files: