G4PrimaryTransformer Class Reference

#include <G4PrimaryTransformer.hh>

Public Member Functions
	G4PrimaryTransformer ()
virtual	~G4PrimaryTransformer ()=default
G4TrackVector *	GimmePrimaries (G4Event *anEvent, G4int trackIDCounter=0)
void	CheckUnknown ()
void	SetVerboseLevel (G4int vl)
void	SetUnknownParticleDefined (G4bool vl)
void	SetChargedUnknownParticleDefined (G4bool vl)
G4bool	GetUnknownParticleDefined () const
G4bool	GetChargedUnknownParticleDefined () const

Static Public Member Functions
static void	SetKETolerance (G4double val, G4ExceptionSeverity sev=JustWarning)

Protected Member Functions
void	GenerateTracks (G4PrimaryVertex *primaryVertex)
void	GenerateSingleTrack (G4PrimaryParticle *primaryParticle, G4double x0, G4double y0, G4double z0, G4double t0, G4double wv)
void	SetDecayProducts (G4PrimaryParticle *mother, G4DynamicParticle *motherDP)
G4bool	CheckDynamicParticle (G4DynamicParticle *DP)
virtual G4ParticleDefinition *	GetDefinition (G4PrimaryParticle *pp)
virtual G4bool	IsGoodForTrack (G4ParticleDefinition *pd)

Protected Attributes
G4TrackVector	TV
G4ParticleTable *	particleTable = nullptr
G4ParticleDefinition *	unknown = nullptr
G4ParticleDefinition *	chargedunknown = nullptr
G4ParticleDefinition *	opticalphoton = nullptr
G4int	verboseLevel = 0
G4int	trackID = 0
G4int	nWarn = 0
G4bool	unknownParticleDefined = false
G4bool	chargedUnknownParticleDefined = false
G4bool	opticalphotonDefined = false

Static Protected Attributes
static G4double	kETolerance = 1.0 * CLHEP::MeV
static G4ExceptionSeverity	kETSeverity = JustWarning

Detailed Description

Definition at line 48 of file G4PrimaryTransformer.hh.

Constructor & Destructor Documentation

G4PrimaryTransformer()

G4PrimaryTransformer::G4PrimaryTransformer

(

)

Definition at line 47 of file G4PrimaryTransformer.cc.

{
  particleTable = G4ParticleTable::GetParticleTable();
  CheckUnknown();
}

~G4PrimaryTransformer()

virtual G4PrimaryTransformer::~G4PrimaryTransformer ( )

virtualdefault

Member Function Documentation

CheckDynamicParticle()

G4bool G4PrimaryTransformer::CheckDynamicParticle ( G4DynamicParticle * DP )

protected

Definition at line 377 of file G4PrimaryTransformer.cc.

{
  if(IsGoodForTrack(DP->GetDefinition())) return true;
  auto* decayProducts
    = (G4DecayProducts*)(DP->GetPreAssignedDecayProducts());
  if(decayProducts != nullptr && decayProducts->entries()>0) return true;
  G4cerr << G4endl
         << "G4PrimaryTransformer: a shortlived primary particle is found"
         << G4endl
         << " without any valid decay table nor pre-assigned decay mode."
         << G4endl;
  G4Exception("G4PrimaryTransformer", "InvalidPrimary", JustWarning,
              "This primary particle will be ignored.");
  return false;
}

Referenced by GenerateSingleTrack(), and SetDecayProducts().

CheckUnknown()

void G4PrimaryTransformer::CheckUnknown

(

)

Definition at line 53 of file G4PrimaryTransformer.cc.

{
  unknown = particleTable->FindParticle("unknown");
  unknownParticleDefined = unknown != nullptr;
  chargedunknown = particleTable->FindParticle("chargedunknown");
  chargedUnknownParticleDefined = chargedunknown != nullptr;
  opticalphoton = particleTable->FindParticle("opticalphoton");
  opticalphotonDefined = opticalphoton != nullptr;
}

Referenced by G4PrimaryTransformer(), and G4RunManagerKernel::RunInitialization().

GenerateSingleTrack()

void G4PrimaryTransformer::GenerateSingleTrack ( G4PrimaryParticle * primaryParticle, G4double x0, G4double y0, G4double z0, G4double t0, G4double wv )

protected

Definition at line 113 of file G4PrimaryTransformer.cc.

