G4PDGCodeChecker Class Reference

#include <G4PDGCodeChecker.hh>

Collaboration diagram for G4PDGCodeChecker:

Public Member Functions
	G4PDGCodeChecker ()
	~G4PDGCodeChecker ()
G4int	CheckPDGCode (G4int code, G4String type)
G4int	GetQuarkContent (G4int flavor) const
G4int	GetAntiQuarkContent (G4int flavor) const
G4bool	IsAntiParticle () const
G4int	GetQuarkFlavor (G4int idx) const
G4int	GetSpin () const
G4int	GetExotic () const
G4int	GetRadial () const
G4int	GetMultiplet () const
G4bool	CheckCharge (G4double charge) const
G4int	GetVerboseLevel () const
void	SetVerboseLevel (G4int verbose)

Protected Types
enum	{ NumberOfQuarkFlavor = 8 }

Private Member Functions
void	GetDigits (G4int code)
G4int	CheckForQuarks ()
G4int	CheckForDiQuarks ()
G4int	CheckForMesons ()
G4int	CheckForBaryons ()
G4int	CheckForNuclei ()

Private Attributes
G4int	verboseLevel
G4int	code
G4String	theParticleType
G4int	higherSpin
G4int	exotic
G4int	radial
G4int	multiplet
G4int	quark1
G4int	quark2
G4int	quark3
G4int	spin
G4int	theQuarkContent [NumberOfQuarkFlavor]
G4int	theAntiQuarkContent [NumberOfQuarkFlavor]

Detailed Description

Definition at line 44 of file G4PDGCodeChecker.hh.

Member Enumeration Documentation

anonymous enum

anonymous enum

protected

Enumerator
NumberOfQuarkFlavor

Definition at line 73 of file G4PDGCodeChecker.hh.

{NumberOfQuarkFlavor = 8};

Constructor & Destructor Documentation

G4PDGCodeChecker()

G4PDGCodeChecker::G4PDGCodeChecker

(

)

Definition at line 45 of file G4PDGCodeChecker.cc.

  :code(0),theParticleType(""),
   higherSpin(0),
   exotic(0),radial(0),multiplet(0),
   quark1(0),quark2(0),quark3(0),spin(0)
{
  verboseLevel = 1;
  // clear QuarkContents
  G4int flavor;
  for (flavor=0; flavor<NumberOfQuarkFlavor; flavor++){
    theQuarkContent[flavor] =0;
    theAntiQuarkContent[flavor] =0;
  }
}

~G4PDGCodeChecker()

G4PDGCodeChecker::~G4PDGCodeChecker ( )

inline

Definition at line 49 of file G4PDGCodeChecker.hh.

{};

Here is the call graph for this function:

Member Function Documentation

CheckCharge()

G4bool G4PDGCodeChecker::CheckCharge

(

G4double

charge

)

const

Definition at line 353 of file G4PDGCodeChecker.cc.

{
  // check charge
  G4double totalCharge = 0.0;
  for (G4int flavor= 0; flavor<NumberOfQuarkFlavor-1; flavor+=2){
    totalCharge += (-1./3.)*eplus*theQuarkContent[flavor];
    totalCharge += 1./3.*eplus*theAntiQuarkContent[flavor];
    totalCharge += 2./3.*eplus*theQuarkContent[flavor+1];
    totalCharge += (-2./3.)*eplus*theAntiQuarkContent[flavor+1];
  }

  if (std::fabs(totalCharge-thePDGCharge)>0.1*eplus) { 
#ifdef G4VERBOSE
    if (verboseLevel>0) {
      G4cout << " G4PDGCodeChecker::CheckCharge  : ";
      G4cout << " illegal electric charge " << thePDGCharge/eplus;
      G4cout << " PDG code=" << code <<G4endl;
    }
#endif
    return false;
  }
  return true;
}

Here is the caller graph for this function:

CheckForBaryons()

G4int G4PDGCodeChecker::CheckForBaryons ( )

private

Definition at line 107 of file G4PDGCodeChecker.cc.

