Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/cuts/src/G4ProductionCuts.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 /processes/cuts/src/G4ProductionCuts.cc (Version 11.3.0) and /processes/cuts/src/G4ProductionCuts.cc (Version 10.7.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 // G4ProductionCuts class implementation           26 // G4ProductionCuts class implementation
 27 //                                                 27 //
 28 // Author: H.Kurashige, 17 September 2002 - Fi     28 // Author: H.Kurashige, 17 September 2002 - First implementation
 29 // -------------------------------------------     29 // --------------------------------------------------------------------
 30                                                    30 
 31 #include "G4ProductionCuts.hh"                     31 #include "G4ProductionCuts.hh"
 32 #include "G4ProductionCutsTable.hh"                32 #include "G4ProductionCutsTable.hh"
 33                                                    33 
 34 #include <sstream>                             <<  34 #include <iomanip>
                                                   >>  35 
                                                   >>  36 G4ThreadLocal G4ParticleDefinition* G4ProductionCuts::gammaDef = nullptr;
                                                   >>  37 G4ThreadLocal G4ParticleDefinition* G4ProductionCuts::electDef = nullptr;
                                                   >>  38 G4ThreadLocal G4ParticleDefinition* G4ProductionCuts::positDef = nullptr;
                                                   >>  39 G4ThreadLocal G4ParticleDefinition* G4ProductionCuts::protonDef = nullptr;
 35                                                    40 
 36 G4ProductionCuts::G4ProductionCuts()               41 G4ProductionCuts::G4ProductionCuts()
 37 {                                                  42 {
 38   for (G4int i=0; i<NumberOfG4CutIndex; ++i)   <<  43   for (G4int i=0; i< NumberOfG4CutIndex; ++i)
 39   {                                                44   {
 40     fRangeCuts.push_back(0.0);                     45     fRangeCuts.push_back(0.0);
 41   }                                                46   }
 42 }                                                  47 }
 43                                                    48 
 44 G4ProductionCuts::G4ProductionCuts(const G4Pro     49 G4ProductionCuts::G4ProductionCuts(const G4ProductionCuts& right) 
 45 {                                                  50 {
 46   for (G4int i=0; i<NumberOfG4CutIndex; ++i)   <<  51   for (G4int i=0; i< NumberOfG4CutIndex; ++i)
 47   {                                                52   {
 48     fRangeCuts.push_back(0.0);                     53     fRangeCuts.push_back(0.0);
 49   }                                                54   }
 50   *this = right;                                   55   *this = right;
 51 }                                                  56 }
 52                                                    57 
 53 G4ProductionCuts::~G4ProductionCuts()              58 G4ProductionCuts::~G4ProductionCuts()
 54 {                                                  59 {
 55   fRangeCuts.clear();                              60   fRangeCuts.clear();
 56 }                                                  61 }
 57                                                    62 
 58 G4ProductionCuts& G4ProductionCuts::operator=(     63 G4ProductionCuts& G4ProductionCuts::operator=(const G4ProductionCuts& right)
 59 {                                                  64 {
 60   if (&right==this) return *this;                  65   if (&right==this) return *this;
 61                                                    66 
 62   for (G4int i=0; i<NumberOfG4CutIndex; ++i)   <<  67   for (G4int i=0; i< NumberOfG4CutIndex; ++i)
 63   {                                                68   {
 64     fRangeCuts[i] = right.fRangeCuts[i];           69     fRangeCuts[i] = right.fRangeCuts[i];
 65   }                                                70   }
 66   isModified = right.isModified;                   71   isModified = right.isModified;
 67   return *this;                                    72   return *this;
 68 }                                                  73 }
 69                                                    74 
 70 G4bool G4ProductionCuts::operator==(const G4Pr     75 G4bool G4ProductionCuts::operator==(const G4ProductionCuts& right) const
 71 {                                                  76 {
 72   return (this == &right);                         77   return (this == &right);
 73 }                                                  78 }
 74                                                    79 
                                                   >>  80 
 75 G4bool G4ProductionCuts::operator!=(const G4Pr     81 G4bool G4ProductionCuts::operator!=(const G4ProductionCuts& right) const
 76 {                                                  82 {
 77   return (this != &right);                         83   return (this != &right);
 78 }                                                  84 }
 79                                                    85 
 80 void G4ProductionCuts::SetProductionCut(G4doub << 
 81 {                                              << 
 82   if(index >= 0 && index < NumberOfG4CutIndex) << 
 83   {                                            << 
 84     fRangeCuts[index] = cut;                   << 
 85     isModified = true;                         << 
 86   }                                            << 
 87   else                                         << 
 88   {                                            << 
 89     std::ostringstream os;                     << 
 90     os << "Setting cuts for particles other th << 
 91           "no effect.";                        << 
 92     G4Exception("G4ProductionCuts::SetProducti << 
 93                 JustWarning, os.str().c_str()) << 
 94   }                                            << 
 95 }                                              << 
 96                                                << 
 97 void G4ProductionCuts::SetProductionCut(G4doub << 
 98 {                                              << 
 99   for(G4int i = 0; i < NumberOfG4CutIndex; ++i << 
100   {                                            << 
101     fRangeCuts[i] = cut;                       << 
102   }                                            << 
103   isModified = true;                           << 
104 }                                              << 
105                                                << 
106 void G4ProductionCuts::SetProductionCut(G4doub << 
107 {                                              << 
108   SetProductionCut(cut, GetIndex(ptr));        << 
109 }                                              << 
110                                                << 
111 void G4ProductionCuts::SetProductionCut(G4doub << 
112 {                                              << 
113   SetProductionCut(cut, GetIndex(pName));      << 
114 }                                              << 
115                                                << 
116 G4double G4ProductionCuts::GetProductionCut(G4 << 
117 {                                              << 
118   G4double cut = -1.0;                         << 
119   if (index>=0 && index<NumberOfG4CutIndex)    << 
120   {                                            << 
121     cut = fRangeCuts[index];                   << 
122   }                                            << 
123   return cut;                                  << 
124 }                                              << 
125                                                << 
126 G4double G4ProductionCuts::GetProductionCut(co << 
127 {                                              << 
128   return GetProductionCut(GetIndex(name));     << 
129 }                                              << 
130                                                << 
131                                                << 
132 const std::vector<G4double>&   G4ProductionCut << 
133 {                                              << 
134   return fRangeCuts;                           << 
135 }                                              << 
136                                                << 
137 G4bool G4ProductionCuts::IsModified() const    << 
138 {                                              << 
139   return isModified;                           << 
140 }                                              << 
141                                                << 
142 void G4ProductionCuts::PhysicsTableUpdated()   << 
143 {                                              << 
144   isModified = false;                          << 
145 }                                              << 
146                                                << 
147 G4int G4ProductionCuts::GetIndex(const G4Strin     86 G4int G4ProductionCuts::GetIndex(const G4String& name)
148 {                                                  87 {
149   G4int index = -1;                            <<  88   static const G4String gamma ("gamma");
150   if ( name == "gamma" ) { index = 0; }        <<  89   static const G4String electron("e-");
151   else if ( name == "e-" ) { index = 1; }      <<  90   static const G4String positron("e+");
152   else if ( name == "e+" ) { index = 2; }      <<  91   static const G4String proton("proton");
153   else if ( name == "proton" ) { index = 3; }  <<  92   
                                                   >>  93   G4int index;
                                                   >>  94   if       ( name == gamma )        { index =  0; }
                                                   >>  95   else  if ( name == electron )     { index =  1; }
                                                   >>  96   else  if ( name == positron )     { index =  2; }
                                                   >>  97   else  if ( name == proton )       { index =  3; }
                                                   >>  98   else                              { index = -1; }
154                                                    99 
155   return index;                                   100   return index;
156 }                                                 101 }
157                                                   102 
158                                                   103 
159 G4int G4ProductionCuts::GetIndex(const G4Parti << 104 G4int G4ProductionCuts::GetIndex(const G4ParticleDefinition* ptcl)
160 {                                              << 105 { 
161   G4int pdg = (nullptr == ptr) ? 0 : ptr->GetP << 106   if(!ptcl) return -1;
162   G4int index = -1;                            << 107 
163   if (pdg == 22) { index = 0; }                << 108   // In the first call, pointers are set 
164   else if (pdg == 11) { index = 1; }           << 109   if(gammaDef==nullptr  && ptcl->GetParticleName()=="gamma")
165   else if (pdg == -11) { index = 2; }          << 110     { gammaDef = (G4ParticleDefinition*) ptcl; }
166   else if (pdg == 2212) { index = 3; }         << 111   if(electDef==nullptr  && ptcl->GetParticleName()=="e-")
                                                   >> 112     { electDef = (G4ParticleDefinition*) ptcl; }
                                                   >> 113   if(positDef==nullptr  && ptcl->GetParticleName()=="e+")
                                                   >> 114     { positDef = (G4ParticleDefinition*) ptcl; }
                                                   >> 115   if(protonDef==nullptr && ptcl->GetParticleName()=="proton")
                                                   >> 116     { protonDef = (G4ParticleDefinition*) ptcl; }
                                                   >> 117 
                                                   >> 118   G4int index;
                                                   >> 119   if(ptcl==(const G4ParticleDefinition*) gammaDef)       { index = 0;  }
                                                   >> 120   else if(ptcl==(const G4ParticleDefinition*) electDef)  { index = 1;  }
                                                   >> 121   else if(ptcl==(const G4ParticleDefinition*) positDef)  { index = 2;  }
                                                   >> 122   else if(ptcl==(const G4ParticleDefinition*) protonDef) { index = 3;  }
                                                   >> 123   else { index = -1; }
167                                                   124 
168   return index;                                   125   return index;
169 }                                                 126 }
170                                                   127 
171 void G4ProductionCuts::SetProductionCuts(std::    128 void G4ProductionCuts::SetProductionCuts(std::vector<G4double>& cut)
172 {                                                 129 {  
173   G4int vSize = (G4int)cut.size();             << 130   G4int vSize = cut.size();
174   if (vSize != NumberOfG4CutIndex)                131   if (vSize != NumberOfG4CutIndex)
175   {                                               132   {
176 #ifdef G4VERBOSE                                  133 #ifdef G4VERBOSE
177     if (G4ProductionCutsTable::GetProductionCu << 134     if ( G4ProductionCutsTable::GetProductionCutsTable()->GetVerboseLevel()>1)
178     {                                             135     {
179       G4cout << "G4ProductionCuts::SetProducti << 136       G4cerr << "G4ProductionCuts::SetProductionCuts ";
180       G4cout << " The size of given cut value  << 137       G4cerr << " The size of given cut value vector [=" << vSize << "]  "
181              << " is not consistent with numbe    138              << " is not consistent with number of CutIndex [="  
182              << NumberOfG4CutIndex << G4endl;     139              << NumberOfG4CutIndex << G4endl;
183     }                                             140     }
184 #endif                                            141 #endif
185     G4Exception( "G4ProductionCuts::SetProduct    142     G4Exception( "G4ProductionCuts::SetProductionCuts ",
186                  "ProcCuts108",                   143                  "ProcCuts108",
187                  JustWarning, "Given vector si    144                  JustWarning, "Given vector size is inconsistent ");
188     if (NumberOfG4CutIndex<vSize)  { vSize = N    145     if (NumberOfG4CutIndex<vSize)  { vSize = NumberOfG4CutIndex; }
189   }                                               146   }
190   for(G4int i = 0; i<vSize; ++i)               << 147   for(G4int i = 0; (i<vSize ); ++i)
191   {                                               148   {
192     fRangeCuts[i] = cut[i];                       149     fRangeCuts[i] = cut[i];
193   }                                               150   }
194   isModified = true;                              151   isModified = true;
195 }                                                 152 }
196                                                   153