{
  G4ParticleDefinition* partDef = GetDefinition(primaryParticle);
  if(!IsGoodForTrack(partDef))
  {  // The particle cannot be converted to G4Track, check daughters
#ifdef G4VERBOSE
    if(verboseLevel>1)
    {
      G4cout << "Primary particle (PDGcode " << primaryParticle->GetPDGcode()
             << ") --- Ignored" << G4endl;
    }
#endif 
    G4PrimaryParticle* daughter = primaryParticle->GetDaughter();
    while(daughter != nullptr) // Loop checking 12.28.2015 M.Asai
    {
      GenerateSingleTrack(daughter,x0,y0,z0,t0,wv);
      daughter = daughter->GetNext();
    }
  }
  else  // The particle is defined in GEANT4
  {
    // Create G4DynamicParticle object
#ifdef G4VERBOSE
    if(verboseLevel>1)
    {
      G4cout << "Primary particle (" << partDef->GetParticleName()
             << ") --- Transferred with momentum "
             << primaryParticle->GetMomentum()
             << G4endl;
    }
#endif
    // Check the mass of the "real" particle
    // N.B. PDG code 0 is used for artificial particle such as geantino
    if(primaryParticle->GetPDGcode() != 0 && kETSeverity != IgnoreTheIssue)
    { 
      G4double pmas = partDef->GetPDGMass();
      if(std::abs(pmas - primaryParticle->GetMass()) > kETolerance) {
        G4ExceptionDescription ed;
        ed << "Primary particle PDG=" << primaryParticle->GetPDGcode()
           << " deltaMass(MeV)=" << (std::abs(pmas - primaryParticle->GetMass()))/CLHEP::MeV
           << " is larger than the tolerance(MeV)=" << kETolerance/CLHEP::MeV
           << "\n Specified mass(MeV)=" << (primaryParticle->GetMass())/CLHEP::MeV
           << " while PDG mass(MEV)=" << pmas/CLHEP::MeV
           << "\n To change the tolerance or the exception severity,"
           << " use G4PrimaryTransformer::SetKETolerance() method."; 
        G4Exception("G4PrimaryParticle::Set4Momentum", "part0005", kETSeverity, ed);
      }
    }
    auto* DP = 
      new G4DynamicParticle(partDef,
                            primaryParticle->GetMomentumDirection(),
                            primaryParticle->GetKineticEnergy());
    if(opticalphotonDefined && partDef==opticalphoton
       && primaryParticle->GetPolarization().mag2()==0.)
    {
      if(nWarn<10)
      {
        G4Exception("G4PrimaryTransformer::GenerateSingleTrack",
                    "ZeroPolarization", JustWarning,
                    "Polarization of the optical photon is null.\
                     Random polarization is assumed.");
        G4cerr << "This warning message is issued up to 10 times." << G4endl;
        ++nWarn;
      }
 
      G4double angle = G4UniformRand() * 360.0*deg;
      G4ThreeVector normal (1., 0., 0.);
      G4ThreeVector kphoton = DP->GetMomentumDirection();
      G4ThreeVector product = normal.cross(kphoton);
      G4double modul2       = product*product;
 
      G4ThreeVector e_perpend (0., 0., 1.);
      if (modul2 > 0.) e_perpend = (1./std::sqrt(modul2))*product;
      G4ThreeVector e_paralle    = e_perpend.cross(kphoton);
 
      G4ThreeVector polar = std::cos(angle)*e_paralle
                          + std::sin(angle)*e_perpend;
      DP->SetPolarization(polar.x(),polar.y(),polar.z());
    }
    else
    {
      DP->SetPolarization(primaryParticle->GetPolX(),
                          primaryParticle->GetPolY(),
                          primaryParticle->GetPolZ());
    }
    if(primaryParticle->GetProperTime()>=0.0)
    {
      DP->SetPreAssignedDecayProperTime(primaryParticle->GetProperTime());
    }
 
    // Set Mass if it is specified
    //
    G4double pmas = primaryParticle->GetMass();
    if(pmas>=0.) { DP->SetMass(pmas); }
 
    // Set Charge if it is specified
    //
    if (primaryParticle->GetCharge()<DBL_MAX)
    {
      if (partDef->GetAtomicNumber() <0)
      {
        DP->SetCharge(primaryParticle->GetCharge());
      }
      else  // ions
      {
        G4int iz = partDef->GetAtomicNumber();
        auto  iq = static_cast<G4int>(primaryParticle->GetCharge()/eplus);
        G4int n_e = iz - iq;
        if (n_e>0) DP->AddElectron(0,n_e);  
      }
    } 
    // Set decay products to the DynamicParticle
    //
    SetDecayProducts( primaryParticle, DP );
 
    // Set primary particle
    //
    DP->SetPrimaryParticle(primaryParticle);
 
    // Set PDG code if it is different from G4ParticleDefinition
    //
    if(partDef->GetPDGEncoding()==0 && primaryParticle->GetPDGcode()!=0)
    {
      DP->SetPDGcode(primaryParticle->GetPDGcode());
    }
 
    // Check the particle is properly constructed
    //
    if(!CheckDynamicParticle(DP))
    {
      delete DP;
      return;
    }
 
    // Create G4Track object
    //
    auto  track = new G4Track(DP,t0,G4ThreeVector(x0,y0,z0));
 
    // Set trackID and let primary particle know it
    //
    ++trackID;
    track->SetTrackID(trackID);
    primaryParticle->SetTrackID(trackID);
 
    // Set parentID to 0 as a primary particle
    //
    track->SetParentID(0);
 
    // Set weight ( vertex weight * particle weight )
    //
    track->SetWeight(wv*(primaryParticle->GetWeight()));
 
    // Store it to G4TrackVector
    //
    TV.push_back( track );
  }
}