{
  G4int   tempPDGcode = code;

  if ((quark1==0)||(quark2==0)||(quark3==0)){ 
#ifdef G4VERBOSE
    if (verboseLevel>0) {
      G4cout << " G4PDGCodeChecker::CheckPDGCode : ";
      G4cout << " meson has three quark ";
      G4cout << " PDG code=" << code <<G4endl;
    }
#endif
    return 0;
  }
 
 //exceptions
  if (std::abs(tempPDGcode)%10000 == 3122) { 
    // Lambda
    quark2=2;  quark3 = 1; spin = 1;
  } else if (std::abs(tempPDGcode)%10000 == 3124) { 
    // Lambda*
    quark2=2;  quark3 = 1; spin = 3;
  } else if (std::abs(tempPDGcode)%10000 == 3126) { 
    // Lambda*
    quark2=2;  quark3 = 1; spin = 5;
  } else if (std::abs(tempPDGcode)%10000 == 3128) { 
    // Lambda*
    quark2=2;  quark3 = 1; spin = 7;
  } else if (std::abs(tempPDGcode)%10000 == 4122) { 
    // Lambda_c
    quark2=2;  quark3 = 1; spin = 1;
  } else if (std::abs(tempPDGcode)%10000 == 5122) { 
    // Lambda_b
    quark2=2;  quark3 = 1; spin = 1;
  } else if (std::abs(tempPDGcode)%10000 == 4132) { 
    // Xi_c0
    quark2=3;  quark3 = 1; spin = 1;
  } else if (std::abs(tempPDGcode)%10000 == 4232) { 
    // Xi_c+
    quark2=3;  quark3 = 2; spin = 1;
  } else if (std::abs(tempPDGcode)%10000 == 5132) { 
    // Xi_b0
    quark2=3;  quark3 = 1; spin = 1;
  } else if (std::abs(tempPDGcode)%10000 == 5232) { 
    // Xi_b+
    quark2=3;  quark3 = 2; spin = 1;
  } else if (std::abs(tempPDGcode)%10000 == 2122) { 
    // Delta+ (spin 1/2) 
    quark2=2;  quark3 = 1; spin = 1;
  } else if (std::abs(tempPDGcode)%10000 == 1212) { 
    // Delta0 (spin 1/2) 
    quark1=2;  quark2 = 1; spin = 1;
  } else if (std::abs(tempPDGcode)%10000 == 2126) { 
    // Delta+ (spin 5/2) 
    quark2=2;  quark3 = 1; spin = 5;
  } else if (std::abs(tempPDGcode)%10000 == 1216) { 
    // Delta0 (spin 5/2) 
    quark1=2;  quark2 = 1; spin = 5;
  } else if (std::abs(tempPDGcode)%10000 == 2128) { 
    // Delta+ (spin 7/2) 
    quark2=2;  quark3 = 1; spin = 7;
  } else if (std::abs(tempPDGcode)%10000 == 1218) { 
    // Delta0 (spin 7/2) 
    quark1=2;  quark2 = 1; spin = 7;
  } else if (std::abs(tempPDGcode)%10000 == 2124) { 
    // N*+ (spin 3/2) 
    quark2=2;  quark3 = 1; spin = 3;
  } else if (std::abs(tempPDGcode)%10000 == 1214) { 
    // N*0 (spin 3/2) 
    quark1=2;  quark2 = 1; spin = 3;
  } 

    // check quark flavor
  if ((quark1<quark2)||(quark2<quark3)||(quark1<quark3)) { 
#ifdef G4VERBOSE
    if (verboseLevel>0) {
      G4cout << " G4PDGCodeChecker::CheckPDGCode : ";
      G4cout << " illegal code for baryon ";
      G4cout << " PDG code=" << code <<G4endl;
    }
#endif
    return 0;
  }
  if (quark1> NumberOfQuarkFlavor) {
#ifdef G4VERBOSE
    if (verboseLevel>0) {
      G4cout << " G4PDGCodeChecker::CheckPDGCode : ";
      G4cout << " ??? unknown quark ";
      G4cout << " PDG code=" << code <<G4endl;
    }
#endif
    return 0;
  }
  

  // Fill Quark contents
  if (tempPDGcode >0) {
    theQuarkContent[quark1-1] ++;
    theQuarkContent[quark2-1] ++;
    theQuarkContent[quark3-1] ++;
  } else {
    theAntiQuarkContent[quark1-1] ++;
    theAntiQuarkContent[quark2-1] ++;
    theAntiQuarkContent[quark3-1] ++;
  }

  return code;
}

