00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011 #include "cddefines.h"
00012 #include "physconst.h"
00013 #include "iso.h"
00014 #include "thermal.h"
00015 #include "secondaries.h"
00016 #include "opacity.h"
00017 #include "rfield.h"
00018 #include "ionbal.h"
00019 #include "atmdat.h"
00020 #include "heavy.h"
00021 #include "gammas.h"
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032 double GammaBn(
00033
00034 long int ipLoEnr,
00035
00036 long int ipHiEnr,
00037
00038 long int ipOpac,
00039
00040 double thresh,
00041
00042 double *ainduc,
00043
00044 double *rcool)
00045 {
00046 long int i,
00047 ilo,
00048 iup,
00049 limit;
00050 double GamHi,
00051 bnfun_v,
00052 emin,
00053 g,
00054 phisig,
00055 RateInducRec,
00056 RateInducRecCool,
00057 prod;
00058
00059 DEBUG_ENTRY( "GammaBn()" );
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070 if( ipLoEnr >= rfield.nflux || ipLoEnr >= ipHiEnr )
00071 {
00072 bnfun_v = 0.;
00073 thermal.HeatNet = 0.;
00074 thermal.HeatLowEnr = 0.;
00075 thermal.HeatHiEnr = 0.;
00076 *ainduc = 0.;
00077 *rcool = 0.;
00078
00079 DEBUG_EXIT( "GammaBn()" );
00080 return( bnfun_v );
00081 }
00082
00083 ASSERT( ipLoEnr >= 0 && ipHiEnr >= 0 );
00084
00085
00086
00087
00088 emin = MAX2(thresh,rfield.anu[ipLoEnr-1]);
00089
00090
00091 emin = thresh;
00092
00093 thermal.HeatNet = 0.;
00094 g = 0.;
00095 RateInducRec = 0.;
00096 RateInducRecCool = 0.;
00097
00098
00099
00100 i = ipLoEnr;
00101
00102
00103 phisig = (rfield.flux[i-1] + rfield.otslin[i-1] +
00104 rfield.ConInterOut[i-1]*rfield.lgOutOnly)*
00105 opac.OpacStack[i-ipLoEnr+ipOpac-1];
00106
00107 g += phisig;
00108 thermal.HeatNet += phisig*rfield.anu[i-1];
00109
00110
00111 prod = phisig*rfield.ContBoltz[i-1];
00112 RateInducRec += prod;
00113
00114 RateInducRecCool += prod*(rfield.anu[i-1] - emin);
00115
00116 iup = MIN2(ipHiEnr,rfield.nflux);
00117 limit = MIN2(iup,secondaries.ipSecIon-1);
00118
00119
00120 for( i=ipLoEnr; i < limit; i++ )
00121 {
00122
00123
00124 phisig = rfield.SummedCon[i]*opac.OpacStack[i-ipLoEnr+ipOpac];
00125
00126 g += phisig;
00127 thermal.HeatNet += phisig*rfield.anu[i];
00128
00129
00130 prod = phisig*rfield.ContBoltz[i];
00131
00132 RateInducRec += prod;
00133
00134 RateInducRecCool += prod*(rfield.anu[i] - emin);
00135 }
00136
00137
00138
00139
00140 thermal.HeatNet = MAX2(0.,thermal.HeatNet - g*thresh);
00141
00142
00143 thermal.HeatLowEnr = thermal.HeatNet;
00144
00145
00146 thermal.HeatHiEnr = 0.;
00147 GamHi = 0.;
00148
00149
00150 ilo = MAX2(ipLoEnr+1,secondaries.ipSecIon);
00151 for( i=ilo-1; i < iup; i++ )
00152 {
00153 phisig = rfield.SummedCon[i]*opac.OpacStack[i-ipLoEnr+ipOpac];
00154
00155 GamHi += phisig;
00156 thermal.HeatHiEnr += phisig*rfield.anu[i];
00157
00158
00159 prod = phisig*rfield.ContBoltz[i];
00160 RateInducRec += prod;
00161
00162 RateInducRecCool += prod*(rfield.anu[i] - emin);
00163 }
00164
00165
00166 bnfun_v = g + GamHi;
00167
00168
00169 thermal.HeatHiEnr = thermal.HeatHiEnr - GamHi*thresh;
00170
00171
00172 thermal.HeatNet += thermal.HeatHiEnr*secondaries.heatef;
00173
00174
00175 thermal.HeatNet *= EN1RYD;
00176 thermal.HeatHiEnr *= EN1RYD;
00177 thermal.HeatLowEnr *= EN1RYD;
00178
00179
00180 if( rfield.lgInducProcess )
00181 {
00182 *rcool = RateInducRecCool*EN1RYD;
00183 *ainduc = RateInducRec;
00184 }
00185 else
00186 {
00187
00188 *rcool = 0.;
00189 *ainduc = 0.;
00190 }
00191
00192 ASSERT( bnfun_v >= 0. );
00193 ASSERT( thermal.HeatNet>= 0. );
00194
00195 DEBUG_EXIT( "GammaBn()" );
00196 return( bnfun_v );
00197 }
00198
00199
00200
00201 void GammaPrtShells( long nelem , long ion )
00202 {
00203 double sum;
00204 long int ns;
00205
00206 DEBUG_ENTRY( "GammaPrtShells()" );
00207
00208 fprintf(ioQQQ," GammaPrtShells nz\t%.2f \t%.2li %.2li ",
00209 fnzone ,
00210 nelem,
00211 ion
00212 );
00213 sum = 0;
00214 for( ns=0; ns < Heavy.nsShells[nelem][ion]; ++ns )
00215 {
00216 sum += ionbal.PhotoRate_Shell[nelem][ion][ns][0];
00217 }
00218 fprintf(ioQQQ,"\ttot\t%.2e", sum);
00219
00220 for( ns=0; ns < Heavy.nsShells[nelem][ion]; ++ns )
00221 {
00222 fprintf(ioQQQ,"\t%.2e", ionbal.PhotoRate_Shell[nelem][ion][ns][0] );
00223 # if 0
00224
00225 if( (ns==(Heavy.nsShells[nelem][ion]-1) || opac.lgRedoStatic) )
00226 {
00227
00228 iplow = opac.ipElement[nelem][ion][ns][0];
00229 iphi = opac.ipElement[nelem][ion][ns][1];
00230 ipop = opac.ipElement[nelem][ion][ns][2];
00231
00232
00233
00234 ionbal.PhotoRate_Shell[nelem][ion][ns][0] =
00235 GammaK(iplow,iphi,
00236 ipop,t_yield::Inst().elec_eject_frac(nelem,ion,ns,0))*ionbal.lgPhotoIoniz_On;
00237 }
00238 # endif
00239 }
00240 fprintf(ioQQQ,"\n");
00241
00242 DEBUG_EXIT( "GammaPrtShells()" );
00243 return;
00244 }
00245
00246
00247
00248
00249
00250
00251
00252
00253
00254 void GammaPrt(
00255
00256 long int ipLoEnr,
00257 long int ipHiEnr,
00258 long int ipOpac,
00259
00260 FILE * ioFILE,
00261
00262 double total,
00263
00264 double threshold)
00265 {
00266 long int i,
00267 j,
00268 k;
00269 double flxcor,
00270 phisig;
00271
00272 DEBUG_ENTRY( "GammaPrt()" );
00273
00274
00275
00276
00277
00278 if( ipLoEnr >= rfield.nflux || ipLoEnr >= ipHiEnr )
00279 {
00280 DEBUG_EXIT( "GammaPrt()" );
00281 return;
00282 }
00283
00284 fprintf( ioFILE, " GammaPrt %.2f from ",fnzone);
00285 fprintf( ioFILE,PrintEfmt("%9.2e",rfield.anu[ipLoEnr-1]));
00286 fprintf( ioFILE, " to ");
00287 fprintf( ioFILE,PrintEfmt("%9.2e",rfield.anu[ipHiEnr-1]));
00288 fprintf( ioFILE, "R rates >");
00289 fprintf( ioFILE,PrintEfmt("%9.2e",threshold));
00290 fprintf( ioFILE, " of total=");
00291 fprintf( ioFILE,PrintEfmt("%9.2e",total));
00292 fprintf( ioFILE, " (frac inc, otslin, otscon, ConInterOut, outlin ConOTS_local_OTS_rate ) chL, C\n");
00293
00294 if( threshold <= 0. || total <= 0. )
00295 {
00296 DEBUG_EXIT( "GammaPrt()" );
00297 return;
00298 }
00299
00300 k = ipLoEnr;
00301 j = MIN2(ipHiEnr,rfield.nflux);
00302
00303
00304 i = k-1;
00305
00306
00307 phisig = (rfield.flux[i] + rfield.otslin[i]+ rfield.ConInterOut[i]*rfield.lgOutOnly)*
00308 opac.OpacStack[i-k+ipOpac];
00309 if( phisig > threshold || phisig < 0.)
00310 {
00311 flxcor = rfield.flux[i] + rfield.otslin[i] + rfield.ConInterOut[i]*rfield.lgOutOnly;
00312
00313
00314 fprintf( ioFILE, "[%5ld]" , i );
00315 fprintf( ioFILE, PrintEfmt("%9.2e",rfield.anu[i]));
00316 fprintf( ioFILE, PrintEfmt("%9.2e",phisig/total));
00317 fprintf( ioFILE, "%5.2f%5.2f%5.2f%5.2f%5.2f%5.2f %4.4s %4.4s %.2e \n",
00318 rfield.flux[i]/SDIV(flxcor),
00319 rfield.otslin[i]/SDIV(flxcor),
00320
00321 0./SDIV(flxcor),
00322 rfield.ConInterOut[i]*rfield.lgOutOnly/SDIV(flxcor),
00323 (rfield.outlin[i]+rfield.outlin_noplot[i])/SDIV(flxcor),
00324 rfield.ConOTS_local_OTS_rate[i]/SDIV(flxcor),
00325 rfield.chLineLabel[i],
00326 rfield.chContLabel[i],
00327 opac.OpacStack[i-k+ipOpac]);
00328 }
00329
00330 for( i=k; i < j; i++ )
00331 {
00332 phisig = rfield.SummedCon[i]*opac.OpacStack[i-k+ipOpac];
00333 if( phisig > threshold || phisig < 0.)
00334 {
00335
00336 flxcor = rfield.flux[i] + rfield.otslin[i] + rfield.otscon[i] +
00337 rfield.outlin[i] + rfield.outlin_noplot[i] +rfield.ConInterOut[i]*rfield.lgOutOnly;
00338
00339 fprintf( ioFILE, "%5ld", i );
00340 fprintf(ioFILE,PrintEfmt("%9.2e",rfield.anu[i]));
00341 fprintf(ioFILE,PrintEfmt("%9.2e",phisig/total));
00342 fprintf( ioFILE, "%5.2f%5.2f%5.2f%5.2f%5.2f%5.2f %4.4s %4.4s %.2e \n",
00343 rfield.flux[i]/SDIV(flxcor),
00344 rfield.otslin[i]/SDIV(flxcor),
00345 rfield.otscon[i]/SDIV(flxcor),
00346 rfield.ConInterOut[i]*rfield.lgOutOnly/SDIV(flxcor),
00347 (rfield.outlin[i] + rfield.outlin_noplot[i])/SDIV(flxcor),
00348 rfield.ConOTS_local_OTS_rate[i]/SDIV(flxcor),
00349 rfield.chLineLabel[i],
00350 rfield.chContLabel[i],
00351 opac.OpacStack[i-k+ipOpac]);
00352 }
00353 }
00354
00355 DEBUG_EXIT( "GammaPrt()" );
00356 return;
00357 }
00358
00359
00360
00361
00362
00363
00364 double GammaK(
00365
00366
00367 long int ipLoEnr,
00368 long int ipHiEnr,
00369
00370 long int ipOpac,
00371
00372
00373 double yield1)
00374 {
00375 long int i,
00376 ilo,
00377 ipOffset,
00378 iup,
00379 limit;
00380 double GamHi,
00381 eauger;
00382
00383 double gamk_v ,
00384 phisig;
00385
00386 DEBUG_ENTRY( "GammaK()" );
00387
00388
00389
00390
00391
00392
00393
00394 if( ipLoEnr >= rfield.nflux || ipLoEnr >= ipHiEnr)
00395 {
00396 gamk_v = 0.;
00397 thermal.HeatNet = 0.;
00398 thermal.HeatHiEnr = 0.;
00399 thermal.HeatLowEnr = 0.;
00400
00401 DEBUG_EXIT( "GammaK()" );
00402 return( gamk_v );
00403 }
00404
00405 iup = MIN2(ipHiEnr,rfield.nflux);
00406
00407
00408
00409
00410 eauger = rfield.anu[ipLoEnr-1]*yield1;
00411
00412
00413
00414 gamk_v = 0.;
00415 thermal.HeatNet = 0.;
00416
00417
00418 ipOffset = ipOpac - ipLoEnr;
00419
00420
00421
00422
00423
00424
00425 phisig = (rfield.flux[ipLoEnr-1] + rfield.otslin[ipLoEnr-1]+
00426 rfield.ConInterOut[ipLoEnr-1]*rfield.lgOutOnly) * opac.OpacStack[ipOpac-1];
00427 gamk_v += phisig;
00428 thermal.HeatNet += phisig*rfield.anu[ipLoEnr-1];
00429
00430
00431 limit = MIN2(iup,secondaries.ipSecIon-1);
00432 for( i=ipLoEnr; i < limit; i++ )
00433 {
00434 phisig = rfield.SummedCon[i]*opac.OpacStack[i+ipOffset];
00435 gamk_v += phisig;
00436 thermal.HeatNet += phisig*rfield.anu[i];
00437 }
00438
00439
00440
00441
00442 ASSERT( thermal.HeatNet >= 0. );
00443 thermal.HeatNet = MAX2(0.,thermal.HeatNet - gamk_v*eauger);
00444
00445
00446 thermal.HeatLowEnr = thermal.HeatNet;
00447
00448
00449 thermal.HeatHiEnr = 0.;
00450 GamHi = 0.;
00451
00452 ilo = MAX2(ipLoEnr+1,secondaries.ipSecIon);
00453 for( i=ilo-1; i < iup; i++ )
00454 {
00455
00456 phisig = rfield.SummedCon[i]*opac.OpacStack[i+ipOffset];
00457 GamHi += phisig;
00458 thermal.HeatHiEnr += phisig*rfield.anu[i];
00459 }
00460
00461
00462 gamk_v += GamHi;
00463
00464 thermal.HeatHiEnr -= GamHi*eauger;
00465
00466
00467
00468 thermal.HeatNet += thermal.HeatHiEnr*secondaries.heatef;
00469
00470
00471 thermal.HeatNet *= EN1RYD;
00472 thermal.HeatLowEnr *= EN1RYD;
00473 thermal.HeatHiEnr *= EN1RYD;
00474
00475 ASSERT( gamk_v >= 0. );
00476 ASSERT( thermal.HeatNet>= 0. );
00477
00478 DEBUG_EXIT( "GammaK()" );
00479 return( gamk_v );
00480 }
00481
00482
00483
00484
00485 double GammaPL(
00486
00487 long int n,
00488
00489 long int nelem)
00490 {
00491 long int i,
00492 ilo,
00493 iup,
00494 limit,
00495 ipLoEnr,
00496 ipHiEnr;
00497 float GamHi,
00498 csThresh,
00499 gamPL_v,
00500 phisig;
00501
00502 DEBUG_ENTRY( "GammaPL()" );
00503
00504
00505
00506
00507
00508
00509
00510 ASSERT( nelem >= 0);
00511 ASSERT( nelem < LIMELM);
00512 ASSERT( n >= 0);
00513
00514
00515 ipLoEnr = iso.ipIsoLevNIonCon[ipH_LIKE][nelem][n];
00516 ASSERT( ipLoEnr>0 );
00517
00518 if( ipLoEnr >= rfield.nflux )
00519 {
00520 gamPL_v = 0.;
00521 thermal.HeatNet = 0.;
00522 thermal.HeatHiEnr = 0.;
00523 thermal.HeatLowEnr = 0.;
00524
00525 DEBUG_EXIT( "GammaPL()" );
00526 return( gamPL_v );
00527 }
00528
00529 ipHiEnr = iso.ipIsoLevNIonCon[ipH_LIKE][nelem][ipH2s];
00530 iup = MIN2(ipHiEnr,rfield.nflux);
00531
00532 csThresh = t_ADfA::Inst().sth(n)*rfield.anu3[ipLoEnr-1]/ POW2(nelem+1.f);
00533
00534
00535
00536 gamPL_v = 0.;
00537 thermal.HeatNet = 0.;
00538
00539
00540
00541
00542 phisig = (rfield.flux[ipLoEnr-1] + rfield.otslin[ipLoEnr-1] +
00543 rfield.ConInterOut[ipLoEnr-1]*rfield.lgOutOnly ) /rfield.anu3[ipLoEnr-1];
00544 gamPL_v += phisig;
00545
00546
00547 limit = MIN2(iup,secondaries.ipSecIon-1);
00548 for( i=ipLoEnr; i < limit; i++ )
00549 {
00550 phisig = rfield.SummedCon[i]/rfield.anu3[i];
00551 gamPL_v += phisig;
00552 thermal.HeatNet += phisig*rfield.anu[i];
00553 }
00554
00555
00556 gamPL_v *= csThresh;
00557
00558
00559 thermal.HeatNet *= csThresh;
00560 thermal.HeatNet += -gamPL_v*rfield.anu[ipLoEnr-1];
00561 thermal.HeatLowEnr = thermal.HeatNet;
00562
00563
00564 thermal.HeatHiEnr = 0.;
00565 GamHi = 0.;
00566
00567
00568 ilo = MAX2(ipLoEnr+1,secondaries.ipSecIon);
00569 for( i=ilo-1; i < iup; i++ )
00570 {
00571
00572 phisig = rfield.SummedCon[i]/rfield.anu3[i];
00573 GamHi += phisig;
00574 thermal.HeatHiEnr += phisig*rfield.anu[i];
00575 }
00576
00577
00578 gamPL_v += GamHi*csThresh;
00579
00580
00581 thermal.HeatHiEnr = (thermal.HeatHiEnr - GamHi*rfield.anu[ipLoEnr-1])*csThresh;
00582
00583
00584 thermal.HeatNet += thermal.HeatHiEnr*secondaries.heatef;
00585
00586
00587 thermal.HeatNet *= EN1RYD;
00588 thermal.HeatHiEnr *= EN1RYD;
00589 thermal.HeatLowEnr *= EN1RYD;
00590
00591 ASSERT( gamPL_v>= 0.);
00592
00593 DEBUG_EXIT( "GammaPL()" );
00594 return( gamPL_v );
00595 }
00596
00597
00598
00599 double GammaBnPL(long int n,
00600 long int nelem,
00601 double *ainduc,
00602 double *rcool)
00603 {
00604 long int i,
00605 ilo,
00606 iup,
00607 limit,
00608 ipLoEnr,
00609 ipHiEnr;
00610 double GamHi,
00611 bnfunPL_v,
00612 csThresh,
00613 emin,
00614 g,
00615 phisig,
00616 RateInducRec,
00617 RateInducRecCool,
00618 prod,
00619 thresh;
00620
00621 DEBUG_ENTRY( "GammaBnPL()" );
00622
00623
00624 ASSERT( nelem >= 0);
00625 ASSERT( nelem < LIMELM );
00626
00627
00628
00629
00630
00631 ipLoEnr = iso.ipIsoLevNIonCon[ipH_LIKE][nelem][n];
00632 ipHiEnr = iso.ipIsoLevNIonCon[ipH_LIKE][nelem][ipH1s];
00633
00634 ilo = ipLoEnr;
00635 iup = MIN2(ipHiEnr,rfield.nflux);
00636 if( ipLoEnr >= rfield.nflux || ipLoEnr >= ipHiEnr )
00637 {
00638 bnfunPL_v = 0.;
00639 thermal.HeatNet = 0.;
00640 thermal.HeatHiEnr = 0.;
00641 thermal.HeatLowEnr = 0.;
00642 *ainduc = 0.;
00643 *rcool = 0.;
00644
00645 DEBUG_EXIT( "GammaBnPL()" );
00646 return( bnfunPL_v );
00647 }
00648
00649
00650
00651
00652 thresh = iso.xIsoLevNIonRyd[ipH_LIKE][nelem][n];
00653 emin = MAX2(thresh,rfield.anu[ipLoEnr-1]);
00654
00655
00656 emin = thresh;
00657
00658 thermal.HeatNet = 0.;
00659 g = 0.;
00660 RateInducRec = 0.;
00661 RateInducRecCool = 0.;
00662
00663
00664 csThresh = t_ADfA::Inst().sth(n)*rfield.anu3[ipLoEnr-1] / POW2(nelem+1.f);
00665
00666
00667
00668 phisig = (rfield.flux[ipLoEnr-1] + rfield.otslin[ipLoEnr-1]+
00669 rfield.ConInterOut[ipLoEnr-1]*rfield.lgOutOnly)/
00670 rfield.anu3[ipLoEnr-1];
00671
00672 g += phisig;
00673 thermal.HeatNet += phisig*rfield.anu[ipLoEnr-1];
00674
00675
00676 prod = phisig*rfield.ContBoltz[ipLoEnr-1];
00677 RateInducRec += prod;
00678
00679 RateInducRecCool += prod*(rfield.anu[ipLoEnr-1] - emin);
00680
00681 limit = MIN2(iup,secondaries.ipSecIon-1);
00682 for( i=ipLoEnr; i < limit; i++ )
00683 {
00684 phisig = rfield.SummedCon[i]/rfield.anu3[i];
00685
00686 g += phisig;
00687 thermal.HeatNet += phisig*rfield.anu[i];
00688
00689
00690 prod = phisig*rfield.ContBoltz[i];
00691 RateInducRec += prod;
00692
00693 RateInducRecCool += prod*(rfield.anu[i] - emin);
00694 }
00695
00696
00697 thermal.HeatNet = MAX2(0.,(thermal.HeatNet - g*thresh)*csThresh);
00698 thermal.HeatLowEnr = thermal.HeatNet;
00699
00700
00701 thermal.HeatHiEnr = 0.;
00702 GamHi = 0.;
00703
00704 ilo = MAX2(ipLoEnr+1,secondaries.ipSecIon);
00705 for( i=ilo-1; i < iup; i++ )
00706 {
00707 phisig = rfield.SummedCon[i]/rfield.anu3[i];
00708 GamHi += phisig;
00709 thermal.HeatHiEnr += phisig*rfield.anu[i];
00710
00711
00712 prod = phisig*rfield.ContBoltz[i];
00713 RateInducRec += prod;
00714
00715 RateInducRecCool += prod*(rfield.anu[i] - emin);
00716 }
00717 RateInducRec *= csThresh;
00718 RateInducRecCool *= csThresh;
00719
00720
00721 bnfunPL_v = (g + GamHi)*csThresh;
00722
00723
00724 thermal.HeatHiEnr = (thermal.HeatHiEnr - GamHi*thresh)*csThresh;
00725
00726
00727 thermal.HeatNet += thermal.HeatHiEnr*secondaries.heatef;
00728
00729
00730 thermal.HeatNet *= EN1RYD;
00731 thermal.HeatHiEnr *= EN1RYD;
00732 thermal.HeatLowEnr *= EN1RYD;
00733
00734
00735 if( rfield.lgInducProcess )
00736 {
00737 *rcool = RateInducRecCool*EN1RYD;
00738 *ainduc = RateInducRec;
00739 }
00740 else
00741 {
00742
00743 *rcool = 0.;
00744 *ainduc = 0.;
00745 }
00746
00747 ASSERT( bnfunPL_v>= 0.);
00748
00749 DEBUG_EXIT( "GammaBnPL()" );
00750 return( bnfunPL_v );
00751 }
00752
00753
00754 void GammaPrtRate(
00755
00756 FILE * ioFILE,
00757
00758 long int ion ,
00759
00760 long int nelem,
00761
00762 bool lgPRT )
00763 {
00764 long int nshell , ns;
00765
00766 DEBUG_ENTRY( "GammaPrtRate()" );
00767
00768
00769 nshell = Heavy.nsShells[nelem][ion];
00770
00771
00772 fprintf(ioFILE , "GammaPrtRate: %li %li",ion , nelem );
00773 for( ns=nshell-1; ns>=0; --ns )
00774 {
00775 fprintf(ioFILE , " %.2e" , ionbal.PhotoRate_Shell[nelem][ion][ns][0]);
00776
00777
00778 if( lgPRT )
00779 {
00780 fprintf(ioFILE , "\n");
00781 GammaPrt(
00782
00783 opac.ipElement[nelem][ion][ns][0],
00784 opac.ipElement[nelem][ion][ns][1],
00785 opac.ipElement[nelem][ion][ns][2],
00786
00787 ioFILE,
00788
00789 ionbal.PhotoRate_Shell[nelem][ion][ns][0],
00790
00791 ionbal.PhotoRate_Shell[nelem][ion][ns][0]*0.05);
00792 }
00793 }
00794 fprintf(ioFILE , "\n");
00795
00796 DEBUG_EXIT( "GammaPrtRate()" );
00797 return;
00798 }
00799