Referenced by GenerateSingleTrack(), and GenerateTracks().

GenerateTracks()

void G4PrimaryTransformer::GenerateTracks ( G4PrimaryVertex * primaryVertex )

protected

Definition at line 82 of file G4PrimaryTransformer.cc.

{
  G4double X0 = primaryVertex->GetX0();
  G4double Y0 = primaryVertex->GetY0();
  G4double Z0 = primaryVertex->GetZ0();
  G4double T0 = primaryVertex->GetT0();
  G4double WV = primaryVertex->GetWeight();
 
#ifdef G4VERBOSE
  if(verboseLevel>2)
  { 
    primaryVertex->Print();
  }
  else if (verboseLevel==1)
  {
    G4cout << "G4PrimaryTransformer::PrimaryVertex ("
           << X0 / mm << "(mm),"
           << Y0 / mm << "(mm),"
           << Z0 / mm << "(mm),"
           << T0 / nanosecond << "(nsec))" << G4endl;
  }
#endif
 
  G4PrimaryParticle* primaryParticle = primaryVertex->GetPrimary();
  while( primaryParticle != nullptr ) // Loop checking 12.28.2015 M.Asai
  {
    GenerateSingleTrack( primaryParticle, X0, Y0, Z0, T0, WV );
    primaryParticle = primaryParticle->GetNext();
  }
}

Referenced by GimmePrimaries().

GetChargedUnknownParticleDefined()

G4bool G4PrimaryTransformer::GetChargedUnknownParticleDefined ( ) const

inline

Definition at line 70 of file G4PrimaryTransformer.hh.

      { return chargedUnknownParticleDefined; }

GetDefinition()

G4ParticleDefinition * G4PrimaryTransformer::GetDefinition ( G4PrimaryParticle * pp )

protectedvirtual

Definition at line 394 of file G4PrimaryTransformer.cc.

{
  G4ParticleDefinition* partDef = pp->GetG4code();
  if(partDef == nullptr)
  {
    partDef = particleTable->FindParticle(pp->GetPDGcode());
  }
  if((partDef == nullptr) || partDef->IsShortLived())
  {
    if (chargedUnknownParticleDefined && pp->GetCharge()!=0.0)
    {
      partDef = chargedunknown;
    }
    else if (unknownParticleDefined)
    {
      partDef = unknown;
    }
  }
  return partDef;
}

Referenced by GenerateSingleTrack(), and SetDecayProducts().

GetUnknownParticleDefined()

G4bool G4PrimaryTransformer::GetUnknownParticleDefined ( ) const

inline

Definition at line 67 of file G4PrimaryTransformer.hh.

      { return unknownParticleDefined; }

GimmePrimaries()

G4TrackVector * G4PrimaryTransformer::GimmePrimaries	(	G4Event *	anEvent,
		G4int	trackIDCounter = 0 )

Definition at line 64 of file G4PrimaryTransformer.cc.

