Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/hadronic/models/lend/src/MCGIDI_map.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 ]

  1 /*
  2 # <<BEGIN-copyright>>
  3 # <<END-copyright>>
  4 */
  5 #include <string.h>
  6 #include <limits.h>
  7 #include <PoPs.h>
  8 #include "MCGIDI_map.h"
  9 #include <xDataTOM_importXML_private.h>
 10 
 11 #ifndef PATH_MAX
 12 #define PATH_MAX 4096
 13 #endif
 14 
 15 #if defined(WIN32) || defined(__MINGW32__)
 16 #include <windows.h>
 17 #define realpath( a, b ) GetFullPathName( a, PATH_MAX, b, NULL )
 18 #endif
 19 
 20 static int aliasesNeeded = 1;
 21 
 22 #if defined __cplusplus
 23     extern "C" {
 24     namespace GIDI {
 25     using namespace GIDI;
 26 #endif
 27 static MCGIDI_mapEntry *_MCGIDI_map_addEntry( statusMessageReporting *smr, MCGIDI_map *map, enum MCGIDI_mapEntry_type type, const char *schema, const char *path,
 28     const char *evaluation, const char *projectile, const char *target );
 29 static char *_MCGIDI_map_findTargetViaPoPIDs2( statusMessageReporting *smr, MCGIDI_map *map, const char *evaluation, 
 30             int projectile_PoPID, int target_PoPID );
 31 static int _MCGIDI_map_findAllOfTargetViaPoPIDs2( statusMessageReporting *smr, MCGIDI_map *mapAllOfTarget, MCGIDI_map *map, 
 32         int projectile_PoPID, int target_PoPID );
 33 static int _MCGIDI_map_walkTree2( statusMessageReporting *smr, MCGIDI_map *map, int level, int (*handler)( MCGIDI_mapEntry *entry, int level, void *userData), 
 34     void *userData );
 35 static void _MCGIDI_map_simpleWrite2( FILE *f, MCGIDI_map *map, int level );
 36 static char *_MCGIDI_map_smrUserInterface( void *userData );
 37 #if defined __cplusplus
 38     }
 39     }
 40 #endif
 41 
 42 #if defined __cplusplus
 43 namespace GIDI {
 44 using namespace GIDI;
 45 #endif
 46 /*
 47 ************************************************************
 48 */
 49 MCGIDI_map *MCGIDI_map_new( statusMessageReporting *smr ) {
 50 
 51     MCGIDI_map *map;
 52     
 53     if( ( map = (MCGIDI_map *) smr_malloc2( smr, sizeof( MCGIDI_map ), 0, "map" ) ) == NULL ) return( NULL );
 54     if( MCGIDI_map_initialize( smr, map ) ) map = (MCGIDI_map *) MCGIDI_map_free( NULL, map );
 55     return( map );
 56 }
 57 /*
 58 ************************************************************
 59 */
 60 int MCGIDI_map_initialize( statusMessageReporting *smr, MCGIDI_map *map ) {
 61 
 62     memset( map, 0, sizeof( MCGIDI_map ) );
 63     map->status = MCGIDI_map_status_Ok;
 64     map->smrUserInterface.smrUserInterface = _MCGIDI_map_smrUserInterface;
 65     map->smrUserInterface.map = map;
 66     map->path = NULL;
 67     map->mapFileName = NULL;
 68     map->numberOfEntries = 0;
 69     map->mapEntries = NULL;
 70 
 71 /*
 72 *   Add some default aliases. This is a kludge until aliases are fully supported.
 73 */
 74 if( aliasesNeeded ) { /* Support all meta-stables in ENDF/B-VII.1 */
 75     char const *aliases[] = { "Co58m1",  "Ag110m1",  "Cd115m1",  "Te127m1",  "Te129m1",  "Pm148m1",  "Ho166m1",  "Am242m1",  "Am244m1",  "Es254m1" };
 76     char const *targets[] = { "Co58_e1", "Ag110_e2", "Cd115_e1", "Te127_e2", "Te129_e1", "Pm148_e2", "Ho166_e1", "Am242_e2", "Am244_e1", "Es254_e2" };
 77     int i1, n1 = sizeof( aliases ) / sizeof( aliases[1] );
 78     
 79 
 80     for( i1 = 0; i1 < n1; i1++ ) {
 81         lPoPs_addParticleIfNeeded( smr, targets[i1], NULL );
 82         if( !smr_isOk( smr ) ) return( 1 );
 83         PoPs_addAliasIfNeeded( smr, targets[i1], aliases[i1] );
 84         if( !smr_isOk( smr ) ) return( 1 );
 85     }
 86     aliasesNeeded = 0;
 87 }
 88     return( 0 );
 89 }
 90 /*
 91 ************************************************************
 92 */
 93 MCGIDI_map *MCGIDI_map_readFile( statusMessageReporting *smr, const char *basePath, const char *mapFileName ) {
 94 /*
 95 *   If an error occurrs, map is freed and NULL is returned.
 96 */
 97     int n = 0;
 98     xDataXML_document *doc;
 99     xDataXML_element *element;
100     xDataXML_element *child;
101     MCGIDI_map *map;
102     const char *evaluation, *projectile, *targetName, *path, *schema;
103     char realPath[2 * ( PATH_MAX + 1 )], *p = &(realPath[PATH_MAX+1]);
104 
105     if( ( map = MCGIDI_map_new( smr ) ) == NULL ) return( NULL );
106 
107     if( ( basePath == NULL ) || ( mapFileName[0] == '/' ) ) {
108         strcpy( realPath, mapFileName ); }
109     else {
110         strcpy( realPath, basePath );
111         strcat( realPath, "/" );
112         strcat( realPath, mapFileName );
113     }
114     if( realpath( realPath, p ) == NULL ) {
115         smr_setReportError2( smr, smr_unknownID, MCGIDI_map_status_mapParsing, "No map file %s\n", mapFileName );
116         return( (MCGIDI_map *) MCGIDI_map_free( NULL, map ) );
117     }
118     n = (int) strlen( p ) + 2;
119     if( ( map->path = (char *) smr_malloc2( smr, 2 * n, 0, "map->path" ) ) == NULL ) return( (MCGIDI_map *) MCGIDI_map_free( NULL, map ) );
120     map->mapFileName = &(map->path[n + 1]);
121     strcpy( map->mapFileName, p );
122     strcpy( map->path, p );
123     if( ( p = strrchr( map->path, '/' ) ) != NULL ) {
124         *p = 0; }
125     else {
126         strcpy( map->path, "." );
127     }
128 
129     if( ( doc = xDataXML_importFile2( smr, map->mapFileName ) ) == NULL ) return( (MCGIDI_map *) MCGIDI_map_free( NULL, map ) );
130 
131     element = xDataXML_getDocumentsElement( doc );
132     for( child = xDataXML_getFirstElement( element ); child != NULL; child = xDataXML_getNextElement( child ) ) {
133         if( strcmp( child->name, "path" ) == 0 ) {
134             if( ( path = xDataXML_getAttributesValueInElement( child , "path" ) ) == NULL ) {
135                 smr_setReportError3p( smr, &(map->smrUserInterface), smr_unknownID, MCGIDI_map_status_mapParsing, "path missing path attribute" );
136                 break;
137             }
138             MCGIDI_map_addPath( smr, map, path ); }
139         else if( strcmp( child->name, "target" ) == 0 ) {
140             if( ( schema = xDataXML_getAttributesValueInElement( child , "schema" ) ) == NULL ) {
141                 smr_setReportError3p( smr, &(map->smrUserInterface), smr_unknownID, MCGIDI_map_status_mapParsing, "target missing 'schema' attribute" );
142                 break;
143             }
144             if( ( path = xDataXML_getAttributesValueInElement( child , "path" ) ) == NULL ) {
145                 smr_setReportError3p( smr, &(map->smrUserInterface), smr_unknownID, MCGIDI_map_status_mapParsing, "target missing 'path' attribute" );
146                 break;
147             }
148             if( ( evaluation = xDataXML_getAttributesValueInElement( child , "evaluation" ) ) == NULL ) {
149                 smr_setReportError3p( smr, &(map->smrUserInterface), smr_unknownID, MCGIDI_map_status_mapParsing, "target missing 'evaluation' attribute" );
150                 break;
151             }
152             if( ( projectile = xDataXML_getAttributesValueInElement( child , "projectile" ) ) == NULL ) {
153                 smr_setReportError3p( smr, &(map->smrUserInterface), smr_unknownID, MCGIDI_map_status_mapParsing, "target missing 'projectile' attribute" );
154                 break;
155             }
156             if( ( targetName = xDataXML_getAttributesValueInElement( child , "target" ) ) == NULL ) {
157                 smr_setReportError3p( smr, &(map->smrUserInterface), smr_unknownID, MCGIDI_map_status_mapParsing, "target missing 'target' attribute" );
158                 break;
159             }
160             MCGIDI_map_addTarget( smr, map, schema, path, evaluation, projectile, targetName ); }
161         else {
162             smr_setReportError3( smr, &(map->smrUserInterface), smr_unknownID, MCGIDI_map_status_mapParsing, "invalid element = %s", child->name );
163         }
164         if( !smr_isOk( smr ) ) break;
165     }
166     xDataXML_freeDoc( smr, doc );
167     if( !smr_isOk( smr ) ) map = (MCGIDI_map *) MCGIDI_map_free( NULL, map );
168     return( map );
169 }
170 /*
171 ************************************************************
172 */
173 void *MCGIDI_map_free( statusMessageReporting *smr, MCGIDI_map *map ) {
174 
175     MCGIDI_map_release( smr, map );
176     smr_freeMemory( (void **) &map );
177     return( NULL );
178 }
179 /*
180 ************************************************************
181 */
182 void MCGIDI_map_release( statusMessageReporting *smr, MCGIDI_map *map ) {
183 
184     MCGIDI_mapEntry *entry, *next;
185 
186     if( map->path != NULL ) smr_freeMemory( (void **) &(map->path) );
187     for( entry = map->mapEntries; entry != NULL; entry = next ) {
188         next = entry->next;
189         if( entry->schema != NULL ) smr_freeMemory( (void **) &(entry->schema) );
190         if( entry->path != NULL ) smr_freeMemory( (void **) &(entry->path) );
191         if( entry->evaluation != NULL ) smr_freeMemory( (void **) &(entry->evaluation) );
192         if( entry->projectile != NULL ) smr_freeMemory( (void **) &(entry->projectile) );
193         if( entry->targetName != NULL ) smr_freeMemory( (void **) &(entry->targetName) );
194         if( entry->map != NULL ) MCGIDI_map_free( smr, entry->map );
195         smr_freeMemory( (void **) &entry );
196     }
197     map->numberOfEntries = 0;
198     map->mapEntries = NULL;
199     map->status = MCGIDI_map_status_Ok;
200 }
201 /*
202 ************************************************************
203 */
204 MCGIDI_mapEntry *MCGIDI_map_getFirstEntry( MCGIDI_map *map ) {
205 
206     return( map->mapEntries );
207 }
208 /*
209 ************************************************************
210 */
211 MCGIDI_mapEntry *MCGIDI_map_getNextEntry( MCGIDI_mapEntry *entry ) {
212 
213     return( entry->next );
214 }
215 /*
216 ************************************************************
217 */
218 int MCGIDI_map_addTarget( statusMessageReporting *smr, MCGIDI_map *map, const char *schema, const char *path, const char *evaluation, const char *projectile, const char *target ) {
219 
220     return( _MCGIDI_map_addEntry( smr, map, MCGIDI_mapEntry_type_target, schema, path, evaluation, projectile, target ) != NULL );
221 }
222 /*
223 ************************************************************
224 */
225 int MCGIDI_map_addPath( statusMessageReporting *smr, MCGIDI_map *map, const char *path ) {
226 
227     MCGIDI_mapEntry *entry = _MCGIDI_map_addEntry( smr, map, MCGIDI_mapEntry_type_path, NULL, path, NULL, NULL, NULL );
228 
229     if( entry != NULL ) {
230         if( ( entry->map = MCGIDI_map_readFile( smr, map->path, entry->path ) ) == NULL ) entry = NULL;
231     }
232     return( entry != NULL );
233 }
234 /*
235 ************************************************************
236 */
237 static MCGIDI_mapEntry *_MCGIDI_map_addEntry( statusMessageReporting *smr, MCGIDI_map *map, enum MCGIDI_mapEntry_type type, const char *schema, 
238     const char *path, const char *evaluation, const char *projectile, const char *targetName ) {
239 
240     MCGIDI_mapEntry *p;
241     MCGIDI_mapEntry *entry;
242 
243     if( ( entry = (MCGIDI_mapEntry * ) smr_malloc2( smr, sizeof( MCGIDI_mapEntry ), 1, "entry" ) ) == NULL ) return( NULL );
244     entry->next = NULL;
245     entry->type = type;
246     entry->parent = map;
247     entry->schema = NULL;
248     entry->path = NULL;
249     entry->evaluation = NULL;
250     entry->projectile = NULL;
251     entry->targetName = NULL;
252     entry->globalPoPsIndexProjectile = entry->globalPoPsIndexTarget = -1;
253     entry->map = NULL;
254 
255     if( path != NULL ) {
256         if( ( entry->path = (char *) smr_malloc2( smr, strlen( path ) + 1, 0, "path" ) ) == NULL ) goto err;
257         strcpy( entry->path, path );
258     }
259 
260     if( evaluation != NULL ) {
261         if( ( entry->evaluation = (char *) smr_malloc2( smr, strlen( evaluation ) + 1, 0, "evaluation" ) ) == NULL ) goto err;
262         strcpy( entry->evaluation, evaluation );
263     }
264 
265     if( projectile != NULL ) {
266         if( ( entry->globalPoPsIndexProjectile = lPoPs_addParticleIfNeeded( smr, projectile, "LLNL" ) ) < 0 ) goto err;
267         if( ( entry->projectile = (char *) smr_malloc2( smr, strlen( projectile ) + 1, 0, "projectile" ) ) == NULL ) goto err;
268         strcpy( entry->projectile, projectile );
269     }
270 
271     if( targetName != NULL ) {
272         if( ( entry->globalPoPsIndexTarget = lPoPs_addParticleIfNeeded( smr, targetName, "LLNL" ) ) < 0 ) goto err;
273         if( ( entry->targetName = (char *) smr_malloc2( smr, strlen( targetName ) + 1, 0, "target" ) ) == NULL ) goto err;
274         strcpy( entry->targetName, targetName );
275     }
276 
277     if( schema != NULL ) {
278         if( ( entry->schema = (char *) smr_malloc2( smr, strlen( schema ) + 1, 0, "schema" ) ) == NULL ) goto err;
279         strcpy( entry->schema, schema );
280     }
281 
282     if( map->mapEntries == NULL ) {
283         map->mapEntries = entry; }
284     else {
285         for( p = map->mapEntries; p->next != NULL; p = p->next );
286         p->next = entry;
287     }
288     map->numberOfEntries++;
289     return( entry );
290 
291 err:
292     smr_freeMemory( (void **) &(entry->path) );
293     smr_freeMemory( (void **) &(entry->evaluation) );
294     smr_freeMemory( (void **) &(entry->projectile) );
295     smr_freeMemory( (void **) &(entry->targetName) );
296     smr_freeMemory( (void **) &entry );
297     return( NULL );
298 }
299 /*
300 ************************************************************
301 */
302 char *MCGIDI_map_findTargetViaPoPIDs( statusMessageReporting *smr, MCGIDI_map *map, const char *evaluation, 
303     int projectile_PoPID, int target_PoPID ) {
304 /*
305 * Calling routine must free returned pointer.
306 */
307     char *path;
308     char const *projectileName = PoPs_getName_atIndex( smr, projectile_PoPID );
309     char const *targetName = PoPs_getName_atIndex( smr, target_PoPID );
310 
311     if( !smr_isOk( smr ) ) return( NULL );
312     if( map->status != MCGIDI_map_status_Ok ) return( NULL );
313 
314     path = _MCGIDI_map_findTargetViaPoPIDs2( smr, map, evaluation, projectile_PoPID, target_PoPID );
315     if( ( path == NULL ) && smr_isOk( smr ) ) {
316         if( evaluation == NULL ) {
317             smr_setReportInfo3( smr, &(map->smrUserInterface), smr_unknownID, 1, "target %s for projectile %s not found", 
318                 targetName, projectileName ); }
319         else {
320             smr_setReportInfo3( smr, &(map->smrUserInterface), smr_unknownID, 1, "target %s for projectile %s and evaluation %s not found", 
321                 targetName, projectileName, evaluation );
322         }
323     }
324     return( path );
325 }
326 /*
327 ************************************************************
328 */
329 static char *_MCGIDI_map_findTargetViaPoPIDs2( statusMessageReporting *smr, MCGIDI_map *map, const char *evaluation, 
330             int projectile_PoPID, int target_PoPID ) {
331 
332     MCGIDI_mapEntry *entry;
333     char *path = NULL;
334     int n, status;
335 
336     if( evaluation != NULL ) {
337         if( strlen( evaluation ) == 0 ) evaluation = NULL;
338     }
339 
340     for( entry = map->mapEntries; entry != NULL; entry = entry->next ) {
341         switch( entry->type ) {
342         case MCGIDI_mapEntry_type_target :
343             if( ( projectile_PoPID == entry->globalPoPsIndexProjectile ) && ( target_PoPID == entry->globalPoPsIndexTarget ) ) {
344                 if( evaluation == NULL ) {
345                     status = 1; }
346                 else {
347                     status = strcmp( evaluation,  entry->evaluation ) == 0;
348                 }
349                 if( status ) {
350                     n = (int) strlen( map->path ) + 1 + (int) strlen( entry->path ) + 1;
351                     if( ( path = (char * ) smr_malloc2( smr, n, 0, "path" ) ) == NULL ) return( NULL );
352                     strcpy( path, map->path );
353                     strcat( path, "/" );
354                     if( entry->path[0] == '/' ) {
355                         strcpy( path, entry->path ); }
356                     else {
357                         strcat( path, entry->path );
358                     }
359                     return( path );
360                 }
361             }
362             break;
363         case MCGIDI_mapEntry_type_path :
364             if( ( path = _MCGIDI_map_findTargetViaPoPIDs2( smr, entry->map, evaluation, projectile_PoPID, target_PoPID ) ) != NULL ) return( path );
365             break;
366         default :
367             smr_setReportInfo3( smr, &(map->smrUserInterface), smr_unknownID, MCGIDI_map_status_UnknownType, "unknown type = %d", entry->type );
368             return( NULL );
369         }
370     }
371     return( NULL );
372 }
373 /*
374 ************************************************************
375 */
376 char *MCGIDI_map_findTarget( statusMessageReporting *smr, MCGIDI_map *map, const char *evaluation, const char *projectile, const char *targetName ) {
377 
378     int projectile_PoPID, target_PoPID;
379 
380     if( ( projectile_PoPID = lPoPs_addParticleIfNeeded( smr, projectile, "LLNL" ) ) < 0 ) return( NULL );
381     if( ( target_PoPID     = lPoPs_addParticleIfNeeded( smr, targetName, "LLNL" ) ) < 0 ) return( NULL );
382     return( MCGIDI_map_findTargetViaPoPIDs( smr, map, evaluation, projectile_PoPID, target_PoPID ) );
383 }
384 /*
385 ************************************************************
386 */
387 MCGIDI_map *MCGIDI_map_findAllOfTargetViaPoPIDs( statusMessageReporting *smr, MCGIDI_map *map, int projectile_PoPID, 
388     int target_PoPID ) {
389 /*
390 * Calling routine must free returned pointer.
391 */
392     int status;
393     MCGIDI_map *mapAllOfTarget;
394     
395     if( map->status != MCGIDI_map_status_Ok ) return( NULL );
396     if( ( mapAllOfTarget = MCGIDI_map_new( smr ) ) == NULL ) return( NULL );
397     status = _MCGIDI_map_findAllOfTargetViaPoPIDs2( smr, mapAllOfTarget, map, projectile_PoPID, target_PoPID );
398     if( ( status != 0 ) ) mapAllOfTarget = (MCGIDI_map *) MCGIDI_map_free( smr, mapAllOfTarget );
399     return( mapAllOfTarget );
400 }
401 /*
402 ************************************************************
403 */
404 static int _MCGIDI_map_findAllOfTargetViaPoPIDs2( statusMessageReporting *smr, MCGIDI_map *mapAllOfTarget, MCGIDI_map *map, 
405         int projectile_PoPID, int target_PoPID ) {
406 
407     MCGIDI_mapEntry *entry;
408 
409     for( entry = map->mapEntries; entry != NULL; entry = entry->next ) {
410         switch( entry->type ) {
411         case MCGIDI_mapEntry_type_target :
412             if( ( projectile_PoPID == entry->globalPoPsIndexProjectile ) && ( target_PoPID == entry->globalPoPsIndexTarget ) ) {
413                 if( _MCGIDI_map_addEntry( smr, mapAllOfTarget, entry->type, entry->schema, entry->path, entry->evaluation, entry->projectile, 
414                     entry->targetName ) == NULL ) return( 1 );
415             }
416             break;
417         case MCGIDI_mapEntry_type_path :
418             if( _MCGIDI_map_findAllOfTargetViaPoPIDs2( smr, mapAllOfTarget, entry->map, projectile_PoPID, target_PoPID ) != 0 ) return( 1 );
419             break;
420         default :
421             smr_setReportInfo3( smr, &(map->smrUserInterface), smr_unknownID, MCGIDI_map_status_UnknownType, "unknown type = %d", entry->type );
422             return( 1 );
423         }
424     }
425     return( 0 );
426 }
427 /*
428 ************************************************************
429 */
430 MCGIDI_map *MCGIDI_map_findAllOfTarget( statusMessageReporting *smr, MCGIDI_map *map, const char *projectile, const char *targetName ) {
431 
432     int projectile_PoPID, target_PoPID;
433     
434     if( ( projectile_PoPID = lPoPs_addParticleIfNeeded( smr, projectile, "LLNL" ) ) < 0 ) return( NULL );
435     if( ( target_PoPID     = lPoPs_addParticleIfNeeded( smr, targetName, "LLNL" ) ) < 0 ) return( NULL );
436     return( MCGIDI_map_findAllOfTargetViaPoPIDs( smr, map, projectile_PoPID, target_PoPID ) );
437 }
438 /*
439 ************************************************************
440 */
441 char *MCGIDI_map_getFullPath( statusMessageReporting *smr, MCGIDI_map *map, const char *endPath ) {
442 
443     char *path;
444 
445     if( endPath[0] == '/' ) {
446         if( ( path = (char *) smr_malloc2( smr, strlen( endPath ) + 1, 0, "path" ) ) == NULL ) return( NULL );
447         path[0] = 0; }
448     else {
449         if( ( path = (char *) smr_malloc2( smr, strlen( map->path ) + strlen( endPath ) + 2, 0, "path" ) ) == NULL ) return( NULL );
450         strcpy( path, map->path );
451         strcat( path, "/" );
452     }
453     strcat( path, endPath );
454     return( path );
455 }
456 /*
457 ************************************************************
458 */
459 char *MCGIDI_map_getTargetsFullPath( statusMessageReporting *smr, MCGIDI_mapEntry *target ) {
460 
461     char *path = NULL;
462     MCGIDI_map *map = target->parent;
463 
464     switch( target->type ) {
465     case MCGIDI_mapEntry_type_target :
466         path = MCGIDI_map_getFullPath( smr, map, target->path );
467         break;
468     case MCGIDI_mapEntry_type_path :
469         smr_setReportInfo3p( smr, &(map->smrUserInterface), smr_unknownID, MCGIDI_map_status_UnknownType, "path type not allowed" );
470         break;
471     default :
472         smr_setReportInfo3( smr, &(map->smrUserInterface), smr_unknownID, MCGIDI_map_status_UnknownType, "unknown type = %d", target->type );
473         break;
474     }
475     return( path );
476 }
477 /*
478 ************************************************************
479 */
480 static int _MCGIDI_map_walkTree2( statusMessageReporting *smr, MCGIDI_map *map, int level, int (*handler)( MCGIDI_mapEntry *entry, int level, void *userData), 
481     void *userData ) {
482     
483     MCGIDI_mapEntry *entry;
484 
485     for( entry = map->mapEntries; entry != NULL; entry = entry->next ) {
486         if( handler( entry, level, userData ) != 0 ) return( 1 );
487         if( entry->type == MCGIDI_mapEntry_type_path ) if( _MCGIDI_map_walkTree2( smr, entry->map, level + 1, handler, userData ) != 0 ) return( 1 );
488     }
489     return( 0 );
490 }
491 /*
492 ************************************************************
493 */
494 int MCGIDI_map_walkTree( statusMessageReporting *smr, MCGIDI_map *map, int (*handler)( MCGIDI_mapEntry *entry, int level, void *userData), void *userData ) {
495 
496     return( _MCGIDI_map_walkTree2( smr, map, 0, handler, userData ) );
497 }
498 /*
499 ************************************************************
500 */
501 char *MCGIDI_map_toXMLString( statusMessageReporting *smr, MCGIDI_map *map ) {
502 
503     MCGIDI_mapEntry *entry;
504     char *s, *p;
505     char targetFormat[] = "<target schema=\"%s\" evaluation=\"%s\" projectile=\"%s\" target=\"%s\" path=\"%s\"/>\n";
506     char pathFormat[] = "<path projectile=\"%s\" path=\"%s\"/>\n";
507     char start[] = "<map>\n";
508     char end[] = "</map>";
509     int n = 0, nStart = (int) strlen( start ), nEnd = (int) strlen( end );
510     int nTarget = (int) strlen( targetFormat ) - 10, nPath = (int) strlen( pathFormat ) - 4;
511 
512     if( map->status != MCGIDI_map_status_Ok ) return( NULL );
513 
514     n = nStart + nEnd + 1;
515     for( entry = map->mapEntries; entry != NULL; entry = entry->next ) {
516         switch( entry->type ) {
517         case MCGIDI_mapEntry_type_target :
518             n += (int) ( strlen( entry->schema ) + strlen( entry->path ) + strlen( entry->evaluation ) + strlen( entry->projectile ) + strlen( entry->targetName ) + nTarget );
519             break;
520         case MCGIDI_mapEntry_type_path :
521             n += (int ) strlen( entry->path ) + (int ) strlen( entry->projectile ) + nPath;
522             break;
523         default :
524             smr_setReportInfo3( smr, &(map->smrUserInterface), smr_unknownID, MCGIDI_map_status_UnknownType, "unknown type = %d", entry->type );
525             return( NULL );
526         }
527     }
528 
529     if( ( s = (char *) smr_malloc2( smr, n, 0, "xml string" ) ) == NULL ) return( NULL );
530     p = s;
531     strcpy( p, start );
532     while( *p ) p++; // Loop checking, 11.06.2015, T. Koi
533     for( entry = map->mapEntries; entry != NULL; entry = entry->next ) {
534         switch( entry->type ) {
535         case MCGIDI_mapEntry_type_target :
536             snprintf( p, sizeof start, targetFormat, entry->schema, entry->evaluation, entry->projectile, entry->targetName, entry->path );
537             break;
538         case MCGIDI_mapEntry_type_path :
539             snprintf( p, sizeof start, pathFormat, entry->projectile, entry->path );
540             break;
541         }
542         while( *p ) p++; // Loop checking, 11.06.2015, T. Koi
543     }
544     strcpy( p, end );
545     return( s );
546 }
547 /*
548 ************************************************************
549 */
550 void MCGIDI_map_simpleWrite( FILE *f, MCGIDI_map *map ) { _MCGIDI_map_simpleWrite2( f, map, 0 ); }
551 /*
552 ************************************************************
553 */
554 static void _MCGIDI_map_simpleWrite2( FILE *f, MCGIDI_map *map, int level ) {
555 
556     MCGIDI_mapEntry *entry;
557     char sLevel[] = "                        ";
558     int n = (int ) strlen( sLevel ) / 4;
559 
560     if( map->status != MCGIDI_map_status_Ok ) {
561         fprintf( f, "Bad map status = %d\n", map->status );
562         return;
563     }
564     if( level < n ) sLevel[4 * level] = 0;
565     fprintf( f, "%smap->path = %s\n", sLevel, map->path );
566     fprintf( f, "%smap->mapFileName = %s\n", sLevel, map->mapFileName );
567     for( entry = map->mapEntries; entry != NULL; entry = entry->next ) {
568         switch( entry->type ) {
569         case MCGIDI_mapEntry_type_target :
570             fprintf( f, "%sType = target: schema = %s: evaluation = %s: projectile = %s: target = %s: path = %s\n", sLevel, entry->schema, 
571                 entry->evaluation, entry->projectile, entry->targetName, entry->path );
572             break;
573         case MCGIDI_mapEntry_type_path :
574             fprintf( f, "%sType =   path: path = %s\n", sLevel, entry->path );
575             _MCGIDI_map_simpleWrite2( f, entry->map, level + 1 );
576             break;
577         default :
578             fprintf( f, "%sUnknown type = %d\n", sLevel, entry->type );
579         }
580     }
581 }
582 /*
583 ************************************************************
584 */
585 static char *_MCGIDI_map_smrUserInterface( void *userData ) {
586 
587     MCGIDI_map_smr *smrUserInterface = (MCGIDI_map_smr *) userData;
588 
589     return( smr_allocateFormatMessage( "map file = %s", smrUserInterface->map->mapFileName ) );
590 }
591 
592 #if defined __cplusplus
593 }
594 #endif
595 
596