| Geant4 Cross Reference |
1 /* 1
2 # <<BEGIN-copyright>>
3 # <<END-copyright>>
4 */
5
6 #include <map>
7 #include <string.h>
8 #include <cmath>
9
10 #include "MCGIDI.h"
11 #include "MCGIDI_misc.h"
12 #include <xDataTOM_importXML_private.h>
13
14 #if defined __cplusplus
15 extern "C" {
16 namespace GIDI {
17 using namespace GIDI;
18 #endif
19 static int _MCGIDI_target_releaseAndReturnOne(
20 #if defined __cplusplus
21 }
22 }
23 #endif
24 /*
25 **********************************************
26 */
27
28 #if defined __cplusplus
29 namespace GIDI {
30 using namespace GIDI;
31 #endif
32
33 MCGIDI_target *MCGIDI_target_new( statusMessag
34
35 MCGIDI_target *target;
36
37 if( ( target = (MCGIDI_target *) smr_mallo
38 if( MCGIDI_target_initialize( smr, target
39 return( target );
40 }
41 /*
42 **********************************************
43 */
44 int MCGIDI_target_initialize( statusMessageRep
45
46 memset( target, 0, sizeof( MCGIDI_target )
47 return( 0 );
48 }
49 /*
50 **********************************************
51 */
52 MCGIDI_target *MCGIDI_target_newRead( statusMe
53
54 MCGIDI_target *target;
55
56 if( ( target = MCGIDI_target_new( smr ) )
57 if( MCGIDI_target_read( smr, target, fileN
58 return( target );
59 }
60 /*
61 **********************************************
62 */
63 int MCGIDI_target_readFromMapViaPoPIDs( status
64 int projectile_PoPID, int target_PoPID
65
66 char *targetPath;
67
68 if( ( targetPath = MCGIDI_map_findTargetVi
69 return( MCGIDI_target_read( smr, target, t
70 }
71 /*
72 **********************************************
73 */
74 int MCGIDI_target_readFromMap( statusMessageRe
75 const char *targetName ) {
76
77 char *targetPath;
78
79 if( ( targetPath = MCGIDI_map_findTarget(
80 return( MCGIDI_target_read( smr, target, t
81 }
82 /*
83 **********************************************
84 */
85 MCGIDI_target *MCGIDI_target_newReadFromMapVia
86 int projectile_PoPID, int target_PoPID
87
88 char *targetPath;
89 MCGIDI_target *target;
90
91 if( ( targetPath = MCGIDI_map_findTargetVi
92 target = MCGIDI_target_newRead( smr, targe
93 smr_freeMemory( (void **) &targetPath );
94 return( target );
95 }
96 /*
97 **********************************************
98 */
99 MCGIDI_target *MCGIDI_target_newReadFromMap( s
100 const char *targetName ) {
101
102 char *targetPath;
103 MCGIDI_target *target;
104
105 targetPath = MCGIDI_map_findTarget( smr, m
106 if( targetPath == NULL ) return( NULL );
107 target = MCGIDI_target_newRead( smr, targe
108 smr_freeMemory( (void **) &targetPath );
109 return( target );
110 }
111 /*
112 **********************************************
113 */
114 MCGIDI_target *MCGIDI_target_free( statusMessa
115
116 MCGIDI_target_release( smr, target );
117 smr_freeMemory( (void **) &target );
118 return( NULL );
119 }
120 /*
121 **********************************************
122 */
123 int MCGIDI_target_release( statusMessageReport
124
125 int i;
126
127 smr_freeMemory( (void **) &(target->path)
128 smr_freeMemory( (void **) &(target->absPat
129 xDataTOMAL_release( &(target->attributes)
130 for( i = 0; i < target->nHeatedTargets; i+
131 smr_freeMemory( (void **) &(target->he
132 smr_freeMemory( (void **) &(target->he
133 if( target->heatedTargets[i].heatedTar
134 }
135 smr_freeMemory( (void **) &(target->heated
136 smr_freeMemory( (void **) &(target->readHe
137 MCGIDI_target_initialize( smr, target );
138 return( 0 );
139 }
140 /*
141 **********************************************
142 */
143 int MCGIDI_target_read( statusMessageReporting
144 /*
145 * If a target has already been read into thi
146 * Otherwise, there will be memory leaks.
147 */
148 xDataXML_document *doc;
149 xDataXML_element *element, *child;
150 int i, iHeated, nHeated = 0, status = 1;
151 double temperature;
152 /* char *pReturnValue; */
153 char const *version, *contents;
154
155 MCGIDI_target_initialize( smr, target );
156 if( ( target->path = smr_allocateCopyStrin
157 if( ( target->absPath = MCGIDI_misc_getAbs
158 if( ( doc = xDataXML_importFile2( smr, fil
159 element = xDataXML_getDocumentsElement( do
160 if( strcmp( element->name, "xTarget" ) !=
161 MCGIDI_misc_setMessageError_Element( s
162 else {
163 status = 0;
164 if( ( version = xDataXML_getAttributes
165 smr_setReportError2( smr, smr_unkn
166 status = 1; }
167 else {
168 if( strcmp( version, "xMCProcess 0
169 smr_setReportError2( smr, smr_
170 status = 1;
171 }
172 }
173 if( status == 0 ) {
174 /* pReturnValue = ( MCGIDI_misc_cop
175 for( nHeated = 0, child = xDataXML
176 if( strcmp( child->name, "targ
177 MCGIDI_misc_setMessageErro
178 element->name
179 status = 1;
180 break;
181 }
182 }
183 }
184 if( status == 0 ) {
185 if( ( target->heatedTargets = (MCG
186 status = 1; }
187 else {
188 if( ( target->readHeatedTarget
189 status = 1;
190 }
191 for( nHeated = 0, child = xDataXML
192 nHeated++, child = xDataXM
193 if( ( i = xDataXML_convertAttr
194 if( i > 0 ) smr_setReportE
195 status = 1;
196 break;
197 }
198 for( iHeated = 0; iHeated < nH
199 if( iHeated < nHeated ) for( i
200 target->heatedTargets[iHeated]
201 target->heatedTargets[iHeated]
202 target->heatedTargets[iHeated]
203 target->heatedTargets[iHeated]
204 if( ( contents = xDataXML_getA
205 if( ( target->heatedTarget
206 status = 1;
207 break;
208 }
209 }
210 if( ( contents = xDataXML_getA
211 status = 1;
212 break;
213 }
214 if( ( target->heatedTargets[iH
215 status = 1;
216 break;
217 }
218 strcpy( target->heatedTargets[
219 *strrchr( target->heatedTarget
220 strcat( target->heatedTargets[
221 strcat( target->heatedTargets[
222 target->nHeatedTargets++;
223 }
224 }
225 }
226 xDataXML_freeDoc( smr, doc );
227 if( status == 0 ) {
228 for( i = 0; i < nHeated; i++ ) target-
229 for( i = 0; i < nHeated; i++ ) if( tar
230 if( i == nHeated ) i = 0;
231 if( MCGIDI_target_readHeatedTarget( sm
232 target->baseHeatedTarget = target-
233 else {
234 MCGIDI_target_release( NULL, targe
235 status = 1;
236 } }
237 else {
238 MCGIDI_target_release( smr, target );
239 }
240 return( status );
241 }
242 /*
243 **********************************************
244 */
245 char const *MCGIDI_target_getAttributesValue(
246
247 return( xDataTOMAL_getAttributesValue( &(t
248 }
249 /*
250 **********************************************
251 */
252 int MCGIDI_target_getTemperatures( statusMessa
253
254 int i;
255
256 if( temperatures != NULL ) for( i = 0; i <
257 return( target->nHeatedTargets );
258 }
259 /*
260 **********************************************
261 */
262 int MCGIDI_target_readHeatedTarget( statusMess
263
264 int i;
265
266 if( ( index < 0 ) || ( index >= target->nH
267 smr_setReportError2( smr, smr_unknownI
268 return( -1 );
269 }
270 if( target->heatedTargets[index].heatedTar
271 if( ( target->heatedTargets[index].heatedT
272 target->projectilePOP = target->heated
273 target->targetPOP = target->heatedTarg
274 if( target->heatedTargets[index].heate
275 target->heatedTargets[index].heate
276 for( i = target->nReadHeatedTarget
277 if( target->readHeatedTargets[
278 target->readHeatedTargets[i] =
279 }
280 target->readHeatedTargets[i] = &(t
281 target->nReadHeatedTargets++;
282 }
283 }
284 return( ( target->heatedTargets[index].hea
285 }
286 /*
287 **********************************************
288 */
289 MCGIDI_target_heated *MCGIDI_target_getHeatedT
290
291 if( ( index < 0 ) || ( index >= target->nH
292 smr_setReportError2( smr, smr_unknownI
293 return( NULL );
294 }
295 if( target->heatedTargets[index].heatedTar
296 return( target->heatedTargets[index].heate
297 }
298 /*
299 **********************************************
300 */
301 MCGIDI_target_heated *MCGIDI_target_getHeatedT
302
303 if( ( index < 0 ) || ( index >= target->nH
304 smr_setReportError2( smr, smr_unknownI
305 return( NULL );
306 }
307 if( target->heatedTargets[index].heatedTar
308 smr_setReportError2( smr, smr_unknownI
309 return( NULL );
310 }
311 return( target->heatedTargets[index].heate
312 }
313 /*
314 **********************************************
315 */
316 int MCGIDI_target_numberOfReactions( statusMes
317
318 return( MCGIDI_target_heated_numberOfReact
319 }
320 /*
321 **********************************************
322 */
323 enum MCGIDI_reactionType MCGIDI_target_getReac
324
325 MCGIDI_reaction *reaction = MCGIDI_target_
326
327 if( reaction == NULL ) return( MCGIDI_reac
328 return( MCGIDI_reaction_getReactionType( s
329 }
330 /*
331 **********************************************
332 */
333 MCGIDI_reaction *MCGIDI_target_getReactionAtIn
334
335 return( MCGIDI_target_heated_getReactionAt
336 }
337 /*
338 **********************************************
339 */
340 MCGIDI_reaction *MCGIDI_target_getReactionAtIn
341
342 return( MCGIDI_target_heated_getReactionAt
343 }
344 /*
345 **********************************************
346 */
347 int MCGIDI_target_numberOfProductionReactions(
348
349 #if 0
350 return( MCGIDI_target_heated_numberOfProdu
351 #endif
352 return( 0 );
353 }
354
355 /*
356 **********************************************
357 */
358 double MCGIDI_target_getTotalCrossSectionAtTAn
359 bool sampling ) {
360
361 int i;
362 double xsec = 0., xsec1, xsec2, temperatur
363
364 for( i = 0; i < target->nReadHeatedTargets
365 if( i == 0 ) {
366 xsec = MCGIDI_target_heated_getTotalCr
367 else if( i == target->nReadHeatedTargets )
368 xsec = MCGIDI_target_heated_getTotalCr
369 else {
370 xsec1 = MCGIDI_target_heated_getTotalC
371 xsec2 = MCGIDI_target_heated_getTotalC
372 xsec = ( ( target->readHeatedTargets[i
373 ( temperature - target->readH
374 ( target->readHeatedTargets[i
375 }
376
377 return( xsec );
378 }
379 /*
380 **********************************************
381 */
382 int MCGIDI_target_getDomain( statusMessageRepo
383
384 int ir, nr = MCGIDI_target_numberOfReactio
385 double EMin_, EMax_;
386
387 for( ir = 0; ir < nr; ir++ ) {
388 MCGIDI_target_heated_getReactionsDomai
389 if( ir == 0 ) {
390 *EMin = EMin_;
391 *EMax = EMax_; }
392 else {
393 if( *EMin > EMin_ ) *EMin = EMin_;
394 if( *EMax < EMax_ ) *EMax = EMax_;
395 }
396 }
397 return( 0 );
398 }
399 /*
400 **********************************************
401 */
402 double MCGIDI_target_getIndexReactionCrossSect
403 bool sampling ) {
404
405 int i;
406 double xsec = 0., xsec1, xsec2, temperatur
407
408 for( i = 0; i < target->nReadHeatedTargets
409 if( i == 0 ) {
410 xsec = MCGIDI_target_heated_getIndexRe
411 else if( i == target->nReadHeatedTargets )
412 xsec = MCGIDI_target_heated_getIndexRe
413 else {
414 xsec1 = MCGIDI_target_heated_getIndexR
415 xsec2 = MCGIDI_target_heated_getIndexR
416 xsec = ( ( target->readHeatedTargets[i
417 ( temperature - target->readH
418 ( target->readHeatedTargets[i
419 }
420
421 return( xsec );
422 }
423 /*
424 **********************************************
425 */
426 int MCGIDI_target_sampleReaction( statusMessag
427 double (*userrng)( void * ), void *rng
428
429 int ir, nr = MCGIDI_target_numberOfReactio
430 double rngValue = (*userrng)( rngState );
431 double cumm_xsec = 0., r_xsec = rngValue *
432
433 for( ir = 0; ir < nr; ir++ ) {
434 cumm_xsec += MCGIDI_target_getIndexRea
435 if( cumm_xsec >= r_xsec ) break;
436 }
437 if( ir == nr ) {
438 if( ( totalXSec - cumm_xsec ) >= 1e-12
439 smr_setReportError2( smr, smr_unkn
440 "Failed to sample a reaction f
441 modes.getTemperature( ), modes
442 return( -1 );
443 }
444 ir--; /*
445 }
446 if( modes.getCrossSectionMode( ) == MCGIDI
447 MCGIDI_reaction *reaction = MCGIDI_tar
448
449 if( modes.getGroupIndex( ) == reaction
450 double dEnergy = modes.getProjecti
451
452 if( dEnergy <= 0 ) return( MCGIDI
453 if( ( (*userrng)( rngState ) * rea
454 }
455 }
456 return( ir );
457 }
458 /*
459 **********************************************
460 */
461 int MCGIDI_target_sampleNullReactionProductsAt
462 MCGIDI_quantitiesLookupModes &modes, MCGID
463
464 MCGIDI_sampledProductsData productData;
465
466 productData.isVelocity = decaySamplingInfo
467 productData.pop = target->projectilePOP;
468 productData.kineticEnergy = modes.getProje
469 productData.px_vx = 0.;
470 productData.py_vy = 0.;
471 productData.pz_vz = std::sqrt( productData
472 if( productData.isVelocity ) productData.p
473 MCGIDI_speedOfLight_cm_sec / std::
474 productData.delayedNeutronIndex = 0;
475 productData.delayedNeutronRate = 0.;
476 productData.birthTimeSec = 0;
477
478 productDatas->numberOfProducts = 0;
479 MCGIDI_sampledProducts_addProduct( smr, pr
480 return( productDatas->numberOfProducts );
481 }
482 /*
483 **********************************************
484 */
485 int MCGIDI_target_sampleIndexReactionProductsA
486 MCGIDI_quantitiesLookupModes &modes, M
487
488 return( MCGIDI_target_heated_sampleIndexRe
489 }
490 /*
491 **********************************************
492 */
493 double MCGIDI_target_getIndexReactionFinalQ( s
494 MCGIDI_quantitiesLookupModes &modes )
495
496 return( MCGIDI_target_heated_getIndexReact
497 }
498 /*
499 **********************************************
500 */
501 std::map<int, enum MCGIDI_transportability> co
502
503 return( MCGIDI_target_heated_getUniqueProd
504 }
505 /*
506 **********************************************
507 */
508 int MCGIDI_target_recast( statusMessageReporti
509
510 int i1, status = 0;
511
512 for( i1 = 0; i1 < target->nReadHeatedTarge
513 if( ( status = MCGIDI_target_heated_re
514 }
515 return( status );
516 }
517 /*
518 **********************************************
519 */
520 static int _MCGIDI_target_releaseAndReturnOne(
521
522 MCGIDI_target_release( smr, target );
523 return( 1 );
524 }
525
526 #if defined __cplusplus
527 }
528 #endif
529