{
  trackID = trackIDCounter;
 
  for(auto tr : TV) delete tr;
  TV.clear();
 
  // Loop over vertices
  //
  G4PrimaryVertex* nextVertex = anEvent->GetPrimaryVertex();
  while(nextVertex != nullptr) // Loop checking 12.28.2015 M.Asai
  { 
    GenerateTracks(nextVertex);
    nextVertex = nextVertex->GetNext();
  }
  return &TV;
}

IsGoodForTrack()

G4bool G4PrimaryTransformer::IsGoodForTrack ( G4ParticleDefinition * pd )

protectedvirtual

Definition at line 415 of file G4PrimaryTransformer.cc.

{
  if(pd == nullptr)
  { return false; }
  if(!(pd->IsShortLived()))
  { return true; }
  //
  // Following two lines should be removed if the user does not want to make
  // shortlived primary particle with proper decay table to be converted into
  // a track.
  //
  if(pd->GetDecayTable() != nullptr)
  { return true; }
 
  return false;
}

Referenced by CheckDynamicParticle(), GenerateSingleTrack(), and SetDecayProducts().

SetChargedUnknownParticleDefined()

void G4PrimaryTransformer::SetChargedUnknownParticleDefined

(

G4bool

vl

)

Definition at line 365 of file G4PrimaryTransformer.cc.

{
  chargedUnknownParticleDefined = vl;
  if(chargedUnknownParticleDefined && (chargedunknown == nullptr))
  {
    G4cerr << "chargedUnknownParticleDefined cannot be set true because" << G4endl
           << "G4ChargedUnknownParticle is not defined in the physics list." << G4endl
           << "Command ignored." << G4endl;
    chargedUnknownParticleDefined = false;
  }
}

SetDecayProducts()

void G4PrimaryTransformer::SetDecayProducts ( G4PrimaryParticle * mother, G4DynamicParticle * motherDP )

protected

Definition at line 274 of file G4PrimaryTransformer.cc.

{
  G4PrimaryParticle* daughter = mother->GetDaughter();
  if(daughter == nullptr) return;
  auto* decayProducts
    = (G4DecayProducts*)(motherDP->GetPreAssignedDecayProducts() );
  if(decayProducts == nullptr)
  {
    decayProducts = new G4DecayProducts(*motherDP);
    motherDP->SetPreAssignedDecayProducts(decayProducts);
  }
  while(daughter != nullptr)
  {
    G4ParticleDefinition* partDef = GetDefinition(daughter);
    if(!IsGoodForTrack(partDef))
    { 
#ifdef G4VERBOSE
      if(verboseLevel>2)
      {
        G4cout << " >> Decay product (PDGcode " << daughter->GetPDGcode()
               << ") --- Ignored" << G4endl;
      }
#endif 
      SetDecayProducts(daughter,motherDP);
    }
    else
    {
#ifdef G4VERBOSE
      if(verboseLevel>1)
      {
        G4cout << " >> Decay product (" << partDef->GetParticleName()
               << ") --- Attached with momentum " << daughter->GetMomentum()
               << G4endl;
      }
#endif
      auto* DP 
        = new G4DynamicParticle(partDef,daughter->GetMomentum());
      DP->SetPrimaryParticle(daughter);
 
      // Decay proper time for daughter
      //
      if(daughter->GetProperTime()>=0.0)
      {
        DP->SetPreAssignedDecayProperTime(daughter->GetProperTime());
      }
 
      // Set Charge and Mass is specified
      //
      if (daughter->GetCharge()<DBL_MAX)
      {
        DP->SetCharge(daughter->GetCharge());
      } 
      G4double pmas = daughter->GetMass();
      if(pmas>=0.)
      {
        DP->SetMass(pmas);
      }
 
      // Set Polarization
      //
      DP->SetPolarization(daughter->GetPolX(),
                          daughter->GetPolY(),
                          daughter->GetPolZ());
      decayProducts->PushProducts(DP);
      SetDecayProducts(daughter,DP);
 
      // Check the particle is properly constructed
      //
      if(!CheckDynamicParticle(DP))
      {
        delete DP;
        return;
      }
    }
    daughter = daughter->GetNext();
  }
}

Referenced by GenerateSingleTrack(), and SetDecayProducts().

SetKETolerance()

static void G4PrimaryTransformer::SetKETolerance ( G4double val, G4ExceptionSeverity sev = JustWarning )

