Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/hadronic/models/de_excitation/multifragmentation/src/G4StatMFMicroCanonical.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/hadronic/models/de_excitation/multifragmentation/src/G4StatMFMicroCanonical.cc (Version 11.3.0) and /processes/hadronic/models/de_excitation/multifragmentation/src/G4StatMFMicroCanonical.cc (Version 11.0)


  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 //                                                 26 //
 27 //                                                 27 //
 28 // Hadronic Process: Nuclear De-excitations        28 // Hadronic Process: Nuclear De-excitations
 29 // by V. Lara                                      29 // by V. Lara
 30                                                    30 
 31 #include <numeric>                                 31 #include <numeric>
 32                                                    32 
 33 #include "G4StatMFMicroCanonical.hh"               33 #include "G4StatMFMicroCanonical.hh"
 34 #include "G4PhysicalConstants.hh"                  34 #include "G4PhysicalConstants.hh"
 35 #include "G4SystemOfUnits.hh"                      35 #include "G4SystemOfUnits.hh"
 36 #include "G4HadronicException.hh"                  36 #include "G4HadronicException.hh"
 37 #include "G4Pow.hh"                                37 #include "G4Pow.hh"
 38                                                    38 
 39 // constructor                                     39 // constructor
 40 G4StatMFMicroCanonical::G4StatMFMicroCanonical     40 G4StatMFMicroCanonical::G4StatMFMicroCanonical(G4Fragment const & theFragment) 
 41 {                                                  41 {
 42   // Perform class initialization                  42   // Perform class initialization
 43   Initialize(theFragment);                         43   Initialize(theFragment);
 44 }                                                  44 }
 45                                                    45 
 46 // destructor                                      46 // destructor
 47 G4StatMFMicroCanonical::~G4StatMFMicroCanonica     47 G4StatMFMicroCanonical::~G4StatMFMicroCanonical() 
 48 {                                                  48 {
 49   // garbage collection                            49   // garbage collection
 50   if (!_ThePartitionManagerVector.empty()) {       50   if (!_ThePartitionManagerVector.empty()) {
 51     std::for_each(_ThePartitionManagerVector.b     51     std::for_each(_ThePartitionManagerVector.begin(),
 52         _ThePartitionManagerVector.end(),          52         _ThePartitionManagerVector.end(),
 53         DeleteFragment());                         53         DeleteFragment());
 54   }                                                54   }
 55 }                                                  55 }
 56                                                    56 
 57 void G4StatMFMicroCanonical::Initialize(const      57 void G4StatMFMicroCanonical::Initialize(const G4Fragment & theFragment) 
 58 {                                                  58 {
 59                                                    59   
 60   std::vector<G4StatMFMicroManager*>::iterator     60   std::vector<G4StatMFMicroManager*>::iterator it;
 61                                                    61 
 62   // Excitation Energy                             62   // Excitation Energy 
 63   G4double U = theFragment.GetExcitationEnergy     63   G4double U = theFragment.GetExcitationEnergy();
 64                                                    64 
 65   G4int A = theFragment.GetA_asInt();              65   G4int A = theFragment.GetA_asInt();
 66   G4int Z = theFragment.GetZ_asInt();              66   G4int Z = theFragment.GetZ_asInt();
 67   G4double x = 1.0 - 2.0*Z/G4double(A);            67   G4double x = 1.0 - 2.0*Z/G4double(A);
 68   G4Pow* g4calc = G4Pow::GetInstance();            68   G4Pow* g4calc = G4Pow::GetInstance();
 69                                                    69     
 70   // Configuration temperature                     70   // Configuration temperature
 71   G4double TConfiguration = std::sqrt(8.0*U/G4     71   G4double TConfiguration = std::sqrt(8.0*U/G4double(A));
 72                                                    72   
 73   // Free internal energy at Temperature T = 0     73   // Free internal energy at Temperature T = 0
 74   __FreeInternalE0 = A*(                           74   __FreeInternalE0 = A*( 
 75       // Volume term (for T = 0)                   75       // Volume term (for T = 0)
 76       -G4StatMFParameters::GetE0() +               76       -G4StatMFParameters::GetE0() +  
 77       // Symmetry term                             77       // Symmetry term
 78       G4StatMFParameters::GetGamma0()*x*x          78       G4StatMFParameters::GetGamma0()*x*x 
 79       ) +                                          79       ) + 
 80     // Surface term (for T = 0)                    80     // Surface term (for T = 0)
 81     G4StatMFParameters::GetBeta0()*g4calc->Z23     81     G4StatMFParameters::GetBeta0()*g4calc->Z23(A) + 
 82     // Coulomb term                                82     // Coulomb term 
 83     elm_coupling*0.6*Z*Z/(G4StatMFParameters::     83     elm_coupling*0.6*Z*Z/(G4StatMFParameters::Getr0()*g4calc->Z13(A));
 84                                                    84   
 85   // Statistical weight                            85   // Statistical weight
 86   G4double W = 0.0;                                86   G4double W = 0.0;
 87                                                    87   
 88   // Mean breakup multiplicity                     88   // Mean breakup multiplicity
 89   __MeanMultiplicity = 0.0;                        89   __MeanMultiplicity = 0.0;
 90                                                    90   
 91   // Mean channel temperature                      91   // Mean channel temperature
 92   __MeanTemperature = 0.0;                         92   __MeanTemperature = 0.0;
 93                                                    93   
 94   // Mean channel entropy                          94   // Mean channel entropy
 95   __MeanEntropy = 0.0;                             95   __MeanEntropy = 0.0;
 96                                                    96   
 97   // Calculate entropy of compound nucleus         97   // Calculate entropy of compound nucleus
 98   G4double SCompoundNucleus = CalcEntropyOfCom     98   G4double SCompoundNucleus = CalcEntropyOfCompoundNucleus(theFragment,TConfiguration);
 99                                                    99   
100   // Statistical weight of compound nucleus       100   // Statistical weight of compound nucleus
101   _WCompoundNucleus = 1.0;                        101   _WCompoundNucleus = 1.0; 
102                                                   102   
103   W += _WCompoundNucleus;                         103   W += _WCompoundNucleus;
104                                                   104     
105   // Maximal fragment multiplicity allowed in     105   // Maximal fragment multiplicity allowed in direct simulation
106   G4int MaxMult = G4StatMFMicroCanonical::MaxA    106   G4int MaxMult = G4StatMFMicroCanonical::MaxAllowedMultiplicity;
107   if (A > 110) MaxMult -= 1;                      107   if (A > 110) MaxMult -= 1;
108                                                   108   
109   for (G4int im = 2; im <= MaxMult; im++) {       109   for (G4int im = 2; im <= MaxMult; im++) {
110     G4StatMFMicroManager * aMicroManager =        110     G4StatMFMicroManager * aMicroManager = 
111       new G4StatMFMicroManager(theFragment,im,    111       new G4StatMFMicroManager(theFragment,im,__FreeInternalE0,SCompoundNucleus);
112     _ThePartitionManagerVector.push_back(aMicr    112     _ThePartitionManagerVector.push_back(aMicroManager);
113   }                                               113   }
114                                                   114   
115   // W is the total probability                   115   // W is the total probability
116   W = std::accumulate(_ThePartitionManagerVect    116   W = std::accumulate(_ThePartitionManagerVector.begin(),
117           _ThePartitionManagerVector.end(),       117           _ThePartitionManagerVector.end(),
118           W, [](const G4double& running_total,    118           W, [](const G4double& running_total,
119                             G4StatMFMicroManag    119                             G4StatMFMicroManager*& manager)
120                          {                        120                          {
121                return running_total + manager-    121                return running_total + manager->GetProbability();
122              } );                                 122              } );
123                                                   123   
124   // Normalization of statistical weights         124   // Normalization of statistical weights
125   for (it =  _ThePartitionManagerVector.begin(    125   for (it =  _ThePartitionManagerVector.begin(); it !=  _ThePartitionManagerVector.end(); ++it) 
126     {                                             126     {
127       (*it)->Normalize(W);                        127       (*it)->Normalize(W);
128     }                                             128     }
129                                                   129 
130   _WCompoundNucleus /= W;                         130   _WCompoundNucleus /= W;
131                                                   131   
132   __MeanMultiplicity += 1.0 * _WCompoundNucleu    132   __MeanMultiplicity += 1.0 * _WCompoundNucleus;
133   __MeanTemperature += TConfiguration * _WComp    133   __MeanTemperature += TConfiguration * _WCompoundNucleus;
134   __MeanEntropy += SCompoundNucleus * _WCompou    134   __MeanEntropy += SCompoundNucleus * _WCompoundNucleus;
135                                                   135   
136   for (it =  _ThePartitionManagerVector.begin(    136   for (it =  _ThePartitionManagerVector.begin(); it !=  _ThePartitionManagerVector.end(); ++it) 
137     {                                             137     {
138       __MeanMultiplicity += (*it)->GetMeanMult    138       __MeanMultiplicity += (*it)->GetMeanMultiplicity();
139       __MeanTemperature += (*it)->GetMeanTempe    139       __MeanTemperature += (*it)->GetMeanTemperature();
140       __MeanEntropy += (*it)->GetMeanEntropy()    140       __MeanEntropy += (*it)->GetMeanEntropy();
141     }                                             141     }
142                                                   142   
143   return;                                         143   return;
144 }                                                 144 }
145                                                   145 
146 G4double G4StatMFMicroCanonical::CalcFreeInter    146 G4double G4StatMFMicroCanonical::CalcFreeInternalEnergy(const G4Fragment & theFragment, 
147               G4double T)                         147               G4double T)
148 {                                                 148 {
149   G4int A = theFragment.GetA_asInt();             149   G4int A = theFragment.GetA_asInt();
150   G4int Z = theFragment.GetZ_asInt();             150   G4int Z = theFragment.GetZ_asInt();
151   G4double A13 = G4Pow::GetInstance()->Z13(A);    151   G4double A13 = G4Pow::GetInstance()->Z13(A);
152                                                   152   
153   G4double InvLevelDensityPar = G4StatMFParame    153   G4double InvLevelDensityPar = G4StatMFParameters::GetEpsilon0()
154     *(1.0 + 3.0/G4double(A-1));                   154     *(1.0 + 3.0/G4double(A-1));
155                                                   155   
156   G4double VolumeTerm = (-G4StatMFParameters::    156   G4double VolumeTerm = (-G4StatMFParameters::GetE0()+T*T/InvLevelDensityPar)*A;
157                                                   157   
158   G4double SymmetryTerm = G4StatMFParameters::    158   G4double SymmetryTerm = G4StatMFParameters::GetGamma0()
159     *(A - 2*Z)*(A - 2*Z)/G4double(A);             159     *(A - 2*Z)*(A - 2*Z)/G4double(A);
160                                                   160   
161   G4double SurfaceTerm = (G4StatMFParameters::    161   G4double SurfaceTerm = (G4StatMFParameters::Beta(T)
162         - T*G4StatMFParameters::DBetaDT(T))*A1    162         - T*G4StatMFParameters::DBetaDT(T))*A13*A13;
163                                                   163   
164   G4double CoulombTerm = elm_coupling*0.6*Z*Z/    164   G4double CoulombTerm = elm_coupling*0.6*Z*Z/(G4StatMFParameters::Getr0()*A13);
165                                                   165   
166   return VolumeTerm + SymmetryTerm + SurfaceTe    166   return VolumeTerm + SymmetryTerm + SurfaceTerm + CoulombTerm;
167 }                                                 167 }
168                                                   168 
169 G4double                                          169 G4double 
170 G4StatMFMicroCanonical::CalcEntropyOfCompoundN    170 G4StatMFMicroCanonical::CalcEntropyOfCompoundNucleus(const G4Fragment & theFragment,
171                  G4double & TConf)                171                  G4double & TConf)
172   // Calculates Temperature and Entropy of com    172   // Calculates Temperature and Entropy of compound nucleus
173 {                                                 173 {
174   G4int A = theFragment.GetA_asInt();             174   G4int A = theFragment.GetA_asInt();
175   G4double U = theFragment.GetExcitationEnergy    175   G4double U = theFragment.GetExcitationEnergy();
176   G4double A13 = G4Pow::GetInstance()->Z13(A);    176   G4double A13 = G4Pow::GetInstance()->Z13(A);
177                                                   177   
178   G4double Ta = std::max(std::sqrt(U/(0.125*A)    178   G4double Ta = std::max(std::sqrt(U/(0.125*A)),0.0012*MeV); 
179   G4double Tb = Ta;                               179   G4double Tb = Ta;
180                                                   180   
181   G4double ECompoundNucleus = CalcFreeInternal    181   G4double ECompoundNucleus = CalcFreeInternalEnergy(theFragment,Ta);
182   G4double Da = (U+__FreeInternalE0-ECompoundN    182   G4double Da = (U+__FreeInternalE0-ECompoundNucleus)/U;
183   G4double Db = 0.0;                              183   G4double Db = 0.0;
184                                                   184     
185   G4double InvLevelDensity = CalcInvLevelDensi    185   G4double InvLevelDensity = CalcInvLevelDensity(A);
186                                                   186   
187   // bracketing the solution                      187   // bracketing the solution
188   if (Da == 0.0) {                                188   if (Da == 0.0) {
189     TConf = Ta;                                   189     TConf = Ta;
190     return 2*Ta*A/InvLevelDensity - G4StatMFPa    190     return 2*Ta*A/InvLevelDensity - G4StatMFParameters::DBetaDT(Ta)*A13*A13;
191   } else if (Da < 0.0) {                          191   } else if (Da < 0.0) {
192     do {                                          192     do {
193       Tb -= 0.5*Tb;                               193       Tb -= 0.5*Tb;
194       ECompoundNucleus = CalcFreeInternalEnerg    194       ECompoundNucleus = CalcFreeInternalEnergy(theFragment,Tb);
195       Db = (U+__FreeInternalE0-ECompoundNucleu    195       Db = (U+__FreeInternalE0-ECompoundNucleus)/U;
196     } while (Db < 0.0);                           196     } while (Db < 0.0);
197   } else {                                        197   } else {
198     do {                                          198     do {
199       Tb += 0.5*Tb;                               199       Tb += 0.5*Tb;
200       ECompoundNucleus = CalcFreeInternalEnerg    200       ECompoundNucleus = CalcFreeInternalEnergy(theFragment,Tb);
201       Db = (U+__FreeInternalE0-ECompoundNucleu    201       Db = (U+__FreeInternalE0-ECompoundNucleus)/U;
202     } while (Db > 0.0);                           202     } while (Db > 0.0);
203   }                                               203   }
204                                                   204   
205   G4double eps = 1.0e-14 * std::abs(Tb-Ta);       205   G4double eps = 1.0e-14 * std::abs(Tb-Ta);
206                                                   206   
207   for (G4int i = 0; i < 1000; i++) {              207   for (G4int i = 0; i < 1000; i++) {
208     G4double Tc = (Ta+Tb)*0.5;                    208     G4double Tc = (Ta+Tb)*0.5;
209     if (std::abs(Ta-Tb) <= eps) {                 209     if (std::abs(Ta-Tb) <= eps) {
210       TConf = Tc;                                 210       TConf = Tc;
211       return 2*Tc*A/InvLevelDensity - G4StatMF    211       return 2*Tc*A/InvLevelDensity - G4StatMFParameters::DBetaDT(Tc)*A13*A13;
212     }                                             212     }
213     ECompoundNucleus = CalcFreeInternalEnergy(    213     ECompoundNucleus = CalcFreeInternalEnergy(theFragment,Tc);
214     G4double Dc = (U+__FreeInternalE0-ECompoun    214     G4double Dc = (U+__FreeInternalE0-ECompoundNucleus)/U;
215                                                   215     
216     if (Dc == 0.0) {                              216     if (Dc == 0.0) {
217       TConf = Tc;                                 217       TConf = Tc;
218       return 2*Tc*A/InvLevelDensity - G4StatMF    218       return 2*Tc*A/InvLevelDensity - G4StatMFParameters::DBetaDT(Tc)*A13*A13;
219     }                                             219     }
220                                                   220     
221     if (Da*Dc < 0.0) {                            221     if (Da*Dc < 0.0) {
222       Tb = Tc;                                    222       Tb = Tc;
223       Db = Dc;                                    223       Db = Dc;
224     } else {                                      224     } else {
225       Ta = Tc;                                    225       Ta = Tc;
226       Da = Dc;                                    226       Da = Dc;
227     }                                             227     } 
228   }                                               228   }
229                                                   229   
230   G4cout <<                                       230   G4cout << 
231     "G4StatMFMicrocanoncal::CalcEntropyOfCompo    231     "G4StatMFMicrocanoncal::CalcEntropyOfCompoundNucleus: I can't calculate the temperature" 
232    << G4endl;                                     232    << G4endl;
233                                                   233   
234   return 0.0;                                     234   return 0.0;
235 }                                                 235 }
236                                                   236 
237 G4StatMFChannel *  G4StatMFMicroCanonical::Cho    237 G4StatMFChannel *  G4StatMFMicroCanonical::ChooseAandZ(const G4Fragment & theFragment)
238   // Choice of fragment atomic numbers and cha    238   // Choice of fragment atomic numbers and charges 
239 {                                                 239 {
240   // We choose a multiplicity (1,2,3,...) and     240   // We choose a multiplicity (1,2,3,...) and then a channel
241   G4double RandNumber = G4UniformRand();          241   G4double RandNumber = G4UniformRand();
242                                                   242 
243   if (RandNumber < _WCompoundNucleus) {           243   if (RandNumber < _WCompoundNucleus) { 
244                                                   244   
245     G4StatMFChannel * aChannel = new G4StatMFC    245     G4StatMFChannel * aChannel = new G4StatMFChannel;
246     aChannel->CreateFragment(theFragment.GetA_    246     aChannel->CreateFragment(theFragment.GetA_asInt(),theFragment.GetZ_asInt());
247     return aChannel;                              247     return aChannel;
248                                                   248   
249   } else {                                        249   } else {
250                                                   250   
251     G4double AccumWeight = _WCompoundNucleus;     251     G4double AccumWeight = _WCompoundNucleus;
252     std::vector<G4StatMFMicroManager*>::iterat    252     std::vector<G4StatMFMicroManager*>::iterator it;
253     for (it = _ThePartitionManagerVector.begin    253     for (it = _ThePartitionManagerVector.begin(); it != _ThePartitionManagerVector.end(); ++it) {
254       AccumWeight += (*it)->GetProbability();     254       AccumWeight += (*it)->GetProbability();
255       if (RandNumber < AccumWeight) {             255       if (RandNumber < AccumWeight) {
256   return (*it)->ChooseChannel(theFragment.GetA    256   return (*it)->ChooseChannel(theFragment.GetA_asInt(),theFragment.GetZ_asInt(),__MeanTemperature);
257       }                                           257       }
258     }                                             258     }
259     throw G4HadronicException(__FILE__, __LINE    259     throw G4HadronicException(__FILE__, __LINE__, "G4StatMFMicroCanonical::ChooseAandZ: wrong normalization!");
260   }                                               260   }
261                                                   261 
262   return 0;                                       262   return 0; 
263 }                                                 263 }
264                                                   264 
265 G4double G4StatMFMicroCanonical::CalcInvLevelD    265 G4double G4StatMFMicroCanonical::CalcInvLevelDensity(G4int anA)
266 {                                                 266 {
267   G4double res = 0.0;                             267   G4double res = 0.0;
268   if (anA > 1) {                                  268   if (anA > 1) {
269     res = G4StatMFParameters::GetEpsilon0()*(1    269     res = G4StatMFParameters::GetEpsilon0()*(1.0+3.0/(anA - 1.0));
270   }                                               270   }
271   return res;                                     271   return res;
272 }                                                 272 }
273                                                   273