Here is the caller graph for this function:

CheckForDiQuarks()

G4int G4PDGCodeChecker::CheckForDiQuarks ( )

private

Definition at line 290 of file G4PDGCodeChecker.cc.

{
  if ((quark1 ==0) || (quark2 ==0) || (quark3 !=0)) {
    // quark3 should be 0
    //  --- code is wrong 
    return 0;

  } else if (quark1 < quark2) {
    //  --- code is wrong 
    return 0;

  } else if (quark2>NumberOfQuarkFlavor){
#ifdef G4VERBOSE
    if (verboseLevel>0) {
      G4cout << " G4PDGCodeChecker::CheckPDGCode : ";
      G4cout << " ??? unknown quark ";
      G4cout << " PDG code=" << code <<G4endl;
    }
#endif
    return 0;

  }

  // Fill Quark Contents
  if (code>0){
    theQuarkContent[quark1-1] +=1;
    theQuarkContent[quark2-1] +=1;
  } else {
    theAntiQuarkContent[quark1-1] +=1;
    theAntiQuarkContent[quark2-1] +=1;
  }

  return code;
}

Here is the caller graph for this function:

CheckForMesons()

G4int G4PDGCodeChecker::CheckForMesons ( )

private

Definition at line 217 of file G4PDGCodeChecker.cc.

{
  G4int   tempPDGcode = code;

  //   -- exceptions --
  if (tempPDGcode == 310) spin = 0;        //K0s
  if (tempPDGcode == 130) {     //K0l
    spin = 0;        
    quark2 = 3;
    quark3 = 1;
  }
  
  // 
  if ((quark1 !=0)||(quark2==0)||(quark3==0)){ 
#ifdef G4VERBOSE
    if (verboseLevel>0) {
      G4cout << " G4PDGCodeChecker::CheckPDGCode : ";
      G4cout << " meson has only quark and anti-quark pair";
      G4cout << " PDG code=" << code <<G4endl;
    }
#endif
    return 0;
  } 
  if (quark2<quark3) { 
#ifdef G4VERBOSE
    if (verboseLevel>0) {
      G4cout << " G4PDGCodeChecker::CheckPDGCode : ";
      G4cout << " illegal code for meson ";
      G4cout << " PDG code=" << code <<G4endl;
    }
#endif
    return 0;
  }

  // check quark flavor
  if (quark2> NumberOfQuarkFlavor){
#ifdef G4VERBOSE
    if (verboseLevel>0) {
      G4cout << " G4PDGCodeChecker::CheckPDGCode : ";
      G4cout << " ??? unknown quark ";
      G4cout << " PDG code=" << code <<G4endl;
    }
#endif
    return 0;
  }

 
  // check heavier quark type
  if (quark2 & 1) {
    // down type qurak
    if (tempPDGcode >0) {
      theQuarkContent[quark3-1] =1;
      theAntiQuarkContent[quark2-1] =1;
    } else {
      theQuarkContent[quark2-1] =1;
      theAntiQuarkContent[quark3-1] =1;
    }
  } else {
    // up type quark
    if (tempPDGcode >0) {
      theQuarkContent[quark2-1] =1;
      theAntiQuarkContent[quark3-1] =1;
    } else {
      theQuarkContent[quark3-1] =1;
      theAntiQuarkContent[quark2-1] =1;
    }
  }
  return code;
}

Here is the caller graph for this function:

CheckForNuclei()

G4int G4PDGCodeChecker::CheckForNuclei ( )

private

Definition at line 378 of file G4PDGCodeChecker.cc.