inlinestatic

Definition at line 115 of file G4PrimaryTransformer.hh.

    { kETolerance = val; kETSeverity = sev; }

SetUnknownParticleDefined()

void G4PrimaryTransformer::SetUnknownParticleDefined

(

G4bool

vl

)

Definition at line 353 of file G4PrimaryTransformer.cc.

{
  unknownParticleDefined = vl;
  if(unknownParticleDefined && (unknown == nullptr))
  {
    G4cerr << "unknownParticleDefined cannot be set true because" << G4endl
           << "G4UnknownParticle is not defined in the physics list." << G4endl
           << "Command ignored." << G4endl;
    unknownParticleDefined = false;
  }
}

SetVerboseLevel()

void G4PrimaryTransformer::SetVerboseLevel ( G4int vl )

inline

Definition at line 58 of file G4PrimaryTransformer.hh.

      { verboseLevel = vl; }

Member Data Documentation

chargedunknown

G4ParticleDefinition* G4PrimaryTransformer::chargedunknown = nullptr

protected

Definition at line 103 of file G4PrimaryTransformer.hh.

Referenced by CheckUnknown(), GetDefinition(), and SetChargedUnknownParticleDefined().

chargedUnknownParticleDefined

G4bool G4PrimaryTransformer::chargedUnknownParticleDefined = false

protected

Definition at line 109 of file G4PrimaryTransformer.hh.

Referenced by CheckUnknown(), GetChargedUnknownParticleDefined(), GetDefinition(), and SetChargedUnknownParticleDefined().

kETolerance

G4double G4PrimaryTransformer::kETolerance = 1.0 * CLHEP::MeV

staticprotected

Definition at line 112 of file G4PrimaryTransformer.hh.

Referenced by GenerateSingleTrack(), and SetKETolerance().

kETSeverity

G4ExceptionSeverity G4PrimaryTransformer::kETSeverity = JustWarning

staticprotected

Definition at line 113 of file G4PrimaryTransformer.hh.

Referenced by GenerateSingleTrack(), and SetKETolerance().

nWarn

G4int G4PrimaryTransformer::nWarn = 0

protected

Definition at line 107 of file G4PrimaryTransformer.hh.

Referenced by GenerateSingleTrack().

opticalphoton

G4ParticleDefinition* G4PrimaryTransformer::opticalphoton = nullptr

protected

Definition at line 104 of file G4PrimaryTransformer.hh.

Referenced by CheckUnknown(), and GenerateSingleTrack().

opticalphotonDefined

G4bool G4PrimaryTransformer::opticalphotonDefined = false

protected

Definition at line 110 of file G4PrimaryTransformer.hh.

Referenced by CheckUnknown(), and GenerateSingleTrack().

particleTable

G4ParticleTable* G4PrimaryTransformer::particleTable = nullptr

protected

Definition at line 100 of file G4PrimaryTransformer.hh.

Referenced by CheckUnknown(), G4PrimaryTransformer(), and GetDefinition().

trackID

G4int G4PrimaryTransformer::trackID = 0

protected

Definition at line 106 of file G4PrimaryTransformer.hh.

Referenced by GenerateSingleTrack(), and GimmePrimaries().

TV

G4TrackVector G4PrimaryTransformer::TV

protected

Definition at line 99 of file G4PrimaryTransformer.hh.

Referenced by GenerateSingleTrack(), and GimmePrimaries().

unknown

G4ParticleDefinition* G4PrimaryTransformer::unknown = nullptr

protected

Definition at line 102 of file G4PrimaryTransformer.hh.

Referenced by CheckUnknown(), GetDefinition(), and SetUnknownParticleDefined().

unknownParticleDefined

G4bool G4PrimaryTransformer::unknownParticleDefined = false

protected

Definition at line 108 of file G4PrimaryTransformer.hh.

Referenced by CheckUnknown(), GetDefinition(), GetUnknownParticleDefined(), and SetUnknownParticleDefined().

verboseLevel

G4int G4PrimaryTransformer::verboseLevel = 0

protected

Definition at line 105 of file G4PrimaryTransformer.hh.

Referenced by GenerateSingleTrack(), GenerateTracks(), SetDecayProducts(), and SetVerboseLevel().

---

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

• G4PrimaryTransformer.hh
• G4PrimaryTransformer.cc