Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/particles/utils/src/G4HtmlPPReporter.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /particles/utils/src/G4HtmlPPReporter.cc (Version 11.3.0) and /particles/utils/src/G4HtmlPPReporter.cc (Version 9.0.p1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25                                                <<  25 //
                                                   >>  26 // the GEANT4 collaboration.
                                                   >>  27 //
                                                   >>  28 // By copying, distributing or modifying the Program (or any work
                                                   >>  29 // based on the Program) you indicate your acceptance of this statement,
                                                   >>  30 // and all its terms.
                                                   >>  31 //
                                                   >>  32 // $Id: G4HtmlPPReporter.cc,v 1.5 2007/03/11 07:17:35 kurasige Exp $
                                                   >>  33 // GEANT4 tag $Name: geant4-09-00-patch-01 $
                                                   >>  34 //
                                                   >>  35 // 
                                                   >>  36 // ---------------------------------------------------------------
 26 #include "G4HtmlPPReporter.hh"                     37 #include "G4HtmlPPReporter.hh"
 27                                                << 
 28 #include "G4DecayTable.hh"                     << 
 29 #include "G4ParticleDefinition.hh"             << 
 30 #include "G4ParticleTable.hh"                  << 
 31 #include "G4SystemOfUnits.hh"                  << 
 32 #include "G4Tokenizer.hh"                      << 
 33 #include "G4VDecayChannel.hh"                  << 
 34 #include "G4ios.hh"                                38 #include "G4ios.hh"
 35 #include "globals.hh"                              39 #include "globals.hh"
 36                                                <<  40 #include "G4DecayTable.hh"  
                                                   >>  41 #include "G4Tokenizer.hh"
 37 #include <iomanip>                                 42 #include <iomanip>
 38                                                    43 
 39 void G4HtmlPPReporter::Print(const G4String& o <<  44  G4HtmlPPReporter::G4HtmlPPReporter():G4VParticlePropertyReporter()
                                                   >>  45 {
                                                   >>  46  
                                                   >>  47 }
                                                   >>  48 
                                                   >>  49  G4HtmlPPReporter::~G4HtmlPPReporter()
                                                   >>  50 {
                                                   >>  51 }    
                                                   >>  52 
                                                   >>  53  void G4HtmlPPReporter::Print(const G4String& option)
 40 {                                                  54 {
 41   SparseOption(option);                        <<  55   SparseOption( option );
 42                                                    56 
 43   GenerateIndex();                                 57   GenerateIndex();
 44                                                    58 
 45   for (const auto& i : pList) {                <<  59   for (size_t i=0; i< pList.size(); i++){
 46     G4ParticleDefinition* particle =           <<  60     G4ParticleDefinition* particle  = G4ParticleTable::GetParticleTable()->FindParticle( pList[i]->GetParticleName() ); 
 47       G4ParticleTable::GetParticleTable()->Fin << 
 48     GeneratePropertyTable(particle);               61     GeneratePropertyTable(particle);
 49   }                                                62   }
 50 }                                              <<  63 }    
                                                   >>  64 
 51                                                    65 
 52 void G4HtmlPPReporter::SparseOption(const G4St     66 void G4HtmlPPReporter::SparseOption(const G4String& option)
 53 {                                                  67 {
 54   G4Tokenizer savedToken(option);              <<  68   G4Tokenizer savedToken( option );
 55                                                <<  69   
 56   // 1st option : base directory                   70   // 1st option : base directory
 57   baseDir = savedToken();                          71   baseDir = savedToken();
 58   if (!baseDir.empty()) {                      <<  72   if (!baseDir.isNull()) {
 59     if (baseDir.back() != '/') {               <<  73     if(baseDir(baseDir.length()-1)!='/') {
 60       baseDir += "/";                              74       baseDir += "/";
 61     }                                              75     }
 62   }                                                76   }
 63   comment = savedToken();                      <<  77   comment =  savedToken();
 64 }                                                  78 }
 65                                                    79 
 66 void G4HtmlPPReporter::GenerateIndex()         <<  80  void G4HtmlPPReporter::GenerateIndex()
 67 {                                                  81 {
 68   //--- open index file -----                      82   //--- open index file -----
 69   G4String fileName = baseDir + "index.html";      83   G4String fileName = baseDir + "index.html";
 70   std::ofstream outFile(fileName, std::ios::ou <<  84   std::ofstream outFile(fileName, std::ios::out );
 71   outFile.setf(std::ios::scientific, std::ios: <<  85   outFile.setf( std::ios:: scientific, std::ios::floatfield );
 72                                                <<  86   
 73   // header                                        87   // header
 74   PrintHeader(outFile);                            88   PrintHeader(outFile);
 75                                                <<  89   
 76   // comment                                       90   // comment
 77   outFile << "<! -- " << comment << " -- !> "  <<  91   outFile << "<! -- " << comment << " --!> " << G4endl;
 78   outFile << G4endl;                               92   outFile << G4endl;
 79                                                <<  93   
                                                   >>  94   
 80   outFile << sTABLE << '"' << "80%" << '"' <<      95   outFile << sTABLE << '"' << "80%" << '"' << " > " << G4endl;
 81                                                <<  96   
 82   // Raw #1                                        97   // Raw #1
 83   outFile << sTR;                                  98   outFile << sTR;
 84   outFile << sTD << sLFONT << "Code" << eLFONT <<  99   outFile << sTD << sLFONT << "Code" << eLFONT<< eTD; 
 85   outFile << sTD << sLFONT << "Name" << eLFONT << 100   outFile << sTD << sLFONT << "Name" << eLFONT<< eTD; 
 86   outFile << sTD << sLFONT << "Mass" << eLFONT << 101   outFile << sTD << sLFONT << "Anti-Particle" << eLFONT<< eTD; 
 87   outFile << sTD << sLFONT << "Charge" << eLFO << 102   outFile << eTR << G4endl;;
 88   outFile << sTD << sLFONT << "Life Time" << e << 103   
 89   outFile << sTD << sLFONT << "Anti-Particle"  << 104   for (size_t i=0; i< pList.size(); i++){
 90   outFile << eTR << G4endl;                    << 105     if (pList[i]->GetPDGEncoding()<0) continue;
 91   ;                                            << 
 92                                                << 
 93   // Raw #2                                    << 
 94   outFile << sTR;                              << 
 95   outFile << sTD << " " << eTD;                << 
 96   outFile << sTD << " " << eTD;                << 
 97   outFile << sTD << " [GeV/c" << sSUP << "2" < << 
 98   outFile << sTD << " " << eTD;                << 
 99   outFile << sTD << " [ns]" << eTD;            << 
100   outFile << sTD << " " << eTD;                << 
101   outFile << eTR << G4endl;                    << 
102   ;                                            << 
103                                                   106 
104   for (const auto& i : pList) {                << 107     outFile << sTR << G4endl;;
105     if (i->GetPDGEncoding() < 0) continue;     << 
106                                                << 
107     outFile << sTR << G4endl;                  << 
108     ;                                          << 
109     // column 1  : endcoding                      108     // column 1  : endcoding
110     outFile << sTD << i->GetPDGEncoding() << e << 109     outFile << sTD << pList[i]->GetPDGEncoding() << eTD << G4endl;; 
111     ;                                          << 110     // column 2  : name 
112     // column 2  : name                        << 111     G4String name = pList[i]->GetParticleName();
113     G4String name = i->GetParticleName();      << 112     
114                                                << 113     G4String fname = name +".html";
115     G4String fname = name + ".html";           << 
116     // exception                                  114     // exception
117     if (name == "J/psi") fname = "jpsi.html";     115     if (name == "J/psi") fname = "jpsi.html";
118                                                << 116     
119     outFile << sTD;                               117     outFile << sTD;
120     outFile << "<A HREF=" << '"' << fname << '    118     outFile << "<A HREF=" << '"' << fname << '"' << ">";
121     outFile << name << "</A>" << eTD << G4endl    119     outFile << name << "</A>" << eTD << G4endl;
122                                                << 120    
123     // column 3 mass                           << 121     // column 3 AntiParticle
124     outFile << sTD << i->GetPDGMass() / GeV << << 122     if  ( (pList[i]->GetAntiPDGEncoding()!= 0) &&
125                                                << 123           (pList[i]->GetAntiPDGEncoding() != pList[i]->GetPDGEncoding() ) ) {
126     // column 4 charge                         << 124       G4ParticleDefinition* anti_particle  = G4ParticleTable::GetParticleTable()->FindParticle( pList[i]->GetAntiPDGEncoding() ); 
127     outFile << sTD << i->GetPDGCharge() / eplu << 125       
128                                                << 126       outFile << sTD <<  anti_particle->GetParticleName() << eTD << G4endl;;
129     // column 5 life time                      << 
130     outFile << sTD << i->GetPDGLifeTime() / ns << 
131                                                << 
132     // column 6 AntiParticle                   << 
133     if ((i->GetAntiPDGEncoding() != 0) && (i-> << 
134       G4ParticleDefinition* anti_particle =    << 
135         G4ParticleTable::GetParticleTable()->F << 
136                                                << 
137       outFile << sTD << anti_particle->GetPart << 
138       ;                                        << 
139     }                                             127     }
140                                                << 128     outFile << eTR << G4endl;;
141     // end raw                                 << 
142     outFile << eTR << G4endl;                  << 
143     ;                                          << 
144   }                                               129   }
145                                                << 130   
146   outFile << eTABLE << G4endl;                    131   outFile << eTABLE << G4endl;
147                                                << 132   
148   // footer                                       133   // footer
149   PrintFooter(outFile);                        << 134   PrintFooter(outFile); 
                                                   >> 135   
150 }                                                 136 }
151                                                   137 
152 void G4HtmlPPReporter::GeneratePropertyTable(c << 138  void  G4HtmlPPReporter::GeneratePropertyTable(G4ParticleDefinition* particle)
153 {                                                 139 {
154   if (particle->GetPDGEncoding() < 0) return;  << 140   if (particle->GetPDGEncoding()<0) return;
155                                                   141 
156   G4String name = particle->GetParticleName();    142   G4String name = particle->GetParticleName();
157   //--- open index file -----                     143   //--- open index file -----
158   G4String fileName = baseDir + name + ".html"    144   G4String fileName = baseDir + name + ".html";
159   // exception                                    145   // exception
160   if (name == "J/psi") fileName = baseDir + "j << 146   if (name == "J/psi") fileName = baseDir +"jpsi.html";
161   std::ofstream outFile(fileName, std::ios::ou << 147   std::ofstream outFile(fileName, std::ios::out );
162   outFile.setf(std::ios::scientific, std::ios: << 148   outFile.setf( std::ios:: scientific, std::ios::floatfield );
163   outFile << std::setprecision(7) << G4endl;      149   outFile << std::setprecision(7) << G4endl;
164                                                   150 
165   PrintHeader(outFile);                           151   PrintHeader(outFile);
166                                                << 152    
167   // particle name                                153   // particle name
168   outFile << "<H2>" << name << "</H2>" << G4en    154   outFile << "<H2>" << name << "</H2>" << G4endl;
169   outFile << "<HR>" << G4endl;                    155   outFile << "<HR>" << G4endl;
170                                                   156 
171   // encoding, type                               157   // encoding, type
172   outFile << sTABLE << '"' << "40%" << '"' <<     158   outFile << sTABLE << '"' << "40%" << '"' << " > " << G4endl;
173   outFile << sTR << sTD << sB << "PDG encoding    159   outFile << sTR << sTD << sB << "PDG encoding" << eB << eTD;
174   outFile << sTD << particle->GetPDGEncoding() << 160   outFile << sTD <<  particle->GetPDGEncoding() << eTD << eTR << G4endl;
175   outFile << sTR << sTD << sB << "Type" << eB     161   outFile << sTR << sTD << sB << "Type" << eB << eTD;
176   outFile << sTD << particle->GetParticleType( << 162   outFile << sTD <<  particle->GetParticleType() << eTD << eTR << G4endl;
177   outFile << eTABLE << G4endl;                    163   outFile << eTABLE << G4endl;
178   outFile << "<HR>" << G4endl;                    164   outFile << "<HR>" << G4endl;
179                                                   165 
180   // Properties                                << 166   // Properties  
181   outFile << sTABLE << '"' << "60%" << '"' <<     167   outFile << sTABLE << '"' << "60%" << '"' << " > " << G4endl;
182   // mass                                         168   // mass
183   outFile << sTR << sTD << sB << "Mass" << eB     169   outFile << sTR << sTD << sB << "Mass" << eB << eTD;
184   outFile << sTD << particle->GetPDGMass() / G << 170   outFile << sTD <<  particle->GetPDGMass()/GeV;
185   outFile << " [GeV/c" << sSUP << "2" << eSUP     171   outFile << " [GeV/c" << sSUP << "2" << eSUP << "]" << eTD << eTR << G4endl;
186   // width                                        172   // width
187   outFile << sTR << sTD << sB << "Width" << eB    173   outFile << sTR << sTD << sB << "Width" << eB << eTD;
188   outFile << sTD << particle->GetPDGWidth() /  << 174   outFile << sTD <<  particle->GetPDGWidth()/GeV;
189   outFile << " [GeV/c" << sSUP << "2" << eSUP     175   outFile << " [GeV/c" << sSUP << "2" << eSUP << "]" << eTD << eTR << G4endl;
190   // IJPC                                         176   // IJPC
191   outFile << sTR << sTD << sB << "I J" << sSUP << 177   outFile << sTR << sTD << sB << "I J" << sSUP << "PC"<< eSUP << eB << eTD;
192   if (particle->GetPDGiIsospin() < 0) {        << 178   if ( particle->GetPDGiIsospin() <0 ) {
193     outFile << sTD << "    ";                     179     outFile << sTD << "    ";
194   }                                            << 180   } else if ( particle->GetPDGiIsospin() == 1) {
195   else if (particle->GetPDGiIsospin() == 1) {  << 
196     outFile << sTD << "1/2 ";                     181     outFile << sTD << "1/2 ";
                                                   >> 182   } else if ( particle->GetPDGiIsospin() == 3) {
                                                   >> 183     outFile << sTD << "3/2 "; 
                                                   >> 184   } else {
                                                   >> 185     outFile << sTD << particle->GetPDGiIsospin()/2 << " ";
197   }                                               186   }
198   else if (particle->GetPDGiIsospin() == 3) {  << 187   if ( particle->GetPDGiSpin() == 1) {
199     outFile << sTD << "3/2 ";                  << 
200   }                                            << 
201   else {                                       << 
202     outFile << sTD << particle->GetPDGiIsospin << 
203   }                                            << 
204   if (particle->GetPDGiSpin() == 1) {          << 
205     outFile << "1/2";                             188     outFile << "1/2";
206   }                                            << 189   } else if ( particle->GetPDGiSpin() == 3) {
207   else if (particle->GetPDGiSpin() == 3) {     << 190     outFile << "3/2"; 
208     outFile << "3/2";                          << 191   } else if ( particle->GetPDGiSpin() == 5) {
209   }                                            << 192     outFile << "5/2"; 
210   else if (particle->GetPDGiSpin() == 5) {     << 193   } else if ( particle->GetPDGiSpin() == 7) {
211     outFile << "5/2";                          << 194     outFile << "7/2"; 
212   }                                            << 195   } else if ( particle->GetPDGiSpin() == 9) {
213   else if (particle->GetPDGiSpin() == 7) {     << 196     outFile << "9/2"; 
214     outFile << "7/2";                          << 197   } else if ( particle->GetPDGiSpin() == 11) {
215   }                                            << 198     outFile << "11/2"; 
216   else if (particle->GetPDGiSpin() == 9) {     << 199   } else if ( particle->GetPDGiSpin() == 13) {
217     outFile << "9/2";                          << 200     outFile << "13/2"; 
218   }                                            << 201   } else {
219   else if (particle->GetPDGiSpin() == 11) {    << 202     outFile << particle->GetPDGiSpin()/2;
220     outFile << "11/2";                         << 
221   }                                            << 
222   else if (particle->GetPDGiSpin() == 13) {    << 
223     outFile << "13/2";                         << 
224   }                                            << 
225   else {                                       << 
226     outFile << particle->GetPDGiSpin() / 2;    << 
227   }                                               203   }
228   outFile << sSUP << sSYMBOL;                     204   outFile << sSUP << sSYMBOL;
229   if (particle->GetPDGiParity() == +1) {       << 205   if (particle->GetPDGiParity() == +1 ){
230     outFile << "+";                            << 206   outFile << "+";
231   }                                            << 207   } else if (particle->GetPDGiParity() == -1 ){
232   else if (particle->GetPDGiParity() == -1) {  << 208   outFile << "-";
233     outFile << "-";                            << 209   } else {
234   }                                            << 
235   else {                                       << 
236     outFile << " ";                               210     outFile << " ";
237   }                                               211   }
238   if (particle->GetPDGiConjugation() == +1) {  << 212   if (particle->GetPDGiConjugation() == +1 ){
239     outFile << "+";                            << 213   outFile << "+";
240   }                                            << 214   } else if (particle->GetPDGiConjugation() == -1 ){
241   else if (particle->GetPDGiConjugation() == - << 215   outFile << "-";
242     outFile << "-";                            << 216   } else {
243   }                                            << 
244   else {                                       << 
245     outFile << " ";                               217     outFile << " ";
246   }                                               218   }
247   outFile << eSYMBOL << eSUP;                     219   outFile << eSYMBOL << eSUP;
248   outFile << eTD << eTR << G4endl;             << 220   outFile <<  eTD << eTR << G4endl;
249   // charge                                       221   // charge
250   outFile << sTR << sTD << sB << "Charge" << e    222   outFile << sTR << sTD << sB << "Charge" << eB << eTD;
251   outFile << sTD << particle->GetPDGCharge() / << 223   outFile << sTD <<  particle->GetPDGCharge()/eplus;
252   outFile << eTD << eTR << G4endl;                224   outFile << eTD << eTR << G4endl;
253   // Magnetic Moment                              225   // Magnetic Moment
254   outFile << sTR << sTD << sB << "Magnetic Mom    226   outFile << sTR << sTD << sB << "Magnetic Moment" << eB << eTD;
255   if (particle->GetPDGMagneticMoment() != 0.0) << 227   if  (particle->GetPDGMagneticMoment() != 0.0){
256     outFile << sTD << particle->GetPDGMagnetic << 228     outFile << sTD <<  particle->GetPDGMagneticMoment()/MeV*tesla;
257     outFile << "[MeV/T]" << eTD << eTR << G4en    229     outFile << "[MeV/T]" << eTD << eTR << G4endl;
258   }                                            << 230   } else {
259   else {                                       << 231     outFile << sTD <<  " not defined ";
260     outFile << sTD << " not defined ";         << 
261     outFile << eTD << eTR << G4endl;              232     outFile << eTD << eTR << G4endl;
262   }                                               233   }
263   // life time                                    234   // life time
264   outFile << sTR << sTD << sB << "Life Time" <    235   outFile << sTR << sTD << sB << "Life Time" << eB << eTD;
265   if (particle->GetPDGLifeTime() > 0.0) {      << 236   if ( particle->GetPDGLifeTime() >0.0 ) {
266     outFile << sTD << particle->GetPDGLifeTime << 237     outFile << sTD <<  particle->GetPDGLifeTime()/second;
267     outFile << "[sec]" << eTD << G4endl;          238     outFile << "[sec]" << eTD << G4endl;
268   }                                            << 239   } else {
269   else {                                       << 
270     if (particle->GetPDGStable()) {               240     if (particle->GetPDGStable()) {
271       outFile << sTD << "stable" << eTD;          241       outFile << sTD << "stable" << eTD;
272     }                                          << 242     } else if (particle->IsShortLived()) {
273     else if (particle->IsShortLived()) {       << 
274       outFile << sTD << "short-lived" << eTD;     243       outFile << sTD << "short-lived" << eTD;
275     }                                          << 244     } else {
276     else {                                     << 245       outFile << sTD <<  "not Defined" << eTD;
277       outFile << sTD << "not Defined" << eTD;  << 
278     }                                             246     }
279   }                                               247   }
280   outFile << eTR << G4endl;                       248   outFile << eTR << G4endl;
281                                                   249 
282   outFile << eTABLE << G4endl;                    250   outFile << eTABLE << G4endl;
283   outFile << "<HR>" << G4endl;                    251   outFile << "<HR>" << G4endl;
284                                                   252 
285   // Qurak content                             << 253   // Qurak content 
286   outFile << "<H2>"                            << 254   outFile << "<H2>" << " Quark Content " << "</H2>" << G4endl;
287           << " Quark Content "                 << 
288           << "</H2>" << G4endl;                << 
289                                                   255 
290   outFile << sTABLE << '"' << "60%" << '"' <<     256   outFile << sTABLE << '"' << "60%" << '"' << " > " << G4endl;
291                                                << 257  
292   outFile << sTR;                                 258   outFile << sTR;
293   outFile << sTD << sB << "flavour " << eB <<  << 259   outFile << sTD << sB << "flavour " << eB << eTD ;
294   outFile << sTD << sB << " quark " << eB << e << 260   outFile << sTD << sB << " quark " << eB << eTD; 
295   outFile << sTD << sB << " anti-quark " << eB << 261   outFile << sTD << sB << " anti-quark " << eB << eTD; 
296   outFile << eTR;                                 262   outFile << eTR;
297                                                   263 
298   static const char* quarkName[6] = {"d", "u", << 264   static const char* quarkName[6] = { "d", "u", "s", "c", "b", "t" };
299   for (G4int flv = 0; flv < 6; flv++) {        << 265   for (G4int flv = 0; flv <6 ; flv++ ){
300     outFile << sTR;                               266     outFile << sTR;
301     outFile << sTD << sB << quarkName[flv] <<  << 267     outFile << sTD << sB << quarkName[flv] << eB << eTD ;
302     outFile << sTD << sB << particle->GetQuark << 268     outFile << sTD << sB << particle->GetQuarkContent(flv+1) << eB << eTD ;
303     outFile << sTD << sB << particle->GetAntiQ << 269     outFile << sTD << sB << particle->GetAntiQuarkContent(flv+1) << eB << eTD ;
304     outFile << eTR;                               270     outFile << eTR;
305   }                                               271   }
306   outFile << eTABLE << G4endl;                    272   outFile << eTABLE << G4endl;
307   outFile << "<HR>" << G4endl;                    273   outFile << "<HR>" << G4endl;
308                                                   274 
309   // Decay Table                               << 275  // Decay Table  
310   G4DecayTable* dcyTable = particle->GetDecayT << 276   G4DecayTable* dcyTable = particle->GetDecayTable(); 
311   if (dcyTable != nullptr) {                   << 277   if (dcyTable != 0) { 
312     outFile << "<H2>"                          << 278     outFile << "<H2>" << " Decay Table " << "</H2>" << G4endl;
313             << " Decay Table "                 << 
314             << "</H2>" << G4endl;              << 
315                                                   279 
316     outFile << sTABLE << '"' << "80%" << '"' <    280     outFile << sTABLE << '"' << "80%" << '"' << " > " << G4endl;
317                                                << 281     
318     outFile << sTR;                               282     outFile << sTR;
319     outFile << sTD << sB << "BR" << eB << eTD; << 283     outFile << sTD << sB << "BR" << eB << eTD ;
320     outFile << sTD << sB << "kinematics" << eB << 284     outFile << sTD << sB << "kinematics" << eB << eTD; 
321     outFile << eTR;                               285     outFile << eTR;
322                                                   286 
323     for (G4int i = 0; i < dcyTable->entries(); << 287     for (G4int i=0; i< dcyTable->entries(); i++){
324       G4VDecayChannel* channel = dcyTable->Get << 288       G4VDecayChannel * channel = dcyTable->GetDecayChannel(i);
325       outFile << sTR << G4endl;                << 289       outFile << sTR << G4endl;;
326       ;                                        << 
327       // column 1  : BR                           290       // column 1  : BR
328       outFile << sTD << channel->GetBR() << eT    291       outFile << sTD << channel->GetBR() << eTD;
329       // column 2 : Kinematics                    292       // column 2 : Kinematics
330       outFile << sTD << channel->GetKinematics    293       outFile << sTD << channel->GetKinematicsName() << eTD;
331       // column 3..  : daughters                  294       // column 3..  : daughters
332       for (G4int j = 0; j < channel->GetNumber << 295       for (G4int j=0; j< channel->GetNumberOfDaughters(); j++){
333         outFile << sTD << channel->GetDaughter    296         outFile << sTD << channel->GetDaughter(j)->GetParticleName() << eTD;
334       }                                           297       }
335       outFile << eTR << G4endl;                   298       outFile << eTR << G4endl;
336     }                                             299     }
337     outFile << eTABLE << G4endl;                  300     outFile << eTABLE << G4endl;
338     outFile << "<HR>" << G4endl;                  301     outFile << "<HR>" << G4endl;
339   }                                               302   }
340                                                << 303   
341   outFile << sB;                                  304   outFile << sB;
342   outFile << "<A HREF=" << '"' << "index.html" << 305   outFile << "<A HREF=" << '"' <<  "index.html" << '"' << ">back to index</A>";
343   outFile << eB << G4endl;                        306   outFile << eB << G4endl;
344                                                   307 
345   PrintFooter(outFile);                        << 308   PrintFooter(outFile); 
346 }                                                 309 }
347                                                   310 
348 void G4HtmlPPReporter::PrintHeader(std::ofstre << 311  void G4HtmlPPReporter::PrintHeader(std::ofstream& outFile)
349 {                                                 312 {
350   outFile << "<HTML>" << G4endl;                  313   outFile << "<HTML>" << G4endl;
351   outFile << "<HEAD>" << G4endl;                  314   outFile << "<HEAD>" << G4endl;
352   outFile << " <META HTTP-EQUIV="              << 315   outFile << " <META HTTP-EQUIV=" << "\"" << " Content-Type" << "\"";
353           << "\""                              << 316   outFile << " CONTENT=" << "\"" << "text/html; charset=iso-8859-1" << "\"" << ">" << G4endl;
354           << " Content-Type"                   << 
355           << "\"";                             << 
356   outFile << " CONTENT="                       << 
357           << "\""                              << 
358           << "text/html; charset=iso-8859-1"   << 
359           << "\""                              << 
360           << ">" << G4endl;                    << 
361   outFile << " <TITLE>Geant4 Particle List </T    317   outFile << " <TITLE>Geant4 Particle List </TITLE>" << G4endl;
362   outFile << "</HEAD>" << G4endl;                 318   outFile << "</HEAD>" << G4endl;
363   outFile << "<! -- Generated automatically by << 319   outFile << "<!-- Generated automatically by Geant4, ";
364           << " -- !>" << G4endl;               << 320   outFile << " -- >" << G4endl;
365   outFile << "<BODY>" << G4endl;                  321   outFile << "<BODY>" << G4endl;
366 }                                                 322 }
367                                                   323 
368 void G4HtmlPPReporter::PrintFooter(std::ofstre << 324  void G4HtmlPPReporter::PrintFooter(std::ofstream& outFile)
369 {                                                 325 {
370   outFile << "<HR>" << G4endl;                    326   outFile << "<HR>" << G4endl;
371   outFile << "</BODY>" << G4endl;                 327   outFile << "</BODY>" << G4endl;
372   outFile << "</HTML>" << G4endl;                 328   outFile << "</HTML>" << G4endl;
373 }                                                 329 }
374                                                   330 
375 const char* G4HtmlPPReporter::sTABLE = "<TABLE << 331 const char*  G4HtmlPPReporter::sTABLE = "<TABLE WIDTH=";
376 const char* G4HtmlPPReporter::eTABLE = "</TABL << 332 const char*  G4HtmlPPReporter::eTABLE = "</TABLE>";
377 const char* G4HtmlPPReporter::sTR = "<TR>";    << 333 const char*  G4HtmlPPReporter::sTR = "<TR>";
378 const char* G4HtmlPPReporter::eTR = "</TR>";   << 334 const char*  G4HtmlPPReporter::eTR = "</TR>";
379 const char* G4HtmlPPReporter::sTD = "<TD>";    << 335 const char*  G4HtmlPPReporter::sTD = "<TD>";
380 const char* G4HtmlPPReporter::eTD = "</TD>";   << 336 const char*  G4HtmlPPReporter::eTD = "</TD>";
381 const char* G4HtmlPPReporter::sB = "<B>";      << 337 const char*  G4HtmlPPReporter::sB = "<B>";
382 const char* G4HtmlPPReporter::eB = "</B>";     << 338 const char*  G4HtmlPPReporter::eB = "</B>";
383 const char* G4HtmlPPReporter::sLFONT = "<FONT  << 339 const char*  G4HtmlPPReporter::sLFONT = "<FONT SIZE = +1>";
384 const char* G4HtmlPPReporter::eLFONT = "</FONT << 340 const char*  G4HtmlPPReporter::eLFONT = "</FONT>";
385 const char* G4HtmlPPReporter::sSYMBOL = "<FONT << 341 const char*  G4HtmlPPReporter::sSYMBOL = "<FONT FACE = \"symbol\" >";
386 const char* G4HtmlPPReporter::eSYMBOL = "</FON << 342 const char*  G4HtmlPPReporter::eSYMBOL = "</FONT>";
387 const char* G4HtmlPPReporter::sSUP = "<SUP>";  << 343 const char*  G4HtmlPPReporter::sSUP = "<SUP>";
388 const char* G4HtmlPPReporter::eSUP = "</SUP>"; << 344 const char*  G4HtmlPPReporter::eSUP = "</SUP>";
389 const char* G4HtmlPPReporter::sSUB = "<SUB>";  << 345 const char*  G4HtmlPPReporter::sSUB = "<SUB>";
390 const char* G4HtmlPPReporter::eSUB = "</SUB>"; << 346 const char*  G4HtmlPPReporter::eSUB = "</SUB>";
                                                   >> 347  
                                                   >> 348  
391                                                   349