{
  G4int pcode = std::abs(code);
  if (pcode < 1000000000) {
    // non-nuclei   
    return 0;
  }

  pcode -= 1000000000;
  G4int LL = pcode/10000000;
  pcode -= 10000000*LL;
  G4int Z = pcode/10000;
  pcode -= 10000*Z;
  G4int A = pcode/10;
  
  // Allow neutron balls
  // if (A < 2 || Z > A-LL || LL>A || Z<=0 ) {
  if (A < 2 || Z > A-LL || LL>A ) {
#ifdef G4VERBOSE
    if (verboseLevel>0) {
      G4cout << " G4PDGCodeChecker::CheckPDGCode : ";
      G4cout << " ???  Illegal PDG encoding for nucleus ";
      G4cout << " PDG code=" << code <<G4endl;
    }
#endif
    return 0;
  }

  G4int n_up   = 2*Z +   (A-Z-LL) + LL;
  G4int n_down =   Z + 2*(A-Z-LL) + LL;
  G4int n_s    =   LL;

  // Fill Quark contents
  if (code>0) {
    theQuarkContent[0] = n_up;
    theQuarkContent[1] = n_down;
    theQuarkContent[2] = n_s;
   } else {
    // anti_nucleus
    theAntiQuarkContent[0] = n_up;
    theAntiQuarkContent[1] = n_down;
    theAntiQuarkContent[2] = n_s;
  }
  return code;
}

Here is the call graph for this function:

Here is the caller graph for this function:

CheckForQuarks()

G4int G4PDGCodeChecker::CheckForQuarks ( )

private

Definition at line 326 of file G4PDGCodeChecker.cc.

{
  if ( std::abs(quark1)>NumberOfQuarkFlavor ) {
#ifdef G4VERBOSE
    if (verboseLevel>0) {
      G4cout << " G4PDGCodeChecker::CheckPDGCode : ";
      G4cout << " ??? unknown quark ";
      G4cout << " PDG code=" << code <<G4endl;
    }
#endif
    //  --- code is wrong 
    return 0;

  } 

  quark1 = std::abs(code);

  // Fill Quark Contents
  if (code>0){
    theQuarkContent[quark1-1] =1;
  } else {
    theAntiQuarkContent[quark1-1] =1;
  }
  return code;
}

Here is the caller graph for this function:

CheckPDGCode()

G4int G4PDGCodeChecker::CheckPDGCode	(	G4int	code,
		G4String	type
	)

Definition at line 61 of file G4PDGCodeChecker.cc.

