G4PrimaryTransformer Class Reference

#include <G4PrimaryTransformer.hh>

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

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
G4int	verboseLevel
G4int	trackID
G4ParticleDefinition *	unknown
G4bool	unknownParticleDefined

Detailed Description

Definition at line 47 of file G4PrimaryTransformer.hh.

Constructor & Destructor Documentation

G4PrimaryTransformer()

G4PrimaryTransformer::G4PrimaryTransformer

(

)

Definition at line 43 of file G4PrimaryTransformer.cc.

:verboseLevel(0),trackID(0),unknown(0),unknownParticleDefined(false)
{
  particleTable = G4ParticleTable::GetParticleTable();
  CheckUnknown();
}

~G4PrimaryTransformer()

G4PrimaryTransformer::~G4PrimaryTransformer ( )

virtual

Definition at line 50 of file G4PrimaryTransformer.cc.

{;}

Member Function Documentation

CheckDynamicParticle()

G4bool G4PrimaryTransformer::CheckDynamicParticle ( G4DynamicParticle *  DP )

protected

Definition at line 301 of file G4PrimaryTransformer.cc.

{
  if(IsGoodForTrack(DP->GetDefinition())) return true;
  G4DecayProducts* decayProducts = (G4DecayProducts*)(DP->GetPreAssignedDecayProducts());
  if(decayProducts && 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");
  if(unknown) 
  { unknownParticleDefined = true; }
  else
  { unknownParticleDefined = false; }
}

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 107 of file G4PrimaryTransformer.cc.

{
  static G4ParticleDefinition* optPhoton = 0;
  static G4int nWarn = 0;
  if(!optPhoton) optPhoton = particleTable->FindParticle("opticalphoton");
 
  G4ParticleDefinition* partDef = GetDefinition(primaryParticle);
  if(!IsGoodForTrack(partDef))
  // The particle cannot be converted to G4Track, check daughters
  {
#ifdef G4VERBOSE
    if(verboseLevel>2)
    {
      G4cout << "Primary particle (PDGcode " << primaryParticle->GetPDGcode()
             << ") --- Ignored" << G4endl;
    }
#endif 
    G4PrimaryParticle* daughter = primaryParticle->GetDaughter();
    while(daughter)
    {
      GenerateSingleTrack(daughter,x0,y0,z0,t0,wv);
      daughter = daughter->GetNext();
    }
  }
 
  // The particle is defined in GEANT4
  else
  {
    // Create G4DynamicParticle object
#ifdef G4VERBOSE
    if(verboseLevel>1)
    {
      G4cout << "Primary particle (" << partDef->GetParticleName()
             << ") --- Transfered with momentum " << primaryParticle->GetMomentum()
             << G4endl;
    }
#endif
    G4DynamicParticle* DP = 
      new G4DynamicParticle(partDef,
                primaryParticle->GetMomentumDirection(),
                primaryParticle->GetKineticEnergy());
    if(partDef==optPhoton && 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();
    G4int iq = static_cast<int>(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
    G4Track* 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 79 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 != 0 )
  {
    GenerateSingleTrack( primaryParticle, X0, Y0, Z0, T0, WV );
    primaryParticle = primaryParticle->GetNext();
  }
}

Referenced by GimmePrimaries().

GetDefinition()

G4ParticleDefinition * G4PrimaryTransformer::GetDefinition ( G4PrimaryParticle *  pp )

protectedvirtual

Definition at line 314 of file G4PrimaryTransformer.cc.

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

Referenced by GenerateSingleTrack(), and SetDecayProducts().

GetUnknownParticleDefined()

G4bool G4PrimaryTransformer::GetUnknownParticleDefined ( ) const

inline

Definition at line 74 of file G4PrimaryTransformer.hh.

    { return unknownParticleDefined; }

GimmePrimaries()

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

Definition at line 62 of file G4PrimaryTransformer.cc.

{
  trackID = trackIDCounter;
 
  //TV.clearAndDestroy();
  for( size_t ii=0; ii<TV.size();ii++)
  { delete TV[ii]; }
  TV.clear();
  G4PrimaryVertex* nextVertex = anEvent->GetPrimaryVertex();
  while(nextVertex)
  { 
    GenerateTracks(nextVertex);
    nextVertex = nextVertex->GetNext();
  }
  return &TV;
}

IsGoodForTrack()

G4bool G4PrimaryTransformer::IsGoodForTrack ( G4ParticleDefinition *  pd )

protectedvirtual

Definition at line 322 of file G4PrimaryTransformer.cc.

{
  if(!pd)
  { return false; }
  else 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.
  else if(pd->GetDecayTable())
  { return true; }
  return false;
}

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

SetDecayProducts()

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

protected

Definition at line 230 of file G4PrimaryTransformer.cc.

{
  G4PrimaryParticle* daughter = mother->GetDaughter();
  if(!daughter) return;
  G4DecayProducts* decayProducts = (G4DecayProducts*)(motherDP->GetPreAssignedDecayProducts() );
  if(!decayProducts)
  {
    decayProducts = new G4DecayProducts(*motherDP);
    motherDP->SetPreAssignedDecayProducts(decayProducts);
  }
  while(daughter)
  {
    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
      G4DynamicParticle*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 is specified
      if (daughter->GetCharge()<DBL_MAX) {
        DP->SetCharge(daughter->GetCharge());
      } 
      G4double pmas = daughter->GetMass();
      if(pmas>=0.)
      { DP->SetMass(pmas); }
      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().

SetUnknnownParticleDefined()

void G4PrimaryTransformer::SetUnknnownParticleDefined

(

G4bool

vl

)

Definition at line 291 of file G4PrimaryTransformer.cc.

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

SetVerboseLevel()

void G4PrimaryTransformer::SetVerboseLevel ( G4int  vl )

inline

Definition at line 66 of file G4PrimaryTransformer.hh.

    { verboseLevel = vl; };

Referenced by G4EventManager::SetVerboseLevel().

Member Data Documentation

particleTable

G4ParticleTable* G4PrimaryTransformer::particleTable

protected

Definition at line 58 of file G4PrimaryTransformer.hh.

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

trackID

G4int G4PrimaryTransformer::trackID

protected

Definition at line 60 of file G4PrimaryTransformer.hh.

Referenced by GenerateSingleTrack(), and GimmePrimaries().

TV

G4TrackVector G4PrimaryTransformer::TV

protected

Definition at line 57 of file G4PrimaryTransformer.hh.

Referenced by GenerateSingleTrack(), and GimmePrimaries().

unknown

G4ParticleDefinition* G4PrimaryTransformer::unknown

protected

Definition at line 62 of file G4PrimaryTransformer.hh.

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

unknownParticleDefined

G4bool G4PrimaryTransformer::unknownParticleDefined

protected

Definition at line 63 of file G4PrimaryTransformer.hh.

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

verboseLevel

G4int G4PrimaryTransformer::verboseLevel

protected

Definition at line 59 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