00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038 #include <cmath>
00039
00040 #include "kalbach.hpp"
00041 #include "convert.hpp"
00042 #include "messaging.hpp"
00043
00044 extern ENDLClass ENDL;
00045
00046
00047
00048 void Kalbach_data::read_data( mf6_file& inFile, int num_E_out )
00049
00050 {
00051 string sbuff;
00052 Kalbach_triple triple;
00053
00054 for ( int count = 0; count < num_E_out; ++count )
00055 {
00056 inFile >> sbuff;
00057
00058 triple.E_out = ENDL.eV2MeV*stod( sbuff );
00059 inFile >> sbuff;
00060 triple.Prob_E_out = stod( sbuff );
00061 inFile >> sbuff;
00062 triple.compound_frac = stod( sbuff );
00063 insert(end(), triple);
00064 }
00065 inFile.ignore(66,'\n');
00066 }
00067
00068 Kalbach_data::iterator Kalbach_data::find_data(double E_out)
00069
00070
00071
00072 {
00073 const double eps = 1.0e-6;
00074 Kalbach_data::iterator data_ptr = end();
00075 for(--data_ptr; ; --data_ptr)
00076 {
00077 if(( E_out >= data_ptr->E_out ) ||
00078 ( (data_ptr == begin()) && (E_out >= (1 - eps)*data_ptr->E_out)) )
00079 {
00080 return data_ptr;
00081 }
00082
00083
00084 if(data_ptr == begin())
00085 {
00086 Warning("Kalbach_data::find_data",pastenum("E_out too small in Kalbach: ",E_out));
00087 return data_ptr;
00088 }
00089 }
00090 }
00091
00092
00093
00094 void one_d_Kalbach::one_E_row( double min_E, double max_E )
00095
00096
00097 {
00098
00099 if( min_E > max_E )
00100 {
00101 SevereError( "one_d_Kalbach::one_E_row", "energies out of order" );
00102 }
00103
00104
00105 double E_lab_trans = mu( ) * mu( ) * map_->E_transl;
00106
00107 if( ( mu( ) > 0.0 ) && ( max_E < E_lab_trans ) )
00108 {
00109
00110 cm_E_decr( min_E, max_E );
00111 }
00112 else if( ( mu( ) > 0.0 ) && ( min_E < E_lab_trans ) &&
00113 ( max_E > E_lab_trans ) )
00114 {
00115
00116 cm_E_decr( min_E, E_lab_trans );
00117 cm_E_incr( E_lab_trans, max_E );
00118 }
00119 else
00120 {
00121
00122 cm_E_incr( min_E, max_E );
00123 }
00124 }
00125
00126
00127
00128 void one_d_Kalbach::cm_E_incr( double min_E, double max_E )
00129 {
00130 Pair lab_Emu;
00131 Pair cm_Emu;
00132
00133 double E_out;
00134 double Prob;
00135 dd_link e_out_link;
00136 double dE;
00137
00138 lab_Emu.mu = mu( );
00139
00140
00141
00142 int sigma = ( mu( ) > 0.0 ) ? 1 : -1;
00143
00144
00145 dE = ENDL_EPSILON( min_E );
00146 lab_Emu.E = min_E + dE;
00147
00148 cm_Emu = map_->lab_to_cm( lab_Emu );
00149
00150 E_f0_r_ptr = data_ptr__->find_data( max(cm_Emu.E,0.0) );
00151
00152 Prob = f( lab_Emu.E );
00153 e_out_link = dd_link( lab_Emu.E, Prob );
00154 insert( end( ), e_out_link );
00155
00156
00157 dE = ENDL_EPSILON( max_E );
00158 lab_Emu.E = max_E - dE;
00159 cm_Emu = map_->lab_to_cm( lab_Emu );
00160 double E_cm_max = cm_Emu.E;
00161
00162
00163
00164 Kalbach_data::iterator next_data;
00165 for( next_data = E_f0_r_ptr; ; )
00166 {
00167 ++next_data;
00168 one_d_Kalbach::iterator this_link;
00169 one_d_Kalbach::iterator next_link;
00170
00171
00172 if( ( next_data == data_ptr__->end( ) ) ||
00173 ( next_data->E_out > E_cm_max ) )
00174 {
00175
00176 this_link = end( );
00177 --this_link;
00178
00179
00180 Prob = f( max_E );
00181 e_out_link = dd_link( max_E, Prob );
00182 insert( end( ), e_out_link );
00183
00184 next_link = end( );
00185 --next_link;
00186 thicken( this_link, next_link );
00187 break;
00188 }
00189
00190
00191 this_link = end( );
00192 --this_link;
00193
00194
00195 E_out = map_->get_lab_E( next_data->E_out, mu(), sigma );
00196 dE = ENDL_EPSILON( E_out );
00197
00198 Prob = f( E_out - dE );
00199 e_out_link = dd_link( E_out - dE, Prob );
00200 insert( end( ), e_out_link );
00201
00202 next_link = end( );
00203 --next_link;
00204 thicken( this_link, next_link );
00205
00206
00207 E_f0_r_ptr = next_data;
00208 Prob = f( E_out + dE );
00209 e_out_link = dd_link( E_out + dE, Prob );
00210 insert( end( ), e_out_link );
00211 }
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221 }
00222
00223
00224
00225 void one_d_Kalbach::cm_E_decr( double min_E, double max_E )
00226 {
00227 Pair lab_Emu;
00228 Pair cm_Emu;
00229
00230 double E_out;
00231 double Prob;
00232 dd_link e_out_link;
00233 double dE;
00234
00235 lab_Emu.mu = mu( );
00236
00237
00238
00239 int sigma = -1;
00240
00241
00242 dE = ENDL_EPSILON( min_E );
00243
00244 double E_diff = max_E - min_E;
00245 if( 4*dE > E_diff ){
00246 dE = E_diff/4.0;
00247 }
00248
00249
00250 lab_Emu.E = min_E + dE;
00251
00252 cm_Emu = map_->lab_to_cm( lab_Emu );
00253
00254 E_f0_r_ptr = data_ptr__->find_data( max(0.0,cm_Emu.E) );
00255
00256 Prob = f( lab_Emu.E );
00257 e_out_link = dd_link( lab_Emu.E, Prob );
00258 insert( end( ), e_out_link );
00259
00260
00261 dE = ENDL_EPSILON( max_E );
00262 lab_Emu.E = max_E - dE;
00263 cm_Emu = map_->lab_to_cm( lab_Emu );
00264 double E_cm_min = cm_Emu.E;
00265
00266
00267
00268 Kalbach_data::iterator this_data;
00269 for( this_data = E_f0_r_ptr; ; )
00270 {
00271 one_d_Kalbach::iterator this_link;
00272 one_d_Kalbach::iterator next_link;
00273
00274
00275 if( ( this_data == data_ptr__->begin( ) ) ||
00276 ( this_data->E_out < E_cm_min ) )
00277 {
00278
00279 this_link = end( );
00280 --this_link;
00281
00282
00283 Prob = f( max_E );
00284 e_out_link = dd_link( max_E, Prob );
00285 insert( end( ), e_out_link );
00286
00287 next_link = end( );
00288 --next_link;
00289 thicken( this_link, next_link );
00290 break;
00291 }
00292
00293
00294 this_link = end( );
00295 --this_link;
00296
00297
00298 E_out = map_->get_lab_E( this_data->E_out, mu(), sigma );
00299 dE = ENDL_EPSILON( E_out );
00300
00301 Prob = f( E_out - dE );
00302 e_out_link = dd_link( E_out - dE, Prob );
00303 insert( end( ), e_out_link );
00304
00305 next_link = end( );
00306 --next_link;
00307 thicken( this_link, next_link );
00308
00309
00310 --this_data;
00311 E_f0_r_ptr = this_data;
00312 Prob = f( E_out + dE );
00313 e_out_link = dd_link( E_out + dE, Prob );
00314 insert( end( ), e_out_link );
00315 }
00316 }
00317
00318
00319 void one_d_Kalbach::copy_params( Param *params )
00320 {
00321 params__ = params;
00322 }
00323
00324
00325
00326 void one_d_Kalbach::copy_data( list< Kalbach_data >::iterator data_ptr )
00327 {
00328 data_ptr__ = data_ptr;
00329 }
00330
00331
00332
00333 double one_d_Kalbach::get_a( double E_out )
00334 {
00335 return Get_a( E_out, *params__ );
00336 }
00337
00338
00339 double one_d_Kalbach::f( double E )
00340
00341
00342 {
00343 Pair lab_Emu;
00344 Pair cm_Emu;
00345 double Prob;
00346
00347 lab_Emu.mu = mu( );
00348 lab_Emu.E = E;
00349
00350
00351 cm_Emu = map_->lab_to_cm( lab_Emu );
00352
00353 if( E_f0_r_ptr == NULL )
00354 {
00355 E_f0_r_ptr = data_ptr__->find_data( max(0.0,cm_Emu.E) );
00356 }
00357
00358 double slope_a = get_a( cm_Emu.E );
00359
00360 Prob = 0.5*(E_f0_r_ptr->Prob_E_out*( slope_a/sinh( slope_a ) )*
00361 ( cosh( slope_a*cm_Emu.mu ) +
00362 E_f0_r_ptr->compound_frac*sinh( slope_a*cm_Emu.mu ) ));
00363
00364
00365 Prob *= map_->J_cm_to_lab( cm_Emu.E, lab_Emu.E );
00366 return Prob;
00367 }
00368
00369
00370
00371 two_d_Kalbach::iterator
00372 two_d_Kalbach::new_one_d( two_d_Kalbach::iterator where )
00373 {
00374 one_d_Kalbach new_link;
00375 insert( where, new_link );
00376
00377
00378 two_d_Kalbach::iterator link_ptr = where;
00379 --link_ptr;
00380
00381
00382 link_ptr->copy_params( params_ );
00383 link_ptr->copy_map( &map );
00384 link_ptr->copy_data( data_ptr_ );
00385
00386 return link_ptr;
00387 }
00388
00389 void two_d_Kalbach::set_params(
00390 list< Kalbach_data >::iterator data_ptr, Param *params )
00391 {
00392 data_ptr_ = data_ptr;
00393 params_ = params;
00394 }
00395
00396
00397
00398 three_d_Kalbach::three_d_Kalbach( int targ_ZA, int proj_ZA,
00399 int eject_ZA, int this_mult )
00400
00401 {
00402
00403 if( targ_ZA % 1000 == 0 )
00404 {
00405 SevereError( "three_d_Kalbach::three_d_Kalbach",
00406 " the Kalbach model makes no sense for natural targets" );
00407 }
00408
00409 this_mult_ = this_mult;
00410
00411 A.set(targ_ZA);
00412 a.set(proj_ZA);
00413 b.set(eject_ZA);
00414 C.set(targ_ZA + proj_ZA);
00415 B.set(C.ZA - eject_ZA);
00416
00417
00418 S_a = get_S(A, a);
00419
00420
00421 Params.get_space( 5 );
00422 Params[0] = 0.0;
00423 Params[1] = ( B.AWR + b.AWR ) / B.AWR;
00424 Params[2] = get_S( B, b );
00425
00426
00427 switch(a.ZA)
00428 {
00429 case 1:
00430 Params[3] = 1.0;
00431 break;
00432 case 1001:
00433 Params[3] = 1.0;
00434 break;
00435 case 1002:
00436 Params[3] = 1.0;
00437 break;
00438 case 1003:
00439 Params[3] = 0.0;
00440 break;
00441 case 2003:
00442 Params[3] = 0.0;
00443 break;
00444 case 2004:
00445 Params[3] = 0.0;
00446 break;
00447 default:
00448 Unimplemented("three_d_Kalbach::three_d_Kalbach",
00449 pastenum("M for particle ",a.ZA)+" not implemented");
00450 }
00451
00452
00453 switch(b.ZA)
00454 {
00455 case 1:
00456 Params[4] = 0.5;
00457 break;
00458 case 1001:
00459 Params[4] = 1.0;
00460 break;
00461 case 1002:
00462 Params[4] = 1.0;
00463 break;
00464 case 1003:
00465 Params[4] = 1.0;
00466 break;
00467 case 2003:
00468 Params[4] = 1.0;
00469 break;
00470 case 2004:
00471 Params[4] = 2.0;
00472 break;
00473 default:
00474 Unimplemented("three_d_Kalbach::three_d_Kalbach",
00475 pastenum("M for particle ",b.ZA)+" not implemented");
00476 }
00477
00478 }
00479
00480 void three_d_Kalbach::expand_data(int num_E_in, mf6_file& inFile)
00481
00482
00483 {
00484
00485 read_data( inFile, num_E_in );
00486 if(!ENDL.write_file )
00487 {
00488 return;
00489 }
00490
00491 if( Global.Value( "Kalbach_i10" ) > 0 )
00492 {
00493
00494 check_i10( );
00495 }
00496
00497
00498 for( Data_ptr = triples.begin( ); Data_ptr != triples.end( );
00499 ++Data_ptr )
00500 {
00501 one_e_in();
00502 }
00503 }
00504
00505 void three_d_Kalbach::one_e_in( )
00506
00507 {
00508
00509 two_d_Kalbach e_in_link;
00510 e_in_link.E_in( ) = Data_ptr->E_in;
00511 insert( end( ), e_in_link );
00512
00513
00514 three_d_Kalbach::iterator this_link = end();
00515 --this_link;
00516
00517
00518 this_link->set_params( Data_ptr, &Params );
00519
00520
00521 expand_E_in( this_link );
00522
00523
00524 one_d_table new_cos;
00525 cosines.insert(cosines.end(), new_cos);
00526
00527
00528 two_d_list<one_d_table>::iterator cos_ptr = cosines.end();
00529 --cos_ptr;
00530 this_link->make_cos_link( Data_ptr->E_in, cos_ptr );
00531
00532 }
00533
00534
00535 void three_d_Kalbach::expand_E_in( three_d_Kalbach::iterator e_in_link )
00536
00537 {
00538
00539
00540 Params[0] = e_in_link->E_in()*A.AWR/(A.AWR + a.AWR) + S_a;
00541
00542
00543
00544
00545
00546 Kalbach_data::iterator this_data = Data_ptr->begin( );
00547 double first_E_out = this_data->E_out;
00548
00549
00550 this_data = Data_ptr->end( );
00551 --this_data;
00552 double last_E_out = this_data->E_out;
00553
00554
00555 e_in_link->map.set_map( &A, &a, &b, e_in_link->E_in() );
00556
00557
00558 e_in_link->get_geom( first_E_out, last_E_out );
00559 if( e_in_link->geom_.fastest == Both_ways )
00560 {
00561
00562 if( e_in_link->geom_.slowest == Straight )
00563 {
00564
00565 e_in_link->full_range( last_E_out );
00566 }
00567 else if( e_in_link->geom_.slowest == Forward )
00568 {
00569
00570 e_in_link->both_ways_hole( first_E_out, last_E_out );
00571 }
00572 else if( e_in_link->geom_.slowest == Transition )
00573 {
00574
00575 e_in_link->both_ways_trans( first_E_out, last_E_out );
00576 }
00577 else
00578 {
00579
00580 e_in_link->all_both_ways( first_E_out, last_E_out );
00581 }
00582 }
00583 else if( e_in_link->geom_.fastest == Transition )
00584 {
00585
00586 if( e_in_link->geom_.slowest == Straight )
00587 {
00588
00589 e_in_link->full_trans( last_E_out );
00590 }
00591 else
00592 {
00593
00594 e_in_link->trans_hole( first_E_out, last_E_out );
00595 }
00596 }
00597 else
00598 {
00599
00600 if( e_in_link->geom_.slowest == Straight )
00601 {
00602
00603 e_in_link->full_forward( 0.0, last_E_out );
00604 }
00605 else
00606 {
00607
00608 e_in_link->forward_hole( first_E_out, last_E_out );
00609 }
00610 }
00611 }
00612
00613
00614 void three_d_Kalbach::read_data( mf6_file& inFile, int num_E_in )
00615
00616
00617 {
00618 Kalbach_data one_set;
00619 list<Kalbach_data>::iterator data_ptr;
00620
00621 double ZERO;
00622 double E_1;
00623 int ND;
00624 int NA;
00625 int NW;
00626 int NEP;
00627
00628 string linebuff;
00629 for(int count = 0; count < num_E_in; ++count)
00630 {
00631 getline( inFile, linebuff );
00632 read_ddiiii(&linebuff,
00633 &ZERO, &E_1,
00634 &ND,
00635 &NA,
00636 &NW,
00637 &NEP);
00638 if(ND > 0)
00639 {
00640 SevereError("three_d_Kalbach::read_data","Implement discrete energies for Kalbach");
00641 }
00642
00643
00644 one_set.E_in = E_1*ENDL.eV2MeV;
00645 triples.insert(triples.end(), one_set);
00646
00647
00648 data_ptr = triples.end();
00649 --data_ptr;
00650
00651 data_ptr->read_data( inFile, NEP );
00652 }
00653 }
00654
00655
00656
00657
00658
00659
00660
00661
00662
00663
00664
00665
00666
00667
00668
00669
00670
00671
00672
00673
00674
00675 double three_d_Kalbach::get_S(Nuclei& targ_A, Nuclei& proj_a)
00676
00677 {
00678 double S;
00679
00680 double I_a;
00681 switch(proj_a.ZA)
00682 {
00683 case 1:
00684 I_a = 0.0;
00685 break;
00686 case 1001:
00687 I_a = 0.0;
00688 break;
00689 case 1002:
00690 I_a = 2.22;
00691 break;
00692 case 1003:
00693 I_a = 8.48;
00694 break;
00695 case 2003:
00696 I_a = 7.72;
00697 break;
00698 case 2004:
00699 I_a = 28.3;
00700 break;
00701 default:
00702 Unimplemented("three_d_Kalbach::get_S",
00703 pastenum("particle ",proj_a.ZA)+" not implemented in get_S");
00704 }
00705
00706 const double coef_1 = 15.68;
00707 const double coef_2 = 28.07;
00708 const double coef_3 = 18.56;
00709 const double coef_4 = 33.22;
00710 const double coef_5 = 0.717;
00711 const double coef_6 = 1.211;
00712
00713 S = coef_1*(C.A - targ_A.A) -
00714 coef_2*((C.N - C.Z)*(C.N - C.Z)/C.A -
00715 (targ_A.N - targ_A.Z)*(targ_A.N - targ_A.Z)/
00716 targ_A.A) -
00717 coef_3*(exp(2.0/3.0*log(1.0*C.A)) -
00718 exp(2.0/3.0*log(1.0*targ_A.A))) +
00719 coef_4*((C.N - C.Z)*(C.N - C.Z)/
00720 exp(4.0/3.0*log(1.0*C.A)) -
00721 (targ_A.N - targ_A.Z)*(targ_A.N - targ_A.Z)/
00722 exp(4.0/3.0*log(1.0*targ_A.A))) -
00723 coef_5*(C.Z*C.Z/exp(1.0/3.0*log(1.0*C.A)) -
00724 targ_A.Z*targ_A.Z/exp(1.0/3.0*log(1.0*targ_A.A))) +
00725 coef_6*(C.Z*C.Z/C.A -
00726 targ_A.Z*A.Z/targ_A.A) - I_a;
00727
00728 return S;
00729 }
00730
00731 void three_d_Kalbach::renorm( ){
00732 for (three_d_list< two_d_Kalbach >::iterator it=begin();it!=end();++it) it->renorm();
00733 }
00734
00735
00736 void three_d_Kalbach::check_i10( )
00737
00738
00739
00740
00741
00742
00743
00744
00745
00746
00747
00748
00749
00750
00751
00752
00753
00754
00755
00756
00757
00758
00759
00760
00761
00762 {
00763 one_d_table i10_data;
00764 double gamma = sqrt( a.AWR * b.AWR )/( A.AWR + a.AWR );
00765
00766
00767 quad_list adapt_quad( av_energy );
00768
00769
00770 for( Data_ptr = triples.begin( ); Data_ptr != triples.end();
00771 ++Data_ptr )
00772 {
00773 dd_link new_link;
00774 new_link.x = Data_ptr->E_in;
00775 double E_a_coef = gamma*gamma*new_link.x;
00776 double Er_sum = 0;
00777 double E0_sum = 0;
00778 double norm_sum = 0;
00779 Kalbach_data::iterator this_data = Data_ptr->begin();
00780 double prev_E_out = this_data->E_out;
00781 double prev_f0 = this_data->Prob_E_out;
00782 double prev_r = this_data->compound_frac;
00783 double integral_coef = 2 * prev_f0 * gamma * sqrt( new_link.x );
00784
00785
00786 for( ++this_data ; this_data != Data_ptr->end( ); ++this_data )
00787 {
00788 double E_out = this_data->E_out;
00789
00790 norm_sum += prev_f0 * ( E_out - prev_E_out );
00791
00792 E0_sum += prev_f0 * ( E_out - prev_E_out ) *
00793 ( 0.5*( E_out + prev_E_out ) + E_a_coef );
00794
00795 Er_sum += integral_coef * prev_r *
00796 adapt_quad.Simp_quad( prev_E_out, E_out, Params, 1.0e-8 );
00797
00798 prev_f0 = this_data->Prob_E_out;
00799 prev_r = this_data->compound_frac;
00800 prev_E_out = E_out;
00801 }
00802 new_link.y = this_mult_ * ( E0_sum + Er_sum ) / norm_sum;
00803 i10_data.insert( i10_data.end( ), new_link );
00804 }
00805 i10_data.write_endl( 10 );
00806 }
00807
00808
00809 double Get_a( double E_out, Param& params )
00810
00811
00812
00813
00814
00815
00816
00817 {
00818 double slope_a;
00819 double e_a = params[0];
00820 if( e_a == 0.0 )
00821 {
00822 slope_a = 0.0;
00823 }
00824 else
00825 {
00826
00827 double e_b = E_out*params[1] + params[2];
00828
00829 const double E_t1 = 130.0;
00830 double R_1 = ( e_a < E_t1 ) ? e_a : E_t1;
00831 double X_1 = R_1*e_b/e_a;
00832
00833 const double E_t3 = 41.0;
00834 double R_3 = ( e_a < E_t3 ) ? e_a : E_t3;
00835 double X_3 = R_3*e_b/e_a;
00836
00837 const double C_1 = 0.04;
00838 const double C_2 = 1.8e-6;
00839 const double C_3 = 6.7e-7;
00840
00841 slope_a = X_1*(C_1 + C_2*X_1*X_1) +
00842 C_3*params[3]*params[4]*X_3*X_3*X_3;
00843 }
00844 return slope_a;
00845 }
00846
00847
00848
00849 double av_energy( double E_b, Param& params )
00850 {
00851 double slope_a = Get_a( E_b, params );
00852
00853 double ans;
00854 ans = ( slope_a == 0.0 ) ? 0.0 :
00855 sqrt( slope_a ) * ( cosh( slope_a ) / sinh( slope_a ) -
00856 ( 1.0 / slope_a ) );
00857
00858 return ans;
00859 }