{
  code = PDGcode;
  theParticleType = particleType;

  // clear QuarkContents
  G4int flavor;
  for (flavor=0; flavor<NumberOfQuarkFlavor; flavor++){
    theQuarkContent[flavor] =0;
    theAntiQuarkContent[flavor] =0;
  }

  // check code for nuclei
  if ((theParticleType == "nucleus")||(theParticleType == "anti_nucleus")) {
    return CheckForNuclei();
  }

  // get each digit number
  GetDigits(code);

  // check code
  if (theParticleType =="quarks") {
    return CheckForQuarks();

  } else if  (theParticleType =="diquarks") {
    return CheckForDiQuarks();

  } else if (theParticleType =="gluons") {
    // gluons 
    //   do not care about
    return code;

  } else if (theParticleType == "meson") {
    return CheckForMesons();

  } else if (theParticleType == "baryon"){
    return CheckForBaryons();


  }
  // No check
  return code;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetAntiQuarkContent()

G4int G4PDGCodeChecker::GetAntiQuarkContent ( G4int  flavor ) const

inline

Definition at line 119 of file G4PDGCodeChecker.hh.

{
  G4int value = 0;
  if ((flavor>=0)&&(flavor<NumberOfQuarkFlavor)) {
    value = theAntiQuarkContent[flavor];
  }
  return value;
}

Here is the caller graph for this function:

GetDigits()

void G4PDGCodeChecker::GetDigits ( G4int  code )

private

Definition at line 425 of file G4PDGCodeChecker.cc.

{
  G4int temp = std::abs(PDGcode);
  
  higherSpin = temp/10000000;
  temp -= G4int(higherSpin*10000000);

  exotic = temp/1000000;
  temp -= G4int(exotic*1000000);

  radial = temp/100000;
  temp -= G4int(radial*100000);

  multiplet = temp/10000;
  temp -= G4int(multiplet*10000);

  quark1 = temp/1000;
  temp -= G4int(quark1*1000);

  quark2 = temp/100;
  temp -= G4int(quark2*100);

  quark3 = temp/10;
  temp -= G4int(quark3*10);

  spin= temp;
  if ((spin ==0) && ( higherSpin !=0 )) {
    spin =  higherSpin-1;
  } else {
    spin -= 1;
  }
}

Here is the caller graph for this function:

GetExotic()

G4int G4PDGCodeChecker::GetExotic ( ) const

inline

Definition at line 141 of file G4PDGCodeChecker.hh.

{
  return exotic;
}

Here is the caller graph for this function:

GetMultiplet()

G4int G4PDGCodeChecker::GetMultiplet ( ) const

inline

Definition at line 153 of file G4PDGCodeChecker.hh.

{
  return multiplet;
}

Here is the caller graph for this function:

GetQuarkContent()

G4int G4PDGCodeChecker::GetQuarkContent ( G4int  flavor ) const

inline

Definition at line 109 of file G4PDGCodeChecker.hh.

{
  G4int value = 0;
  if ((flavor>=0)&&(flavor<NumberOfQuarkFlavor)) {
    value = theQuarkContent[flavor];
  }
  return value;
}

Here is the caller graph for this function:

GetQuarkFlavor()

G4int G4PDGCodeChecker::GetQuarkFlavor ( G4int  idx ) const

inline

Definition at line 130 of file G4PDGCodeChecker.hh.

{
  G4int value;
  if (idx ==0) value = quark1;
  else if (idx ==1) value = quark2;
  else if (idx ==2) value = quark3;
  else value = -1;
  return value;
}

Here is the caller graph for this function:

GetRadial()

G4int G4PDGCodeChecker::GetRadial ( ) const

inline

Definition at line 147 of file G4PDGCodeChecker.hh.

{
  return radial;
}

Here is the caller graph for this function:

GetSpin()

G4int G4PDGCodeChecker::GetSpin ( ) const

inline

Definition at line 159 of file G4PDGCodeChecker.hh.

{
  return spin;
}

Here is the caller graph for this function:

GetVerboseLevel()

G4int G4PDGCodeChecker::GetVerboseLevel ( ) const

inline

Definition at line 177 of file G4PDGCodeChecker.hh.

{
   return verboseLevel;
}

Here is the caller graph for this function:

IsAntiParticle()

G4bool G4PDGCodeChecker::IsAntiParticle ( ) const

inline

Definition at line 165 of file G4PDGCodeChecker.hh.

{
  return (code <0);
}

Here is the caller graph for this function:

SetVerboseLevel()

void G4PDGCodeChecker::SetVerboseLevel ( G4int  verbose )

inline

Definition at line 171 of file G4PDGCodeChecker.hh.

{
   verboseLevel = value;
}

Here is the caller graph for this function:

Member Data Documentation

code

G4int G4PDGCodeChecker::code

private

Definition at line 87 of file G4PDGCodeChecker.hh.

exotic

G4int G4PDGCodeChecker::exotic

private

Definition at line 91 of file G4PDGCodeChecker.hh.

higherSpin

G4int G4PDGCodeChecker::higherSpin

private

Definition at line 90 of file G4PDGCodeChecker.hh.

multiplet

G4int G4PDGCodeChecker::multiplet

private

Definition at line 93 of file G4PDGCodeChecker.hh.

quark1

G4int G4PDGCodeChecker::quark1

private

Definition at line 94 of file G4PDGCodeChecker.hh.

quark2

G4int G4PDGCodeChecker::quark2

private

Definition at line 95 of file G4PDGCodeChecker.hh.

quark3

G4int G4PDGCodeChecker::quark3

private

Definition at line 96 of file G4PDGCodeChecker.hh.

radial

G4int G4PDGCodeChecker::radial

private

Definition at line 92 of file G4PDGCodeChecker.hh.

spin

G4int G4PDGCodeChecker::spin

private

Definition at line 97 of file G4PDGCodeChecker.hh.

theAntiQuarkContent

G4int G4PDGCodeChecker::theAntiQuarkContent[NumberOfQuarkFlavor]

private

Definition at line 100 of file G4PDGCodeChecker.hh.

theParticleType

G4String G4PDGCodeChecker::theParticleType

private

Definition at line 88 of file G4PDGCodeChecker.hh.

theQuarkContent

G4int G4PDGCodeChecker::theQuarkContent[NumberOfQuarkFlavor]

private

Definition at line 99 of file G4PDGCodeChecker.hh.

verboseLevel

G4int G4PDGCodeChecker::verboseLevel

private

Definition at line 85 of file G4PDGCodeChecker.hh.

---

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

• G4PDGCodeChecker.hh
• G4PDGCodeChecker.cc